lower L7: remove SymTab/QbeGen procedures made dead by the flip

Unreferenced from the grammar, Lower and the tests (verified with a
whole-tree scan): SymTab's CurModule/CurUnit/ProcDepth/ParamName/
ModDefined/ModImplemented/QualFind/QualKind/QualProcUid/QualProcNPar/
QualParamType/QualParamIsVar/QualProcRes/NestArray/NewSub/SetElemCheck/
SetFor/UnaryCheck/FwdVarKind, and QbeGen.StrLen.

(AST.AddChild/SetKind/TxtLen looked dead too but t_ast.mod uses the
first two, so AST is left alone.)

Suite 204/204; FIXPOINT OK (3,423,008 bytes).

compiler/src/QbeGen.def

@@ -402,8 +402,6 @@ PROCEDURE SetBinOp (sel: INTEGER; l: ARRAY OF CHAR; r: ARRAY OF CHAR;
 PROCEDURE StrEq (op: INTEGER; l, r: ARRAY OF CHAR; VAR q: QVal);
 (* String equality (`=`/`OpNeq`) via the shim; result BOOLEAN. *)
 
-PROCEDURE StrLen (s: ARRAY OF CHAR; VAR q: QVal);
-(* q := the string length (characters before the NUL), INTEGER. *)
 
 PROCEDURE StrAssign (dst, src: ARRAY OF CHAR);
 (* Content copy of a string into a CHAR array (NUL-terminated). *)

compiler/src/QbeGen.mod

@@ -1922,13 +1922,6 @@ PROCEDURE StrEq (op: INTEGER; l, r: ARRAY OF CHAR; VAR q: QVal);
     END
   END StrEq;
 
-PROCEDURE StrLen (s: ARRAY OF CHAR; VAR q: QVal);
-(* q := the number of characters before the NUL (INTEGER). *)
-  BEGIN
-    NewTemp(q);
-    W("  "); W(q); W(" =w call $m2strlen(l "); W(s); WL(")")
-  END StrLen;
-
 PROCEDURE StrAssign (dst, src: ARRAY OF CHAR);
 (* Copy the string src into the CHAR array at dst (content copy,
    truncated to the destination capacity, NUL-terminated). *)

compiler/src/SymTab.def

@@ -201,8 +201,6 @@ PROCEDURE CurRes (): TypeIndex;
 (* Result type of the innermost open procedure,
    InvalidType outside procedures or for proper procedures. *)
 
-PROCEDURE ProcDepth (): CARDINAL;
-(* Number of open procedure headings/bodies (nesting depth). *)
 
 PROCEDURE ProcDepthOf (name: ARRAY OF CHAR): CARDINAL;
 (* Lexical function-nesting depth of the named procedure
@@ -218,11 +216,6 @@ 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 out: ARRAY OF CHAR): BOOLEAN;
-(* The i-th formal's name (FALSE when out of range).  Read-only helper
-   for the two-phase Lower walk. *)
-
 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. *)
@@ -248,19 +241,13 @@ PROCEDURE BeginProg (name: ARRAY OF CHAR): BOOLEAN;
 PROCEDURE EndUnit;
 (* Returns to the global scope. *)
 
-PROCEDURE CurUnit (): INTEGER;
-(* Unit kind currently open (UnitProg/Def/Impl); -1 between units. *)
 
-PROCEDURE CurModule (VAR name: Name);
-(* Name of the module currently open ('' between units). *)
 
 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 ModDefined (name: ARRAY OF CHAR): BOOLEAN;
-PROCEDURE ModImplemented (name: ARRAY OF CHAR): BOOLEAN;
 
 PROCEDURE ImportFrom (mod, name: ARRAY OF CHAR): BOOLEAN;
 (* Materializes an exported name from mod into the current scope
@@ -271,16 +258,8 @@ PROCEDURE OpaqueBase (name: ARRAY OF CHAR): TypeIndex;
    returns that alias descriptor so the implementation can complete
    it via SetTarget; InvalidType otherwise. *)
 
-PROCEDURE QualFind (mod, name: ARRAY OF CHAR): BOOLEAN;
-(* TRUE when mod exports name. *)
 
-PROCEDURE QualKind (mod, name: ARRAY OF CHAR): INTEGER;
 PROCEDURE QualType (mod, name: ARRAY OF CHAR): TypeIndex;
-PROCEDURE QualProcUid (mod, name: ARRAY OF CHAR): CARDINAL;
-PROCEDURE QualProcNPar (mod, name: ARRAY OF CHAR): CARDINAL;
-PROCEDURE QualParamType (mod, name: ARRAY OF CHAR; i: CARDINAL): TypeIndex;
-PROCEDURE QualParamIsVar (mod, name: ARRAY OF CHAR; i: CARDINAL): BOOLEAN;
-PROCEDURE QualProcRes (mod, name: ARRAY OF CHAR): TypeIndex;
 
 PROCEDURE ExportUp (name: ARRAY OF CHAR);
 (* Nested-module END: clones the entry `name` from the just-finished
@@ -389,7 +368,6 @@ PROCEDURE PushClassMembers (t: TypeIndex): BOOLEAN;
 (* ---------------- type descriptors ---------------- *)
 
 PROCEDURE NewAlias (): TypeIndex;
-PROCEDURE NewSub (base: TypeIndex): TypeIndex;
 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. *)
@@ -411,8 +389,6 @@ 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 NestArray (elem: TypeIndex): TypeIndex;
-(* Nests the accumulated bounds inside-out around elem. *)
 PROCEDURE NewRecord (): TypeIndex;
 PROCEDURE IsOrdinal (t: TypeIndex): BOOLEAN;
 (* integer family / CHAR / UCHAR / BOOLEAN / enumeration. *)
@@ -465,7 +441,6 @@ PROCEDURE FwdVarRef (name: ARRAY OF CHAR; kind: INTEGER;
    body before its declaration (forward variable).  kind is KindVar
    (variable) or KindProc (procedure); id/t identify the placeholder. *)
 PROCEDURE FwdVarType (id: INTEGER): TypeIndex;
-PROCEDURE FwdVarKind (id: INTEGER): INTEGER;
 PROCEDURE IsFwdVar (t: TypeIndex): BOOLEAN;
 (* TRUE for a forward-variable placeholder: type checks are lenient. *)
 
@@ -587,8 +562,6 @@ PROCEDURE ArithCheck (l, r: TypeIndex; divmod: BOOLEAN;
                       VAR res: TypeIndex): BOOLEAN;
 (* + - * / (divmod FALSE) or DIV MOD (TRUE); res is result type (211). *)
 
-PROCEDURE UnaryCheck (t: TypeIndex; VAR res: TypeIndex): BOOLEAN;
-(* Unary + - (part of 211). *)
 
 PROCEDURE BoolCheck (t: TypeIndex): BOOLEAN;
 (* BOOLEAN required: NOT/AND/OR operands (212), conditions (214). *)
@@ -616,9 +589,6 @@ 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 SetElemCheck (first, elem: TypeIndex): BOOLEAN;
-PROCEDURE SetFor (elem: TypeIndex): TypeIndex;
-(* Fresh SET OF elem descriptor for set literals. *)
 
 PROCEDURE StrLen (s: ARRAY OF CHAR): CARDINAL;
 

compiler/src/SymTab.mod

@@ -631,11 +631,6 @@ PROCEDURE NewAlias (): TypeIndex;
     RETURN NewDesc(FAlias, InvalidType)
   END NewAlias;
 
-PROCEDURE NewSub (base: TypeIndex): TypeIndex;
-  BEGIN
-    RETURN NewDesc(FSub, base)
-  END NewSub;
-
 PROCEDURE NewSubR (lo, hi: INTEGER): TypeIndex;
   VAR t: TypeIndex;
   BEGIN
@@ -702,17 +697,6 @@ PROCEDURE BoundHi (i: CARDINAL): INTEGER;
     IF i < nBounds THEN RETURN bhi[i] ELSE RETURN -1 END
   END BoundHi;
 
-PROCEDURE NestArray (elem: TypeIndex): TypeIndex;
-  VAR i: CARDINAL;
-  BEGIN
-    i := nBounds;
-    WHILE i > 0 DO
-      DEC(i);
-      elem := NewArrayB(elem, blo[i], bhi[i])
-    END;
-    RETURN elem
-  END NestArray;
-
 PROCEDURE NewRecord (): TypeIndex;
   BEGIN
     RETURN NewDesc(FRecord, -1)
@@ -2153,11 +2137,6 @@ PROCEDURE CurRes (): TypeIndex;
     RETURN procStk[nProc - 1]^.rslt
   END CurRes;
 
-PROCEDURE ProcDepth (): CARDINAL;
-  BEGIN
-    RETURN nProc
-  END ProcDepth;
-
 PROCEDURE ProcDepthOf (name: ARRAY OF CHAR): CARDINAL;
   VAR node: SymPtr;
   BEGIN
@@ -2219,20 +2198,6 @@ PROCEDURE ParamIsVar (name: ARRAY OF CHAR; i: CARDINAL): BOOLEAN;
     RETURN p^.isVar
   END ParamIsVar;
 
-PROCEDURE ParamName (name: ARRAY OF CHAR; i: CARDINAL;
-                     VAR out: ARRAY OF CHAR): BOOLEAN;
-  VAR node, p: SymPtr;
-  BEGIN
-    out[0] := CHR(0);
-    node := Find(name);
-    IF node = NIL THEN RETURN FALSE END;
-    IF node^.kind # KindProc THEN RETURN FALSE END;
-    p := NthParam(node, i);
-    IF p = NIL THEN RETURN FALSE END;
-    Assign(out, p^.name);
-    RETURN TRUE
-  END ParamName;
-
 
 (* ---------------- modules / separate compilation (step 4.3) ---------------- *)
 
@@ -2335,37 +2300,11 @@ PROCEDURE EndUnit;
     curUnit := -1
   END EndUnit;
 
-PROCEDURE CurUnit (): INTEGER;
-  BEGIN
-    RETURN curUnit
-  END CurUnit;
-
-PROCEDURE CurModule (VAR name: Name);
-  BEGIN
-    IF curMod < 0 THEN name[0] := CHR(0)
-    ELSE Assign(name, modNames[curMod])
-    END
-  END CurModule;
-
 PROCEDURE ModKnown (name: ARRAY OF CHAR): BOOLEAN;
   BEGIN
     RETURN FindMod(name) # -1
   END ModKnown;
 
-PROCEDURE ModDefined (name: ARRAY OF CHAR): BOOLEAN;
-  VAR i : INTEGER;
-  BEGIN
-    i := FindMod(name);
-    RETURN (i # -1) AND (modKind[i] # UnitProg)
-  END ModDefined;
-
-PROCEDURE ModImplemented (name: ARRAY OF CHAR): BOOLEAN;
-  VAR i : INTEGER;
-  BEGIN
-    i := FindMod(name);
-    RETURN (i # -1) AND modImpl[i]
-  END ModImplemented;
-
 PROCEDURE OpaqueBase (name: ARRAY OF CHAR): TypeIndex;
   VAR node: SymPtr;
     r : TypeIndex;
@@ -2450,19 +2389,6 @@ PROCEDURE QualNode (mod, name: ARRAY OF CHAR): SymPtr;
     RETURN TreeFind(modScopes[i]^.root, name)
   END QualNode;
 
-PROCEDURE QualFind (mod, name: ARRAY OF CHAR): BOOLEAN;
-  BEGIN
-    RETURN QualNode(mod, name) # NIL
-  END QualFind;
-
-PROCEDURE QualKind (mod, name: ARRAY OF CHAR): INTEGER;
-  VAR n : SymPtr;
-  BEGIN
-    n := QualNode(mod, name);
-    IF n = NIL THEN RETURN -1 END;
-    RETURN n^.kind
-  END QualKind;
-
 PROCEDURE QualType (mod, name: ARRAY OF CHAR): TypeIndex;
   VAR n : SymPtr;
   BEGIN
@@ -2471,15 +2397,6 @@ PROCEDURE QualType (mod, name: ARRAY OF CHAR): TypeIndex;
     RETURN n^.typ
   END QualType;
 
-PROCEDURE QualProcUid (mod, name: ARRAY OF CHAR): CARDINAL;
-  VAR n : SymPtr;
-  BEGIN
-    n := QualNode(mod, name);
-    IF n = NIL THEN RETURN 0 END;
-    IF n^.kind # KindProc THEN RETURN 0 END;
-    RETURN n^.uid
-  END QualProcUid;
-
 PROCEDURE QualNthParam (n: SymPtr; i: CARDINAL): SymPtr;
   BEGIN
     n := n^.plink;
@@ -2489,51 +2406,6 @@ PROCEDURE QualNthParam (n: SymPtr; i: CARDINAL): SymPtr;
     RETURN n
   END QualNthParam;
 
-PROCEDURE QualProcNPar (mod, name: ARRAY OF CHAR): CARDINAL;
-  VAR n, p : SymPtr;
-    c : CARDINAL;
-  BEGIN
-    n := QualNode(mod, name);
-    IF n = NIL THEN RETURN 0 END;
-    IF n^.kind # KindProc THEN RETURN 0 END;
-    c := 0; p := n^.plink;
-    WHILE p # NIL DO INC(c); p := p^.plink END;
-    RETURN c
-  END QualProcNPar;
-
-PROCEDURE QualParamType (mod, name: ARRAY OF CHAR; i: CARDINAL):
-                                                            TypeIndex;
-  VAR n, p : SymPtr;
-  BEGIN
-    n := QualNode(mod, name);
-    IF n = NIL THEN RETURN InvalidType END;
-    IF n^.kind # KindProc THEN RETURN InvalidType END;
-    p := QualNthParam(n, i);
-    IF p = NIL THEN RETURN InvalidType END;
-    RETURN p^.typ
-  END QualParamType;
-
-PROCEDURE QualParamIsVar (mod, name: ARRAY OF CHAR; i: CARDINAL):
-                                                             BOOLEAN;
-  VAR n, p : SymPtr;
-  BEGIN
-    n := QualNode(mod, name);
-    IF n = NIL THEN RETURN FALSE END;
-    IF n^.kind # KindProc THEN RETURN FALSE END;
-    p := QualNthParam(n, i);
-    IF p = NIL THEN RETURN FALSE END;
-    RETURN p^.isVar
-  END QualParamIsVar;
-
-PROCEDURE QualProcRes (mod, name: ARRAY OF CHAR): TypeIndex;
-  VAR n : SymPtr;
-  BEGIN
-    n := QualNode(mod, name);
-    IF n = NIL THEN RETURN InvalidType END;
-    IF n^.kind # KindProc THEN RETURN InvalidType END;
-    RETURN n^.rslt
-  END QualProcRes;
-
 PROCEDURE ExportUp (name: ARRAY OF CHAR);
   VAR src, node: SymPtr;
     parent: ScopePtr;
@@ -2735,14 +2607,6 @@ PROCEDURE FwdVarType (id: INTEGER): TypeIndex;
     RETURN InvalidType
   END FwdVarType;
 
-PROCEDURE FwdVarKind (id: INTEGER): INTEGER;
-  BEGIN
-    IF (id >= 1) AND (id <= VAL(INTEGER, nFwdVar)) THEN
-      RETURN fwdVarKind[id - 1]
-    END;
-    RETURN -1
-  END FwdVarKind;
-
 PROCEDURE FwdVarResolve (id: INTEGER): BOOLEAN;
 (* Resolves forward reference id against the module's declarations.
    TRUE when the name now exists; sets the recorded placeholder's
@@ -2917,17 +2781,6 @@ PROCEDURE ArithCheck (l, r: TypeIndex; divmod: BOOLEAN;
     RETURN FALSE
   END ArithCheck;
 
-PROCEDURE UnaryCheck (t: TypeIndex; VAR res: TypeIndex): BOOLEAN;
-  BEGIN
-    res := InvalidType;
-    IF IsFwdVar(t) THEN res := dInt; RETURN TRUE END;
-    IF t = InvalidType THEN RETURN TRUE END;
-    IF IsLongFamily(t) THEN res := dLong; RETURN TRUE END;
-    IF IsIntFamily(t) THEN res := dInt; RETURN TRUE END;
-    IF ClassOf(t) = ClReal THEN res := dReal; RETURN TRUE END;
-    RETURN FALSE
-  END UnaryCheck;
-
 PROCEDURE BoolCheck (t: TypeIndex): BOOLEAN;
   BEGIN
     IF t = InvalidType THEN RETURN TRUE END;
@@ -3083,24 +2936,6 @@ PROCEDURE RelCheck (l, r: TypeIndex; op: INTEGER): BOOLEAN;
     RETURN OrdCheck(l, r)
   END RelCheck;
 
-PROCEDURE SetElemCheck (first, elem: TypeIndex): BOOLEAN;
-  BEGIN
-    IF (first = InvalidType) OR (elem = InvalidType) THEN
-      RETURN TRUE
-    END;
-    IF SameType(first, elem) THEN RETURN TRUE END;
-    IF IsIntFamily(first) AND IsIntFamily(elem) THEN RETURN TRUE END;
-    RETURN FALSE
-  END SetElemCheck;
-
-PROCEDURE SetFor (elem: TypeIndex): TypeIndex;
-  VAR e: TypeIndex;
-  BEGIN
-    e := Resolve(elem);
-    IF e = InvalidType THEN e := dInt END;
-    RETURN NewSet(e)
-  END SetFor;
-
 (* ---------------- init ---------------- *)
 
 PROCEDURE Predef (name: ARRAY OF CHAR; kind: INTEGER; t: TypeIndex);