My Project
Data Structures | Macros | Typedefs | Functions | Variables
scanner.cc File Reference
#include <stdio.h>
#include "factory/globaldefs.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include "kernel/mod2.h"
#include "omalloc/omalloc.h"
#include "Singular/tok.h"
#include "Singular/stype.h"
#include "Singular/ipshell.h"
#include "Singular/fevoices.h"
#include "kernel/oswrapper/feread.h"

Go to the source code of this file.

Data Structures

struct  YY_BUFFER_STATE
 

Macros

#define FLEX_SCANNER
 
#define YY_FLEX_MAJOR_VERSION   2
 
#define YY_FLEX_MINOR_VERSION   5
 
#define YY_USE_PROTOS
 
#define YY_USE_CONST
 
#define yyconst   const
 
#define YY_PROTO(proto)   proto
 
#define YY_NULL   0
 
#define YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
 
#define BEGIN   yy_start = 1 + 2 *
 
#define YY_START   ((yy_start - 1) / 2)
 
#define YYSTATE   YY_START
 
#define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
 
#define YY_NEW_FILE   yyrestart( yyin )
 
#define YY_END_OF_BUFFER_CHAR   0
 
#define YY_BUF_SIZE   16384
 
#define EOB_ACT_CONTINUE_SCAN   0
 
#define EOB_ACT_END_OF_FILE   1
 
#define EOB_ACT_LAST_MATCH   2
 
#define yyless(n)
 
#define unput(c)   yyunput( c, yytext_ptr )
 
#define YY_BUFFER_NEW   0
 
#define YY_BUFFER_NORMAL   1
 
#define YY_BUFFER_EOF_PENDING   2
 
#define YY_CURRENT_BUFFER   yy_current_buffer
 
#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )
 
#define yy_new_buffer   yy_create_buffer
 
#define yy_set_interactive(is_interactive)
 
#define yy_set_bol(at_bol)
 
#define YY_AT_BOL()   (yy_current_buffer->yy_at_bol)
 
#define yytext_ptr   yytext
 
#define YY_DO_BEFORE_ACTION
 
#define YY_NUM_RULES   66
 
#define YY_END_OF_BUFFER   67
 
#define REJECT   reject_used_but_not_detected
 
#define yymore()   (yy_more_flag = 1)
 
#define YY_MORE_ADJ   yy_more_len
 
#define YY_RESTORE_YY_MORE_OFFSET
 
#define INITIAL   0
 
#define ALLOC(a)   omAlloc((a))
 
#define malloc   omAlloc
 
#define realloc   omRealloc
 
#define free   omFree
 
#define YY_DECL   int yylex(YYSTYPE* lvalp)
 
#define YY_INPUT(buf, result, max_size)    result = feReadLine( (char *) (buf), (max_size) )
 
#define YY_USER_ACTION
 
#define YY_ALWAYS_INTERACTIVE   1
 
#define string   1
 
#define block   2
 
#define blockstr   3
 
#define brace   4
 
#define bracestr   5
 
#define bracket   6
 
#define asstring   7
 
#define YY_NO_PUSH_STATE   1
 
#define YY_NO_POP_STATE   1
 
#define YY_NO_TOP_STATE   1
 
#define YY_READ_BUF_SIZE   8192
 
#define ECHO   (void) fwrite( yytext, yyleng, 1, yyout )
 
#define yyterminate()   return YY_NULL
 
#define YY_START_STACK_INCR   25
 
#define YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
 
#define YY_BREAK   break;
 
#define YY_RULE_SETUP    YY_USER_ACTION
 
#define YY_EXIT_FAILURE   2
 
#define yyless(n)
 

Typedefs

typedef unsigned int yy_size_t
 
typedef unsigned char YY_CHAR
 
typedef int yy_state_type
 

Functions

void yyrestart YY_PROTO ((FILE *input_file))
 
void yy_switch_to_buffer YY_PROTO ((YY_BUFFER_STATE new_buffer))
 
void yy_load_buffer_state YY_PROTO ((void))
 
YY_BUFFER_STATE yy_create_buffer YY_PROTO ((FILE *file, int size))
 
void yy_delete_buffer YY_PROTO ((YY_BUFFER_STATE b))
 
void yy_init_buffer YY_PROTO ((YY_BUFFER_STATE b, FILE *file))
 
YY_BUFFER_STATE yy_scan_buffer YY_PROTO ((char *base, yy_size_t size))
 
YY_BUFFER_STATE yy_scan_string YY_PROTO ((yyconst char *yy_str))
 
YY_BUFFER_STATE yy_scan_bytes YY_PROTO ((yyconst char *bytes, int len))
 
static void *yy_flex_alloc YY_PROTO ((yy_size_t))
 
static void *yy_flex_realloc YY_PROTO ((void *, yy_size_t))
 
static void yy_flex_free YY_PROTO ((void *))
 
static yy_state_type yy_try_NUL_trans YY_PROTO ((yy_state_type current_state))
 
static void yy_fatal_error YY_PROTO ((yyconst char msg[]))
 
int feReadLine (char *b, int l)
 
static char * dupyytext ()
 
static char * dupyytextNL ()
 
int yywrap ()
 
static void yyunput YY_PROTO ((int c, char *buf_ptr))
 
 if (yy_init)
 
 while (1)
 
static int yy_get_next_buffer ()
 
static yy_state_type yy_get_previous_state ()
 
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state)
 
static void yyunput (int c, register char *yy_bp)
 
static int yyinput ()
 
void yyrestart (FILE *input_file)
 
void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
 
void yy_load_buffer_state (void)
 
YY_BUFFER_STATE yy_create_buffer (FILE *file, int size)
 
void yy_delete_buffer (YY_BUFFER_STATE b)
 
void yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
 
void yy_flush_buffer (YY_BUFFER_STATE b)
 
YY_BUFFER_STATE yy_scan_buffer (char *base, yy_size_t size)
 
YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str)
 
YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes, int len)
 
static void yy_fatal_error (yyconst char msg[])
 
static void * yy_flex_alloc (yy_size_t size)
 
static void * yy_flex_realloc (void *ptr, yy_size_t size)
 
static void yy_flex_free (void *ptr)
 
void * myynewbuffer ()
 
void myyoldbuffer (void *oldb)
 
void myychangebuffer ()
 
void my_yy_flush ()
 

Variables

EXTERN_VAR int yyleng
 
EXTERN_VAR FILE * yyin = (FILE *) 0
 
EXTERN_VAR FILE * yyout = (FILE *) 0
 
STATIC_VAR YY_BUFFER_STATE yy_current_buffer = 0
 
STATIC_VAR char yy_hold_char
 
STATIC_VAR int yy_n_chars
 
STATIC_VAR char * yy_c_buf_p = (char *) 0
 
STATIC_VAR int yy_init = 1
 
STATIC_VAR int yy_start = 0
 
STATIC_VAR int yy_did_buffer_switch_on_eof
 
EXTERN_VAR char * yytext
 
static yyconst short int yy_accept [171]
 
static yyconst int yy_ec [256]
 
static yyconst int yy_meta [49]
 
static yyconst short int yy_base [192]
 
static yyconst short int yy_def [192]
 
static yyconst short int yy_nxt [610]
 
static yyconst short int yy_chk [610]
 
STATIC_VAR yy_state_type yy_last_accepting_state
 
STATIC_VAR char * yy_last_accepting_cpos
 
STATIC_VAR int yy_more_flag = 0
 
STATIC_VAR int yy_more_len = 0
 
VAR int blocknest = 0
 
EXTERN_VAR int inerror
 
 YY_DECL
 
register char * yy_cp
 
register char * yy_bp
 
register int yy_act
 

Data Structure Documentation

◆ yy_buffer_state

struct yy_buffer_state

Definition at line 164 of file libparse.cc.

Data Fields
int yy_at_bol
char * yy_buf_pos
yy_size_t yy_buf_size
int yy_buffer_status
char * yy_ch_buf
int yy_fill_buffer
FILE * yy_input_file
int yy_is_interactive
int yy_is_our_buffer
int yy_n_chars

Macro Definition Documentation

◆ ALLOC

#define ALLOC (   a)    omAlloc((a))

Definition at line 579 of file scanner.cc.

◆ asstring

#define asstring   7

Definition at line 656 of file scanner.cc.

◆ BEGIN

#define BEGIN   yy_start = 1 + 2 *

Definition at line 80 of file scanner.cc.

◆ block

#define block   2

Definition at line 646 of file scanner.cc.

◆ blockstr

#define blockstr   3

Definition at line 648 of file scanner.cc.

◆ brace

#define brace   4

Definition at line 650 of file scanner.cc.

◆ bracestr

#define bracestr   5

Definition at line 652 of file scanner.cc.

◆ bracket

#define bracket   6

Definition at line 654 of file scanner.cc.

◆ ECHO

#define ECHO   (void) fwrite( yytext, yyleng, 1, yyout )

Definition at line 737 of file scanner.cc.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 105 of file scanner.cc.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 106 of file scanner.cc.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 107 of file scanner.cc.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 7 of file scanner.cc.

◆ free

#define free   omFree

Definition at line 594 of file scanner.cc.

◆ INITIAL

#define INITIAL   0

Definition at line 560 of file scanner.cc.

◆ malloc

#define malloc   omAlloc

Definition at line 590 of file scanner.cc.

◆ realloc

#define realloc   omRealloc

Definition at line 592 of file scanner.cc.

◆ REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 552 of file scanner.cc.

◆ string

#define string   1

Definition at line 644 of file scanner.cc.

◆ unput

#define unput (   c)    yyunput( c, yytext_ptr )

Definition at line 136 of file scanner.cc.

◆ YY_ALWAYS_INTERACTIVE

#define YY_ALWAYS_INTERACTIVE   1

Definition at line 643 of file scanner.cc.

◆ YY_AT_BOL

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 263 of file scanner.cc.

◆ YY_BREAK

#define YY_BREAK   break;

Definition at line 796 of file scanner.cc.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 98 of file scanner.cc.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 199 of file scanner.cc.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 187 of file scanner.cc.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 188 of file scanner.cc.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 208 of file scanner.cc.

◆ YY_DECL

#define YY_DECL   int yylex(YYSTYPE* lvalp)

Definition at line 626 of file scanner.cc.

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION
Value:
yytext_ptr -= yy_more_len; \
yyleng = (int) (yy_cp - yytext_ptr); \
yy_hold_char = *yy_cp; \
*yy_cp = '\0'; \
yy_c_buf_p = yy_cp;
register char * yy_bp
Definition: scanner.cc:805
#define yytext_ptr
Definition: scanner.cc:269
register char * yy_cp
Definition: scanner.cc:805
STATIC_VAR int yy_more_len
Definition: scanner.cc:554

Definition at line 279 of file scanner.cc.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   67

Definition at line 288 of file scanner.cc.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 95 of file scanner.cc.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 2182 of file scanner.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 777 of file scanner.cc.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 8 of file scanner.cc.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 9 of file scanner.cc.

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )

Definition at line 237 of file scanner.cc.

◆ YY_INPUT

#define YY_INPUT (   buf,
  result,
  max_size 
)     result = feReadLine( (char *) (buf), (max_size) )

Definition at line 634 of file scanner.cc.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ   yy_more_len

Definition at line 556 of file scanner.cc.

◆ yy_new_buffer

#define yy_new_buffer   yy_create_buffer

Definition at line 247 of file scanner.cc.

◆ YY_NEW_FILE

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 93 of file scanner.cc.

◆ YY_NO_POP_STATE

#define YY_NO_POP_STATE   1

Definition at line 707 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 706 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 708 of file scanner.cc.

◆ YY_NULL

#define YY_NULL   0

Definition at line 67 of file scanner.cc.

◆ YY_NUM_RULES

#define YY_NUM_RULES   66

Definition at line 287 of file scanner.cc.

◆ YY_PROTO

#define YY_PROTO (   proto)    proto

Definition at line 61 of file scanner.cc.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 728 of file scanner.cc.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 557 of file scanner.cc.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP    YY_USER_ACTION

Definition at line 799 of file scanner.cc.

◆ YY_SC_TO_UI

#define YY_SC_TO_UI (   c)    ((unsigned int) (unsigned char) c)

Definition at line 74 of file scanner.cc.

◆ yy_set_bol

#define yy_set_bol (   at_bol)
Value:
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
yy_current_buffer->yy_at_bol = at_bol; \
}
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1922
EXTERN_VAR FILE * yyin
Definition: scanner.cc:103
STATIC_VAR YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:202
#define YY_BUF_SIZE
Definition: scanner.cc:98

Definition at line 256 of file scanner.cc.

◆ yy_set_interactive

#define yy_set_interactive (   is_interactive)
Value:
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
yy_current_buffer->yy_is_interactive = is_interactive; \
}

Definition at line 249 of file scanner.cc.

◆ YY_START

#define YY_START   ((yy_start - 1) / 2)

Definition at line 86 of file scanner.cc.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 772 of file scanner.cc.

◆ YY_STATE_EOF

#define YY_STATE_EOF (   state)    (YY_END_OF_BUFFER + state + 1)

Definition at line 90 of file scanner.cc.

◆ YY_USE_CONST

#define YY_USE_CONST

Definition at line 32 of file scanner.cc.

◆ YY_USE_PROTOS

#define YY_USE_PROTOS

Definition at line 29 of file scanner.cc.

◆ YY_USER_ACTION

#define YY_USER_ACTION
Value:
if ((inerror==1)&&(*yytext>=' '))\
{ Print(" skipping text from `%s`",yytext);inerror=2; }
#define Print
Definition: emacs.cc:80
EXTERN_VAR char * yytext
Definition: scanner.cc:268
EXTERN_VAR int inerror
Definition: scanner.cc:586

Definition at line 638 of file scanner.cc.

◆ yyconst

#define yyconst   const

Definition at line 54 of file scanner.cc.

◆ yyless [1/2]

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up yytext. */ \
YY_RESTORE_YY_MORE_OFFSET \
yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \
while ( 0 )
#define YY_MORE_ADJ
Definition: scanner.cc:556
STATIC_VAR char yy_hold_char
Definition: scanner.cc:212

Definition at line 2201 of file scanner.cc.

◆ yyless [2/2]

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up yytext. */ \
yytext[yyleng] = yy_hold_char; \
yy_c_buf_p = yytext + n; \
yy_hold_char = *yy_c_buf_p; \
*yy_c_buf_p = '\0'; \
yyleng = n; \
} \
while ( 0 )
EXTERN_VAR int yyleng
Definition: scanner.cc:102
STATIC_VAR char * yy_c_buf_p
Definition: scanner.cc:220

Definition at line 2201 of file scanner.cc.

◆ yymore

#define yymore ( )    (yy_more_flag = 1)

Definition at line 555 of file scanner.cc.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 87 of file scanner.cc.

◆ yyterminate

#define yyterminate ( )    return YY_NULL

Definition at line 767 of file scanner.cc.

◆ yytext_ptr

#define yytext_ptr   yytext

Definition at line 269 of file scanner.cc.

Typedef Documentation

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 265 of file scanner.cc.

◆ yy_size_t

typedef unsigned int yy_size_t

Definition at line 142 of file scanner.cc.

◆ yy_state_type

typedef int yy_state_type

Definition at line 267 of file scanner.cc.

Function Documentation

◆ dupyytext()

static char* dupyytext ( )
static

Definition at line 597 of file scanner.cc.

598 {
599  char* s;
600  if (yyleng>0) yytext[yyleng-1] = '\0';
601  s = omStrDup((char *)yytext);
603  return s;
604 }
const CanonicalForm int s
Definition: facAbsFact.cc:51
#define omStrDup(s)
Definition: omAllocDecl.h:263
void omMarkAsStaticAddr(void *addr)

◆ dupyytextNL()

static char* dupyytextNL ( )
static

Definition at line 606 of file scanner.cc.

607 {
608  int i = yyleng;//strlen((char *)yytext);
609  char * rc = (char*)omAlloc( 3 + i );
610  omMarkAsStaticAddr(rc);
611  if (i>0)
612  {
613  strncpy( rc, (char *)yytext, i-1 );
614  }
615  else
616  {
617  i++;
618  }
619  rc[i-1] = '\n';
620  rc[i] = '\n';
621  rc[i+1] = '\0';
622  return rc;
623 }
int i
Definition: cfEzgcd.cc:132
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ feReadLine()

int feReadLine ( char *  b,
int  l 
)

Definition at line 500 of file fevoices.cc.

501 {
502  char *s=NULL;
503  int offset = 0; /* will not be used if s==NULL*/
504  // try to read from the buffer into b, max l chars
505  if (currentVoice!=NULL)
506  {
507  if((currentVoice->buffer!=NULL)
508  && (currentVoice->buffer[currentVoice->fptr]!='\0'))
509  {
510  NewBuff:
511  REGISTER int i=0;
512  long startfptr=currentVoice->fptr;
513  long tmp_ptr=currentVoice->fptr;
514  l--;
515  loop
516  {
517  REGISTER char c=
518  b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
519  i++;
520  if (yy_noeof==noeof_block)
521  {
522  if (c<' ') yylineno++;
523  else if (c=='}') break;
524  }
525  else
526  {
527  if ((c<' ') ||
528  (c==';') ||
529  (c==')')
530  )
531  break;
532  }
533  if (i>=l) break;
534  tmp_ptr++;/*currentVoice->fptr++;*/
535  if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
536  }
537  currentVoice->fptr=tmp_ptr;
538  b[i]='\0';
539  if (currentVoice->sw==BI_buffer)
540  {
541  BOOLEAN show_echo=FALSE;
542  char *anf;
543  long len;
544  if (startfptr==0)
545  {
546  anf=currentVoice->buffer;
547  const char *ss=strchr(anf,'\n');
548  if (ss==NULL) len=strlen(anf);
549  else len=ss-anf;
550  show_echo=TRUE;
551  }
552  else if (/*(startfptr>0) &&*/
553  (currentVoice->buffer[startfptr-1]=='\n'))
554  {
555  anf=currentVoice->buffer+startfptr;
556  const char *ss=strchr(anf,'\n');
557  if (ss==NULL) len=strlen(anf);
558  else len=ss-anf;
559  yylineno++;
560  show_echo=TRUE;
561  }
562  if (show_echo)
563  {
564  char *s=(char *)omAlloc(len+2);
565  strncpy(s,anf,len+2);
566  s[len+1]='\0';
567  fePrintEcho(s,b);
568  omFree((ADDRESS)s);
569  }
570  }
571  currentVoice->fptr++;
572  return i;
573  }
574  // no buffer there or e-o-buffer or eoln:
575  if (currentVoice->sw!=BI_buffer)
576  {
577  currentVoice->fptr=0;
578  if (currentVoice->buffer==NULL)
579  {
583  }
584  }
585  offset=0;
586  NewRead:
587  yylineno++;
588  if (currentVoice->sw==BI_stdin)
589  {
590  feShowPrompt();
594  //int i=0;
595  //if (s!=NULL)
596  // while((s[i]!='\0') /*&& (i<MAX_FILE_BUFFER)*/) {s[i] &= (char)127;i++;}
597  }
598  else if (currentVoice->sw==BI_file)
599  {
603  if (s!=NULL)
604  {
606  // ftell returns -1 for non-seekable streams, such as pipes
607  if (currentVoice->ftellptr<0)
609  }
610  }
611  //else /* BI_buffer */ s==NULL => return 0
612  // done by the default return
613  }
614  if (s!=NULL)
615  {
616  // handle prot:
617  if (feProt&SI_PROT_I)
618  {
619  fputs(s,feProtFile);
620  }
621  if (File_Log!=NULL)
622  {
624  fputs(s,File_Log);
625  }
626  int rc=fePrintEcho(s,b)+1;
627  //s[strlen(s)+1]='\0'; add an second \0 at the end of the string
628  s[rc]='\0';
629  // handel \\ :
630  rc-=3; if (rc<0) rc=0;
631  if ((s[rc]=='\\')&&(currentVoice->sw!=BI_buffer))
632  {
633  s[rc]='\0';
634  offset+=rc;
635  if (offset<currentVoice->buff_size) goto NewRead;
636  }
637  goto NewBuff;
638  }
639  /* else if (s==NULL) */
640  {
641  const char *err;
642  switch(yy_noeof)
643  {
644  case noeof_brace:
645  case noeof_block:
646  err="{...}";
647  break;
648  case noeof_asstring:
649  err="till `.`";
650  break;
651  case noeof_string:
652  err="string";
653  break;
654  case noeof_bracket:
655  err="(...)";
656  break;
657  case noeof_procname:
658  err="proc";
659  break;
660  case noeof_comment:
661  err="/*...*/";
662  break;
663  default:
664  return 0;
665  }
666  Werror("premature end of file while reading %s",err);
667  return 0;
668  }
669 }
int BOOLEAN
Definition: auxiliary.h:87
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
void * ADDRESS
Definition: auxiliary.h:119
int l
Definition: cfEzgcd.cc:100
CanonicalForm b
Definition: cfModGcd.cc:4103
FILE * files
Definition: fevoices.h:67
char * buffer
Definition: fevoices.h:69
long ftellptr
Definition: fevoices.h:71
int buff_size
Definition: fevoices.h:73
feBufferInputs sw
Definition: fevoices.h:77
long fptr
Definition: fevoices.h:70
VAR int yylineno
Definition: febase.cc:40
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:32
#define MAX_FILE_BUFFER
Definition: fevoices.cc:39
VAR char fe_promptstr[]
Definition: fevoices.cc:31
VAR Voice * currentVoice
Definition: fevoices.cc:49
VAR BOOLEAN File_Log_written
Definition: fevoices.cc:34
VAR FILE * File_Log
Definition: fevoices.cc:33
static int fePrintEcho(char *anf, char *)
Definition: fevoices.cc:418
VAR int yy_noeof
Definition: fevoices.cc:47
static void feShowPrompt(void)
Definition: fevoices.cc:410
@ BI_file
Definition: fevoices.h:32
@ BI_buffer
Definition: fevoices.h:31
@ BI_stdin
Definition: fevoices.h:30
@ noeof_string
Definition: fevoices.h:42
@ noeof_brace
Definition: fevoices.h:36
@ noeof_comment
Definition: fevoices.h:40
@ noeof_asstring
Definition: fevoices.h:37
@ noeof_block
Definition: fevoices.h:38
@ noeof_procname
Definition: fevoices.h:41
@ noeof_bracket
Definition: fevoices.h:39
STATIC_VAR int offset
Definition: janet.cc:29
#define SEEK_SET
Definition: mod2.h:115
#define omFree(addr)
Definition: omAllocDecl.h:261
#define NULL
Definition: omList.c:12
#define REGISTER
Definition: omalloc.h:27
VAR int feProt
Definition: reporter.cc:56
VAR FILE * feProtFile
Definition: reporter.cc:57
void Werror(const char *fmt,...)
Definition: reporter.cc:189
#define SI_PROT_I
Definition: reporter.h:53
#define loop
Definition: structs.h:75

◆ if()

if ( yy_init  )

Definition at line 811 of file scanner.cc.

812  {
813  yy_init = 0;
814 
815 #ifdef YY_USER_INIT
816  YY_USER_INIT;
817 #endif
818 
819  if ( ! yy_start )
820  yy_start = 1; /* first start state */
821 
822  if ( ! yyin )
823  yyin = stdin;
824 
825  if ( ! yyout )
826  yyout = stdout;
827 
828  if ( ! yy_current_buffer )
831 
833  }
#define YY_USER_INIT
Definition: libparse.cc:1210
EXTERN_VAR FILE * yyout
Definition: scanner.cc:103
STATIC_VAR int yy_start
Definition: scanner.cc:222
void yy_load_buffer_state(void)
Definition: scanner.cc:1909
STATIC_VAR int yy_init
Definition: scanner.cc:221

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2318 of file scanner.cc.

2318 { YY_FLUSH_BUFFER;BEGIN(0); }
#define BEGIN
Definition: scanner.cc:80
#define YY_FLUSH_BUFFER
Definition: scanner.cc:237

◆ myychangebuffer()

void myychangebuffer ( )

Definition at line 2311 of file scanner.cc.

2312 {
2313  yy_flush_buffer((YY_BUFFER_STATE)YY_CURRENT_BUFFER);
2316 }
void yy_flush_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:2006
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1879
#define YY_CURRENT_BUFFER
Definition: scanner.cc:208
void yy_delete_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:1953

◆ myynewbuffer()

void* myynewbuffer ( )

Definition at line 2297 of file scanner.cc.

2298 {
2299  void * oldb = YY_CURRENT_BUFFER;
2301  return oldb;
2302 }

◆ myyoldbuffer()

void myyoldbuffer ( void *  oldb)

Definition at line 2304 of file scanner.cc.

2305 {
2307  yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
2308  //yy_flush_buffer((YY_BUFFER_STATE)oldb);
2309 }

◆ while()

while ( )

Definition at line 835 of file scanner.cc.

836  {
837  yy_more_len = 0;
838  if ( yy_more_flag )
839  {
841  yy_more_flag = 0;
842  }
843  yy_cp = yy_c_buf_p;
844 
845  /* Support of yytext. */
846  *yy_cp = yy_hold_char;
847 
848  /* yy_bp points to the position in yy_ch_buf of the start of
849  * the current run.
850  */
851  yy_bp = yy_cp;
852 
853  yy_current_state = yy_start;
854 yy_match:
855  do
856  {
857  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
858  if ( yy_accept[yy_current_state] )
859  {
860  yy_last_accepting_state = yy_current_state;
862  }
863  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
864  {
865  yy_current_state = (int) yy_def[yy_current_state];
866  if ( yy_current_state >= 171 )
867  yy_c = yy_meta[(unsigned int) yy_c];
868  }
869  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
870  ++yy_cp;
871  }
872  while ( yy_base[yy_current_state] != 561 );
873 
874 yy_find_action:
875  yy_act = yy_accept[yy_current_state];
876  if ( yy_act == 0 )
877  { /* have to back up */
879  yy_current_state = yy_last_accepting_state;
880  yy_act = yy_accept[yy_current_state];
881  }
882 
884 
885 
886 do_action: /* This label is used only to access EOF actions. */
887 
888 
889  switch ( yy_act )
890  { /* beginning of action switch */
891  case 0: /* must back up */
892  /* undo the effects of YY_DO_BEFORE_ACTION */
893  *yy_cp = yy_hold_char;
895  yy_current_state = yy_last_accepting_state;
896  goto yy_find_action;
897 
898 case 1:
900 #line 122 "scanner.l"
901 { }
902  YY_BREAK
903 case 2:
905 #line 123 "scanner.l"
906 { }
907  YY_BREAK
908 case 3:
910 #line 124 "scanner.l"
911 {
913  loop
914  {
915  REGISTER int c;
916  while ( (c = yyinput()) != '*' && c != EOF );
917  if ( c == '*' )
918  {
919  while ( (c = yyinput()) == '*' );
920  if ( c == '/' ) break; /* found the end */
921  }
922  else
923  {
924  break;
925  }
926  }
927  yy_noeof=0;
928  }
929  YY_BREAK
930 case 4:
932 #line 142 "scanner.l"
933 { prompt_char='.';
935  return WHILE_CMD;}
936  YY_BREAK
937 case 5:
939 #line 145 "scanner.l"
940 { prompt_char='.';
942  return FOR_CMD;}
943  YY_BREAK
944 case 6:
946 #line 149 "scanner.l"
948  BEGIN(asstring);
949  return HELP_CMD;
950  }
951  YY_BREAK
952 case 7:
954 #line 154 "scanner.l"
956  BEGIN(asstring);
957  return EXAMPLE_CMD;
958  }
959  YY_BREAK
960 case 8:
962 #line 159 "scanner.l"
963 {
964  char c; char *cp;
965  lvalp->name = omStrDup(iiProcName((char *)yytext,c,cp));
967  blocknest = 1;
968  BEGIN(brace);
969  return PROC_DEF;
970  }
971  YY_BREAK
972 case 9:
974 #line 167 "scanner.l"
975 {
976  lvalp->name = omStrDup((char *)yytext);
977  yy_noeof = 0; BEGIN(INITIAL);
978  return STRINGTOK;
979  }
980  YY_BREAK
981 case 10:
983 #line 172 "scanner.l"
984 {
985  yy_noeof = 0; BEGIN(INITIAL);
986  return *yytext;
987  }
988  YY_BREAK
989 case 11:
991 #line 177 "scanner.l"
992 {
994  BEGIN(bracestr);
995  yymore();
996  }
997  YY_BREAK
998 case 12:
1000 #line 182 "scanner.l"
1001 { if (blocknest++) yymore(); }
1002  YY_BREAK
1003 case 13:
1005 #line 183 "scanner.l"
1006 { if (blocknest) yymore(); }
1007  YY_BREAK
1008 case 14:
1010 #line 184 "scanner.l"
1011 {
1012  if (blocknest)
1013  {
1014  lvalp->name = dupyytext();
1015  return STRINGTOK;
1016  }
1017  }
1018  YY_BREAK
1019 case 15:
1021 #line 191 "scanner.l"
1022 {
1023  if (--blocknest <= 0)
1024  {
1025  yy_noeof = 0;
1026  BEGIN(INITIAL);
1027  lvalp->name = dupyytext();
1028  return STRINGTOK;
1029  }
1030  yymore();
1031  }
1032  YY_BREAK
1033 case 16:
1035 #line 201 "scanner.l"
1036 {
1038  BEGIN(brace);
1039  yymore();
1040  }
1041  YY_BREAK
1042 case 17:
1044 #line 206 "scanner.l"
1045 { yymore(); }
1046  YY_BREAK
1047 case 18:
1049 #line 207 "scanner.l"
1050 { return '('; }
1051  YY_BREAK
1052 case 19:
1054 #line 208 "scanner.l"
1055 { return ','; }
1056  YY_BREAK
1057 case 20:
1059 #line 209 "scanner.l"
1060 { ; }
1061  YY_BREAK
1062 case 21:
1064 #line 210 "scanner.l"
1065 {
1066  lvalp->name = omStrDup((char *)yytext);
1067  return STRINGTOK;
1068  }
1069  YY_BREAK
1070 case 22:
1072 #line 214 "scanner.l"
1073 {
1074  lvalp->name = omStrDup((char *)yytext);
1075  return STRINGTOK;
1076  }
1077  YY_BREAK
1078 case 23:
1080 #line 218 "scanner.l"
1081 {
1082  yy_noeof = 0; BEGIN(INITIAL);
1083  return ')';
1084  }
1085  YY_BREAK
1086 case 24:
1088 #line 223 "scanner.l"
1089 {
1091  blocknest = 1;
1093  BEGIN(block);
1094  }
1095  YY_BREAK
1096 case 25:
1098 #line 229 "scanner.l"
1099 {
1101  BEGIN(blockstr);
1102  yymore();
1103  }
1104  YY_BREAK
1105 case 26:
1107 #line 234 "scanner.l"
1108 { yymore(); }
1109  YY_BREAK
1110 case 27:
1112 #line 235 "scanner.l"
1113 { yymore(); }
1114  YY_BREAK
1115 case 28:
1117 #line 236 "scanner.l"
1118 { yymore(); }
1119  YY_BREAK
1120 case 29:
1122 #line 237 "scanner.l"
1123 {
1125  BEGIN(block);
1126  yymore();
1127  }
1128  YY_BREAK
1129 case 30:
1131 #line 242 "scanner.l"
1132 { yymore(); }
1133  YY_BREAK
1134 case 31:
1136 #line 243 "scanner.l"
1137 { yymore(); }
1138  YY_BREAK
1139 case 32:
1141 #line 244 "scanner.l"
1142 { blocknest++; yymore(); }
1143  YY_BREAK
1144 case 33:
1146 #line 245 "scanner.l"
1147 {
1148  if (--blocknest <= 0)
1149  {
1150  BEGIN(INITIAL);
1151  yy_noeof = 0;
1152  lvalp->name = dupyytextNL();
1153  return BLOCKTOK;
1154  }
1155  yymore();
1156  }
1157  YY_BREAK
1158 case 34:
1160 #line 255 "scanner.l"
1161 { BEGIN(string); yy_noeof = noeof_string;}
1162  YY_BREAK
1163 case 35:
1165 #line 256 "scanner.l"
1166 { return SYS_BREAK; }
1167  YY_BREAK
1168 case 36:
1170 #line 257 "scanner.l"
1171 { yymore(); }
1172  YY_BREAK
1173 case 37:
1175 #line 258 "scanner.l"
1176 { yymore(); }
1177  YY_BREAK
1178 case 38:
1180 #line 259 "scanner.l"
1181 { yymore(); }
1182  YY_BREAK
1183 case 39:
1185 #line 260 "scanner.l"
1186 {
1187  char * s;
1188  yy_noeof = 0;
1189  BEGIN(INITIAL);
1190  s = lvalp->name = dupyytext();
1191  while (*yytext)
1192  {
1193  if (*yytext == '\\') yytext++;
1194  *s++ = *yytext++;
1195  }
1196  *s++ = *yytext++;
1197  return STRINGTOK;
1198  }
1199  YY_BREAK
1200 case 40:
1202 #line 274 "scanner.l"
1203 /* skip whitespace */
1204  YY_BREAK
1205 case 41:
1207 #line 275 "scanner.l"
1208 { return DOTDOT; }
1209  YY_BREAK
1210 case 42:
1212 #line 276 "scanner.l"
1213 { return COLONCOLON; }
1214  YY_BREAK
1215 case 43:
1217 #line 277 "scanner.l"
1218 { return MINUSMINUS; }
1219  YY_BREAK
1220 case 44:
1222 #line 278 "scanner.l"
1223 { return PLUSPLUS ; }
1224  YY_BREAK
1225 case 45:
1227 #line 279 "scanner.l"
1228 { return EQUAL_EQUAL; }
1229  YY_BREAK
1230 case 46:
1232 #line 280 "scanner.l"
1233 { lvalp->i='&'; return LOGIC_OP; }
1234  YY_BREAK
1235 case 47:
1237 #line 281 "scanner.l"
1238 { lvalp->i='|'; return LOGIC_OP; }
1239  YY_BREAK
1240 case 48:
1242 #line 282 "scanner.l"
1243 { lvalp->i=LE; return COMP_OP; }
1244  YY_BREAK
1245 case 49:
1247 #line 283 "scanner.l"
1248 { lvalp->i=GE; return COMP_OP; }
1249  YY_BREAK
1250 case 50:
1252 #line 284 "scanner.l"
1253 { return NOT; }
1254  YY_BREAK
1255 case 51:
1257 #line 285 "scanner.l"
1258 { return NOTEQUAL; }
1259  YY_BREAK
1260 case 52:
1262 #line 286 "scanner.l"
1263 { return NOTEQUAL; }
1264  YY_BREAK
1265 case 53:
1267 #line 287 "scanner.l"
1268 { return '^'; }
1269  YY_BREAK
1270 case 54:
1272 #line 288 "scanner.l"
1273 { return ARROW; }
1274  YY_BREAK
1275 case 55:
1277 #line 289 "scanner.l"
1278 { return '\\'; }
1279  YY_BREAK
1280 case 56:
1282 #line 290 "scanner.l"
1283 {
1284  lvalp->name = omStrDup("\n");
1285  return STRINGTOK;
1286  }
1287  YY_BREAK
1288 case 57:
1290 #line 294 "scanner.l"
1291 {
1292  lvalp->name = (char *)yytext;
1293  return INT_CONST;
1294  }
1295  YY_BREAK
1296 case 58:
1298 #line 298 "scanner.l"
1299 {
1300  lvalp->name = (char *)yytext;
1301  return MONOM;
1302  }
1303  YY_BREAK
1304 case 59:
1306 #line 302 "scanner.l"
1307 {
1308  m2_end(-1);
1309  }
1310  YY_BREAK
1311 case 60:
1313 #line 305 "scanner.l"
1314 {
1315  #ifdef MM_STAT
1316  mmStat(-500);
1317  #endif
1318  #ifdef OM_TRACK
1319  #ifndef SING_NDEBUG
1320  omPrintUsedTrackAddrs(stdout, 10);
1321  #endif
1322  #endif
1323  m2_end(0);
1324  }
1325  YY_BREAK
1326 case 61:
1328 #line 317 "scanner.l"
1329 {
1330  lvalp->name = (char *)yytext;
1331  return MONOM;
1332  }
1333  YY_BREAK
1334 case 62:
1336 #line 321 "scanner.l"
1337 {
1338  lvalp->name = (char *)yytext;
1339  return MONOM;
1340  }
1341  YY_BREAK
1342 case 63:
1343 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1344 yy_c_buf_p = yy_cp -= 1;
1345 YY_DO_BEFORE_ACTION; /* set up yytext again */
1347 #line 325 "scanner.l"
1348 {
1349  lvalp->name = (char *)yytext;
1350  return MONOM;
1351  }
1352  YY_BREAK
1353 case 64:
1355 #line 330 "scanner.l"
1356 {
1357  /* {name} */
1358  int rc=0;
1359  if (yytext[strlen((char *)yytext)-1] == '\n')
1360  {
1361  yytext[strlen((char *)yytext)-1] = '\0';
1362  }
1363  if (yyleng > 1)
1364  {
1365  rc = IsCmd((char *)yytext,lvalp->i);
1366  if (rc) return rc;
1367  }
1368  lvalp->name = omStrDup((char *)yytext);
1369  return UNKNOWN_IDENT;
1370  }
1371  YY_BREAK
1372 case 65:
1374 #line 346 "scanner.l"
1375 {
1376  /*if (*yytext == '\n') REJECT;*/
1377  REGISTER char ch= *yytext;
1378  lvalp->i = ch;
1379  switch(ch)
1380  {
1381  /* case '&': */
1382  case '|':
1383  return LOGIC_OP;
1384  /* case '/': */
1385  case '%':
1386  case '*':
1387  return MULDIV_OP;
1388  /* case '<': */
1389  case '>':
1390  return COMP_OP;
1391  default:
1392  break;
1393  }
1394  return ch;
1395  }
1396  YY_BREAK
1397 case 66:
1399 #line 367 "scanner.l"
1400 YY_FATAL_ERROR( "flex scanner jammed" );
1401  YY_BREAK
1402 case YY_STATE_EOF(INITIAL):
1403 case YY_STATE_EOF(string):
1404 case YY_STATE_EOF(block):
1405 case YY_STATE_EOF(blockstr):
1406 case YY_STATE_EOF(brace):
1407 case YY_STATE_EOF(bracestr):
1408 case YY_STATE_EOF(bracket):
1409 case YY_STATE_EOF(asstring):
1410  yyterminate();
1411 
1412  case YY_END_OF_BUFFER:
1413  {
1414  /* Amount of text matched not including the EOB char. */
1415  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1416 
1417  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1418  *yy_cp = yy_hold_char;
1420 
1421  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1422  {
1423  /* We're scanning a new file or input source. It's
1424  * possible that this happened because the user
1425  * just pointed yyin at a new source and called
1426  * yylex(). If so, then we have to assure
1427  * consistency between yy_current_buffer and our
1428  * globals. Here is the right place to do so, because
1429  * this is the first action (other than possibly a
1430  * back-up) that will match for the new input source.
1431  */
1432  yy_n_chars = yy_current_buffer->yy_n_chars;
1433  yy_current_buffer->yy_input_file = yyin;
1434  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1435  }
1436 
1437  /* Note that here we test for yy_c_buf_p "<=" to the position
1438  * of the first EOB in the buffer, since yy_c_buf_p will
1439  * already have been incremented past the NUL character
1440  * (since all states make transitions on EOB to the
1441  * end-of-buffer state). Contrast this with the test
1442  * in input().
1443  */
1444  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1445  { /* This was really a NUL. */
1446  yy_state_type yy_next_state;
1447 
1448  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1449 
1450  yy_current_state = yy_get_previous_state();
1451 
1452  /* Okay, we're now positioned to make the NUL
1453  * transition. We couldn't have
1454  * yy_get_previous_state() go ahead and do it
1455  * for us because it doesn't know how to deal
1456  * with the possibility of jamming (and we don't
1457  * want to build jamming into it because then it
1458  * will run more slowly).
1459  */
1460 
1461  yy_next_state = yy_try_NUL_trans( yy_current_state );
1462 
1464 
1465  if ( yy_next_state )
1466  {
1467  /* Consume the NUL. */
1468  yy_cp = ++yy_c_buf_p;
1469  yy_current_state = yy_next_state;
1470  goto yy_match;
1471  }
1472 
1473  else
1474  {
1475  yy_cp = yy_c_buf_p;
1476  goto yy_find_action;
1477  }
1478  }
1479 
1480  else switch ( yy_get_next_buffer() )
1481  {
1482  case EOB_ACT_END_OF_FILE:
1483  {
1485 
1486  if ( yywrap() )
1487  {
1488  /* Note: because we've taken care in
1489  * yy_get_next_buffer() to have set up
1490  * yytext, we can now set up
1491  * yy_c_buf_p so that if some total
1492  * hoser (like flex itself) wants to
1493  * call the scanner after we return the
1494  * YY_NULL, it'll still work - another
1495  * YY_NULL will get returned.
1496  */
1498 
1500  goto do_action;
1501  }
1502 
1503  else
1504  {
1506  YY_NEW_FILE;
1507  }
1508  break;
1509  }
1510 
1511  case EOB_ACT_CONTINUE_SCAN:
1512  yy_c_buf_p =
1513  yytext_ptr + yy_amount_of_matched_text;
1514 
1515  yy_current_state = yy_get_previous_state();
1516 
1517  yy_cp = yy_c_buf_p;
1519  goto yy_match;
1520 
1521  case EOB_ACT_LAST_MATCH:
1522  yy_c_buf_p =
1523  &yy_current_buffer->yy_ch_buf[yy_n_chars];
1524 
1525  yy_current_state = yy_get_previous_state();
1526 
1527  yy_cp = yy_c_buf_p;
1529  goto yy_find_action;
1530  }
1531  break;
1532  }
1533 
1534  default:
1536  "fatal flex scanner internal error--no action found" );
1537  } /* end of action switch */
1538  } /* end of scanning one token */
EXTERN_VAR char prompt_char
Definition: feread.h:10
@ PLUSPLUS
Definition: grammar.cc:274
@ NOT
Definition: grammar.cc:272
@ MINUSMINUS
Definition: grammar.cc:271
@ EXAMPLE_CMD
Definition: grammar.cc:323
@ SYS_BREAK
Definition: grammar.cc:346
@ ARROW
Definition: grammar.cc:276
@ GE
Definition: grammar.cc:269
@ EQUAL_EQUAL
Definition: grammar.cc:268
@ INT_CONST
Definition: grammar.cc:333
@ BLOCKTOK
Definition: grammar.cc:332
@ LE
Definition: grammar.cc:270
@ MONOM
Definition: grammar.cc:335
@ UNKNOWN_IDENT
Definition: grammar.cc:334
@ FOR_CMD
Definition: grammar.cc:344
@ NOTEQUAL
Definition: grammar.cc:273
@ STRINGTOK
Definition: grammar.cc:331
@ DOTDOT
Definition: grammar.cc:267
@ PROC_DEF
Definition: grammar.cc:336
@ COLONCOLON
Definition: grammar.cc:275
@ WHILE_CMD
Definition: grammar.cc:347
@ HELP_CMD
Definition: grammar.cc:325
int IsCmd(const char *n, int &tok)
Definition: iparith.cc:9501
char * iiProcName(char *buf, char &ct, char *&e)
Definition: iplib.cc:100
unsigned char YY_CHAR
Definition: libparse.cc:284
int yy_state_type
Definition: libparse.cc:286
void m2_end(int i)
Definition: misc_ip.cc:1097
EXTERN_VAR int yy_noeof
Definition: reporter.h:19
EXTERN_VAR int yy_blocklineno
Definition: reporter.h:18
#define YY_NEW_FILE
Definition: scanner.cc:93
#define block
Definition: scanner.cc:646
static char * dupyytextNL()
Definition: scanner.cc:606
#define string
Definition: scanner.cc:644
static yyconst short int yy_accept[171]
Definition: scanner.cc:289
#define YY_BREAK
Definition: scanner.cc:796
#define brace
Definition: scanner.cc:650
static yyconst int yy_ec[256]
Definition: scanner.cc:311
STATIC_VAR int yy_n_chars
Definition: scanner.cc:214
#define YY_BUFFER_NEW
Definition: scanner.cc:187
#define YY_RESTORE_YY_MORE_OFFSET
Definition: scanner.cc:557
#define YY_BUFFER_NORMAL
Definition: scanner.cc:188
#define YY_RULE_SETUP
Definition: scanner.cc:799
VAR int blocknest
Definition: scanner.cc:582
#define yymore()
Definition: scanner.cc:555
#define EOB_ACT_END_OF_FILE
Definition: scanner.cc:106
register int yy_act
Definition: scanner.cc:806
STATIC_VAR int yy_did_buffer_switch_on_eof
Definition: scanner.cc:227
static int yyinput()
Definition: scanner.cc:1791
#define bracestr
Definition: scanner.cc:652
static char * dupyytext()
Definition: scanner.cc:597
#define YY_START
Definition: scanner.cc:86
static int yy_get_next_buffer()
Definition: scanner.cc:1550
#define blockstr
Definition: scanner.cc:648
#define asstring
Definition: scanner.cc:656
#define bracket
Definition: scanner.cc:654
#define INITIAL
Definition: scanner.cc:560
static yyconst short int yy_base[192]
Definition: scanner.cc:352
#define YY_END_OF_BUFFER
Definition: scanner.cc:288
#define YY_STATE_EOF(state)
Definition: scanner.cc:90
static yyconst short int yy_def[192]
Definition: scanner.cc:378
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:777
STATIC_VAR int yy_more_flag
Definition: scanner.cc:553
#define yyterminate()
Definition: scanner.cc:767
static yy_state_type yy_get_previous_state()
Definition: scanner.cc:1682
static yyconst int yy_meta[49]
Definition: scanner.cc:343
#define YY_DO_BEFORE_ACTION
Definition: scanner.cc:279
#define EOB_ACT_LAST_MATCH
Definition: scanner.cc:107
int yywrap()
Definition: scanner.cc:630
static yyconst short int yy_nxt[610]
Definition: scanner.cc:404
#define EOB_ACT_CONTINUE_SCAN
Definition: scanner.cc:105
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition: scanner.cc:1717
#define YY_SC_TO_UI(c)
Definition: scanner.cc:74
static yyconst short int yy_chk[610]
Definition: scanner.cc:475
STATIC_VAR yy_state_type yy_last_accepting_state
Definition: scanner.cc:546
STATIC_VAR char * yy_last_accepting_cpos
Definition: scanner.cc:547
#define LOGIC_OP
Definition: tok.h:25
#define COMP_OP
Definition: tok.h:27
#define MULDIV_OP
Definition: tok.h:26
#define omPrintUsedTrackAddrs(F, max)
Definition: xalloc.h:266

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 1922 of file scanner.cc.

1928  {
1929  YY_BUFFER_STATE b;
1930 
1931  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1932  if ( ! b )
1933  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1934 
1935  b->yy_buf_size = size;
1936 
1937  /* yy_ch_buf has to be 2 characters longer than the size given because
1938  * we need to put in 2 end-of-buffer characters.
1939  */
1940  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1941  if ( ! b->yy_ch_buf )
1942  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1943 
1944  b->yy_is_our_buffer = 1;
1945 
1946  yy_init_buffer( b, file );
1947 
1948  return b;
1949  }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
static void * yy_flex_alloc(yy_size_t size)
Definition: scanner.cc:2250
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: scanner.cc:1979

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 1953 of file scanner.cc.

1958  {
1959  if ( ! b )
1960  return;
1961 
1962  if ( b == yy_current_buffer )
1963  yy_current_buffer = (YY_BUFFER_STATE) 0;
1964 
1965  if ( b->yy_is_our_buffer )
1966  yy_flex_free( (void *) b->yy_ch_buf );
1967 
1968  yy_flex_free( (void *) b );
1969  }
static void yy_flex_free(void *ptr)
Definition: scanner.cc:2278

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 2186 of file scanner.cc.

2191  {
2192  (void) fprintf( stderr, "%s\n", msg );
2193  exit( YY_EXIT_FAILURE );
2194  }
#define YY_EXIT_FAILURE
Definition: scanner.cc:2182

◆ yy_flex_alloc()

static void* yy_flex_alloc ( yy_size_t  size)
static

Definition at line 2250 of file scanner.cc.

2255  {
2256  return (void *) malloc( size );
2257  }
#define malloc
Definition: scanner.cc:590

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 2278 of file scanner.cc.

2283  {
2284  free( ptr );
2285  }
#define free
Definition: scanner.cc:594

◆ yy_flex_realloc()

static void* yy_flex_realloc ( void *  ptr,
yy_size_t  size 
)
static

Definition at line 2260 of file scanner.cc.

2266  {
2267  /* The cast to (char *) in the following accommodates both
2268  * implementations that use char* generic pointers, and those
2269  * that use void* generic pointers. It works with the latter
2270  * because both ANSI C and C++ allow castless assignment from
2271  * any pointer type to void*, and deal with argument conversions
2272  * as though doing an assignment.
2273  */
2274  return (void *) realloc( (char *) ptr, size );
2275  }
#define realloc
Definition: scanner.cc:592

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 2006 of file scanner.cc.

2012  {
2013  if ( ! b )
2014  return;
2015 
2016  b->yy_n_chars = 0;
2017 
2018  /* We always need two end-of-buffer characters. The first causes
2019  * a transition to the end-of-buffer state. The second causes
2020  * a jam in that state.
2021  */
2022  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2023  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2024 
2025  b->yy_buf_pos = &b->yy_ch_buf[0];
2026 
2027  b->yy_at_bol = 1;
2028  b->yy_buffer_status = YY_BUFFER_NEW;
2029 
2030  if ( b == yy_current_buffer )
2032  }
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:95

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( )
static

Definition at line 1550 of file scanner.cc.

1551  {
1552  register char *dest = yy_current_buffer->yy_ch_buf;
1553  register char *source = yytext_ptr;
1554  register int number_to_move, i;
1555  int ret_val;
1556 
1557  if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1559  "fatal flex scanner internal error--end of buffer missed" );
1560 
1561  if ( yy_current_buffer->yy_fill_buffer == 0 )
1562  { /* Don't try to fill the buffer, so this is an EOF. */
1563  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1564  {
1565  /* We matched a single character, the EOB, so
1566  * treat this as a final EOF.
1567  */
1568  return EOB_ACT_END_OF_FILE;
1569  }
1570 
1571  else
1572  {
1573  /* We matched some text prior to the EOB, first
1574  * process it.
1575  */
1576  return EOB_ACT_LAST_MATCH;
1577  }
1578  }
1579 
1580  /* Try to read more data. */
1581 
1582  /* First move last chars to start of buffer. */
1583  number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1584 
1585  for ( i = 0; i < number_to_move; ++i )
1586  *(dest++) = *(source++);
1587 
1588  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1589  /* don't do the read, it's not guaranteed to return an EOF,
1590  * just force an EOF
1591  */
1592  yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1593 
1594  else
1595  {
1596  int num_to_read =
1597  yy_current_buffer->yy_buf_size - number_to_move - 1;
1598 
1599  while ( num_to_read <= 0 )
1600  { /* Not enough room in the buffer - grow it. */
1601 #ifdef YY_USES_REJECT
1603 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1604 #else
1605 
1606  /* just a shorter name for the current buffer */
1607  YY_BUFFER_STATE b = yy_current_buffer;
1608 
1609  int yy_c_buf_p_offset =
1610  (int) (yy_c_buf_p - b->yy_ch_buf);
1611 
1612  if ( b->yy_is_our_buffer )
1613  {
1614  int new_size = b->yy_buf_size * 2;
1615 
1616  if ( new_size <= 0 )
1617  b->yy_buf_size += b->yy_buf_size / 8;
1618  else
1619  b->yy_buf_size *= 2;
1620 
1621  b->yy_ch_buf = (char *)
1622  /* Include room in for 2 EOB chars. */
1623  yy_flex_realloc( (void *) b->yy_ch_buf,
1624  b->yy_buf_size + 2 );
1625  }
1626  else
1627  /* Can't grow it, we don't own it. */
1628  b->yy_ch_buf = 0;
1629 
1630  if ( ! b->yy_ch_buf )
1632  "fatal error - scanner input buffer overflow" );
1633 
1634  yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1635 
1636  num_to_read = yy_current_buffer->yy_buf_size -
1637  number_to_move - 1;
1638 #endif
1639  }
1640 
1641  if ( num_to_read > YY_READ_BUF_SIZE )
1642  num_to_read = YY_READ_BUF_SIZE;
1643 
1644  /* Read in more data. */
1645  YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1646  yy_n_chars, num_to_read );
1647 
1648  yy_current_buffer->yy_n_chars = yy_n_chars;
1649  }
1650 
1651  if ( yy_n_chars == 0 )
1652  {
1653  if ( number_to_move == YY_MORE_ADJ )
1654  {
1655  ret_val = EOB_ACT_END_OF_FILE;
1656  yyrestart( yyin );
1657  }
1658 
1659  else
1660  {
1661  ret_val = EOB_ACT_LAST_MATCH;
1662  yy_current_buffer->yy_buffer_status =
1664  }
1665  }
1666 
1667  else
1668  ret_val = EOB_ACT_CONTINUE_SCAN;
1669 
1670  yy_n_chars += number_to_move;
1673 
1674  yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1675 
1676  return ret_val;
1677  }
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: scanner.cc:2260
#define YY_READ_BUF_SIZE
Definition: scanner.cc:728
#define YY_INPUT(buf, result, max_size)
Definition: scanner.cc:634
void yyrestart(FILE *input_file)
Definition: scanner.cc:1864
#define YY_BUFFER_EOF_PENDING
Definition: scanner.cc:199

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( )
static

Definition at line 1682 of file scanner.cc.

1683  {
1684  register yy_state_type yy_current_state;
1685  register char *yy_cp;
1686 
1687  yy_current_state = yy_start;
1688 
1689  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1690  {
1691  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1692  if ( yy_accept[yy_current_state] )
1693  {
1694  yy_last_accepting_state = yy_current_state;
1696  }
1697  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1698  {
1699  yy_current_state = (int) yy_def[yy_current_state];
1700  if ( yy_current_state >= 171 )
1701  yy_c = yy_meta[(unsigned int) yy_c];
1702  }
1703  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1704  }
1705 
1706  return yy_current_state;
1707  }

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 1979 of file scanner.cc.

1987  {
1988  yy_flush_buffer( b );
1989 
1990  b->yy_input_file = file;
1991  b->yy_fill_buffer = 1;
1992 
1993 #if YY_ALWAYS_INTERACTIVE
1994  b->yy_is_interactive = 1;
1995 #else
1996 #if YY_NEVER_INTERACTIVE
1997  b->yy_is_interactive = 0;
1998 #else
1999  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2000 #endif
2001 #endif
2002  }

◆ yy_load_buffer_state()

void yy_load_buffer_state ( void  )

Definition at line 1909 of file scanner.cc.

1913  {
1914  yy_n_chars = yy_current_buffer->yy_n_chars;
1915  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1916  yyin = yy_current_buffer->yy_input_file;
1918  }

◆ YY_PROTO() [1/15]

YY_BUFFER_STATE yy_scan_buffer YY_PROTO ( (char *base, yy_size_t size )

◆ YY_PROTO() [2/15]

YY_BUFFER_STATE yy_create_buffer YY_PROTO ( (FILE *file, int size )

◆ YY_PROTO() [3/15]

void yyrestart YY_PROTO ( (FILE *input_file)  )

◆ YY_PROTO() [4/15]

static void yyunput YY_PROTO ( (int c, char *buf_ptr)  )
static

◆ YY_PROTO() [5/15]

static void yy_flex_free YY_PROTO ( (void *)  )
static

◆ YY_PROTO() [6/15]

static void* yy_flex_realloc YY_PROTO ( (void *, yy_size_t )
static

◆ YY_PROTO() [7/15]

void yy_load_buffer_state YY_PROTO ( (void)  )

◆ YY_PROTO() [8/15]

void yy_delete_buffer YY_PROTO ( (YY_BUFFER_STATE b )

◆ YY_PROTO() [9/15]

void yy_init_buffer YY_PROTO ( (YY_BUFFER_STATE b, FILE *file)  )

◆ YY_PROTO() [10/15]

void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer)  )

◆ YY_PROTO() [11/15]

static void* yy_flex_alloc YY_PROTO ( (yy_size_t )
static

◆ YY_PROTO() [12/15]

static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  )
static

◆ YY_PROTO() [13/15]

YY_BUFFER_STATE yy_scan_bytes YY_PROTO ( (yyconst char *bytes, int len)  )

◆ YY_PROTO() [14/15]

YY_BUFFER_STATE yy_scan_string YY_PROTO ( (yyconst char *yy_str)  )

◆ YY_PROTO() [15/15]

static void yy_fatal_error YY_PROTO ( (yyconst char msg[])  )
static

◆ yy_scan_buffer()

YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Definition at line 2037 of file scanner.cc.

2043  {
2044  YY_BUFFER_STATE b;
2045 
2046  if ( size < 2 ||
2049  /* They forgot to leave room for the EOB's. */
2050  return 0;
2051 
2052  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2053  if ( ! b )
2054  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2055 
2056  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2057  b->yy_buf_pos = b->yy_ch_buf = base;
2058  b->yy_is_our_buffer = 0;
2059  b->yy_input_file = 0;
2060  b->yy_n_chars = b->yy_buf_size;
2061  b->yy_is_interactive = 0;
2062  b->yy_at_bol = 1;
2063  b->yy_fill_buffer = 0;
2064  b->yy_buffer_status = YY_BUFFER_NEW;
2065 
2067 
2068  return b;
2069  }
char N base
Definition: ValueTraits.h:144

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 2092 of file scanner.cc.

2098  {
2099  YY_BUFFER_STATE b;
2100  char *buf;
2101  yy_size_t n;
2102  int i;
2103 
2104  /* Get memory for full buffer, including space for trailing EOB's. */
2105  n = len + 2;
2106  buf = (char *) yy_flex_alloc( n );
2107  if ( ! buf )
2108  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2109 
2110  for ( i = 0; i < len; ++i )
2111  buf[i] = bytes[i];
2112 
2113  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2114 
2115  b = yy_scan_buffer( buf, n );
2116  if ( ! b )
2117  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2118 
2119  /* It's okay to grow etc. this buffer, and we should throw it
2120  * away when we're done.
2121  */
2122  b->yy_is_our_buffer = 1;
2123 
2124  return b;
2125  }
unsigned int yy_size_t
Definition: libparse.cc:161
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
Definition: scanner.cc:2037
int status int void * buf
Definition: si_signals.h:59

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char *  yy_str)

Definition at line 2075 of file scanner.cc.

2080  {
2081  int len;
2082  for ( len = 0; yy_str[len]; ++len )
2083  ;
2084 
2085  return yy_scan_bytes( yy_str, len );
2086  }
YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, int len)
Definition: scanner.cc:2092

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 1879 of file scanner.cc.

1884  {
1885  if ( yy_current_buffer == new_buffer )
1886  return;
1887 
1888  if ( yy_current_buffer )
1889  {
1890  /* Flush out information for old buffer. */
1892  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1893  yy_current_buffer->yy_n_chars = yy_n_chars;
1894  }
1895 
1896  yy_current_buffer = new_buffer;
1898 
1899  /* We don't actually know whether we did this switch during
1900  * EOF (yywrap()) processing, but the only time this flag
1901  * is looked at is after yywrap() is called, so it's safe
1902  * to go ahead and always set it.
1903  */
1905  }

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 1717 of file scanner.cc.

1722  {
1723  register int yy_is_jam;
1724  register char *yy_cp = yy_c_buf_p;
1725 
1726  register YY_CHAR yy_c = 1;
1727  if ( yy_accept[yy_current_state] )
1728  {
1729  yy_last_accepting_state = yy_current_state;
1731  }
1732  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1733  {
1734  yy_current_state = (int) yy_def[yy_current_state];
1735  if ( yy_current_state >= 171 )
1736  yy_c = yy_meta[(unsigned int) yy_c];
1737  }
1738  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1739  yy_is_jam = (yy_current_state == 170);
1740 
1741  return yy_is_jam ? 0 : yy_current_state;
1742  }

◆ yyinput()

static int yyinput ( )
static

Definition at line 1791 of file scanner.cc.

1795  {
1796  int c;
1797 
1799 
1801  {
1802  /* yy_c_buf_p now points to the character we want to return.
1803  * If this occurs *before* the EOB characters, then it's a
1804  * valid NUL; if not, then we've hit the end of the buffer.
1805  */
1806  if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1807  /* This was really a NUL. */
1808  *yy_c_buf_p = '\0';
1809 
1810  else
1811  { /* need more input */
1812  int offset = yy_c_buf_p - yytext_ptr;
1813  ++yy_c_buf_p;
1814 
1815  switch ( yy_get_next_buffer() )
1816  {
1817  case EOB_ACT_LAST_MATCH:
1818  /* This happens because yy_g_n_b()
1819  * sees that we've accumulated a
1820  * token and flags that we need to
1821  * try matching the token before
1822  * proceeding. But for input(),
1823  * there's no matching to consider.
1824  * So convert the EOB_ACT_LAST_MATCH
1825  * to EOB_ACT_END_OF_FILE.
1826  */
1827 
1828  /* Reset buffer status. */
1829  yyrestart( yyin );
1830 
1831  /* fall through */
1832 
1833  case EOB_ACT_END_OF_FILE:
1834  {
1835  if ( yywrap() )
1836  return EOF;
1837 
1839  YY_NEW_FILE;
1840 #ifdef __cplusplus
1841  return yyinput();
1842 #else
1843  return input();
1844 #endif
1845  }
1846 
1847  case EOB_ACT_CONTINUE_SCAN:
1849  break;
1850  }
1851  }
1852  }
1853 
1854  c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1855  *yy_c_buf_p = '\0'; /* preserve yytext */
1856  yy_hold_char = *++yy_c_buf_p;
1857 
1858 
1859  return c;
1860  }

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 1864 of file scanner.cc.

1869  {
1870  if ( ! yy_current_buffer )
1872 
1873  yy_init_buffer( yy_current_buffer, input_file );
1875  }

◆ yyunput()

static void yyunput ( int  c,
register char *  yy_bp 
)
static

Definition at line 1747 of file scanner.cc.

1753  {
1754  register char *yy_cp = yy_c_buf_p;
1755 
1756  /* undo effects of setting up yytext */
1757  *yy_cp = yy_hold_char;
1758 
1759  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1760  { /* need to shift things up to make room */
1761  /* +2 for EOB chars. */
1762  register int number_to_move = yy_n_chars + 2;
1763  register char *dest = &yy_current_buffer->yy_ch_buf[
1764  yy_current_buffer->yy_buf_size + 2];
1765  register char *source =
1766  &yy_current_buffer->yy_ch_buf[number_to_move];
1767 
1768  while ( source > yy_current_buffer->yy_ch_buf )
1769  *--dest = *--source;
1770 
1771  yy_cp += (int) (dest - source);
1772  yy_bp += (int) (dest - source);
1773  yy_current_buffer->yy_n_chars =
1774  yy_n_chars = yy_current_buffer->yy_buf_size;
1775 
1776  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1777  YY_FATAL_ERROR( "flex scanner push-back overflow" );
1778  }
1779 
1780  *--yy_cp = (char) c;
1781 
1782 
1783  yytext_ptr = yy_bp;
1784  yy_hold_char = *yy_cp;
1785  yy_c_buf_p = yy_cp;
1786  }

◆ yywrap()

int yywrap ( )

Definition at line 630 of file scanner.cc.

630 { return exitVoice(); }
BOOLEAN exitVoice()
Definition: fevoices.cc:341

Variable Documentation

◆ blocknest

VAR int blocknest = 0

Definition at line 582 of file scanner.cc.

◆ inerror

EXTERN_VAR int inerror

Definition at line 586 of file scanner.cc.

◆ yy_accept

yyconst short int yy_accept[171]
static
Initial value:
=
{ 0,
0, 0, 0, 0, 30, 30, 0, 0, 0, 0,
0, 0, 20, 20, 0, 0, 67, 65, 40, 40,
50, 34, 64, 59, 65, 64, 65, 65, 65, 65,
65, 57, 65, 65, 65, 65, 6, 55, 64, 64,
64, 64, 64, 64, 64, 64, 24, 65, 35, 36,
39, 36, 30, 25, 30, 32, 33, 26, 29, 26,
13, 11, 12, 15, 14, 17, 16, 21, 20, 21,
18, 23, 19, 9, 66, 10, 51, 2, 46, 64,
64, 64, 53, 44, 43, 54, 41, 61, 3, 1,
61, 0, 0, 57, 42, 48, 52, 45, 49, 6,
64, 64, 64, 64, 64, 64, 64, 47, 38, 37,
30, 30, 28, 27, 21, 20, 21, 0, 21, 9,
2, 0, 1, 61, 63, 61, 63, 58, 64, 64,
5, 64, 64, 64, 64, 64, 30, 31, 22, 0,
0, 0, 64, 64, 6, 64, 64, 64, 61, 62,
0, 64, 0, 60, 64, 0, 4, 64, 64, 0,
0, 7, 56, 0, 0, 8, 0, 0, 7, 0
}

Definition at line 289 of file scanner.cc.

◆ yy_act

register int yy_act

Definition at line 806 of file scanner.cc.

◆ yy_base

yyconst short int yy_base[192]
static
Initial value:
=
{ 0,
0, 0, 43, 44, 45, 46, 47, 48, 50, 54,
295, 294, 74, 92, 75, 76, 296, 561, 561, 561,
269, 561, 271, 561, 254, 40, 230, 227, 84, 38,
69, 92, 197, 60, 181, 177, 99, 561, 561, 86,
87, 93, 98, 99, 100, 102, 561, 136, 561, 561,
561, 62, 0, 561, 158, 561, 561, 561, 561, 109,
561, 561, 561, 561, 561, 561, 561, 0, 129, 134,
561, 561, 561, 0, 561, 561, 561, 0, 561, 114,
124, 125, 561, 561, 561, 561, 561, 128, 561, 0,
136, 129, 149, 143, 561, 561, 561, 561, 561, 154,
144, 146, 147, 148, 151, 136, 151, 561, 561, 561,
0, 177, 561, 561, 0, 187, 190, 144, 0, 0,
0, 171, 0, 180, 561, 176, 193, 193, 180, 186,
188, 190, 192, 201, 203, 204, 236, 0, 561, 119,
103, 97, 207, 244, 246, 222, 231, 223, 80, 39,
243, 224, 266, 561, 238, 252, 242, 252, 256, 286,
70, 288, 245, 192, 291, 561, 292, 293, 296, 561,
320, 332, 344, 356, 368, 380, 392, 400, 408, 418,
430, 442, 454, 466, 478, 490, 502, 514, 526, 537,
548
}

Definition at line 352 of file scanner.cc.

◆ yy_bp

register char * yy_bp

Definition at line 805 of file scanner.cc.

◆ yy_c_buf_p

STATIC_VAR char* yy_c_buf_p = (char *) 0

Definition at line 220 of file scanner.cc.

◆ yy_chk

yyconst short int yy_chk[610]
static

Definition at line 475 of file scanner.cc.

◆ yy_cp

register char* yy_cp

Definition at line 805 of file scanner.cc.

◆ yy_current_buffer

STATIC_VAR YY_BUFFER_STATE yy_current_buffer = 0

Definition at line 202 of file scanner.cc.

◆ YY_DECL

YY_DECL
Initial value:
{
register yy_state_type yy_current_state

Definition at line 802 of file scanner.cc.

◆ yy_def

yyconst short int yy_def[192]
static
Initial value:
=
{ 0,
170, 1, 171, 171, 172, 172, 173, 173, 174, 174,
175, 175, 176, 176, 177, 177, 170, 170, 170, 170,
170, 170, 170, 170, 170, 178, 170, 170, 170, 170,
170, 179, 170, 170, 170, 170, 170, 170, 170, 178,
178, 178, 178, 178, 178, 178, 170, 170, 170, 170,
170, 170, 180, 170, 180, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 181, 170, 182,
170, 170, 170, 183, 170, 170, 170, 184, 170, 178,
178, 178, 170, 170, 170, 170, 170, 170, 170, 185,
179, 186, 170, 179, 170, 170, 170, 170, 170, 170,
178, 178, 178, 178, 178, 101, 101, 170, 170, 170,
180, 187, 170, 170, 181, 170, 182, 188, 181, 183,
184, 170, 185, 179, 170, 170, 170, 179, 101, 101,
101, 101, 101, 101, 101, 101, 187, 189, 170, 170,
170, 170, 101, 101, 144, 101, 101, 101, 170, 170,
179, 101, 170, 170, 101, 190, 101, 101, 101, 191,
170, 144, 101, 170, 191, 170, 191, 191, 170, 0,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170
}

Definition at line 378 of file scanner.cc.

◆ yy_did_buffer_switch_on_eof

STATIC_VAR int yy_did_buffer_switch_on_eof

Definition at line 227 of file scanner.cc.

◆ yy_ec

yyconst int yy_ec[256]
static

Definition at line 311 of file scanner.cc.

◆ yy_hold_char

STATIC_VAR char yy_hold_char

Definition at line 212 of file scanner.cc.

◆ yy_init

STATIC_VAR int yy_init = 1

Definition at line 221 of file scanner.cc.

◆ yy_last_accepting_cpos

STATIC_VAR char* yy_last_accepting_cpos

Definition at line 547 of file scanner.cc.

◆ yy_last_accepting_state

STATIC_VAR yy_state_type yy_last_accepting_state

Definition at line 546 of file scanner.cc.

◆ yy_meta

yyconst int yy_meta[49]
static
Initial value:
=
{ 0,
1, 2, 3, 1, 1, 4, 1, 1, 1, 5,
6, 7, 1, 1, 7, 1, 8, 9, 10, 1,
11, 1, 1, 1, 1, 1, 12, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 4, 1, 4, 1
}

Definition at line 343 of file scanner.cc.

◆ yy_more_flag

STATIC_VAR int yy_more_flag = 0

Definition at line 553 of file scanner.cc.

◆ yy_more_len

STATIC_VAR int yy_more_len = 0

Definition at line 554 of file scanner.cc.

◆ yy_n_chars

STATIC_VAR int yy_n_chars

Definition at line 214 of file scanner.cc.

◆ yy_nxt

yyconst short int yy_nxt[610]
static

Definition at line 404 of file scanner.cc.

◆ yy_start

STATIC_VAR int yy_start = 0

Definition at line 222 of file scanner.cc.

◆ yyin

VAR FILE* yyin = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yyleng

EXTERN_VAR int yyleng

Definition at line 102 of file scanner.cc.

◆ yyout

VAR FILE * yyout = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yytext

EXTERN_VAR char* yytext

Definition at line 268 of file scanner.cc.