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

skParseNode.h

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

Generated on Mon Dec 16 16:30:12 2002 for Simkin by doxygen1.3-rc1