dtool/src/cppparser/cppToken.cxx Source File

00001 // Filename: cppToken.cxx
00002 // Created by:  drose (22Oct99)
00003 //
00004 ////////////////////////////////////////////////////////////////////
00005 //
00006 // PANDA 3D SOFTWARE
00007 // Copyright (c) 2001, Disney Enterprises, Inc.  All rights reserved
00008 //
00009 // All use of this software is subject to the terms of the Panda 3d
00010 // Software license.  You should have received a copy of this license
00011 // along with this source code; you will also find a current copy of
00012 // the license at http://www.panda3d.org/license.txt .
00013 //
00014 // To contact the maintainers of this program write to
00015 // panda3d@yahoogroups.com .
00016 //
00017 ////////////////////////////////////////////////////////////////////
00018 
00019 
00020 #include "cppToken.h"
00021 #include "cppIdentifier.h"
00022 #include "cppBison.h"
00023 
00024 #include <ctype.h>
00025 
00026 ////////////////////////////////////////////////////////////////////
00027 //     Function: CPPToken::Constructor
00028 //       Access: Public
00029 //  Description:
00030 ////////////////////////////////////////////////////////////////////
00031 CPPToken::
00032 CPPToken(int token, int line_number, int col_number,
00033          const CPPFile &file, const string &str,
00034          const YYSTYPE &lval) :
00035   _token(token), _lval(lval)
00036 {
00037   _lval.str = str;
00038   _lloc.first_line = line_number;
00039   _lloc.first_column = col_number;
00040   _lloc.last_line = line_number;
00041   _lloc.last_column = col_number;
00042   _lloc.file = file;
00043 }
00044 
00045 ////////////////////////////////////////////////////////////////////
00046 //     Function: CPPToken::Copy Constructor
00047 //       Access: Public
00048 //  Description:
00049 ////////////////////////////////////////////////////////////////////
00050 CPPToken::
00051 CPPToken(const CPPToken &copy) :
00052   _token(copy._token),
00053   _lloc(copy._lloc)
00054 {
00055   _lval.str = copy._lval.str;
00056   _lval.u = copy._lval.u;
00057 }
00058 
00059 ////////////////////////////////////////////////////////////////////
00060 //     Function: CPPToken::Copy Assignment Operator
00061 //       Access: Public
00062 //  Description:
00063 ////////////////////////////////////////////////////////////////////
00064 void CPPToken::
00065 operator = (const CPPToken &copy) {
00066   _token = copy._token;
00067   _lval.str = copy._lval.str;
00068   _lval.u = copy._lval.u;
00069   _lloc = copy._lloc;
00070 }
00071 
00072 ////////////////////////////////////////////////////////////////////
00073 //     Function: CPPToken::eof
00074 //       Access: Public, Static
00075 //  Description: A named constructor for the token returned when the
00076 //               end of file has been reached.
00077 ////////////////////////////////////////////////////////////////////
00078 CPPToken CPPToken::
00079 eof() {
00080   return CPPToken(0);
00081 }
00082 
00083 ////////////////////////////////////////////////////////////////////
00084 //     Function: CPPToken::is_eof
00085 //       Access: Public
00086 //  Description: Returns true if this is the EOF token.
00087 ////////////////////////////////////////////////////////////////////
00088 bool CPPToken::
00089 is_eof() const {
00090   return _token == 0;
00091 }
00092 
00093 
00094 ////////////////////////////////////////////////////////////////////
00095 //     Function: CPPToken::output
00096 //       Access: Public
00097 //  Description:
00098 ////////////////////////////////////////////////////////////////////
00099 void CPPToken::
00100 output(ostream &out) const {
00101   switch (_token) {
00102   case REAL:
00103     out << "REAL " << _lval.u.real;
00104     break;
00105 
00106   case INTEGER:
00107     out << "INTEGER " << _lval.u.integer;
00108     break;
00109 
00110   case CHAR:
00111     out << "CHAR " << _lval.u.integer << " = " << _lval.str;
00112     break;
00113 
00114   case STRING:
00115     out << "STRING " << _lval.str;
00116     break;
00117 
00118   case SIMPLE_IDENTIFIER:
00119     out << "SIMPLE_IDENTIFIER " << _lval.str;
00120     break;
00121 
00122   case IDENTIFIER:
00123     out << "IDENTIFIER " << *_lval.u.identifier;
00124     break;
00125 
00126   case TYPENAME_IDENTIFIER:
00127     out << "TYPENAME_IDENTIFIER " << *_lval.u.identifier;
00128     break;
00129 
00130   case SCOPING:
00131     out << "SCOPING " << *_lval.u.identifier << "::";
00132     break;
00133 
00134   case TYPEDEFNAME:
00135     out << "TYPEDEFNAME " << _lval.str;
00136     break;
00137 
00138   case ELLIPSIS:
00139     out << "ELLIPSIS";
00140     break;
00141 
00142   case OROR:
00143     out << "OROR";
00144     break;
00145 
00146   case ANDAND:
00147     out << "ANDAND";
00148     break;
00149 
00150   case EQCOMPARE:
00151     out << "EQCOMPARE";
00152     break;
00153 
00154   case NECOMPARE:
00155     out << "NECOMPARE";
00156     break;
00157 
00158   case LECOMPARE:
00159     out << "LECOMPARE";
00160     break;
00161 
00162   case GECOMPARE:
00163     out << "GECOMPARE";
00164     break;
00165 
00166   case LSHIFT:
00167     out << "LSHIFT";
00168     break;
00169 
00170   case RSHIFT:
00171     out << "RSHIFT";
00172     break;
00173 
00174   case POINTSAT_STAR:
00175     out << "POINTSAT_STAR";
00176     break;
00177 
00178   case DOT_STAR:
00179     out << "DOT_STAR";
00180     break;
00181 
00182   case UNARY_NOT:
00183     out << "UNARY_NOT";
00184     break;
00185 
00186   case UNARY_MINUS:
00187     out << "UNARY_MINUS";
00188     break;
00189 
00190   case UNARY_NEGATE:
00191     out << "UNARY_NEGATE";
00192     break;
00193 
00194   case UNARY_STAR:
00195     out << "UNARY_STAR";
00196     break;
00197 
00198   case UNARY_REF:
00199     out << "UNARY_REF";
00200     break;
00201 
00202   case POINTSAT:
00203     out << "POINTSAT";
00204     break;
00205 
00206   case SCOPE:
00207     out << "SCOPE";
00208     break;
00209 
00210   case PLUSPLUS:
00211     out << "PLUSPLUS";
00212     break;
00213 
00214   case MINUSMINUS:
00215     out << "MINUSMINUS";
00216     break;
00217 
00218   case TIMESEQUAL:
00219     out << "TIMESEQUAL";
00220     break;
00221 
00222   case DIVIDEEQUAL:
00223     out << "DIVIDEEQUAL";
00224     break;
00225 
00226   case MODEQUAL:
00227     out << "MODEQUAL";
00228     break;
00229 
00230   case PLUSEQUAL:
00231     out << "PLUSEQUAL";
00232     break;
00233 
00234   case MINUSEQUAL:
00235     out << "MINUSEQUAL";
00236     break;
00237 
00238   case OREQUAL:
00239     out << "OREQUAL";
00240     break;
00241 
00242   case ANDEQUAL:
00243     out << "ANDEQUAL";
00244     break;
00245 
00246   case LSHIFTEQUAL:
00247     out << "LSHIFTEQUAL";
00248     break;
00249 
00250   case RSHIFTEQUAL:
00251     out << "RSHIFTEQUAL";
00252     break;
00253 
00254   case TOKENPASTE:
00255     out << "TOKENPASTE";
00256     break;
00257 
00258   case KW_BOOL:
00259     out << "KW_BOOL";
00260     break;
00261 
00262   case KW_CATCH:
00263     out << "KW_CATCH";
00264     break;
00265 
00266   case KW_CHAR:
00267     out << "KW_CHAR";
00268     break;
00269 
00270   case KW_CLASS:
00271     out << "KW_CLASS";
00272     break;
00273 
00274   case KW_CONST:
00275     out << "KW_CONST";
00276     break;
00277 
00278   case KW_DELETE:
00279     out << "KW_DELETE";
00280     break;
00281 
00282   case KW_DOUBLE:
00283     out << "KW_DOUBLE";
00284     break;
00285 
00286   case KW_DYNAMIC_CAST:
00287     out << "KW_DYNAMIC_CAST";
00288     break;
00289 
00290   case KW_ELSE:
00291     out << "KW_ELSE";
00292     break;
00293 
00294   case KW_ENUM:
00295     out << "KW_ENUM";
00296     break;
00297 
00298   case KW_EXPLICIT:
00299     out << "KW_EXPLICIT";
00300     break;
00301 
00302   case KW_EXTERN:
00303     out << "KW_EXTERN";
00304     break;
00305 
00306   case KW_FALSE:
00307     out << "KW_FALSE";
00308     break;
00309 
00310   case KW_FLOAT:
00311     out << "KW_FLOAT";
00312     break;
00313 
00314   case KW_FRIEND:
00315     out << "KW_FRIEND";
00316     break;
00317 
00318   case KW_FOR:
00319     out << "KW_FOR";
00320     break;
00321 
00322   case KW_GOTO:
00323     out << "KW_GOTO";
00324     break;
00325 
00326   case KW_IF:
00327     out << "KW_IF";
00328     break;
00329 
00330   case KW_INLINE:
00331     out << "KW_INLINE";
00332     break;
00333 
00334   case KW_INT:
00335     out << "KW_INT";
00336     break;
00337 
00338   case KW_LONG:
00339     out << "KW_LONG";
00340     break;
00341 
00342   case KW_MUTABLE:
00343     out << "KW_MUTABLE";
00344     break;
00345 
00346   case KW_NAMESPACE:
00347     out << "KW_NAMESPACE";
00348     break;
00349 
00350   case KW_NEW:
00351     out << "KW_NEW";
00352     break;
00353 
00354   case KW_OPERATOR:
00355     if (_lval.u.identifier != NULL) {
00356       out << *_lval.u.identifier << "::";
00357     }
00358     out << "KW_OPERATOR";
00359     break;
00360 
00361   case KW_PRIVATE:
00362     out << "KW_PRIVATE";
00363     break;
00364 
00365   case KW_PROTECTED:
00366     out << "KW_PROTECTED";
00367     break;
00368 
00369   case KW_PUBLIC:
00370     out << "KW_PUBLIC";
00371     break;
00372 
00373   case KW_REGISTER:
00374     out << "KW_REGISTER";
00375     break;
00376 
00377   case KW_RETURN:
00378     out << "KW_RETURN";
00379     break;
00380 
00381   case KW_SHORT:
00382     out << "KW_SHORT";
00383     break;
00384 
00385   case KW_SIGNED:
00386     out << "KW_SIGNED";
00387     break;
00388 
00389   case KW_SIZEOF:
00390     out << "KW_SIZEOF";
00391     break;
00392 
00393   case KW_STATIC:
00394     out << "KW_STATIC";
00395     break;
00396 
00397   case KW_STATIC_CAST:
00398     out << "KW_STATIC_CAST";
00399     break;
00400 
00401   case KW_STRUCT:
00402     out << "KW_STRUCT";
00403     break;
00404 
00405   case KW_TEMPLATE:
00406     out << "KW_TEMPLATE";
00407     break;
00408 
00409   case KW_THROW:
00410     out << "KW_THROW";
00411     break;
00412 
00413   case KW_TRUE:
00414     out << "KW_TRUE";
00415     break;
00416 
00417   case KW_TRY:
00418     out << "KW_TRY";
00419     break;
00420 
00421   case KW_TYPEDEF:
00422     out << "KW_TYPEDEF";
00423     break;
00424 
00425   case KW_TYPENAME:
00426     out << "KW_TYPENAME";
00427     break;
00428 
00429   case KW_USING:
00430     out << "KW_USING";
00431     break;
00432 
00433   case KW_UNION:
00434     out << "KW_UNION";
00435     break;
00436 
00437   case KW_UNSIGNED:
00438     out << "KW_UNSIGNED";
00439     break;
00440 
00441   case KW_VIRTUAL:
00442     out << "KW_VIRTUAL";
00443     break;
00444 
00445   case KW_VOID:
00446     out << "KW_VOID";
00447     break;
00448 
00449   case KW_VOLATILE:
00450     out << "KW_VOLATILE";
00451     break;
00452 
00453   case KW_WHILE:
00454     out << "KW_WHILE";
00455     break;
00456 
00457   case START_CPP:
00458     out << "START_CPP";
00459     break;
00460 
00461   case START_CONST_EXPR:
00462     out << "START_CONST_EXPR";
00463     break;
00464 
00465   case START_TYPE:
00466     out << "START_TYPE";
00467     break;
00468 
00469   default:
00470     if (_token < 128 && isprint(_token)) {
00471       out << "'" << (char)_token << "'";
00472     } else {
00473       out << "token " << _token << "\n";
00474     }
00475   }
00476 }