src/foam/db/IOstreams/token/tokenIO.C

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | foam-extend: Open Source CFD
   4    \\    /   O peration     | Version:     3.2
   5     \\  /    A nd           | Web:         http://www.foam-extend.org
   6      \\/     M anipulation  | For copyright notice see file Copyright
   7 -------------------------------------------------------------------------------
   8 License
   9     This file is part of foam-extend.
  10
  11     foam-extend 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 3 of the License, or (at your
  14     option) any later version.
  15
  16     foam-extend is distributed in the hope that it will be useful, but
  17     WITHOUT ANY WARRANTY; without even the implied warranty of
  18     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19     General Public License for more details.
  20
  21     You should have received a copy of the GNU General Public License
  22     along with foam-extend.  If not, see <http://www.gnu.org/licenses/>.
  23
  24 Description
  25     Stream operators for token
  26
  27 \*---------------------------------------------------------------------------*/
  28
  29 #include "error.H"
  30 #include "token.H"
  31
  32 #include "IOstreams.H"
  33 #include "scalar.H"
  34
  35 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
  36
  37 Foam::token::token(Istream& is)
  38 :
  39     type_(UNDEFINED)
  40 {
  41     is.read(*this);
  42 }
  43
  44
  45 // * * * * * * * * * * * * IOstream operators  * * * * * * * * * * * * * * * //
  46
  47 Foam::Istream& Foam::operator>>(Istream& is, token& t)
  48 {
  49     t.clear();
  50     return is.read(t);
  51 }
  52
  53
  54 Foam::Ostream& Foam::operator<<(Ostream& os, const token& t)
  55 {
  56     switch (t.type_)
  57     {
  58         case token::UNDEFINED:
  59             os << "UNDEFINED";
  60             WarningIn("Ostream& operator<<(Ostream&, const token&)")
  61                 << "Undefined token" << endl;
  62         break;
  63
  64         case token::PUNCTUATION:
  65             os << t.punctuationToken_;
  66         break;
  67
  68         case token::WORD:
  69             os << *t.wordTokenPtr_;
  70         break;
  71
  72         case token::STRING:
  73             os << *t.stringTokenPtr_;
  74         break;
  75
  76         case token::LABEL:
  77             os << t.labelToken_;
  78         break;
  79
  80         case token::FLOAT_SCALAR:
  81             os << t.floatScalarToken_;
  82         break;
  83
  84         case token::DOUBLE_SCALAR:
  85             os << t.doubleScalarToken_;
  86         break;
  87
  88         case token::LONG_DOUBLE_SCALAR:
  89             os << t.longDoubleScalarToken_;
  90         break;
  91
  92         case token::COMPOUND:
  93             os << *t.compoundTokenPtr_;
  94         break;
  95
  96         case token::FATALERROR:
  97             os << "FATALERROR";
  98             WarningIn("Ostream& operator<<(Ostream&, const token&)")
  99                 << "Error token" << endl;
 100         break;
 101
 102         default:
 103             os << "UNKNOWN";
 104             SeriousErrorIn("Ostream& operator<<(Ostream&, const token&)")
 105                 << "Unknown token"
 106                 << endl;
 107     }
 108
 109     // Check state of stream
 110     os.check("Ostream& operator<<(Ostream&, const token&)");
 111
 112     return os;
 113 }
 114
 115
 116 ostream& Foam::operator<<(ostream& os, const token::punctuationToken& pt)
 117 {
 118     return os << char(pt);
 119 }
 120
 121
 122 Foam::Ostream& Foam::operator<<(Ostream& os, const token::punctuationToken& pt)
 123 {
 124     return os << char(pt);
 125 }
 126
 127
 128 Foam::Ostream& Foam::operator<<(Ostream& os, const token::compound& ct)
 129 {
 130     os << ct.type() << token::SPACE;
 131     ct.write(os);
 132
 133     return os;
 134 }
 135
 136
 137 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 138
 139 ostream& Foam::operator<<(ostream& os, const InfoProxy<token>& ip)
 140 {
 141     const token& t = ip.t_;
 142
 143     os  << "on line " << t.lineNumber();
 144
 145     switch (t.type())
 146     {
 147         case token::UNDEFINED:
 148             os  << " an undefined token";
 149         break;
 150
 151         case token::PUNCTUATION:
 152             os  << " the punctuation token " << '\'' << t.pToken() << '\'';
 153         break;
 154
 155         case token::WORD:
 156             os  << " the word " << '\'' << t.wordToken() << '\'';
 157         break;
 158
 159         case token::STRING:
 160             os  << " the string " << t.stringToken();
 161         break;
 162
 163         case token::LABEL:
 164             os  << " the label " << t.labelToken();
 165         break;
 166
 167         case token::FLOAT_SCALAR:
 168             os  << " the floatScalar " << t.floatScalarToken();
 169         break;
 170
 171         case token::DOUBLE_SCALAR:
 172             os  << " the doubleScalar " << t.doubleScalarToken();
 173         break;
 174
 175         case token::LONG_DOUBLE_SCALAR:
 176             os  << " the longDoubleScalar " << t.doubleScalarToken();
 177         break;
 178
 179         case token::COMPOUND:
 180         {
 181             if (t.compoundToken().empty())
 182             {
 183                 os  << " the empty compound of type "
 184                     << t.compoundToken().type();
 185             }
 186             else
 187             {
 188                 os  << " the compound of type "
 189                     << t.compoundToken().type();
 190             }
 191         }
 192         break;
 193
 194         case token::FATALERROR:
 195             os  << " an error";
 196         break;
 197
 198         default:
 199             os  << " an unknown token type " << '\'' << int(t.type()) << '\'';
 200     }
 201
 202     return os;
 203 }
 204
 205
 206 // template specialization
 207 namespace Foam
 208 {
 209
 210 #if defined (__GNUC__)
 211 template<>
 212 #endif
 213 Ostream& operator<<(Ostream& os, const InfoProxy<token>& ip)
 214 {
 215     const token& t = ip.t_;
 216
 217     os  << "on line " << t.lineNumber();
 218
 219     switch (t.type())
 220     {
 221         case token::UNDEFINED:
 222             os  << " an undefined token";
 223         break;
 224
 225         case token::PUNCTUATION:
 226             os  << " the punctuation token " << '\'' << t.pToken() << '\'';
 227         break;
 228
 229         case token::WORD:
 230             os  << " the word " << '\'' << t.wordToken() << '\'';
 231         break;
 232
 233         case token::STRING:
 234             os  << " the string " << t.stringToken();
 235         break;
 236
 237         case token::LABEL:
 238             os  << " the label " << t.labelToken();
 239         break;
 240
 241         case token::FLOAT_SCALAR:
 242             os  << " the floatScalar " << t.floatScalarToken();
 243         break;
 244
 245         case token::DOUBLE_SCALAR:
 246             os  << " the doubleScalar " << t.doubleScalarToken();
 247         break;
 248
 249         case token::LONG_DOUBLE_SCALAR:
 250             os  << " the longDoubleScalar " << t.longDoubleScalarToken();
 251         break;
 252
 253         case token::COMPOUND:
 254         {
 255             if (t.compoundToken().empty())
 256             {
 257                 os  << " the empty compound of type "
 258                     << t.compoundToken().type();
 259             }
 260             else
 261             {
 262                 os  << " the compound of type "
 263                     << t.compoundToken().type();
 264             }
 265         }
 266         break;
 267
 268         case token::FATALERROR:
 269             os  << " an error";
 270         break;
 271
 272         default:
 273             os  << " an unknown token type "  << '\'' << int(t.type()) << '\'';
 274     }
 275
 276     return os;
 277 }
 278
 279
 280 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 281
 282 } // End namespace Foam
 283
 284 // ************************************************************************* //