modula2: tidyup remove unused procedures and unused parameters

This patch removes M2GenGCC.mod:QuadCondition and
M2Quads.mod:GenQuadOTypeUniquetok.  It also removes unused parameter
WalkAction for all FoldIf procedures.

gcc/m2/ChangeLog:

	* gm2-compiler/M2GenGCC.mod (QuadCondition): Remove.
	(FoldIfEqu): Remove WalkAction parameter.
	(FoldIfNotEqu): Ditto.
	(FoldIfGreEqu): Ditto.
	(FoldIfLessEqu): Ditto.
	(FoldIfGre): Ditto.
	(FoldIfLess): Ditto.
	(FoldIfIn): Ditto.
	(FoldIfNotIn): Ditto.
	* gm2-compiler/M2Quads.mod (GenQuadOTypeUniquetok): Remove.

Signed-off-by: Gaius Mulley <gaiusmod2@gmail.com>

diff --git a/gcc/m2/gm2-compiler/M2GenGCC.mod b/gcc/m2/gm2-compiler/M2GenGCC.mod
index c59695a37795939fa593d8f734bd03f4b30f1675..fc3fa204ac0a50fe903a8e9f2fd9a21d96db241f 100644 (file)
--- a/gcc/m2/gm2-compiler/M2GenGCC.mod
+++ b/gcc/m2/gm2-compiler/M2GenGCC.mod
@@ -637,14 +637,14 @@ BEGIN
          CastOp             : FoldCast (tokenno, p, quad, op1, op2, op3) |
          InclOp             : FoldIncl (tokenno, p, quad, op1, op3) |
          ExclOp             : FoldExcl (tokenno, p, quad, op1, op3) |
-         IfEquOp            : FoldIfEqu (tokenno, p, quad, op1, op2, op3) |
-         IfNotEquOp         : FoldIfNotEqu (tokenno, p, quad, op1, op2, op3) |
-         IfLessOp           : FoldIfLess (tokenno, p, quad, op1, op2, op3) |
-         IfLessEquOp        : FoldIfLessEqu (tokenno, p, quad, op1, op2, op3) |
-         IfGreOp            : FoldIfGre (tokenno, p, quad, op1, op2, op3) |
-         IfGreEquOp         : FoldIfGreEqu (tokenno, p, quad, op1, op2, op3) |
-         IfInOp             : FoldIfIn (tokenno, p, quad, op1, op2, op3) |
-         IfNotInOp          : FoldIfNotIn (tokenno, p, quad, op1, op2, op3) |
+         IfEquOp            : FoldIfEqu (tokenno, quad, op1, op2, op3) |
+         IfNotEquOp         : FoldIfNotEqu (tokenno, quad, op1, op2, op3) |
+         IfLessOp           : FoldIfLess (tokenno, quad, op1, op2, op3) |
+         IfLessEquOp        : FoldIfLessEqu (tokenno, quad, op1, op2, op3) |
+         IfGreOp            : FoldIfGre (tokenno, quad, op1, op2, op3) |
+         IfGreEquOp         : FoldIfGreEqu (tokenno, quad, op1, op2, op3) |
+         IfInOp             : FoldIfIn (tokenno, quad, op1, op2, op3) |
+         IfNotInOp          : FoldIfNotIn (tokenno, quad, op1, op2, op3) |
          LogicalShiftOp     : FoldSetShift(tokenno, p, quad, op1, op2, op3) |
          LogicalRotateOp    : FoldSetRotate (tokenno, p, quad, op1, op2, op3) |
          ParamOp            : FoldBuiltinFunction (tokenno, p, quad, op1, op2, op3) |
@@ -5332,7 +5332,7 @@ END FoldIncl ;
                 if op1 < op2 then goto op3.
 *)
 
-PROCEDURE FoldIfLess (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfLess (tokenno: CARDINAL;
                       quad: CARDINAL; left, right, destQuad: CARDINAL) ;
 BEGIN
    (* Firstly ensure that constant literals are declared.  *)
@@ -5357,57 +5357,12 @@ BEGIN
 END FoldIfLess ;
 
 
-(*
-   QuadCondition - Pre-condition:  left, right operands are constants
-                   which have been resolved.
-                   Post-condition: return TRUE if the condition at
-                   quad is TRUE.
-*)
-
-PROCEDURE QuadCondition (quad: CARDINAL) : BOOLEAN ;
-VAR
-   left, right, dest, combined,
-   leftpos, rightpos, destpos : CARDINAL ;
-   constExpr, overflow        : BOOLEAN ;
-   op                         : QuadOperator ;
-BEGIN
-   GetQuadOtok (quad, combined, op,
-                left, right, dest, overflow,
-                constExpr,
-                leftpos, rightpos, destpos) ;
-   CASE op OF
-
-   IfInOp     :  PushValue (right) ;
-                 RETURN SetIn (left, combined) |
-   IfNotInOp  :  PushValue (right) ;
-                 RETURN NOT SetIn (left, combined)
-
-   ELSE
-   END ;
-   PushValue (left) ;
-   PushValue (right) ;
-   CASE op OF
-
-   IfGreOp    :  RETURN Gre (combined) |
-   IfLessOp   :  RETURN Less (combined) |
-   IfLessEquOp:  RETURN LessEqu (combined) |
-   IfGreEquOp :  RETURN GreEqu (combined) |
-   IfEquOp    :  RETURN GreEqu (combined) |
-   IfNotEquOp :  RETURN NotEqu (combined)
-
-   ELSE
-      InternalError ('unrecognized comparison operator')
-   END ;
-   RETURN FALSE
-END QuadCondition ;
-
-
 (*
    FoldIfGre - check to see if it is possible to evaluate
                if op1 > op2 then goto op3.
 *)
 
-PROCEDURE FoldIfGre (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfGre (tokenno: CARDINAL;
                      quad: CARDINAL;
                      left, right, destQuad: CARDINAL) ;
 BEGIN
@@ -5438,7 +5393,7 @@ END FoldIfGre ;
                    if op1 <= op2 then goto op3.
 *)
 
-PROCEDURE FoldIfLessEqu (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfLessEqu (tokenno: CARDINAL;
                          quad: CARDINAL;
                          left, right, destQuad: CARDINAL) ;
 BEGIN
@@ -5469,7 +5424,7 @@ END FoldIfLessEqu ;
                   if op1 >= op2 then goto op3.
 *)
 
-PROCEDURE FoldIfGreEqu (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfGreEqu (tokenno: CARDINAL;
                         quad: CARDINAL;
                         left, right, destQuad: CARDINAL) ;
 BEGIN
@@ -5500,7 +5455,7 @@ END FoldIfGreEqu ;
               if op1 in op2 then goto op3
 *)
 
-PROCEDURE FoldIfIn (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfIn (tokenno: CARDINAL;
                     quad: CARDINAL;
                     left, right, destQuad: CARDINAL) ;
 BEGIN
@@ -5535,7 +5490,7 @@ END FoldIfIn ;
                  if not (op1 in op2) then goto op3
 *)
 
-PROCEDURE FoldIfNotIn (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfNotIn (tokenno: CARDINAL;
                        quad: CARDINAL;
                        left, right, destQuad: CARDINAL) ;
 BEGIN
@@ -5571,7 +5526,7 @@ END FoldIfNotIn ;
                if op1 = op2 then goto op3.
 *)
 
-PROCEDURE FoldIfEqu (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfEqu (tokenno: CARDINAL;
                      quad: CARDINAL;
                      left, right, destQuad: CARDINAL) ;
 BEGIN
@@ -5603,7 +5558,7 @@ END FoldIfEqu ;
                   if op1 # op2 then goto op3.
 *)
 
-PROCEDURE FoldIfNotEqu (tokenno: CARDINAL; p: WalkAction;
+PROCEDURE FoldIfNotEqu (tokenno: CARDINAL;
                         quad: CARDINAL;
                         left, right, destQuad: CARDINAL) ;
 BEGIN

diff --git a/gcc/m2/gm2-compiler/M2Quads.mod b/gcc/m2/gm2-compiler/M2Quads.mod
index 16c1e016a6f5c97e579e32f4d86cf725ec72468b..6476806ac35875b41e5bd59b68cdab4e93bf4af2 100644 (file)
--- a/gcc/m2/gm2-compiler/M2Quads.mod
+++ b/gcc/m2/gm2-compiler/M2Quads.mod
@@ -13822,58 +13822,6 @@ BEGIN
 END GenQuadOTypetok ;
 
 
-(*
-   GenQuadOTypeUniquetok - assigns the fields of the quadruple with
-                           the parameters and marks the quad as constexpr.
-*)
-
-PROCEDURE GenQuadOTypeUniquetok (TokPos: CARDINAL;
-                                 Operation: QuadOperator;
-                                 Op1, Op2, Op3: CARDINAL;
-                                 overflow, typecheck: BOOLEAN;
-                                 Op1Pos, Op2Pos, Op3Pos: CARDINAL) ;
-VAR
-   f: QuadFrame ;
-BEGIN
-   (* WriteString('Potential Quad: ') ; *)
-   IF QuadrupleGeneration
-   THEN
-      IF NextQuad # Head
-      THEN
-         f := GetQF (NextQuad-1) ;
-         f^.Next := NextQuad
-      END ;
-      PutQuadOType (NextQuad, Operation, Op1, Op2, Op3, overflow, typecheck) ;
-      f := GetQF (NextQuad) ;
-      WITH f^ DO
-         Next := 0 ;
-         LineNo := GetLineNo () ;
-         IF TokPos = UnknownTokenNo
-         THEN
-            TokenNo := GetTokenNo ()
-         ELSE
-            TokenNo := TokPos
-         END ;
-         op1pos := Op1Pos ;
-         op2pos := Op2Pos ;
-         op3pos := Op3Pos ;
-         ConstExpr := TRUE ;
-         IF GetDebugTraceQuad ()
-         THEN
-            printf0('generating: ') ;
-            DisplayQuad (NextQuad) ;
-            (* MetaErrorT1 (TokenNo, '{%1On}', NextQuad) *)
-         END
-      END ;
-      IF NextQuad=BreakAtQuad
-      THEN
-         stop
-      END ;
-      NewQuad (NextQuad)
-   END
-END GenQuadOTypeUniquetok ;
-
-
 (*
    DumpUntil - dump all quadruples until we seen the ending quadruple
                with procsym in the third operand.