00001 00002 00003 00004 00005 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