lex_scanner


  class lex_scanner : public scanner {
  public:
  
  lex_scanner(istream* in = &cin, ostream* out = &cout) : scanner(this) {
  initialized = 0; 
  yyin = in; yyout = out;
  yyleng = yylineno = 0;
  //AE yymorfg = yyleng = yylineno = 0;
  //cerr << "Creating scanner" << endl;
  }
  
  virtual ~lex_scanner() {
  //cerr << "Deleting scanner" << endl;
  }
  
  virtual term* operator()() {
          cerr << "scanner::operator() **ERROR**" << endl; 
          return 0;
          }
  
  virtual int yywrap() {
          //cerr << "calling wrap" << endl;
          return(1);
          }
  
  //istream* yyin;
  //ostream* yyout;
  
  int yyleng;
  //int yylineno;
  ifdef FLEX_SCANNER
  char* yytext;
  else
  char yytext[YYLMAX];
  endif
  
  protected:
  int initialized;
  // added for allowing interactive use of lex
  ifndef FLEX_SCANNER
  int newline() { return yytchar == '\n'; }
  endif
  
  ifndef FLEX_SCANNER
  // ordinary lex variables
  
  char *yysptr;
  char yysbuf[YYLMAX];
  int yymorfg;
  //int yytchar;
  struct yywork *yytop;
  struct yysvf *yybgin;
  struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  int *yyfnd;
  struct yysvf *yyestate;
  int yyprevious;
  
  inline void init();
  endif
  
  ifdef FLEX_SCANNER
  define YY_NEVER_INTERACTIVE 1
  
  //#ifndef YY_CHAR
  //#define YY_CHAR char
  //#endif
  
  define YY_FATAL_ERROR(X) /* yerror() */
  typedef struct yy_buffer_state *YY_BUFFER_STATE;
  
  typedef int yy_state_type;
  char yy_hold_char;
  int yy_n_chars;
  yy_state_type yy_last_accepting_state;
  char* yy_last_accepting_cpos;
  char* yy_c_buf_p; 
  int yy_start, yy_init;
  int yy_did_buffer_switch_on_eof;
  
  inline yy_state_type yy_get_previous_state ( void );
  inline int yy_get_next_buffer ( void );
  inline yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
  inline void yy_fatal_error( yyconst char msg[] );
  inline void yyunput ( int c, register char* buf_ptr );
  //inline void yyunput ( YY_CHAR c, YY_CHAR *buf_ptr );
  inline void yyrestart ( istream* input_file );
  inline void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
  inline void yy_load_buffer_state ( void );
  inline YY_BUFFER_STATE yy_create_buffer ( istream* file, int size );
  inline void yy_delete_buffer ( YY_BUFFER_STATE b );
  inline void yy_init_buffer ( YY_BUFFER_STATE b, istream* file );
  inline void yy_flush_buffer( YY_BUFFER_STATE b );
  inline YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size );
  inline YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len );
  inline YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str );
  
  inline int yy_input(char* b, int& result, int max) {
  int i = 0; char c; char *p = b; 
  while (i < max && yyin && yyin->get(c) ) {
  	*p++ = c; i++;
  }
  return result = i;
  }
  
  inline int yyinput();
  
  inline void init() {
  yy_c_buf_p = 0;
  yy_init = 1;
  yy_start = 0;
  yy_c_buf_p = (char *) 0;
  }
  endif
  
  ifndef FLEX_SCANNER
  virtual int yyinput();
  virtual        int yyback(int *, int);
  virtual        void yyunput(int);
  virtual        void yyoutput(int);
  inline int yylook();
  endif
  
  virtual char yyget() { return yyin?yyin->get():0; }
  virtual void yyput(char c) { if (yyout) yyout->put(c); }
  
  virtual void echo() { if (yyout) *yyout << yytext; }
  void output(char c) { yyput(c); }
  
  ifndef FLEX_SCANNER
  int xxinput() {
    int n = yytchar;
    ((n = (yysptr>yysbuf)?
    (*--yysptr):yyget())==10?(yylineno++,yytchar):
      (yytchar)==EOF)?0:yytchar;
      yytchar = n;
      return yytchar;
      }
  
  void xxunput(char c) { 
      yytchar = (int) c;
      if (yytchar=='\n') yylineno--;
      *yysptr++ = yytchar;
      }
  
  void xxmore() { (yymorfg=1); }
  endif
  
  };

slide: lex_scanner