00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include <iostream>
00028
00029
00030
00031 namespace Foam
00032 {
00033
00034
00035
00036
00037 inline void token::clear()
00038 {
00039 if (type_ == WORD)
00040 {
00041 delete wordTokenPtr_;
00042 }
00043 else if (type_ == STRING)
00044 {
00045 delete stringTokenPtr_;
00046 }
00047 else if (type_ == COMPOUND)
00048 {
00049 if (compoundTokenPtr_->okToDelete())
00050 {
00051 delete compoundTokenPtr_;
00052 }
00053 else
00054 {
00055 compoundTokenPtr_->refCount::operator--();
00056 }
00057 }
00058
00059 type_ = UNDEFINED;
00060 }
00061
00062
00063
00064
00065
00066 inline token::token()
00067 :
00068 type_(UNDEFINED),
00069 lineNumber_(0)
00070 {}
00071
00072
00073 inline token::token(const token& t)
00074 :
00075 type_(t.type_),
00076 lineNumber_(t.lineNumber_)
00077 {
00078 switch (type_)
00079 {
00080 case token::UNDEFINED:
00081 break;
00082
00083 case PUNCTUATION:
00084 punctuationToken_ = t.punctuationToken_;
00085 break;
00086
00087 case WORD:
00088 wordTokenPtr_ = new word(*t.wordTokenPtr_);
00089 break;
00090
00091 case STRING:
00092 stringTokenPtr_ = new string(*t.stringTokenPtr_);
00093 break;
00094
00095 case LABEL:
00096 labelToken_ = t.labelToken_;
00097 break;
00098
00099 case FLOAT_SCALAR:
00100 floatScalarToken_ = t.floatScalarToken_;
00101 break;
00102
00103 case DOUBLE_SCALAR:
00104 doubleScalarToken_ = t.doubleScalarToken_;
00105 break;
00106
00107 case COMPOUND:
00108 compoundTokenPtr_ = t.compoundTokenPtr_;
00109 compoundTokenPtr_->refCount::operator++();
00110 break;
00111
00112 case token::ERROR:
00113 break;
00114 }
00115 }
00116
00117
00118 inline token::token(punctuationToken p, label lineNumber)
00119 :
00120 type_(PUNCTUATION),
00121 punctuationToken_(p),
00122 lineNumber_(lineNumber)
00123 {}
00124
00125
00126 inline token::token(const word& w, label lineNumber)
00127 :
00128 type_(WORD),
00129 wordTokenPtr_(new word(w)),
00130 lineNumber_(lineNumber)
00131 {}
00132
00133
00134 inline token::token(const string& s, label lineNumber)
00135 :
00136 type_(STRING),
00137 stringTokenPtr_(new string(s)),
00138 lineNumber_(lineNumber)
00139 {}
00140
00141
00142 inline token::token(const label l, label lineNumber)
00143 :
00144 type_(LABEL),
00145 labelToken_(l),
00146 lineNumber_(lineNumber)
00147 {}
00148
00149
00150 inline token::token(const floatScalar s, label lineNumber)
00151 :
00152 type_(FLOAT_SCALAR),
00153 floatScalarToken_(s),
00154 lineNumber_(lineNumber)
00155 {}
00156
00157
00158 inline token::token(const doubleScalar s, label lineNumber)
00159 :
00160 type_(DOUBLE_SCALAR),
00161 doubleScalarToken_(s),
00162 lineNumber_(lineNumber)
00163 {}
00164
00165
00166
00167
00168
00169 inline token::~token()
00170 {
00171 clear();
00172 }
00173
00174
00175
00176
00177 inline token::tokenType token::type() const
00178 {
00179 return type_;
00180 }
00181
00182 inline bool token::good() const
00183 {
00184 return (type_ != ERROR && type_ != UNDEFINED);
00185 }
00186
00187 inline bool token::undefined() const
00188 {
00189 return (type_ == UNDEFINED);
00190 }
00191
00192 inline bool token::error() const
00193 {
00194 return (type_ == ERROR);
00195 }
00196
00197 inline bool token::isPunctuation() const
00198 {
00199 return (type_ == PUNCTUATION);
00200 }
00201
00202 inline token::punctuationToken token::pToken() const
00203 {
00204 if (type_ == PUNCTUATION)
00205 {
00206 return punctuationToken_;
00207 }
00208 else
00209 {
00210 parseError("punctuation character");
00211 return NULL_TOKEN;
00212 }
00213 }
00214
00215 inline bool token::isWord() const
00216 {
00217 return (type_ == WORD);
00218 }
00219
00220 inline const word& token::wordToken() const
00221 {
00222 if (type_ == WORD)
00223 {
00224 return *wordTokenPtr_;
00225 }
00226 else
00227 {
00228 parseError("word");
00229 return word::null;
00230 }
00231 }
00232
00233 inline bool token::isString() const
00234 {
00235 return (type_ == STRING);
00236 }
00237
00238 inline const string& token::stringToken() const
00239 {
00240 if (type_ == STRING)
00241 {
00242 return *stringTokenPtr_;
00243 }
00244 else
00245 {
00246 parseError("string");
00247 return string::null;
00248 }
00249 }
00250
00251 inline bool token::isLabel() const
00252 {
00253 return (type_ == LABEL);
00254 }
00255
00256 inline label token::labelToken() const
00257 {
00258 if (type_ == LABEL)
00259 {
00260 return labelToken_;
00261 }
00262 else
00263 {
00264 parseError("label");
00265 return 0;
00266 }
00267 }
00268
00269 inline bool token::isFloatScalar() const
00270 {
00271 return (type_ == FLOAT_SCALAR);
00272 }
00273
00274 inline floatScalar token::floatScalarToken() const
00275 {
00276 if (type_ == FLOAT_SCALAR)
00277 {
00278 return floatScalarToken_;
00279 }
00280 else
00281 {
00282 parseError("floatScalar");
00283 return 0.0;
00284 }
00285 }
00286
00287
00288 inline bool token::isDoubleScalar() const
00289 {
00290 return (type_ == DOUBLE_SCALAR);
00291 }
00292
00293 inline doubleScalar token::doubleScalarToken() const
00294 {
00295 if (type_ == DOUBLE_SCALAR)
00296 {
00297 return doubleScalarToken_;
00298 }
00299 else
00300 {
00301 parseError("doubleScalar");
00302 return 0.0;
00303 }
00304 }
00305
00306
00307 inline bool token::isScalar() const
00308 {
00309 return (type_ == FLOAT_SCALAR || type_ == DOUBLE_SCALAR);
00310 }
00311
00312 inline scalar token::scalarToken() const
00313 {
00314 if (type_ == FLOAT_SCALAR)
00315 {
00316 return floatScalarToken_;
00317 }
00318 else if (type_ == DOUBLE_SCALAR)
00319 {
00320 return doubleScalarToken_;
00321 }
00322 else
00323 {
00324 parseError("scalar");
00325 return 0.0;
00326 }
00327 }
00328
00329 inline bool token::isNumber() const
00330 {
00331 return (type_ == LABEL || isScalar());
00332 }
00333
00334 inline scalar token::number() const
00335 {
00336 if (type_ == LABEL)
00337 {
00338 return labelToken_;
00339 }
00340 else if (isScalar())
00341 {
00342 return scalarToken();
00343 }
00344 else
00345 {
00346 parseError("number (label or scalar)");
00347 return 0.0;
00348 }
00349 }
00350
00351 inline bool token::isCompound() const
00352 {
00353 return (type_ == COMPOUND);
00354 }
00355
00356 inline const token::compound& token::compoundToken() const
00357 {
00358 if (type_ == COMPOUND)
00359 {
00360 return *compoundTokenPtr_;
00361 }
00362 else
00363 {
00364 parseError("compound");
00365 return *compoundTokenPtr_;
00366 }
00367 }
00368
00369
00370 inline label token::lineNumber() const
00371 {
00372 return lineNumber_;
00373 }
00374
00375 inline label& token::lineNumber()
00376 {
00377 return lineNumber_;
00378 }
00379
00380
00381 inline void token::setBad()
00382 {
00383 clear();
00384 type_ = ERROR;
00385 }
00386
00387
00388
00389
00390 inline void token::operator=(const token& t)
00391 {
00392 clear();
00393 type_ = t.type_;
00394
00395 switch (type_)
00396 {
00397 case token::UNDEFINED:
00398 break;
00399
00400 case PUNCTUATION:
00401 punctuationToken_ = t.punctuationToken_;
00402 break;
00403
00404 case WORD:
00405 wordTokenPtr_ = new word(*t.wordTokenPtr_);
00406 break;
00407
00408 case STRING:
00409 stringTokenPtr_ = new string(*t.stringTokenPtr_);
00410 break;
00411
00412 case LABEL:
00413 labelToken_ = t.labelToken_;
00414 break;
00415
00416 case FLOAT_SCALAR:
00417 floatScalarToken_ = t.floatScalarToken_;
00418 break;
00419
00420 case DOUBLE_SCALAR:
00421 doubleScalarToken_ = t.doubleScalarToken_;
00422 break;
00423
00424 case COMPOUND:
00425 compoundTokenPtr_ = t.compoundTokenPtr_;
00426 compoundTokenPtr_->refCount::operator++();
00427 break;
00428
00429 case token::ERROR:
00430 break;
00431 }
00432
00433 lineNumber_ = t.lineNumber_;
00434 }
00435
00436 inline void token::operator=(const punctuationToken p)
00437 {
00438 clear();
00439 type_ = PUNCTUATION;
00440 punctuationToken_ = p;
00441 }
00442
00443 inline void token::operator=(word* wPtr)
00444 {
00445 clear();
00446 type_ = WORD;
00447 wordTokenPtr_ = wPtr;
00448 }
00449
00450 inline void token::operator=(const word& w)
00451 {
00452 operator=(new word(w));
00453 }
00454
00455 inline void token::operator=(string* sPtr)
00456 {
00457 clear();
00458 type_ = STRING;
00459 stringTokenPtr_ = sPtr;
00460 }
00461
00462 inline void token::operator=(const string& s)
00463 {
00464 operator=(new string(s));
00465 }
00466
00467 inline void token::operator=(const label l)
00468 {
00469 clear();
00470 type_ = LABEL;
00471 labelToken_ = l;
00472 }
00473
00474 inline void token::operator=(const floatScalar s)
00475 {
00476 clear();
00477 type_ = FLOAT_SCALAR;
00478 floatScalarToken_ = s;
00479 }
00480
00481 inline void token::operator=(const doubleScalar s)
00482 {
00483 clear();
00484 type_ = DOUBLE_SCALAR;
00485 doubleScalarToken_ = s;
00486 }
00487
00488 inline void token::operator=(token::compound* cPtr)
00489 {
00490 clear();
00491 type_ = COMPOUND;
00492 compoundTokenPtr_ = cPtr;
00493 }
00494
00495
00496 inline bool token::operator==(const token& t) const
00497 {
00498 if (type_ != t.type_)
00499 {
00500 return false;
00501 }
00502
00503 switch (type_)
00504 {
00505 case token::UNDEFINED:
00506 return true;
00507
00508 case PUNCTUATION:
00509 return punctuationToken_ == t.punctuationToken_;
00510
00511 case WORD:
00512 return *wordTokenPtr_ == *t.wordTokenPtr_;
00513
00514 case STRING:
00515 return *stringTokenPtr_ == *t.stringTokenPtr_;
00516
00517 case LABEL:
00518 return labelToken_ == t.labelToken_;
00519
00520 case FLOAT_SCALAR:
00521 return equal(floatScalarToken_, t.floatScalarToken_);
00522
00523 case DOUBLE_SCALAR:
00524 return equal(doubleScalarToken_, t.doubleScalarToken_);
00525
00526 case COMPOUND:
00527 return compoundTokenPtr_ == t.compoundTokenPtr_;
00528
00529 case token::ERROR:
00530 return true;
00531 }
00532
00533 return false;
00534 }
00535
00536 inline bool token::operator==(const punctuationToken p) const
00537 {
00538 return (type_ == PUNCTUATION && punctuationToken_ == p);
00539 }
00540
00541 inline bool token::operator==(const word& w) const
00542 {
00543 return (type_ == WORD && wordToken() == w);
00544 }
00545
00546 inline bool token::operator==(const string& s) const
00547 {
00548 return (type_ == STRING && stringToken() == s);
00549 }
00550
00551 inline bool token::operator==(const label l) const
00552 {
00553 return (type_ == LABEL && labelToken_ == l);
00554 }
00555
00556 inline bool token::operator==(const floatScalar s) const
00557 {
00558 return (type_ == FLOAT_SCALAR && equal(floatScalarToken_, s));
00559 }
00560
00561 inline bool token::operator==(const doubleScalar s) const
00562 {
00563 return (type_ == DOUBLE_SCALAR && equal(doubleScalarToken_, s));
00564 }
00565
00566 inline bool token::operator!=(const token& t) const
00567 {
00568 return !operator==(t);
00569 }
00570
00571 inline bool token::operator!=(const punctuationToken p) const
00572 {
00573 return !operator==(p);
00574 }
00575
00576 inline bool token::operator!=(const word& w) const
00577 {
00578 return !operator==(w);
00579 }
00580
00581 inline bool token::operator!=(const string& s) const
00582 {
00583 return !operator==(s);
00584 }
00585
00586 inline bool token::operator!=(const floatScalar s) const
00587 {
00588 return !operator==(s);
00589 }
00590
00591 inline bool token::operator!=(const doubleScalar s) const
00592 {
00593 return !operator==(s);
00594 }
00595
00596 inline bool token::operator!=(const label l) const
00597 {
00598 return !operator==(l);
00599 }
00600
00601
00602
00603
00604 }
00605
00606