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 676 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 666 of file scanner.cc.

◆ blockstr

#define blockstr   3

Definition at line 668 of file scanner.cc.

◆ brace

#define brace   4

Definition at line 670 of file scanner.cc.

◆ bracestr

#define bracestr   5

Definition at line 672 of file scanner.cc.

◆ bracket

#define bracket   6

Definition at line 674 of file scanner.cc.

◆ ECHO

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

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

◆ INITIAL

#define INITIAL   0

Definition at line 560 of file scanner.cc.

◆ malloc

#define malloc   omAlloc

Definition at line 611 of file scanner.cc.

◆ realloc

#define realloc   omRealloc

Definition at line 613 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 664 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 663 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 816 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 646 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:825
#define yytext_ptr
Definition: scanner.cc:269
register char * yy_cp
Definition: scanner.cc:825
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 2202 of file scanner.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 797 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 654 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 727 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 726 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 728 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 748 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 819 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:1942
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 792 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 658 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 2221 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 2221 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 787 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 617 of file scanner.cc.

618 {
619  char* s;
620  if (yyleng>0) yytext[yyleng-1] = '\0';
621  s = omStrDup((char *)yytext);
623  return s;
624 }
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 626 of file scanner.cc.

627 {
628  int i = yyleng;//strlen((char *)yytext);
629  char * rc = (char*)omAlloc( 3 + i );
630  omMarkAsStaticAddr(rc);
631  if (i>0)
632  {
633  strncpy( rc, (char *)yytext, i-1 );
634  }
635  else
636  {
637  i++;
638  }
639  rc[i-1] = '\n';
640  rc[i] = '\n';
641  rc[i+1] = '\0';
642  return rc;
643 }
int i
Definition: cfEzgcd.cc:132
#define omAlloc(size)
Definition: omAllocDecl.h:210

◆ feReadLine()

int feReadLine ( char *  b,
int  l 
)

Definition at line 498 of file fevoices.cc.

499 {
500  char *s=NULL;
501  int offset = 0; /* will not be used if s==NULL*/
502  // try to read from the buffer into b, max l chars
503  if (currentVoice!=NULL)
504  {
505  if((currentVoice->buffer!=NULL)
506  && (currentVoice->buffer[currentVoice->fptr]!='\0'))
507  {
508  NewBuff:
509  REGISTER int i=0;
510  long startfptr=currentVoice->fptr;
511  long tmp_ptr=currentVoice->fptr;
512  l--;
513  loop
514  {
515  REGISTER char c=
516  b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
517  i++;
518  if (yy_noeof==noeof_block)
519  {
520  if (c<' ') yylineno++;
521  else if (c=='}') break;
522  }
523  else
524  {
525  if ((c<' ') ||
526  (c==';') ||
527  (c==')')
528  )
529  break;
530  }
531  if (i>=l) break;
532  tmp_ptr++;/*currentVoice->fptr++;*/
533  if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
534  }
535  currentVoice->fptr=tmp_ptr;
536  b[i]='\0';
537  if (currentVoice->sw==BI_buffer)
538  {
539  BOOLEAN show_echo=FALSE;
540  char *anf;
541  long len;
542  if (startfptr==0)
543  {
544  anf=currentVoice->buffer;
545  const char *ss=strchr(anf,'\n');
546  if (ss==NULL) len=strlen(anf);
547  else len=ss-anf;
548  show_echo=TRUE;
549  }
550  else if (/*(startfptr>0) &&*/
551  (currentVoice->buffer[startfptr-1]=='\n'))
552  {
553  anf=currentVoice->buffer+startfptr;
554  const char *ss=strchr(anf,'\n');
555  if (ss==NULL) len=strlen(anf);
556  else len=ss-anf;
557  yylineno++;
558  show_echo=TRUE;
559  }
560  if (show_echo)
561  {
562  char *s=(char *)omAlloc(len+2);
563  strncpy(s,anf,len+2);
564  s[len+1]='\0';
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();
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  {
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; if (rc<0) rc=0;
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 }
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:4105
FILE * files
Definition: fevoices.h:67
char * buffer
Definition: fevoices.h:69
long ftellptr
Definition: fevoices.h:71
feBufferInputs sw
Definition: fevoices.h:76
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:30
#define MAX_FILE_BUFFER
Definition: fevoices.cc:37
VAR char fe_promptstr[]
Definition: fevoices.cc:31
VAR Voice * currentVoice
Definition: fevoices.cc:47
static int fePrintEcho(char *anf, char *)
Definition: fevoices.cc:416
VAR int yy_noeof
Definition: fevoices.cc:45
static void feShowPrompt(void)
Definition: fevoices.cc:408
@ 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:113
#define omFree(addr)
Definition: omAllocDecl.h:261
size_t omSizeOfAddr(const void *addr)
#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:80

◆ if()

if ( yy_init  )

Definition at line 831 of file scanner.cc.

832  {
833  yy_init = 0;
834 
835 #ifdef YY_USER_INIT
836  YY_USER_INIT;
837 #endif
838 
839  if ( ! yy_start )
840  yy_start = 1; /* first start state */
841 
842  if ( ! yyin )
843  yyin = stdin;
844 
845  if ( ! yyout )
846  yyout = stdout;
847 
848  if ( ! yy_current_buffer )
851 
853  }
#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:1929
STATIC_VAR int yy_init
Definition: scanner.cc:221

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2338 of file scanner.cc.

2338 { 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 2331 of file scanner.cc.

2332 {
2333  yy_flush_buffer((YY_BUFFER_STATE)YY_CURRENT_BUFFER);
2336 }
void yy_flush_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:2026
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1899
#define YY_CURRENT_BUFFER
Definition: scanner.cc:208
void yy_delete_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:1973

◆ myynewbuffer()

void* myynewbuffer ( )

Definition at line 2317 of file scanner.cc.

2318 {
2319  void * oldb = YY_CURRENT_BUFFER;
2321  return oldb;
2322 }

◆ myyoldbuffer()

void myyoldbuffer ( void *  oldb)

Definition at line 2324 of file scanner.cc.

2325 {
2327  yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
2328  //yy_flush_buffer((YY_BUFFER_STATE)oldb);
2329 }

◆ while()

while ( )

Definition at line 855 of file scanner.cc.

856  {
857  yy_more_len = 0;
858  if ( yy_more_flag )
859  {
861  yy_more_flag = 0;
862  }
863  yy_cp = yy_c_buf_p;
864 
865  /* Support of yytext. */
866  *yy_cp = yy_hold_char;
867 
868  /* yy_bp points to the position in yy_ch_buf of the start of
869  * the current run.
870  */
871  yy_bp = yy_cp;
872 
873  yy_current_state = yy_start;
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 MONOM;
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 MONOM;
1352  }
1353  YY_BREAK
1354 case 62:
1356 #line 321 "scanner.l"
1357 {
1358  lvalp->name = (char *)yytext;
1359  return MONOM;
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 MONOM;
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 */
EXTERN_VAR char prompt_char
Definition: feread.h:12
@ 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:9461
char * iiProcName(char *buf, char &ct, char *&e)
Definition: iplib.cc:96
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:1096
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:666
static char * dupyytextNL()
Definition: scanner.cc:626
#define string
Definition: scanner.cc:664
static yyconst short int yy_accept[171]
Definition: scanner.cc:289
#define YY_BREAK
Definition: scanner.cc:816
#define brace
Definition: scanner.cc:670
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:819
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:826
STATIC_VAR int yy_did_buffer_switch_on_eof
Definition: scanner.cc:227
static int yyinput()
Definition: scanner.cc:1811
#define bracestr
Definition: scanner.cc:672
static char * dupyytext()
Definition: scanner.cc:617
#define YY_START
Definition: scanner.cc:86
static int yy_get_next_buffer()
Definition: scanner.cc:1570
#define blockstr
Definition: scanner.cc:668
#define asstring
Definition: scanner.cc:676
#define bracket
Definition: scanner.cc:674
#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:797
STATIC_VAR int yy_more_flag
Definition: scanner.cc:553
#define yyterminate()
Definition: scanner.cc:787
static yy_state_type yy_get_previous_state()
Definition: scanner.cc:1702
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:650
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:1737
#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:314

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 1942 of file scanner.cc.

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

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 1973 of file scanner.cc.

1978  {
1979  if ( ! b )
1980  return;
1981 
1982  if ( b == yy_current_buffer )
1983  yy_current_buffer = (YY_BUFFER_STATE) 0;
1984 
1985  if ( b->yy_is_our_buffer )
1986  yy_flex_free( (void *) b->yy_ch_buf );
1987 
1988  yy_flex_free( (void *) b );
1989  }
static void yy_flex_free(void *ptr)
Definition: scanner.cc:2298

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 2206 of file scanner.cc.

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

◆ yy_flex_alloc()

static void* yy_flex_alloc ( yy_size_t  size)
static

Definition at line 2270 of file scanner.cc.

2275  {
2276  return (void *) malloc( size );
2277  }
#define malloc
Definition: scanner.cc:611

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 2298 of file scanner.cc.

2303  {
2304  free( ptr );
2305  }
#define free
Definition: scanner.cc:616

◆ yy_flex_realloc()

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

Definition at line 2280 of file scanner.cc.

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

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 2026 of file scanner.cc.

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

◆ 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  }
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: scanner.cc:2280
#define YY_READ_BUF_SIZE
Definition: scanner.cc:748
#define YY_INPUT(buf, result, max_size)
Definition: scanner.cc:654
void yyrestart(FILE *input_file)
Definition: scanner.cc:1884
#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 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 
1709  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1710  {
1711  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1712  if ( yy_accept[yy_current_state] )
1713  {
1714  yy_last_accepting_state = yy_current_state;
1716  }
1717  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1718  {
1719  yy_current_state = (int) yy_def[yy_current_state];
1720  if ( yy_current_state >= 171 )
1721  yy_c = yy_meta[(unsigned int) yy_c];
1722  }
1723  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1724  }
1725 
1726  return yy_current_state;
1727  }

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 1999 of file scanner.cc.

2007  {
2008  yy_flush_buffer( b );
2009 
2010  b->yy_input_file = file;
2011  b->yy_fill_buffer = 1;
2012 
2013 #if YY_ALWAYS_INTERACTIVE
2014  b->yy_is_interactive = 1;
2015 #else
2016 #if YY_NEVER_INTERACTIVE
2017  b->yy_is_interactive = 0;
2018 #else
2019  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2020 #endif
2021 #endif
2022  }

◆ yy_load_buffer_state()

void yy_load_buffer_state ( void  )

Definition at line 1929 of file scanner.cc.

1933  {
1934  yy_n_chars = yy_current_buffer->yy_n_chars;
1935  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1936  yyin = yy_current_buffer->yy_input_file;
1938  }

◆ 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 2057 of file scanner.cc.

2063  {
2064  YY_BUFFER_STATE b;
2065 
2066  if ( size < 2 ||
2069  /* They forgot to leave room for the EOB's. */
2070  return 0;
2071 
2072  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2073  if ( ! b )
2074  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2075 
2076  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
2077  b->yy_buf_pos = b->yy_ch_buf = base;
2078  b->yy_is_our_buffer = 0;
2079  b->yy_input_file = 0;
2080  b->yy_n_chars = b->yy_buf_size;
2081  b->yy_is_interactive = 0;
2082  b->yy_at_bol = 1;
2083  b->yy_fill_buffer = 0;
2084  b->yy_buffer_status = YY_BUFFER_NEW;
2085 
2087 
2088  return b;
2089  }
char N base
Definition: ValueTraits.h:144

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 2112 of file scanner.cc.

2118  {
2119  YY_BUFFER_STATE b;
2120  char *buf;
2121  yy_size_t n;
2122  int i;
2123 
2124  /* Get memory for full buffer, including space for trailing EOB's. */
2125  n = len + 2;
2126  buf = (char *) yy_flex_alloc( n );
2127  if ( ! buf )
2128  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2129 
2130  for ( i = 0; i < len; ++i )
2131  buf[i] = bytes[i];
2132 
2133  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2134 
2135  b = yy_scan_buffer( buf, n );
2136  if ( ! b )
2137  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2138 
2139  /* It's okay to grow etc. this buffer, and we should throw it
2140  * away when we're done.
2141  */
2142  b->yy_is_our_buffer = 1;
2143 
2144  return b;
2145  }
unsigned int yy_size_t
Definition: libparse.cc:161
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
Definition: scanner.cc:2057
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 2095 of file scanner.cc.

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

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 1899 of file scanner.cc.

1904  {
1905  if ( yy_current_buffer == new_buffer )
1906  return;
1907 
1908  if ( yy_current_buffer )
1909  {
1910  /* Flush out information for old buffer. */
1912  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1913  yy_current_buffer->yy_n_chars = yy_n_chars;
1914  }
1915 
1916  yy_current_buffer = new_buffer;
1918 
1919  /* We don't actually know whether we did this switch during
1920  * EOF (yywrap()) processing, but the only time this flag
1921  * is looked at is after yywrap() is called, so it's safe
1922  * to go ahead and always set it.
1923  */
1925  }

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 1737 of file scanner.cc.

1742  {
1743  register int yy_is_jam;
1744  register char *yy_cp = yy_c_buf_p;
1745 
1746  register YY_CHAR yy_c = 1;
1747  if ( yy_accept[yy_current_state] )
1748  {
1749  yy_last_accepting_state = yy_current_state;
1751  }
1752  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1753  {
1754  yy_current_state = (int) yy_def[yy_current_state];
1755  if ( yy_current_state >= 171 )
1756  yy_c = yy_meta[(unsigned int) yy_c];
1757  }
1758  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1759  yy_is_jam = (yy_current_state == 170);
1760 
1761  return yy_is_jam ? 0 : yy_current_state;
1762  }

◆ yyinput()

static int yyinput ( )
static

Definition at line 1811 of file scanner.cc.

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

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 1884 of file scanner.cc.

1889  {
1890  if ( ! yy_current_buffer )
1892 
1893  yy_init_buffer( yy_current_buffer, input_file );
1895  }

◆ yyunput()

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

Definition at line 1767 of file scanner.cc.

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

◆ yywrap()

int yywrap ( )

Definition at line 650 of file scanner.cc.

650 { return exitVoice(); }
BOOLEAN exitVoice()
Definition: fevoices.cc:339

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 826 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 825 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 825 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 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, 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.