code wiki / (root) / nx_licdetect_gate.nx
`nx_licdetect_gate.nx` source

↩ module page · 138 lines · 7930 B
1// nx_licdetect_gate.nx -- GATE for nx_licdetect_lib.
2//
3// The load-bearing tooth reads a REAL LICENCE TEXT WE HOLD (the Anny Apache-2.0 file mirrored from
4// raw.githubusercontent.com with its own provenance row and pin), not a synthetic fixture. A detector
5// proven only against text the test author wrote is proven against the author's idea of the licence.
6// If that mirror is missing the tooth reports a MISSING PRECONDITION and the gate SKIPs -- "I could
7// not look" must never arrive in the same word as "I looked and it passed".
8// license_tier: ORIGINAL
9import "nx_syscalls.nx"
10import "nx_gate_verdict.nx"
11import "nx_licdetect_lib.nx"
12
13func ldg_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
14
15// detect over a NUL-terminated literal, and compare the winning id to a wanted string.
16func ldg_is(ctx: *i64, text: *u8, want: *u8) -> i64 {
  let out: *i64 = sys_mmap(32) as *i64
  let r: i64 = ld_detect(ctx, text, ldg_len(text), out)
  if r != LD_DETECTED { return 0 }
  let buf: *u8 = ctx[0] as *u8
  let wn: i64 = ldg_len(want)
  if out[1] != wn { return 0 }
  var i: i64 = 0
  while i < wn { if buf[out[0] + i] != want[i] { return 0 } i = i + 1 }
  return 1
26}
27
28func ldg_code(ctx: *i64, text: *u8) -> i64 {
  let out: *i64 = sys_mmap(32) as *i64
  return ld_detect(ctx, text, ldg_len(text), out)
31}
32
33func main(argc: i64, argv: *i64) -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("=== nx_licdetect_gate: which licence is this TEXT, read from bytes not declarations ===" as *u8)
36
  let ctx: *i64 = ld_ctx()
  gv_check("marker-table-loads" as *u8, (ctx[3] > 0) as i64, ctr)
39
  // ---- THE LOAD-BEARING TOOTH: a real Apache-2.0 licence text from our own library ----
  let lp: *i64 = sys_mmap(16) as *i64
  let real: *u8 = sys_read_file("knowledge/fetched/cmp_librarian_anny_LICENSE.txt" as *u8, lp)
  var have_real: i64 = 0
  if (real as i64) != 0 { if lp[0] > 0 { have_real = 1 } }
  gv_need("precondition-real-apache-licence-mirror-is-held" as *u8, have_real, ctr)
  if have_real == 1 {
      let out: *i64 = sys_mmap(32) as *i64
      let r: i64 = ld_detect(ctx, real, lp[0], out)
      gv_check("REAL-held-apache-licence-text-DETECTS" as *u8, (r == LD_DETECTED) as i64, ctr)
      let buf: *u8 = ctx[0] as *u8
      var isap: i64 = 0
      if r == LD_DETECTED {
          if out[1] == 10 {
              if buf[out[0]] == (97 as u8) { isap = 1 }
          }
      }
      gv_check("REAL-held-licence-detects-as-apache-2.0-ten-chars-starting-a" as *u8, isap, ctr)
      // The mirrored text is 10875 B against the canonical 11358 B -- it adds a NAVER copyright
      // preamble and omits the APPENDIX. A detector keyed on the file's SIZE or its first line would
      // miss it; keying on definitional phrases inside the reproduced terms does not.
      gv_check("detection-survives-a-preamble-and-a-missing-appendix" as *u8, (r == LD_DETECTED) as i64, ctr)
  }
63
  // ---- the marker table is held to its own evidence discipline ----
  // apache-2.0 has a V row naming the held text above; mit does not, and that must READ as unverified
  // rather than being quietly presented as equally proven.
  let cbuf: *u8 = ctx[0] as *u8
  let rows: *i64 = ctx[2] as *i64
  var ap_lo: i64 = 0 - 1
  var ap_ll: i64 = 0
  var mit_lo: i64 = 0 - 1
  var mit_ll: i64 = 0
  var i: i64 = 0
  while i < ctx[3] {
      let lo: i64 = rows[i * LD_ROW_STRIDE + 0]
      let ll: i64 = rows[i * LD_ROW_STRIDE + 1]
      if ll == 10 { if cbuf[lo] == (97 as u8) { ap_lo = lo; ap_ll = ll } }
      if ll == 3 { if cbuf[lo] == (109 as u8) { mit_lo = lo; mit_ll = ll } }
      i = i + 1
  }
  gv_check("apache-marker-set-is-VERIFIED-against-a-licence-we-hold" as *u8,
      ld_marker_set_verified(ctx, ap_lo, ap_ll), ctr)
  gv_check("mit-marker-set-is-honestly-UNVERIFIED-no-held-text-yet" as *u8,
      (ld_marker_set_verified(ctx, mit_lo, mit_ll) == 0) as i64, ctr)
85
  // ---- synthetic texts for the paths no held licence covers yet ----
  gv_check("mit-text-detects-mit" as *u8,
      ldg_is(ctx, "MIT License. Permission is hereby granted, free of charge, to any person obtaining a copy. THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND." as *u8, "mit" as *u8), ctr)
  gv_check("gpl3-text-detects-gpl-3.0" as *u8,
      ldg_is(ctx, "GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Everyone is permitted to copy." as *u8, "gpl-3.0" as *u8), ctr)
91
  // ---- fail-closed: nothing matched is UNKNOWN, never a nearest guess ----
  gv_check("prose-with-no-licence-markers-is-UNKNOWN" as *u8,
      (ldg_code(ctx, "This repository contains research code for a 3D human body model and some notes." as *u8) == LD_UNKNOWN) as i64, ctr)
  gv_check("empty-text-is-UNKNOWN" as *u8, (ldg_code(ctx, "" as *u8) == LD_UNKNOWN) as i64, ctr)
  // A README that merely NAMES a licence is a DECLARATION, not the licence text. It must not detect.
  gv_check("a-readme-merely-naming-apache-2.0-does-NOT-detect" as *u8,
      (ldg_code(ctx, "This project is released under the Apache 2.0 license. See LICENSE for details." as *u8) == LD_UNKNOWN) as i64, ctr)
99
  // ---- exclusions: the markers that stop one licence being read as another ----
  // AGPL text contains the words GNU GENERAL PUBLIC LICENSE in its own prose, so without the AFFERO
  // exclusion every AGPL file would match GPL-3.0 too and the result would be AMBIGUOUS at best.
  gv_check("agpl-text-detects-agpl-not-gpl3" as *u8,
      ldg_is(ctx, "GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007 based on the GNU GENERAL PUBLIC LICENSE" as *u8, "agpl-3.0" as *u8), ctr)
105
  // ---- ambiguity is a REFUSAL, not a tie to break ----
  let amb: *u8 = "Attribution-NonCommercial 4.0 International and also Attribution-ShareAlike 4.0 International" as *u8
  gv_check("text-matching-two-licences-is-AMBIGUOUS" as *u8, (ldg_code(ctx, amb) == LD_AMBIGUOUS) as i64, ctr)
  // and the winner is CLEARED, so a caller cannot read an id out of an ambiguous result by ignoring
  // the return code -- the commonest way a three-state answer degrades into a two-state one.
  let ambout: *i64 = sys_mmap(32) as *i64
  ld_detect(ctx, amb, ldg_len(amb), ambout)
  gv_check("AMBIGUOUS-clears-the-winner-so-it-cannot-be-read-anyway" as *u8, (ambout[0] == (0 - 1)) as i64, ctr)
114
  // ================= BITE-PROVEN NEGATIVE CONTROLS =================
  var b1_bad: i64 = 0
  var b1_good: i64 = 0
  if have_real == 1 {
      let o2: *i64 = sys_mmap(32) as *i64
      if ld_detect(ctx, real, lp[0], o2) == LD_DETECTED { b1_bad = 1 }
  }
  if ldg_code(ctx, "This repository contains research code for a 3D human body model and some notes." as *u8) == LD_DETECTED { b1_good = 1 }
  gv_bite("neg-control-a-real-licence-text-DETECTS-and-ordinary-prose-does-not" as *u8, b1_bad, b1_good, ctr)
124
  var b2_bad: i64 = 0
  var b2_good: i64 = 0
  if ldg_is(ctx, "GNU AFFERO GENERAL PUBLIC LICENSE Version 3, 19 November 2007 based on the GNU GENERAL PUBLIC LICENSE" as *u8, "gpl-3.0" as *u8) == 0 { b2_bad = 1 }
  if ldg_is(ctx, "GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Everyone is permitted to copy." as *u8, "gpl-3.0" as *u8) == 0 { b2_good = 1 }
  gv_bite("neg-control-affero-exclusion-blocks-gpl3-on-agpl-text-but-not-on-gpl-text" as *u8, b2_bad, b2_good, ctr)
130
  var b3_bad: i64 = 0
  var b3_good: i64 = 0
  if ldg_code(ctx, amb) == LD_AMBIGUOUS { b3_bad = 1 }
  if ldg_code(ctx, "Attribution-ShareAlike 4.0 International" as *u8) == LD_AMBIGUOUS { b3_good = 1 }
  gv_bite("neg-control-two-licences-go-AMBIGUOUS-and-a-single-one-does-not" as *u8, b3_bad, b3_good, ctr)
136
  return gv_verdict("LICDETECT-GATE" as *u8, ctr, "a licence is read from its TEXT, a declaration never detects, and both nothing-matched and two-matched refuse" as *u8)
138}
nx_licdetect_gate.nx source

`nx_licdetect_gate.nx` source
