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

skParseNode.h

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

Generated on Thu Jan 23 15:25:39 2003 for Simkin by doxygen1.3-rc1