Data Structures | Macros | Typedefs | Functions | Variables
scanner.cc File Reference
#include <stdio.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   my_malloc
 
#define realloc   my_realloc
 
#define free   my_free
 
#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
 
#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 void * my_malloc (size_t size)
 
static void * my_realloc (void *addr, size_t size)
 
static void my_free (void *addr)
 
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

int yyleng
 
FILE * yyin = (FILE *) 0
 
FILE * yyout = (FILE *) 0
 
static YY_BUFFER_STATE yy_current_buffer = 0
 
static char yy_hold_char
 
static int yy_n_chars
 
static char * yy_c_buf_p = (char *) 0
 
static int yy_init = 1
 
static int yy_start = 0
 
static int yy_did_buffer_switch_on_eof
 
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 yy_state_type yy_last_accepting_state
 
static char * yy_last_accepting_cpos
 
static int yy_more_flag = 0
 
static int yy_more_len = 0
 
int blocknest = 0
 
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 162 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 578 of file scanner.cc.

◆ asstring

#define asstring   7

Definition at line 672 of file scanner.cc.

◆ BEGIN

#define BEGIN   yy_start = 1 + 2 *

Definition at line 79 of file scanner.cc.

◆ block

#define block   2

Definition at line 662 of file scanner.cc.

◆ blockstr

#define blockstr   3

Definition at line 664 of file scanner.cc.

◆ brace

#define brace   4

Definition at line 666 of file scanner.cc.

◆ bracestr

#define bracestr   5

Definition at line 668 of file scanner.cc.

◆ bracket

#define bracket   6

Definition at line 670 of file scanner.cc.

◆ ECHO

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

Definition at line 753 of file scanner.cc.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 104 of file scanner.cc.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 105 of file scanner.cc.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 106 of file scanner.cc.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 7 of file scanner.cc.

◆ free

#define free   my_free

Definition at line 612 of file scanner.cc.

◆ INITIAL

#define INITIAL   0

Definition at line 559 of file scanner.cc.

◆ malloc

#define malloc   my_malloc

Definition at line 608 of file scanner.cc.

◆ realloc

#define realloc   my_realloc

Definition at line 610 of file scanner.cc.

◆ REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 551 of file scanner.cc.

◆ string

#define string   1

Definition at line 660 of file scanner.cc.

◆ unput

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

Definition at line 135 of file scanner.cc.

◆ YY_ALWAYS_INTERACTIVE

#define YY_ALWAYS_INTERACTIVE   1

Definition at line 659 of file scanner.cc.

◆ YY_AT_BOL

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 262 of file scanner.cc.

◆ YY_BREAK

#define YY_BREAK   break;

Definition at line 812 of file scanner.cc.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 97 of file scanner.cc.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 198 of file scanner.cc.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 186 of file scanner.cc.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 187 of file scanner.cc.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 207 of file scanner.cc.

◆ YY_DECL

#define YY_DECL   int yylex(YYSTYPE* lvalp)

Definition at line 642 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:824
static int yy_more_len
Definition: scanner.cc:553
#define yytext_ptr
Definition: scanner.cc:268
register char * yy_cp
Definition: scanner.cc:824

Definition at line 278 of file scanner.cc.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   67

Definition at line 287 of file scanner.cc.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 94 of file scanner.cc.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 2204 of file scanner.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 793 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 236 of file scanner.cc.

◆ YY_INPUT

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

Definition at line 650 of file scanner.cc.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ   yy_more_len

Definition at line 555 of file scanner.cc.

◆ yy_new_buffer

#define yy_new_buffer   yy_create_buffer

Definition at line 246 of file scanner.cc.

◆ YY_NEW_FILE

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 92 of file scanner.cc.

◆ YY_NO_POP_STATE

#define YY_NO_POP_STATE   1

Definition at line 723 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 722 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 724 of file scanner.cc.

◆ YY_NULL

#define YY_NULL   0

Definition at line 66 of file scanner.cc.

◆ YY_NUM_RULES

#define YY_NUM_RULES   66

Definition at line 286 of file scanner.cc.

◆ YY_PROTO

#define YY_PROTO (   proto)    proto

Definition at line 60 of file scanner.cc.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 744 of file scanner.cc.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 556 of file scanner.cc.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP
Value:
if ( yyleng > 0 ) \
yy_current_buffer->yy_at_bol = \
(yytext[yyleng - 1] == '\n'); \
YY_USER_ACTION
int yyleng
Definition: scanner.cc:216
char * yytext
Definition: scanner.cc:557

Definition at line 815 of file scanner.cc.

◆ YY_SC_TO_UI

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

Definition at line 73 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:1944
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
#define YY_BUF_SIZE
Definition: scanner.cc:97
FILE * yyin
Definition: scanner.cc:265

Definition at line 255 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; \
}
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1944
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
#define YY_BUF_SIZE
Definition: scanner.cc:97
FILE * yyin
Definition: scanner.cc:265

Definition at line 248 of file scanner.cc.

◆ YY_START

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

Definition at line 85 of file scanner.cc.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 788 of file scanner.cc.

◆ YY_STATE_EOF

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

Definition at line 89 of file scanner.cc.

◆ YY_USE_CONST

#define YY_USE_CONST

Definition at line 31 of file scanner.cc.

◆ YY_USE_PROTOS

#define YY_USE_PROTOS

Definition at line 28 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:83
int inerror
Definition: grammar.cc:175
char * yytext
Definition: scanner.cc:557

Definition at line 654 of file scanner.cc.

◆ yyconst

#define yyconst   const

Definition at line 53 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 )
register char * yy_bp
Definition: scanner.cc:824
static char yy_hold_char
Definition: scanner.cc:211
#define YY_MORE_ADJ
Definition: scanner.cc:555
register char * yy_cp
Definition: scanner.cc:824

Definition at line 2223 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 )
static char yy_hold_char
Definition: scanner.cc:211
int yyleng
Definition: scanner.cc:216
static char * yy_c_buf_p
Definition: scanner.cc:219
char * yytext
Definition: scanner.cc:557

Definition at line 2223 of file scanner.cc.

◆ yymore

#define yymore ( )    (yy_more_flag = 1)

Definition at line 554 of file scanner.cc.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 86 of file scanner.cc.

◆ yyterminate

#define yyterminate ( )    return YY_NULL

Definition at line 783 of file scanner.cc.

◆ yytext_ptr

#define yytext_ptr   yytext

Definition at line 268 of file scanner.cc.

Typedef Documentation

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 264 of file scanner.cc.

◆ yy_size_t

typedef unsigned int yy_size_t

Definition at line 141 of file scanner.cc.

◆ yy_state_type

typedef int yy_state_type

Definition at line 266 of file scanner.cc.

Function Documentation

◆ dupyytext()

static char* dupyytext ( )
static

Definition at line 613 of file scanner.cc.

614 {
615  char* s;
616  if (yyleng>0) yytext[yyleng-1] = '\0';
617  s = omStrDup((char *)yytext);
619  return s;
620 }
const CanonicalForm int s
Definition: facAbsFact.cc:55
int yyleng
Definition: scanner.cc:216
void omMarkAsStaticAddr(void *addr)
char * yytext
Definition: scanner.cc:557
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ dupyytextNL()

static char* dupyytextNL ( )
static

Definition at line 622 of file scanner.cc.

623 {
624  int i = yyleng;//strlen((char *)yytext);
625  char * rc = (char*)omAlloc( 3 + i );
626  omMarkAsStaticAddr(rc);
627  if (i>0)
628  {
629  strncpy( rc, (char *)yytext, i-1 );
630  }
631  else
632  {
633  i++;
634  }
635  rc[i-1] = '\n';
636  rc[i] = '\n';
637  rc[i+1] = '\0';
638  return rc;
639 }
#define omAlloc(size)
Definition: omAllocDecl.h:210
int yyleng
Definition: scanner.cc:216
int i
Definition: cfEzgcd.cc:123
void omMarkAsStaticAddr(void *addr)
char * yytext
Definition: scanner.cc:557

◆ feReadLine()

int feReadLine ( char *  b,
int  l 
)

Definition at line 499 of file fevoices.cc.

500 {
501  char *s=NULL;
502  int offset = 0; /* will not be used if s==NULL*/
503  // try to read from the buffer into b, max l chars
504  if (currentVoice!=NULL)
505  {
506  if((currentVoice->buffer!=NULL)
507  && (currentVoice->buffer[currentVoice->fptr]!='\0'))
508  {
509  NewBuff:
510  register int i=0;
511  long startfptr=currentVoice->fptr;
512  long tmp_ptr=currentVoice->fptr;
513  l--;
514  loop
515  {
516  register char c=
517  b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
518  i++;
519  if (yy_noeof==noeof_block)
520  {
521  if (c<' ') yylineno++;
522  else if (c=='}') break;
523  }
524  else
525  {
526  if ((c<' ') ||
527  (c==';') ||
528  (c==')')
529  )
530  break;
531  }
532  if (i>=l) break;
533  tmp_ptr++;/*currentVoice->fptr++;*/
534  if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
535  }
536  currentVoice->fptr=tmp_ptr;
537  b[i]='\0';
538  if (currentVoice->sw==BI_buffer)
539  {
540  if (startfptr==0)
541  {
542  char *anf=currentVoice->buffer;
543  const char *ss=strchr(anf,'\n');
544  long len;
545  if (ss==NULL) len=strlen(anf);
546  else len=ss-anf;
547  char *s=(char *)omAlloc(len+2);
548  strncpy(s,anf,len+2);
549  s[len+1]='\0';
550  fePrintEcho(s,b);
551  omFree((ADDRESS)s);
552  }
553  else if (/*(startfptr>0) &&*/
554  (currentVoice->buffer[startfptr-1]=='\n'))
555  {
556  char *anf=currentVoice->buffer+startfptr;
557  const char *ss=strchr(anf,'\n');
558  long len;
559  if (ss==NULL) len=strlen(anf);
560  else len=ss-anf;
561  char *s=(char *)omAlloc(len+2);
562  strncpy(s,anf,len+2);
563  s[len+1]='\0';
564  yylineno++;
565  fePrintEcho(s,b);
566  omFree((ADDRESS)s);
567  }
568  }
569  currentVoice->fptr++;
570  return i;
571  }
572  // no buffer there or e-o-buffer or eoln:
573  if (currentVoice->sw!=BI_buffer)
574  {
575  currentVoice->fptr=0;
576  if (currentVoice->buffer==NULL)
577  {
580  }
581  }
582  offset=0;
583  NewRead:
584  yylineno++;
585  if (currentVoice->sw==BI_stdin)
586  {
587  feShowPrompt();
589  &(currentVoice->buffer[offset]),
590  omSizeOfAddr(currentVoice->buffer)-1-offset);
591  //int i=0;
592  //if (s!=NULL)
593  // while((s[i]!='\0') /*&& (i<MAX_FILE_BUFFER)*/) {s[i] &= (char)127;i++;}
594  }
595  else if (currentVoice->sw==BI_file)
596  {
598  s=fgets(currentVoice->buffer+offset,(MAX_FILE_BUFFER-1-sizeof(ADDRESS))-offset,
600  if (s!=NULL)
601  {
603  // ftell returns -1 for non-seekable streams, such as pipes
604  if (currentVoice->ftellptr<0)
606  }
607  }
608  //else /* BI_buffer */ s==NULL => return 0
609  // done by the default return
610  }
611  if (s!=NULL)
612  {
613  // handle prot:
614  if (feProt&SI_PROT_I)
615  {
616  fputs(s,feProtFile);
617  }
618  int rc=fePrintEcho(s,b)+1;
619  //s[strlen(s)+1]='\0'; add an second \0 at the end of the string
620  s[rc]='\0';
621  // handel \\ :
622  rc-=3;
623  if ((s[rc]=='\\')&&(currentVoice->sw!=BI_buffer))
624  {
625  s[rc]='\0';
626  offset+=rc;
627  if (offset<(int)omSizeOfAddr(currentVoice->buffer)) goto NewRead;
628  }
629  goto NewBuff;
630  }
631  /* else if (s==NULL) */
632  {
633  const char *err;
634  switch(yy_noeof)
635  {
636  case noeof_brace:
637  case noeof_block:
638  err="{...}";
639  break;
640  case noeof_asstring:
641  err="till `.`";
642  break;
643  case noeof_string:
644  err="string";
645  break;
646  case noeof_bracket:
647  err="(...)";
648  break;
649  case noeof_procname:
650  err="proc";
651  break;
652  case noeof_comment:
653  err="/*...*/";
654  break;
655  default:
656  return 0;
657  }
658  Werror("premature end of file while reading %s",err);
659  return 0;
660  }
661 }
char fe_promptstr[]
Definition: fevoices.cc:37
long fptr
Definition: fevoices.h:70
FILE * feProtFile
Definition: reporter.cc:57
int yy_noeof
Definition: fevoices.cc:55
const CanonicalForm int s
Definition: facAbsFact.cc:55
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:34
int yylineno
Definition: febase.cc:45
char * buffer
Definition: fevoices.h:69
static void feShowPrompt(void)
Definition: fevoices.cc:415
loop
Definition: myNF.cc:98
size_t omSizeOfAddr(const void *addr)
void * ADDRESS
Definition: auxiliary.h:115
#define omAlloc(size)
Definition: omAllocDecl.h:210
int feProt
Definition: reporter.cc:56
#define SI_PROT_I
Definition: reporter.h:52
#define omFree(addr)
Definition: omAllocDecl.h:261
static int fePrintEcho(char *anf, char *)
Definition: fevoices.cc:423
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
#define MAX_FILE_BUFFER
Definition: fevoices.cc:45
Voice * currentVoice
Definition: fevoices.cc:57
FILE * files
Definition: fevoices.h:67
void omMarkAsStaticAddr(void *addr)
#define SEEK_SET
Definition: mod2.h:114
feBufferInputs sw
Definition: fevoices.h:76
long ftellptr
Definition: fevoices.h:71
int offset
Definition: libparse.cc:1091
const poly b
Definition: syzextra.cc:213
void Werror(const char *fmt,...)
Definition: reporter.cc:189
int l
Definition: cfEzgcd.cc:94

◆ if()

if ( yy_init  )

Definition at line 830 of file scanner.cc.

831  {
832  yy_init = 0;
833 
834 #ifdef YY_USER_INIT
835  YY_USER_INIT;
836 #endif
837 
838  if ( ! yy_start )
839  yy_start = 1; /* first start state */
840 
841  if ( ! yyin )
842  yyin = stdin;
843 
844  if ( ! yyout )
845  yyout = stdout;
846 
847  if ( ! yy_current_buffer )
850 
852  }
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1944
void yy_load_buffer_state(void)
Definition: scanner.cc:1931
static int yy_init
Definition: scanner.cc:220
static int yy_start
Definition: scanner.cc:221
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
#define YY_BUF_SIZE
Definition: scanner.cc:97
FILE * yyout
Definition: scanner.cc:265
FILE * yyin
Definition: scanner.cc:265
#define YY_USER_INIT
Definition: libparse.cc:1208

◆ my_free()

static void my_free ( void *  addr)
static

Definition at line 603 of file scanner.cc.

604 {
605  omFree(addr);
606 }
#define omFree(addr)
Definition: omAllocDecl.h:261

◆ my_malloc()

static void* my_malloc ( size_t  size)
static

Definition at line 590 of file scanner.cc.

591 {
592  void* addr = omAlloc(size);
593  omMarkAsStaticAddr(addr);
594  return addr;
595 }
#define omAlloc(size)
Definition: omAllocDecl.h:210
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
void omMarkAsStaticAddr(void *addr)

◆ my_realloc()

static void* my_realloc ( void *  addr,
size_t  size 
)
static

Definition at line 597 of file scanner.cc.

598 {
599  void* new_addr = omRealloc(addr, size);
600  omMarkAsStaticAddr(new_addr);
601  return new_addr;
602 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
void omMarkAsStaticAddr(void *addr)
#define omRealloc(addr, size)
Definition: omAllocDecl.h:225

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2340 of file scanner.cc.

2340 { YY_FLUSH_BUFFER;BEGIN(0); }
#define YY_FLUSH_BUFFER
Definition: scanner.cc:236
#define BEGIN
Definition: scanner.cc:79

◆ myychangebuffer()

void myychangebuffer ( )

Definition at line 2333 of file scanner.cc.

2334 {
2335  yy_flush_buffer((YY_BUFFER_STATE)YY_CURRENT_BUFFER);
2338 }
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1944
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1901
#define YY_CURRENT_BUFFER
Definition: scanner.cc:207
void yy_delete_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:1975
#define YY_BUF_SIZE
Definition: scanner.cc:97
#define NULL
Definition: omList.c:10
void yy_flush_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:2028

◆ myynewbuffer()

void* myynewbuffer ( )

Definition at line 2319 of file scanner.cc.

2320 {
2321  void * oldb = YY_CURRENT_BUFFER;
2323  return oldb;
2324 }
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1944
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1901
#define YY_CURRENT_BUFFER
Definition: scanner.cc:207
#define YY_BUF_SIZE
Definition: scanner.cc:97
#define NULL
Definition: omList.c:10

◆ myyoldbuffer()

void myyoldbuffer ( void *  oldb)

Definition at line 2326 of file scanner.cc.

2327 {
2329  yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
2330  //yy_flush_buffer((YY_BUFFER_STATE)oldb);
2331 }
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1901
#define YY_CURRENT_BUFFER
Definition: scanner.cc:207
void yy_delete_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:1975

◆ while()

while ( )

Definition at line 854 of file scanner.cc.

855  {
856  yy_more_len = 0;
857  if ( yy_more_flag )
858  {
860  yy_more_flag = 0;
861  }
862  yy_cp = yy_c_buf_p;
863 
864  /* Support of yytext. */
865  *yy_cp = yy_hold_char;
866 
867  /* yy_bp points to the position in yy_ch_buf of the start of
868  * the current run.
869  */
870  yy_bp = yy_cp;
871 
872  yy_current_state = yy_start;
873  yy_current_state += YY_AT_BOL();
874 yy_match:
875  do
876  {
877  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
878  if ( yy_accept[yy_current_state] )
879  {
880  yy_last_accepting_state = yy_current_state;
882  }
883  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
884  {
885  yy_current_state = (int) yy_def[yy_current_state];
886  if ( yy_current_state >= 171 )
887  yy_c = yy_meta[(unsigned int) yy_c];
888  }
889  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
890  ++yy_cp;
891  }
892  while ( yy_base[yy_current_state] != 561 );
893 
894 yy_find_action:
895  yy_act = yy_accept[yy_current_state];
896  if ( yy_act == 0 )
897  { /* have to back up */
899  yy_current_state = yy_last_accepting_state;
900  yy_act = yy_accept[yy_current_state];
901  }
902 
904 
905 
906 do_action: /* This label is used only to access EOF actions. */
907 
908 
909  switch ( yy_act )
910  { /* beginning of action switch */
911  case 0: /* must back up */
912  /* undo the effects of YY_DO_BEFORE_ACTION */
913  *yy_cp = yy_hold_char;
915  yy_current_state = yy_last_accepting_state;
916  goto yy_find_action;
917 
918 case 1:
920 #line 122 "scanner.l"
921 { }
922  YY_BREAK
923 case 2:
925 #line 123 "scanner.l"
926 { }
927  YY_BREAK
928 case 3:
930 #line 124 "scanner.l"
931 {
933  loop
934  {
935  register int c;
936  while ( (c = yyinput()) != '*' && c != EOF );
937  if ( c == '*' )
938  {
939  while ( (c = yyinput()) == '*' );
940  if ( c == '/' ) break; /* found the end */
941  }
942  else
943  {
944  break;
945  }
946  }
947  yy_noeof=0;
948  }
949  YY_BREAK
950 case 4:
952 #line 142 "scanner.l"
953 { prompt_char='.';
955  return WHILE_CMD;}
956  YY_BREAK
957 case 5:
959 #line 145 "scanner.l"
960 { prompt_char='.';
962  return FOR_CMD;}
963  YY_BREAK
964 case 6:
966 #line 149 "scanner.l"
968  BEGIN(asstring);
969  return HELP_CMD;
970  }
971  YY_BREAK
972 case 7:
974 #line 154 "scanner.l"
976  BEGIN(asstring);
977  return EXAMPLE_CMD;
978  }
979  YY_BREAK
980 case 8:
982 #line 159 "scanner.l"
983 {
984  char c; char *cp;
985  lvalp->name = omStrDup(iiProcName((char *)yytext,c,cp));
987  blocknest = 1;
988  BEGIN(brace);
989  return PROC_DEF;
990  }
991  YY_BREAK
992 case 9:
994 #line 167 "scanner.l"
995 {
996  lvalp->name = omStrDup((char *)yytext);
997  yy_noeof = 0; BEGIN(INITIAL);
998  return STRINGTOK;
999  }
1000  YY_BREAK
1001 case 10:
1003 #line 172 "scanner.l"
1004 {
1005  yy_noeof = 0; BEGIN(INITIAL);
1006  return *yytext;
1007  }
1008  YY_BREAK
1009 case 11:
1011 #line 177 "scanner.l"
1012 {
1014  BEGIN(bracestr);
1015  yymore();
1016  }
1017  YY_BREAK
1018 case 12:
1020 #line 182 "scanner.l"
1021 { if (blocknest++) yymore(); }
1022  YY_BREAK
1023 case 13:
1025 #line 183 "scanner.l"
1026 { if (blocknest) yymore(); }
1027  YY_BREAK
1028 case 14:
1030 #line 184 "scanner.l"
1031 {
1032  if (blocknest)
1033  {
1034  lvalp->name = dupyytext();
1035  return STRINGTOK;
1036  }
1037  }
1038  YY_BREAK
1039 case 15:
1041 #line 191 "scanner.l"
1042 {
1043  if (--blocknest <= 0)
1044  {
1045  yy_noeof = 0;
1046  BEGIN(INITIAL);
1047  lvalp->name = dupyytext();
1048  return STRINGTOK;
1049  }
1050  yymore();
1051  }
1052  YY_BREAK
1053 case 16:
1055 #line 201 "scanner.l"
1056 {
1058  BEGIN(brace);
1059  yymore();
1060  }
1061  YY_BREAK
1062 case 17:
1064 #line 206 "scanner.l"
1065 { yymore(); }
1066  YY_BREAK
1067 case 18:
1069 #line 207 "scanner.l"
1070 { return '('; }
1071  YY_BREAK
1072 case 19:
1074 #line 208 "scanner.l"
1075 { return ','; }
1076  YY_BREAK
1077 case 20:
1079 #line 209 "scanner.l"
1080 { ; }
1081  YY_BREAK
1082 case 21:
1084 #line 210 "scanner.l"
1085 {
1086  lvalp->name = omStrDup((char *)yytext);
1087  return STRINGTOK;
1088  }
1089  YY_BREAK
1090 case 22:
1092 #line 214 "scanner.l"
1093 {
1094  lvalp->name = omStrDup((char *)yytext);
1095  return STRINGTOK;
1096  }
1097  YY_BREAK
1098 case 23:
1100 #line 218 "scanner.l"
1101 {
1102  yy_noeof = 0; BEGIN(INITIAL);
1103  return ')';
1104  }
1105  YY_BREAK
1106 case 24:
1108 #line 223 "scanner.l"
1109 {
1111  blocknest = 1;
1113  BEGIN(block);
1114  }
1115  YY_BREAK
1116 case 25:
1118 #line 229 "scanner.l"
1119 {
1121  BEGIN(blockstr);
1122  yymore();
1123  }
1124  YY_BREAK
1125 case 26:
1127 #line 234 "scanner.l"
1128 { yymore(); }
1129  YY_BREAK
1130 case 27:
1132 #line 235 "scanner.l"
1133 { yymore(); }
1134  YY_BREAK
1135 case 28:
1137 #line 236 "scanner.l"
1138 { yymore(); }
1139  YY_BREAK
1140 case 29:
1142 #line 237 "scanner.l"
1143 {
1145  BEGIN(block);
1146  yymore();
1147  }
1148  YY_BREAK
1149 case 30:
1151 #line 242 "scanner.l"
1152 { yymore(); }
1153  YY_BREAK
1154 case 31:
1156 #line 243 "scanner.l"
1157 { yymore(); }
1158  YY_BREAK
1159 case 32:
1161 #line 244 "scanner.l"
1162 { blocknest++; yymore(); }
1163  YY_BREAK
1164 case 33:
1166 #line 245 "scanner.l"
1167 {
1168  if (--blocknest <= 0)
1169  {
1170  BEGIN(INITIAL);
1171  yy_noeof = 0;
1172  lvalp->name = dupyytextNL();
1173  return BLOCKTOK;
1174  }
1175  yymore();
1176  }
1177  YY_BREAK
1178 case 34:
1180 #line 255 "scanner.l"
1181 { BEGIN(string); yy_noeof = noeof_string;}
1182  YY_BREAK
1183 case 35:
1185 #line 256 "scanner.l"
1186 { return SYS_BREAK; }
1187  YY_BREAK
1188 case 36:
1190 #line 257 "scanner.l"
1191 { yymore(); }
1192  YY_BREAK
1193 case 37:
1195 #line 258 "scanner.l"
1196 { yymore(); }
1197  YY_BREAK
1198 case 38:
1200 #line 259 "scanner.l"
1201 { yymore(); }
1202  YY_BREAK
1203 case 39:
1205 #line 260 "scanner.l"
1206 {
1207  char * s;
1208  yy_noeof = 0;
1209  BEGIN(INITIAL);
1210  s = lvalp->name = dupyytext();
1211  while (*yytext)
1212  {
1213  if (*yytext == '\\') yytext++;
1214  *s++ = *yytext++;
1215  }
1216  *s++ = *yytext++;
1217  return STRINGTOK;
1218  }
1219  YY_BREAK
1220 case 40:
1222 #line 274 "scanner.l"
1223 /* skip whitespace */
1224  YY_BREAK
1225 case 41:
1227 #line 275 "scanner.l"
1228 { return DOTDOT; }
1229  YY_BREAK
1230 case 42:
1232 #line 276 "scanner.l"
1233 { return COLONCOLON; }
1234  YY_BREAK
1235 case 43:
1237 #line 277 "scanner.l"
1238 { return MINUSMINUS; }
1239  YY_BREAK
1240 case 44:
1242 #line 278 "scanner.l"
1243 { return PLUSPLUS ; }
1244  YY_BREAK
1245 case 45:
1247 #line 279 "scanner.l"
1248 { return EQUAL_EQUAL; }
1249  YY_BREAK
1250 case 46:
1252 #line 280 "scanner.l"
1253 { lvalp->i='&'; return LOGIC_OP; }
1254  YY_BREAK
1255 case 47:
1257 #line 281 "scanner.l"
1258 { lvalp->i='|'; return LOGIC_OP; }
1259  YY_BREAK
1260 case 48:
1262 #line 282 "scanner.l"
1263 { lvalp->i=LE; return COMP_OP; }
1264  YY_BREAK
1265 case 49:
1267 #line 283 "scanner.l"
1268 { lvalp->i=GE; return COMP_OP; }
1269  YY_BREAK
1270 case 50:
1272 #line 284 "scanner.l"
1273 { return NOT; }
1274  YY_BREAK
1275 case 51:
1277 #line 285 "scanner.l"
1278 { return NOTEQUAL; }
1279  YY_BREAK
1280 case 52:
1282 #line 286 "scanner.l"
1283 { return NOTEQUAL; }
1284  YY_BREAK
1285 case 53:
1287 #line 287 "scanner.l"
1288 { return '^'; }
1289  YY_BREAK
1290 case 54:
1292 #line 288 "scanner.l"
1293 { return ARROW; }
1294  YY_BREAK
1295 case 55:
1297 #line 289 "scanner.l"
1298 { return '\\'; }
1299  YY_BREAK
1300 case 56:
1302 #line 290 "scanner.l"
1303 {
1304  lvalp->name = omStrDup("\n");
1305  return STRINGTOK;
1306  }
1307  YY_BREAK
1308 case 57:
1310 #line 294 "scanner.l"
1311 {
1312  lvalp->name = (char *)yytext;
1313  return INT_CONST;
1314  }
1315  YY_BREAK
1316 case 58:
1318 #line 298 "scanner.l"
1319 {
1320  lvalp->name = (char *)yytext;
1321  return RINGVAR;
1322  }
1323  YY_BREAK
1324 case 59:
1326 #line 302 "scanner.l"
1327 {
1328  m2_end(-1);
1329  }
1330  YY_BREAK
1331 case 60:
1333 #line 305 "scanner.l"
1334 {
1335  #ifdef MM_STAT
1336  mmStat(-500);
1337  #endif
1338  #ifdef OM_TRACK
1339  #ifndef SING_NDEBUG
1340  omPrintUsedTrackAddrs(stdout, 10);
1341  #endif
1342  #endif
1343  m2_end(0);
1344  }
1345  YY_BREAK
1346 case 61:
1348 #line 317 "scanner.l"
1349 {
1350  lvalp->name = (char *)yytext;
1351  return RINGVAR;
1352  }
1353  YY_BREAK
1354 case 62:
1356 #line 321 "scanner.l"
1357 {
1358  lvalp->name = (char *)yytext;
1359  return RINGVAR;
1360  }
1361  YY_BREAK
1362 case 63:
1363 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1364 yy_c_buf_p = yy_cp -= 1;
1365 YY_DO_BEFORE_ACTION; /* set up yytext again */
1367 #line 325 "scanner.l"
1368 {
1369  lvalp->name = (char *)yytext;
1370  return RINGVAR;
1371  }
1372  YY_BREAK
1373 case 64:
1375 #line 330 "scanner.l"
1376 {
1377  /* {name} */
1378  int rc=0;
1379  if (yytext[strlen((char *)yytext)-1] == '\n')
1380  {
1381  yytext[strlen((char *)yytext)-1] = '\0';
1382  }
1383  if (yyleng > 1)
1384  {
1385  rc = IsCmd((char *)yytext,lvalp->i);
1386  if (rc) return rc;
1387  }
1388  lvalp->name = omStrDup((char *)yytext);
1389  return UNKNOWN_IDENT;
1390  }
1391  YY_BREAK
1392 case 65:
1394 #line 346 "scanner.l"
1395 {
1396  /*if (*yytext == '\n') REJECT;*/
1397  register char ch= *yytext;
1398  lvalp->i = ch;
1399  switch(ch)
1400  {
1401  /* case '&': */
1402  case '|':
1403  return LOGIC_OP;
1404  /* case '/': */
1405  case '%':
1406  case '*':
1407  return MULDIV_OP;
1408  /* case '<': */
1409  case '>':
1410  return COMP_OP;
1411  default:
1412  break;
1413  }
1414  return ch;
1415  }
1416  YY_BREAK
1417 case 66:
1419 #line 367 "scanner.l"
1420 YY_FATAL_ERROR( "flex scanner jammed" );
1421  YY_BREAK
1422 case YY_STATE_EOF(INITIAL):
1423 case YY_STATE_EOF(string):
1424 case YY_STATE_EOF(block):
1425 case YY_STATE_EOF(blockstr):
1426 case YY_STATE_EOF(brace):
1427 case YY_STATE_EOF(bracestr):
1428 case YY_STATE_EOF(bracket):
1429 case YY_STATE_EOF(asstring):
1430  yyterminate();
1431 
1432  case YY_END_OF_BUFFER:
1433  {
1434  /* Amount of text matched not including the EOB char. */
1435  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1436 
1437  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1438  *yy_cp = yy_hold_char;
1440 
1441  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1442  {
1443  /* We're scanning a new file or input source. It's
1444  * possible that this happened because the user
1445  * just pointed yyin at a new source and called
1446  * yylex(). If so, then we have to assure
1447  * consistency between yy_current_buffer and our
1448  * globals. Here is the right place to do so, because
1449  * this is the first action (other than possibly a
1450  * back-up) that will match for the new input source.
1451  */
1452  yy_n_chars = yy_current_buffer->yy_n_chars;
1453  yy_current_buffer->yy_input_file = yyin;
1454  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1455  }
1456 
1457  /* Note that here we test for yy_c_buf_p "<=" to the position
1458  * of the first EOB in the buffer, since yy_c_buf_p will
1459  * already have been incremented past the NUL character
1460  * (since all states make transitions on EOB to the
1461  * end-of-buffer state). Contrast this with the test
1462  * in input().
1463  */
1464  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1465  { /* This was really a NUL. */
1466  yy_state_type yy_next_state;
1467 
1468  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1469 
1470  yy_current_state = yy_get_previous_state();
1471 
1472  /* Okay, we're now positioned to make the NUL
1473  * transition. We couldn't have
1474  * yy_get_previous_state() go ahead and do it
1475  * for us because it doesn't know how to deal
1476  * with the possibility of jamming (and we don't
1477  * want to build jamming into it because then it
1478  * will run more slowly).
1479  */
1480 
1481  yy_next_state = yy_try_NUL_trans( yy_current_state );
1482 
1484 
1485  if ( yy_next_state )
1486  {
1487  /* Consume the NUL. */
1488  yy_cp = ++yy_c_buf_p;
1489  yy_current_state = yy_next_state;
1490  goto yy_match;
1491  }
1492 
1493  else
1494  {
1495  yy_cp = yy_c_buf_p;
1496  goto yy_find_action;
1497  }
1498  }
1499 
1500  else switch ( yy_get_next_buffer() )
1501  {
1502  case EOB_ACT_END_OF_FILE:
1503  {
1505 
1506  if ( yywrap() )
1507  {
1508  /* Note: because we've taken care in
1509  * yy_get_next_buffer() to have set up
1510  * yytext, we can now set up
1511  * yy_c_buf_p so that if some total
1512  * hoser (like flex itself) wants to
1513  * call the scanner after we return the
1514  * YY_NULL, it'll still work - another
1515  * YY_NULL will get returned.
1516  */
1518 
1520  goto do_action;
1521  }
1522 
1523  else
1524  {
1526  YY_NEW_FILE;
1527  }
1528  break;
1529  }
1530 
1531  case EOB_ACT_CONTINUE_SCAN:
1532  yy_c_buf_p =
1533  yytext_ptr + yy_amount_of_matched_text;
1534 
1535  yy_current_state = yy_get_previous_state();
1536 
1537  yy_cp = yy_c_buf_p;
1539  goto yy_match;
1540 
1541  case EOB_ACT_LAST_MATCH:
1542  yy_c_buf_p =
1543  &yy_current_buffer->yy_ch_buf[yy_n_chars];
1544 
1545  yy_current_state = yy_get_previous_state();
1546 
1547  yy_cp = yy_c_buf_p;
1549  goto yy_find_action;
1550  }
1551  break;
1552  }
1553 
1554  default:
1556  "fatal flex scanner internal error--no action found" );
1557  } /* end of action switch */
1558  } /* end of scanning one token */
unsigned char YY_CHAR
Definition: libparse.cc:282
register char * yy_bp
Definition: scanner.cc:824
Definition: grammar.cc:272
#define YY_START
Definition: scanner.cc:85
#define YY_RULE_SETUP
Definition: scanner.cc:815
const CanonicalForm int s
Definition: facAbsFact.cc:55
#define brace
Definition: scanner.cc:666
#define EOB_ACT_LAST_MATCH
Definition: scanner.cc:106
static yyconst short int yy_chk[610]
Definition: scanner.cc:474
int yylineno
Definition: febase.cc:45
static char yy_hold_char
Definition: scanner.cc:211
#define blockstr
Definition: scanner.cc:664
#define block
Definition: scanner.cc:662
#define YY_RESTORE_YY_MORE_OFFSET
Definition: scanner.cc:556
int blocknest
Definition: scanner.cc:581
static yyconst short int yy_def[192]
Definition: scanner.cc:377
#define BEGIN
Definition: scanner.cc:79
loop
Definition: myNF.cc:98
#define INITIAL
Definition: scanner.cc:559
static char * dupyytext()
Definition: scanner.cc:613
static yyconst short int yy_nxt[610]
Definition: scanner.cc:403
#define YY_MORE_ADJ
Definition: scanner.cc:555
static int yy_did_buffer_switch_on_eof
Definition: scanner.cc:226
static int yy_more_flag
Definition: scanner.cc:552
char prompt_char
Definition: febase.cc:44
static yyconst short int yy_accept[171]
Definition: scanner.cc:288
Definition: grammar.cc:270
#define COMP_OP
Definition: tok.h:27
static int yy_n_chars
Definition: scanner.cc:213
void m2_end(int i)
Definition: misc_ip.cc:1074
static yyconst short int yy_base[192]
Definition: scanner.cc:351
#define YY_DO_BEFORE_ACTION
Definition: scanner.cc:278
#define YY_SC_TO_UI(c)
Definition: scanner.cc:73
#define MULDIV_OP
Definition: tok.h:26
#define YY_END_OF_BUFFER
Definition: scanner.cc:287
#define YY_BUFFER_NORMAL
Definition: scanner.cc:187
#define YY_AT_BOL()
Definition: scanner.cc:262
#define EOB_ACT_CONTINUE_SCAN
Definition: scanner.cc:104
#define yyterminate()
Definition: scanner.cc:783
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
static int yy_more_len
Definition: scanner.cc:553
static int yy_start
Definition: scanner.cc:221
register int yy_act
Definition: scanner.cc:825
int yy_noeof
Definition: fevoices.cc:55
int yyleng
Definition: scanner.cc:216
static yy_state_type yy_get_previous_state()
Definition: scanner.cc:1702
static char * yy_c_buf_p
Definition: scanner.cc:219
Definition: grammar.cc:269
#define YY_BREAK
Definition: scanner.cc:812
#define YY_BUFFER_NEW
Definition: scanner.cc:186
static yyconst int yy_meta[49]
Definition: scanner.cc:342
static yy_state_type yy_last_accepting_state
Definition: scanner.cc:545
char * iiProcName(char *buf, char &ct, char *&e)
Definition: iplib.cc:113
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition: scanner.cc:1738
#define yytext_ptr
Definition: scanner.cc:268
#define bracestr
Definition: scanner.cc:668
#define LOGIC_OP
Definition: tok.h:25
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
static int yy_get_next_buffer()
Definition: scanner.cc:1570
static int yyinput()
Definition: scanner.cc:1812
#define yymore()
Definition: scanner.cc:554
#define string
Definition: scanner.cc:660
static yyconst int yy_ec[256]
Definition: scanner.cc:310
int yywrap()
Definition: scanner.cc:646
int yy_state_type
Definition: libparse.cc:284
register char * yy_cp
Definition: scanner.cc:824
int yy_blocklineno
Definition: fevoices.cc:56
FILE * yyin
Definition: scanner.cc:265
static char * dupyytextNL()
Definition: scanner.cc:622
#define EOB_ACT_END_OF_FILE
Definition: scanner.cc:105
void omPrintUsedTrackAddrs(FILE *fd, int max_frames)
Definition: omDebugCheck.c:568
#define YY_STATE_EOF(state)
Definition: scanner.cc:89
#define YY_NEW_FILE
Definition: scanner.cc:92
#define asstring
Definition: scanner.cc:672
char * yytext
Definition: scanner.cc:557
static char * yy_last_accepting_cpos
Definition: scanner.cc:546
int IsCmd(const char *n, int &tok)
Definition: iparith.cc:8729
#define bracket
Definition: scanner.cc:670
#define omStrDup(s)
Definition: omAllocDecl.h:263

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 1944 of file scanner.cc.

1950  {
1951  YY_BUFFER_STATE b;
1952 
1953  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1954  if ( ! b )
1955  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1956 
1957  b->yy_buf_size = size;
1958 
1959  /* yy_ch_buf has to be 2 characters longer than the size given because
1960  * we need to put in 2 end-of-buffer characters.
1961  */
1962  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1963  if ( ! b->yy_ch_buf )
1964  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1965 
1966  b->yy_is_our_buffer = 1;
1967 
1968  yy_init_buffer( b, file );
1969 
1970  return b;
1971  }
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: scanner.cc:2001
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
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:2272
const poly b
Definition: syzextra.cc:213

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 1975 of file scanner.cc.

1980  {
1981  if ( ! b )
1982  return;
1983 
1984  if ( b == yy_current_buffer )
1985  yy_current_buffer = (YY_BUFFER_STATE) 0;
1986 
1987  if ( b->yy_is_our_buffer )
1988  yy_flex_free( (void *) b->yy_ch_buf );
1989 
1990  yy_flex_free( (void *) b );
1991  }
static void yy_flex_free(void *ptr)
Definition: scanner.cc:2300
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
const poly b
Definition: syzextra.cc:213

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 2208 of file scanner.cc.

2213  {
2214  (void) fprintf( stderr, "%s\n", msg );
2215  exit( YY_EXIT_FAILURE );
2216  }
#define YY_EXIT_FAILURE
Definition: scanner.cc:2204

◆ yy_flex_alloc()

static void* yy_flex_alloc ( yy_size_t  size)
static

Definition at line 2272 of file scanner.cc.

2277  {
2278  return (void *) malloc( size );
2279  }
#define malloc
Definition: scanner.cc:608
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 2300 of file scanner.cc.

2305  {
2306  free( ptr );
2307  }
#define free
Definition: scanner.cc:612

◆ yy_flex_realloc()

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

Definition at line 2282 of file scanner.cc.

2288  {
2289  /* The cast to (char *) in the following accommodates both
2290  * implementations that use char* generic pointers, and those
2291  * that use void* generic pointers. It works with the latter
2292  * because both ANSI C and C++ allow castless assignment from
2293  * any pointer type to void*, and deal with argument conversions
2294  * as though doing an assignment.
2295  */
2296  return (void *) realloc( (char *) ptr, size );
2297  }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define realloc
Definition: scanner.cc:610

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 2028 of file scanner.cc.

2034  {
2035  if ( ! b )
2036  return;
2037 
2038  b->yy_n_chars = 0;
2039 
2040  /* We always need two end-of-buffer characters. The first causes
2041  * a transition to the end-of-buffer state. The second causes
2042  * a jam in that state.
2043  */
2044  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2045  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2046 
2047  b->yy_buf_pos = &b->yy_ch_buf[0];
2048 
2049  b->yy_at_bol = 1;
2050  b->yy_buffer_status = YY_BUFFER_NEW;
2051 
2052  if ( b == yy_current_buffer )
2054  }
void yy_load_buffer_state(void)
Definition: scanner.cc:1931
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
#define YY_BUFFER_NEW
Definition: scanner.cc:186
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
const poly b
Definition: syzextra.cc:213

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( )
static

Definition at line 1570 of file scanner.cc.

1571  {
1572  register char *dest = yy_current_buffer->yy_ch_buf;
1573  register char *source = yytext_ptr;
1574  register int number_to_move, i;
1575  int ret_val;
1576 
1577  if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1579  "fatal flex scanner internal error--end of buffer missed" );
1580 
1581  if ( yy_current_buffer->yy_fill_buffer == 0 )
1582  { /* Don't try to fill the buffer, so this is an EOF. */
1583  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1584  {
1585  /* We matched a single character, the EOB, so
1586  * treat this as a final EOF.
1587  */
1588  return EOB_ACT_END_OF_FILE;
1589  }
1590 
1591  else
1592  {
1593  /* We matched some text prior to the EOB, first
1594  * process it.
1595  */
1596  return EOB_ACT_LAST_MATCH;
1597  }
1598  }
1599 
1600  /* Try to read more data. */
1601 
1602  /* First move last chars to start of buffer. */
1603  number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1604 
1605  for ( i = 0; i < number_to_move; ++i )
1606  *(dest++) = *(source++);
1607 
1608  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1609  /* don't do the read, it's not guaranteed to return an EOF,
1610  * just force an EOF
1611  */
1612  yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1613 
1614  else
1615  {
1616  int num_to_read =
1617  yy_current_buffer->yy_buf_size - number_to_move - 1;
1618 
1619  while ( num_to_read <= 0 )
1620  { /* Not enough room in the buffer - grow it. */
1621 #ifdef YY_USES_REJECT
1623 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1624 #else
1625 
1626  /* just a shorter name for the current buffer */
1627  YY_BUFFER_STATE b = yy_current_buffer;
1628 
1629  int yy_c_buf_p_offset =
1630  (int) (yy_c_buf_p - b->yy_ch_buf);
1631 
1632  if ( b->yy_is_our_buffer )
1633  {
1634  int new_size = b->yy_buf_size * 2;
1635 
1636  if ( new_size <= 0 )
1637  b->yy_buf_size += b->yy_buf_size / 8;
1638  else
1639  b->yy_buf_size *= 2;
1640 
1641  b->yy_ch_buf = (char *)
1642  /* Include room in for 2 EOB chars. */
1643  yy_flex_realloc( (void *) b->yy_ch_buf,
1644  b->yy_buf_size + 2 );
1645  }
1646  else
1647  /* Can't grow it, we don't own it. */
1648  b->yy_ch_buf = 0;
1649 
1650  if ( ! b->yy_ch_buf )
1652  "fatal error - scanner input buffer overflow" );
1653 
1654  yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1655 
1656  num_to_read = yy_current_buffer->yy_buf_size -
1657  number_to_move - 1;
1658 #endif
1659  }
1660 
1661  if ( num_to_read > YY_READ_BUF_SIZE )
1662  num_to_read = YY_READ_BUF_SIZE;
1663 
1664  /* Read in more data. */
1665  YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1666  yy_n_chars, num_to_read );
1667 
1668  yy_current_buffer->yy_n_chars = yy_n_chars;
1669  }
1670 
1671  if ( yy_n_chars == 0 )
1672  {
1673  if ( number_to_move == YY_MORE_ADJ )
1674  {
1675  ret_val = EOB_ACT_END_OF_FILE;
1676  yyrestart( yyin );
1677  }
1678 
1679  else
1680  {
1681  ret_val = EOB_ACT_LAST_MATCH;
1682  yy_current_buffer->yy_buffer_status =
1684  }
1685  }
1686 
1687  else
1688  ret_val = EOB_ACT_CONTINUE_SCAN;
1689 
1690  yy_n_chars += number_to_move;
1693 
1694  yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1695 
1696  return ret_val;
1697  }
#define EOB_ACT_LAST_MATCH
Definition: scanner.cc:106
#define YY_BUFFER_EOF_PENDING
Definition: scanner.cc:198
#define YY_MORE_ADJ
Definition: scanner.cc:555
#define YY_INPUT(buf, result, max_size)
Definition: scanner.cc:650
static int yy_n_chars
Definition: scanner.cc:213
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: scanner.cc:2282
#define EOB_ACT_CONTINUE_SCAN
Definition: scanner.cc:104
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
static char * yy_c_buf_p
Definition: scanner.cc:219
int i
Definition: cfEzgcd.cc:123
#define yytext_ptr
Definition: scanner.cc:268
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
FILE * yyin
Definition: scanner.cc:265
#define YY_READ_BUF_SIZE
Definition: scanner.cc:744
#define EOB_ACT_END_OF_FILE
Definition: scanner.cc:105
void yyrestart(FILE *input_file)
Definition: scanner.cc:1886
const poly b
Definition: syzextra.cc:213

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( )
static

Definition at line 1702 of file scanner.cc.

1703  {
1704  register yy_state_type yy_current_state;
1705  register char *yy_cp;
1706 
1707  yy_current_state = yy_start;
1708  yy_current_state += YY_AT_BOL();
1709 
1710  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1711  {
1712  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1713  if ( yy_accept[yy_current_state] )
1714  {
1715  yy_last_accepting_state = yy_current_state;
1717  }
1718  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1719  {
1720  yy_current_state = (int) yy_def[yy_current_state];
1721  if ( yy_current_state >= 171 )
1722  yy_c = yy_meta[(unsigned int) yy_c];
1723  }
1724  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1725  }
1726 
1727  return yy_current_state;
1728  }
unsigned char YY_CHAR
Definition: libparse.cc:282
static yyconst short int yy_chk[610]
Definition: scanner.cc:474
static yyconst short int yy_def[192]
Definition: scanner.cc:377
static yyconst short int yy_nxt[610]
Definition: scanner.cc:403
#define YY_MORE_ADJ
Definition: scanner.cc:555
static yyconst short int yy_accept[171]
Definition: scanner.cc:288
static yyconst short int yy_base[192]
Definition: scanner.cc:351
#define YY_SC_TO_UI(c)
Definition: scanner.cc:73
#define YY_AT_BOL()
Definition: scanner.cc:262
static int yy_start
Definition: scanner.cc:221
static char * yy_c_buf_p
Definition: scanner.cc:219
static yyconst int yy_meta[49]
Definition: scanner.cc:342
static yy_state_type yy_last_accepting_state
Definition: scanner.cc:545
#define yytext_ptr
Definition: scanner.cc:268
static yyconst int yy_ec[256]
Definition: scanner.cc:310
int yy_state_type
Definition: libparse.cc:284
register char * yy_cp
Definition: scanner.cc:824
static char * yy_last_accepting_cpos
Definition: scanner.cc:546

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 2001 of file scanner.cc.

2009  {
2010  yy_flush_buffer( b );
2011 
2012  b->yy_input_file = file;
2013  b->yy_fill_buffer = 1;
2014 
2015 #if YY_ALWAYS_INTERACTIVE
2016  b->yy_is_interactive = 1;
2017 #else
2018 #if YY_NEVER_INTERACTIVE
2019  b->yy_is_interactive = 0;
2020 #else
2021  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2022 #endif
2023 #endif
2024  }
void yy_flush_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:2028
const poly b
Definition: syzextra.cc:213

◆ yy_load_buffer_state()

void yy_load_buffer_state ( void  )

Definition at line 1931 of file scanner.cc.

1935  {
1936  yy_n_chars = yy_current_buffer->yy_n_chars;
1937  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1938  yyin = yy_current_buffer->yy_input_file;
1940  }
static char yy_hold_char
Definition: scanner.cc:211
static int yy_n_chars
Definition: scanner.cc:213
static char * yy_c_buf_p
Definition: scanner.cc:219
#define yytext_ptr
Definition: scanner.cc:268
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
FILE * yyin
Definition: scanner.cc:265

◆ YY_PROTO() [1/15]

void yyrestart YY_PROTO ( (FILE *input_file)  )

◆ YY_PROTO() [2/15]

void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer)  )

◆ YY_PROTO() [3/15]

void yy_load_buffer_state YY_PROTO ( (void)  )

◆ YY_PROTO() [4/15]

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

◆ YY_PROTO() [5/15]

void yy_delete_buffer YY_PROTO ( (YY_BUFFER_STATE b )

◆ YY_PROTO() [6/15]

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

◆ YY_PROTO() [7/15]

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

◆ YY_PROTO() [8/15]

YY_BUFFER_STATE yy_scan_string YY_PROTO ( (yyconst char *yy_str)  )

◆ YY_PROTO() [9/15]

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

◆ YY_PROTO() [10/15]

static void* yy_flex_alloc YY_PROTO ( (yy_size_t )
static

◆ YY_PROTO() [11/15]

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

◆ YY_PROTO() [12/15]

static void yy_flex_free YY_PROTO ( (void *)  )
static

◆ YY_PROTO() [13/15]

static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  )
static

◆ YY_PROTO() [14/15]

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

◆ YY_PROTO() [15/15]

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

◆ yy_scan_buffer()

YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Definition at line 2059 of file scanner.cc.

2065  {
2066  YY_BUFFER_STATE b;
2067 
2068  if ( size < 2 ||
2071  /* They forgot to leave room for the EOB's. */
2072  return 0;
2073 
2074  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2075  if ( ! b )
2076  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2077 
2078  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2079  b->yy_buf_pos = b->yy_ch_buf = base;
2080  b->yy_is_our_buffer = 0;
2081  b->yy_input_file = 0;
2082  b->yy_n_chars = b->yy_buf_size;
2083  b->yy_is_interactive = 0;
2084  b->yy_at_bol = 1;
2085  b->yy_fill_buffer = 0;
2086  b->yy_buffer_status = YY_BUFFER_NEW;
2087 
2088  yy_switch_to_buffer( b );
2089 
2090  return b;
2091  }
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1901
char N base
Definition: ValueTraits.h:144
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
#define YY_BUFFER_NEW
Definition: scanner.cc:186
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:2272
const poly b
Definition: syzextra.cc:213

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 2114 of file scanner.cc.

2120  {
2121  YY_BUFFER_STATE b;
2122  char *buf;
2123  yy_size_t n;
2124  int i;
2125 
2126  /* Get memory for full buffer, including space for trailing EOB's. */
2127  n = len + 2;
2128  buf = (char *) yy_flex_alloc( n );
2129  if ( ! buf )
2130  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2131 
2132  for ( i = 0; i < len; ++i )
2133  buf[i] = bytes[i];
2134 
2135  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2136 
2137  b = yy_scan_buffer( buf, n );
2138  if ( ! b )
2139  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2140 
2141  /* It's okay to grow etc. this buffer, and we should throw it
2142  * away when we're done.
2143  */
2144  b->yy_is_our_buffer = 1;
2145 
2146  return b;
2147  }
unsigned int yy_size_t
Definition: libparse.cc:159
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
int status int void * buf
Definition: si_signals.h:59
int i
Definition: cfEzgcd.cc:123
static void * yy_flex_alloc(yy_size_t size)
Definition: scanner.cc:2272
const poly b
Definition: syzextra.cc:213
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
Definition: scanner.cc:2059

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char *  yy_str)

Definition at line 2097 of file scanner.cc.

2102  {
2103  int len;
2104  for ( len = 0; yy_str[len]; ++len )
2105  ;
2106 
2107  return yy_scan_bytes( yy_str, len );
2108  }
YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, int len)
Definition: scanner.cc:2114

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 1901 of file scanner.cc.

1906  {
1907  if ( yy_current_buffer == new_buffer )
1908  return;
1909 
1910  if ( yy_current_buffer )
1911  {
1912  /* Flush out information for old buffer. */
1914  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1915  yy_current_buffer->yy_n_chars = yy_n_chars;
1916  }
1917 
1918  yy_current_buffer = new_buffer;
1920 
1921  /* We don't actually know whether we did this switch during
1922  * EOF (yywrap()) processing, but the only time this flag
1923  * is looked at is after yywrap() is called, so it's safe
1924  * to go ahead and always set it.
1925  */
1927  }
static char yy_hold_char
Definition: scanner.cc:211
void yy_load_buffer_state(void)
Definition: scanner.cc:1931
static int yy_did_buffer_switch_on_eof
Definition: scanner.cc:226
static int yy_n_chars
Definition: scanner.cc:213
static char * yy_c_buf_p
Definition: scanner.cc:219
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 1738 of file scanner.cc.

1743  {
1744  register int yy_is_jam;
1745  register char *yy_cp = yy_c_buf_p;
1746 
1747  register YY_CHAR yy_c = 1;
1748  if ( yy_accept[yy_current_state] )
1749  {
1750  yy_last_accepting_state = yy_current_state;
1752  }
1753  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1754  {
1755  yy_current_state = (int) yy_def[yy_current_state];
1756  if ( yy_current_state >= 171 )
1757  yy_c = yy_meta[(unsigned int) yy_c];
1758  }
1759  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1760  yy_is_jam = (yy_current_state == 170);
1761 
1762  return yy_is_jam ? 0 : yy_current_state;
1763  }
unsigned char YY_CHAR
Definition: libparse.cc:282
static yyconst short int yy_chk[610]
Definition: scanner.cc:474
static yyconst short int yy_def[192]
Definition: scanner.cc:377
static yyconst short int yy_nxt[610]
Definition: scanner.cc:403
static yyconst short int yy_accept[171]
Definition: scanner.cc:288
static yyconst short int yy_base[192]
Definition: scanner.cc:351
static char * yy_c_buf_p
Definition: scanner.cc:219
static yyconst int yy_meta[49]
Definition: scanner.cc:342
static yy_state_type yy_last_accepting_state
Definition: scanner.cc:545
register char * yy_cp
Definition: scanner.cc:824
static char * yy_last_accepting_cpos
Definition: scanner.cc:546

◆ yyinput()

static int yyinput ( )
static

Definition at line 1812 of file scanner.cc.

1816  {
1817  int c;
1818 
1820 
1822  {
1823  /* yy_c_buf_p now points to the character we want to return.
1824  * If this occurs *before* the EOB characters, then it's a
1825  * valid NUL; if not, then we've hit the end of the buffer.
1826  */
1827  if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1828  /* This was really a NUL. */
1829  *yy_c_buf_p = '\0';
1830 
1831  else
1832  { /* need more input */
1833  int offset = yy_c_buf_p - yytext_ptr;
1834  ++yy_c_buf_p;
1835 
1836  switch ( yy_get_next_buffer() )
1837  {
1838  case EOB_ACT_LAST_MATCH:
1839  /* This happens because yy_g_n_b()
1840  * sees that we've accumulated a
1841  * token and flags that we need to
1842  * try matching the token before
1843  * proceeding. But for input(),
1844  * there's no matching to consider.
1845  * So convert the EOB_ACT_LAST_MATCH
1846  * to EOB_ACT_END_OF_FILE.
1847  */
1848 
1849  /* Reset buffer status. */
1850  yyrestart( yyin );
1851 
1852  /* fall through */
1853 
1854  case EOB_ACT_END_OF_FILE:
1855  {
1856  if ( yywrap() )
1857  return EOF;
1858 
1860  YY_NEW_FILE;
1861 #ifdef __cplusplus
1862  return yyinput();
1863 #else
1864  return input();
1865 #endif
1866  }
1867 
1868  case EOB_ACT_CONTINUE_SCAN:
1869  yy_c_buf_p = yytext_ptr + offset;
1870  break;
1871  }
1872  }
1873  }
1874 
1875  c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1876  *yy_c_buf_p = '\0'; /* preserve yytext */
1877  yy_hold_char = *++yy_c_buf_p;
1878 
1879  yy_current_buffer->yy_at_bol = (c == '\n');
1880 
1881  return c;
1882  }
#define EOB_ACT_LAST_MATCH
Definition: scanner.cc:106
static char yy_hold_char
Definition: scanner.cc:211
static int yy_did_buffer_switch_on_eof
Definition: scanner.cc:226
static int yy_n_chars
Definition: scanner.cc:213
#define EOB_ACT_CONTINUE_SCAN
Definition: scanner.cc:104
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
static char * yy_c_buf_p
Definition: scanner.cc:219
#define yytext_ptr
Definition: scanner.cc:268
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
static int yy_get_next_buffer()
Definition: scanner.cc:1570
static int yyinput()
Definition: scanner.cc:1812
int yywrap()
Definition: scanner.cc:646
FILE * yyin
Definition: scanner.cc:265
#define EOB_ACT_END_OF_FILE
Definition: scanner.cc:105
#define YY_NEW_FILE
Definition: scanner.cc:92
void yyrestart(FILE *input_file)
Definition: scanner.cc:1886
int offset
Definition: libparse.cc:1091

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 1886 of file scanner.cc.

1891  {
1892  if ( ! yy_current_buffer )
1894 
1895  yy_init_buffer( yy_current_buffer, input_file );
1897  }
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1944
void yy_load_buffer_state(void)
Definition: scanner.cc:1931
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: scanner.cc:2001
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
#define YY_BUF_SIZE
Definition: scanner.cc:97
FILE * yyin
Definition: scanner.cc:265

◆ yyunput()

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

Definition at line 1768 of file scanner.cc.

1774  {
1775  register char *yy_cp = yy_c_buf_p;
1776 
1777  /* undo effects of setting up yytext */
1778  *yy_cp = yy_hold_char;
1779 
1780  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1781  { /* need to shift things up to make room */
1782  /* +2 for EOB chars. */
1783  register int number_to_move = yy_n_chars + 2;
1784  register char *dest = &yy_current_buffer->yy_ch_buf[
1785  yy_current_buffer->yy_buf_size + 2];
1786  register char *source =
1787  &yy_current_buffer->yy_ch_buf[number_to_move];
1788 
1789  while ( source > yy_current_buffer->yy_ch_buf )
1790  *--dest = *--source;
1791 
1792  yy_cp += (int) (dest - source);
1793  yy_bp += (int) (dest - source);
1794  yy_current_buffer->yy_n_chars =
1795  yy_n_chars = yy_current_buffer->yy_buf_size;
1796 
1797  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1798  YY_FATAL_ERROR( "flex scanner push-back overflow" );
1799  }
1800 
1801  *--yy_cp = (char) c;
1802 
1803 
1804  yytext_ptr = yy_bp;
1805  yy_hold_char = *yy_cp;
1806  yy_c_buf_p = yy_cp;
1807  }
register char * yy_bp
Definition: scanner.cc:824
static char yy_hold_char
Definition: scanner.cc:211
static int yy_n_chars
Definition: scanner.cc:213
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:793
static char * yy_c_buf_p
Definition: scanner.cc:219
#define yytext_ptr
Definition: scanner.cc:268
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
register char * yy_cp
Definition: scanner.cc:824

◆ yywrap()

int yywrap ( )

Definition at line 646 of file scanner.cc.

646 { return exitVoice(); }
BOOLEAN exitVoice()
Definition: fevoices.cc:346

Variable Documentation

◆ blocknest

int blocknest = 0

Definition at line 581 of file scanner.cc.

◆ inerror

int inerror

Definition at line 175 of file grammar.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, 24, 65, 35, 64, 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, 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, 2, 38, 37,
30, 30, 28, 27, 21, 20, 21, 0, 21, 9,
0, 1, 61, 63, 61, 63, 58, 64, 64, 5,
64, 64, 64, 64, 64, 2, 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 288 of file scanner.cc.

◆ yy_act

register int yy_act

Definition at line 825 of file scanner.cc.

◆ yy_base

yyconst short int yy_base[192]
static
Initial value:
=
{ 0,
0, 299, 43, 44, 45, 46, 47, 48, 50, 54,
295, 294, 74, 92, 75, 76, 296, 561, 561, 561,
269, 561, 561, 561, 267, 40, 250, 229, 84, 38,
69, 92, 221, 60, 194, 181, 99, 561, 86, 87,
93, 98, 99, 100, 102, 561, 154, 561, 177, 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, 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, 0, 561, 561,
0, 177, 561, 561, 0, 187, 190, 144, 0, 0,
171, 0, 180, 561, 176, 193, 193, 180, 186, 188,
190, 192, 201, 203, 204, 0, 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 351 of file scanner.cc.

◆ yy_bp

register char * yy_bp

Definition at line 824 of file scanner.cc.

◆ yy_c_buf_p

char* yy_c_buf_p = (char *) 0
static

Definition at line 219 of file scanner.cc.

◆ yy_chk

yyconst short int yy_chk[610]
static

Definition at line 474 of file scanner.cc.

◆ yy_cp

register char* yy_cp

Definition at line 824 of file scanner.cc.

◆ yy_current_buffer

YY_BUFFER_STATE yy_current_buffer = 0
static

Definition at line 201 of file scanner.cc.

◆ YY_DECL

YY_DECL
Initial value:
{
register yy_state_type yy_current_state
int yy_state_type
Definition: libparse.cc:284

Definition at line 822 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, 178, 178,
178, 178, 178, 178, 178, 170, 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, 170, 178, 178,
178, 170, 170, 170, 170, 170, 170, 170, 184, 179,
185, 170, 179, 170, 170, 170, 170, 170, 170, 178,
178, 178, 178, 178, 100, 100, 170, 186, 170, 170,
180, 187, 170, 170, 181, 170, 182, 188, 181, 183,
170, 184, 179, 170, 170, 170, 179, 100, 100, 100,
100, 100, 100, 100, 100, 186, 187, 189, 170, 170,
170, 170, 100, 100, 144, 100, 100, 100, 170, 170,
179, 100, 170, 170, 100, 190, 100, 100, 100, 191,
170, 144, 100, 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 377 of file scanner.cc.

◆ yy_did_buffer_switch_on_eof

int yy_did_buffer_switch_on_eof
static

Definition at line 226 of file scanner.cc.

◆ yy_ec

yyconst int yy_ec[256]
static

Definition at line 310 of file scanner.cc.

◆ yy_hold_char

char yy_hold_char
static

Definition at line 211 of file scanner.cc.

◆ yy_init

int yy_init = 1
static

Definition at line 220 of file scanner.cc.

◆ yy_last_accepting_cpos

char* yy_last_accepting_cpos
static

Definition at line 546 of file scanner.cc.

◆ yy_last_accepting_state

yy_state_type yy_last_accepting_state
static

Definition at line 545 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 342 of file scanner.cc.

◆ yy_more_flag

int yy_more_flag = 0
static

Definition at line 552 of file scanner.cc.

◆ yy_more_len

int yy_more_len = 0
static

Definition at line 553 of file scanner.cc.

◆ yy_n_chars

int yy_n_chars
static

Definition at line 213 of file scanner.cc.

◆ yy_nxt

yyconst short int yy_nxt[610]
static

Definition at line 403 of file scanner.cc.

◆ yy_start

int yy_start = 0
static

Definition at line 221 of file scanner.cc.

◆ yyin

FILE* yyin = (FILE *) 0

Definition at line 265 of file scanner.cc.

◆ yyleng

int yyleng

Definition at line 216 of file scanner.cc.

◆ yyout

FILE * yyout = (FILE *) 0

Definition at line 265 of file scanner.cc.

◆ yytext

char* yytext

Definition at line 557 of file scanner.cc.