code wiki / _hdl_build / nx_vizsla_ics.nx
`nx_vizsla_ics.nx` source

↩ module page · 847 lines · 31783 B
1// nx_vizsla_ics.nx -- NISHI VIZSLA R-CAL.4 (census PA14 interop): RFC 5545 iCalendar EXPORT.
2// Operator 2026-07-07: "exposing a calendar for a group to coordinate" -- the sovereign calendar
3// store becomes a standards-compliant .ics artifact ANY calendar app (Google/Apple/Outlook/
4// Thunderbird) can import or subscribe to. READ-ONLY over the R-CAL data plane (cal: events +
5// rec: RRULE records written by nx_vizsla_calendar); the data never needs a cloud account.
6//
7// Command (argv[1]):
8//   export <prefix> <from YYYY-MM-DD> <to YYYY-MM-DD> <out.ics>
9//     cal: events with from<=date<=to  -> VEVENT (DTSTART/DTEND local floating time)
10//     rec: rules intersecting [from,to] (first occurrence <= to AND last >= from)
11//                                       -> VEVENT anchored at sdate + native RRULE passthrough
12//                                          (FREQ=DAILY|WEEKLY|MONTHLY|YEARLY;INTERVAL;COUNT)
13// RFC 5545 discipline (the gate's oracle): CRLF line ends; VERSION:2.0 + PRODID; every VEVENT
14// carries UID (stable "<id>-<YYYYMMDD>@nishi.vizsla") + DTSTAMP; TEXT escaping of \ ; , in
15// SUMMARY; content lines folded at 75 octets (continuation = CRLF + single space).
16// DETERMINISM: no clocks -- DTSTAMP derives from the record's own date, so the same store
17// exports byte-identical .ics every run (subscribable artifact, CID-friendly).
18// HONEST SCOPE: floating local time (no VTIMEZONE) -- right for a same-timezone friend group;
19// TZ-aware export is a later rung. Loud-fail: bad dates, to<from, unwritable out, unknown cmd.
20// spec: knowledge/research/2026-06-22-vizsla-sclass-roadmap.md   license_tier: ORIGINAL
21import "nx_syscalls.nx"
22import "nx_seg_store.nx"
23import "nx_canon_cid.nx"
24const K_MAGIC_1970: i64 = 1970
25const K_MAGIC_146097: i64 = 146097
26const K_MAGIC_719468: i64 = 719468
27const K_MAGIC_146096: i64 = 146096
28const K_MAGIC_1460: i64 = 1460
29const K_MAGIC_36524: i64 = 36524
30const K_MAGIC_524288: i64 = 524288
31const K_MAGIC_4096: i64 = 4096
32const K_MAGIC_2048: i64 = 2048
33const K_MAGIC_1024: i64 = 1024
34
35func vi_slen(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
36func vi_p(s: *u8) -> i64 { sys_write(1, s, vi_slen(s)); return 0 }
37
38func vi_eq(a: *u8, b: *u8) -> i64 {
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      if a[i] != b[i] { return 0 }
      if a[i] == (0 as u8) { return 1 }
      i = i + 1
  }
  return 0
47}
48
49func vi_atoi(s: *u8) -> i64 {
  var v: i64 = 0
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let d: i64 = (s[i] as i64) - 48
      if d >= 0 { if d <= 9 { v = v * 10 + d } }
      i = i + 1
  }
  return v
58}
59
60func vi_cat(dst: *u8, off: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while s[i] != (0 as u8) { dst[off + i] = s[i]; i = i + 1 }
  return off + i
64}
65
66func vi_catc(dst: *u8, off: i64, c: i64) -> i64 {
  dst[off] = c as u8
  return off + 1
69}
70
71func vi_catn(dst: *u8, off: i64, v: i64) -> i64 {
  var o: i64 = off
  var m: i64 = v
  if m < 0 { dst[o] = 45 as u8; o = o + 1; m = 0 - m }
  let t: *u8 = sys_mmap(28)
  var k: i64 = 0
  if m == 0 { t[0] = 48 as u8; k = 1 }
  while m > 0 { t[k] = (48 + (m % 10)) as u8; m = m / 10; k = k + 1 }
  var i: i64 = 0
  while i < k { dst[o + i] = t[k - 1 - i]; i = i + 1 }
  return o + k
82}
83
84func vi_kmemeq(b: *u8, off: i64, n: i64, s: *u8) -> i64 {
  if vi_slen(s) != n { return 0 }
  var i: i64 = 0
  while i < n {
      if b[off + i] != s[i] { return 0 }
      i = i + 1
  }
  return 1
92}
93
94func vi_field(rec: *u8, rl: i64, want: *u8, out: *u8, cap: i64) -> i64 {
  if rl < 8 { return 0 }
  let nf: i64 = ss_r32(rec, 4)
  var off: i64 = 8
  var fi: i64 = 0
  while fi < nf {
      if off + 8 > rl { return 0 }
      let kl: i64 = ss_r32(rec, off)
      let koff: i64 = off + 4
      let vl: i64 = ss_r32(rec, koff + kl)
      let voff: i64 = koff + kl + 4
      if vi_kmemeq(rec, koff, kl, want) == 1 {
          var t: i64 = 0
          while t < vl {
              if t < cap - 1 { out[t] = rec[voff + t] }
              t = t + 1
          }
          if t > cap - 1 { t = cap - 1 }
          out[t] = 0 as u8
          return 1
      }
      off = voff + vl
      fi = fi + 1
  }
  return 0
119}
120
121func vi_iskind(b: *u8, koff: i64, kl: i64, pfx: *u8) -> i64 {
  if kl <= 4 { return 0 }
  return vi_kmemeq(b, koff, 4, pfx)
124}
125
126// civil "YYYY-MM-DD" -> days since epoch (Hinnant); -1 malformed
127func vi_datedays(s: *u8) -> i64 {
  let nums: *i64 = sys_mmap(8 * 4) as *i64
  var nn: i64 = 0
  var cur: i64 = 0
  var indig: i64 = 0
  var i: i64 = 0
  var go: i64 = 1
  while go == 1 {
      let c: i64 = s[i] as i64
      var isd: i64 = 0
      if c >= 48 { if c <= 57 { isd = 1 } }
      if isd == 1 { cur = cur * 10 + (c - 48); indig = 1 }
      if isd == 0 {
          if indig == 1 {
              if nn < 4 { nums[nn] = cur; nn = nn + 1 }
              cur = 0
              indig = 0
          }
      }
      if c == 0 { go = 0 }
      i = i + 1
  }
  if nn != 3 { return 0 - 1 }
  var y: i64 = nums[0]
  let m: i64 = nums[1]
  let d: i64 = nums[2]
  if y < K_MAGIC_1970 { return 0 - 1 }
  if m < 1 { return 0 - 1 }
  if m > 12 { return 0 - 1 }
  if d < 1 { return 0 - 1 }
  if d > 31 { return 0 - 1 }
  if m <= 2 { y = y - 1 }
  let era: i64 = y / 400
  let yoe: i64 = y - era * 400
  var mp: i64 = m - 3
  if m <= 2 { mp = m + 9 }
  let doy: i64 = (153 * mp + 2) / 5 + d - 1
  let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
  return era * K_MAGIC_146097 + doe - K_MAGIC_719468
166}
167
168func vi_ymd2days(y0: i64, m: i64, d: i64) -> i64 {
  var y: i64 = y0
  if m <= 2 { y = y0 - 1 }
  let era: i64 = y / 400
  let yoe: i64 = y - era * 400
  var mp: i64 = m - 3
  if m <= 2 { mp = m + 9 }
  let doy: i64 = (153 * mp + 2) / 5 + d - 1
  let doe: i64 = yoe * 365 + yoe / 4 - yoe / 100 + doy
  return era * K_MAGIC_146097 + doe - K_MAGIC_719468
178}
179
180func vi_civil(z0: i64, out: *i64) -> i64 {
  var z: i64 = z0 + K_MAGIC_719468
  var era: i64 = z / K_MAGIC_146097
  if z < 0 { era = (z - K_MAGIC_146096) / K_MAGIC_146097 }
  let doe: i64 = z - era * K_MAGIC_146097
  let yoe: i64 = (doe - doe / K_MAGIC_1460 + doe / K_MAGIC_36524 - doe / K_MAGIC_146096) / 365
  let y0: i64 = yoe + era * 400
  let doy: i64 = doe - (365 * yoe + yoe / 4 - yoe / 100)
  let mp: i64 = (5 * doy + 2) / 153
  let d: i64 = doy - (153 * mp + 2) / 5 + 1
  var m: i64 = mp + 3
  if mp >= 10 { m = mp - 9 }
  var y: i64 = y0
  if m <= 2 { y = y0 + 1 }
  out[0] = y; out[1] = m; out[2] = d
  return 0
196}
197
198func vi_dim(y: i64, m: i64) -> i64 {
  if m == 2 {
      var leap: i64 = 0
      if y % 4 == 0 { leap = 1 }
      if y % 100 == 0 { leap = 0 }
      if y % 400 == 0 { leap = 1 }
      if leap == 1 { return 29 }
      return 28
  }
  if m == 4 { return 30 }
  if m == 6 { return 30 }
  if m == 9 { return 30 }
  if m == 11 { return 30 }
  return 31
212}
213
214// k-th occurrence day (mirrors nx_vizsla_calendar vc_occ incl. YEARLY month-step + day clamp)
215func vi_occ(freq: *u8, sd0: i64, sy: i64, sm: i64, sd: i64, interval: i64, k: i64) -> i64 {
  if vi_eq(freq, "DAILY" as *u8) == 1 { return sd0 + k * interval }
  if vi_eq(freq, "WEEKLY" as *u8) == 1 { return sd0 + k * interval * 7 }
  var mstep: i64 = interval
  if vi_eq(freq, "YEARLY" as *u8) == 1 { mstep = interval * 12 }
  let tot: i64 = (sm - 1) + k * mstep
  let y2: i64 = sy + tot / 12
  let m2: i64 = tot - (tot / 12) * 12 + 1
  var d2: i64 = sd
  let dim: i64 = vi_dim(y2, m2)
  if d2 > dim { d2 = dim }
  return vi_ymd2days(y2, m2, d2)
227}
228
229// "YYYY-MM-DD" -> append "YYYYMMDD"
230func vi_dt8(dst: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  while s[i] != (0 as u8) {
      if s[i] != (45 as u8) { dst[o] = s[i]; o = o + 1 }
      i = i + 1
  }
  return o
238}
239
240// minute-of-day -> append "HHMMSS" (zero-padded, SS=00)
241func vi_hms(dst: *u8, off: i64, m: i64) -> i64 {
  var o: i64 = off
  let h: i64 = m / 60
  let mm: i64 = m - h * 60
  if h < 10 { dst[o] = 48 as u8; o = o + 1 }
  o = vi_catn(dst, o, h)
  if mm < 10 { dst[o] = 48 as u8; o = o + 1 }
  o = vi_catn(dst, o, mm)
  o = vi_cat(dst, o, "00" as *u8)
  return o
251}
252
253// RFC5545 TEXT escaping: backslash, semicolon, comma (newlines cannot occur in store tokens)
254func vi_esc(dst: *u8, off: i64, s: *u8) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  while s[i] != (0 as u8) {
      let c: i64 = s[i] as i64
      if c == 92 { o = vi_catc(dst, o, 92); o = vi_catc(dst, o, 92) }
      if c == 59 { o = vi_catc(dst, o, 92); o = vi_catc(dst, o, 59) }
      if c == 44 { o = vi_catc(dst, o, 92); o = vi_catc(dst, o, 44) }
      if c != 92 { if c != 59 { if c != 44 {
          o = vi_catc(dst, o, c)
      } } }
      i = i + 1
  }
  return o
268}
269
270// append one content line with RFC5545 75-octet folding + CRLF termination.
271// first physical line carries <=75 octets; each continuation = single leading space + <=74 more.
272// st[0] accumulates folded-line count (evidence for the verdict).
273func vi_fold(rep: *u8, off: i64, lb: *u8, ll: i64, st: *i64) -> i64 {
  var o: i64 = off
  var i: i64 = 0
  var seg: i64 = 75
  var first: i64 = 1
  while i < ll {
      var take: i64 = ll - i
      if take > seg { take = seg }
      if first == 0 {
          o = vi_catc(rep, o, 32)
      }
      var t: i64 = 0
      while t < take { rep[o + t] = lb[i + t]; t = t + 1 }
      o = o + take
      i = i + take
      o = vi_catc(rep, o, 13)
      o = vi_catc(rep, o, 10)
      if i < ll { st[0] = st[0] + 1 }
      first = 0
      seg = 74
  }
  if ll == 0 {
      o = vi_catc(rep, o, 13)
      o = vi_catc(rep, o, 10)
  }
  return o
299}
300
301// ---------------- EXPORT ----------------
302func vi_cmd_export(argc: i64, argv: *i64) -> i64 {
  if argc < 6 { vi_p("VIZSLA-ICS export needs <prefix> <from> <to> <out.ics> -- fail loud\n" as *u8); return 1 }
  let prefix: *u8 = argv[2] as *u8
  let qfrom: i64 = vi_datedays(argv[3] as *u8)
  let qto: i64 = vi_datedays(argv[4] as *u8)
  let outp: *u8 = argv[5] as *u8
  if qfrom < 0 { vi_p("VIZSLA-ICS bad from date -- fail loud\n" as *u8); return 1 }
  if qto < 0 { vi_p("VIZSLA-ICS bad to date -- fail loud\n" as *u8); return 1 }
  if qto < qfrom { vi_p("VIZSLA-ICS to < from -- fail loud\n" as *u8); return 1 }
311
  let rep: *u8 = sys_mmap(K_MAGIC_524288)
  let lb: *u8 = sys_mmap(K_MAGIC_4096)
  let st: *i64 = sys_mmap(16) as *i64
  st[0] = 0
  var o: i64 = 0
  var ll: i64 = 0
  ll = vi_cat(lb, 0, "BEGIN:VCALENDAR" as *u8)
  o = vi_fold(rep, o, lb, ll, st)
  ll = vi_cat(lb, 0, "VERSION:2.0" as *u8)
  o = vi_fold(rep, o, lb, ll, st)
  ll = vi_cat(lb, 0, "PRODID:-//Nishi//Vizsla Calendar//EN" as *u8)
  o = vi_fold(rep, o, lb, ll, st)
  ll = vi_cat(lb, 0, "CALSCALE:GREGORIAN" as *u8)
  o = vi_fold(rep, o, lb, ll, st)
326
  var nev: i64 = 0
  var nru: i64 = 0
329
  let segs: *i64 = sys_mmap(8 * 260) as *i64
  let ns: i64 = ss_manifest(prefix, segs)
  let fid: *u8 = sys_mmap(128)
  let fdt: *u8 = sys_mmap(128)
  let fst: *u8 = sys_mmap(128)
  let fdu: *u8 = sys_mmap(128)
  let ffr: *u8 = sys_mmap(64)
  let fiv: *u8 = sys_mmap(64)
  let fct: *u8 = sys_mmap(64)
  let ftl: *u8 = sys_mmap(256)
  let ymd: *i64 = sys_mmap(8 * 4) as *i64
  var s: i64 = 0
  while s < ns {
      let path: *u8 = sys_mmap(512)
      var po: i64 = 0
      po = vi_cat(path, po, prefix)
      po = vi_cat(path, po, segs[s] as *u8)
      po = vi_cat(path, po, ".docs" as *u8)
      path[po] = 0 as u8
      let szp: *i64 = sys_mmap(16) as *i64
      let b: *u8 = ss_readall(path, szp)
      let sz: i64 = szp[0]
      var j: i64 = 0
      while j + 9 <= sz {
          let kind: i64 = b[j]
          let kl: i64 = ss_r32(b, j + 1)
          let koff: i64 = j + 5
          let vl: i64 = ss_r32(b, koff + kl)
          let voff: i64 = koff + kl + 4
          let rec: *u8 = (b as i64 + voff) as *u8
          var iscal: i64 = 0
          var isrec: i64 = 0
          if kind == 1 { iscal = vi_iskind(b, koff, kl, "cal:" as *u8) }
          if kind == 1 { isrec = vi_iskind(b, koff, kl, "rec:" as *u8) }
          if iscal == 1 {
              var dd: i64 = 0 - 1
              if vi_field(rec, vl, "date" as *u8, fdt, 128) == 1 { dd = vi_datedays(fdt) }
              var inwin: i64 = 0
              if dd >= qfrom { if dd <= qto { inwin = 1 } }
              if inwin == 1 {
                  vi_field(rec, vl, "id" as *u8, fid, 128)
                  vi_field(rec, vl, "start" as *u8, fst, 128)
                  vi_field(rec, vl, "dur" as *u8, fdu, 128)
                  vi_field(rec, vl, "title" as *u8, ftl, 256)
                  let smin: i64 = vi_atoi(fst)
                  let emin: i64 = smin + vi_atoi(fdu)
                  ll = vi_cat(lb, 0, "BEGIN:VEVENT" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "UID:" as *u8)
                  ll = vi_cat(lb, ll, fid)
                  ll = vi_catc(lb, ll, 45)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_cat(lb, ll, "@nishi.vizsla" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "DTSTAMP:" as *u8)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_cat(lb, ll, "T000000Z" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "DTSTART:" as *u8)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_catc(lb, ll, 84)
                  ll = vi_hms(lb, ll, smin)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "DTEND:" as *u8)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_catc(lb, ll, 84)
                  ll = vi_hms(lb, ll, emin)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "SUMMARY:" as *u8)
                  ll = vi_esc(lb, ll, ftl)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "END:VEVENT" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  nev = nev + 1
              }
          }
          if isrec == 1 {
              vi_field(rec, vl, "id" as *u8, fid, 128)
              vi_field(rec, vl, "sdate" as *u8, fdt, 128)
              vi_field(rec, vl, "start" as *u8, fst, 128)
              vi_field(rec, vl, "dur" as *u8, fdu, 128)
              vi_field(rec, vl, "freq" as *u8, ffr, 64)
              vi_field(rec, vl, "interval" as *u8, fiv, 64)
              vi_field(rec, vl, "count" as *u8, fct, 64)
              vi_field(rec, vl, "title" as *u8, ftl, 256)
              let sd0: i64 = vi_datedays(fdt)
              vi_civil(sd0, ymd)
              let iv: i64 = vi_atoi(fiv)
              let ct: i64 = vi_atoi(fct)
              let lastocc: i64 = vi_occ(ffr, sd0, ymd[0], ymd[1], ymd[2], iv, ct - 1)
              var inwin: i64 = 0
              if sd0 <= qto { if lastocc >= qfrom { inwin = 1 } }
              if inwin == 1 {
                  let smin: i64 = vi_atoi(fst)
                  let emin: i64 = smin + vi_atoi(fdu)
                  ll = vi_cat(lb, 0, "BEGIN:VEVENT" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "UID:" as *u8)
                  ll = vi_cat(lb, ll, fid)
                  ll = vi_catc(lb, ll, 45)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_cat(lb, ll, "@nishi.vizsla" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "DTSTAMP:" as *u8)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_cat(lb, ll, "T000000Z" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "DTSTART:" as *u8)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_catc(lb, ll, 84)
                  ll = vi_hms(lb, ll, smin)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "DTEND:" as *u8)
                  ll = vi_dt8(lb, ll, fdt)
                  ll = vi_catc(lb, ll, 84)
                  ll = vi_hms(lb, ll, emin)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "RRULE:FREQ=" as *u8)
                  ll = vi_cat(lb, ll, ffr)
                  ll = vi_cat(lb, ll, ";INTERVAL=" as *u8)
                  ll = vi_catn(lb, ll, iv)
                  ll = vi_cat(lb, ll, ";COUNT=" as *u8)
                  ll = vi_catn(lb, ll, ct)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "SUMMARY:" as *u8)
                  ll = vi_esc(lb, ll, ftl)
                  o = vi_fold(rep, o, lb, ll, st)
                  ll = vi_cat(lb, 0, "END:VEVENT" as *u8)
                  o = vi_fold(rep, o, lb, ll, st)
                  nru = nru + 1
              }
          }
          j = voff + vl
      }
      s = s + 1
  }
466
  ll = vi_cat(lb, 0, "END:VCALENDAR" as *u8)
  o = vi_fold(rep, o, lb, ll, st)
469
  let fd: i64 = sys_openat_wr(outp, 0x1a4)
  if fd < 0 { vi_p("VIZSLA-ICS cannot write out.ics -- fail loud\n" as *u8); return 1 }
  sys_write(fd, rep, o)
  sys_close(fd)
474
  let vb: *u8 = sys_mmap(256)
  var vo: i64 = 0
  vo = vi_cat(vb, vo, "VIZSLA-ICS-VERDICT events=" as *u8)
  vo = vi_catn(vb, vo, nev)
  vo = vi_cat(vb, vo, " rules=" as *u8)
  vo = vi_catn(vb, vo, nru)
  vo = vi_cat(vb, vo, " bytes=" as *u8)
  vo = vi_catn(vb, vo, o)
  vo = vi_cat(vb, vo, " folded=" as *u8)
  vo = vi_catn(vb, vo, st[0])
  vo = vi_cat(vb, vo, "\n" as *u8)
  sys_write(1, vb, vo)
  return 0
488}
489
490// ================= IMPORT (RFC5545 .ics -> cal:/rec: records the calendar organ reads) =================
491
492func vi_find2(list: *i64, n: i64, s: *u8) -> i64 {
  var i: i64 = 0
  while i < n {
      if vi_eq(list[i] as *u8, s) == 1 { return i }
      i = i + 1
  }
  return 0 - 1
499}
500
501func vi_dup(s: *u8) -> *u8 {
  let n: i64 = vi_slen(s)
  let d: *u8 = sys_mmap(n + 2)
  var i: i64 = 0
  while i <= n { d[i] = s[i]; i = i + 1 }
  return d
507}
508
509// canon-store one record with CID dedup. st: 0=writer 1=seen 2=nseen 3=added 4=dupfile 5=dupstore 6=prefix
510func vi_put(keys: *i64, vals: *i64, nf: i64, kp: *u8, st: *i64) -> i64 {
  let enc: *u8 = sys_mmap(K_MAGIC_2048)
  let el: i64 = canon_encode(keys, vals, nf, enc)
  let cid: *u8 = sys_mmap(96)
  cid_of(enc, el, cid)
  let kbuf: *u8 = sys_mmap(128)
  var ko: i64 = 0
  ko = vi_cat(kbuf, ko, kp)
  ko = vi_cat(kbuf, ko, cid)
  kbuf[ko] = 0 as u8
  let seen: *i64 = st[1] as *i64
  var fresh: i64 = 1
  if vi_find2(seen, st[2], kbuf) >= 0 { fresh = 0; st[4] = st[4] + 1 }
  if fresh == 1 {
      if st[2] < K_MAGIC_2048 { let dk: *u8 = vi_dup(kbuf); seen[st[2]] = dk as i64; st[2] = st[2] + 1 }
  }
  if fresh == 1 {
      let pp: *i64 = sys_mmap(16) as *i64
      let ll: *i64 = sys_mmap(16) as *i64
      if ss_get_idx(st[6] as *u8, kbuf, pp, ll) == 1 { fresh = 0; st[5] = st[5] + 1 }
  }
  if fresh == 1 {
      if ss_add(st[0] as *i64, 1, kbuf, enc, el) != 0 { return 0 - 1 }
      st[3] = st[3] + 1
  }
  return 0
536}
537
538// unfold RFC5545 continuation lines (CRLF + leading space/tab -> joined) + strip CR. Returns new length.
539func vi_unfold(src: *u8, slen: i64, dst: *u8) -> i64 {
  var o: i64 = 0
  var i: i64 = 0
  while i < slen {
      let c: i64 = src[i] as i64
      if c == 13 {
          // skip CR
          i = i + 1
      } else {
          var join: i64 = 0
          if c == 32 { if o > 0 { if dst[o - 1] == (10 as u8) { join = 1 } } }
          if c == 9 { if o > 0 { if dst[o - 1] == (10 as u8) { join = 1 } } }
          if join == 1 { o = o - 1 } else { dst[o] = c as u8; o = o + 1 }
          i = i + 1
      }
  }
  return o
556}
557
558// if line[0,llen) starts with property `name` (followed by ':' or ';'), copy the value after the
559// first ':' into out (unescaped for TEXT). returns 1 if matched.
560func vi_prop(line: *u8, llen: i64, name: *u8, out: *u8, cap: i64) -> i64 {
  let nl: i64 = vi_slen(name)
  if nl > llen { return 0 }
  var j: i64 = 0
  while j < nl { if line[j] != name[j] { return 0 } j = j + 1 }
  if nl >= llen { return 0 }
  let after: i64 = line[nl] as i64
  if after != 58 { if after != 59 { return 0 } }   // ':' or ';'
  var col: i64 = nl
  while col < llen { if line[col] == (58 as u8) { break } col = col + 1 }
  if col >= llen { return 0 }
  var p: i64 = col + 1
  var t: i64 = 0
  while p < llen {
      var c: i64 = line[p] as i64
      if c == 92 {   // backslash unescape
          if p + 1 < llen {
              let nx: i64 = line[p + 1] as i64
              if nx == 110 { c = 10; p = p + 1 }       // \n
              if nx == 92 { c = 92; p = p + 1 }
              if nx == 59 { c = 59; p = p + 1 }
              if nx == 44 { c = 44; p = p + 1 }
          }
      }
      if t < cap - 1 { out[t] = c as u8; t = t + 1 }
      p = p + 1
  }
  out[t] = 0 as u8
  return 1
589}
590
591// "YYYYMMDDThhmmss" (or "YYYYMMDD") -> "YYYY-MM-DD" in datebuf, start-minute return. -1 if malformed.
592func vi_dtparse(v: *u8, datebuf: *u8) -> i64 {
  let n: i64 = vi_slen(v)
  if n < 8 { return 0 - 1 }
  var i: i64 = 0
  while i < 8 { let c: i64 = v[i] as i64; if c < 48 { return 0 - 1 } if c > 57 { return 0 - 1 } i = i + 1 }
  var o: i64 = 0
  datebuf[o] = v[0]; o = o + 1
  datebuf[o] = v[1]; o = o + 1
  datebuf[o] = v[2]; o = o + 1
  datebuf[o] = v[3]; o = o + 1
  datebuf[o] = 45 as u8; o = o + 1
  datebuf[o] = v[4]; o = o + 1
  datebuf[o] = v[5]; o = o + 1
  datebuf[o] = 45 as u8; o = o + 1
  datebuf[o] = v[6]; o = o + 1
  datebuf[o] = v[7]; o = o + 1
  datebuf[o] = 0 as u8
  if n >= 15 { if v[8] == (84 as u8) {   // 'T'
      let hh: i64 = ((v[9] as i64) - 48) * 10 + ((v[10] as i64) - 48)
      let mm: i64 = ((v[11] as i64) - 48) * 10 + ((v[12] as i64) - 48)
      return hh * 60 + mm
  } }
  return 0   // all-day -> midnight
615}
616
617// derive a sanitized id from a UID: take up to '@', strip a trailing "-<8 digits>", sanitize.
618func vi_idfromuid(uid: *u8, out: *u8, cap: i64) -> i64 {
  var n: i64 = 0
  while uid[n] != (0 as u8) { if uid[n] == (64 as u8) { break } n = n + 1 }   // stop at '@'
  // strip trailing "-DDDDDDDD"
  if n >= 9 {
      if uid[n - 9] == (45 as u8) {
          var alld: i64 = 1
          var k: i64 = n - 8
          while k < n { let c: i64 = uid[k] as i64; if c < 48 { alld = 0 } if c > 57 { alld = 0 } k = k + 1 }
          if alld == 1 { n = n - 9 }
      }
  }
  var t: i64 = 0
  var i: i64 = 0
  while i < n {
      let c: i64 = uid[i] as i64
      var ok: i64 = 0
      if c >= 48 { if c <= 57 { ok = 1 } }
      if c >= 65 { if c <= 90 { ok = 1 } }
      if c >= 97 { if c <= 122 { ok = 1 } }
      if c == 95 { ok = 1 }
      if c == 45 { ok = 1 }
      if t < cap - 1 {
          if ok == 1 { out[t] = c as u8 } else { out[t] = 45 as u8 }
          t = t + 1
      }
      i = i + 1
  }
  if t == 0 { out[0] = 105 as u8; out[1] = 109 as u8; out[2] = 112 as u8; t = 3 }   // "imp"
  out[t] = 0 as u8
  return 0
649}
650
651// parse RRULE value "FREQ=W;INTERVAL=1;COUNT=8" -> freq/interval/count buffers. 1 if FREQ present.
652func vi_rrparse(v: *u8, freq: *u8, ival: *u8, cnt: *u8) -> i64 {
  let n: i64 = vi_slen(v)
  freq[0] = 0 as u8
  ival[0] = 49 as u8; ival[1] = 0 as u8   // default INTERVAL=1
  cnt[0] = 49 as u8; cnt[1] = 0 as u8      // default COUNT=1 (bounded; UNTIL/infinite = later rung)
  var i: i64 = 0
  while i < n {
      var e: i64 = i
      while e < n { if v[e] == (59 as u8) { break } e = e + 1 }   // ';'
      // token [i,e) = K=V
      var eq: i64 = i
      while eq < e { if v[eq] == (61 as u8) { break } eq = eq + 1 }   // '='
      if eq < e {
          var dst: *u8 = 0 as *u8
          if vi_kmemeq(v, i, eq - i, "FREQ" as *u8) == 1 { dst = freq }
          if vi_kmemeq(v, i, eq - i, "INTERVAL" as *u8) == 1 { dst = ival }
          if vi_kmemeq(v, i, eq - i, "COUNT" as *u8) == 1 { dst = cnt }
          if (dst as i64) != 0 {
              var t: i64 = 0
              var p: i64 = eq + 1
              while p < e { dst[t] = v[p]; t = t + 1; p = p + 1 }
              dst[t] = 0 as u8
          }
      }
      i = e + 1
  }
  if freq[0] == (0 as u8) { return 0 }
  return 1
680}
681
682func vi_cmd_import(argc: i64, argv: *i64) -> i64 {
  if argc < 4 { vi_p("VIZSLA-ICS import needs <in.ics> <prefix> [segid] -- fail loud\n" as *u8); return 1 }
  let infile: *u8 = argv[2] as *u8
  let prefix: *u8 = argv[3] as *u8
  var segid: i64 = 0
  if argc > 4 { segid = vi_atoi(argv[4] as *u8) }
  if segid == 0 { segid = sys_now_us() }
689
  let szp: *i64 = sys_mmap(16) as *i64
  let raw: *u8 = ss_readall(infile, szp)
  let rsz: i64 = szp[0]
  if rsz <= 0 { vi_p("VIZSLA-ICS import file MISSING/EMPTY -- fail loud\n" as *u8); return 1 }
  let buf: *u8 = sys_mmap(rsz + 64)
  let bn: i64 = vi_unfold(raw, rsz, buf)
696
  let ckeys: *i64 = sys_mmap(8 * 8) as *i64
  let cvals: *i64 = sys_mmap(8 * 8) as *i64
  ckeys[0] = "kind" as *u8 as i64
  ckeys[1] = "id" as *u8 as i64
  ckeys[2] = "date" as *u8 as i64
  ckeys[3] = "start" as *u8 as i64
  ckeys[4] = "dur" as *u8 as i64
  ckeys[5] = "title" as *u8 as i64
  cvals[0] = "cal" as *u8 as i64
  let rkeys: *i64 = sys_mmap(8 * 12) as *i64
  let rvals: *i64 = sys_mmap(8 * 12) as *i64
  rkeys[0] = "kind" as *u8 as i64
  rkeys[1] = "id" as *u8 as i64
  rkeys[2] = "sdate" as *u8 as i64
  rkeys[3] = "start" as *u8 as i64
  rkeys[4] = "dur" as *u8 as i64
  rkeys[5] = "freq" as *u8 as i64
  rkeys[6] = "interval" as *u8 as i64
  rkeys[7] = "count" as *u8 as i64
  rkeys[8] = "title" as *u8 as i64
  rvals[0] = "rec" as *u8 as i64
718
  let st: *i64 = sys_mmap(8 * 8) as *i64
  st[0] = ss_begin() as i64
  st[1] = sys_mmap(8 * K_MAGIC_2048)
  st[2] = 0
  st[3] = 0
  st[4] = 0
  st[5] = 0
  st[6] = prefix as i64
727
  let uid: *u8 = sys_mmap(512)
  let vds: *u8 = sys_mmap(256)
  let vde: *u8 = sys_mmap(256)
  let summ: *u8 = sys_mmap(K_MAGIC_1024)
  let rrule: *u8 = sys_mmap(512)
  let sdate: *u8 = sys_mmap(64)
  let edate: *u8 = sys_mmap(64)
  let idb: *u8 = sys_mmap(256)
  let startb: *u8 = sys_mmap(32)
  let durb: *u8 = sys_mmap(32)
  let freq: *u8 = sys_mmap(64)
  let ival: *u8 = sys_mmap(64)
  let cnt: *u8 = sys_mmap(64)
  var inev: i64 = 0
  var nev: i64 = 0
  var nru: i64 = 0
744
  var i: i64 = 0
  while i < bn {
      var e: i64 = i
      var go: i64 = 1
      while go == 1 { if e >= bn { go = 0 } else { if buf[e] == (10 as u8) { go = 0 } else { e = e + 1 } } }
      let line: *u8 = (buf as i64 + i) as *u8
      let llen: i64 = e - i
      if vi_kmemeq(line, 0, llen, "BEGIN:VEVENT" as *u8) == 1 {
          inev = 1
          uid[0] = 0 as u8; vds[0] = 0 as u8; vde[0] = 0 as u8; summ[0] = 0 as u8; rrule[0] = 0 as u8
      } else {
          if vi_kmemeq(line, 0, llen, "END:VEVENT" as *u8) == 1 {
              if inev == 1 {
                  if vds[0] != (0 as u8) {
                      let smin: i64 = vi_dtparse(vds, sdate)
                      if smin >= 0 { if vi_datedays(sdate) >= 0 {
                          vi_idfromuid(uid, idb, 256)
                          var so: i64 = 0
                          so = vi_catn(startb, 0, smin); startb[so] = 0 as u8
                          var dur: i64 = 60
                          if vde[0] != (0 as u8) {
                              let emin: i64 = vi_dtparse(vde, edate)
                              if emin > smin { dur = emin - smin }
                          }
                          var duo: i64 = 0
                          duo = vi_catn(durb, 0, dur); durb[duo] = 0 as u8
                          var ttl: *u8 = summ
                          if summ[0] == (0 as u8) { ttl = "untitled" as *u8 }
                          if rrule[0] != (0 as u8) {
                              if vi_rrparse(rrule, freq, ival, cnt) == 1 {
                                  rvals[1] = idb as i64
                                  rvals[2] = sdate as i64
                                  rvals[3] = startb as i64
                                  rvals[4] = durb as i64
                                  rvals[5] = freq as i64
                                  rvals[6] = ival as i64
                                  rvals[7] = cnt as i64
                                  rvals[8] = ttl as i64
                                  if vi_put(rkeys, rvals, 9, "rec:" as *u8, st) != 0 { vi_p("VIZSLA-ICS import writer full -- fail loud\n" as *u8); return 1 }
                                  nru = nru + 1
                              }
                          } else {
                              cvals[1] = idb as i64
                              cvals[2] = sdate as i64
                              cvals[3] = startb as i64
                              cvals[4] = durb as i64
                              cvals[5] = ttl as i64
                              if vi_put(ckeys, cvals, 6, "cal:" as *u8, st) != 0 { vi_p("VIZSLA-ICS import writer full -- fail loud\n" as *u8); return 1 }
                              nev = nev + 1
                          }
                      } }
                  }
              }
              inev = 0
          } else {
              if inev == 1 {
                  vi_prop(line, llen, "UID" as *u8, uid, 512)
                  vi_prop(line, llen, "DTSTART" as *u8, vds, 256)
                  vi_prop(line, llen, "DTEND" as *u8, vde, 256)
                  vi_prop(line, llen, "SUMMARY" as *u8, summ, K_MAGIC_1024)
                  vi_prop(line, llen, "RRULE" as *u8, rrule, 512)
              }
          }
      }
      i = e + 1
  }
811
  var committed: i64 = 0
  if st[3] > 0 {
      if ss_commit(prefix, st[0] as *i64, segid) != 0 { vi_p("VIZSLA-ICS import commit FAILED -- fail loud\n" as *u8); return 1 }
      committed = 1
  }
817
  let rep: *u8 = sys_mmap(K_MAGIC_1024)
  var o: i64 = 0
  o = vi_cat(rep, o, "VIZSLA-ICS-IMPORT events=" as *u8)
  o = vi_catn(rep, o, nev)
  o = vi_cat(rep, o, " rules=" as *u8)
  o = vi_catn(rep, o, nru)
  o = vi_cat(rep, o, " new=" as *u8)
  o = vi_catn(rep, o, st[3])
  o = vi_cat(rep, o, " dup_instore=" as *u8)
  o = vi_catn(rep, o, st[5])
  o = vi_cat(rep, o, " segment=" as *u8)
  if committed == 1 {
      o = vi_cat(rep, o, "seg-" as *u8)
      o = vi_catn(rep, o, segid)
  } else {
      o = vi_cat(rep, o, "none" as *u8)
  }
  o = vi_cat(rep, o, "\n" as *u8)
  sys_write(1, rep, o)
  return 0
838}
839
840func main(argc: i64, argv: *i64) -> i64 {
  if argc < 2 { vi_p("VIZSLA-ICS usage: export <prefix> <from> <to> <out.ics> | import <in.ics> <prefix> [segid] -- fail loud\n" as *u8); return 1 }
  let cmd: *u8 = argv[1] as *u8
  if vi_eq(cmd, "export" as *u8) == 1 { return vi_cmd_export(argc, argv) }
  if vi_eq(cmd, "import" as *u8) == 1 { return vi_cmd_import(argc, argv) }
  vi_p("VIZSLA-ICS unknown command (export|import) -- fail loud\n" as *u8)
  return 1
847}
nx_vizsla_ics.nx source

`nx_vizsla_ics.nx` source
