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