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

   1 /*---------------------------------------------------------------------------*\
   2   =========                 |
   3   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
   4    \\    /   O peration     |
   5     \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
   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
  13     the Free Software Foundation, either version 3 of the License, or
  14     (at your 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, 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         case token::VERBATIMSTRING:
  74             os << *t.stringTokenPtr_;
  75         break;
  76
  77         case token::LABEL:
  78             os << t.labelToken_;
  79         break;
  80
  81         case token::FLOAT_SCALAR:
  82             os << t.floatScalarToken_;
  83         break;
  84
  85         case token::DOUBLE_SCALAR:
  86             os << t.doubleScalarToken_;
  87         break;
  88
  89         case token::COMPOUND:
  90             os << *t.compoundTokenPtr_;
  91         break;
  92
  93         case token::ERROR:
  94             os << "ERROR";
  95             WarningIn("Ostream& operator<<(Ostream&, const token&)")
  96                 << "Error token" << endl;
  97         break;
  98
  99         default:
 100             os << "UNKNOWN";
 101             SeriousErrorIn("Ostream& operator<<(Ostream&, const token&)")
 102                 << "Unknown token"
 103                 << endl;
 104     }
 105
 106     // Check state of stream
 107     os.check("Ostream& operator<<(Ostream&, const token&)");
 108
 109     return os;
 110 }
 111
 112
 113 ostream& Foam::operator<<(ostream& os, const token::punctuationToken& pt)
 114 {
 115     return os << char(pt);
 116 }
 117
 118
 119 Foam::Ostream& Foam::operator<<(Ostream& os, const token::punctuationToken& pt)
 120 {
 121     return os << char(pt);
 122 }
 123
 124
 125 Foam::Ostream& Foam::operator<<(Ostream& os, const token::compound& ct)
 126 {
 127     os << ct.type() << token::SPACE;
 128     ct.write(os);
 129
 130     return os;
 131 }
 132
 133
 134 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 135
 136 ostream& Foam::operator<<(ostream& os, const InfoProxy<token>& ip)
 137 {
 138     const token& t = ip.t_;
 139
 140     os  << "on line " << t.lineNumber();
 141
 142     switch (t.type())
 143     {
 144         case token::UNDEFINED:
 145             os  << " an undefined token";
 146         break;
 147
 148         case token::PUNCTUATION:
 149             os  << " the punctuation token " << '\'' << t.pToken() << '\'';
 150         break;
 151
 152         case token::WORD:
 153             os  << " the word " << '\'' << t.wordToken() << '\'';
 154         break;
 155
 156         case token::STRING:
 157             os  << " the string " << t.stringToken();
 158         break;
 159
 160         case token::VERBATIMSTRING:
 161             os  << " the verbatim string " << t.stringToken();
 162         break;
 163
 164         case token::LABEL:
 165             os  << " the label " << t.labelToken();
 166         break;
 167
 168         case token::FLOAT_SCALAR:
 169             os  << " the floatScalar " << t.floatScalarToken();
 170         break;
 171
 172         case token::DOUBLE_SCALAR:
 173             os  << " the doubleScalar " << t.doubleScalarToken();
 174         break;
 175
 176         case token::COMPOUND:
 177         {
 178             if (t.compoundToken().empty())
 179             {
 180                 os  << " the empty compound of type "
 181                     << t.compoundToken().type();
 182             }
 183             else
 184             {
 185                 os  << " the compound of type "
 186                     << t.compoundToken().type();
 187             }
 188         }
 189         break;
 190
 191         case token::ERROR:
 192             os  << " an error";
 193         break;
 194
 195         default:
 196             os  << " an unknown token type " << '\'' << int(t.type()) << '\'';
 197     }
 198
 199     return os;
 200 }
 201
 202
 203 // template specialization
 204 namespace Foam
 205 {
 206
 207 #if defined (__GNUC__)
 208 template<>
 209 #endif
 210 Ostream& operator<<(Ostream& os, const InfoProxy<token>& ip)
 211 {
 212     const token& t = ip.t_;
 213
 214     os  << "on line " << t.lineNumber();
 215
 216     switch (t.type())
 217     {
 218         case token::UNDEFINED:
 219             os  << " an undefined token";
 220         break;
 221
 222         case token::PUNCTUATION:
 223             os  << " the punctuation token " << '\'' << t.pToken() << '\'';
 224         break;
 225
 226         case token::WORD:
 227             os  << " the word " << '\'' << t.wordToken() << '\'';
 228         break;
 229
 230         case token::STRING:
 231             os  << " the string " << t.stringToken();
 232         break;
 233
 234         case token::VERBATIMSTRING:
 235             os  << " the verbatim string " << t.stringToken();
 236         break;
 237
 238         case token::LABEL:
 239             os  << " the label " << t.labelToken();
 240         break;
 241
 242         case token::FLOAT_SCALAR:
 243             os  << " the floatScalar " << t.floatScalarToken();
 244         break;
 245
 246         case token::DOUBLE_SCALAR:
 247             os  << " the doubleScalar " << t.doubleScalarToken();
 248         break;
 249
 250         case token::COMPOUND:
 251         {
 252             if (t.compoundToken().empty())
 253             {
 254                 os  << " the empty compound of type "
 255                     << t.compoundToken().type();
 256             }
 257             else
 258             {
 259                 os  << " the compound of type "
 260                     << t.compoundToken().type();
 261             }
 262         }
 263         break;
 264
 265         case token::ERROR:
 266             os  << " an error";
 267         break;
 268
 269         default:
 270             os  << " an unknown token type "  << '\'' << int(t.type()) << '\'';
 271     }
 272
 273     return os;
 274 }
 275
 276
 277 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 278
 279 } // End namespace Foam
 280
 281 // ************************************************************************* //