home *** CD-ROM | disk | FTP | other *** search
/ ftp.ee.pdx.edu / 2014.02.ftp.ee.pdx.edu.tar / ftp.ee.pdx.edu / pub / users / Harry / Blitz / version-1-0 / Beta / ir.h < prev    next >
C/C++ Source or Header  |  2007-09-04  |  51KB  |  2,604 lines
  1. // ir.h  --  Classes of the Intermediate Representation
  2. //
  3. // KPL Compiler
  4. //
  5. // Copyright 2002-2007, Harry H. Porter III
  6. //
  7. // This file may be freely copied, modified and compiled, on the sole
  8. // condition that if you modify it...
  9. //   (1) Your name and the date of modification is added to this comment
  10. //       under "Modifications by", and
  11. //   (2) Your name and the date of modification is added to the printHelp()
  12. //       routine in file "main.cc" under "Modifications by".
  13. //
  14. // Original Author:
  15. //   05/24/03 - Harry H. Porter III
  16. //
  17. // Modifcations by:
  18. //   03/15/06 - Harry H. Porter III
  19. //
  20.  
  21.  
  22. #define OPComment  1
  23. #define OPGoto     2
  24. #define OPLabel    3
  25. #define OPImport   4
  26. #define OPExport   5
  27. #define OPData     6
  28. #define OPText     7
  29. #define OPAlign    8
  30. #define OPSkip     9
  31. #define OPByte     10
  32. #define OPWord     11
  33. #define OPWord2    12
  34. #define OPLoadAddr 13
  35. #define OPDouble   14
  36. #define OPCall     15
  37. #define OPDebug    16
  38. #define OPHalt     17
  39. //   #define OPZeroLocal          18
  40. #define OPSetLineNumber      19
  41. #define OPFunctionEntry      20
  42. #define OPFunctionReturn     21
  43. #define OPCheckVersion       22
  44. #define OPCallCheckVersion   23
  45. #define OPEndCheckVersion    24
  46. #define OPStartCheckVersion  25
  47. #define OPVarDesc1           26
  48. #define OPVarDesc2           27
  49. #define OPFrameSize          28
  50. #define OPAssign1            29
  51. #define OPAssign4            30
  52. #define OPAssign8            31
  53. #define OPAscii              32
  54. #define OPAscii2             33
  55. #define OPIAdd               34
  56. #define OPISub               35
  57. #define OPIMul               36
  58. #define OPIDiv               37
  59. #define OPIRem               38
  60. #define OPSll                39
  61. #define OPSra                40
  62. #define OPSrl                41
  63. #define OPAnd                42
  64. #define OPOr                 43
  65. #define OPXor                44
  66. #define OPNot                45
  67. #define OPINeg               46
  68. #define OPFAdd               47
  69. #define OPFSub               48
  70. #define OPFMul               49
  71. #define OPFDiv               50
  72. #define OPFNeg               51
  73. #define OPItoF               52
  74. #define OPFtoI               53
  75. #define OPItoC               54
  76. #define OPCtoI               55
  77. #define OPPosInf             56
  78. #define OPNegInf             57
  79. #define OPNegZero            58
  80. #define OPIntLTGoto          59
  81. #define OPIntLEGoto          60
  82. #define OPIntGTGoto          61
  83. #define OPIntGEGoto          62
  84. #define OPIntEQGoto          63
  85. #define OPIntNEGoto          64
  86. #define OPFloatLTGoto        65
  87. #define OPFloatLEGoto        66
  88. #define OPFloatGTGoto        67
  89. #define OPFloatGEGoto        68
  90. #define OPFloatEQGoto        69
  91. #define OPFloatNEGoto        70
  92. #define OPBoolTest           71
  93. #define OPBXor               72
  94. #define OPBEq                73
  95. #define OPBNot               74
  96. #define OPIntEqZero          75
  97. #define OPPrepareArg         76
  98. #define OPRetrieveResult     77
  99. #define OPReturnResult       78
  100. #define OPComment2           79
  101. #define OPGoto2              80
  102. #define OPMethodEntry        81
  103. #define OPMethodReturn       82
  104. #define OPSet                83
  105. #define OPSend               84
  106. #define OPLoadAddr2          85
  107. #define OPBoolTest2          86
  108. #define OPLoadSelfPtr        87
  109. #define OPMove               88
  110. #define OPBoolEqZeroIndirect 89
  111. #define OPCallIndirect       90
  112. #define OPLoadAddrWithIncr   91
  113. #define OPCheckDPT           92
  114. #define OPCheckDPT2          93
  115. #define OPWord3              94
  116. #define OPDynamicObjectMove  95
  117. #define OPCopyArrays         96
  118. #define OPCheckArraySizeInt  97
  119. #define OPCheckArraySizeInt2 98
  120. #define OPArrayIndex         99
  121. #define OPTestObjEq         100
  122. #define OPForTest           101
  123. #define OPForTest2          102
  124. #define OPIncrVarDirect     104
  125. #define OPIncrVarIndirect   103
  126. #define OPSwitchReg1        105
  127. #define OPSwitchTestReg1    106
  128. #define OPComment3          107
  129. #define OPSwitchDirect      108
  130. #define OPSwitchHashJump    109
  131. #define OPMultiplyVarImmed  110
  132. #define OPIntNeZero         111
  133. #define OPAlloc             112
  134. #define OPFree              114
  135. #define OPIntLeZero         115
  136. #define OPLoadAddrIndirect  116
  137. #define OPLoadAddrWithIncr2 117
  138. #define OPSaveCatchStack    118
  139. #define OPRestoreCatchStack 119
  140. #define OPPushCatchRecord   120
  141. #define OPThrow             121
  142. #define OPCopyCatchParm     122
  143. #define OPResetStack        123
  144. #define OPIsKindOf          124
  145. #define OPIsInstanceOf      125
  146. #define OPZeroMemory        126
  147. #define OPAscii0            127
  148.  
  149.  
  150. class IRLabel;
  151.  
  152.  
  153. //----------  IR  ----------
  154.  
  155. class IR {
  156.   public:
  157.     IR * next;
  158.     int op;
  159.  
  160.     IR (int oper) {
  161.       op = oper;
  162.       next = NULL;
  163.     }
  164.     ~IR () {}
  165.     virtual void print ();
  166.  
  167.  
  168. };
  169.  
  170.  
  171.  
  172. //----------  Comment  ----------
  173.  
  174. void IRComment (char * str);
  175.  
  176. class Comment : public IR {
  177.   public:
  178.     char * str;
  179.  
  180.     Comment (char * s) : IR (OPComment) {
  181.       str = s;
  182.     }
  183.     ~Comment () {}
  184.     virtual void print ();
  185. };
  186.  
  187.  
  188.  
  189. //----------  Comment3  ----------
  190.  
  191. void IRComment3 (char * str, int i);
  192.  
  193. class Comment3 : public IR {
  194.   public:
  195.     char * str;
  196.     int ivalue;
  197.  
  198.     Comment3 (char * s, int i) : IR (OPComment3) {
  199.       str = s;
  200.       ivalue = i;
  201.     }
  202.     ~Comment3 () {}
  203.     virtual void print ();
  204. };
  205.  
  206.  
  207.  
  208. //----------  Goto  ----------
  209.  
  210. void IRGoto (char * lab);
  211.  
  212. class Goto : public IR {
  213.   public:
  214.     char * label;
  215.  
  216.     Goto (char * lab) : IR (OPGoto) {
  217.       label = lab;
  218.     }
  219.     ~Goto () {}
  220.     virtual void print ();
  221. };
  222.  
  223.  
  224.  
  225. //----------  Goto2  ----------
  226.  
  227. void IRGoto2 (char * lab, int offset, char * selector);
  228.  
  229. class Goto2 : public IR {
  230.   public:
  231.     char * label;
  232.     int    offset;
  233.     char * selector;
  234.  
  235.     Goto2 (char * lab, int i, char * sel) : IR (OPGoto2) {
  236.       label = lab;
  237.       offset = i;
  238.       selector = sel;
  239.     }
  240.     ~Goto2 () {}
  241.     virtual void print ();
  242. };
  243.  
  244.  
  245.  
  246. //----------  Label  ----------
  247.  
  248. void IRLabel (char * lab);
  249.  
  250. class Label : public IR {
  251.   public:
  252.     char * label;
  253.  
  254.     Label (char * lab) : IR (OPLabel) {
  255.       label = lab;
  256.     }
  257.     ~Label () {}
  258.     virtual void print ();
  259. };
  260.  
  261.  
  262.  
  263. //----------  Import  ----------
  264.  
  265. void IRImport (char * nam);
  266.  
  267. class Import : public IR {
  268.   public:
  269.     char * name;
  270.  
  271.     Import (char * nam) : IR (OPImport) {
  272.       name = nam;
  273.     }
  274.     ~Import () {}
  275.     virtual void print ();
  276. };
  277.  
  278.  
  279.  
  280. //----------  Export  ----------
  281.  
  282. void IRExport (char * nam);
  283.  
  284. class Export : public IR {
  285.   public:
  286.     char * name;
  287.  
  288.     Export (char * nam) : IR (OPExport) {
  289.       name = nam;
  290.     }
  291.     ~Export () {}
  292.     virtual void print ();
  293. };
  294.  
  295.  
  296.  
  297. //----------  Data  ----------
  298.  
  299. void IRData ();
  300.  
  301. class Data : public IR {
  302.   public:
  303.  
  304.     Data () : IR (OPData) {
  305.     }
  306.     ~Data () {}
  307.     virtual void print ();
  308. };
  309.  
  310.  
  311.  
  312. //----------  Text  ----------
  313.  
  314. void IRText ();
  315.  
  316. class Text : public IR {
  317.   public:
  318.  
  319.     Text () : IR (OPText) {
  320.     }
  321.     ~Text () {}
  322.     virtual void print ();
  323. };
  324.  
  325.  
  326.  
  327. //----------  Align  ----------
  328.  
  329. void IRAlign ();
  330.  
  331. class Align : public IR {
  332.   public:
  333.  
  334.     Align () : IR (OPAlign) {
  335.     }
  336.     ~Align () {}
  337.     virtual void print ();
  338. };
  339.  
  340.  
  341.  
  342. //----------  Skip  ----------
  343.  
  344. void IRSkip (int i);
  345.  
  346. class Skip : public IR {
  347.   public:
  348.     int byteCount;
  349.  
  350.     Skip (int i) : IR (OPSkip) {
  351.       byteCount = i;
  352.     }
  353.     ~Skip () {}
  354.     virtual void print ();
  355. };
  356.  
  357.  
  358.  
  359. //----------  Byte  ----------
  360.  
  361. void IRByte (int i);
  362.  
  363. class Byte : public IR {
  364.   public:
  365.     int byteValue;
  366.  
  367.     Byte (int i) : IR (OPByte) {
  368.       byteValue = i;
  369.     }
  370.     ~Byte () {}
  371.     virtual void print ();
  372. };
  373.  
  374.  
  375.  
  376. //----------  Word  ----------
  377.  
  378. void IRWord (int i);
  379.  
  380. class Word : public IR {
  381.   public:
  382.     int wordValue;
  383.  
  384.     Word (int i) : IR (OPWord) {
  385.       wordValue = i;
  386.     }
  387.     ~Word () {}
  388.     virtual void print ();
  389. };
  390.  
  391.  
  392.  
  393. //----------  Word2  ----------
  394.  
  395. void IRWord2 (char * s);
  396.  
  397. class Word2 : public IR {
  398.   public:
  399.     char * symbol;
  400.  
  401.     Word2 (char * s) : IR (OPWord2) {
  402.       symbol = s;
  403.     }
  404.     ~Word2 () {}
  405.     virtual void print ();
  406. };
  407.  
  408.  
  409.  
  410. //----------  Word3  ----------
  411.  
  412. void IRWord3 (int i, char * s);
  413.  
  414. class Word3 : public IR {
  415.   public:
  416.     int    wordValue;
  417.     char * comment;
  418.  
  419.     Word3 (int i, char * s) : IR (OPWord3) {
  420.       wordValue = i;
  421.       comment = s;
  422.     }
  423.     ~Word3 () {}
  424.     virtual void print ();
  425. };
  426.  
  427.  
  428.  
  429. //----------  LoadAddr  ----------
  430.  
  431. void IRLoadAddr (AstNode * dest, char * stringName);
  432.  
  433. class LoadAddr : public IR {
  434.   public:
  435.     AstNode * dest;         // Either local, global, or parameter
  436.     char * stringName;      // A string Constant
  437.  
  438.     LoadAddr (AstNode * d, char * s) : IR (OPLoadAddr) {
  439.       dest = d;
  440.       stringName = s;
  441.     }
  442.     ~LoadAddr () {}
  443.     virtual void print ();
  444. };
  445.  
  446.  
  447.  
  448. //----------  LoadAddrIndirect  ----------
  449.  
  450. void IRLoadAddrIndirect (AstNode * dest, char * stringName);
  451.  
  452. class LoadAddrIndirect : public IR {
  453.   public:
  454.     AstNode * dest;         // Either local, global, or parameter
  455.     char * stringName;      // A string Constant
  456.  
  457.     LoadAddrIndirect (AstNode * d, char * s) : IR (OPLoadAddrIndirect) {
  458.       dest = d;
  459.       stringName = s;
  460.     }
  461.     ~LoadAddrIndirect () {}
  462.     virtual void print ();
  463. };
  464.  
  465.  
  466.  
  467. //----------  LoadAddr2  ----------
  468.  
  469. void IRLoadAddr2 (VarDecl * dest, AstNode * src);
  470.  
  471. class LoadAddr2 : public IR {
  472.   public:
  473.     VarDecl * dest;         // Either local, global, or parameter
  474.     AstNode * src;          // Either local, global, or parameter
  475.  
  476.     LoadAddr2 (VarDecl * d, AstNode * s) : IR (OPLoadAddr2) {
  477.       dest = d;
  478.       src = s;
  479.     }
  480.     ~LoadAddr2 () {}
  481.     virtual void print ();
  482. };
  483.  
  484.  
  485.  
  486. //----------  LoadAddrWithIncr  ----------
  487.  
  488. void IRLoadAddrWithIncr (VarDecl * dest, AstNode * src, FieldInit * f);
  489.  
  490. class LoadAddrWithIncr : public IR {
  491.   public:
  492.     VarDecl * dest;         // Either local, global, or parameter
  493.     AstNode * src;          // Either local, global, or parameter
  494.     FieldInit * fieldInit;
  495.  
  496.     LoadAddrWithIncr (VarDecl * d, AstNode * s, FieldInit * f) : IR (OPLoadAddrWithIncr) {
  497.       dest = d;
  498.       src = s;
  499.       fieldInit = f;
  500.     }
  501.     ~LoadAddrWithIncr () {}
  502.     virtual void print ();
  503. };
  504.  
  505.  
  506.  
  507. //----------  LoadAddrWithIncr2  ----------
  508.  
  509. void IRLoadAddrWithIncr2 (VarDecl * dest, AstNode * src, FieldInit * f);
  510.  
  511. class LoadAddrWithIncr2 : public IR {
  512.   public:
  513.     VarDecl * dest;         // Either local, global, or parameter
  514.     AstNode * src;          // Either local, global, or parameter
  515.     FieldInit * fieldInit;
  516.  
  517.     LoadAddrWithIncr2 (VarDecl * d, AstNode * s, FieldInit * f) : IR (OPLoadAddrWithIncr2) {
  518.       dest = d;
  519.       src = s;
  520.       fieldInit = f;
  521.     }
  522.     ~LoadAddrWithIncr2 () {}
  523.     virtual void print ();
  524. };
  525.  
  526.  
  527.  
  528. //----------  Double  ----------
  529.  
  530. void IRDouble (double d);
  531.  
  532. class Double : public IR {
  533.   public:
  534.     double doubleValue;
  535.  
  536.     Double (double d) : IR (OPDouble) {
  537.       doubleValue = d;
  538.     }
  539.     ~Double () {}
  540.     virtual void print ();
  541. };
  542.  
  543.  
  544.  
  545. //----------  Call  ----------
  546.  
  547. void IRCall (char * n);
  548.  
  549. class Call : public IR {
  550.   public:
  551.     char * name;
  552.  
  553.     Call (char * n) : IR (OPCall) {
  554.       name = n;
  555.     }
  556.     ~Call () {}
  557.     virtual void print ();
  558. };
  559.  
  560.  
  561.  
  562. //----------  CallIndirect  ----------
  563.  
  564. void IRCallIndirect (VarDecl * varDesc);
  565.  
  566. class CallIndirect : public IR {
  567.   public:
  568.     VarDecl * varDesc;
  569.  
  570.     CallIndirect (VarDecl * vd) : IR (OPCallIndirect) {
  571.       varDesc = vd;
  572.     }
  573.     ~CallIndirect () {}
  574.     virtual void print ();
  575. };
  576.  
  577.  
  578.  
  579. //----------  Debug  ----------
  580.  
  581. void IRDebug ();
  582.  
  583. class Debug : public IR {
  584.   public:
  585.  
  586.     Debug () : IR (OPDebug) {
  587.     }
  588.     ~Debug () {}
  589.     virtual void print ();
  590. };
  591.  
  592.  
  593.  
  594. //----------  Halt  ----------
  595.  
  596. void IRHalt ();
  597.  
  598. class Halt : public IR {
  599.   public:
  600.  
  601.     Halt () : IR (OPHalt) {
  602.     }
  603.     ~Halt () {}
  604.     virtual void print ();
  605. };
  606.  
  607.  
  608.  
  609. //----------  SetLineNumber  ----------
  610.  
  611. void IRSetLineNumber (int i, char * s);
  612.  
  613. class SetLineNumber : public IR {
  614.   public:
  615.     int lineNumber;
  616.     char * stmtCode;
  617.  
  618.     SetLineNumber (int i, char * s) : IR (OPSetLineNumber) {
  619.       lineNumber = i;
  620.       stmtCode = s;
  621.     }
  622.     ~SetLineNumber () {}
  623.     virtual void print ();
  624. };
  625.  
  626.  
  627.  
  628. //----------  FunctionEntry  ----------
  629.  
  630. void IRFunctionEntry (Function * f);
  631.  
  632. class FunctionEntry : public IR {
  633.   public:
  634.     Function * fun;
  635.  
  636.     FunctionEntry (Function * f) : IR (OPFunctionEntry) {
  637.       fun = f;
  638.     }
  639.     ~FunctionEntry () {}
  640.     virtual void print ();
  641. };
  642.  
  643.  
  644.  
  645. //----------  FunctionReturn  ----------
  646.  
  647. void IRFunctionReturn (Function * f);
  648.  
  649. class FunctionReturn : public IR {
  650.   public:
  651.     Function * fun;
  652.  
  653.     FunctionReturn (Function * f) : IR (OPFunctionReturn) {
  654.       fun = f;
  655.     }
  656.     ~FunctionReturn () {}
  657.     virtual void print ();
  658. };
  659.  
  660.  
  661.  
  662. //----------  MethodEntry  ----------
  663.  
  664. void IRMethodEntry (Method * m);
  665.  
  666. class MethodEntry : public IR {
  667.   public:
  668.     Method * meth;
  669.  
  670.     MethodEntry (Method * m) : IR (OPMethodEntry) {
  671.       meth = m;
  672.     }
  673.     ~MethodEntry () {}
  674.     virtual void print ();
  675. };
  676.  
  677.  
  678.  
  679. //----------  MethodReturn  ----------
  680.  
  681. void IRMethodReturn (Method * m);
  682.  
  683. class MethodReturn : public IR {
  684.   public:
  685.     Method * meth;
  686.  
  687.     MethodReturn (Method * m) : IR (OPMethodReturn) {
  688.       meth = m;
  689.     }
  690.     ~MethodReturn () {}
  691.     virtual void print ();
  692. };
  693.  
  694.  
  695.  
  696. //----------  CheckVersion  ----------
  697.  
  698. void IRCheckVersion (char * str, int i, char * lab1);
  699.  
  700. class CheckVersion : public IR {
  701.   public:
  702.     char * mySaniName;
  703.     int myHashVal;
  704.     char * label1;
  705.  
  706.     CheckVersion (char * str, int i, char * lab1) : IR (OPCheckVersion) {
  707.       myHashVal = i;
  708.       mySaniName = str;
  709.       label1 = lab1;
  710.     }
  711.     ~CheckVersion () {}
  712.     virtual void print ();
  713. };
  714.  
  715.  
  716.  
  717. //----------  CallCheckVersion  ----------
  718.  
  719. void IRCallCheckVersion (char * str, int i, char * lab2);
  720.  
  721. class CallCheckVersion : public IR {
  722.   public:
  723.     char * theirSaniName;
  724.     int theirHashVal;
  725.     char * label2;
  726.  
  727.     CallCheckVersion (char * str, int i, char * lab2) : IR (OPCallCheckVersion) {
  728.       theirHashVal = i;
  729.       theirSaniName = str;
  730.       label2 = lab2;
  731.     }
  732.     ~CallCheckVersion () {}
  733.     virtual void print ();
  734. };
  735.  
  736.  
  737.  
  738. //----------  EndCheckVersion  ----------
  739.  
  740. void IREndCheckVersion (char * lab2);
  741.  
  742. class EndCheckVersion : public IR {
  743.   public:
  744.     char * label2;
  745.  
  746.     EndCheckVersion (char * lab2) : IR (OPEndCheckVersion) {
  747.       label2 = lab2;
  748.     }
  749.     ~EndCheckVersion () {}
  750.     virtual void print ();
  751. };
  752.  
  753.  
  754.  
  755. //----------  StartCheckVersion  ----------
  756.  
  757. void IRStartCheckVersion (char * str, int i, char * lab);
  758.  
  759. class StartCheckVersion : public IR {
  760.   public:
  761.     char * mySaniName;
  762.     int myHashVal;
  763.     char * continueLab;
  764.  
  765.     StartCheckVersion (char * str, int i, char * lab) : IR (OPStartCheckVersion) {
  766.       myHashVal = i;
  767.       mySaniName = str;
  768.       continueLab = lab;
  769.     }
  770.     ~StartCheckVersion () {}
  771.     virtual void print ();
  772. };
  773.  
  774.  
  775.  
  776. //----------  VarDesc1  ----------
  777.  
  778. void IRVarDesc1 (char * lab, VarDecl * vd, int sz);
  779.  
  780. class VarDesc1 : public IR {
  781.   public:
  782.     char * label;
  783.     VarDecl * varDecl;
  784.     int sizeInBytes;
  785.  
  786.     VarDesc1 (char * lab, VarDecl * vd, int sz) : IR (OPVarDesc1) {
  787.       label = lab;
  788.       varDecl = vd;
  789.       sizeInBytes = sz;
  790.     }
  791.     ~VarDesc1 () {}
  792.     virtual void print ();
  793. };
  794.  
  795.  
  796.  
  797. //----------  VarDesc2  ----------
  798.  
  799. void IRVarDesc2 (char * lab, char k, char * n);
  800.  
  801. class VarDesc2 : public IR {
  802.   public:
  803.     char * label;
  804.     char kind;
  805.     char * name;
  806.  
  807.     VarDesc2 (char * lab, char k, char * n) : IR (OPVarDesc2) {
  808.       label = lab;
  809.       kind = k;
  810.       name = n;
  811.     }
  812.     ~VarDesc2 () {}
  813.     virtual void print ();
  814. };
  815.  
  816.  
  817.  
  818. //----------  FrameSize  ----------
  819.  
  820. void IRFrameSize (AstNode * n);
  821.  
  822. class FrameSize : public IR {
  823.   public:
  824.     AstNode * funOrMeth;
  825.  
  826.     FrameSize (AstNode * n) : IR (OPFrameSize) {
  827.       funOrMeth = n;
  828.     }
  829.     ~FrameSize () {}
  830.     virtual void print ();
  831. };
  832.  
  833.  
  834.  
  835. //----------  Assign1  ----------
  836.  
  837. void IRAssign1 (AstNode * dest, AstNode * src);
  838.  
  839. class Assign1 : public IR {
  840.   public:
  841.     AstNode * dest;  // Either local, global, or parameter
  842.     AstNode * src;   // Either local, global, parameter, char or bool
  843.  
  844.     Assign1 (AstNode * d, AstNode * s) : IR (OPAssign1) {
  845.       dest = d;
  846.       src = s;
  847.     }
  848.     ~Assign1 () {}
  849.     virtual void print ();
  850. };
  851.  
  852.  
  853.  
  854. //----------  Assign4  ----------
  855.  
  856. void IRAssign4 (AstNode * dest, AstNode * src);
  857.  
  858. class Assign4 : public IR {
  859.   public:
  860.     AstNode * dest;  // Either local, global, or parameter
  861.     AstNode * src;   // Either local, global, parameter, int
  862.  
  863.     Assign4 (AstNode * d, AstNode * s) : IR (OPAssign4) {
  864.       dest = d;
  865.       src = s;
  866.     }
  867.     ~Assign4 () {}
  868.     virtual void print ();
  869. };
  870.  
  871.  
  872.  
  873. //----------  Assign8  ----------
  874.  
  875. void IRAssign8 (AstNode * dest, AstNode * src);
  876.  
  877. class Assign8 : public IR {
  878.   public:
  879.     AstNode * dest;  // Either local, global, or parameter
  880.     AstNode * src;   // Either local, global, parameter, double
  881.  
  882.     Assign8 (AstNode * d, AstNode * s) : IR (OPAssign8) {
  883.       dest = d;
  884.       src = s;
  885.     }
  886.     ~Assign8 () {}
  887.     virtual void print ();
  888. };
  889.  
  890.  
  891.  
  892. //----------  Ascii  ----------
  893.  
  894. void IRAscii (char * s);
  895.  
  896. class Ascii : public IR {
  897.   public:
  898.     char * str;
  899.  
  900.     Ascii (char * s) : IR (OPAscii) {
  901.       str = s;
  902.     }
  903.     ~Ascii () {}
  904.     virtual void print ();
  905. };
  906.  
  907.  
  908.  
  909. //----------  Ascii0  ----------
  910.  
  911. void IRAscii0 (char * s);
  912.  
  913. class Ascii0 : public IR {
  914.   public:
  915.     char * str;
  916.  
  917.     Ascii0 (char * s) : IR (OPAscii0) {
  918.       str = s;
  919.     }
  920.     ~Ascii0 () {}
  921.     virtual void print ();
  922. };
  923.  
  924.  
  925.  
  926. //----------  Ascii2  ----------
  927.  
  928. void IRAscii2 (String * s);
  929.  
  930. class Ascii2 : public IR {
  931.   public:
  932.     String * str;
  933.  
  934.     Ascii2 (String * s) : IR (OPAscii2) {
  935.       str = s;
  936.     }
  937.     ~Ascii2 () {}
  938.     virtual void print ();
  939. };
  940.  
  941.  
  942.  
  943. //----------  IAdd  ----------
  944.  
  945. void IRIAdd (AstNode * d, AstNode * a1, AstNode * a2);
  946.  
  947. class IAdd : public IR {
  948.   public:
  949.     AstNode * dest;           // Local, Global, Parm
  950.     AstNode * arg1;           // Local, Global, Parm, IntConst
  951.     AstNode * arg2;           // Local, Global, Parm, IntConst
  952.  
  953.     IAdd (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPIAdd) {
  954.       dest = d;
  955.       arg1 = a1;
  956.       arg2 = a2;
  957.     }
  958.     ~IAdd () {}
  959.     virtual void print ();
  960. };
  961.  
  962.  
  963.  
  964. //----------  ISub  ----------
  965.  
  966. void IRISub (AstNode * d, AstNode * a1, AstNode * a2);
  967.  
  968. class ISub : public IR {
  969.   public:
  970.     AstNode * dest;           // Local, Global, Parm
  971.     AstNode * arg1;           // Local, Global, Parm, IntConst
  972.     AstNode * arg2;           // Local, Global, Parm, IntConst
  973.  
  974.     ISub (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPISub) {
  975.       dest = d;
  976.       arg1 = a1;
  977.       arg2 = a2;
  978.     }
  979.     ~ISub () {}
  980.     virtual void print ();
  981. };
  982.  
  983.  
  984.  
  985. //----------  IMul  ----------
  986.  
  987. void IRIMul (AstNode * d, AstNode * a1, AstNode * a2);
  988.  
  989. class IMul : public IR {
  990.   public:
  991.     AstNode * dest;           // Local, Global, Parm
  992.     AstNode * arg1;           // Local, Global, Parm, IntConst
  993.     AstNode * arg2;           // Local, Global, Parm, IntConst
  994.  
  995.     IMul (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPIMul) {
  996.       dest = d;
  997.       arg1 = a1;
  998.       arg2 = a2;
  999.     }
  1000.     ~IMul () {}
  1001.     virtual void print ();
  1002. };
  1003.  
  1004.  
  1005.  
  1006. //----------  IDiv  ----------
  1007.  
  1008. void IRIDiv (AstNode * d, AstNode * a1, AstNode * a2);
  1009.  
  1010. class IDiv : public IR {
  1011.   public:
  1012.     AstNode * dest;           // Local, Global, Parm
  1013.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1014.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1015.  
  1016.     IDiv (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPIDiv) {
  1017.       dest = d;
  1018.       arg1 = a1;
  1019.       arg2 = a2;
  1020.     }
  1021.     ~IDiv () {}
  1022.     virtual void print ();
  1023. };
  1024.  
  1025.  
  1026.  
  1027. //----------  IRem  ----------
  1028.  
  1029. void IRIRem (AstNode * d, AstNode * a1, AstNode * a2);
  1030.  
  1031. class IRem : public IR {
  1032.   public:
  1033.     AstNode * dest;           // Local, Global, Parm
  1034.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1035.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1036.  
  1037.     IRem (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPIRem) {
  1038.       dest = d;
  1039.       arg1 = a1;
  1040.       arg2 = a2;
  1041.     }
  1042.     ~IRem () {}
  1043.     virtual void print ();
  1044. };
  1045.  
  1046.  
  1047.  
  1048. //----------  Sll  ----------
  1049.  
  1050. void IRSll (AstNode * d, AstNode * a1, AstNode * a2);
  1051.  
  1052. class Sll : public IR {
  1053.   public:
  1054.     AstNode * dest;           // Local, Global, Parm
  1055.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1056.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1057.  
  1058.     Sll (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPSll) {
  1059.       dest = d;
  1060.       arg1 = a1;
  1061.       arg2 = a2;
  1062.     }
  1063.     ~Sll () {}
  1064.     virtual void print ();
  1065. };
  1066.  
  1067.  
  1068.  
  1069. //----------  Sra  ----------
  1070.  
  1071. void IRSra (AstNode * d, AstNode * a1, AstNode * a2);
  1072.  
  1073. class Sra : public IR {
  1074.   public:
  1075.     AstNode * dest;           // Local, Global, Parm
  1076.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1077.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1078.  
  1079.     Sra (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPSra) {
  1080.       dest = d;
  1081.       arg1 = a1;
  1082.       arg2 = a2;
  1083.     }
  1084.     ~Sra () {}
  1085.     virtual void print ();
  1086. };
  1087.  
  1088.  
  1089.  
  1090. //----------  Srl  ----------
  1091.  
  1092. void IRSrl (AstNode * d, AstNode * a1, AstNode * a2);
  1093.  
  1094. class Srl : public IR {
  1095.   public:
  1096.     AstNode * dest;           // Local, Global, Parm
  1097.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1098.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1099.  
  1100.     Srl (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPSrl) {
  1101.       dest = d;
  1102.       arg1 = a1;
  1103.       arg2 = a2;
  1104.     }
  1105.     ~Srl () {}
  1106.     virtual void print ();
  1107. };
  1108.  
  1109.  
  1110.  
  1111. //----------  And  ----------
  1112.  
  1113. void IRAnd (AstNode * d, AstNode * a1, AstNode * a2);
  1114.  
  1115. class And : public IR {
  1116.   public:
  1117.     AstNode * dest;           // Local, Global, Parm
  1118.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1119.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1120.  
  1121.     And (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPAnd) {
  1122.       dest = d;
  1123.       arg1 = a1;
  1124.       arg2 = a2;
  1125.     }
  1126.     ~And () {}
  1127.     virtual void print ();
  1128. };
  1129.  
  1130.  
  1131.  
  1132. //----------  Or  ----------
  1133.  
  1134. void IROr (AstNode * d, AstNode * a1, AstNode * a2);
  1135.  
  1136. class Or : public IR {
  1137.   public:
  1138.     AstNode * dest;           // Local, Global, Parm
  1139.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1140.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1141.  
  1142.     Or (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPOr) {
  1143.       dest = d;
  1144.       arg1 = a1;
  1145.       arg2 = a2;
  1146.     }
  1147.     ~Or () {}
  1148.     virtual void print ();
  1149. };
  1150.  
  1151.  
  1152.  
  1153. //----------  Xor  ----------
  1154.  
  1155. void IRXor (AstNode * d, AstNode * a1, AstNode * a2);
  1156.  
  1157. class Xor : public IR {
  1158.   public:
  1159.     AstNode * dest;           // Local, Global, Parm
  1160.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1161.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1162.  
  1163.     Xor (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPXor) {
  1164.       dest = d;
  1165.       arg1 = a1;
  1166.       arg2 = a2;
  1167.     }
  1168.     ~Xor () {}
  1169.     virtual void print ();
  1170. };
  1171.  
  1172.  
  1173.  
  1174. //----------  INeg  ----------
  1175.  
  1176. void IRINeg (AstNode * d, AstNode * a);
  1177.  
  1178. class INeg : public IR {
  1179.   public:
  1180.     AstNode * dest;           // Local, Global, Parm
  1181.     AstNode * arg;            // Local, Global, Parm, IntConst
  1182.  
  1183.     INeg (AstNode * d, AstNode * a) : IR (OPINeg) {
  1184.       dest = d;
  1185.       arg = a;
  1186.     }
  1187.     ~INeg () {}
  1188.     virtual void print ();
  1189. };
  1190.  
  1191.  
  1192.  
  1193. //----------  Not  ----------
  1194.  
  1195. void IRNot (AstNode * d, AstNode * a);
  1196.  
  1197. class Not : public IR {
  1198.   public:
  1199.     AstNode * dest;           // Local, Global, Parm
  1200.     AstNode * arg;            // Local, Global, Parm, IntConst
  1201.  
  1202.     Not (AstNode * d, AstNode * a) : IR (OPNot) {
  1203.       dest = d;
  1204.       arg = a;
  1205.     }
  1206.     ~Not () {}
  1207.     virtual void print ();
  1208. };
  1209.  
  1210.  
  1211.  
  1212. //----------  FAdd  ----------
  1213.  
  1214. void IRFAdd (AstNode * d, AstNode * a1, AstNode * a2);
  1215.  
  1216. class FAdd : public IR {
  1217.   public:
  1218.     AstNode * dest;           // Local, Global, Parm
  1219.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1220.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1221.  
  1222.     FAdd (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPFAdd) {
  1223.       dest = d;
  1224.       arg1 = a1;
  1225.       arg2 = a2;
  1226.     }
  1227.     ~FAdd () {}
  1228.     virtual void print ();
  1229. };
  1230.  
  1231.  
  1232.  
  1233. //----------  FSub  ----------
  1234.  
  1235. void IRFSub (AstNode * d, AstNode * a1, AstNode * a2);
  1236.  
  1237. class FSub : public IR {
  1238.   public:
  1239.     AstNode * dest;           // Local, Global, Parm
  1240.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1241.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1242.  
  1243.     FSub (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPFSub) {
  1244.       dest = d;
  1245.       arg1 = a1;
  1246.       arg2 = a2;
  1247.     }
  1248.     ~FSub () {}
  1249.     virtual void print ();
  1250. };
  1251.  
  1252.  
  1253.  
  1254. //----------  FMul  ----------
  1255.  
  1256. void IRFMul (AstNode * d, AstNode * a1, AstNode * a2);
  1257.  
  1258. class FMul : public IR {
  1259.   public:
  1260.     AstNode * dest;           // Local, Global, Parm
  1261.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1262.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1263.  
  1264.     FMul (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPFMul) {
  1265.       dest = d;
  1266.       arg1 = a1;
  1267.       arg2 = a2;
  1268.     }
  1269.     ~FMul () {}
  1270.     virtual void print ();
  1271. };
  1272.  
  1273.  
  1274.  
  1275. //----------  FDiv  ----------
  1276.  
  1277. void IRFDiv (AstNode * d, AstNode * a1, AstNode * a2);
  1278.  
  1279. class FDiv : public IR {
  1280.   public:
  1281.     AstNode * dest;           // Local, Global, Parm
  1282.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1283.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1284.  
  1285.     FDiv (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPFDiv) {
  1286.       dest = d;
  1287.       arg1 = a1;
  1288.       arg2 = a2;
  1289.     }
  1290.     ~FDiv () {}
  1291.     virtual void print ();
  1292. };
  1293.  
  1294.  
  1295.  
  1296. //----------  FNeg  ----------
  1297.  
  1298. void IRFNeg (AstNode * d, AstNode * a);
  1299.  
  1300. class FNeg : public IR {
  1301.   public:
  1302.     AstNode * dest;           // Local, Global, Parm
  1303.     AstNode * arg;            // Local, Global, Parm, DoubleConst
  1304.  
  1305.     FNeg (AstNode * d, AstNode * a) : IR (OPFNeg) {
  1306.       dest = d;
  1307.       arg = a;
  1308.     }
  1309.     ~FNeg () {}
  1310.     virtual void print ();
  1311. };
  1312.  
  1313.  
  1314.  
  1315. //----------  ItoF  ----------
  1316.  
  1317. void IRItoF (AstNode * d, AstNode * a);
  1318.  
  1319. class ItoF : public IR {
  1320.   public:
  1321.     AstNode * dest;           // Local, Global, Parm
  1322.     AstNode * arg;            // Local, Global, Parm, IntConst
  1323.  
  1324.     ItoF (AstNode * d, AstNode * a) : IR (OPItoF) {
  1325.       dest = d;
  1326.       arg = a;
  1327.     }
  1328.     ~ItoF () {}
  1329.     virtual void print ();
  1330. };
  1331.  
  1332.  
  1333.  
  1334. //----------  FtoI  ----------
  1335.  
  1336. void IRFtoI (AstNode * d, AstNode * a);
  1337.  
  1338. class FtoI : public IR {
  1339.   public:
  1340.     AstNode * dest;           // Local, Global, Parm
  1341.     AstNode * arg;            // Local, Global, Parm, DoubleConst
  1342.  
  1343.     FtoI (AstNode * d, AstNode * a) : IR (OPFtoI) {
  1344.       dest = d;
  1345.       arg = a;
  1346.     }
  1347.     ~FtoI () {}
  1348.     virtual void print ();
  1349. };
  1350.  
  1351.  
  1352.  
  1353. //----------  ItoC  ----------
  1354.  
  1355. void IRItoC (AstNode * d, AstNode * a);
  1356.  
  1357. class ItoC : public IR {
  1358.   public:
  1359.     AstNode * dest;           // Local, Global, Parm
  1360.     AstNode * arg;            // Local, Global, Parm, IntConst
  1361.  
  1362.     ItoC (AstNode * d, AstNode * a) : IR (OPItoC) {
  1363.       dest = d;
  1364.       arg = a;
  1365.     }
  1366.     ~ItoC () {}
  1367.     virtual void print ();
  1368. };
  1369.  
  1370.  
  1371.  
  1372. //----------  CtoI  ----------
  1373.  
  1374. void IRCtoI (AstNode * d, AstNode * a);
  1375.  
  1376. class CtoI : public IR {
  1377.   public:
  1378.     AstNode * dest;           // Local, Global, Parm
  1379.     AstNode * arg;            // Local, Global, Parm, CharConst, BoolConst
  1380.  
  1381.     CtoI (AstNode * d, AstNode * a) : IR (OPCtoI) {
  1382.       dest = d;
  1383.       arg = a;
  1384.     }
  1385.     ~CtoI () {}
  1386.     virtual void print ();
  1387. };
  1388.  
  1389.  
  1390.  
  1391. //----------  PosInf  ----------
  1392.  
  1393. void IRPosInf (AstNode * d);
  1394.  
  1395. class PosInf : public IR {
  1396.   public:
  1397.     AstNode * dest;           // Local, Global, Parm
  1398.  
  1399.     PosInf (AstNode * d) : IR (OPPosInf) {
  1400.       dest = d;
  1401.     }
  1402.     ~PosInf () {}
  1403.     virtual void print ();
  1404. };
  1405.  
  1406.  
  1407.  
  1408. //----------  NegInf  ----------
  1409.  
  1410. void IRNegInf (AstNode * d);
  1411.  
  1412. class NegInf : public IR {
  1413.   public:
  1414.     AstNode * dest;           // Local, Global, Parm
  1415.  
  1416.     NegInf (AstNode * d) : IR (OPNegInf) {
  1417.       dest = d;
  1418.     }
  1419.     ~NegInf () {}
  1420.     virtual void print ();
  1421. };
  1422.  
  1423.  
  1424.  
  1425. //----------  NegZero  ----------
  1426.  
  1427. void IRNegZero (AstNode * d);
  1428.  
  1429. class NegZero : public IR {
  1430.   public:
  1431.     AstNode * dest;           // Local, Global, Parm
  1432.  
  1433.     NegZero (AstNode * d) : IR (OPNegZero) {
  1434.       dest = d;
  1435.     }
  1436.     ~NegZero () {}
  1437.     virtual void print ();
  1438. };
  1439.  
  1440.  
  1441.  
  1442. //----------  IntLTGoto  ----------
  1443.  
  1444. void IRIntLTGoto (AstNode * a1, AstNode * a2, char * lab);
  1445.  
  1446. class IntLTGoto : public IR {
  1447.   public:
  1448.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1449.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1450.     char * label;
  1451.  
  1452.     IntLTGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPIntLTGoto) {
  1453.       arg1 = a1;
  1454.       arg2 = a2;
  1455.       label = lab;
  1456.     }
  1457.     ~IntLTGoto () {}
  1458.     virtual void print ();
  1459. };
  1460.  
  1461.  
  1462.  
  1463. //----------  IntLEGoto  ----------
  1464.  
  1465. void IRIntLEGoto (AstNode * a1, AstNode * a2, char * lab);
  1466.  
  1467. class IntLEGoto : public IR {
  1468.   public:
  1469.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1470.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1471.     char * label;
  1472.  
  1473.     IntLEGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPIntLEGoto) {
  1474.       arg1 = a1;
  1475.       arg2 = a2;
  1476.       label = lab;
  1477.     }
  1478.     ~IntLEGoto () {}
  1479.     virtual void print ();
  1480. };
  1481.  
  1482.  
  1483.  
  1484. //----------  IntGTGoto  ----------
  1485.  
  1486. void IRIntGTGoto (AstNode * a1, AstNode * a2, char * lab);
  1487.  
  1488. class IntGTGoto : public IR {
  1489.   public:
  1490.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1491.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1492.     char * label;
  1493.  
  1494.     IntGTGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPIntGTGoto) {
  1495.       arg1 = a1;
  1496.       arg2 = a2;
  1497.       label = lab;
  1498.     }
  1499.     ~IntGTGoto () {}
  1500.     virtual void print ();
  1501. };
  1502.  
  1503.  
  1504.  
  1505. //----------  IntGEGoto  ----------
  1506.  
  1507. void IRIntGEGoto (AstNode * a1, AstNode * a2, char * lab);
  1508.  
  1509. class IntGEGoto : public IR {
  1510.   public:
  1511.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1512.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1513.     char * label;
  1514.  
  1515.     IntGEGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPIntGEGoto) {
  1516.       arg1 = a1;
  1517.       arg2 = a2;
  1518.       label = lab;
  1519.     }
  1520.     ~IntGEGoto () {}
  1521.     virtual void print ();
  1522. };
  1523.  
  1524.  
  1525.  
  1526. //----------  IntEQGoto  ----------
  1527.  
  1528. void IRIntEQGoto (AstNode * a1, AstNode * a2, char * lab);
  1529.  
  1530. class IntEQGoto : public IR {
  1531.   public:
  1532.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1533.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1534.     char * label;
  1535.  
  1536.     IntEQGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPIntEQGoto) {
  1537.       arg1 = a1;
  1538.       arg2 = a2;
  1539.       label = lab;
  1540.     }
  1541.     ~IntEQGoto () {}
  1542.     virtual void print ();
  1543. };
  1544.  
  1545.  
  1546.  
  1547. //----------  IntNEGoto  ----------
  1548.  
  1549. void IRIntNEGoto (AstNode * a1, AstNode * a2, char * lab);
  1550.  
  1551. class IntNEGoto : public IR {
  1552.   public:
  1553.     AstNode * arg1;           // Local, Global, Parm, IntConst
  1554.     AstNode * arg2;           // Local, Global, Parm, IntConst
  1555.     char * label;
  1556.  
  1557.     IntNEGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPIntNEGoto) {
  1558.       arg1 = a1;
  1559.       arg2 = a2;
  1560.       label = lab;
  1561.     }
  1562.     ~IntNEGoto () {}
  1563.     virtual void print ();
  1564. };
  1565.  
  1566.  
  1567.  
  1568. //----------  FloatLTGoto  ----------
  1569.  
  1570. void IRFloatLTGoto (AstNode * a1, AstNode * a2, char * lab);
  1571.  
  1572. class FloatLTGoto : public IR {
  1573.   public:
  1574.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1575.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1576.     char * label;
  1577.  
  1578.     FloatLTGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPFloatLTGoto) {
  1579.       arg1 = a1;
  1580.       arg2 = a2;
  1581.       label = lab;
  1582.     }
  1583.     ~FloatLTGoto () {}
  1584.     virtual void print ();
  1585. };
  1586.  
  1587.  
  1588.  
  1589. //----------  FloatLEGoto  ----------
  1590.  
  1591. void IRFloatLEGoto (AstNode * a1, AstNode * a2, char * lab);
  1592.  
  1593. class FloatLEGoto : public IR {
  1594.   public:
  1595.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1596.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1597.     char * label;
  1598.  
  1599.     FloatLEGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPFloatLEGoto) {
  1600.       arg1 = a1;
  1601.       arg2 = a2;
  1602.       label = lab;
  1603.     }
  1604.     ~FloatLEGoto () {}
  1605.     virtual void print ();
  1606. };
  1607.  
  1608.  
  1609.  
  1610. //----------  FloatGTGoto  ----------
  1611.  
  1612. void IRFloatGTGoto (AstNode * a1, AstNode * a2, char * lab);
  1613.  
  1614. class FloatGTGoto : public IR {
  1615.   public:
  1616.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1617.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1618.     char * label;
  1619.  
  1620.     FloatGTGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPFloatGTGoto) {
  1621.       arg1 = a1;
  1622.       arg2 = a2;
  1623.       label = lab;
  1624.     }
  1625.     ~FloatGTGoto () {}
  1626.     virtual void print ();
  1627. };
  1628.  
  1629.  
  1630.  
  1631. //----------  FloatGEGoto  ----------
  1632.  
  1633. void IRFloatGEGoto (AstNode * a1, AstNode * a2, char * lab);
  1634.  
  1635. class FloatGEGoto : public IR {
  1636.   public:
  1637.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1638.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1639.     char * label;
  1640.  
  1641.     FloatGEGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPFloatGEGoto) {
  1642.       arg1 = a1;
  1643.       arg2 = a2;
  1644.       label = lab;
  1645.     }
  1646.     ~FloatGEGoto () {}
  1647.     virtual void print ();
  1648. };
  1649.  
  1650.  
  1651.  
  1652. //----------  FloatEQGoto  ----------
  1653.  
  1654. void IRFloatEQGoto (AstNode * a1, AstNode * a2, char * lab);
  1655.  
  1656. class FloatEQGoto : public IR {
  1657.   public:
  1658.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1659.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1660.     char * label;
  1661.  
  1662.     FloatEQGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPFloatEQGoto) {
  1663.       arg1 = a1;
  1664.       arg2 = a2;
  1665.       label = lab;
  1666.     }
  1667.     ~FloatEQGoto () {}
  1668.     virtual void print ();
  1669. };
  1670.  
  1671.  
  1672.  
  1673. //----------  FloatNEGoto  ----------
  1674.  
  1675. void IRFloatNEGoto (AstNode * a1, AstNode * a2, char * lab);
  1676.  
  1677. class FloatNEGoto : public IR {
  1678.   public:
  1679.     AstNode * arg1;           // Local, Global, Parm, DoubleConst
  1680.     AstNode * arg2;           // Local, Global, Parm, DoubleConst
  1681.     char * label;
  1682.  
  1683.     FloatNEGoto (AstNode * a1, AstNode * a2, char * lab) : IR (OPFloatNEGoto) {
  1684.       arg1 = a1;
  1685.       arg2 = a2;
  1686.       label = lab;
  1687.     }
  1688.     ~FloatNEGoto () {}
  1689.     virtual void print ();
  1690. };
  1691.  
  1692.  
  1693.  
  1694. //----------  BoolTest  ----------
  1695.  
  1696. void IRBoolTest (AstNode * a, char * lab1, char * lab2);
  1697.  
  1698. class BoolTest : public IR {
  1699.   public:
  1700.     AstNode * arg;           // Local, Global, Parm, BoolConst
  1701.     char * trueLabel;
  1702.     char * falseLabel;
  1703.  
  1704.     BoolTest (AstNode * a, char * lab1, char * lab2) : IR (OPBoolTest) {
  1705.       arg = a;
  1706.       trueLabel = lab1;
  1707.       falseLabel = lab2;
  1708.     }
  1709.     ~BoolTest () {}
  1710.     virtual void print ();
  1711. };
  1712.  
  1713.  
  1714.  
  1715. //----------  BoolTest2  ----------
  1716.  
  1717. void IRBoolTest2 (char * lab1, char * lab2);
  1718.  
  1719. class BoolTest2 : public IR {
  1720.   public:
  1721.     char * trueLabel;
  1722.     char * falseLabel;
  1723.  
  1724.     BoolTest2 (char * lab1, char * lab2) : IR (OPBoolTest2) {
  1725.       trueLabel = lab1;
  1726.       falseLabel = lab2;
  1727.     }
  1728.     ~BoolTest2 () {}
  1729.     virtual void print ();
  1730. };
  1731.  
  1732.  
  1733.  
  1734. //----------  BXor  ----------
  1735.  
  1736. void IRBXor (AstNode * d, AstNode * a1, AstNode * a2);
  1737.  
  1738. class BXor : public IR {
  1739.   public:
  1740.     AstNode * dest;           // Local, Global, Parm
  1741.     AstNode * arg1;           // Local, Global, Parm, BoolConst
  1742.     AstNode * arg2;           // Local, Global, Parm, BoolConst
  1743.  
  1744.     BXor (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPBXor) {
  1745.       dest = d;
  1746.       arg1 = a1;
  1747.       arg2 = a2;
  1748.     }
  1749.     ~BXor () {}
  1750.     virtual void print ();
  1751. };
  1752.  
  1753.  
  1754.  
  1755. //----------  BEq  ----------
  1756.  
  1757. void IRBEq (AstNode * d, AstNode * a1, AstNode * a2);
  1758.  
  1759. class BEq : public IR {
  1760.   public:
  1761.     AstNode * dest;           // Local, Global, Parm
  1762.     AstNode * arg1;           // Local, Global, Parm, BoolConst
  1763.     AstNode * arg2;           // Local, Global, Parm, BoolConst
  1764.  
  1765.     BEq (AstNode * d, AstNode * a1, AstNode * a2) : IR (OPBEq) {
  1766.       dest = d;
  1767.       arg1 = a1;
  1768.       arg2 = a2;
  1769.     }
  1770.     ~BEq () {}
  1771.     virtual void print ();
  1772. };
  1773.  
  1774.  
  1775.  
  1776. //----------  BNot  ----------
  1777.  
  1778. void IRBNot (AstNode * d, AstNode * a);
  1779.  
  1780. class BNot : public IR {
  1781.   public:
  1782.     AstNode * dest;           // Local, Global, Parm
  1783.     AstNode * arg;           // Local, Global, Parm, BoolConst
  1784.  
  1785.     BNot (AstNode * d, AstNode * a) : IR (OPBNot) {
  1786.       dest = d;
  1787.       arg = a;
  1788.     }
  1789.     ~BNot () {}
  1790.     virtual void print ();
  1791. };
  1792.  
  1793.  
  1794.  
  1795. //----------  IntEqZero  ----------
  1796.  
  1797. void IRIntEqZero (AstNode * a, char * lab);
  1798.  
  1799. class IntEqZero : public IR {
  1800.   public:
  1801.     AstNode * arg;           // Local, Global, Parm, ClassField, IntConst
  1802.     char * label;
  1803.  
  1804.     IntEqZero (AstNode * a, char * lab) : IR (OPIntEqZero) {
  1805.       arg = a;
  1806.       label = lab;
  1807.     }
  1808.     ~IntEqZero () {}
  1809.     virtual void print ();
  1810. };
  1811.  
  1812.  
  1813.  
  1814. //----------  IntNeZero  ----------
  1815.  
  1816. void IRIntNeZero (AstNode * a, char * lab);
  1817.  
  1818. class IntNeZero : public IR {
  1819.   public:
  1820.     AstNode * arg;           // Local, Global, Parm, ClassField, IntConst
  1821.     char * label;
  1822.  
  1823.     IntNeZero (AstNode * a, char * lab) : IR (OPIntNeZero) {
  1824.       arg = a;
  1825.       label = lab;
  1826.     }
  1827.     ~IntNeZero () {}
  1828.     virtual void print ();
  1829. };
  1830.  
  1831.  
  1832.  
  1833. //----------  IntLeZero  ----------
  1834.  
  1835. void IRIntLeZero (AstNode * a, char * lab);
  1836.  
  1837. class IntLeZero : public IR {
  1838.   public:
  1839.     AstNode * arg;           // Local, Global, Parm, ClassField, IntConst
  1840.     char * label;
  1841.  
  1842.     IntLeZero (AstNode * a, char * lab) : IR (OPIntLeZero) {
  1843.       arg = a;
  1844.       label = lab;
  1845.     }
  1846.     ~IntLeZero () {}
  1847.     virtual void print ();
  1848. };
  1849.  
  1850.  
  1851.  
  1852. //----------  BoolEqZeroIndirect  ----------
  1853.  
  1854. void IRBoolEqZeroIndirect (VarDecl * a, char * lab);
  1855.  
  1856. class BoolEqZeroIndirect : public IR {
  1857.   public:
  1858.     VarDecl * arg;           // Local, Global, Parm, ClassField -- this will be a ptr
  1859.     char * label;
  1860.  
  1861.     BoolEqZeroIndirect (VarDecl * a, char * lab) : IR (OPBoolEqZeroIndirect) {
  1862.       arg = a;
  1863.       label = lab;
  1864.     }
  1865.     ~BoolEqZeroIndirect () {}
  1866.     virtual void print ();
  1867. };
  1868.  
  1869.  
  1870.  
  1871. //----------  PrepareArg  ----------
  1872.  
  1873. void IRPrepareArg (int off, AstNode * tname, int size);
  1874.  
  1875. class PrepareArg : public IR {
  1876.   public:
  1877.     int offset;
  1878.     AstNode * tempName;
  1879.     int sizeInBytes;
  1880.  
  1881.     PrepareArg (int off, AstNode * tname, int size) : IR (OPPrepareArg) {
  1882.       offset = off;
  1883.       tempName = tname;
  1884.       sizeInBytes = size;
  1885.     }
  1886.     ~PrepareArg () {}
  1887.     virtual void print ();
  1888. };
  1889.  
  1890.  
  1891.  
  1892. //----------  RetrieveResult  ----------
  1893.  
  1894. void IRRetrieveResult (VarDecl * tname, int size);
  1895.  
  1896. class RetrieveResult : public IR {
  1897.   public:
  1898.     VarDecl * targetName;
  1899.     int sizeInBytes;
  1900.  
  1901.     RetrieveResult (VarDecl * tname, int size) : IR (OPRetrieveResult) {
  1902.       targetName = tname;
  1903.       sizeInBytes = size;
  1904.     }
  1905.     ~RetrieveResult () {}
  1906.     virtual void print ();
  1907. };
  1908.  
  1909.  
  1910.  
  1911. //----------  ReturnResult  ----------
  1912.  
  1913. void IRReturnResult (AstNode * tname, int size);
  1914.  
  1915. class ReturnResult : public IR {
  1916.   public:
  1917.     AstNode * tempName;
  1918.     int sizeInBytes;
  1919.  
  1920.     ReturnResult (AstNode * tname, int size) : IR (OPReturnResult) {
  1921.       tempName = tname;
  1922.       sizeInBytes = size;
  1923.     }
  1924.     ~ReturnResult () {}
  1925.     virtual void print ();
  1926. };
  1927.  
  1928.  
  1929.  
  1930. //----------  Comment2  ----------
  1931.  
  1932. void IRComment2 (char * str1, char * str2, char * str3);
  1933.  
  1934. class Comment2 : public IR {
  1935.   public:
  1936.     char * str1;
  1937.     char * str2;
  1938.     char * str3;
  1939.  
  1940.     Comment2 (char * s1, char * s2, char * s3) : IR (OPComment2) {
  1941.       str1 = s1;
  1942.       str2 = s2;
  1943.       str3 = s3;
  1944.     }
  1945.     ~Comment2 () {}
  1946.     virtual void print ();
  1947. };
  1948.  
  1949.  
  1950.  
  1951. //----------  Set  ----------
  1952.  
  1953. void IRSet (VarDecl * v, int i);
  1954.  
  1955. class Set : public IR {
  1956.   public:
  1957.     VarDecl * varDecl;
  1958.     int initValue;
  1959.  
  1960.     Set (VarDecl * v, int i) : IR (OPSet) {
  1961.       varDecl = v;
  1962.       initValue = i;
  1963.     }
  1964.     ~Set () {}
  1965.     virtual void print ();
  1966. };
  1967.  
  1968.  
  1969.  
  1970. //----------  Send  ----------
  1971.  
  1972. void IRSend (VarDecl * r, MethodProto * m);
  1973.  
  1974. class Send : public IR {
  1975.   public:
  1976.     VarDecl *     recvr;
  1977.     MethodProto * methProto;
  1978.  
  1979.     Send (VarDecl * r, MethodProto * m) : IR (OPSend) {
  1980.       recvr = r;
  1981.       methProto = m;
  1982.     }
  1983.     ~Send () {}
  1984.     virtual void print ();
  1985. };
  1986.  
  1987.  
  1988.  
  1989. //----------  LoadSelfPtr  ----------
  1990.  
  1991. void IRLoadSelfPtr (VarDecl * tname);
  1992.  
  1993. class LoadSelfPtr : public IR {
  1994.   public:
  1995.     VarDecl * targetName;
  1996.  
  1997.     LoadSelfPtr (VarDecl * tname) : IR (OPLoadSelfPtr) {
  1998.       targetName = tname;
  1999.     }
  2000.     ~LoadSelfPtr () {}
  2001.     virtual void print ();
  2002. };
  2003.  
  2004.  
  2005.  
  2006. //----------  Move  ----------
  2007.  
  2008. void IRMove (VarDecl * tarV, VarDecl * tarP, AstNode * srcV, VarDecl * srcP, int sz);
  2009.  
  2010. class Move : public IR {
  2011.   public:
  2012.     VarDecl * targetVar;
  2013.     VarDecl * targetPtr;
  2014.     AstNode * srcVar;  // INT_, DOUBLE_, BOOL_, CHAR_, LOCAL, PARM, GLOBAL, CLASS_FIELD
  2015.     VarDecl * srcPtr;
  2016.     int sizeInBytes;
  2017.  
  2018.     Move (VarDecl * tarV, VarDecl * tarP, AstNode * srcV, VarDecl * srcP, int sz) : IR (OPMove) {
  2019.       targetVar = tarV;
  2020.       targetPtr = tarP;
  2021.       srcVar = srcV;
  2022.       srcPtr = srcP;
  2023.       sizeInBytes = sz;
  2024.     }
  2025.     ~Move () {}
  2026.     virtual void print ();
  2027. };
  2028.  
  2029.  
  2030.  
  2031. //----------  DynamicObjectMove  ----------
  2032.  
  2033. void IRDynamicObjectMove (VarDecl * tar, VarDecl * src);
  2034.  
  2035. class DynamicObjectMove : public IR {
  2036.   public:
  2037.     VarDecl * targetPtr;
  2038.     VarDecl * srcPtr;
  2039.  
  2040.     DynamicObjectMove (VarDecl * tar, VarDecl * src) : IR (OPDynamicObjectMove) {
  2041.       targetPtr = tar;
  2042.       srcPtr = src;
  2043.     }
  2044.     ~DynamicObjectMove () {}
  2045.     virtual void print ();
  2046. };
  2047.  
  2048.  
  2049.  
  2050. //   //----------  ZeroLocal  ----------
  2051. //   
  2052. //   void IRZeroLocal (Local * loc);
  2053. //   
  2054. //   class ZeroLocal : public IR {
  2055. //     public:
  2056. //       Local * local;
  2057. //   
  2058. //       ZeroLocal (Local * loc) : IR (OPZeroLocal) {
  2059. //         local = loc;
  2060. //       }
  2061. //       ~ZeroLocal () {}
  2062. //       virtual void print ();
  2063. //   };
  2064.  
  2065.  
  2066.  
  2067. //----------  IncrVarDirect  ----------
  2068.  
  2069. void IRIncrVarDirect (VarDecl * d, VarDecl * s, AstNode * i, int i2, int want);
  2070.  
  2071. class IncrVarDirect : public IR {
  2072.   public:
  2073.     VarDecl * dest;
  2074.     VarDecl * src;
  2075.     AstNode * incr;     // or NULL; local,parm,global,classfield, or intConst
  2076.     int       incrInt;  // This is a 16-bit number if incr is NULL
  2077.     int       wantOverflowTest;
  2078.  
  2079.     IncrVarDirect (VarDecl * d, VarDecl * s, AstNode * i, int i2, int want) : IR (OPIncrVarDirect) {
  2080.       dest = d;
  2081.       src = s;
  2082.       incr = i;
  2083.       incrInt = i2;
  2084.       wantOverflowTest = want;
  2085.     }
  2086.     ~IncrVarDirect () {}
  2087.     virtual void print ();
  2088. };
  2089.  
  2090.  
  2091.  
  2092. //----------  IncrVarIndirect  ----------
  2093.  
  2094. void IRIncrVarIndirect (VarDecl * p, VarDecl * i, int i2);
  2095.  
  2096. class IncrVarIndirect : public IR {
  2097.   public:
  2098.     VarDecl * ptr;
  2099.     VarDecl * incr;
  2100.     int       incrInt;
  2101.  
  2102.     IncrVarIndirect (VarDecl * p, VarDecl * i, int i2) : IR (OPIncrVarIndirect) {
  2103.       ptr = p;
  2104.       incr = i;
  2105.       incrInt = i2;
  2106.     }
  2107.     ~IncrVarIndirect () {}
  2108.     virtual void print ();
  2109. };
  2110.  
  2111.  
  2112.  
  2113. //----------  MultiplyVarImmed  ----------
  2114.  
  2115. void IRMultiplyVarImmed (VarDecl * d, VarDecl * s, int i);
  2116.  
  2117. class MultiplyVarImmed : public IR {
  2118.   public:
  2119.     VarDecl * dest;
  2120.     VarDecl * src;
  2121.     int       ivalue;
  2122.  
  2123.     MultiplyVarImmed (VarDecl * d, VarDecl * s, int i) : IR (OPMultiplyVarImmed) {
  2124.       dest = d;
  2125.       src = s;
  2126.       ivalue = i;
  2127.     }
  2128.     ~MultiplyVarImmed () {}
  2129.     virtual void print ();
  2130. };
  2131.  
  2132.  
  2133.  
  2134. //----------  CheckDPT  ----------
  2135.  
  2136. void IRCheckDPT (VarDecl * v, ClassDef * cl);
  2137.  
  2138. class CheckDPT : public IR {
  2139.   public:
  2140.     VarDecl * var;
  2141.     ClassDef * classDef;
  2142.  
  2143.     CheckDPT (VarDecl * v, ClassDef * cl) : IR (OPCheckDPT) {
  2144.       var = v;
  2145.       classDef = cl;
  2146.     }
  2147.     ~CheckDPT () {}
  2148.     virtual void print ();
  2149. };
  2150.  
  2151.  
  2152.  
  2153. //----------  CheckDPT2  ----------
  2154.  
  2155. void IRCheckDPT2 (VarDecl * v, ClassDef * cl);
  2156.  
  2157. class CheckDPT2 : public IR {
  2158.   public:
  2159.     VarDecl * var;
  2160.     ClassDef * classDef;
  2161.  
  2162.     CheckDPT2 (VarDecl * v, ClassDef * cl) : IR (OPCheckDPT2) {
  2163.       var = v;
  2164.       classDef = cl;
  2165.     }
  2166.     ~CheckDPT2 () {}
  2167.     virtual void print ();
  2168. };
  2169.  
  2170.  
  2171.  
  2172. //----------  CopyArrays  ----------
  2173.  
  2174. void IRCopyArrays (VarDecl * tar, VarDecl * src, int i);
  2175.  
  2176. class CopyArrays : public IR {
  2177.   public:
  2178.     VarDecl * targetPtr;
  2179.     VarDecl * srcPtr;
  2180.     int       elementSize;
  2181.  
  2182.     CopyArrays (VarDecl * tar, VarDecl * src, int i) : IR (OPCopyArrays) {
  2183.       targetPtr = tar;
  2184.       srcPtr = src;
  2185.       elementSize = i;
  2186.     }
  2187.     ~CopyArrays () {}
  2188.     virtual void print ();
  2189. };
  2190.  
  2191.  
  2192.  
  2193. //----------  CheckArraySizeInt  ----------
  2194.  
  2195. void IRCheckArraySizeInt (VarDecl * p, int i);
  2196.  
  2197. class CheckArraySizeInt : public IR {
  2198.   public:
  2199.     VarDecl * ptr;
  2200.     int       numberOfElements;
  2201.  
  2202.     CheckArraySizeInt (VarDecl * p, int i) : IR (OPCheckArraySizeInt) {
  2203.       ptr = p;
  2204.       numberOfElements = i;
  2205.     }
  2206.     ~CheckArraySizeInt () {}
  2207.     virtual void print ();
  2208. };
  2209.  
  2210.  
  2211.  
  2212. //----------  CheckArraySizeInt2  ----------
  2213.  
  2214. void IRCheckArraySizeInt2 (VarDecl * p, int i);
  2215.  
  2216. class CheckArraySizeInt2 : public IR {
  2217.   public:
  2218.     VarDecl * ptr;
  2219.     int       numberOfElements;
  2220.  
  2221.     CheckArraySizeInt2 (VarDecl * p, int i) : IR (OPCheckArraySizeInt2) {
  2222.       ptr = p;
  2223.       numberOfElements = i;
  2224.     }
  2225.     ~CheckArraySizeInt2 () {}
  2226.     virtual void print ();
  2227. };
  2228.  
  2229.  
  2230.  
  2231. //----------  ArrayIndex  ----------
  2232.  
  2233. void IRArrayIndex (VarDecl * b, AstNode * i, VarDecl * r, int sz);
  2234.  
  2235. class ArrayIndex : public IR {
  2236.   public:
  2237.     VarDecl * baseAddr;
  2238.     AstNode * indexVal;
  2239.     VarDecl * result;
  2240.     int       elementSize;
  2241.  
  2242.     ArrayIndex (VarDecl * b, AstNode * i, VarDecl * r, int sz) : IR (OPArrayIndex) {
  2243.       baseAddr = b;
  2244.       indexVal = i;
  2245.       result = r;
  2246.       elementSize = sz;
  2247.     }
  2248.     ~ArrayIndex () {}
  2249.     virtual void print ();
  2250. };
  2251.  
  2252.  
  2253.  
  2254. //----------  TestObjEq  ----------
  2255.  
  2256. void IRTestObjEq (VarDecl * p1, VarDecl * p2, char * tlab, char * flab);
  2257.  
  2258. class TestObjEq : public IR {
  2259.   public:
  2260.     VarDecl * ptr1;
  2261.     VarDecl * ptr2;
  2262.     char *    trueLabel;
  2263.     char *    falseLabel;
  2264.  
  2265.     TestObjEq (VarDecl * p1, VarDecl * p2, char * tlab, char * flab) : IR (OPTestObjEq) {
  2266.     ptr1 = p1;
  2267.     ptr2 = p2;
  2268.     trueLabel = tlab;
  2269.     falseLabel = flab;
  2270.     }
  2271.     ~TestObjEq () {}
  2272.     virtual void print ();
  2273. };
  2274.  
  2275.  
  2276.  
  2277. //----------  ForTest  ----------
  2278.  
  2279. void IRForTest (VarDecl * pt, AstNode * st, char * lab);
  2280.  
  2281. class ForTest : public IR {
  2282.   public:
  2283.     VarDecl * ptr;           // Local, Global, Parm, ClassField
  2284.     AstNode * stopVal;       // Local, Global, Parm, ClassField, IntConst
  2285.     char * exitLabel;
  2286.  
  2287.     ForTest (VarDecl * pt, AstNode * st, char * lab) : IR (OPForTest) {
  2288.       ptr = pt;
  2289.       stopVal = st;
  2290.       exitLabel = lab;
  2291.     }
  2292.     ~ForTest () {}
  2293.     virtual void print ();
  2294. };
  2295.  
  2296.  
  2297.  
  2298. //----------  ForTest2  ----------
  2299.  
  2300. void IRForTest2 (VarDecl * v, AstNode * st, char * lab);
  2301.  
  2302. class ForTest2 : public IR {
  2303.   public:
  2304.     VarDecl * var;           // Local or Parm
  2305.     AstNode * stopVal;       // Local, Global, Parm, ClassField, IntConst
  2306.     char * exitLabel;
  2307.  
  2308.     ForTest2 (VarDecl * v, AstNode * st, char * lab) : IR (OPForTest2) {
  2309.       var = v;
  2310.       stopVal = st;
  2311.       exitLabel = lab;
  2312.     }
  2313.     ~ForTest2 () {}
  2314.     virtual void print ();
  2315. };
  2316.  
  2317.  
  2318.  
  2319. //----------  SwitchReg1  ----------
  2320.  
  2321. void IRSwitchReg1 (AstNode * e);
  2322.  
  2323. class SwitchReg1 : public IR {
  2324.   public:
  2325.     AstNode * expr;
  2326.  
  2327.     SwitchReg1 (AstNode * e) : IR (OPSwitchReg1) {
  2328.       expr = e;
  2329.     }
  2330.     ~SwitchReg1 () {}
  2331.     virtual void print ();
  2332. };
  2333.  
  2334.  
  2335.  
  2336. //----------  SwitchTestReg1  ----------
  2337.  
  2338. void IRSwitchTestReg1 (int i, char * l);
  2339.  
  2340. class SwitchTestReg1 : public IR {
  2341.   public:
  2342.     int ivalue;
  2343.     char * label;
  2344.  
  2345.     SwitchTestReg1 (int i, char * l) : IR (OPSwitchTestReg1) {
  2346.       ivalue = i;
  2347.       label = l;
  2348.     }
  2349.     ~SwitchTestReg1 () {}
  2350.     virtual void print ();
  2351. };
  2352.  
  2353.  
  2354.  
  2355. //----------  SwitchDirect  ----------
  2356.  
  2357. void IRSwitchDirect (AstNode * e, char * tab, char * def, int low, int high);
  2358.  
  2359. class SwitchDirect : public IR {
  2360.   public:
  2361.     AstNode * expr;
  2362.     char * directTable;
  2363.     char * defaultLabel;
  2364.     int lowValue;
  2365.     int highValue;
  2366.  
  2367.     SwitchDirect (AstNode * e, char * tab, char * def, int low, int high) : IR (OPSwitchDirect) {
  2368.       expr = e;
  2369.       directTable = tab;
  2370.       defaultLabel = def;
  2371.       lowValue = low;
  2372.       highValue = high;
  2373.     }
  2374.     ~SwitchDirect () {}
  2375.     virtual void print ();
  2376. };
  2377.  
  2378.  
  2379.  
  2380.  
  2381. //----------  SwitchHashJump  ----------
  2382.  
  2383. void IRSwitchHashJump (AstNode * e, char * tab, char * def, int sz);
  2384.  
  2385. class SwitchHashJump : public IR {
  2386.   public:
  2387.     AstNode * expr;
  2388.     char * tableName;
  2389.     char * defaultLabel;
  2390.     int tableSize;
  2391.  
  2392.     SwitchHashJump (AstNode * e, char * tab, char * def, int sz) : IR (OPSwitchHashJump) {
  2393.       expr = e;
  2394.       tableName = tab;
  2395.       defaultLabel = def;
  2396.       tableSize = sz;
  2397.     }
  2398.     ~SwitchHashJump () {}
  2399.     virtual void print ();
  2400. };
  2401.  
  2402.  
  2403.  
  2404. //----------  Alloc  ----------
  2405.  
  2406. void IRAlloc (VarDecl * d, VarDecl * b);
  2407.  
  2408. class Alloc : public IR {
  2409.   public:
  2410.     VarDecl * dest;
  2411.     VarDecl * byteCount;
  2412.  
  2413.     Alloc (VarDecl * d, VarDecl * b) : IR (OPAlloc) {
  2414.       dest = d;
  2415.       byteCount = b;
  2416.     }
  2417.     ~Alloc () {}
  2418.     virtual void print ();
  2419. };
  2420.  
  2421.  
  2422.  
  2423. //----------  Free  ----------
  2424.  
  2425. void IRFree (AstNode * p);
  2426.  
  2427. class Free : public IR {
  2428.   public:
  2429.     AstNode * ptr;
  2430.  
  2431.     Free (AstNode * p) : IR (OPFree) {
  2432.       ptr = p;
  2433.     }
  2434.     ~Free () {}
  2435.     virtual void print ();
  2436. };
  2437.  
  2438.  
  2439.  
  2440. //----------  SaveCatchStack  ----------
  2441.  
  2442. void IRSaveCatchStack (VarDecl * t);
  2443.  
  2444. class SaveCatchStack : public IR {
  2445.   public:
  2446.     VarDecl * temp;
  2447.  
  2448.     SaveCatchStack (VarDecl * t) : IR (OPSaveCatchStack) {
  2449.       temp = t;
  2450.     }
  2451.     ~SaveCatchStack () {}
  2452.     virtual void print ();
  2453. };
  2454.  
  2455.  
  2456.  
  2457. //----------  RestoreCatchStack  ----------
  2458.  
  2459. void IRRestoreCatchStack (VarDecl * t);
  2460.  
  2461. class RestoreCatchStack : public IR {
  2462.   public:
  2463.     VarDecl * temp;
  2464.  
  2465.     RestoreCatchStack (VarDecl * t) : IR (OPRestoreCatchStack) {
  2466.       temp = t;
  2467.     }
  2468.     ~RestoreCatchStack () {}
  2469.     virtual void print ();
  2470. };
  2471.  
  2472.  
  2473.  
  2474. //----------  PushCatchRecord  ----------
  2475.  
  2476. void IRPushCatchRecord (Catch * cat);
  2477.  
  2478. class PushCatchRecord : public IR {
  2479.   public:
  2480.     Catch * cat;
  2481.  
  2482.     PushCatchRecord (Catch * c) : IR (OPPushCatchRecord) {
  2483.       cat = c;
  2484.     }
  2485.     ~PushCatchRecord () {}
  2486.     virtual void print ();
  2487. };
  2488.  
  2489.  
  2490.  
  2491. //----------  Throw  ----------
  2492.  
  2493. void IRThrow (ErrorDecl * errorDecl);
  2494.  
  2495. class Throw : public IR {
  2496.   public:
  2497.     ErrorDecl * errorDecl;
  2498.  
  2499.     Throw (ErrorDecl * e) : IR (OPThrow) {
  2500.       errorDecl = e;
  2501.     }
  2502.     ~Throw () {}
  2503.     virtual void print ();
  2504. };
  2505.  
  2506.  
  2507.  
  2508. //----------  CopyCatchParm  ----------
  2509.  
  2510. void IRCopyCatchParm (Parameter * parm);
  2511.  
  2512. class CopyCatchParm : public IR {
  2513.   public:
  2514.     Parameter * parm;
  2515.  
  2516.     CopyCatchParm (Parameter * p) : IR (OPCopyCatchParm) {
  2517.       parm = p;
  2518.     }
  2519.     ~CopyCatchParm () {}
  2520.     virtual void print ();
  2521. };
  2522.  
  2523.  
  2524.  
  2525. //----------  ResetStack  ----------
  2526.  
  2527. void IRResetStack ();
  2528.  
  2529. class ResetStack : public IR {
  2530.   public:
  2531.  
  2532.     ResetStack () : IR (OPResetStack) {
  2533.     }
  2534.     ~ResetStack () {}
  2535.     virtual void print ();
  2536. };
  2537.  
  2538.  
  2539.  
  2540. //----------  IsKindOf  ----------
  2541.  
  2542. void IRIsKindOf (VarDecl * target, VarDecl * temp, char * descLab, char * falseLabel);
  2543.  
  2544. class IsKindOf : public IR {
  2545.   public:
  2546.     VarDecl * target;
  2547.     VarDecl * temp;
  2548.     char * falseLabel;
  2549.     char * descLab;
  2550.  
  2551.     IsKindOf (VarDecl * tar, VarDecl * tmp, char * dslab, char * lab) : IR (OPIsKindOf) {
  2552.       target = tar;
  2553.       temp = tmp;
  2554.       descLab = dslab;
  2555.       falseLabel = lab;
  2556.     }
  2557.     ~IsKindOf () {}
  2558.     virtual void print ();
  2559. };
  2560.  
  2561.  
  2562.  
  2563. //----------  IsInstanceOf  ----------
  2564.  
  2565. void IRIsInstanceOf (VarDecl * target, VarDecl * temp, char * descLab, char * falseLabel);
  2566.  
  2567. class IsInstanceOf : public IR {
  2568.   public:
  2569.     VarDecl * target;
  2570.     VarDecl * temp;
  2571.     char * falseLabel;
  2572.     char * descLab;
  2573.  
  2574.     IsInstanceOf (VarDecl * tar, VarDecl * tmp, char * dslab, char * lab) : IR (OPIsInstanceOf) {
  2575.       target = tar;
  2576.       temp = tmp;
  2577.       descLab = dslab;
  2578.       falseLabel = lab;
  2579.     }
  2580.     ~IsInstanceOf () {}
  2581.     virtual void print ();
  2582. };
  2583.  
  2584.  
  2585.  
  2586. //----------  ZeroMemory  ----------
  2587.  
  2588. void IRZeroMemory (VarDecl * tarV, VarDecl * tarP, int sz);
  2589.  
  2590. class ZeroMemory : public IR {
  2591.   public:
  2592.     VarDecl * targetVar;
  2593.     VarDecl * targetPtr;
  2594.     int sizeInBytes;
  2595.  
  2596.     ZeroMemory (VarDecl * tarV, VarDecl * tarP, int sz) : IR (OPZeroMemory) {
  2597.       targetVar = tarV;
  2598.       targetPtr = tarP;
  2599.       sizeInBytes = sz;
  2600.     }
  2601.     ~ZeroMemory () {}
  2602.     virtual void print ();
  2603. };
  2604.