# ast.ludic — the node kinds and the single Node shape they share, plus the
# declaration tables the emitter reads.

# declarations
const N_STRUCT: int = 0
const N_FIELD:  int = 1
const N_VAR:    int = 2
const N_CONST:  int = 3
const N_FN:     int = 4
const N_PARAM:  int = 5
const N_MAIN:   int = 6
const N_BLOCK:  int = 7
const N_COMP:   int = 8
const N_SYS:    int = 9
const N_ARCH:   int = 10
const N_EXTERN: int = 11
const N_UI:     int = 12
const N_ENUM:   int = 27         # enum Name { A, B, ... } — named int constants
const S_TOGGLE: int = 28         # enable/disable  (ival: 1=enable 0=disable; s=target; a=entity or null)
const N_SCENE:  int = 45         # scene Name [start] { on enter{} on exit{} layer L { handlers } }
                                 #   s=name  ival=scene id  a=on-enter block  b=on-exit block
const S_ATTACH: int = 46         # attach P on e [{ overrides }]  — add a property to a live entity
                                 #   s=property  a=entity expr  b=override record (E_REC) or null
const S_DETACH: int = 47         # detach P on e  — remove a property from a live entity
                                 #   s=property  a=entity expr
const N_EVENT:  int = 48         # event Name { field: T = default, ... } — a public event payload
                                 #   s=name  kids=payload fields (N_FIELD)
const S_EMIT:   int = 49         # emit E(field: v, ...) — fire event E (calls its @On listeners)
                                 #   s=event name  a=E_REC of named args; also usable as an
                                 #   expression (a cancellable event returns its cancelled flag)
const S_CANCEL: int = 50         # cancel — inside a listener, veto a `cancellable` event
const N_TEST:   int = 51         # test "name" { ... } — a named test block (the testing framework)
                                 #   s=name  a=body block  line=source line of the test
const N_PREFAB: int = 53         # prefab Name: Model { Comp { field: v }, … } — a model plus preset fields
                                 #   s=name  ty=model  kids=E_FINIT component records (like spawn)
const E_TRY:    int = 52         # try EXPR else { ... } — recover a fallible result as a value (issue #46)
                                 #   a=the fallible (result-typed) expression  b=else block (its
                                 #   trailing expression is the fallback)  line=source line
const E_LIST:   int = 54         # [a, b, c] — a slice literal; kids=the elements, all of one type
const S_UNSAFE: int = 56         # unsafe { ... } — raw memory allowed inside (L7); a = the block
const E_FNREF:  int = 55         # fn name — a top-level function as a value (s=the name); a worker entry point
# statements
const S_LET:      int = 10
const S_ASSIGN:   int = 11
const S_IF:       int = 12
const S_WHILE:    int = 13
const S_FOR:      int = 14
const S_RETURN:   int = 15
const S_EXPR:     int = 16
const S_BREAK:    int = 17
const S_CONTINUE: int = 18
const S_MATCH:    int = 19
const S_MARM:     int = 20
const S_QUERY:    int = 21
const S_SPAWN:    int = 22
const S_DESPAWN:  int = 23
const S_MACHINE:  int = 24
const S_STATE:    int = 25
const S_BECOME:   int = 26
# expressions
const E_INT:    int = 30
const E_STR:    int = 31
const E_BOOL:   int = 32
const E_ID:     int = 33
const E_CALL:   int = 34
const E_MEMBER: int = 35
const E_INDEX:  int = 36
const E_BIN:    int = 37
const E_UN:     int = 38
const E_NEW:    int = 39
const E_FLOAT:  int = 40
const E_REC:    int = 41
const E_FINIT:  int = 42
const E_PREVAL: int = 190    # an already-evaluated value (emit_float.ludic preval_node)
const E_NULL:   int = 43         # the `null` pointer literal
const E_SLICE:  int = 44         # s[a..b] — substring (a=base, b=start, c=end)

property Node {
  kind: int = 0
  s:    pointer = null      # name / operator / string / type-of-new
  ival: int = 0               # int literal, bool, flags
  ty:   pointer = null      # declared type (let/param/field/fn/var/const)
  a:    Node                  # fixed children (meaning per kind)
  b:    Node
  c:    Node
  kids: []Node                # variadic children
  line: int = 0
  file: pointer = null        # the source file the node was parsed from (for diagnostics)
  vis:  int = 0               # L3: 1 when the declaration is `export`ed from its module
  tps:  pointer = null        # L5: a generic declaration's type parameters, "T|U"; null when not generic
  uns:  int = 0               # L7: 1 on an `unsafe function`
  pos:  int = -1              # 0.S: byte offset of its first token in its file (-1: generated)
  pos2: int = -1              # 0.S: a second place a rewrite needs (a declaration's end, a '(')
  mg:   int = -1              # 0.S2: its index in the migration's tables (migrate.ludic)
  vw:   int = -1              # 0.S: the view a function was generated for or written in
  cm:   int = -1              # 0.S: the component a function was generated for or written in
}

# every node remembers where it was parsed (file + the line of the token the
# parser is looking at), so any later diagnostic can point at real source
function node(kind: int) -> Node {
  let n = new Node
  n.kind = kind
  n.kids = new []Node
  n.file = g_parse_file
  if g_parsing and pi < len(toks) {
    n.line = toks[pi].line
    n.pos = toks[pi].pos
    if g_gen_nodes { n.pos = -1 }            # made by the compiler, not read from a file
  }
  return n
}