The DejaVU Framework -- hush 3.0
[.] Papers Tutorials Examples Manuals Interfaces Sources Packages Resources ?

source: test.c hush-3.0b4/api/grammar/examples/lexs


[.] - [up] [top] - index C++ text make include source grammar scripts
  include <stdio.h>
  # define U(x) x
  # define NLSTATE yyprevious=YYNEWLINE
  # define BEGIN yybgin = yysvec + 1 +
  # define INITIAL 0
  # define YYLERR yysvec
  # define YYSTATE (yyestate-yysvec-1)
  # define YYOPTIM 1
  // # define YYLMAX BUFSIZ
  // #ifndef __cplusplus
  // # define output(c) (void)put(c)
  // #else
  // # define output(c) (void)put(c)
  // #endif
  
  // #if defined(__cplusplus) || defined(__STDC__)
  // 
  // #if defined(__cplusplus) && defined(__EXTERN_C__)
  // extern "C" {
  // #endif
  //         int yyback(int *, int);
  //         int yyinput(void);
  //         int yylook(void);
  //         void yyoutput(int);
  //         int yyracc(int);
  //         int yyreject(void);
  //         void yyunput(int);
  //         int yylex(void);
  // #ifdef YYLEX_E
  //         void yywoutput(wchar_t);
  //         wchar_t yywinput(void);
  // #endif
  // #ifndef yyless
  //         void yyless(int);
  // #endif
  // #ifndef yywrap
  //         int yywrap(void);
  // #endif
  // #ifdef LEXDEBUG
  //         void allprint(char);
  //         void sprint(char *);
  // #endif
  // #if defined(__cplusplus) && defined(__EXTERN_C__)
  // }
  // #endif
  // 
  // #ifdef __cplusplus
  // extern "C" {
  // #endif
  //         void exit(int);
  // #ifdef __cplusplus
  // }
  // #endif
  // 
  // #endif
  # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  # define yymore() (yymorfg=1)
  ifndef __cplusplus
  # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):get())==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  else
  # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):get())==10?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  endif
  define ECHO fprintf(yyout, "%s",yytext)
  # define REJECT { nstr = yyreject(); goto yyfussy;}
  // int yyleng; extern char yytext[];
   // int yymorfg;
  // extern char *yysptr, yysbuf[];
  // int yytchar;
  // extern int yylineno;
  // struct yysvf { 
  //         struct yywork *yystoff;
  //         struct yysvf *yyother;
  //         int *yystops;};
  // struct yysvf *yyestate;
  // extern struct yysvf yysvec[], *yybgin;
  define NAME alex
  include <iostream.h>
  include <alex.h>
  include <blex.h>
  static blex b;
  # define YYNEWLINE 10
  #undef ECHO
  define ECHO echo()
  
  ifndef FLEX_SCANNER
  struct yysvf { struct yywork *yystoff; struct yysvf *yyother; int *yystops;};
  endif
  
  ifndef NAME
  define NAME lex
  endif
  
  ifdef FLEX_SCANNER
  
  #undef YY_INPUT
  
  define YY_INPUT(B,R,S) yy_input(B,R,S);
  
  static YY_BUFFER_STATE yy_create_buffer( istream& file, int size );
  
  static void yy_init_buffer( YY_BUFFER_STATE b, istream& file );
  
  endif
  
  token NAME::operator()(){if (!initialized) { init(); initialized = 1; }
  int nstr; extern int yyprevious;
  ifdef __cplusplus
  /* to avoid CC and lint complaining yyfussy not being used ...*/
  static int __lex_hack = 0;
  if (__lex_hack) goto yyfussy;
  endif
  while((nstr = yylook()) >= 0)
  yyfussy: switch(nstr){
  case 0:
  if(yywrap()) return(0); break;
  case 1:
  
  { blex b(istrstream("this is just an example")); b(); }
  break;
  case 2:
  
  cout << yytext << " :A\n";
  break;
  case 3:
  
   { ;}
  break;
  case 4:
  
  { cout << " NL(A)\n"; }
  break;
  case -1:
  break;
  default:
  (void)fprintf(yyout,"bad switch yylook %d",nstr);
  } return(0); }
  /* end of yylex */
  int main() {
  alex a;
  a();
  return 0;
  }
  static int yyvstop[] = {
  0,
  
  3,
  0,
  
  4,
  0,
  
  1,
  0,
  
  2,
  0,
  0};
  # define YYTYPE unsigned char
  static struct yywork { YYTYPE verify, advance; } yycrank[] = {
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        1,3,        1,4,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        1,3,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        1,5,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        0,0,        0,0,        
  0,0,        0,0,        1,6,        1,6,        
  1,6,        1,6,        1,6,        1,6,        
  1,6,        1,6,        1,6,        1,6,        
  1,6,        1,6,        1,6,        1,6,        
  1,6,        1,6,        1,6,        1,6,        
  1,6,        1,6,        1,6,        1,6,        
  1,6,        1,6,        1,6,        1,6,        
  6,6,        6,6,        6,6,        6,6,        
  6,6,        6,6,        6,6,        6,6,        
  6,6,        6,6,        6,6,        6,6,        
  6,6,        6,6,        6,6,        6,6,        
  6,6,        6,6,        6,6,        6,6,        
  6,6,        6,6,        6,6,        6,6,        
  6,6,        6,6,        0,0,        0,0,        
  0,0};
  static struct yysvf yysvec[] = {
  0,        0,        0,
  yycrank+1,        0,                0,        
  yycrank+0,        yysvec+1,        0,        
  yycrank+0,        0,                yyvstop+1,
  yycrank+0,        0,                yyvstop+3,
  yycrank+0,        0,                yyvstop+5,
  yycrank+27,        0,                yyvstop+7,
  0,        0,        0};
  void scanner::init() {
  /*struct yywork */ yytop = yycrank+149;
  /* struct yysvf */ yybgin = yysvec+1;
  yylineno = 1;
  yysptr = yysbuf;
  yyprevious = YYNEWLINE;
  }
  static char yymatch[] = {
    0,   1,   1,   1,   1,   1,   1,   1, 
    1,   9,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    9,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,  97,  97,  97,  97,  97,  97,  97, 
   97,  97,  97,  97,  97,  97,  97,  97, 
   97,  97,  97,  97,  97,  97,  97,  97, 
   97,  97,  97,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
    1,   1,   1,   1,   1,   1,   1,   1, 
  0};
  static char yyextra[] = {
  0,0,0,0,0,0,0,0,
  0};
  /*	Copyright (c) 1989 AT&T	*/
  /*	  All Rights Reserved  	*/
  
  /*	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T	*/
  /*	The copyright notice above does not evidence any   	*/
  /*	actual or intended publication of such source code.	*/
  
  #pragma ident        "@(#)ncform        6.7        93/06/07 SMI"
  
  // int yylineno =1;
  # define YYU(x) x
  # define NLSTATE yyprevious=YYNEWLINE
  // char yytext[YYLMAX];
  // struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  // char yysbuf[YYLMAX];
  // char *yysptr = yysbuf;
  // int *yyfnd;
  // extern struct yysvf *yyestate;
  // int yyprevious = YYNEWLINE;
  if defined(__cplusplus) || defined(__STDC__)
  int scanner::yylook(void)
  else
  
  endif
  {
          register struct yysvf *yystate, **lsp;
          register struct yywork *yyt;
          struct yysvf *yyz;
          int yych, yyfirst;
          struct yywork *yyr;
  # ifdef LEXDEBUG
          int debug;
  # endif
          char *yylastch;
          /* start off machines */
  # ifdef LEXDEBUG
          debug = 0;
  # endif
          yyfirst=1;
          if (!yymorfg)
                  yylastch = yytext;
          else {
                  yymorfg=0;
                  yylastch = yytext+yyleng;
                  }
          for(;;){
                  lsp = yylstate;
                  yyestate = yystate = yybgin;
                  if (yyprevious==YYNEWLINE) yystate++;
                  for (;;){
  # ifdef LEXDEBUG
                          if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  # endif
                          yyt = yystate->yystoff;
                          if(yyt == yycrank && !yyfirst){  /* may not be any transitions */
                                  yyz = yystate->yyother;
                                  if(yyz == 0)break;
                                  if(yyz->yystoff == yycrank)break;
                                  }
  ifndef __cplusplus
  			*yylastch++ = yych = input();
  else
  			*yylastch++ = yych = input();
  endif
                          if(yylastch > &yytext[YYLMAX]) {
                                  fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
                                  exit(1);
                          }
                          yyfirst=0;
                  tryagain:
  # ifdef LEXDEBUG
                          if(debug){
                                  fprintf(yyout,"char ");
                                  allprint(yych);
                                  putchar('\n');
                                  }
  # endif
                          yyr = yyt;
                          if ( (int)yyt > (int)yycrank){
                                  yyt = yyr + yych;
                                  if (yyt <= yytop && yyt->verify+yysvec == yystate){
                                          if(yyt->advance+yysvec == YYLERR)        /* error transitions */
                                                  {unput(*--yylastch);break;}
  					*lsp++ = yystate = yyt->advance+yysvec;
                                          if(lsp > &yylstate[YYLMAX]) {
                                                  fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
                                                  exit(1);
                                          }
                                          goto contin;
                                          }
                                  }
  # ifdef YYOPTIM
                          else if((int)yyt < (int)yycrank) {                /* r < yycrank */
                                  yyt = yyr = yycrank+(yycrank-yyt);
  # ifdef LEXDEBUG
                                  if(debug)fprintf(yyout,"compressed state\n");
  # endif
                                  yyt = yyt + yych;
                                  if(yyt <= yytop && yyt->verify+yysvec == yystate){
                                          if(yyt->advance+yysvec == YYLERR)        /* error transitions */
                                                  {unput(*--yylastch);break;}
  					*lsp++ = yystate = yyt->advance+yysvec;
                                          if(lsp > &yylstate[YYLMAX]) {
                                                  fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
                                                  exit(1);
                                          }
                                          goto contin;
                                          }
                                  yyt = yyr + YYU(yymatch[yych]);
  # ifdef LEXDEBUG
                                  if(debug){
                                          fprintf(yyout,"try fall back character ");
                                          allprint(YYU(yymatch[yych]));
                                          putchar('\n');
                                          }
  # endif
                                  if(yyt <= yytop && yyt->verify+yysvec == yystate){
                                          if(yyt->advance+yysvec == YYLERR)        /* error transition */
                                                  {unput(*--yylastch);break;}
  					*lsp++ = yystate = yyt->advance+yysvec;
                                          if(lsp > &yylstate[YYLMAX]) {
                                                  fprintf(yyout,"Input string too long, limit %d\n",YYLMAX);
                                                  exit(1);
                                          }
                                          goto contin;
                                          }
                                  }
                          if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  # ifdef LEXDEBUG
                                  if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  # endif
                                  goto tryagain;
                                  }
  # endif
                          else
                                  {unput(*--yylastch);break;}
                  contin:
  # ifdef LEXDEBUG
                          if(debug){
                                  fprintf(yyout,"state %d char ",yystate-yysvec-1);
                                  allprint(yych);
                                  putchar('\n');
                                  }
  # endif
                          ;
                          }
  # ifdef LEXDEBUG
                  if(debug){
                          fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
                          allprint(yych);
                          putchar('\n');
                          }
  # endif
                  while (lsp-- > yylstate){
  			*yylastch-- = 0;
                          if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
                                  yyolsp = lsp;
                                  if(yyextra[*yyfnd]){                /* must backup */
                                          while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
                                                  lsp--;
                                                  unput(*yylastch--);
                                                  }
                                          }
                                  yyprevious = YYU(*yylastch);
                                  yylsp = lsp;
                                  yyleng = yylastch-yytext+1;
                                  yytext[yyleng] = 0;
  # ifdef LEXDEBUG
                                  if(debug){
                                          fprintf(yyout,"\nmatch ");
                                          sprint(yytext);
                                          fprintf(yyout," action %d\n",*yyfnd);
                                          }
  # endif
                                  return(*yyfnd++);
                                  }
                          unput(*yylastch);
                          }
                  if (yytext[0] == 0  /* && feof(yyin) */)
                          {
                          yysptr=yysbuf;
                          return(0);
                          }
  ifndef __cplusplus
                  yyprevious = yytext[0] = input();
                  if (yyprevious>0)
                          output(yyprevious);
  else
                  yyprevious = yytext[0] = input();
                  if (yyprevious>0)
                          output(yyprevious);
  endif
                  yylastch=yytext;
  # ifdef LEXDEBUG
                  if(debug)putchar('\n');
  # endif
                  }
          }
  if defined(__cplusplus) || defined(__STDC__)
  // int scanner::yyback(int *p, int m)
  static yybackNAME(int *p, int m)
  else
  static yybackNAME(int *p, int m)
  //         int *p;
  endif
  {
          if (p==0) return(0);
          while (*p) {
                  if (*p++ == m)
                          return(1);
          }
          return(0);
  }
          
  if defined(__cplusplus) || defined(__STDC__)
  static int scanneryyinput(void) {}
  else
  static int scanneryyinput(void){}
  endif
  
  // #endif
  // {
  // #ifndef __cplusplus
  //         return(input());
  // #else
  //         return(input());
  // #endif
  //         }
  // #if defined(__cplusplus) || defined(__STDC__)
  // static yyoutputNAME(int c)
  // #else
  // static yyxxutputNAME(int c)
  //   int c; 
  // #endif
  // {
  // #ifndef __cplusplus
  //         output(c);
  // #else
  //         output(c);
  // #endif
  //         }
  // #if defined(__cplusplus) || defined(__STDC__)
  // static yyunputNAME(int c)
  // #else
  // static yyxxunputNAME(int c)
  //    int c; 
  // #endif
  // {
  //         unput(c);
  //         }
  

[.] Papers Tutorials Examples Manuals Interfaces Sources Packages Resources ?
Hush Online Technology
hush@cs.vu.nl
09/09/98