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

Generated at Fri Jun 22 11:10:42 2001 for Simkin by doxygen1.2.1 written by Dimitri van Heesch, © 1997-2000