BaseTools/Source/C/VfrCompile/Pccts/h/DLexerBase.cpp

   1 /* DLGLexerBase.c
   2  *
   3  * SOFTWARE RIGHTS
   4  *
   5  * We reserve no LEGAL rights to the Purdue Compiler Construction Tool
   6  * Set (PCCTS) -- PCCTS is in the public domain.  An individual or
   7  * company may do whatever they wish with source code distributed with
   8  * PCCTS or the code generated by PCCTS, including the incorporation of
   9  * PCCTS, or its output, into commerical software.
  10  *
  11  * We encourage users to develop software with PCCTS.  However, we do ask
  12  * that credit is given to us for developing PCCTS.  By "credit",
  13  * we mean that if you incorporate our source code into one of your
  14  * programs (commercial product, research project, or otherwise) that you
  15  * acknowledge this fact somewhere in the documentation, research report,
  16  * etc...  If you like PCCTS and have developed a nice tool with the
  17  * output, please mention that you developed it using PCCTS.  In
  18  * addition, we ask that this header remain intact in our source code.
  19  * As long as these guidelines are kept, we expect to continue enhancing
  20  * this system and expect to make other tools available as they are
  21  * completed.
  22  *
  23  * ANTLR 1.33
  24  * Terence Parr
  25  * Parr Research Corporation
  26  * with Purdue University and AHPCRC, University of Minnesota
  27  * 1989-2000
  28  */
  29
  30 #include "pcctscfg.h"
  31
  32 #include "pccts_stdio.h"
  33 #include "pccts_stdlib.h"
  34
  35 PCCTS_NAMESPACE_STD
  36
  37 /* I have to put this here due to C++ limitation
  38  * that you can't have a 'forward' decl for enums.
  39  * I hate C++!!!!!!!!!!!!!!!
  40  */
  41
  42 // MR1
  43 // MR1  10-Apr-97  133MR1  Prevent use of varying sizes for the
  44 // MR1                          ANTLRTokenType enum
  45 // MR1
  46
  47 enum ANTLRTokenType { TER_HATES_CPP=0, ITS_UTTER_GARBAGE,               // MR1
  48                                          WITH_SOME_GOOD_IDEAS=9999};    // MR1
  49
  50 #define ANTLR_SUPPORT_CODE
  51
  52 #include "pcctscfg.h"
  53 #include DLEXERBASE_H
  54 #include APARSER_H              // MR23
  55
  56 DLGLexerBase::
  57 DLGLexerBase(DLGInputStream *in,
  58              unsigned bufsize,
  59              int _interactive,
  60              int _track_columns)
  61 {
  62         this->_bufsize = bufsize;
  63         this->_lextext = new DLGChar[_bufsize];
  64         if ( this->_lextext==NULL ) {
  65             panic("text buffer is NULL");
  66         }
  67         this->_begexpr = this->_endexpr = NULL;
  68         this->ch = this->bufovf = 0;
  69         this->nextpos = NULL;
  70         this->cl = 0;
  71         this->add_erase = 0;
  72         this->input = in;
  73         this->_begcol = 0;
  74         this->_endcol = 0;
  75         this->_line = 1;
  76         this->charfull = 0;
  77         this->automaton = 0;
  78         this->token_to_fill = NULL;
  79         this->interactive = _interactive;
  80         this->track_columns = _track_columns;
  81         this->debugLexerFlag = 0;                                       // MR1
  82         this->parser = NULL;                                            // MR1
  83     this->lexErrCount=0;                        // MR11
  84 }
  85
  86 // MR19  THM
  87
  88 void DLGLexerBase::reset()
  89 {
  90         this->charfull = 0;
  91         this->_begcol = 0;
  92         this->_endcol = 0;
  93         this->automaton = 0;
  94         this->_line=1;
  95         this->lexErrCount=0;
  96 }
  97
  98 void DLGLexerBase::
  99 setInputStream( DLGInputStream *in )
 100 {
 101         this->input = in;
 102         _line = 1;
 103         charfull = 0;
 104 }
 105
 106 /* saves dlg state, but not what feeds dlg (such as file position) */
 107 void DLGLexerBase::
 108 saveState(DLGState *state)
 109 {
 110         state->input = input;
 111         state->interactive = interactive;
 112         state->track_columns = track_columns;
 113         state->auto_num = automaton;
 114         state->add_erase = add_erase;
 115         state->lookc = ch;
 116         state->char_full = charfull;
 117         state->begcol = _begcol;
 118         state->endcol = _endcol;
 119         state->line = _line;
 120         state->lextext = _lextext;
 121         state->begexpr = _begexpr;
 122         state->endexpr = _endexpr;
 123         state->bufsize = _bufsize;
 124         state->bufovf = bufovf;
 125         state->nextpos = nextpos;
 126         state->class_num = cl;
 127         state->debugLexerFlag = debugLexerFlag;                         // MR1
 128         state->parser = parser;                                         // MR1
 129 }
 130
 131 void DLGLexerBase::
 132 restoreState(DLGState *state)
 133 {
 134         input = state->input;
 135         interactive = state->interactive;
 136         track_columns = state->track_columns;
 137         automaton = state->auto_num;
 138         add_erase = state->add_erase;
 139         ch = state->lookc;
 140         charfull = state->char_full;
 141         _begcol = state->begcol;
 142         _endcol = state->endcol;
 143         _line = state->line;
 144         _lextext = state->lextext;
 145         _begexpr = state->begexpr;
 146         _endexpr = state->endexpr;
 147         _bufsize = state->bufsize;
 148         bufovf = state->bufovf;
 149         nextpos = state->nextpos;
 150         cl = state->class_num;
 151         debugLexerFlag = state->debugLexerFlag;                         // MR1
 152         parser = state->parser;                                         // MR1
 153 }
 154
 155 /* erase what is currently in the buffer, and get a new reg. expr */
 156 void DLGLexerBase::
 157 skip()
 158 {
 159         add_erase = 1;
 160 }
 161
 162 /* don't erase what is in the lextext buffer, add on to it */
 163 void DLGLexerBase::
 164 more()
 165 {
 166         add_erase = 2;
 167 }
 168
 169 /* substitute c for the reg. expr last matched and is in the buffer */
 170 void DLGLexerBase::
 171 replchar(DLGChar c)
 172 {
 173         /* can't allow overwriting null at end of string */
 174         if (_begexpr < &_lextext[_bufsize-1]){
 175                 *_begexpr = c;
 176                 *(_begexpr+1) = '\0';
 177         }
 178         _endexpr = _begexpr;
 179         if (c != '\0') {
 180                 nextpos = _begexpr + 1;
 181         }
 182         else {
 183                 nextpos = _begexpr;     /* MR30 Zero terminates string. */
 184         }
 185 }
 186
 187 /* replace the string s for the reg. expr last matched and in the buffer */
 188
 189 #ifdef _MSC_VER  // MR23
 190 //Turn off "assignment within conditional expression" warning
 191 #pragma warning(disable : 4706)
 192 #endif
 193 void DLGLexerBase::
 194 replstr(const DLGChar *s) /* MR20 const */
 195 {
 196         register DLGChar *l= &_lextext[_bufsize -1];
 197
 198         nextpos = _begexpr;
 199         if (s){
 200                 while ((nextpos <= l) && (*(nextpos++) = *(s++))){
 201                         /* empty */
 202                 }
 203                 /* correct for NULL at end of string */
 204                 nextpos--;
 205         }
 206         if ((nextpos <= l) && (*(--s) == 0)){
 207                 bufovf = 0;
 208         }else{
 209                 bufovf = 1;
 210         }
 211         *(nextpos) = '\0';
 212         _endexpr = nextpos - 1;
 213 }
 214 #ifdef _MSC_VER  // MR23
 215 #pragma warning(default: 4706)
 216 #endif
 217
 218 void DLGLexerBase::
 219 errstd(const char *s)                               /* MR20 const */
 220 {
 221         lexErrCount++;                              /* MR11 */
 222         /* MR23 */ printMessage(stderr,
 223                 "%s near line %d (text was '%s')\n",
 224                 ((s == NULL) ? "Lexical error" : s),
 225                 _line,_lextext);
 226 }
 227
 228 int DLGLexerBase::
 229 err_in()
 230 {
 231         /* MR23 */ printMessage(stderr,"No input stream, function, or string\n");
 232         /* return eof to get out gracefully */
 233         return EOF;
 234 }
 235
 236 ANTLRTokenType DLGLexerBase::
 237 erraction()
 238 {
 239         errstd("invalid token");
 240         advance();
 241         skip();
 242         return (ANTLRTokenType) 0;      // bogus, but satisfies compiler
 243 }
 244
 245 _ANTLRTokenPtr DLGLexerBase::
 246 getToken()
 247 {
 248         if ( token_to_fill==NULL ) panic("NULL token_to_fill");
 249         ANTLRTokenType tt = nextTokenType();
 250         _ANTLRTokenPtr tk = token_to_fill->makeToken(tt, _lextext,_line);
 251         return tk;
 252 }
 253
 254 void DLGLexerBase::
 255 panic(const char *msg)      /* MR20 const */
 256 {
 257         if (parser)                             //MR23
 258                 parser->panic(msg);     //MR23
 259         else                                    //MR23
 260         {
 261                 /* MR23 */ printMessage(stderr, "DLG panic: %s\n", msg);
 262         //
 263         //  7-Apr-97 133MR1
 264         //
 265                 exit(PCCTS_EXIT_FAILURE);                                       // MR1
 266         }
 267 }
 268
 269 ANTLRParser * DLGLexerBase::                                            // MR1
 270 setParser(ANTLRParser *p) {                                             // MR1
 271   ANTLRParser   *oldValue=parser;                                       // MR1
 272   parser=p;                                                             // MR1
 273   return oldValue;                                                      // MR1
 274 }                                                                       // MR1
 275                                                                         // MR1
 276 ANTLRParser * DLGLexerBase::                                            // MR1
 277 getParser() {                                                           // MR1
 278   return parser;                                                        // MR1
 279 }                                                                       // MR1
 280                                                                         // MR1
 281 int DLGLexerBase::                                                      // MR1
 282 debugLexer(int newValue) {                                              // MR1
 283   int   oldValue=debugLexerFlag;                                        // MR1
 284   debugLexerFlag=newValue;                                              // MR1
 285   return oldValue;                                                      // MR1
 286 }                                                                       // MR1
 287
 288 //MR23
 289 int DLGLexerBase::printMessage(FILE* pFile, const char* pFormat, ...)
 290 {
 291         va_list marker;
 292         va_start( marker, pFormat );
 293
 294         int iRet = 0;
 295         if (parser)
 296                 parser->printMessageV(pFile, pFormat, marker);
 297         else
 298                 iRet = vfprintf(pFile, pFormat, marker);
 299
 300         va_end( marker );
 301         return iRet;
 302 }