code wiki / _hdl_build / nx_vizsla_calendar.nx
nx_vizsla_calendar.nx source
↩ module page · 1001 lines · 37965 B
1// nx_vizsla_calendar.nx -- NISHI VIZSLA R-CAL.0: the calendar substrate (events + FREE/BUSY).
2// Operator 2026-06-22: "...running our personal relationship management and calendar and to dos..."
3// The census (nx_vizsla_census) measured the ENTIRE calendar area ABSENT; this is the keystone rung it
4// names -- everything time-based (recurrence R-CAL.1, conflicts R-CAL.2, time-blocking R-CAL.3) composes
5// on it. Events are CID records on the SAME tamper-evident seg_store data plane as money (V1) +
6// relationships (V4) + maintenance (V6): additive, idempotent-by-construction (law 10), as-of time-travel.
7// FREE/BUSY is computed integer-only (NO-FLOAT) -- busy = merged union of [start,start+dur); free = the
8// complement within the 1440-minute day. Determinism: stdout has no clocks (today/date are argv).
9//
10// Commands (argv[1]):
11// load <eventsfile> <prefix> [segid] EVENT <id> <date YYYY-MM-DD> <start_min> <dur_min> <title>
12// -> "cal:" CID records on seg_store.
13// day <prefix> <date> the day's events sorted by start + merged BUSY intervals +
14// the FREE complement within [00:00,24:00) + a verdict line.
15// Loud-fail law: missing file, bad date, non-digit/out-of-range start|dur, event crossing midnight = exit 1.
16// EXCEED (grounded knowledge/fetched/pa_c2_icalendar.raw VEVENT/VFREEBUSY): free/busy on a sovereign,
17// auditable, time-travelable data plane -- Google Calendar's free/busy is a cloud query with no portable
18// history. spec: knowledge/research/2026-06-22-vizsla-sclass-roadmap.md license_tier: ORIGINAL
19import "nx_syscalls.nx"
20import "nx_canon_cid.nx"
21import "nx_seg_store.nx"
22const K_MAGIC_1970: i64 = 1970
23const K_MAGIC_146097: i64 = 146097
24const K_MAGIC_719468: i64 = 719468
25const K_MAGIC_146096: i64 = 146096
26const K_MAGIC_1460: i64 = 1460
27const K_MAGIC_36524: i64 = 36524
28const K_MAGIC_2048: i64 = 2048
29const K_MAGIC_1440: i64 = 1440
30const K_MAGIC_4096: i64 = 4096
31const K_MAGIC_131072: i64 = 131072
32const K_MAGIC_262144: i64 = 262144
33
34func vc_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
35func vc_p(s: *u8) -> i64 { sys_write(1, s, vc_slen(s)); return 0 }
36
37func vc_eq(a: *u8, b: *u8) -> i64 {
38 var i: i64 = 0
39 var go: i64 = 1
40 while go == 1 {
41 if a[i] != b[i] { return 0 }
42 if a[i] == (0 as u8) { return 1 }
43 i = i + 1
44 }
45 return 0
46}
47
48func vc_dup(s: *u8) -> *u8 {
49 let n: i64 = vc_slen(s)
50 let d: *u8 = sys_mmap(n + 2)
51 var i: i64 = 0
52 while i <= n { d[i] = s[i]; i = i + 1 }
53 return d
54}
55
56func vc_atoi(s: *u8) -> i64 {
57 var v: i64 = 0
58 var i: i64 = 0
59 while s[i] != (0 as u8) {
60 let d: i64 = (s[i] as i64) - 48
61 if d >= 0 { if d <= 9 { v = v * 10 + d } }
62 i = i + 1
63 }
64 return v
65}
66
67func vc_digits(s: *u8) -> i64 {
68 if s[0] == (0 as u8) { return 0 }
69 var i: i64 = 0
70 while s[i] != (0 as u8) {
71 let d: i64 = (s[i] as i64) - 48
72 if d < 0 { return 0 }
73 if d > 9 { return 0 }
74 i = i + 1
75 }
76 return 1
77}
78
79func vc_isws(c: i64) -> i64 {
80 if c == 32 { return 1 }
81 if c == 13 { return 1 }
82 if c == 9 { return 1 }
83 return 0
84}
85
86func vc_tok(b: *u8, off: i64, lend: i64, dst: *u8, cap: i64) -> i64 {
87 var p: i64 = off
88 var go: i64 = 1
89 while go == 1 {
90 if p >= lend { go = 0 } else {
91 if vc_isws(b[p] as i64) == 1 { p = p + 1 } else { go = 0 }
92 }
93 }
94 var t: i64 = 0
95 go = 1
96 while go == 1 {
97 if p >= lend { go = 0 } else {
98 if vc_isws(b[p] as i64) == 1 { go = 0 } else {
99 if t < cap - 1 { dst[t] = b[p]; t = t + 1 }
100 p = p + 1
101 }
102 }
103 }
104 dst[t] = 0 as u8
105 return p
106}
107
108func vc_cat(dst: *u8, off: i64, s: *u8) -> i64 {
109 var i: i64 = 0
110 while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
111 return off + i
112}
113
114func vc_catn(dst: *u8, off: i64, v: i64) -> i64 {
115 var o: i64 = off
116 var m: i64 = v
117 if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
118 let t: *u8 = sys_mmap(28)
119 var k: i64 = 0
120 if m == 0 { t[0] = 48 as u8; k = 1 }
121 while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
122 var i: i64 = 0
123 while i < k { dst[o + i] = t[k - 1 - i]; i = i + 1 }
124 return o + k
125}
126
127// append "HH:MM" (zero-padded) for a minute-of-day value
128func vc_hhmm(dst: *u8, off: i64, m: i64) -> i64 {
129 var o: i64 = off
130 let h: i64 = m / 60
131 let mm: i64 = m - h * 60
132 if h < 10 { dst[o] = 48 as u8; o = o + 1 }
133 o = vc_catn(dst, o, h)
134 dst[o] = 58 as u8; o = o + 1
135 if mm < 10 { dst[o] = 48 as u8; o = o + 1 }
136 o = vc_catn(dst, o, mm)
137 return o
138}
139
140func vc_find(list: *i64, n: i64, s: *u8) -> i64 {
141 var i: i64 = 0
142 while i < n {
143 if vc_eq(list[i] as *u8, s) == 1 { return i }
144 i = i + 1
145 }
146 return 0 - 1
147}
148
149func vc_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
150 if vc_slen(s) != n { return 0 }
151 var i: i64 = 0
152 while i < n {
153 if b[off + i] != s[i] { return 0 }
154 i = i + 1
155 }
156 return 1
157}
158
159func vc_field(rec: *u8, rl: i64, want: *u8, out: *u8, cap: i64) -> i64 {
160 if rl < 8 { return 0 }
161 let nf: i64 = ss_r32(rec, 4)
162 var off: i64 = 8
163 var fi: i64 = 0
164 while fi < nf {
165 if off + 8 > rl { return 0 }
166 let kl: i64 = ss_r32(rec, off)
167 let koff: i64 = off + 4
168 let vl: i64 = ss_r32(rec, koff + kl)
169 let voff: i64 = koff + kl + 4
170 if vc_kmemeq(rec, koff, kl, want) == 1 {
171 var t: i64 = 0
172 while t < vl {
173 if t < cap - 1 { out[t] = rec[voff + t] }
174 t = t + 1
175 }
176 if t > cap - 1 { t = cap - 1 }
177 out[t] = 0 as u8
178 return 1
179 }
180 off = voff + vl
181 fi = fi + 1
182 }
183 return 0
184}
185
186func vc_iskind(b: *u8, koff: i64, kl: i64, pfx: *u8) -> i64 {
187 if kl <= 4 { return 0 }
188 return vc_kmemeq(b, koff, 4, pfx)
189}
190
191func vc_log_append(prefix: *u8, tag: *u8, rep: *u8, o: i64) -> i64 {
192 let lp: *u8 = sys_mmap(512)
193 var lo: i64 = 0
194 lo = vc_cat(lp, lo, prefix)
195 lo = vc_cat(lp, lo, "cal.log" as *u8)
196 lp[lo] = 0 as u8
197 let fd: i64 = sys_openat_append(lp, 0x1a4)
198 if fd <= 0 { return 0 }
199 let hdr: *u8 = sys_mmap(256)
200 var ho: i64 = 0
201 ho = vc_cat(hdr, ho, "VIZSLA-CAL epoch=" as *u8)
202 ho = vc_catn(hdr, ho, sys_now_realtime_sec())
203 ho = vc_cat(hdr, ho, " cmd=" as *u8)
204 ho = vc_cat(hdr, ho, tag)
205 ho = vc_cat(hdr, ho, "\n" as *u8)
206 sys_write(fd, hdr, ho)
207 sys_write(fd, rep, o)
208 sys_close(fd)
209 return 0
210}
211
212// civil "YYYY-MM-DD" -> days since epoch (Hinnant); -1 malformed
213func vc_datedays(s: *u8) -> i64 {
214 let nums: *i64 = sys_mmap(8 * 4) as *i64
215 var nn: i64 = 0
216 var cur: i64 = 0
217 var indig: i64 = 0
218 var i: i64 = 0
219 var go: i64 = 1
220 while go == 1 {
221 let c: i64 = s[i] as i64
222 var isd: i64 = 0
223 if c >= 48 { if c <= 57 { isd = 1 } }
224 if isd == 1 { cur = cur * 10 + (c - 48); indig = 1 }
225 if isd == 0 {
226 if indig == 1 {
227 if nn < 4 { nums[nn] = cur; nn = nn + 1 }
228 cur = 0
229 indig = 0
230 }
231 }
232 if c == 0 { go = 0 }
233 i = i + 1
234 }
235 if nn != 3 { return 0 - 1 }
236 var y: i64 = nums[0]
237 let m: i64 = nums[1]
238 let d: i64 = nums[2]
239 if y < K_MAGIC_1970 { return 0 - 1 }
240 if m < 1 { return 0 - 1 }
241 if m > 12 { return 0 - 1 }
242 if d < 1 { return 0 - 1 }
243 if d > 31 { return 0 - 1 }
244 if m <= 2 { y = y - 1 }
245 let era: i64 = y / 400
246 let yoe: i64 = y - era * 400
247 var mp: i64 = m - 3
248 if m <= 2 { mp = m + 9 }
249 let doy: i64 = (153 * mp + 2) / 5 + d - 1
250 let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
251 return era * K_MAGIC_146097 + doe - K_MAGIC_719468
252}
253
254// (y,m,d) -> days since epoch (Hinnant forward; caller pre-validates ranges)
255func vc_ymd2days(y0: i64, m: i64, d: i64) -> i64 {
256 var y: i64 = y0
257 if m <= 2 { y = y0 - 1 }
258 let era: i64 = y / 400
259 let yoe: i64 = y - era * 400
260 var mp: i64 = m - 3
261 if m <= 2 { mp = m + 9 }
262 let doy: i64 = (153 * mp + 2) / 5 + d - 1
263 let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
264 return era * K_MAGIC_146097 + doe - K_MAGIC_719468
265}
266
267// days since epoch -> civil (out[0]=y out[1]=m out[2]=d) (Hinnant inverse)
268func vc_civil(z0: i64, out: *i64) -> i64 {
269 var z: i64 = z0 + K_MAGIC_719468
270 var era: i64 = z / K_MAGIC_146097
271 if z < 0 { era = (z - K_MAGIC_146096) / K_MAGIC_146097 }
272 let doe: i64 = z - era * K_MAGIC_146097
273 let yoe: i64 = (doe - doe / K_MAGIC_1460 + doe / K_MAGIC_36524 - doe / K_MAGIC_146096) / 365
274 let y0: i64 = yoe + era * 400
275 let doy: i64 = doe - (365 * yoe + yoe / 4 - yoe / 100)
276 let mp: i64 = (5 * doy + 2) / 153
277 let d: i64 = doy - (153 * mp + 2) / 5 + 1
278 var m: i64 = mp + 3
279 if mp >= 10 { m = mp - 9 }
280 var y: i64 = y0
281 if m <= 2 { y = y0 + 1 }
282 out[0] = y; out[1] = m; out[2] = d
283 return 0
284}
285
286// days in month (with Gregorian leap-year)
287func vc_dim(y: i64, m: i64) -> i64 {
288 if m == 2 {
289 var leap: i64 = 0
290 if y % 4 == 0 { leap = 1 }
291 if y % 100 == 0 { leap = 0 }
292 if y % 400 == 0 { leap = 1 }
293 if leap == 1 { return 29 }
294 return 28
295 }
296 if m == 4 { return 30 }
297 if m == 6 { return 30 }
298 if m == 9 { return 30 }
299 if m == 11 { return 30 }
300 return 31
301}
302
303// append "YYYY-MM-DD" (zero-padded month/day) for a day-number
304func vc_daystr(dst: *u8, off: i64, days: i64) -> i64 {
305 let ymd: *i64 = sys_mmap(8 * 4) as *i64
306 vc_civil(days, ymd)
307 var o: i64 = off
308 o = vc_catn(dst, o, ymd[0])
309 dst[o] = 45 as u8; o = o + 1
310 if ymd[1] < 10 { dst[o] = 48 as u8; o = o + 1 }
311 o = vc_catn(dst, o, ymd[1])
312 dst[o] = 45 as u8; o = o + 1
313 if ymd[2] < 10 { dst[o] = 48 as u8; o = o + 1 }
314 o = vc_catn(dst, o, ymd[2])
315 return o
316}
317
318// occurrence day-number of the k-th instance of a rule starting at day sd0 (y,m,d in sy/sm/sd)
319// MONTHLY steps interval months; YEARLY steps interval*12 months so the SAME day-of-month clamp
320// covers both (RFC5545 semantics: a Feb-29 YEARLY start lands Feb-28 in non-leap years)
321func vc_occ(freq: *u8, sd0: i64, sy: i64, sm: i64, sd: i64, interval: i64, k: i64) -> i64 {
322 if vc_eq(freq, "DAILY" as *u8) == 1 { return sd0 + k * interval }
323 if vc_eq(freq, "WEEKLY" as *u8) == 1 { return sd0 + k * interval * 7 }
324 var mstep: i64 = interval
325 if vc_eq(freq, "YEARLY" as *u8) == 1 { mstep = interval * 12 }
326 let tot: i64 = (sm - 1) + k * mstep
327 let y2: i64 = sy + tot / 12
328 let m2: i64 = tot - (tot / 12) * 12 + 1
329 var d2: i64 = sd
330 let dim: i64 = vc_dim(y2, m2)
331 if d2 > dim { d2 = dim }
332 return vc_ymd2days(y2, m2, d2)
333}
334
335// canonicalize+store one record; st: [0]=writer [1]=seen [2]=nseen [3]=added [4]=dup_infile [5]=dup_instore [6]=prefix
336func vc_put(keys: *i64, vals: *i64, nf: i64, kp: *u8, st: *i64) -> i64 {
337 let enc: *u8 = sys_mmap(K_MAGIC_2048)
338 let el: i64 = canon_encode(keys, vals, nf, enc)
339 let cid: *u8 = sys_mmap(96)
340 cid_of(enc, el, cid)
341 let kbuf: *u8 = sys_mmap(128)
342 var ko: i64 = 0
343 ko = vc_cat(kbuf, ko, kp)
344 ko = vc_cat(kbuf, ko, cid)
345 kbuf[ko] = 0 as u8
346 let seen: *i64 = st[1] as *i64
347 var fresh: i64 = 1
348 if vc_find(seen, st[2], kbuf) >= 0 { fresh = 0; st[4] = st[4] + 1 }
349 if fresh == 1 {
350 if st[2] < K_MAGIC_2048 { seen[st[2]] = vc_dup(kbuf) as i64; st[2] = st[2] + 1 }
351 }
352 if fresh == 1 {
353 let pp: *i64 = sys_mmap(16) as *i64
354 let ll: *i64 = sys_mmap(16) as *i64
355 if ss_get_idx(st[6] as *u8, kbuf, pp, ll) == 1 { fresh = 0; st[5] = st[5] + 1 }
356 }
357 if fresh == 1 {
358 if ss_add(st[0] as *i64, 1, kbuf, enc, el) != 0 { return 0 - 1 }
359 st[3] = st[3] + 1
360 }
361 return 0
362}
363
364// ---------------- LOAD (EVENT loader) ----------------
365func vc_cmd_load(argc: i64, argv: *i64) -> i64 {
366 if argc < 4 { vc_p("VIZSLA-CAL load needs <eventsfile> <prefix> -- fail loud\n" as *u8); return 1 }
367 let efile: *u8 = argv[2] as *u8
368 let prefix: *u8 = argv[3] as *u8
369 var segid: i64 = 0
370 if argc > 4 { segid = vc_atoi(argv[4] as *u8) }
371 if segid == 0 { segid = sys_now_us() }
372
373 let szp: *i64 = sys_mmap(16) as *i64
374 let b: *u8 = ss_readall(efile, szp)
375 let sz: i64 = szp[0]
376 if sz <= 0 { vc_p("VIZSLA-CAL eventsfile MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
377
378 let keys: *i64 = sys_mmap(8 * 8) as *i64
379 let vals: *i64 = sys_mmap(8 * 8) as *i64
380 keys[0] = "kind" as *u8 as i64
381 keys[1] = "id" as *u8 as i64
382 keys[2] = "date" as *u8 as i64
383 keys[3] = "start" as *u8 as i64
384 keys[4] = "dur" as *u8 as i64
385 keys[5] = "title" as *u8 as i64
386 vals[0] = "cal" as *u8 as i64
387 let rkeys: *i64 = sys_mmap(8 * 12) as *i64
388 let rvals: *i64 = sys_mmap(8 * 12) as *i64
389 rkeys[0] = "kind" as *u8 as i64
390 rkeys[1] = "id" as *u8 as i64
391 rkeys[2] = "sdate" as *u8 as i64
392 rkeys[3] = "start" as *u8 as i64
393 rkeys[4] = "dur" as *u8 as i64
394 rkeys[5] = "freq" as *u8 as i64
395 rkeys[6] = "interval" as *u8 as i64
396 rkeys[7] = "count" as *u8 as i64
397 rkeys[8] = "title" as *u8 as i64
398 rvals[0] = "rec" as *u8 as i64
399
400 let st: *i64 = sys_mmap(8 * 8) as *i64
401 st[0] = ss_begin() as i64
402 st[1] = sys_mmap(8 * K_MAGIC_2048)
403 st[2] = 0
404 st[3] = 0
405 st[4] = 0
406 st[5] = 0
407 st[6] = prefix as i64
408
409 let t0: *u8 = sys_mmap(128)
410 let fid: *u8 = sys_mmap(128)
411 let fdt: *u8 = sys_mmap(128)
412 let fst: *u8 = sys_mmap(128)
413 let fdu: *u8 = sys_mmap(128)
414 let ftl: *u8 = sys_mmap(256)
415 let ffr: *u8 = sys_mmap(64)
416 let fiv: *u8 = sys_mmap(64)
417 let fct: *u8 = sys_mmap(64)
418 var scanned: i64 = 0
419
420 var i: i64 = 0
421 while i < sz {
422 var e: i64 = i
423 var go: i64 = 1
424 while go == 1 {
425 if e >= sz { go = 0 } else {
426 if b[e] == (10 as u8) { go = 0 } else { e = e + 1 }
427 }
428 }
429 var p: i64 = vc_tok(b, i, e, t0, 128)
430 if t0[0] == (35 as u8) { t0[0] = 0 as u8 }
431 if vc_eq(t0, "EVENT" as *u8) == 1 {
432 scanned = scanned + 1
433 p = vc_tok(b, p, e, fid, 128)
434 p = vc_tok(b, p, e, fdt, 128)
435 p = vc_tok(b, p, e, fst, 128)
436 p = vc_tok(b, p, e, fdu, 128)
437 p = vc_tok(b, p, e, ftl, 256)
438 if fid[0] == (0 as u8) { vc_p("VIZSLA-CAL EVENT missing id -- fail loud\n" as *u8); return 1 }
439 if vc_datedays(fdt) < 0 { vc_p("VIZSLA-CAL bad date (YYYY-MM-DD) -- fail loud\n" as *u8); return 1 }
440 if vc_digits(fst) == 0 { vc_p("VIZSLA-CAL start_min not digits -- fail loud\n" as *u8); return 1 }
441 if vc_digits(fdu) == 0 { vc_p("VIZSLA-CAL dur_min not digits -- fail loud\n" as *u8); return 1 }
442 if ftl[0] == (0 as u8) { vc_p("VIZSLA-CAL EVENT missing title -- fail loud\n" as *u8); return 1 }
443 let sv: i64 = vc_atoi(fst)
444 let dv: i64 = vc_atoi(fdu)
445 if sv >= K_MAGIC_1440 { vc_p("VIZSLA-CAL start_min >= 1440 -- fail loud\n" as *u8); return 1 }
446 if dv < 1 { vc_p("VIZSLA-CAL dur_min < 1 -- fail loud\n" as *u8); return 1 }
447 if sv + dv > K_MAGIC_1440 { vc_p("VIZSLA-CAL event crosses midnight (start+dur>1440) -- fail loud\n" as *u8); return 1 }
448 vals[1] = fid as i64
449 vals[2] = fdt as i64
450 vals[3] = fst as i64
451 vals[4] = fdu as i64
452 vals[5] = ftl as i64
453 if vc_put(keys, vals, 6, "cal:" as *u8, st) != 0 { vc_p("VIZSLA-CAL writer full -- fail loud\n" as *u8); return 1 }
454 }
455 if vc_eq(t0, "RRULE" as *u8) == 1 {
456 scanned = scanned + 1
457 p = vc_tok(b, p, e, fid, 128)
458 p = vc_tok(b, p, e, fdt, 128)
459 p = vc_tok(b, p, e, fst, 128)
460 p = vc_tok(b, p, e, fdu, 128)
461 p = vc_tok(b, p, e, ffr, 64)
462 p = vc_tok(b, p, e, fiv, 64)
463 p = vc_tok(b, p, e, fct, 64)
464 p = vc_tok(b, p, e, ftl, 256)
465 if fid[0] == (0 as u8) { vc_p("VIZSLA-CAL RRULE missing id -- fail loud\n" as *u8); return 1 }
466 if vc_datedays(fdt) < 0 { vc_p("VIZSLA-CAL RRULE bad start date -- fail loud\n" as *u8); return 1 }
467 if vc_digits(fst) == 0 { vc_p("VIZSLA-CAL RRULE start_min not digits -- fail loud\n" as *u8); return 1 }
468 if vc_digits(fdu) == 0 { vc_p("VIZSLA-CAL RRULE dur_min not digits -- fail loud\n" as *u8); return 1 }
469 var okfreq: i64 = 0
470 if vc_eq(ffr, "DAILY" as *u8) == 1 { okfreq = 1 }
471 if vc_eq(ffr, "WEEKLY" as *u8) == 1 { okfreq = 1 }
472 if vc_eq(ffr, "MONTHLY" as *u8) == 1 { okfreq = 1 }
473 if vc_eq(ffr, "YEARLY" as *u8) == 1 { okfreq = 1 }
474 if okfreq == 0 { vc_p("VIZSLA-CAL RRULE freq not DAILY|WEEKLY|MONTHLY|YEARLY -- fail loud\n" as *u8); return 1 }
475 if vc_digits(fiv) == 0 { vc_p("VIZSLA-CAL RRULE interval not digits -- fail loud\n" as *u8); return 1 }
476 if vc_digits(fct) == 0 { vc_p("VIZSLA-CAL RRULE count not digits -- fail loud\n" as *u8); return 1 }
477 if ftl[0] == (0 as u8) { vc_p("VIZSLA-CAL RRULE missing title -- fail loud\n" as *u8); return 1 }
478 let rsv: i64 = vc_atoi(fst)
479 let rdv: i64 = vc_atoi(fdu)
480 if rsv >= K_MAGIC_1440 { vc_p("VIZSLA-CAL RRULE start_min >= 1440 -- fail loud\n" as *u8); return 1 }
481 if rdv < 1 { vc_p("VIZSLA-CAL RRULE dur_min < 1 -- fail loud\n" as *u8); return 1 }
482 if rsv + rdv > K_MAGIC_1440 { vc_p("VIZSLA-CAL RRULE event crosses midnight -- fail loud\n" as *u8); return 1 }
483 if vc_atoi(fiv) < 1 { vc_p("VIZSLA-CAL RRULE interval < 1 -- fail loud\n" as *u8); return 1 }
484 if vc_atoi(fct) < 1 { vc_p("VIZSLA-CAL RRULE count < 1 -- fail loud\n" as *u8); return 1 }
485 rvals[1] = fid as i64
486 rvals[2] = fdt as i64
487 rvals[3] = fst as i64
488 rvals[4] = fdu as i64
489 rvals[5] = ffr as i64
490 rvals[6] = fiv as i64
491 rvals[7] = fct as i64
492 rvals[8] = ftl as i64
493 if vc_put(rkeys, rvals, 9, "rec:" as *u8, st) != 0 { vc_p("VIZSLA-CAL writer full -- fail loud\n" as *u8); return 1 }
494 }
495 i = e + 1
496 }
497
498 var committed: i64 = 0
499 if st[3] > 0 {
500 if ss_commit(prefix, st[0] as *i64, segid) != 0 { vc_p("VIZSLA-CAL commit FAILED -- fail loud\n" as *u8); return 1 }
501 committed = 1
502 }
503
504 let rep: *u8 = sys_mmap(K_MAGIC_4096)
505 var o: i64 = 0
506 o = vc_cat(rep, o, "VIZSLA-CAL-LOAD scanned=" as *u8)
507 o = vc_catn(rep, o, scanned)
508 o = vc_cat(rep, o, " new=" as *u8)
509 o = vc_catn(rep, o, st[3])
510 o = vc_cat(rep, o, " dup_infile=" as *u8)
511 o = vc_catn(rep, o, st[4])
512 o = vc_cat(rep, o, " dup_instore=" as *u8)
513 o = vc_catn(rep, o, st[5])
514 o = vc_cat(rep, o, " segment=" as *u8)
515 if committed == 1 {
516 o = vc_cat(rep, o, "seg-" as *u8)
517 o = vc_catn(rep, o, segid)
518 } else {
519 o = vc_cat(rep, o, "none" as *u8)
520 }
521 o = vc_cat(rep, o, "\n" as *u8)
522 sys_write(1, rep, o)
523 vc_log_append(prefix, "load" as *u8, rep, o)
524 return 0
525}
526
527// ---------------- DAY (events + free/busy) ----------------
528func vc_cmd_day(argc: i64, argv: *i64) -> i64 {
529 if argc < 4 { vc_p("VIZSLA-CAL day needs <prefix> <date> -- fail loud\n" as *u8); return 1 }
530 let prefix: *u8 = argv[2] as *u8
531 let qdate: *u8 = argv[3] as *u8
532 let qd: i64 = vc_datedays(qdate)
533 if qd < 0 { vc_p("VIZSLA-CAL bad day date -- fail loud\n" as *u8); return 1 }
534
535 let ev_start: *i64 = sys_mmap(8 * 512) as *i64
536 let ev_dur: *i64 = sys_mmap(8 * 512) as *i64
537 let ev_id: *i64 = sys_mmap(8 * 512) as *i64
538 let ev_title: *i64 = sys_mmap(8 * 512) as *i64
539 var n: i64 = 0
540
541 let segs: *i64 = sys_mmap(8 * 260) as *i64
542 let ns: i64 = ss_manifest(prefix, segs)
543 let fdt: *u8 = sys_mmap(128)
544 let fid: *u8 = sys_mmap(128)
545 let fst: *u8 = sys_mmap(128)
546 let fdu: *u8 = sys_mmap(128)
547 let ftl: *u8 = sys_mmap(256)
548 var s: i64 = 0
549 while s < ns {
550 let path: *u8 = sys_mmap(512)
551 var po: i64 = 0
552 po = vc_cat(path, po, prefix)
553 po = vc_cat(path, po, segs[s] as *u8)
554 po = vc_cat(path, po, ".docs" as *u8)
555 path[po] = 0 as u8
556 let szp2: *i64 = sys_mmap(16) as *i64
557 let b: *u8 = ss_readall(path, szp2)
558 let sz: i64 = szp2[0]
559 var j: i64 = 0
560 while j + 9 <= sz {
561 let kind: i64 = b[j]
562 let kl: i64 = ss_r32(b, j + 1)
563 let koff: i64 = j + 5
564 let vl: i64 = ss_r32(b, koff + kl)
565 let voff: i64 = koff + kl + 4
566 var take: i64 = 0
567 if kind == 1 { take = vc_iskind(b, koff, kl, "cal:" as *u8) }
568 if take == 1 {
569 let rec: *u8 = (b as i64 + voff) as *u8
570 if vc_field(rec, vl, "date" as *u8, fdt, 128) == 1 {
571 if vc_datedays(fdt) == qd {
572 vc_field(rec, vl, "id" as *u8, fid, 128)
573 vc_field(rec, vl, "start" as *u8, fst, 128)
574 vc_field(rec, vl, "dur" as *u8, fdu, 128)
575 vc_field(rec, vl, "title" as *u8, ftl, 256)
576 if n < 512 {
577 ev_start[n] = vc_atoi(fst)
578 ev_dur[n] = vc_atoi(fdu)
579 ev_id[n] = vc_dup(fid) as i64
580 ev_title[n] = vc_dup(ftl) as i64
581 n = n + 1
582 }
583 }
584 }
585 }
586 j = voff + vl
587 }
588 s = s + 1
589 }
590
591 // selection sort by start asc (ties keep insertion order)
592 var a: i64 = 0
593 while a < n {
594 var mn: i64 = a
595 var c: i64 = a + 1
596 while c < n {
597 if ev_start[c] < ev_start[mn] { mn = c }
598 c = c + 1
599 }
600 if mn != a {
601 let ts: i64 = ev_start[a]; ev_start[a] = ev_start[mn]; ev_start[mn] = ts
602 let td: i64 = ev_dur[a]; ev_dur[a] = ev_dur[mn]; ev_dur[mn] = td
603 let ti: i64 = ev_id[a]; ev_id[a] = ev_id[mn]; ev_id[mn] = ti
604 let tt: i64 = ev_title[a]; ev_title[a] = ev_title[mn]; ev_title[mn] = tt
605 }
606 a = a + 1
607 }
608
609 let rep: *u8 = sys_mmap(K_MAGIC_131072)
610 var o: i64 = 0
611 var ei: i64 = 0
612 while ei < n {
613 let s0: i64 = ev_start[ei]
614 let e0: i64 = s0 + ev_dur[ei]
615 o = vc_cat(rep, o, "VIZSLA-CAL-EVENT date=" as *u8)
616 o = vc_cat(rep, o, qdate)
617 o = vc_cat(rep, o, " start=" as *u8)
618 o = vc_hhmm(rep, o, s0)
619 o = vc_cat(rep, o, " end=" as *u8)
620 o = vc_hhmm(rep, o, e0)
621 o = vc_cat(rep, o, " dur=" as *u8)
622 o = vc_catn(rep, o, ev_dur[ei])
623 o = vc_cat(rep, o, " id=" as *u8)
624 o = vc_cat(rep, o, ev_id[ei] as *u8)
625 o = vc_cat(rep, o, " title=" as *u8)
626 o = vc_cat(rep, o, ev_title[ei] as *u8)
627 o = vc_cat(rep, o, "\n" as *u8)
628 ei = ei + 1
629 }
630
631 // merge busy intervals (events already sorted by start)
632 let bs: *i64 = sys_mmap(8 * 512) as *i64
633 let be: *i64 = sys_mmap(8 * 512) as *i64
634 var nb: i64 = 0
635 ei = 0
636 while ei < n {
637 let s0: i64 = ev_start[ei]
638 let e0: i64 = s0 + ev_dur[ei]
639 var extend: i64 = 0
640 if nb > 0 { if s0 <= be[nb - 1] { extend = 1 } }
641 if extend == 1 {
642 if e0 > be[nb - 1] { be[nb - 1] = e0 }
643 }
644 if extend == 0 {
645 bs[nb] = s0; be[nb] = e0; nb = nb + 1
646 }
647 ei = ei + 1
648 }
649
650 var busy_min: i64 = 0
651 var bi: i64 = 0
652 while bi < nb {
653 o = vc_cat(rep, o, "VIZSLA-CAL-BUSY start=" as *u8)
654 o = vc_hhmm(rep, o, bs[bi])
655 o = vc_cat(rep, o, " end=" as *u8)
656 o = vc_hhmm(rep, o, be[bi])
657 o = vc_cat(rep, o, "\n" as *u8)
658 busy_min = busy_min + (be[bi] - bs[bi])
659 bi = bi + 1
660 }
661
662 // free = complement of busy within [0,1440)
663 var free_min: i64 = 0
664 var nf: i64 = 0
665 var prev: i64 = 0
666 bi = 0
667 while bi < nb {
668 if bs[bi] > prev {
669 o = vc_cat(rep, o, "VIZSLA-CAL-FREE start=" as *u8)
670 o = vc_hhmm(rep, o, prev)
671 o = vc_cat(rep, o, " end=" as *u8)
672 o = vc_hhmm(rep, o, bs[bi])
673 o = vc_cat(rep, o, "\n" as *u8)
674 free_min = free_min + (bs[bi] - prev)
675 nf = nf + 1
676 }
677 prev = be[bi]
678 bi = bi + 1
679 }
680 if prev < K_MAGIC_1440 {
681 o = vc_cat(rep, o, "VIZSLA-CAL-FREE start=" as *u8)
682 o = vc_hhmm(rep, o, prev)
683 o = vc_cat(rep, o, " end=" as *u8)
684 o = vc_hhmm(rep, o, K_MAGIC_1440)
685 o = vc_cat(rep, o, "\n" as *u8)
686 free_min = free_min + (K_MAGIC_1440 - prev)
687 nf = nf + 1
688 }
689
690 o = vc_cat(rep, o, "VIZSLA-CAL-DAY-VERDICT date=" as *u8)
691 o = vc_cat(rep, o, qdate)
692 o = vc_cat(rep, o, " events=" as *u8)
693 o = vc_catn(rep, o, n)
694 o = vc_cat(rep, o, " busy_min=" as *u8)
695 o = vc_catn(rep, o, busy_min)
696 o = vc_cat(rep, o, " free_min=" as *u8)
697 o = vc_catn(rep, o, free_min)
698 o = vc_cat(rep, o, " busy_blocks=" as *u8)
699 o = vc_catn(rep, o, nb)
700 o = vc_cat(rep, o, " free_blocks=" as *u8)
701 o = vc_catn(rep, o, nf)
702 o = vc_cat(rep, o, "\n" as *u8)
703 sys_write(1, rep, o)
704 vc_log_append(prefix, "day" as *u8, rep, o)
705 return 0
706}
707
708// ---------------- EXPAND (recurrence occurrences in a window) ----------------
709func vc_cmd_expand(argc: i64, argv: *i64) -> i64 {
710 if argc < 5 { vc_p("VIZSLA-CAL expand needs <prefix> <from> <to> -- fail loud\n" as *u8); return 1 }
711 let prefix: *u8 = argv[2] as *u8
712 let qfrom: i64 = vc_datedays(argv[3] as *u8)
713 let qto: i64 = vc_datedays(argv[4] as *u8)
714 if qfrom < 0 { vc_p("VIZSLA-CAL expand bad from date -- fail loud\n" as *u8); return 1 }
715 if qto < 0 { vc_p("VIZSLA-CAL expand bad to date -- fail loud\n" as *u8); return 1 }
716 if qto < qfrom { vc_p("VIZSLA-CAL expand to < from -- fail loud\n" as *u8); return 1 }
717
718 let rep: *u8 = sys_mmap(K_MAGIC_262144)
719 var o: i64 = 0
720 var rules: i64 = 0
721 var occ_total: i64 = 0
722
723 let segs: *i64 = sys_mmap(8 * 260) as *i64
724 let ns: i64 = ss_manifest(prefix, segs)
725 let fid: *u8 = sys_mmap(128)
726 let fdt: *u8 = sys_mmap(128)
727 let fst: *u8 = sys_mmap(128)
728 let fdu: *u8 = sys_mmap(128)
729 let ffr: *u8 = sys_mmap(64)
730 let fiv: *u8 = sys_mmap(64)
731 let fct: *u8 = sys_mmap(64)
732 let ftl: *u8 = sys_mmap(256)
733 let ymd: *i64 = sys_mmap(8 * 4) as *i64
734 var s: i64 = 0
735 while s < ns {
736 let path: *u8 = sys_mmap(512)
737 var po: i64 = 0
738 po = vc_cat(path, po, prefix)
739 po = vc_cat(path, po, segs[s] as *u8)
740 po = vc_cat(path, po, ".docs" as *u8)
741 path[po] = 0 as u8
742 let szp2: *i64 = sys_mmap(16) as *i64
743 let b: *u8 = ss_readall(path, szp2)
744 let sz: i64 = szp2[0]
745 var j: i64 = 0
746 while j + 9 <= sz {
747 let kind: i64 = b[j]
748 let kl: i64 = ss_r32(b, j + 1)
749 let koff: i64 = j + 5
750 let vl: i64 = ss_r32(b, koff + kl)
751 let voff: i64 = koff + kl + 4
752 var take: i64 = 0
753 if kind == 1 { take = vc_iskind(b, koff, kl, "rec:" as *u8) }
754 if take == 1 {
755 let rec: *u8 = (b as i64 + voff) as *u8
756 vc_field(rec, vl, "id" as *u8, fid, 128)
757 vc_field(rec, vl, "sdate" as *u8, fdt, 128)
758 vc_field(rec, vl, "start" as *u8, fst, 128)
759 vc_field(rec, vl, "dur" as *u8, fdu, 128)
760 vc_field(rec, vl, "freq" as *u8, ffr, 64)
761 vc_field(rec, vl, "interval" as *u8, fiv, 64)
762 vc_field(rec, vl, "count" as *u8, fct, 64)
763 vc_field(rec, vl, "title" as *u8, ftl, 256)
764 let sd0: i64 = vc_datedays(fdt)
765 vc_civil(sd0, ymd)
766 let iv: i64 = vc_atoi(fiv)
767 let ct: i64 = vc_atoi(fct)
768 let smin: i64 = vc_atoi(fst)
769 let dmin: i64 = vc_atoi(fdu)
770 var k: i64 = 0
771 while k < ct {
772 let occ: i64 = vc_occ(ffr, sd0, ymd[0], ymd[1], ymd[2], iv, k)
773 if occ >= qfrom { if occ <= qto {
774 o = vc_cat(rep, o, "VIZSLA-CAL-OCC id=" as *u8)
775 o = vc_cat(rep, o, fid)
776 o = vc_cat(rep, o, " date=" as *u8)
777 o = vc_daystr(rep, o, occ)
778 o = vc_cat(rep, o, " start=" as *u8)
779 o = vc_hhmm(rep, o, smin)
780 o = vc_cat(rep, o, " end=" as *u8)
781 o = vc_hhmm(rep, o, smin + dmin)
782 o = vc_cat(rep, o, " freq=" as *u8)
783 o = vc_cat(rep, o, ffr)
784 o = vc_cat(rep, o, " n=" as *u8)
785 o = vc_catn(rep, o, k + 1)
786 o = vc_cat(rep, o, " title=" as *u8)
787 o = vc_cat(rep, o, ftl)
788 o = vc_cat(rep, o, "\n" as *u8)
789 occ_total = occ_total + 1
790 } }
791 k = k + 1
792 }
793 rules = rules + 1
794 }
795 j = voff + vl
796 }
797 s = s + 1
798 }
799
800 o = vc_cat(rep, o, "VIZSLA-CAL-EXPAND-VERDICT rules=" as *u8)
801 o = vc_catn(rep, o, rules)
802 o = vc_cat(rep, o, " occurrences=" as *u8)
803 o = vc_catn(rep, o, occ_total)
804 o = vc_cat(rep, o, "\n" as *u8)
805 sys_write(1, rep, o)
806 vc_log_append(prefix, "expand" as *u8, rep, o)
807 return 0
808}
809
810// ---------------- CONFLICTS (overlap scan across occurrences in a window) ----------------
811func vc_cmd_conflicts(argc: i64, argv: *i64) -> i64 {
812 if argc < 5 { vc_p("VIZSLA-CAL conflicts needs <prefix> <from> <to> -- fail loud\n" as *u8); return 1 }
813 let prefix: *u8 = argv[2] as *u8
814 let qfrom: i64 = vc_datedays(argv[3] as *u8)
815 let qto: i64 = vc_datedays(argv[4] as *u8)
816 if qfrom < 0 { vc_p("VIZSLA-CAL conflicts bad from date -- fail loud\n" as *u8); return 1 }
817 if qto < 0 { vc_p("VIZSLA-CAL conflicts bad to date -- fail loud\n" as *u8); return 1 }
818 if qto < qfrom { vc_p("VIZSLA-CAL conflicts to < from -- fail loud\n" as *u8); return 1 }
819
820 let oc_day: *i64 = sys_mmap(8 * 512) as *i64
821 let oc_start: *i64 = sys_mmap(8 * 512) as *i64
822 let oc_end: *i64 = sys_mmap(8 * 512) as *i64
823 let oc_id: *i64 = sys_mmap(8 * 512) as *i64
824 let oc_title: *i64 = sys_mmap(8 * 512) as *i64
825 var n: i64 = 0
826
827 let segs: *i64 = sys_mmap(8 * 260) as *i64
828 let ns: i64 = ss_manifest(prefix, segs)
829 let fid: *u8 = sys_mmap(128)
830 let fdt: *u8 = sys_mmap(128)
831 let fst: *u8 = sys_mmap(128)
832 let fdu: *u8 = sys_mmap(128)
833 let ffr: *u8 = sys_mmap(64)
834 let fiv: *u8 = sys_mmap(64)
835 let fct: *u8 = sys_mmap(64)
836 let ftl: *u8 = sys_mmap(256)
837 let ymd: *i64 = sys_mmap(8 * 4) as *i64
838 var s: i64 = 0
839 while s < ns {
840 let path: *u8 = sys_mmap(512)
841 var po: i64 = 0
842 po = vc_cat(path, po, prefix)
843 po = vc_cat(path, po, segs[s] as *u8)
844 po = vc_cat(path, po, ".docs" as *u8)
845 path[po] = 0 as u8
846 let szp2: *i64 = sys_mmap(16) as *i64
847 let b: *u8 = ss_readall(path, szp2)
848 let sz: i64 = szp2[0]
849 var j: i64 = 0
850 while j + 9 <= sz {
851 let kind: i64 = b[j]
852 let kl: i64 = ss_r32(b, j + 1)
853 let koff: i64 = j + 5
854 let vl: i64 = ss_r32(b, koff + kl)
855 let voff: i64 = koff + kl + 4
856 let rec: *u8 = (b as i64 + voff) as *u8
857 var iscal: i64 = 0
858 var isrec: i64 = 0
859 if kind == 1 { iscal = vc_iskind(b, koff, kl, "cal:" as *u8) }
860 if kind == 1 { isrec = vc_iskind(b, koff, kl, "rec:" as *u8) }
861 if iscal == 1 {
862 var dd: i64 = 0 - 1
863 if vc_field(rec, vl, "date" as *u8, fdt, 128) == 1 { dd = vc_datedays(fdt) }
864 var inwin: i64 = 0
865 if dd >= qfrom { if dd <= qto { inwin = 1 } }
866 if inwin == 1 { if n < 512 {
867 vc_field(rec, vl, "id" as *u8, fid, 128)
868 vc_field(rec, vl, "start" as *u8, fst, 128)
869 vc_field(rec, vl, "dur" as *u8, fdu, 128)
870 vc_field(rec, vl, "title" as *u8, ftl, 256)
871 oc_day[n] = dd
872 oc_start[n] = vc_atoi(fst)
873 oc_end[n] = vc_atoi(fst) + vc_atoi(fdu)
874 oc_id[n] = vc_dup(fid) as i64
875 oc_title[n] = vc_dup(ftl) as i64
876 n = n + 1
877 } }
878 }
879 if isrec == 1 {
880 vc_field(rec, vl, "id" as *u8, fid, 128)
881 vc_field(rec, vl, "sdate" as *u8, fdt, 128)
882 vc_field(rec, vl, "start" as *u8, fst, 128)
883 vc_field(rec, vl, "dur" as *u8, fdu, 128)
884 vc_field(rec, vl, "freq" as *u8, ffr, 64)
885 vc_field(rec, vl, "interval" as *u8, fiv, 64)
886 vc_field(rec, vl, "count" as *u8, fct, 64)
887 vc_field(rec, vl, "title" as *u8, ftl, 256)
888 let sd0: i64 = vc_datedays(fdt)
889 vc_civil(sd0, ymd)
890 let iv: i64 = vc_atoi(fiv)
891 let ct: i64 = vc_atoi(fct)
892 let smin: i64 = vc_atoi(fst)
893 let emin: i64 = smin + vc_atoi(fdu)
894 var k: i64 = 0
895 while k < ct {
896 let occ: i64 = vc_occ(ffr, sd0, ymd[0], ymd[1], ymd[2], iv, k)
897 var inw: i64 = 0
898 if occ >= qfrom { if occ <= qto { inw = 1 } }
899 if inw == 1 { if n < 512 {
900 oc_day[n] = occ
901 oc_start[n] = smin
902 oc_end[n] = emin
903 oc_id[n] = vc_dup(fid) as i64
904 oc_title[n] = vc_dup(ftl) as i64
905 n = n + 1
906 } }
907 k = k + 1
908 }
909 }
910 j = voff + vl
911 }
912 s = s + 1
913 }
914
915 // sort by (day, start) for deterministic, readable output
916 var a: i64 = 0
917 while a < n {
918 var mn: i64 = a
919 var c: i64 = a + 1
920 while c < n {
921 var less: i64 = 0
922 if oc_day[c] < oc_day[mn] { less = 1 }
923 if oc_day[c] == oc_day[mn] { if oc_start[c] < oc_start[mn] { less = 1 } }
924 if less == 1 { mn = c }
925 c = c + 1
926 }
927 if mn != a {
928 let t1: i64 = oc_day[a]; oc_day[a] = oc_day[mn]; oc_day[mn] = t1
929 let t2: i64 = oc_start[a]; oc_start[a] = oc_start[mn]; oc_start[mn] = t2
930 let t3: i64 = oc_end[a]; oc_end[a] = oc_end[mn]; oc_end[mn] = t3
931 let t4: i64 = oc_id[a]; oc_id[a] = oc_id[mn]; oc_id[mn] = t4
932 let t5: i64 = oc_title[a]; oc_title[a] = oc_title[mn]; oc_title[mn] = t5
933 }
934 a = a + 1
935 }
936
937 // pairwise overlap scan: same day AND [s1,e1) intersects [s2,e2)
938 let rep: *u8 = sys_mmap(K_MAGIC_262144)
939 var o: i64 = 0
940 var conflicts: i64 = 0
941 var ii: i64 = 0
942 while ii < n {
943 var jj: i64 = ii + 1
944 while jj < n {
945 var clash: i64 = 0
946 if oc_day[ii] == oc_day[jj] {
947 var ov: i64 = 0
948 if oc_start[ii] < oc_end[jj] { ov = 1 }
949 if oc_start[jj] >= oc_end[ii] { ov = 0 }
950 clash = ov
951 }
952 if clash == 1 {
953 var os: i64 = oc_start[ii]
954 if oc_start[jj] > os { os = oc_start[jj] }
955 var oe: i64 = oc_end[ii]
956 if oc_end[jj] < oe { oe = oc_end[jj] }
957 o = vc_cat(rep, o, "VIZSLA-CAL-CONFLICT date=" as *u8)
958 o = vc_daystr(rep, o, oc_day[ii])
959 o = vc_cat(rep, o, " a=" as *u8)
960 o = vc_cat(rep, o, oc_id[ii] as *u8)
961 o = vc_cat(rep, o, "@" as *u8)
962 o = vc_hhmm(rep, o, oc_start[ii])
963 o = vc_cat(rep, o, "-" as *u8)
964 o = vc_hhmm(rep, o, oc_end[ii])
965 o = vc_cat(rep, o, " b=" as *u8)
966 o = vc_cat(rep, o, oc_id[jj] as *u8)
967 o = vc_cat(rep, o, "@" as *u8)
968 o = vc_hhmm(rep, o, oc_start[jj])
969 o = vc_cat(rep, o, "-" as *u8)
970 o = vc_hhmm(rep, o, oc_end[jj])
971 o = vc_cat(rep, o, " overlap=" as *u8)
972 o = vc_hhmm(rep, o, os)
973 o = vc_cat(rep, o, "-" as *u8)
974 o = vc_hhmm(rep, o, oe)
975 o = vc_cat(rep, o, "\n" as *u8)
976 conflicts = conflicts + 1
977 }
978 jj = jj + 1
979 }
980 ii = ii + 1
981 }
982 o = vc_cat(rep, o, "VIZSLA-CAL-CONFLICT-VERDICT occurrences=" as *u8)
983 o = vc_catn(rep, o, n)
984 o = vc_cat(rep, o, " conflicts=" as *u8)
985 o = vc_catn(rep, o, conflicts)
986 o = vc_cat(rep, o, "\n" as *u8)
987 sys_write(1, rep, o)
988 vc_log_append(prefix, "conflicts" as *u8, rep, o)
989 return 0
990}
991
992func main(argc: i64, argv: *i64) -> i64 {
993 if argc < 2 { vc_p("VIZSLA-CAL usage: load|day|expand|conflicts -- fail loud\n" as *u8); return 1 }
994 let cmd: *u8 = argv[1] as *u8
995 if vc_eq(cmd, "load" as *u8) == 1 { return vc_cmd_load(argc, argv) }
996 if vc_eq(cmd, "day" as *u8) == 1 { return vc_cmd_day(argc, argv) }
997 if vc_eq(cmd, "expand" as *u8) == 1 { return vc_cmd_expand(argc, argv) }
998 if vc_eq(cmd, "conflicts" as *u8) == 1 { return vc_cmd_conflicts(argc, argv) }
999 vc_p("VIZSLA-CAL unknown command (load|day|expand|conflicts) -- fail loud\n" as *u8)
1000 return 1
1001}