OpenFOAM logo
Open Source CFD Toolkit

tokenI.H

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------------*\
00002   =========                 |
00003   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
00004    \\    /   O peration     |
00005     \\  /    A nd           | Copyright (C) 1991-2005 OpenCFD Ltd.
00006      \\/     M anipulation  |
00007 -------------------------------------------------------------------------------
00008 License
00009     This file is part of OpenFOAM.
00010 
00011     OpenFOAM is free software; you can redistribute it and/or modify it
00012     under the terms of the GNU General Public License as published by the
00013     Free Software Foundation; either version 2 of the License, or (at your
00014     option) any later version.
00015 
00016     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
00017     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
00018     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
00019     for more details.
00020 
00021     You should have received a copy of the GNU General Public License
00022     along with OpenFOAM; if not, write to the Free Software Foundation,
00023     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
00024 
00025 \*---------------------------------------------------------------------------*/
00026 
00027 #include <iostream>
00028 
00029 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
00030 
00031 namespace Foam
00032 {
00033 
00034 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
00035 
00036 // Clear any allocated storage (word or string)
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 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
00064 
00065 // Construct null
00066 inline token::token()
00067 :
00068     type_(UNDEFINED),
00069     lineNumber_(0)
00070 {}
00071 
00072 // Construct as copy
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 // Construct punctuation character token
00118 inline token::token(punctuationToken p, label lineNumber)
00119 :
00120     type_(PUNCTUATION),
00121     punctuationToken_(p),
00122     lineNumber_(lineNumber)
00123 {}
00124 
00125 // Construct word token
00126 inline token::token(const word& w, label lineNumber)
00127 :
00128     type_(WORD),
00129     wordTokenPtr_(new word(w)),
00130     lineNumber_(lineNumber)
00131 {}
00132 
00133 // Construct string token
00134 inline token::token(const string& s, label lineNumber)
00135 :
00136     type_(STRING),
00137     stringTokenPtr_(new string(s)),
00138     lineNumber_(lineNumber)
00139 {}
00140 
00141 // Construct label token
00142 inline token::token(const label l, label lineNumber)
00143 :
00144     type_(LABEL),
00145     labelToken_(l),
00146     lineNumber_(lineNumber)
00147 {}
00148 
00149 // Construct floatScalar token
00150 inline token::token(const floatScalar s, label lineNumber)
00151 :
00152     type_(FLOAT_SCALAR),
00153     floatScalarToken_(s),
00154     lineNumber_(lineNumber)
00155 {}
00156 
00157 // Construct doubleScalar token
00158 inline token::token(const doubleScalar s, label lineNumber)
00159 :
00160     type_(DOUBLE_SCALAR),
00161     doubleScalarToken_(s),
00162     lineNumber_(lineNumber)
00163 {}
00164 
00165 
00166 // * * * * * * * * * * * * * * * * Destructors * * * * * * * * * * * * * * * //
00167 
00168 // Delete token clearing the storage used by word or string
00169 inline token::~token()
00170 {
00171     clear();
00172 }
00173 
00174 
00175 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
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 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
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 } // End namespace Foam
00605 
00606 // ************************************************************************* //
For further information go to www.openfoam.org