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-source.html,v 1.17 2001/07/05 09:56:08 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:
00052   skParseNode(int linenum){
00053           m_LineNum=linenum;
00054   }
00055   virtual ~skParseNode(){
00056   }
00057   virtual int getType(){
00058     return 0;
00059   }
00060   virtual void clear(){
00061   }
00062   int m_LineNum;
00063  private:
00064   skParseNode(const skParseNode& ){
00065   }
00066   skParseNode& operator=(const skParseNode&){
00067     return *this;
00068   }
00069 };
00070 class skParseNodeList : public skTAList<skParseNode>{
00071 };
00072 typedef  skTAListIterator<skParseNode> skParseNodeListIterator;
00073 class skStatNode : public skParseNode {
00074  public:
00075   skStatNode(int linenum) : skParseNode(linenum){
00076   }
00077   virtual ~skStatNode(){
00078   }
00079 };
00080 class skExprNode : public skParseNode {
00081  public:
00082   skExprNode(int linenum) : skParseNode(linenum){
00083   }
00084   virtual ~skExprNode(){
00085   }
00086 };
00087 typedef skTAList<skStatNode> skStatList;
00088 typedef skTAListIterator<skStatNode> skStatListIterator;
00089 
00090 class skStatListNode : public skParseNode {
00091  public:
00092   skStatList m_Stats;
00093   skStatListNode(int linenum): skParseNode(linenum){
00094   }
00095   inline ~skStatListNode(){
00096     m_Stats.clearAndDestroy();
00097   }
00098   inline void addStat(skStatNode * stat){
00099     m_Stats.append(stat);
00100   }
00101   inline void clear(){
00102     m_Stats.clear();
00103   }
00104   inline int numStats(){
00105     return m_Stats.entries();
00106   }
00107 };
00108 typedef skTAList<skExprNode> skExprList;
00109 typedef skTAListIterator<skExprNode> skExprListIterator;
00110 class skExprListNode : public skParseNode {
00111  public:
00112   skExprList m_Exprs;
00113   skExprListNode(int linenum): skParseNode(linenum){
00114   }
00115   inline ~skExprListNode(){
00116     m_Exprs.clearAndDestroy();
00117   }
00118   inline void addExpr(skExprNode * expr){
00119     m_Exprs.append(expr);
00120   }
00121   inline int numExprs(){
00122     return m_Exprs.entries();;
00123   }
00124   inline void clear(){
00125     m_Exprs.clear();
00126   }
00127 };
00128 class skIdNode : public skExprNode {
00129  public:
00130   skString m_Id;
00131   skExprListNode * m_Exprs;
00132   skExprNode * m_ArrayIndex;
00133   inline skIdNode(int linenum,skString id,skExprNode * arrayIndex,skExprListNode * exprs) : skExprNode(linenum){
00134     m_Id=id;
00135     m_Exprs=exprs;
00136     m_ArrayIndex=arrayIndex;
00137   }
00138   inline ~skIdNode(){
00139     delete m_Exprs;
00140   }
00141   inline void clear(){
00142     m_Exprs=0;
00143     m_ArrayIndex=0;
00144   }
00145   inline int getType(){
00146     return s_Id;
00147   }
00148 };
00149 class skIdNodeList : public skTAList<skIdNode>{
00150 };
00151 typedef  skTAListIterator<skIdNode> skIdNodeListIterator;
00152 class skIdListNode : public skExprNode {
00153  public:
00154   skIdNodeList m_Ids;
00155   skString m_Attribute;
00156   inline skIdListNode(int linenum) : skExprNode(linenum){
00157   }
00158   inline ~skIdListNode(){
00159   }
00160   inline void addId(skIdNode * node){
00161     m_Ids.append(node);
00162   }
00163   inline void prependId(skIdNode * node){
00164     m_Ids.prepend(node);
00165   }
00166   inline int numIds(){
00167     return m_Ids.entries();
00168   }
00169   inline void clear(){
00170     m_Ids.clear();
00171   }
00172   inline skIdNode * getLastId(){
00173     return m_Ids[m_Ids.entries()-1];
00174   }
00175   inline int getType(){
00176     return s_IdList;
00177   }
00178 };
00179 class skCaseNode : public skParseNode {
00180  public:
00181   skExprNode * m_Expr;
00182   skStatListNode * m_Stats;
00183   inline skCaseNode(int linenum,skExprNode * expr,skStatListNode * stat) : skParseNode(linenum){
00184     m_Expr=expr;
00185     m_Stats=stat;
00186   }
00187   inline ~skCaseNode(){
00188     delete m_Expr;
00189     delete m_Stats;
00190   }
00191   inline void clear(){
00192     m_Expr=0;
00193     m_Stats=0;
00194   }
00195   inline int getType(){
00196     return s_Case;
00197   }
00198 };
00199 typedef skTAList<skCaseNode> skCaseList;
00200 typedef skTAListIterator<skCaseNode> skCaseListIterator;
00201 class skCaseListNode : public skParseNode {
00202  public:
00203   skCaseList m_Cases;
00204   inline skCaseListNode(int linenum) : skParseNode(linenum){
00205   }
00206   inline ~skCaseListNode(){
00207     m_Cases.clearAndDestroy();
00208   }
00209   inline void addCase(skCaseNode * expr){
00210     m_Cases.append(expr);
00211   }
00212   inline int numCases(){
00213     return m_Cases.entries();;
00214   }
00215   inline void clear(){
00216     m_Cases.clear();
00217   }
00218 };
00219 class skSwitchNode : public skStatNode {
00220  public:
00221   skExprNode * m_Expr;
00222   skCaseListNode * m_Cases;
00223   skStatListNode * m_Default;
00224   inline skSwitchNode(int linenum,skExprNode * expr,skCaseListNode * cases,skStatListNode * defaultStat) : skStatNode(linenum){
00225     m_Expr=expr;
00226     m_Cases=cases;
00227     m_Default=defaultStat;
00228   }
00229   inline ~skSwitchNode(){
00230     delete m_Expr;
00231     delete m_Cases;
00232     delete m_Default;
00233   }
00234   inline void clear(){
00235     m_Expr=0;
00236     m_Cases=0;
00237     m_Default=0;
00238   }
00239   inline int getType(){
00240     return s_Switch;
00241   }
00242 };
00243 class skIfNode : public skStatNode {
00244  public:
00245   skExprNode * m_Expr;
00246   skStatListNode * m_Stats;
00247   skStatListNode * m_Else;
00248   inline skIfNode(int linenum,skExprNode * expr,skStatListNode * stat,skStatListNode * elseStat) : skStatNode(linenum){
00249     m_Expr=expr;
00250     m_Stats=stat;
00251     m_Else=elseStat;
00252   }
00253   inline ~skIfNode(){
00254     delete m_Expr;
00255     delete m_Stats;
00256     delete m_Else;
00257   }
00258   inline void clear(){
00259     m_Expr=0;
00260     m_Stats=0;
00261     m_Else=0;
00262   }
00263   inline int getType(){
00264     return s_If;
00265   }
00266 };
00267 class skReturnNode : public skStatNode {
00268  public:
00269   skExprNode * m_Expr;
00270   inline skReturnNode(int linenum,skExprNode * expr) : skStatNode(linenum){
00271     m_Expr=expr;
00272   }
00273   inline ~skReturnNode(){
00274     delete m_Expr;
00275   }
00276   inline void clear(){
00277     m_Expr=0;
00278   }
00279   inline int getType(){
00280     return s_Return;
00281   }
00282 };
00283 class skWhileNode : public skStatNode {
00284  public:
00285   skExprNode * m_Expr;
00286   skStatListNode * m_Stats;
00287   inline skWhileNode(int linenum,skExprNode * expr,skStatListNode * stat) : skStatNode(linenum){
00288     m_Expr=expr;
00289     m_Stats=stat;
00290   }
00291   inline ~skWhileNode(){
00292     delete m_Expr;
00293     delete m_Stats;
00294   }
00295   inline void clear(){
00296     m_Expr=0;
00297     m_Stats=0;
00298   }
00299   inline int getType(){
00300     return s_While;
00301   }
00302 };
00303 class skForEachNode : public skStatNode {
00304  public:
00305   skString m_Id;
00306   skString m_Qualifier;
00307   skExprNode * m_Expr;
00308   skStatListNode * m_Stats;
00309   inline skForEachNode(int linenum,skString id,skExprNode * expr,skStatListNode * stat) : skStatNode(linenum){
00310     m_Id=id;
00311     m_Expr=expr;
00312     m_Stats=stat;
00313   }
00314   inline skForEachNode(int linenum,skString qualifier,skString id,skExprNode * expr,skStatListNode * stat) : skStatNode(linenum){
00315     m_Id=id;
00316     m_Qualifier=qualifier;
00317     m_Expr=expr;
00318     m_Stats=stat;
00319   }
00320   inline ~skForEachNode(){
00321     delete m_Expr;
00322     delete m_Stats;
00323   }
00324   inline void clear(){
00325     m_Expr=0;
00326     m_Stats=0;
00327   }
00328   inline int getType(){
00329     return s_ForEach;
00330   }
00331 };
00332 class skForNode : public skStatNode {
00333  public:
00334   skString m_Id;
00335   skExprNode * m_StartExpr;
00336   skExprNode * m_EndExpr;
00337   skExprNode * m_StepExpr;
00338   skStatListNode * m_Stats;
00339   inline skForNode(int linenum,skString id,skExprNode * start_expr,skExprNode * end_expr,skStatListNode * stat) : skStatNode(linenum){
00340     m_Id=id;
00341     m_StartExpr=start_expr;
00342     m_EndExpr=end_expr;
00343     m_StepExpr=0;
00344     m_Stats=stat;
00345   }
00346   inline skForNode(int linenum,skString id,skExprNode * start_expr,skExprNode * end_expr,skExprNode * step_expr,skStatListNode * stat) : skStatNode(linenum){
00347     m_Id=id;
00348     m_StartExpr=start_expr;
00349     m_EndExpr=end_expr;
00350     m_StepExpr=step_expr;
00351     m_Stats=stat;
00352   }
00353   inline ~skForNode(){
00354     delete m_StartExpr;
00355     delete m_EndExpr;
00356     delete m_StepExpr;
00357     delete m_Stats;
00358   }
00359   inline void clear(){
00360     m_StartExpr=0;
00361     m_EndExpr=0;
00362     m_StepExpr=0;
00363     m_Stats=0;
00364   }
00365   inline int getType(){
00366     return s_For;
00367   }
00368 };
00369 class skAssignNode : public skStatNode {
00370  public:
00371   skIdListNode * m_Ids;
00372   skExprNode * m_Expr;
00373   inline skAssignNode(int linenum,skIdListNode * idlist, skString * attribute,skExprNode * expr) : skStatNode(linenum){
00374     m_Ids=idlist;
00375     if (attribute)
00376       m_Ids->m_Attribute=*attribute;
00377     delete attribute;
00378     m_Expr=expr;
00379   }
00380   inline ~skAssignNode(){
00381     delete m_Ids;
00382     delete m_Expr;
00383   }
00384   inline void clear(){
00385     m_Ids=0;
00386     m_Expr=0;
00387   }
00388   inline int getType(){
00389     return s_Assign;
00390   }
00391 };
00392 class skMethodStatNode : public skStatNode {
00393  public:
00394   skIdListNode * m_Ids;
00395   inline skMethodStatNode(int linenum,skIdListNode * idlist) : skStatNode(linenum){
00396     m_Ids=idlist;
00397   }
00398   inline ~skMethodStatNode(){
00399     delete m_Ids;
00400   }
00401   inline void clear(){
00402     m_Ids->clear();
00403     m_Ids=0;
00404   }
00405   inline int getType(){
00406     return s_Method;
00407   }
00408 };
00409 class skLiteralNode : public skExprNode {
00410  public:
00411   int m_Type;
00412   union {
00413     float m_Float;
00414     int m_Int;
00415     Char m_Char;
00416     skString * m_String;
00417   };
00418   inline skLiteralNode(int linenum,skString * s) : skExprNode(linenum){
00419     m_String=s;
00420     m_Type=s_String;
00421   }
00422   inline skLiteralNode(int linenum,int i): skExprNode(linenum){
00423     m_Int=i;
00424     m_Type=s_Integer;
00425   }
00426   inline skLiteralNode(int linenum,Char i): skExprNode(linenum){
00427     m_Char=i;
00428     m_Type=s_Character;
00429   }
00430   inline skLiteralNode(int linenum,float f): skExprNode(linenum){
00431     m_Float=f;
00432     m_Type=s_Float;
00433   }
00434   inline ~skLiteralNode(){
00435     if (m_Type==s_String)
00436       delete m_String;
00437   }
00438   inline void clear(){
00439     m_String=0;
00440   }
00441   inline int getType(){
00442     return m_Type;
00443   }
00444 };
00445 class skOpNode : public skExprNode {
00446  public:
00447   skExprNode * m_Expr1;
00448   skExprNode * m_Expr2;
00449   int m_Type;
00450   inline skOpNode(int linenum,int type,skExprNode * expr1,skExprNode * expr2): skExprNode(linenum){
00451     m_Expr1=expr1;
00452     m_Expr2=expr2;
00453     m_Type=type;
00454   }
00455   virtual ~skOpNode(){
00456     delete m_Expr1;
00457     delete m_Expr2;
00458   }
00459   inline void clear(){
00460     m_Expr1=0;
00461     m_Expr2=0;
00462   }
00463   inline int getType(){
00464     return m_Type;
00465   }
00466 };
00471 class skMethodDefNode : public skParseNode {
00472  public:
00473   skStatListNode * m_Stats;
00474   skIdListNode * m_Params;
00475   inline skMethodDefNode(int linenum,skStatListNode * stats) : skParseNode(linenum){
00476     m_Stats=stats;
00477     m_Params=0;
00478   }
00479   inline skMethodDefNode(int linenum,skIdListNode * params,skStatListNode * stats) : skParseNode(linenum){
00480     m_Stats=stats;
00481     m_Params=params;
00482   }
00483   inline ~skMethodDefNode(){
00484     delete m_Stats;
00485     delete m_Params;
00486   }
00487   inline void clear(){
00488     m_Stats=0;
00489     m_Params=0;
00490   }
00491  private:
00492   skMethodDefNode(const skMethodDefNode& ) : skParseNode(0){
00493   }
00494   skMethodDefNode& operator=(const skMethodDefNode&){
00495     return *this;
00496   }
00497 };
00498 #endif
00499 

Generated at Thu Jul 5 10:55:42 2001 for Simkin by doxygen1.2.1 written by Dimitri van Heesch, © 1997-2000