M2compiler-V3/compiler/src/SymTab.def

DEFINITION MODULE SymTab;
(* Symbol table with static type checking for SimpleMod2
   (simplified Modula-2 without procedures).

   - flat scopes with levels: globals at level 0, WITH statement
     bodies push the record's fields as an inner scope (shadowing
     allowed, duplicates within one level rejected)
   - every symbol carries a type descriptor index (InvalidType if
     unknown, e.g. imported names); unknown types suppress follow-on
     errors to avoid cascades
   - type descriptors: aliases (one per TYPE declaration, so
     self-references such as POINTER TO Person resolve), subranges,
     enumerations, arrays, records (with field lists), sets,
     pointers, predefined types, string literals
   - INTEGER, CARDINAL and subranges thereof form one lenient
     "integer family"; mixed INTEGER/REAL arithmetic is rejected *)

CONST
  InvalidType = -1;

  (* symbol kinds *)
  KindConst  = 0;
  KindType   = 1;
  KindVar    = 2;
  KindImport = 3;
  KindModule = 4;
  KindPredef = 5;
  KindField  = 6;
  KindProc   = 7;
  KindParam  = 8;

  (* type classes returned by ClassOf *)
  ClInvalid = 0;
  ClInt     = 1;
  ClReal    = 2;
  ClChar    = 3;
  ClBool    = 4;
  ClEnum    = 5;
  ClArray   = 6;
  ClRecord  = 7;
  ClSet     = 8;
  ClPtr     = 9;
  ClStr     = 10;
  ClClass   = 11;
  ClNil     = 12;
  ClLong    = 13;
  ClProc    = 14;
  ClUChar   = 15;
  ClUStr    = 16;
  ClByte    = 17;
  ClSByte   = 18;
  ClWord16  = 19;
  ClSWord16 = 20;

  (* operator codes for RelCheck *)
  OpEq = 0; OpNeq1 = 1; OpNeq2 = 2;
  OpLt = 3; OpLe  = 4; OpGt   = 5; OpGe = 6;
  OpIn = 7;
  (* operator codes for AddOp / MulOp *)
  OpAdd = 0; OpSub = 1; OpOr = 2;
  OpTimes = 0; OpSlash = 1; OpDiv = 2; OpMod = 3; OpAnd = 4;

TYPE
  Name = ARRAY [0 .. 63] OF CHAR;
  TypeIndex = INTEGER;
  BoundsArr = ARRAY [0 .. 7] OF INTEGER;
(* Per-dimension bounds for array index lists (grammar locals). *)

(* ---------------- symbols and scopes ---------------- *)

PROCEDURE Init;
(* Clears the table and enters predefined identifiers
   (INTEGER, CARDINAL, SHORTINT, LONGINT, SHORTCARD, REAL, LONGREAL,
   CHAR, BOOLEAN, TRUE, FALSE, NIL). *)

PROCEDURE Enter (name: ARRAY OF CHAR; kind: INTEGER): BOOLEAN;
(* Enters name at the current scope level (type InvalidType).
   Returns FALSE on duplicate within the same level. *)

PROCEDURE ReenterModGlobal (name: ARRAY OF CHAR; kind: INTEGER;
                            modName: ARRAY OF CHAR): BOOLEAN;
(* Lower helper: enters name at the current scope with an explicit
   defining-module name (used when re-emitting a unit after its scope
   has closed).  FALSE on duplicate. *)

PROCEDURE EnterPending (name: ARRAY OF CHAR; kind: INTEGER): BOOLEAN;
(* Like Enter, but remembers the entry for a later FixPending call
   (used for VAR identifier lists whose type is parsed afterwards).
   Returns FALSE on duplicate (entry not recorded). *)

PROCEDURE FixPending (t: TypeIndex) : BOOLEAN;
(* Assigns type t to all pending entries, clears the buffer, and
   returns TRUE.  When the current heading resumed a DEFINITION, the
   just-typed formals are compared against the snapshot (strict 231):
   FALSE = mismatch. *)

PROCEDURE PendCount (): CARDINAL;
(* Number of entries currently waiting for FixPending. *)

PROCEDURE PendName (i: CARDINAL; VAR n: Name);
(* Name of the i-th pending entry (empty string if out of range).
   Used by the QBE backend to emit storage for VAR lists whose
   type is parsed after the identifiers. *)

PROCEDURE FieldPending (rec: TypeIndex; name: ARRAY OF CHAR): BOOLEAN;
(* Records a field name for record descriptor rec (type fixed later
   with FixPendingF). Returns FALSE on duplicate field. *)

PROCEDURE FixPendingF (rec: TypeIndex; t: TypeIndex);
(* Assigns type t to pending fields owned by rec. *)

PROCEDURE Lookup (name: ARRAY OF CHAR): BOOLEAN;
(* TRUE if name is visible (innermost scope wins). *)

PROCEDURE SymType (name: ARRAY OF CHAR): TypeIndex;
(* Type of innermost visible entry, InvalidType if absent. *)

PROCEDURE SetSymType (name: ARRAY OF CHAR; t: TypeIndex);
(* Sets type of innermost visible entry. *)

PROCEDURE SymKind (name: ARRAY OF CHAR): INTEGER;
(* Kind of innermost visible entry, -1 if absent. *)

PROCEDURE SetSymVal (name: ARRAY OF CHAR; v: ARRAY OF CHAR);
(* Stores the literal value text of a CONST for constant folding. *)

PROCEDURE GetSymVal (name: ARRAY OF CHAR; VAR v: ARRAY OF CHAR): BOOLEAN;
(* v := stored literal value text of CONST name; FALSE if none. *)

PROCEDURE Equal (a, b: ARRAY OF CHAR): BOOLEAN;

PROCEDURE PushScope;
PROCEDURE PopScope;
(* WITH statement support: PushRecord pushes a record's fields. *)

PROCEDURE PushRecord (t: TypeIndex): BOOLEAN;
(* Pushes a scope containing t's fields (as KindField). FALSE if t
   is not a record type (or invalid). Caller must PopScope after. *)

PROCEDURE PrintTable;

(* ---------------- procedures (headings now, bodies step 4) ---------------- *)

PROCEDURE EnterProc (name: ARRAY OF CHAR): BOOLEAN;
(* Enters a KindProc heading and pushes its parameter scope.
   FALSE on duplicate (no scope pushed). Resets result to
   InvalidType (proper procedure), clears fwd, empties param chain. *)

PROCEDURE ResumeProc (name: ARRAY OF CHAR): BOOLEAN;
(* Resumes a DEFINITION's procedure heading for its
   IMPLEMENTATION body: pushes a fresh body scope, clears the
   formal chain (the implementation re-enters its own). Only valid
   while an IMPLEMENTATION unit is open. *)

PROCEDURE ReenterProc (name: ARRAY OF CHAR): BOOLEAN;
(* Resumes a FORWARD-marked procedure of this scope for its body
   heading: clears fwd, pushes a fresh parameter scope. FALSE
   when no such forward heading exists (then 200 applies). *)

PROCEDURE EnterParam (name: ARRAY OF CHAR; isVar: BOOLEAN): BOOLEAN;
(* Enters a KindParam in the heading scope and chains it into the
   current procedure's positional param list. FALSE on duplicate. *)

PROCEDURE SetProcRes (t: TypeIndex) : BOOLEAN;
(* Sets the current procedure's result type (InvalidType = none) and
   returns TRUE.  When the heading resumed a DEFINITION
   (ResumeProc), it also performs the strict-231 signature check
   (result, formal count, formal types, VAR-ness) and returns the
   outcome; FALSE means the implementation does not match. *)

PROCEDURE ProcRes (name: ARRAY OF CHAR): TypeIndex;
(* Result type of the named procedure, InvalidType if absent/none. *)

PROCEDURE MarkFwd;
(* Marks the current procedure FORWARD (body must follow). *)

PROCEDURE MarkVirtual;
(* Marks the current procedure VIRTUAL (dynamically dispatched;
   dispatch tables arrive with class lowering). *)

PROCEDURE MarkExternal (link: ARRAY OF CHAR);
(* Marks the current procedure EXTERNAL (no body emitted; calls bind
   to the C symbol `link`, or to the procedure's own name if ''). *)

PROCEDURE DeclareCProc (name: ARRAY OF CHAR): BOOLEAN;
(* Enter name as an intrinsic external C procedure (varargs, no
   result): FROM libc IMPORT. *)
PROCEDURE Varargs (name: ARRAY OF CHAR): BOOLEAN;
(* TRUE when the named procedure is a C-varargs intrinsic. *)
PROCEDURE ProcLink (name: ARRAY OF CHAR; VAR link: Name): BOOLEAN;
(* External-procedure query/link lookup (link name of the named
   visible procedure). *)

PROCEDURE CloseProc;
(* Pops the current procedure's scope and its proc-stack entry.
   Replaces bare PopScope at the end of headings (DefUnit),
   FORWARD clauses and bodies. *)

PROCEDURE InProc (): BOOLEAN;
(* TRUE inside a procedure heading/body (RETURN legal). *)

PROCEDURE CurRes (): TypeIndex;
(* Result type of the innermost open procedure,
   InvalidType outside procedures or for proper procedures. *)


PROCEDURE ProcDepthOf (name: ARRAY OF CHAR): CARDINAL;
(* Lexical function-nesting depth of the named procedure
   (enclosing procedures; 0 = module level). Drives the static-
   link walk count at call sites. *)

PROCEDURE ProcUid (name: ARRAY OF CHAR): CARDINAL;
(* Unique id of the named procedure (0 if absent); drives QBE
   name mangling so same-named methods never collide. *)

PROCEDURE ProcNPar (name: ARRAY OF CHAR): CARDINAL;
PROCEDURE ParamType (name: ARRAY OF CHAR; i: CARDINAL): TypeIndex;
PROCEDURE ParamIsVar (name: ARRAY OF CHAR; i: CARDINAL): BOOLEAN;
(* Positional formal access for call checking (233 on mismatch). *)
PROCEDURE ParamName (name: ARRAY OF CHAR; i: CARDINAL;
                     VAR pname: Name): BOOLEAN;
(* The i-th formal's name, for the re-parse pass QbeGen replay. *)

PROCEDURE VarParamOk (actual, formal: TypeIndex): BOOLEAN;
(* VAR-formal compatibility: same type, fixed array into open
   array with same element, or string literal into open CHAR. *)

(* ---------------- modules / separate compilation (step 4.3) ---------------- *)
(* One compiler session compiles several units into one image:
   DEFINITION, its IMPLEMENTATION, and one program (last). Each
   unit gets its own scope; imports materialize names. *)

CONST
  UnitProg = 0; UnitDef = 1; UnitImpl = 2;

PROCEDURE BeginDef (name: ARRAY OF CHAR): BOOLEAN;
(* Opens a DEFINITION module scope. FALSE on duplicate module. *)

PROCEDURE BeginImpl (name: ARRAY OF CHAR): BOOLEAN;
(* Resumes a DEFINITION's scope for its IMPLEMENTATION.
   FALSE when the module is undefined or already implemented. *)

PROCEDURE Reenter (name: ARRAY OF CHAR; kind: INTEGER): BOOLEAN;
(* Re-enters the scope of an already-registered module (kind is UnitDef
   or UnitImpl) for an instantiation re-parse. *)

PROCEDURE BeginProg (name: ARRAY OF CHAR): BOOLEAN;
(* Opens the program module's scope. *)

PROCEDURE EndUnit;
(* Returns to the global scope. *)
PROCEDURE EnterLowerScope (name: ARRAY OF CHAR): BOOLEAN;
(* Make a unit's module scope current while Lower re-emits it. *)
PROCEDURE LeaveLowerScope;



PROCEDURE HaveProgram (): BOOLEAN;
(* TRUE once a program module has been opened (a session without
   one is an error: nothing to link). *)

PROCEDURE ModKnown (name: ARRAY OF CHAR): BOOLEAN;

PROCEDURE ImportFrom (mod, name: ARRAY OF CHAR): BOOLEAN;
(* Materializes an exported name from mod into the current scope
   (FROM mod IMPORT name). FALSE when mod/name is unknown. *)

PROCEDURE OpaqueBase (name: ARRAY OF CHAR): TypeIndex;
(* If name is an opaque alias (its target still InvalidType),
   returns that alias descriptor so the implementation can complete
   it via SetTarget; InvalidType otherwise. *)


PROCEDURE QualType (mod, name: ARRAY OF CHAR): TypeIndex;

PROCEDURE ExportUp (name: ARRAY OF CHAR);
(* Nested-module END: clones the entry `name` from the just-finished
   nested scope into the enclosing scope, so a local module's EXPORT
   list becomes visible outside it. Must be called before PopScope. *)

PROCEDURE Materialize (mod, name: ARRAY OF CHAR): BOOLEAN;
(* FROM-import: clones mod's export into the current scope under
   its plain name. FALSE when mod/name is unknown. *)

PROCEDURE MaterializeReplace (mod, name: ARRAY OF CHAR): BOOLEAN;
(* Like Materialize, but an already-visible name is updated to mod's
   symbol (the current unit's global must win for Lower's per-unit
   re-emit, where units share names like scopeTop/EOL). *)

PROCEDURE MaterializeAlias (mod, name: ARRAY OF CHAR;
                             VAR alias: Name): BOOLEAN;
(* Qualified access: clones mod's export under a per-module alias
   key, so same-named exports of different modules never collide.
   The alias key is used for all subsequent lookups (types, uids,
   params); the node remembers its base name and module for QBE
   symbol emission. *)

PROCEDURE ProcBaseByUid (uid: CARDINAL; VAR base: Name): BOOLEAN;
(* Base (mangling) name of a procedure by uid. *)
PROCEDURE ProcModuleByUid (uid: CARDINAL; VAR mod: Name;
                           VAR depth: CARDINAL): BOOLEAN;
(* Defining module and lexical depth of a procedure by uid. *)
PROCEDURE TypeStableName (t: TypeIndex; VAR mod, name: Name): BOOLEAN;
(* Stable (module, type-name) for a named type/class. *)
PROCEDURE ProcClassByUid (uid: CARDINAL): TypeIndex;
(* Class owning a method declared with this uid, or InvalidType. *)
PROCEDURE SymBase (name: ARRAY OF CHAR; VAR base: Name): BOOLEAN;

PROCEDURE QualProcInfo (mod, name: ARRAY OF CHAR; VAR uid, depth: CARDINAL;
                        VAR res: TypeIndex; VAR ext: BOOLEAN): BOOLEAN;
(* Proc facts of a module-qualified procedure name. *)

PROCEDURE SymMod (name: ARRAY OF CHAR; VAR m: Name): BOOLEAN;
(* Defining module of the visible entry ("" for a local). *)
PROCEDURE AliasProc (formalName: ARRAY OF CHAR; mod, actualName: ARRAY OF CHAR): BOOLEAN;
(* Bind a generic procedure formal to the actual procedure. *)
(* Base symbol name of the visible entry (drops any alias prefix). *)

PROCEDURE GlobalRef (name: ARRAY OF CHAR; VAR g: Name): BOOLEAN;
(* "<mod>_<sym>" QBE global-symbol name for a module-level entry;
   FALSE when name is not a module-level symbol. *)

(* ---------------- classes (Clarion form, lowering deferred) ---------------- *)

PROCEDURE EnterThisParam (cls: TypeIndex): BOOLEAN;
(* Enters a method's hidden THIS VAR parameter. *)

PROCEDURE LayoutClass (t: TypeIndex);
(* Computes a class's field offsets / size. *)

PROCEDURE LayoutRecord (t: TypeIndex);
(* Computes a record's field offsets / size now (idempotent).  Called at
   the record's END so a variant record's size is settled before any
   VAR of that type is emitted. *)

PROCEDURE ParentOf (t: TypeIndex): TypeIndex;
(* The single parent class of t (InvalidType when none). *)

PROCEDURE SetParent (t, p: TypeIndex);
(* Records p as the (single) parent class of t. Multiple parents
   are rejected in the grammar with 230. *)

PROCEDURE PushClassScope (t: TypeIndex);
(* Pushes the body scope of class t and records it on t. *)

PROCEDURE MethodExists (t: TypeIndex; name: ARRAY OF CHAR): BOOLEAN;
(* TRUE if the class scope of t declares name as a procedure. *)

PROCEDURE ResumeMethod (ct: TypeIndex; name: ARRAY OF CHAR): BOOLEAN;
(* Resumes a declared class method for its CLASS IMPLEMENTATION body. *)

PROCEDURE HasVTable (ct: TypeIndex): BOOLEAN;
(* TRUE when the class (or an ancestor) has virtual methods. *)
PROCEDURE VirtSlot (ct: TypeIndex; name: ARRAY OF CHAR): INTEGER;
(* Vtable slot of the method, or -1 when it is not virtual. *)
PROCEDURE IsSubclass (sub, sup: TypeIndex): BOOLEAN;
(* TRUE when sub is sup or inherits (transitively) from sup. *)

PROCEDURE VptrOffset (ct: TypeIndex): INTEGER;
(* Byte offset of the class's vptr field (-1 when it has none). *)
PROCEDURE PushImplClass (ct: TypeIndex);
PROCEDURE PopImplClass;
PROCEDURE CurImplClass (): TypeIndex;
(* The innermost open CLASS IMPLEMENTATION's class (InvalidType none). *)

PROCEDURE VtClassCount (): CARDINAL;
PROCEDURE VtClassAt (k: CARDINAL): TypeIndex;
(* Classes that have a vtable, in build order. *)

PROCEDURE VtCount (ct: TypeIndex): CARDINAL;
PROCEDURE VtName (ct: TypeIndex; k: CARDINAL; VAR name: Name): BOOLEAN;
PROCEDURE VtHasBody (ct: TypeIndex; k: CARDINAL): BOOLEAN;
(* TRUE when slot k's method has an emitted body. *)
PROCEDURE VtUid (ct: TypeIndex; k: CARDINAL): CARDINAL;
(* Virtual-method slot k of ct (inherited slots first). *)


PROCEDURE ClassMethodUid (t: TypeIndex; name: ARRAY OF CHAR): CARDINAL;
(* Unique id of method name in class t or an ancestor (0 if none). *)
PROCEDURE ClassMethodNPar (t: TypeIndex; name: ARRAY OF CHAR): CARDINAL;
(* User formal count of the method (the hidden THIS excluded). *)
PROCEDURE ClassMethodRes (t: TypeIndex; name: ARRAY OF CHAR): TypeIndex;
(* Result type of the method (InvalidType if none/absent). *)
PROCEDURE ClassMethodParamType (t: TypeIndex; name: ARRAY OF CHAR;
                                i: CARDINAL): TypeIndex;
PROCEDURE ClassMethodParamIsVar (t: TypeIndex; name: ARRAY OF CHAR;
                                 i: CARDINAL): BOOLEAN;
(* User formal i of the method (index 0 skips the hidden THIS). *)

PROCEDURE PushClassMembers (t: TypeIndex): BOOLEAN;
(* Pushes a scope with t's fields (KindField) for method bodies in
   CLASS IMPLEMENTATION. FALSE if t is not a class. Method names
   are re-entered fresh by each body (copying them would collide);
   sibling-method references report 201 until step 4 calls. *)

(* ---------------- type descriptors ---------------- *)

PROCEDURE NewAlias (): TypeIndex;
PROCEDURE EnterTypeParam (name: ARRAY OF CHAR): BOOLEAN;
(* A generic formal type parameter: an unresolved alias type.  Its
   target is set when the generic is instantiated. *)

PROCEDURE EnterTypeParamBound (name: ARRAY OF CHAR;
                               actual: TypeIndex): BOOLEAN;
(* A generic formal bound to a concrete actual (instantiation re-parse):
   an alias type whose target is the actual. *)
PROCEDURE NewSubR (lo, hi: INTEGER): TypeIndex;
(* Integer subrange [lo..hi] (no base descriptor needed). Bounds
   accessors arrive with step 3; the backend cannot lower them yet. *)
PROCEDURE NewSubB (lo, hi: INTEGER; base: TypeIndex): TypeIndex;
(* Subrange [lo..hi] anchored on an ordinal base type (CHAR, BOOLEAN,
   enumeration): ClassOf follows the base so assignment compatibility
   and set spans treat e.g. ['A'..'Z'] as a character type, not an
   integer one. *)
PROCEDURE NewEnum (): TypeIndex;
PROCEDURE NewArrayB (elem: TypeIndex; lo, hi: INTEGER): TypeIndex;
(* Bounded array (one dimension; nest for multi-dim). InvalidType
   when the table is full. *)
PROCEDURE NewOpenArray (elem: TypeIndex): TypeIndex;
(* Open ARRAY OF formal: 0-based, runtime count in the header.
   Only legal for formal parameters (grammar enforces). *)

PROCEDURE BoundBegin;
PROCEDURE BoundAdd (lo, hi: INTEGER): BOOLEAN;
(* Accumulates one index bound pair for the enclosing ArrayType
   (max 8 dimensions, FALSE past that). *)
PROCEDURE BoundCount (): CARDINAL;
PROCEDURE BoundLo (i: CARDINAL): INTEGER;
PROCEDURE BoundHi (i: CARDINAL): INTEGER;
(* Read back the accumulated bounds (so a caller can snapshot them
   before parsing a nested element type that reuses the buffer). *)

PROCEDURE NewRecord (): TypeIndex;
PROCEDURE Unresolved (t: TypeIndex): BOOLEAN;
(* TRUE for a not-yet-completed (forward/unbound) type. *)
PROCEDURE IsOrdinal (t: TypeIndex): BOOLEAN;
(* integer family / CHAR / UCHAR / BOOLEAN / enumeration. *)

PROCEDURE ResetFields (rec: TypeIndex);
(* Starts a fresh variant branch (drops pending fields, clears layout). *)

PROCEDURE SetVariantTag (rec: TypeIndex; name : ARRAY OF CHAR);
(* Records the variant CASE selector field (by name). *)

PROCEDURE MarkVariant (rec: TypeIndex);
(* Marks rec as having a variant part (overlapping fields). *)
PROCEDURE IsVariant (rec: TypeIndex): BOOLEAN;
(* TRUE when rec has a variant part. *)
PROCEDURE NewSet (base: TypeIndex): TypeIndex;
PROCEDURE NewPackSet (base: TypeIndex): TypeIndex;
PROCEDURE NewBigSet (base: TypeIndex): TypeIndex;
(* ISO PACKEDSET: same base/span as SET but 1/2/4-byte storage
   (spans up to 32 bits in V3). *)
PROCEDURE NewPtr (base: TypeIndex): TypeIndex;
PROCEDURE NewStr (): TypeIndex;
PROCEDURE NewEmptyStr (): TypeIndex;
(* The empty string literal ""/''.  It is a string (compatible with a
   CHAR array) but, as ISO requires, also compatible with CHAR, where
   its value is the terminator 0.  Marked by tlo = -2 and tested with
   IsEmptyStr. *)
PROCEDURE NewUStr (): TypeIndex;
(* UString literal type: LONGCARD count + count x UCHAR codepoints. *)
PROCEDURE NewClass (): TypeIndex;
(* Fresh class descriptor (holds fields like a record; methods live
   in the class scope). Parent and scope via SetParent/PushClassScope. *)
(* Fresh descriptors; base/elem may be InvalidType. InvalidType is
   returned when the table is full. *)

PROCEDURE SetTarget (t, base: TypeIndex);
(* Sets an alias target (TYPE declaration completion). *)

PROCEDURE BeginTypeBlock;
PROCEDURE EndTypeBlock;
(* Delimit a TYPE block so ForwardType is only active inside one. *)

PROCEDURE ForwardType (name: ARRAY OF CHAR): TypeIndex;
(* Inside a TYPE block: if name is not yet declared, enters it as an
   unresolved forward alias and returns its type index (completed by
   the later TypeItem via SetTarget). InvalidType when the name is
   already known or forward references are not permitted. *)

PROCEDURE IsUnresolved (t: TypeIndex): BOOLEAN;
(* TRUE for a forward placeholder whose target is not yet declared. *)
PROCEDURE FwdPending (): CARDINAL;
PROCEDURE FwdInfo (i: CARDINAL; VAR name: Name; VAR unresolved: BOOLEAN);
(* Module-level forward type references: enumerate them at module end
   and flag those never completed (undeclared type). *)
PROCEDURE FwdClear;

PROCEDURE DeferReset;
(* Fresh deferral table per unit (two-phase parse). *)
PROCEDURE DeferBody (): CARDINAL;
(* Records the current procedure's own scope for a skipped body;
   returns the deferral index (65535 on failure). *)
PROCEDURE ReenterDeferred (idx: CARDINAL): BOOLEAN;
(* Restores a deferred body scope for the re-parse pass. *)
PROCEDURE OrderCheckOff;
(* Ends the use-before-declaration window for a deferred body. *)

PROCEDURE IntType (): TypeIndex;
PROCEDURE UCharType (): TypeIndex;
(* UCHAR: 32-bit Unicode codepoint (QBE w). *)
PROCEDURE RealType (): TypeIndex;
PROCEDURE CharType (): TypeIndex;
PROCEDURE BoolType (): TypeIndex;
PROCEDURE LongType (): TypeIndex;
(* LONGINT/LONGCARD: 64-bit integer (QBE l). *)
PROCEDURE AddrType (): TypeIndex;
(* ADDRESS: the pointer-sized opaque type (interchangeable with any
   pointer for assignment and VAR parameters). *)

PROCEDURE ObjectSize (t: TypeIndex): CARDINAL;
(* Full allocation footprint (arrays 8 + count*element); drives
   SYSTEM.SIZE/TSIZE. *)

PROCEDURE ClassOf (t: TypeIndex): INTEGER;
(* Resolves aliases; InvalidType maps to ClInvalid. *)

PROCEDURE IsIntFamily (t: TypeIndex): BOOLEAN;
(* INTEGER, CARDINAL or subrange thereof (Invalid suppresses). *)

PROCEDURE IsByteType (t: TypeIndex): BOOLEAN;
(* BYTE/SBYTE (8-bit storage; values are passed as 32-bit words). *)

PROCEDURE IsSignedByte (t: TypeIndex): BOOLEAN;
(* SBYTE (sign-extended loads). *)

PROCEDURE IsWord16Type (t: TypeIndex): BOOLEAN;
(* WORD16/INTEGER16 (16-bit storage). *)

PROCEDURE IsSignedWord16 (t: TypeIndex): BOOLEAN;
(* INTEGER16 (sign-extended loads). *)

PROCEDURE IsSmallInt (t: TypeIndex): BOOLEAN;
(* BYTE/SBYTE/WORD16/INTEGER16 (1- or 2-byte storage). *)

PROCEDURE SmallIntBytes (t: TypeIndex): CARDINAL;
(* 1 for BYTE/SBYTE, 2 for WORD16/INTEGER16, 0 otherwise. *)

PROCEDURE IsSignedSmallInt (t: TypeIndex): BOOLEAN;
(* SBYTE/INTEGER16 (sign-extended loads). *)

PROCEDURE IsLongFamily (t: TypeIndex): BOOLEAN;
(* LONGINT/LONGCARD (QBE l). *)

PROCEDURE SameType (a, b: TypeIndex): BOOLEAN;
(* Same resolved descriptor (Invalid suppresses). *)

PROCEDURE FieldExists (rec: TypeIndex; name: ARRAY OF CHAR): BOOLEAN;
PROCEDURE FieldType (rec: TypeIndex; name: ARRAY OF CHAR): TypeIndex;
PROCEDURE ArrayElem (t: TypeIndex): TypeIndex;
PROCEDURE IsCharArray (t: TypeIndex): BOOLEAN;
(* TRUE for arrays whose elements are CHAR: such arrays reserve one
   extra zero byte (index = count) so NUL-scanning works, matching
   gm2's NUL-terminated strings. *)
PROCEDURE IsOpenArray (t: TypeIndex): BOOLEAN;
PROCEDURE MarkByteBuf (t: TypeIndex);
(* Mark an open array as an `ARRAY OF BYTE` formal (gm2 ext). *)
PROCEDURE IsByteBuf (t: TypeIndex): BOOLEAN;
(* TRUE for an `ARRAY OF BYTE` open-array formal. *)
PROCEDURE ByteBufOk (at, ft: TypeIndex): BOOLEAN;
(* gm2 ext: a scalar/pointer/string actual is accepted for `ARRAY OF BYTE`. *)
PROCEDURE TypesOverflow (): BOOLEAN;
(* TRUE once MaxTypes was exhausted (an implementation limit). *)
PROCEDURE ArrayLo (t: TypeIndex): INTEGER;
PROCEDURE ArrayHi (t: TypeIndex): INTEGER;
(* Static bounds (open arrays: lo 0, hi undefined — backend reads
   the header instead). InvalidType maps to 0. *)
PROCEDURE ArrayLen (t: TypeIndex): CARDINAL;
(* Static element count, 0 for open/invalid. *)
PROCEDURE ArrayDepth (t: TypeIndex): CARDINAL;
(* Nesting depth (open/fixed levels); 0 for non-arrays. *)
PROCEDURE ArrayRank (t: TypeIndex): CARDINAL;
(* Alias for ArrayDepth, named for the open-array ABI. *)
PROCEDURE IsMultiArray (t: TypeIndex): BOOLEAN;
(* TRUE when the array rank is greater than one. *)
PROCEDURE ArrayLeafBytes (t: TypeIndex): CARDINAL;
(* Payload bytes of the scalar/record leaf element of an array; 0 for
   non-arrays or invalid types. *)
PROCEDURE ArrayStride (t: TypeIndex; level: CARDINAL): CARDINAL;
(* Bytes between adjacent elements at a 0-based array level for a fixed
   array; 0 when the level is invalid or a lower count is open/unknown. *)
PROCEDURE ArrayPayloadSize (t: TypeIndex): CARDINAL;
(* Static payload bytes of a fully fixed array (header excluded); 0 for
   open/invalid/non-array types. *)

PROCEDURE TypeSize (t: TypeIndex): CARDINAL;
(* Inline footprint in bytes: scalars 4/8, sets words*4, pointers,
   open and fixed arrays 8 (descriptor address), records sum of
   members. *)

PROCEDURE FieldOffset (rec: TypeIndex; name: ARRAY OF CHAR): INTEGER;
(* Declaration-order byte offset (-1 if absent). Computed lazily. *)


PROCEDURE FieldCount (rec: TypeIndex): CARDINAL;
PROCEDURE FieldName (rec: TypeIndex; i: CARDINAL; VAR name: Name);
(* Field enumeration for whole-record lowering (order irrelevant). *)

PROCEDURE SubBounds (t: TypeIndex; VAR lo, hi: INTEGER): BOOLEAN;
(* TRUE with the bounds when t resolves to a subrange. *)
PROCEDURE SetBase (t: TypeIndex): TypeIndex;
(* Base type of a set descriptor (InvalidType if none). *)
PROCEDURE SetWords (t: TypeIndex): CARDINAL;
PROCEDURE SetBytes (t: TypeIndex): CARDINAL;
(* Storage bytes: SET = SetWords*4, PACKEDSET = ceil(count/8) (1..4). *)
PROCEDURE IsPackedSet (t: TypeIndex): BOOLEAN;
PROCEDURE IsBigSet (t: TypeIndex): BOOLEAN;
PROCEDURE BigSetSigned (t: TypeIndex): BOOLEAN;
(* Mask words for a set type from its base span (bool 1, char 8,
   subrange by bounds); 0 when the base is unsuitable. *)
PROCEDURE SetBaseLo (t: TypeIndex): INTEGER;
(* Base minimum (bool/char 0, subrange lo); 0 when unsuitable. *)
PROCEDURE SetCount (t: TypeIndex): CARDINAL;
(* Base span in values (0 when unsuitable). *)
PROCEDURE IsCardinalType (t: TypeIndex): BOOLEAN;
(* TRUE for the predefined CARDINAL type (wide SET base). *)
PROCEDURE TypeBounds (t: TypeIndex; VAR lo, hi: INTEGER): BOOLEAN;
(* Ordinal bounds of a type (MIN/MAX): subrange/array, CHAR/UCHAR,
   BOOLEAN, enumeration, set base, or the integer family. *)
PROCEDURE SetEnumCount (t: TypeIndex; n: CARDINAL);
(* Records the number of literals of an enumeration type. *)
PROCEDURE EnumCount (t: TypeIndex): CARDINAL;
(* Literal count of an enumeration type (0 when not an enum). *)
PROCEDURE NoteEnumLit (t: TypeIndex; name: ARRAY OF CHAR);
(* Registers one enumeration literal (the grammar's Enum action). *)
PROCEDURE EnterEnumLits (t: TypeIndex): CARDINAL;
(* Makes an enum type's literals visible in the current scope (the type
   was just declared or imported), returning how many were newly
   entered.  Modula-2 exports/imports a type's literals with the type. *)
PROCEDURE PtrBase (t: TypeIndex): TypeIndex;

(* ---------------- procedure types (step 8.5) ---------------- *)
(* PROCEDURE (params): result as a value type. Values are code
   pointers (pointer-sized); calls through them are indirect. Param
   lists are collected with ProcTypeBegin/ProcTypeAdd and finalised
   by NewProcType (same pattern as array bounds). *)

PROCEDURE NewProcType (res: TypeIndex): TypeIndex;
(* Fresh procedure type (result may be InvalidType, set later). Its
   parameters are appended in order with ProcTypeAdd. *)
PROCEDURE ProcTypeAdd (t: TypeIndex; isVar: BOOLEAN; pt: TypeIndex);
PROCEDURE SetProcTypeRes (t: TypeIndex; res: TypeIndex);

PROCEDURE ProcTypeNPar (t: TypeIndex): CARDINAL;
PROCEDURE ProcTypeParamType (t: TypeIndex; i: CARDINAL): TypeIndex;
PROCEDURE ProcTypeParamIsVar (t: TypeIndex; i: CARDINAL): BOOLEAN;
PROCEDURE ProcTypeRes (t: TypeIndex): TypeIndex;
(* Accessors for a procedure type (0/InvalidType when not one). *)

PROCEDURE ProcTypeOf (name: ARRAY OF CHAR): TypeIndex;
(* Builds the procedure type descriptor for procedure name (for using
   a procedure as a value). InvalidType if name is not a procedure. *)

(* ---------------- predicates used by grammar checks ---------------- *)
(* All return TRUE if either operand is InvalidType (no cascades). *)

PROCEDURE Assignable (src, dst: TypeIndex): BOOLEAN;
(* Assignment compatibility (210). *)

PROCEDURE ArithCheck (l, r: TypeIndex; divmod: BOOLEAN;
                      VAR res: TypeIndex): BOOLEAN;
(* + - * / (divmod FALSE) or DIV MOD (TRUE); res is result type (211). *)


PROCEDURE BoolCheck (t: TypeIndex): BOOLEAN;
(* BOOLEAN required: NOT/AND/OR operands (212), conditions (214). *)

PROCEDURE RelCheck (l, r: TypeIndex; op: INTEGER): BOOLEAN;
(* = # <> < <= > >= IN (213/222 chosen by caller via op). *)

PROCEDURE IsStrType (t: TypeIndex): BOOLEAN;
(* A string literal (ClStr) or a 1-D ARRAY OF CHAR. *)

PROCEDURE IsEmptyStr (t: TypeIndex): BOOLEAN;
(* TRUE for the empty string literal "" (compatible with CHAR too). *)

PROCEDURE UStrCompat (l, r: TypeIndex): BOOLEAN;
(* Both operands are UString literals (U"..."): `+` concatenates. *)

PROCEDURE IsUCharArray (t: TypeIndex): BOOLEAN;
(* A 1-D ARRAY OF UCHAR (a U"..." content-copy destination). *)

PROCEDURE StrCompat (l, r: TypeIndex): BOOLEAN;
(* Both operands are string-compatible (ClStr / 1-D ARRAY OF CHAR):
   `=`/`#` compare content via the shim. *)

PROCEDURE EqCheck (l, r: TypeIndex): BOOLEAN;
(* = # compatibility, also reused for CASE label matching. *)

PROCEDURE InCheck (l, set: TypeIndex): BOOLEAN;
(* Membership `l IN set`. *)
PROCEDURE SetElemClassOk (c: INTEGER): BOOLEAN;
(* TRUE for an element class acceptable in a set constructor. *)

PROCEDURE StrLen (s: ARRAY OF CHAR): CARDINAL;

PROCEDURE ConstInt (q: ARRAY OF CHAR; VAR v: INTEGER): BOOLEAN;
(* Parses a folded integer immediate ("42", "-5", "16") as produced
   by NormInt/NegFold. FALSE for temporaries and non-numerics. *)

END SymTab.