Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members  

skParseNode.h

00001 /*
00002   Copyright 1996-2001
00003   Simon Whiteside
00004 
00005  * $Id: skParseNode.h,v 1.24 2001/11/16 23:03:24 sdw Exp $
00006 */
00007 
00008 #ifndef PARSENODE_H
00009 #define PARSENODE_H
00010 #include "skStringList.h"
00011 #include "skAlist.h"
00012 
00013 
00014 static const int s_If=4;
00015 static const int s_While=5;
00016 static const int s_Return=6;
00017 static const int s_Assign=7;
00018 static const int s_Method=8;
00019 static const int s_IdList=9;
00020 static const int s_String=10;
00021 static const int s_Integer=11;
00022 static const int s_Not=12;
00023 static const int s_And=13;
00024 static const int s_Or=14;
00025 static const int s_Less=15;
00026 static const int s_More=16;
00027 static const int s_Equals=17;
00028 static const int s_Plus=18;
00029 static const int s_Minus=19;
00030 static const int s_Subtract=20;
00031 static const int s_Concat=21;
00032 static const int s_Divide=22;
00033 static const int s_Mult=23;
00034 static const int s_Mod=24;
00035 static const int s_Float=25;
00036 static const int s_Character=26;
00037 static const int s_CaseList=27;
00038 static const int s_Case=28;
00039 static const int s_Switch=29;
00040 static const int s_Id=30;
00041 static const int s_NotEquals=31;
00042 static const int s_ForEach=32;
00043 static const int s_LessEqual=33;
00044 static const int s_MoreEqual=34;
00045 static const int s_For=35;
00046 
00050 class  skParseNode {
00051  public:
00054   skParseNode(int linenum){
00055           m_LineNum=linenum;
00056   }
00058   virtual ~skParseNode(){
00059   }
00061   virtual int getType(){
00062     return 0;
00063   }
00065   virtual void clear(){
00066   }
00068   int m_LineNum;
00069  private:
00070   skParseNode(const skParseNode& ){
00071   }
00072   skParseNode& operator=(const skParseNode&){
00073     return *this;
00074   }
00075 };
00076 class  skParseNodeList : public skTAList<skParseNode>{
00077 };
00078 typedef  skTAListIterator<skParseNode> skParseNodeListIterator;
00079 class  skStatNode : public skParseNode {
00080  public:
00081   skStatNode(int linenum) : skParseNode(linenum){
00082   }
00083   virtual ~skStatNode(){
00084   }
00085 };
00086 class  skExprNode : public skParseNode {
00087  public:
00088   skExprNode(int linenum) : skParseNode(linenum){
00089   }
00090   virtual ~skExprNode(){
00091   }
00092 };
00093 typedef skTAList<skStatNode> skStatList;
00094 typedef skTAListIterator<skStatNode> skStatListIterator;
00095 
00096 class  skStatListNode : public skParseNode {
00097  public:
00098   skStatList m_Stats;
00099   skStatListNode(int linenum): skParseNode(linenum){
00100   }
00101   inline ~skStatListNode(){
00102     m_Stats.clearAndDestroy();
00103   }
00104   inline void addStat(skStatNode * stat){
00105     m_Stats.append(stat);
00106   }
00107   inline void clear(){
00108     m_Stats.clear();
00109   }
00110   inline int numStats(){
00111     return m_Stats.entries();
00112   }
00113 };
00114 typedef skTAList<skExprNode> skExprList;
00115 typedef skTAListIterator<skExprNode> skExprListIterator;
00116 class  skExprListNode : public skParseNode {
00117  public:
00118   skExprList m_Exprs;
00119   skExprListNode(int linenum): skParseNode(linenum){
00120   }
00121   inline ~skExprListNode(){
00122     m_Exprs.clearAndDestroy();
00123   }
00124   inline void addExpr(skExprNode * expr){
00125     m_Exprs.append(expr);
00126   }
00127   inline int numExprs(){
00128     return m_Exprs.entries();;
00129   }
00130   inline void clear(){
00131     m_Exprs.clear();
00132   }
00133 };
00134 class  skIdNode : public skExprNode {
00135  public:
00136   skString m_Id;
00137   skExprListNode * m_Exprs;
00138   skExprNode * m_ArrayIndex;
00139   inline skIdNode(int linenum,skString id,skExprNode * arrayIndex,skExprListNode * exprs) : skExprNode(linenum){
00140     m_Id=id;
00141     m_Exprs=exprs;
00142     m_ArrayIndex=arrayIndex;
00143   }
00144   inline ~skIdNode(){
00145     delete m_Exprs;
00146   }
00147   inline void clear(){
00148     m_Exprs=0;
00149     m_ArrayIndex=0;
00150   }
00151   inline int getType(){
00152     return s_Id;
00153   }
00154 };
00155 class  skIdNodeList : public skTAList<skIdNode>{
00156 };
00157 typedef  skTAListIterator<skIdNode> skIdNodeListIterator;
00158 class  skIdListNode : public skExprNode {
00159  public:
00160   skIdNodeList m_Ids;
00161   skString m_Attribute;
00162   inline skIdListNode(int linenum) : skExprNode(linenum){
00163   }
00164   inline ~skIdListNode(){
00165   }
00166   inline void addId(skIdNode * node){
00167     m_Ids.append(node);
00168   }
00169   inline void prependId(skIdNode * node){
00170     m_Ids.prepend(node);
00171   }
00172   inline int numIds(){
00173     return m_Ids.entries();
00174   }
00175   inline void clear(){
00176     m_Ids.clear();
00177   }
00178   inline skIdNode * getLastId(){
00179     return m_Ids[m_Ids.entries()-1];
00180   }
00181   inline int getType(){
00182     return s_IdList;
00183   }
00184 };
00185 class  skCaseNode : public skParseNode {
00186  public:
00187   skExprNode * m_Expr;
00188   skStatListNode * m_Stats;
00189   inline skCaseNode(int linenum,skExprNode * expr,skStatListNode * stat) : skParseNode(linenum){
00190     m_Expr=expr;
00191     m_Stats=stat;
00192   }
00193   inline ~skCaseNode(){
00194     delete m_Expr;
00195     delete m_Stats;
00196   }
00197   inline void clear(){
00198     m_Expr=0;
00199     m_Stats=0;
00200   }
00201   inline int getType(){
00202     return s_Case;
00203   }
00204 };
00205 typedef skTAList<skCaseNode> skCaseList;
00206 typedef skTAListIterator<skCaseNode> skCaseListIterator;
00207 class  skCaseListNode : public skParseNode {
00208  public:
00209   skCaseList m_Cases;
00210   inline skCaseListNode(int linenum) : skParseNode(linenum){
00211   }
00212   inline ~skCaseListNode(){
00213     m_Cases.clearAndDestroy();
00214   }
00215   inline void addCase(skCaseNode * expr){
00216     m_Cases.append(expr);
00217   }
00218   inline int numCases(){
00219     return m_Cases.entries();;
00220   }
00221   inline void clear(){
00222     m_Cases.clear();
00223   }
00224 };
00225 class  skSwitchNode : public skStatNode {
00226  public:
00227   skExprNode * m_Expr;
00228   skCaseListNode * m_Cases;
00229   skStatListNode * m_Default;
00230   inline skSwitchNode(int linenum,skExprNode * expr,skCaseListNode * cases,skStatListNode * defaultStat) : skStatNode(linenum){
00231     m_Expr=expr;
00232     m_Cases=cases;
00233     m_Default=defaultStat;
00234   }
00235   inline ~skSwitchNode(){
00236     delete m_Expr;
00237     delete m_Cases;
00238     delete m_Default;
00239   }
00240   inline void clear(){
00241     m_Expr=0;
00242     m_Cases=0;
00243     m_Default=0;
00244   }
00245   inline int getType(){
00246     return s_Switch;
00247   }
00248 };
00249 class  skIfNode : public skStatNode {
00250  public:
00251   skExprNode * m_Expr;
00252   skStatListNode * m_Stats;
00253   skStatListNode * m_Else;
00254   inline skIfNode(int linenum,skExprNode * expr,skStatListNode * stat,skStatListNode * elseStat) : skStatNode(linenum){
00255     m_Expr=expr;
00256     m_Stats=stat;
00257     m_Else=elseStat;
00258   }
00259   inline ~skIfNode(){
00260     delete m_Expr;
00261     delete m_Stats;
00262     delete m_Else;
00263   }
00264   inline void clear(){
00265     m_Expr=0;
00266     m_Stats=0;
00267     m_Else=0;
00268   }
00269   inline int getType(){
00270     return s_If;
00271   }
00272 };
00273 class  skReturnNode : public skStatNode {
00274  public:
00275   skExprNode * m_Expr;
00276   inline skReturnNode(int linenum,skExprNode * expr) : skStatNode(linenum){
00277     m_Expr=expr;
00278   }
00279   inline ~skReturnNode(){
00280     delete m_Expr;
00281   }
00282   inline void clear(){
00283     m_Expr=0;
00284   }
00285   inline int getType(){
00286     return s_Return;
00287   }
00288 };
00289 class  skWhileNode : public skStatNode {
00290  public:
00291   skExprNode * m_Expr;
00292   skStatListNode * m_Stats;
00293   inline skWhileNode(int linenum,skExprNode * expr,skStatListNode * stat) : skStatNode(linenum){
00294     m_Expr=expr;
00295     m_Stats=stat;
00296   }
00297   inline ~skWhileNode(){
00298     delete m_Expr;
00299     delete m_Stats;
00300   }
00301   inline void clear(){
00302     m_Expr=0;
00303     m_Stats=0;
00304   }
00305   inline int getType(){
00306     return s_While;
00307   }
00308 };
00309 class  skForEachNode : public skStatNode {
00310  public:
00311   skString m_Id;
00312   skString m_Qualifier;
00313   skExprNode * m_Expr;
00314   skStatListNode * m_Stats;
00315   inline skForEachNode(int linenum,skString id,skExprNode * expr,skStatListNode * stat) : skStatNode(linenum){
00316     m_Id=id;
00317     m_Expr=expr;
00318     m_Stats=stat;
00319   }
00320   inline skForEachNode(int linenum,skString qualifier,skString id,skExprNode * expr,skStatListNode * stat) : skStatNode(linenum){
00321     m_Id=id;
00322     m_Qualifier=qualifier;
00323     m_Expr=expr;
00324     m_Stats=stat;
00325   }
00326   inline ~skForEachNode(){
00327     delete m_Expr;
00328     delete m_Stats;
00329   }
00330   inline void clear(){
00331     m_Expr=0;
00332     m_Stats=0;
00333   }
00334   inline int getType(){
00335     return s_ForEach;
00336   }
00337 };
00338 class  skForNode : public skStatNode {
00339  public:
00340   skString m_Id;
00341   skExprNode * m_StartExpr;
00342   skExprNode * m_EndExpr;
00343   skExprNode * m_StepExpr;
00344   skStatListNode * m_Stats;
00345   inline skForNode(int linenum,skString id,skExprNode * start_expr,skExprNode * end_expr,skStatListNode * stat) : skStatNode(linenum){
00346     m_Id=id;
00347     m_StartExpr=start_expr;
00348     m_EndExpr=end_expr;
00349     m_StepExpr=0;
00350     m_Stats=stat;
00351   }
00352   inline skForNode(int linenum,skString id,skExprNode * start_expr,skExprNode * end_expr,skExprNode * step_expr,skStatListNode * stat) : skStatNode(linenum){
00353     m_Id=id;
00354     m_StartExpr=start_expr;
00355     m_EndExpr=end_expr;
00356     m_StepExpr=step_expr;
00357     m_Stats=stat;
00358   }
00359   inline ~skForNode(){
00360     delete m_StartExpr;
00361     delete m_EndExpr;
00362     delete m_StepExpr;
00363     delete m_Stats;
00364   }
00365   inline void clear(){
00366     m_StartExpr=0;
00367     m_EndExpr=0;
00368     m_StepExpr=0;
00369     m_Stats=0;
00370   }
00371   inline int getType(){
00372     return s_For;
00373   }
00374 };
00375 class  skAssignNode : public skStatNode {
00376  public:
00377   skIdListNode * m_Ids;
00378   skExprNode * m_Expr;
00379   inline skAssignNode(int linenum,skIdListNode * idlist, skString * attribute,skExprNode * expr) : skStatNode(linenum){
00380     m_Ids=idlist;
00381     if (attribute)
00382       m_Ids->m_Attribute=*attribute;
00383     delete attribute;
00384     m_Expr=expr;
00385   }
00386   inline ~skAssignNode(){
00387     delete m_Ids;
00388     delete m_Expr;
00389   }
00390   inline void clear(){
00391     m_Ids=0;
00392     m_Expr=0;
00393   }
00394   inline int getType(){
00395     return s_Assign;
00396   }
00397 };
00398 class  skMethodStatNode : public skStatNode {
00399  public:
00400   skIdListNode * m_Ids;
00401   inline skMethodStatNode(int linenum,skIdListNode * idlist) : skStatNode(linenum){
00402     m_Ids=idlist;
00403   }
00404   inline ~skMethodStatNode(){
00405     delete m_Ids;
00406   }
00407   inline void clear(){
00408     m_Ids->clear();
00409     m_Ids=0;
00410   }
00411   inline int getType(){
00412     return s_Method;
00413   }
00414 };
00415 class  skLiteralNode : public skExprNode {
00416  public:
00417   int m_Type;
00418   union {
00419     float m_Float;
00420     int m_Int;
00421     Char m_Char;
00422     skString * m_String;
00423   };
00424   inline skLiteralNode(int linenum,skString * s) : skExprNode(linenum){
00425     m_String=s;
00426     m_Type=s_String;
00427   }
00428   inline skLiteralNode(int linenum,int i): skExprNode(linenum){
00429     m_Int=i;
00430     m_Type=s_Integer;
00431   }
00432   inline skLiteralNode(int linenum,Char i): skExprNode(linenum){
00433     m_Char=i;
00434     m_Type=s_Character;
00435   }
00436   inline skLiteralNode(int linenum,float f): skExprNode(linenum){
00437     m_Float=f;
00438     m_Type=s_Float;
00439   }
00440   inline ~skLiteralNode(){
00441     if (m_Type==s_String)
00442       delete m_String;
00443   }
00444   inline void clear(){
00445     m_String=0;
00446   }
00447   inline int getType(){
00448     return m_Type;
00449   }
00450 };
00451 class  skOpNode : public skExprNode {
00452  public:
00453   skExprNode * m_Expr1;
00454   skExprNode * m_Expr2;
00455   int m_Type;
00456   inline skOpNode(int linenum,int type,skExprNode * expr1,skExprNode * expr2): skExprNode(linenum){
00457     m_Expr1=expr1;
00458     m_Expr2=expr2;
00459     m_Type=type;
00460   }
00461   virtual ~skOpNode(){
00462     delete m_Expr1;
00463     delete m_Expr2;
00464   }
00465   inline void clear(){
00466     m_Expr1=0;
00467     m_Expr2=0;
00468   }
00469   inline int getType(){
00470     return m_Type;
00471   }
00472 };
00477 class  skMethodDefNode : public skParseNode {
00478  public:
00480   skStatListNode * m_Stats;
00482   skIdListNode * m_Params;
00484   inline skMethodDefNode(int linenum,skStatListNode * stats) : skParseNode(linenum){
00485     m_Stats=stats;
00486     m_Params=0;
00487   }
00489   inline skMethodDefNode(int linenum,skIdListNode * params,skStatListNode * stats) : skParseNode(linenum){
00490     m_Stats=stats;
00491     m_Params=params;
00492   }
00494   inline ~skMethodDefNode(){
00495     delete m_Stats;
00496     delete m_Params;
00497   }
00499   inline void clear(){
00500     m_Stats=0;
00501     m_Params=0;
00502   }
00503  private:
00504   skMethodDefNode(const skMethodDefNode& ) : skParseNode(0){
00505   }
00506   skMethodDefNode& operator=(const skMethodDefNode&){
00507     return *this;
00508   }
00509 };
00510 #endif
00511 

Generated on Tue Nov 20 17:56:21 2001 for Simkin by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001