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

↩ module page · 941 lines · 35833 B
1// nx_chem_smiles.nx -- C2.1 + C2.2 milestones: basic SMILES parser.
2//
3// Parses the organic-subset SMILES grammar (Daylight 1988 / OpenSMILES
4// 2016) into the MolGraph type from nx_chem_molecule.nx.  Memory-safe
5// by construction: every read is bounded against the input length;
6// every error path sets is_valid=0 + structured err_code + err_pos.
7//
8// Supported (C2.1 + C2.2):
9//   - Organic-subset aliphatic atoms outside brackets: B, C, N, O, P, S, F, Cl, Br, I
10//   - Aromatic lowercase atoms outside brackets: b, c, n, o, p, s
11//   - Wildcard: *
12//   - **Full 118-element bracket atoms** (C2.2): H..Og, all IUPAC element symbols
13//   - Bracket attributes:
14//       isotope     -- leading digits, e.g. [13C]
15//       chirality   -- @ (CCW) or @@ (CW) on atom; stored in Atom.stereo (C2.2)
16//       H count     -- H[count], e.g. [CH4], [NH4+]
17//       charge      -- +, -, ++, --, +n, -n
18//       atom map    -- :n, stored in Atom.map_num (C2.2)
19//   - Bond types: -, =, #, :, .  (default = single between aliphatic, aromatic between two aromatics)
20//   - **Bond stereo: /, \\** -- stored in Bond.stereo as NX_BSTEREO_UP/DOWN (C2.2)
21//   - Branches: ( and )
22//   - **Ring closures: 0..9 + %nn (two-digit, 00..99)** (C2.2)
23//
24// Honest gaps (deferred to C2.3+):
25//   - E/Z resolution from /, \\ (C2.1 stores raw UP/DOWN; CIP-rule resolution is C2.3)
26//   - Atropisomer + enhanced-stereo (C2.4)
27//   - Implicit-H valence inference (C2.3 -- h_count stays -1 for non-bracket atoms)
28//   - 6-aromaticity-tuple model dispatch (C2.5 -- this milestone sets one Daylight bit; tuple slot present)
29//   - Canonical SMILES output (C2.3)
30//   - Fuzzer 10^9 harness (C2.9)
31//
32// EXCEED axes hit (landscape doc references):
33//   E2  -- memory-safe parser by construction (bounded buffer reads + structured error paths)
34//   E4  -- per-atom + per-bond stereo slots populated from SMILES input (C2.2)
35//   E7  -- first-class radicals + charges + isotopes + full 118-element bracket support
36//   E11 -- no format lock-in (output is native MolGraph)
37//
38// nx_safety_envelope:
39//   intended_use:       SMILES -> MolGraph parser for cheminformatics pipeline
40//   sil_target:         SIL1
41//   evidence:           [C2.1 + C2.2 KAT in nx_chem_smiles_test.nx; bounded buffer arithmetic; structured error codes]
42//   verdict:            BENCH-PENDING
43
44import "nx_kernel_v2.nx"
45import "nx_chem_molecule.nx"
46
47// =================================================================
48// ASCII code constants (NishiLang has no char literals).
49// =================================================================
50const NX_C_0:        nx_int = 0x30
51const NX_C_9:        nx_int = 0x39
52const NX_C_A_UP:     nx_int = 0x41
53const NX_C_Z_UP:     nx_int = 0x5A
54const NX_C_A_LO:     nx_int = 0x61
55const NX_C_Z_LO:     nx_int = 0x7A
56const NX_C_LBRACKET: nx_int = 0x5B
57const NX_C_RBRACKET: nx_int = 0x5D
58const NX_C_LPAREN:   nx_int = 0x28
59const NX_C_RPAREN:   nx_int = 0x29
60const NX_C_PLUS:     nx_int = 0x2B
61const NX_C_MINUS:    nx_int = 0x2D
62const NX_C_EQ:       nx_int = 0x3D
63const NX_C_HASH:     nx_int = 0x23
64const NX_C_COLON:    nx_int = 0x3A
65const NX_C_DOT:      nx_int = 0x2E
66const NX_C_SLASH:    nx_int = 0x2F
67const NX_C_BSLASH:   nx_int = 0x5C
68const NX_C_STAR:     nx_int = 0x2A
69const NX_C_AT:       nx_int = 0x40
70const NX_C_PCT:      nx_int = 0x25
71const NX_C_H_UP:     nx_int = 0x48
72const NX_C_B_UP:     nx_int = 0x42
73const NX_C_C_UP:     nx_int = 0x43
74const NX_C_N_UP:     nx_int = 0x4E
75const NX_C_O_UP:     nx_int = 0x4F
76const NX_C_F_UP:     nx_int = 0x46
77const NX_C_P_UP:     nx_int = 0x50
78const NX_C_S_UP:     nx_int = 0x53
79const NX_C_I_UP:     nx_int = 0x49
80const NX_C_K_UP:     nx_int = 0x4B
81const NX_C_B_LO:     nx_int = 0x62
82const NX_C_C_LO:     nx_int = 0x63
83const NX_C_N_LO:     nx_int = 0x6E
84const NX_C_O_LO:     nx_int = 0x6F
85const NX_C_P_LO:     nx_int = 0x70
86const NX_C_S_LO:     nx_int = 0x73
87const NX_C_L_LO:     nx_int = 0x6C
88const NX_C_R_LO:     nx_int = 0x72
89
90// =================================================================
91// Single-char digit / alpha tests.
92// =================================================================
93func smi_is_digit(c: nx_int) -> nx_int {
  if c < NX_C_0 { return 0 }
  if c > NX_C_9 { return 0 }
  return 1
97}
98
99func smi_is_upper(c: nx_int) -> nx_int {
  if c < NX_C_A_UP { return 0 }
  if c > NX_C_Z_UP { return 0 }
  return 1
103}
104
105func smi_is_lower(c: nx_int) -> nx_int {
  if c < NX_C_A_LO { return 0 }
  if c > NX_C_Z_LO { return 0 }
  return 1
109}
110
111// =================================================================
112// Full IUPAC 118-element two-char symbol -> Z.  Returns 0 if not a
113// valid two-char element symbol.  Caller falls back to single-char
114// lookup if this returns 0.
115// =================================================================
116func smi_bracket_symbol_two_char(c1: nx_int, c2: nx_int) -> nx_int {
  if c1 == 0x41 {
      if c2 == 0x63 { return 89 }   // Ac
      if c2 == 0x67 { return 47 }   // Ag
      if c2 == 0x6C { return 13 }   // Al
      if c2 == 0x6D { return 95 }   // Am
      if c2 == 0x72 { return 18 }   // Ar
      if c2 == 0x73 { return 33 }   // As
      if c2 == 0x74 { return 85 }   // At
      if c2 == 0x75 { return 79 }   // Au
      return 0
  }
  if c1 == 0x42 {
      if c2 == 0x61 { return 56 }   // Ba
      if c2 == 0x65 { return 4 }    // Be
      if c2 == 0x68 { return 107 }  // Bh
      if c2 == 0x69 { return 83 }   // Bi
      if c2 == 0x6B { return 97 }   // Bk
      if c2 == 0x72 { return 35 }   // Br
      return 0
  }
  if c1 == 0x43 {
      if c2 == 0x61 { return 20 }   // Ca
      if c2 == 0x64 { return 48 }   // Cd
      if c2 == 0x65 { return 58 }   // Ce
      if c2 == 0x66 { return 98 }   // Cf
      if c2 == 0x6C { return 17 }   // Cl
      if c2 == 0x6D { return 96 }   // Cm
      if c2 == 0x6E { return 112 }  // Cn
      if c2 == 0x6F { return 27 }   // Co
      if c2 == 0x72 { return 24 }   // Cr
      if c2 == 0x73 { return 55 }   // Cs
      if c2 == 0x75 { return 29 }   // Cu
      return 0
  }
  if c1 == 0x44 {
      if c2 == 0x62 { return 105 }  // Db
      if c2 == 0x73 { return 110 }  // Ds
      if c2 == 0x79 { return 66 }   // Dy
      return 0
  }
  if c1 == 0x45 {
      if c2 == 0x72 { return 68 }   // Er
      if c2 == 0x73 { return 99 }   // Es
      if c2 == 0x75 { return 63 }   // Eu
      return 0
  }
  if c1 == 0x46 {
      if c2 == 0x65 { return 26 }   // Fe
      if c2 == 0x6C { return 114 }  // Fl
      if c2 == 0x6D { return 100 }  // Fm
      if c2 == 0x72 { return 87 }   // Fr
      return 0
  }
  if c1 == 0x47 {
      if c2 == 0x61 { return 31 }   // Ga
      if c2 == 0x64 { return 64 }   // Gd
      if c2 == 0x65 { return 32 }   // Ge
      return 0
  }
  if c1 == 0x48 {
      if c2 == 0x65 { return 2 }    // He
      if c2 == 0x66 { return 72 }   // Hf
      if c2 == 0x67 { return 80 }   // Hg
      if c2 == 0x6F { return 67 }   // Ho
      if c2 == 0x73 { return 108 }  // Hs
      return 0
  }
  if c1 == 0x49 {
      if c2 == 0x6E { return 49 }   // In
      if c2 == 0x72 { return 77 }   // Ir
      return 0
  }
  if c1 == 0x4B {
      if c2 == 0x72 { return 36 }   // Kr
      return 0
  }
  if c1 == 0x4C {
      if c2 == 0x61 { return 57 }   // La
      if c2 == 0x69 { return 3 }    // Li
      if c2 == 0x72 { return 103 }  // Lr
      if c2 == 0x75 { return 71 }   // Lu
      if c2 == 0x76 { return 116 }  // Lv
      return 0
  }
  if c1 == 0x4D {
      if c2 == 0x63 { return 115 }  // Mc
      if c2 == 0x64 { return 101 }  // Md
      if c2 == 0x67 { return 12 }   // Mg
      if c2 == 0x6E { return 25 }   // Mn
      if c2 == 0x6F { return 42 }   // Mo
      if c2 == 0x74 { return 109 }  // Mt
      return 0
  }
  if c1 == 0x4E {
      if c2 == 0x61 { return 11 }   // Na
      if c2 == 0x62 { return 41 }   // Nb
      if c2 == 0x64 { return 60 }   // Nd
      if c2 == 0x65 { return 10 }   // Ne
      if c2 == 0x68 { return 113 }  // Nh
      if c2 == 0x69 { return 28 }   // Ni
      if c2 == 0x6F { return 102 }  // No
      if c2 == 0x70 { return 93 }   // Np
      return 0
  }
  if c1 == 0x4F {
      if c2 == 0x67 { return 118 }  // Og
      if c2 == 0x73 { return 76 }   // Os
      return 0
  }
  if c1 == 0x50 {
      if c2 == 0x61 { return 91 }   // Pa
      if c2 == 0x62 { return 82 }   // Pb
      if c2 == 0x64 { return 46 }   // Pd
      if c2 == 0x6D { return 61 }   // Pm
      if c2 == 0x6F { return 84 }   // Po
      if c2 == 0x72 { return 59 }   // Pr
      if c2 == 0x74 { return 78 }   // Pt
      if c2 == 0x75 { return 94 }   // Pu
      return 0
  }
  if c1 == 0x52 {
      if c2 == 0x61 { return 88 }   // Ra
      if c2 == 0x62 { return 37 }   // Rb
      if c2 == 0x65 { return 75 }   // Re
      if c2 == 0x66 { return 104 }  // Rf
      if c2 == 0x67 { return 111 }  // Rg
      if c2 == 0x68 { return 45 }   // Rh
      if c2 == 0x6E { return 86 }   // Rn
      if c2 == 0x75 { return 44 }   // Ru
      return 0
  }
  if c1 == 0x53 {
      if c2 == 0x62 { return 51 }   // Sb
      if c2 == 0x63 { return 21 }   // Sc
      if c2 == 0x65 { return 34 }   // Se
      if c2 == 0x67 { return 106 }  // Sg
      if c2 == 0x69 { return 14 }   // Si
      if c2 == 0x6D { return 62 }   // Sm
      if c2 == 0x6E { return 50 }   // Sn
      if c2 == 0x72 { return 38 }   // Sr
      return 0
  }
  if c1 == 0x54 {
      if c2 == 0x61 { return 73 }   // Ta
      if c2 == 0x62 { return 65 }   // Tb
      if c2 == 0x63 { return 43 }   // Tc
      if c2 == 0x65 { return 52 }   // Te
      if c2 == 0x68 { return 90 }   // Th
      if c2 == 0x69 { return 22 }   // Ti
      if c2 == 0x6C { return 81 }   // Tl
      if c2 == 0x6D { return 69 }   // Tm
      if c2 == 0x73 { return 117 }  // Ts
      return 0
  }
  if c1 == 0x58 {
      if c2 == 0x65 { return 54 }   // Xe
      return 0
  }
  if c1 == 0x59 {
      if c2 == 0x62 { return 70 }   // Yb
      return 0
  }
  if c1 == 0x5A {
      if c2 == 0x6E { return 30 }   // Zn
      if c2 == 0x72 { return 40 }   // Zr
      return 0
  }
  return 0
285}
286
287// =================================================================
288// Single-char element symbol -> Z (14 elements).
289// =================================================================
290func smi_bracket_symbol_single_char(c1: nx_int) -> nx_int {
  if c1 == NX_C_H_UP { return 1 }    // H
  if c1 == NX_C_B_UP { return 5 }    // B
  if c1 == NX_C_C_UP { return 6 }    // C
  if c1 == NX_C_N_UP { return 7 }    // N
  if c1 == NX_C_O_UP { return 8 }    // O
  if c1 == NX_C_F_UP { return 9 }    // F
  if c1 == NX_C_P_UP { return 15 }   // P
  if c1 == NX_C_S_UP { return 16 }   // S
  if c1 == NX_C_K_UP { return 19 }   // K
  if c1 == 0x56 { return 23 }        // V
  if c1 == 0x59 { return 39 }        // Y
  if c1 == NX_C_I_UP { return 53 }   // I
  if c1 == 0x57 { return 74 }        // W
  if c1 == 0x55 { return 92 }        // U
  return 0
306}
307
308// =================================================================
309// Lowercase aromatic atom (single char only) -> Z, or 0 if not aromatic.
310// =================================================================
311func smi_aromatic_lower_to_z(c: nx_int) -> nx_int {
  if c == NX_C_B_LO { return 5 }   // b
  if c == NX_C_C_LO { return 6 }   // c
  if c == NX_C_N_LO { return 7 }   // n
  if c == NX_C_O_LO { return 8 }   // o
  if c == NX_C_P_LO { return 15 }  // p
  if c == NX_C_S_LO { return 16 }  // s
  return 0
319}
320
321// =================================================================
322// Outside-bracket organic-subset atom recognizer.
323// Reads at most 2 chars; returns z + consumed length (1 or 2) via out
324// pointer.  Returns 0 (z) if char doesn't start a known organic-subset
325// atom.
326// =================================================================
327func smi_organic_atom(c1: nx_int, c2: nx_int, consumed_out: *nx_int) -> nx_int {
  // Two-char: Cl, Br
  if c1 == NX_C_C_UP {
      if c2 == NX_C_L_LO { consumed_out[0] = 2; return 17 }  // Cl
      consumed_out[0] = 1; return 6                          // C
  }
  if c1 == NX_C_B_UP {
      if c2 == NX_C_R_LO { consumed_out[0] = 2; return 35 }  // Br
      consumed_out[0] = 1; return 5                          // B
  }
  if c1 == NX_C_N_UP { consumed_out[0] = 1; return 7 }       // N
  if c1 == NX_C_O_UP { consumed_out[0] = 1; return 8 }       // O
  if c1 == NX_C_F_UP { consumed_out[0] = 1; return 9 }       // F
  if c1 == NX_C_P_UP { consumed_out[0] = 1; return 15 }      // P
  if c1 == NX_C_S_UP { consumed_out[0] = 1; return 16 }      // S
  if c1 == NX_C_I_UP { consumed_out[0] = 1; return 53 }      // I
  consumed_out[0] = 0
  return 0
345}
346
347// =================================================================
348// Parse a bracket atom starting at src[pos] = '['.  Advances pos to
349// one past the closing ']'.  Returns 1 on success, 0 on failure (and
350// sets is_valid + err_code on m).
351//
352// Grammar (C2.2):
353//   '[' <isotope-digits>? Symbol <'@'|'@@'>? <H><h-digits>? (<+|-> <digits|+|->*)? (:<digits>)? ']'
354// =================================================================
355func smi_parse_bracket(
  src: *u8, n: nx_int, pos_io: *nx_int,
  m: *MolGraph,
  out_z: *nx_int, out_iso: *nx_int, out_h: *nx_int, out_charge: *nx_int,
  out_stereo: *nx_int, out_map: *nx_int, out_aromatic: *nx_int
360) -> nx_int {
  var pos: nx_int = pos_io[0]
  // Skip leading '['
  pos = pos + 1
  // ---- isotope (leading digits) ----
  var iso: nx_int = 0
  while pos < n {
      let cc: nx_int = src[pos] & 0xff
      if smi_is_digit(cc) == 0 { break }
      iso = (iso * 10) + (cc - NX_C_0)
      pos = pos + 1
  }
  if pos >= n {
      m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_UNCLOSED_BR; m.err_pos = pos
      return 0
  }
  // ---- element symbol (uppercase + optional lowercase, or single lowercase for aromatic) ----
  let c1: nx_int = src[pos] & 0xff
  var z: nx_int = 0
  var arom_bracket: nx_int = 0
  var handled: nx_int = 0
  if smi_is_upper(c1) == 1 {
      var c2: nx_int = 0
      if (pos + 1) < n {
          c2 = src[pos + 1] & 0xff
          if smi_is_lower(c2) == 0 { c2 = 0 }
      }
      if c2 != 0 {
          z = smi_bracket_symbol_two_char(c1, c2)
          if z != 0 { pos = pos + 2 }
      }
      if z == 0 {
          z = smi_bracket_symbol_single_char(c1)
          if z != 0 { pos = pos + 1 }
      }
      if z == 0 {
          m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_INVALID_BR; m.err_pos = pos
          return 0
      }
      handled = 1
  }
  if handled == 0 {
      if smi_is_lower(c1) == 1 {
          z = smi_aromatic_lower_to_z(c1)
          if z == 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_INVALID_BR; m.err_pos = pos
              return 0
          }
          arom_bracket = 1
          pos = pos + 1
          handled = 1
      }
  }
  if handled == 0 {
      if c1 == NX_C_STAR {
          z = 0   // wildcard atom
          pos = pos + 1
          handled = 1
      }
  }
  if handled == 0 {
      m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos
      return 0
  }
  // ---- chirality marker @ or @@ -- now POPULATED into Atom.stereo (C2.2) ----
  var stereo_count: nx_int = 0
  while pos < n {
      let cc: nx_int = src[pos] & 0xff
      if cc != NX_C_AT { break }
      stereo_count = stereo_count + 1
      pos = pos + 1
  }
  var stereo_val: nx_int = NX_STEREO_NONE
  if stereo_count == 1 { stereo_val = NX_STEREO_CCW }
  if stereo_count == 2 { stereo_val = NX_STEREO_CW }
  // ---- H count: H or H<n> ----
  // Per OpenSMILES 3.1.3: bracket atoms with no H specifier have h_count = 0
  // (brackets are fully explicit). Default 0; bumped to 1+ if H seen.
  var h: nx_int = 0
  if pos < n {
      let cc: nx_int = src[pos] & 0xff
      if cc == NX_C_H_UP {
          pos = pos + 1
          h = 1   // [CH] = 1 hydrogen by default
          if pos < n {
              let nc: nx_int = src[pos] & 0xff
              if smi_is_digit(nc) == 1 {
                  h = 0
                  while pos < n {
                      let dd: nx_int = src[pos] & 0xff
                      if smi_is_digit(dd) == 0 { break }
                      h = (h * 10) + (dd - NX_C_0)
                      pos = pos + 1
                  }
              }
          }
      }
  }
  // ---- charge: + or - optionally followed by digits ----
  var charge: nx_int = 0
  if pos < n {
      let cc: nx_int = src[pos] & 0xff
      if cc == NX_C_PLUS {
          pos = pos + 1
          charge = 1
          var count_extra: nx_int = 0
          while pos < n {
              let nc: nx_int = src[pos] & 0xff
              if nc == NX_C_PLUS { count_extra = count_extra + 1; pos = pos + 1 }
              else { break }
          }
          if count_extra > 0 { charge = charge + count_extra }
          else {
              if pos < n {
                  let nc2: nx_int = src[pos] & 0xff
                  if smi_is_digit(nc2) == 1 {
                      charge = 0
                      while pos < n {
                          let dd: nx_int = src[pos] & 0xff
                          if smi_is_digit(dd) == 0 { break }
                          charge = (charge * 10) + (dd - NX_C_0)
                          pos = pos + 1
                      }
                  }
              }
          }
      }
      else {
          if cc == NX_C_MINUS {
              pos = pos + 1
              charge = -1
              var count_extra2: nx_int = 0
              while pos < n {
                  let nc: nx_int = src[pos] & 0xff
                  if nc == NX_C_MINUS { count_extra2 = count_extra2 + 1; pos = pos + 1 }
                  else { break }
              }
              if count_extra2 > 0 { charge = charge - count_extra2 }
              else {
                  if pos < n {
                      let nc2: nx_int = src[pos] & 0xff
                      if smi_is_digit(nc2) == 1 {
                          var mag: nx_int = 0
                          while pos < n {
                              let dd: nx_int = src[pos] & 0xff
                              if smi_is_digit(dd) == 0 { break }
                              mag = (mag * 10) + (dd - NX_C_0)
                              pos = pos + 1
                          }
                          charge = 0 - mag
                      }
                  }
              }
          }
      }
  }
  // ---- atom map :n -- now POPULATED into Atom.map_num (C2.2) ----
  var map_num: nx_int = 0
  if pos < n {
      let cc: nx_int = src[pos] & 0xff
      if cc == NX_C_COLON {
          pos = pos + 1
          while pos < n {
              let dd: nx_int = src[pos] & 0xff
              if smi_is_digit(dd) == 0 { break }
              map_num = (map_num * 10) + (dd - NX_C_0)
              pos = pos + 1
          }
      }
  }
  // ---- closing ']' ----
  if pos >= n {
      m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_UNCLOSED_BR; m.err_pos = pos
      return 0
  }
  let close_c: nx_int = src[pos] & 0xff
  if close_c != NX_C_RBRACKET {
      m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_UNCLOSED_BR; m.err_pos = pos
      return 0
  }
  pos = pos + 1
  out_z[0] = z
  out_iso[0] = iso
  out_h[0] = h
  out_charge[0] = charge
  out_stereo[0] = stereo_val
  out_map[0] = map_num
  out_aromatic[0] = arom_bracket
  pos_io[0] = pos
  return 1
550}
551
552// =================================================================
553// Connect previous atom to new atom with pending or default bond,
554// applying pending_bstereo if set.  Returns the new bond index, or -1.
555// =================================================================
556func smi_connect(m: *MolGraph, prev: nx_int, new_idx: nx_int, pending: nx_int, pending_bstereo: nx_int) -> nx_int {
  if prev < 0 { return -1 }    // no connection yet (first atom)
  var order: nx_int = pending
  if pending == 0 {
      let pa: *Atom = nx_chem_mol_atom(m, prev)
      let na: *Atom = nx_chem_mol_atom(m, new_idx)
      if (pa as nx_int) == 0 { return -1 }
      if (na as nx_int) == 0 { return -1 }
      if pa.aromaticity != 0 {
          if na.aromaticity != 0 { order = NX_BOND_AROMATIC }
          else { order = NX_BOND_SINGLE }
      }
      else { order = NX_BOND_SINGLE }
  }
  let bi: nx_int = nx_chem_mol_bond_add(m, prev, new_idx, order)
  if bi < 0 { return -1 }
  if pending_bstereo != NX_BSTEREO_NONE {
      let bd: *Bond = nx_chem_mol_bond(m, bi)
      bd.stereo = pending_bstereo
  }
  return bi
577}
578
579// =================================================================
580// C2.3f: post-parse pass to populate per-stereo-atom neighbor order.
581//
582// For each Atom with stereo != 0, walks the bond list in input order
583// and records the neighbor permutation as it would be read in SMILES:
584//   - If first bond touching atom is INCOMING (b.b == atom_idx): the
585//     chain-prev is slot 0; implicit H (if h_count > 0) is slot 1;
586//     subsequent neighbors fill slots 2-3.
587//   - If first bond is OUTGOING (b.a == atom_idx; atom is root or
588//     stereocenter at start of chain): implicit H (if any) is slot 0;
589//     subsequent neighbors fill slots 1-3.
590//
591// Sentinel -2 marks the implicit-H position; -1 marks an unfilled slot
592// (under-determined stereo, e.g., chiral atom with <4 neighbors).
593// =================================================================
594func nx_chem_smiles_populate_stereo_neighbors(m: *MolGraph) -> nx_int {
  var i: nx_int = 0
  while i < m.n_atoms {
      let a: *Atom = ((m.atoms as nx_int) + (i * NX_ATOM_BYTES)) as *Atom
      if a.stereo != NX_STEREO_NONE {
          var has_prev: nx_int = 0
          var first_idx: nx_int = -1
          var bi_s: nx_int = 0
          var found_first: nx_int = 0
          while bi_s < m.n_bonds {
              if found_first == 0 {
                  let b: *Bond = ((m.bonds as nx_int) + (bi_s * NX_BOND_BYTES)) as *Bond
                  var touches: nx_int = 0
                  if b.a == i { touches = 1 }
                  if b.b == i { touches = 1 }
                  if touches == 1 {
                      first_idx = bi_s
                      if b.b == i { has_prev = 1 }
                      found_first = 1
                  }
              }
              bi_s = bi_s + 1
          }
          let neighbors: *nx_int = (sys_mmap(64)) as *nx_int
          neighbors[0] = -1
          neighbors[1] = -1
          neighbors[2] = -1
          neighbors[3] = -1
          var pos: nx_int = 0
          if has_prev == 1 {
              if first_idx >= 0 {
                  let bf: *Bond = ((m.bonds as nx_int) + (first_idx * NX_BOND_BYTES)) as *Bond
                  neighbors[0] = bf.a
                  pos = 1
              }
          }
          if a.h_count > 0 {
              if pos < 4 {
                  neighbors[pos] = -2
                  pos = pos + 1
              }
          }
          var skipped_inc: nx_int = 0
          var bi_w: nx_int = 0
          while bi_w < m.n_bonds {
              if pos < 4 {
                  let bw: *Bond = ((m.bonds as nx_int) + (bi_w * NX_BOND_BYTES)) as *Bond
                  var t_w: nx_int = 0
                  if bw.a == i { t_w = 1 }
                  if bw.b == i { t_w = 1 }
                  if t_w == 1 {
                      var skip: nx_int = 0
                      if has_prev == 1 {
                          if skipped_inc == 0 {
                              if bi_w == first_idx { skip = 1; skipped_inc = 1 }
                          }
                      }
                      if skip == 0 {
                          var other: nx_int = bw.b
                          if bw.b == i { other = bw.a }
                          neighbors[pos] = other
                          pos = pos + 1
                      }
                  }
              }
              bi_w = bi_w + 1
          }
          a.stereo_n0 = neighbors[0]
          a.stereo_n1 = neighbors[1]
          a.stereo_n2 = neighbors[2]
          a.stereo_n3 = neighbors[3]
      }
      i = i + 1
  }
  return 0
669}
670
671// =================================================================
672// Main parse entry: SMILES -> MolGraph.  Returns *MolGraph; check
673// .is_valid before use.  On failure, .err_code names the failure
674// class and .err_pos is the offending char index.
675// =================================================================
676func nx_chem_parse_smiles(src: *u8, n: nx_int) -> *MolGraph {
  var cap_a: nx_int = n + 4
  var cap_b: nx_int = 2 * (n + 4)
  let m: *MolGraph = nx_chem_mol_new(cap_a, cap_b)
  if n <= 0 {
      m.is_valid = 0
      m.err_code = NX_MOL_ERR_SMILES_EMPTY
      m.err_pos = 0
      return m
  }
  // Ring closures: 100 slots (0..99) to support %nn (C2.2).
  // -1 = unused slot; otherwise atom-index that opened the ring.
  let ring_atom: *nx_int = (sys_mmap((100 * 8) as i64)) as *nx_int
  let ring_bord: *nx_int = (sys_mmap((100 * 8) as i64)) as *nx_int
  var ri: nx_int = 0
  while ri < 100 {
      ring_atom[ri] = -1
      ring_bord[ri] = 0
      ri = ri + 1
  }
  // Branch stack
  let stack: *nx_int = (sys_mmap((cap_a * 8) as i64)) as *nx_int
  var stack_n: nx_int = 0
  var prev: nx_int = -1
  var pending: nx_int = 0
  var pending_bstereo: nx_int = NX_BSTEREO_NONE
  var pos: nx_int = 0
  var consumed: *nx_int = (sys_mmap(8)) as *nx_int
  var iso_io:    *nx_int = (sys_mmap(8)) as *nx_int
  var z_io:      *nx_int = (sys_mmap(8)) as *nx_int
  var h_io:      *nx_int = (sys_mmap(8)) as *nx_int
  var ch_io:     *nx_int = (sys_mmap(8)) as *nx_int
  var st_io:     *nx_int = (sys_mmap(8)) as *nx_int
  var mp_io:     *nx_int = (sys_mmap(8)) as *nx_int
  var ar_io:     *nx_int = (sys_mmap(8)) as *nx_int
  while pos < n {
      let c: nx_int = src[pos] & 0xff
      // ---- branch open ----
      if c == NX_C_LPAREN {
          if prev < 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos
              return m
          }
          stack[stack_n] = prev
          stack_n = stack_n + 1
          pos = pos + 1
          continue
      }
      // ---- branch close ----
      if c == NX_C_RPAREN {
          if stack_n <= 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_UNCLOSED_PAREN; m.err_pos = pos
              return m
          }
          stack_n = stack_n - 1
          prev = stack[stack_n]
          pending = 0
          pending_bstereo = NX_BSTEREO_NONE
          pos = pos + 1
          continue
      }
      // ---- explicit bond marker ----
      if c == NX_C_MINUS  { pending = NX_BOND_SINGLE;   pos = pos + 1; continue }
      if c == NX_C_EQ     { pending = NX_BOND_DOUBLE;   pos = pos + 1; continue }
      if c == NX_C_HASH   { pending = NX_BOND_TRIPLE;   pos = pos + 1; continue }
      if c == NX_C_COLON  { pending = NX_BOND_AROMATIC; pos = pos + 1; continue }
      if c == NX_C_DOT    { prev = -1; pending = 0; pending_bstereo = NX_BSTEREO_NONE; pos = pos + 1; continue }
      // ---- bond stereo markers (C2.2) ----
      if c == NX_C_SLASH  { pending_bstereo = NX_BSTEREO_UP;   pos = pos + 1; continue }
      if c == NX_C_BSLASH { pending_bstereo = NX_BSTEREO_DOWN; pos = pos + 1; continue }
      // ---- two-digit ring closure %nn (C2.2) ----
      if c == NX_C_PCT {
          if (pos + 2) >= n {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos
              return m
          }
          let d1: nx_int = src[pos + 1] & 0xff
          let d2: nx_int = src[pos + 2] & 0xff
          if smi_is_digit(d1) == 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos + 1
              return m
          }
          if smi_is_digit(d2) == 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos + 2
              return m
          }
          let d: nx_int = ((d1 - NX_C_0) * 10) + (d2 - NX_C_0)
          if prev < 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_ORPHAN_RING; m.err_pos = pos
              return m
          }
          if ring_atom[d] == -1 {
              ring_atom[d] = prev
              ring_bord[d] = pending
              pending = 0
          }
          else {
              let other: nx_int = ring_atom[d]
              var order: nx_int = pending
              if order == 0 { order = ring_bord[d] }
              if order == 0 {
                  let pa: *Atom = nx_chem_mol_atom(m, other)
                  let na: *Atom = nx_chem_mol_atom(m, prev)
                  if (pa as nx_int) == 0 { return m }
                  if (na as nx_int) == 0 { return m }
                  if pa.aromaticity != 0 {
                      if na.aromaticity != 0 { order = NX_BOND_AROMATIC }
                      else { order = NX_BOND_SINGLE }
                  }
                  else { order = NX_BOND_SINGLE }
              }
              let bi: nx_int = nx_chem_mol_bond_add(m, prev, other, order)
              if bi >= 0 {
                  let bd: *Bond = nx_chem_mol_bond(m, bi)
                  bd.in_ring = 1
                  if order == NX_BOND_AROMATIC {
                      bd.aromaticity = NX_AROM_DAYLIGHT
                  }
              }
              ring_atom[d] = -1
              ring_bord[d] = 0
              pending = 0
          }
          pos = pos + 3
          continue
      }
      // ---- single-digit ring closure ----
      if smi_is_digit(c) == 1 {
          let d: nx_int = c - NX_C_0
          if prev < 0 {
              m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_ORPHAN_RING; m.err_pos = pos
              return m
          }
          if ring_atom[d] == -1 {
              ring_atom[d] = prev
              ring_bord[d] = pending
              pending = 0
          }
          else {
              let other: nx_int = ring_atom[d]
              var order: nx_int = pending
              if order == 0 { order = ring_bord[d] }
              if order == 0 {
                  let pa: *Atom = nx_chem_mol_atom(m, other)
                  let na: *Atom = nx_chem_mol_atom(m, prev)
                  if (pa as nx_int) == 0 { return m }
                  if (na as nx_int) == 0 { return m }
                  if pa.aromaticity != 0 {
                      if na.aromaticity != 0 { order = NX_BOND_AROMATIC }
                      else { order = NX_BOND_SINGLE }
                  }
                  else { order = NX_BOND_SINGLE }
              }
              let bi: nx_int = nx_chem_mol_bond_add(m, prev, other, order)
              if bi >= 0 {
                  let bd: *Bond = nx_chem_mol_bond(m, bi)
                  bd.in_ring = 1
                  if order == NX_BOND_AROMATIC {
                      bd.aromaticity = NX_AROM_DAYLIGHT
                  }
              }
              ring_atom[d] = -1
              ring_bord[d] = 0
              pending = 0
          }
          pos = pos + 1
          continue
      }
      // ---- bracket atom ----
      if c == NX_C_LBRACKET {
          var bracket_pos: *nx_int = (sys_mmap(8)) as *nx_int
          bracket_pos[0] = pos
          let ok: nx_int = smi_parse_bracket(src, n, bracket_pos, m, z_io, iso_io, h_io, ch_io, st_io, mp_io, ar_io)
          if ok == 0 { return m }
          pos = bracket_pos[0]
          let new_idx: nx_int = nx_chem_mol_atom_add(m, z_io[0])
          if new_idx < 0 { return m }
          let na: *Atom = nx_chem_mol_atom(m, new_idx)
          na.isotope = iso_io[0]
          na.h_count = h_io[0]
          na.charge  = ch_io[0]
          na.stereo  = st_io[0]
          na.map_num = mp_io[0]
          if ar_io[0] == 1 { na.aromaticity = NX_AROM_DAYLIGHT }
          let _b: nx_int = smi_connect(m, prev, new_idx, pending, pending_bstereo)
          prev = new_idx
          pending = 0
          pending_bstereo = NX_BSTEREO_NONE
          continue
      }
      // ---- wildcard ----
      if c == NX_C_STAR {
          let new_idx: nx_int = nx_chem_mol_atom_add(m, 0)
          if new_idx < 0 { return m }
          let _b: nx_int = smi_connect(m, prev, new_idx, pending, pending_bstereo)
          prev = new_idx
          pending = 0
          pending_bstereo = NX_BSTEREO_NONE
          pos = pos + 1
          continue
      }
      // ---- aromatic lowercase atom ----
      let arom_z: nx_int = smi_aromatic_lower_to_z(c)
      if arom_z > 0 {
          let new_idx: nx_int = nx_chem_mol_atom_add(m, arom_z)
          if new_idx < 0 { return m }
          let na: *Atom = nx_chem_mol_atom(m, new_idx)
          na.aromaticity = NX_AROM_DAYLIGHT
          let _b: nx_int = smi_connect(m, prev, new_idx, pending, pending_bstereo)
          prev = new_idx
          pending = 0
          pending_bstereo = NX_BSTEREO_NONE
          pos = pos + 1
          continue
      }
      // ---- organic-subset uppercase atom ----
      if smi_is_upper(c) == 1 {
          var c2: nx_int = 0
          if (pos + 1) < n { c2 = src[pos + 1] & 0xff }
          let z: nx_int = smi_organic_atom(c, c2, consumed)
          if z > 0 {
              let new_idx: nx_int = nx_chem_mol_atom_add(m, z)
              if new_idx < 0 { return m }
              let _b: nx_int = smi_connect(m, prev, new_idx, pending, pending_bstereo)
              prev = new_idx
              pending = 0
              pending_bstereo = NX_BSTEREO_NONE
              pos = pos + consumed[0]
              continue
          }
          m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos
          return m
      }
      m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_BAD_CHAR; m.err_pos = pos
      return m
  }
  if stack_n != 0 {
      m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_UNCLOSED_PAREN; m.err_pos = pos
      return m
  }
  var ri2: nx_int = 0
  while ri2 < 100 {
      if ring_atom[ri2] != -1 {
          m.is_valid = 0; m.err_code = NX_MOL_ERR_SMILES_ORPHAN_RING; m.err_pos = pos
          return m
      }
      ri2 = ri2 + 1
  }
  // C2.3f: populate per-stereo-atom neighbor permutation for parity correction
  let _sp: nx_int = nx_chem_smiles_populate_stereo_neighbors(m)
  return m
927}
928
929// =================================================================
930// Convenience: parse a NUL-terminated SMILES string.
931// =================================================================
932func nx_chem_parse_smiles_cstr(src: *u8) -> *MolGraph {
  var n: nx_int = 0
  let cap: nx_int = 65535
  while n < cap {
      let c: nx_int = src[n] & 0xff
      if c == 0 { break }
      n = n + 1
  }
  return nx_chem_parse_smiles(src, n)
941}
nx_chem_smiles.nx source

`nx_chem_smiles.nx` source
