nx_release_recent_lib.nx source
↩ module page · 182 lines · 7197 B
1// Latest release selection across all contributing boards; history remains in the plans.
2import "nx_release_delta_lib.nx"
3const RR_FIELDS: i64=8
4const RR_PLAN: i64=0
5const RR_DOMAIN: i64=1
6const RR_EPOCH: i64=2
7const RR_RUNG: i64=3
8const RR_RUNG_LEN: i64=4
9const RR_TEXT: i64=5
10const RR_END: i64=6
11const RR_ORDER: i64=7
12struct ReleaseRecent { rows: *i64, count: i64, sequence: i64, capacity: i64 }
13func rr_new() -> *ReleaseRecent {
14 let r: *ReleaseRecent=sys_mmap_try(__size_of(ReleaseRecent)) as *ReleaseRecent
15 if (r as i64)<=0 { return 0 as *ReleaseRecent }
16 r.rows=0 as *i64;r.count=0;r.sequence=0;r.capacity=0
17 return r
18}
19func rr_reserve(r: *ReleaseRecent,needed: i64) -> i64 {
20 if needed<=r.capacity { return 1 }
21 if needed>9223372036854775807/(RR_FIELDS*8) { return 0 }
22 let rows: *i64=sys_mmap_try(needed*RR_FIELDS*8) as *i64
23 if (rows as i64)<=0 { return 0 }
24 var i: i64=0
25 while i<r.count*RR_FIELDS { rows[i]=r.rows[i];i=i+1 }
26 if r.capacity>0 { sys_munmap_direct(r.rows as *u8,r.capacity*RR_FIELDS*8) }
27 r.rows=rows;r.capacity=needed
28 return 1
29}
30func rr_offer(r: *ReleaseRecent,plan: *u8,dom: *u8,epoch: i64,rung: i64,rn: i64,text: i64,end: i64) -> i64 {
31 if r.count>=r.capacity { return 0 }
32 let row: i64=r.count*RR_FIELDS
33 r.sequence=r.sequence+1
34 r.rows[row+RR_PLAN]=plan as i64;r.rows[row+RR_DOMAIN]=dom as i64
35 r.rows[row+RR_EPOCH]=epoch;r.rows[row+RR_RUNG]=rung;r.rows[row+RR_RUNG_LEN]=rn
36 r.rows[row+RR_TEXT]=text;r.rows[row+RR_END]=end;r.rows[row+RR_ORDER]=r.sequence
37 r.count=r.count+1
38 return 1
39}
40func rr_sort(r: *ReleaseRecent) -> i64 {
41 if r.count<2 { return 1 }
42 let temp: *i64=sys_mmap_try(r.count*RR_FIELDS*8) as *i64
43 if (temp as i64)<=0 { return 0 }
44 var width: i64=1
45 while width<r.count {
46 var base: i64=0
47 while base<r.count {
48 var mid: i64=base+width
49 if mid>r.count { mid=r.count }
50 var end: i64=mid+width
51 if end>r.count { end=r.count }
52 var a: i64=base
53 var b: i64=mid
54 var dst: i64=base
55 while dst<end {
56 var take_a: i64=0
57 if a<mid {
58 if b>=end { take_a=1 } else {
59 let ae: i64=r.rows[a*RR_FIELDS+RR_EPOCH]
60 let be: i64=r.rows[b*RR_FIELDS+RR_EPOCH]
61 if ae>be { take_a=1 }
62 if ae==be && r.rows[a*RR_FIELDS+RR_ORDER]>r.rows[b*RR_FIELDS+RR_ORDER] { take_a=1 }
63 }
64 }
65 var from: i64=b
66 if take_a==1 { from=a;a=a+1 } else { b=b+1 }
67 var k: i64=0
68 while k<RR_FIELDS { temp[dst*RR_FIELDS+k]=r.rows[from*RR_FIELDS+k];k=k+1 }
69 dst=dst+1
70 }
71 base=end
72 }
73 var k: i64=0
74 while k<r.count*RR_FIELDS { r.rows[k]=temp[k];k=k+1 }
75 width=width*2
76 }
77 sys_munmap_direct(temp as *u8,r.count*RR_FIELDS*8)
78 return 1
79}
80func rr_collect(r: *ReleaseRecent,plan: *u8,n: i64,since: *u8,dom: *u8,counts: *i64) -> i64 {
81 if (r as i64)<=0 || n<0 { return -1 }
82 var lines: i64=1
83 var scan: i64=0
84 while scan<n { if rd_byte(plan,scan)==RD_NL { lines=lines+1 };scan=scan+1 }
85 if rr_reserve(r,r.count+lines)!=1 { return -1 }
86 let date: *u8=sys_mmap_try(RD_W_DATE)
87 if (date as i64)<=0 { return -1 }
88 var p: i64=0
89 while p<n {
90 let e: i64=rd_line_end(plan,n,p)
91 if e-p>RD_LOG_PFX_LEN && rd_slice_eq(plan,p,RD_LOG_PFX_LEN,RD_LOG_PFX)==1 {
92 var q: i64=p+RD_LOG_PFX_LEN
93 var epoch: i64=0
94 let start: i64=q
95 var valid: i64=1
96 while q<e {
97 let digit: i64=rd_byte(plan,q)-RD_D0
98 if digit<0 || digit>=RD_BASE10 { break }
99 if epoch>(9223372036854775807-digit)/RD_BASE10 { valid=0;break }
100 epoch=epoch*RD_BASE10+digit;q=q+1
101 }
102 if valid==1 && q>start && q<e && rd_byte(plan,q)==RD_PIPE {
103 q=q+1
104 let rs: i64=q
105 while q<e { if rd_byte(plan,q)==RD_PIPE { break };q=q+1 }
106 let rn: i64=q-rs
107 if rn>0 && q<e {
108 q=q+1
109 let ks: i64=q
110 while q<e { if rd_byte(plan,q)==RD_PIPE { break };q=q+1 }
111 let kn: i64=q-ks
112 if q<e {
113 al_civil_date(epoch,date)
114 if rd_cmp_slice(date,0,RD_DATE_W,since)>0 {
115 if rd_slice_eq(plan,ks,kn,RD_KIND_LAND)==1 {
116 counts[RD_C_LAND]=counts[RD_C_LAND]+1
117 rr_offer(r,plan,dom,epoch,rs,rn,q+1,e)
118 }
119 if rd_slice_eq(plan,ks,kn,RD_KIND_MEASURE)==1 { counts[RD_C_MEASURE]=counts[RD_C_MEASURE]+1 }
120 if rd_slice_eq(plan,ks,kn,RD_KIND_RETRACT)==1 { counts[RD_C_RETRACT]=counts[RD_C_RETRACT]+1 }
121 }
122 }
123 }
124 }
125 }
126 p=e+1
127 }
128 sys_munmap_direct(date,RD_W_DATE)
129 return r.count
130}
131func rr_required(r: *ReleaseRecent) -> i64 {
132 var bytes: i64=1
133 var i: i64=0
134 while i<r.count {
135 let row: i64=i*RR_FIELDS
136 let text: i64=r.rows[row+RR_END]-r.rows[row+RR_TEXT]
137 let dom: i64=al_slen(r.rows[row+RR_DOMAIN] as *u8)
138 let add: i64=(text+dom+r.rows[row+RR_RUNG_LEN])*RD_ENT_MAX+RD_DATE_W+al_slen("<li><b> </b> : </li>" as *u8)
139 if add<0 || bytes>9223372036854775807-add { return -1 }
140 bytes=bytes+add;i=i+1
141 }
142 return bytes
143}
144func rr_render(r: *ReleaseRecent,out: *u8,cap: i64,counts: *i64) -> i64 {
145 let required: i64=rr_required(r)
146 if required<0 || cap<required || (out as i64)<=0 { return -1 }
147 if rr_sort(r)!=1 { return -1 }
148 var o: i64=0
149 var i: i64=0
150 let date: *u8=sys_mmap_try(RD_W_DATE)
151 if (date as i64)<=0 { return -1 }
152 counts[RD_C_LISTED]=0
153 while i<r.count {
154 let row: i64=i*RR_FIELDS
155 let plan: *u8=r.rows[row+RR_PLAN] as *u8
156 o=al_cat(out,o,"<li><b>" as *u8)
157 o=rd_esc_z(out,o,r.rows[row+RR_DOMAIN] as *u8)
158 o=al_cat(out,o," " as *u8)
159 o=rd_esc_html(out,o,plan,r.rows[row+RR_RUNG],r.rows[row+RR_RUNG_LEN])
160 o=al_cat(out,o,"</b> " as *u8)
161 al_civil_date(r.rows[row+RR_EPOCH],date);o=al_cat(out,o,date)
162 o=al_cat(out,o,": " as *u8)
163 let text: i64=r.rows[row+RR_TEXT]
164 var n: i64=r.rows[row+RR_END]-text
165 o=rd_esc_html(out,o,plan,text,n)
166 o=al_cat(out,o,"</li>" as *u8)
167 counts[RD_C_LISTED]=counts[RD_C_LISTED]+1;i=i+1
168 }
169 if cap>o { out[o]=0 as u8 }
170 sys_munmap_direct(date,RD_W_DATE)
171 return o
172}
173
174// Ownership belongs to this collector; every allocation uses direct fallible mappings.
175func rr_destroy(r:*ReleaseRecent)->i64 {
176 if (r as i64)<=0 { return 0 }
177 if r.capacity>0 {
178 let rc:i64=sys_munmap_direct(r.rows as *u8,r.capacity*RR_FIELDS*8)
179 if rc!=0 { return rc }
180 }
181 return sys_munmap_direct(r as *u8,__size_of(ReleaseRecent))
182}