src/OpenFOAM/db/IOstreams/token/token.H

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
   6      \\/     M anipulation  |
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of OpenFOAM.
  10
  11     OpenFOAM is free software; you can redistribute it and/or modify it
  12     under the terms of the GNU General Public License as published by the
  13     Free Software Foundation; either version 2 of the License, or (at your
  14     option) any later version.
  15
  16     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
  17     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19     for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with OpenFOAM; if not, write to the Free Software Foundation,
  23     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  24
  25 Class
  26     Foam::token
  27
  28 Description
  29     A token holds items read from Istream.
  30
  31 SourceFiles
  32     tokenI.H
  33     token.C
  34     tokenIO.C
  35
  36 \*---------------------------------------------------------------------------*/
  37
  38 #ifndef token_H
  39 #define token_H
  40
  41 #include "label.H"
  42 #include "uLabel.H"
  43 #include "scalar.H"
  44 #include "word.H"
  45 #include "InfoProxy.H"
  46 #include "refCount.H"
  47 #include "typeInfo.H"
  48
  49 #define NoHashTableC
  50 #include "runTimeSelectionTables.H"
  51
  52 #include <iostream>
  53
  54 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
  55
  56 namespace Foam
  57 {
  58
  59 // Forward declaration of friend functions and operators
  60
  61 class token;
  62 Istream& operator>>(Istream&, token&);
  63 Ostream& operator<<(Ostream&, const token&);
  64
  65 /*---------------------------------------------------------------------------*\
  66                            Class token Declaration
  67 \*---------------------------------------------------------------------------*/
  68
  69 class token
  70 {
  71
  72 public:
  73
  74     //- Enumeration defining the types of token
  75     enum tokenType
  76     {
  77         UNDEFINED,
  78
  79         PUNCTUATION,
  80         WORD,
  81         STRING,
  82         LABEL,
  83         FLOAT_SCALAR,
  84         DOUBLE_SCALAR,
  85         COMPOUND,
  86
  87         ERROR
  88     };
  89
  90
  91     //- Standard punctuation tokens
  92     enum punctuationToken
  93     {
  94         NULL_TOKEN     = '\0',
  95         SPACE          = ' ',
  96         TAB            = '\t',
  97         NL             = '\n',
  98
  99         END_STATEMENT  = ';',
 100         BEGIN_LIST     = '(',
 101         END_LIST       = ')',
 102         BEGIN_SQR      = '[',
 103         END_SQR        = ']',
 104         BEGIN_BLOCK    = '{',
 105         END_BLOCK      = '}',
 106         COLON          = ':',
 107         COMMA          = ',',
 108
 109         BEGIN_STRING   = '"',
 110         END_STRING     = BEGIN_STRING,
 111
 112         ASSIGN         = '=',
 113         ADD            = '+',
 114         SUBTRACT       = '-',
 115         MULTIPLY       = '*',
 116         DIVIDE         = '/'
 117     };
 118
 119
 120     //- Abstract base class for complex tokens
 121     class compound
 122     :
 123         public refCount
 124     {
 125         // Private data
 126
 127             bool empty_;
 128
 129
 130         // Private Member Functions
 131
 132             //- Disallow default bitwise copy construct
 133             compound(const compound&);
 134
 135             //- Disallow default bitwise assignment
 136             void operator=(const compound&);
 137
 138
 139     public:
 140
 141         //- Runtime type information
 142         TypeName("compound");
 143
 144
 145         //- Declare run-time constructor selection table
 146         declareRunTimeSelectionTable
 147         (
 148             autoPtr,
 149             compound,
 150             Istream,
 151             (Istream& is),
 152             (is)
 153         );
 154
 155
 156         // Constructors
 157
 158             //- Construct null
 159             compound()
 160             :
 161                 empty_(false)
 162             {}
 163
 164
 165         // Selectors
 166
 167             //- Select null constructed
 168             static autoPtr<compound> New(const word& type, Istream&);
 169
 170
 171         // Destructor
 172
 173             virtual ~compound();
 174
 175
 176         // Member Functions
 177
 178             // Access
 179
 180                 //- Return true if name is a compound type
 181                 static bool isCompound(const word& name);
 182
 183                 bool empty() const
 184                 {
 185                     return empty_;
 186                 }
 187
 188                 bool& empty()
 189                 {
 190                     return empty_;
 191                 }
 192
 193                 virtual label size() const = 0;
 194
 195
 196             // Check
 197
 198             // Edit
 199
 200             // Write
 201
 202                 virtual void write(Ostream&) const = 0;
 203
 204
 205         // IOstream Operators
 206
 207             friend Ostream& operator<<(Ostream&, const compound&);
 208     };
 209
 210
 211     //- A templated class for holding compound tokens
 212     template<class T>
 213     class Compound
 214     :
 215         public token::compound,
 216         public T
 217     {
 218     public:
 219
 220         //- Runtime type information
 221         TypeName("Compound<T>");
 222
 223         Compound(Istream& is)
 224         :
 225             T(is)
 226         {}
 227
 228         label size() const
 229         {
 230             return T::size();
 231         }
 232
 233         void write(Ostream& os) const
 234         {
 235             operator<<(os, static_cast<const T&>(*this));
 236         }
 237     };
 238
 239
 240     //- Static undefined token
 241     static token undefinedToken;
 242
 243
 244 private:
 245
 246     // Private data
 247
 248         //- The token type
 249         tokenType type_;
 250
 251         //- Anonymous Union of token types
 252         union
 253         {
 254             punctuationToken punctuationToken_;
 255             word* wordTokenPtr_;
 256             string* stringTokenPtr_;
 257             label labelToken_;
 258             floatScalar floatScalarToken_;
 259             doubleScalar doubleScalarToken_;
 260             mutable compound* compoundTokenPtr_;
 261         };
 262
 263         //- Line number in the file this token was read from
 264         label lineNumber_;
 265
 266
 267     // Private member functions
 268
 269         //- Clear any allocated storage (word or string)
 270         inline void clear();
 271
 272         // Parse error, expected 'expected', found ...
 273         void parseError(const char* expected) const;
 274
 275
 276 public:
 277
 278     // Static data members
 279
 280         static const char* const typeName;
 281
 282
 283     // Constructors
 284
 285         //- Construct null
 286         inline token();
 287
 288         //- Construct as copy
 289         inline token(const token&);
 290
 291         //- Construct punctuation character token
 292         inline token(punctuationToken, label lineNumber=0);
 293
 294         //- Construct word token
 295         inline token(const word&, label lineNumber=0);
 296
 297         //- Construct string token
 298         inline token(const string&, label lineNumber=0);
 299
 300         //- Construct label token
 301         inline token(const label, label lineNumber=0);
 302
 303         //- Construct floatScalar token
 304         inline token(const floatScalar, label lineNumber=0);
 305
 306         //- Construct doubleScalar token
 307         inline token(const doubleScalar, label lineNumber=0);
 308
 309         //- Construct from Istream
 310         token(Istream&);
 311
 312
 313     // Destructor
 314
 315         inline ~token();
 316
 317
 318     // Member functions
 319
 320         // Access
 321
 322             inline tokenType type() const;
 323
 324             inline bool good() const;
 325             inline bool undefined() const;
 326             inline bool error() const;
 327
 328             inline bool isPunctuation() const;
 329             inline punctuationToken pToken() const;
 330
 331             inline bool isWord() const;
 332             inline const word& wordToken() const;
 333
 334             inline bool isString() const;
 335             inline const string& stringToken() const;
 336
 337             inline bool isLabel() const;
 338             inline label labelToken() const;
 339
 340             inline bool isFloatScalar() const;
 341             inline floatScalar floatScalarToken() const;
 342
 343             inline bool isDoubleScalar() const;
 344             inline doubleScalar doubleScalarToken() const;
 345
 346             inline bool isScalar() const;
 347             inline scalar scalarToken() const;
 348
 349             inline bool isNumber() const;
 350             inline scalar number() const;
 351
 352             inline bool isCompound() const;
 353             inline const compound& compoundToken() const;
 354             compound& transferCompoundToken();
 355
 356             inline label lineNumber() const;
 357             inline label& lineNumber();
 358
 359
 360         // Edit
 361
 362             //- Set bad
 363             inline void setBad();
 364
 365
 366         // Info
 367
 368             //- Return info proxy.
 369             //  Used to print token information to a stream
 370             InfoProxy<token> info() const
 371             {
 372                 return *this;
 373             }
 374
 375
 376     // Member operators
 377
 378         // Assignment
 379
 380             inline void operator=(const token&);
 381
 382             inline void operator=(const punctuationToken);
 383
 384             inline void operator=(word*);
 385             inline void operator=(const word&);
 386
 387             inline void operator=(string*);
 388             inline void operator=(const string&);
 389
 390             inline void operator=(const label);
 391             inline void operator=(const floatScalar);
 392             inline void operator=(const doubleScalar);
 393
 394             inline void operator=(compound*);
 395
 396
 397         // Equality
 398
 399             inline bool operator==(const token&) const;
 400             inline bool operator==(const punctuationToken) const;
 401             inline bool operator==(const word&) const;
 402             inline bool operator==(const string&) const;
 403             inline bool operator==(const label) const;
 404             inline bool operator==(const floatScalar) const;
 405             inline bool operator==(const doubleScalar) const;
 406
 407
 408         // Inequality
 409
 410             inline bool operator!=(const token&) const;
 411             inline bool operator!=(const punctuationToken) const;
 412             inline bool operator!=(const word&) const;
 413             inline bool operator!=(const string&) const;
 414             inline bool operator!=(const label) const;
 415             inline bool operator!=(const floatScalar) const;
 416             inline bool operator!=(const doubleScalar) const;
 417
 418
 419     // IOstream operators
 420
 421         friend Istream& operator>>(Istream&, token&);
 422         friend Ostream& operator<<(Ostream&, const token&);
 423
 424         friend Ostream& operator<<(Ostream&, const punctuationToken&);
 425         friend ostream& operator<<(ostream&, const punctuationToken&);
 426
 427         friend ostream& operator<<(ostream&, const InfoProxy<token>&);
 428 };
 429
 430
 431 Ostream& operator<<(Ostream&, const token::punctuationToken&);
 432 ostream& operator<<(ostream&, const token::punctuationToken&);
 433 ostream& operator<<(ostream&, const InfoProxy<token>&);
 434 Ostream& operator<<(Ostream&, const token::compound&);
 435
 436
 437 #define defineCompoundTypeName(Type, Name)                                    \
 438     typedef token::Compound<Type > tokenCompound##Name##_;                    \
 439     defineTemplateTypeNameAndDebugWithName(tokenCompound##Name##_, #Type, 0);
 440
 441 #define addCompoundToRunTimeSelectionTable(Type, Name)                        \
 442     token::compound::addIstreamConstructorToTable<token::Compound<Type > >    \
 443         add##Name##IstreamConstructorToTable_;
 444
 445
 446 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 447
 448 } // End namespace Foam
 449
 450 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 451
 452 #include "tokenI.H"
 453 #include "Istream.H"
 454
 455 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 456
 457 #endif
 458
 459 // ************************************************************************* //