00001 #ifndef PARSER_H
00002 #define PARSER_H
00003
00004 #include "config.h"
00005
00006 #include <list>
00007 #include <vector>
00008 using namespace std;
00009
00010 class Parser;
00011
00012 class Node
00013 {
00014 public:
00015 bool rhoterm;
00016 int ndHole;
00017 virtual void print(std::ostream& o);
00018 virtual void checkSoundnessAndCalcul();
00019 virtual bool containVar(int idvar);
00020 virtual void replace(int idvar,Node *n);
00021
00025 virtual Node* duplicate() = 0;
00026 virtual ~Node();
00027 virtual bool isEqual(Node *n);
00028 list<unsigned int> *holePosition;
00029 Node();
00030 static int ndterms;
00031 virtual Node *find(list<unsigned int> &path);
00032 virtual Node* buildOneAndReplace(list<unsigned int> &path,Node *sub);
00033 };
00034
00035 class Hole : public Node
00036 {
00037 public:
00038 void print(std::ostream& o);
00039 void checkSoundnessAndCalcul();
00040 Node* duplicate();
00041 Hole();
00042 ~Hole();
00043 };
00044
00045 class Clash : public Node
00046 {
00047 void print(std::ostream& o);
00048 Node* duplicate();
00049 };
00050
00051 class Trivial : public Node
00052 {
00053 void print(std::ostream& o);
00054 Node* duplicate();
00055 };
00056
00057
00058 class NumericalVar
00059 {
00060 Parser *parser;
00061 public:
00062 int id;
00063 NumericalVar(const char* name,Parser *parser,bool automatic=true);
00064 void print(std::ostream& o);
00065 NumericalVar* duplicate();
00066 bool isEqual(Node *n);
00067 };
00068
00069 class Variable : public Node
00070 {
00071 Parser *parser;
00072 public:
00073 int id;
00074 Variable(const char *name,Parser *parser);
00075 void print(std::ostream& o);
00076 void checkSoundnessAndCalcul();
00077 bool containVar(int idvar);
00078 Node* duplicate();
00079 bool isEqual(Node *n);
00080 };
00081
00082 class Function : public Node
00083 {
00084 Parser *parser;
00085 public:
00086 int id;
00087 vector<Node*> arguments;
00088 Function(const char* name,Parser *parser);
00089 Function(int id,Parser *parser);
00090 Function();
00091 void addArgument(Node *n);
00092 void print(std::ostream& o);
00093 void checkSoundnessAndCalcul();
00094 bool containVar(int idvar);
00095 void replace(int idvar,Node *n);
00096 void setName(const char* name,Parser *parser);
00097 Node* buildOneAndReplace(list<unsigned int> &path,Node *sub);
00098 Node* duplicate();
00099 bool isEqual(Node *n);
00100 Node *find(list<unsigned int> &path);
00101 };
00102
00103 class Or : public Node
00104 {
00105 public:
00106 list<Node*> branchs;
00107 Or();
00108 void addBranch(Node *n);
00109 void print(std::ostream& o);
00110 void checkSoundnessAndCalcul();
00111 bool containVar(int idvar);
00112 void replace(int idvar,Node *n);
00113 Node* duplicate();
00114 bool isEqual(Node *n);
00115 };
00116
00117 class Condition
00118 {
00119 public:
00120 NumericalVar* n1;
00121 virtual void print(std::ostream& o);
00122 virtual ~Condition();
00123 virtual Condition* duplicate() = 0;
00124 virtual bool isEqual(Condition *n) = 0;
00125 };
00126
00127
00128 class CondA : public Condition
00129 {
00130 public:
00131 int a;
00132 CondA(NumericalVar* n1,int a);
00133 void print(std::ostream& o);
00134 Condition* duplicate();
00135 bool isEqual(Condition *n);
00136 };
00137
00138
00139 class CondANplusB : public Condition
00140 {
00141 public:
00142 int a;
00143 NumericalVar* n2;
00144 int b;
00145 CondANplusB(NumericalVar* n1,int a,NumericalVar* n2,int b);
00146 void print(std::ostream& o);
00147 Condition* duplicate();
00148 bool isEqual(Condition *n);
00149 };
00150
00151
00152 class CondNplusN : public Condition
00153 {
00154 public:
00155 NumericalVar* n2;
00156 NumericalVar* n3;
00157 CondNplusN(NumericalVar* n1,NumericalVar* n2,NumericalVar* n3);
00158 void print(std::ostream& o);
00159 Condition* duplicate();
00160 bool isEqual(Condition *n);
00161 };
00162
00163
00164 class CondN : public Condition
00165 {
00166 public:
00167 NumericalVar* n2;
00168 CondN(NumericalVar* n1,NumericalVar* n2);
00169 void print(std::ostream& o);
00170 Condition* duplicate();
00171 bool isEqual(Condition *n);
00172 };
00173
00174
00175 class And : public Node
00176 {
00177 public:
00178 list<Node*> branchs;
00179 list<Condition*> conditions;
00180 And();
00181 void addBranch(Node *n);
00182 void addCondition(Condition *c);
00183 void print(std::ostream& o);
00184 void printNoBracket(std::ostream& o);
00185 void checkSoundnessAndCalcul();
00186 bool containVar(int idvar);
00187 void replace(int idvar,Node *n);
00188 Node* duplicate();
00189 bool isEqual(Node *n);
00190 };
00191
00192 class Equal : public Node
00193 {
00194 public:
00195 Node *n1;
00196 Node *n2;
00197 Equal(Node *n1,Node *n2);
00198 void print(std::ostream& o);
00199 void checkSoundnessAndCalcul();
00200 bool containVar(int idvar);
00201 void replace(int idvar,Node *n);
00202 Node* duplicate();
00203 bool isEqual(Node *n);
00204 };
00205
00206 class Expo : public Node
00207 {
00208 public:
00209 bool free;
00210 Node *n1;
00211 Node *n2;
00212 union
00213 {
00214 int expNum;
00215 NumericalVar *var;
00216 };
00217 Expo(Node *n1,int num,Node *n2);
00218 Expo(Node *n1,NumericalVar *num,Node *n2);
00219 void print(std::ostream& o);
00220 void checkSoundnessAndCalcul();
00221 bool containVar(int idvar);
00222 void replace(int idvar,Node *n);
00223 Node* buildOne(Node *sub = NULL);
00224 Node* buildTwo(Node *sub = NULL);
00225 Node* build(int num,Node *sub = NULL);
00226 Node* duplicate();
00227 bool isEqual(Node *n);
00228 };
00229
00230 class FonctionTabElement
00231 {
00232 public:
00233 string name;
00234 int arity;
00235 };
00236
00237 class VariableTabElement
00238 {
00239 public:
00240 string name;
00241 };
00242
00243 class NumericalVariableTabElement
00244 {
00245 public:
00246 string name;
00247 bool automatic;
00248 };
00249
00250 class StackElement
00251 {
00252 public:
00253 list<unsigned int> position;
00254 Node* n;
00255 Node **direct;
00256 StackElement(Node *n,Node **direct);
00257 StackElement(Node *n,Node **direct,list<unsigned int> &parentpos,int me);
00258 StackElement();
00259 };
00260
00261 class NodeIterator
00262 {
00263 public:
00264 enum Mode
00265 {
00266 DEPTH_FIRST,
00267 BREADTH_FIRST
00268 };
00269 private:
00270 Mode mode;
00271 list<StackElement> stack;
00272 StackElement last;
00273 Node *n;
00274 Node **direct;
00275 bool allowUnderEqual;
00276 public:
00277 void setUnderEqual(bool u);
00278 NodeIterator(Node *n,Node **direct,Mode mode);
00279 const list<unsigned int> &getPosition();
00280 Node* next();
00281 void reset();
00282 void replaceBy(Node *n);
00283 };
00284
00285 class Parser
00286 {
00287 int autoNumericalValCur;
00288 int autoContstantValCur;
00289 public:
00290 vector<FonctionTabElement> fonctiontab;
00291 vector<VariableTabElement> variabletab;
00292 vector<NumericalVariableTabElement> numericalvariabletab;
00293 Node *result;
00294 Configuration *config;
00295
00296 void checkSoundness();
00297 Parser(Configuration *config);
00298 string genNumericalValName();
00299 string genContstantValName();
00300 };
00301
00302 #endif
00303