My Project  debian-1:4.1.1-p2+ds-4build1
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   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

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

◆ asstring

#define asstring   7

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

◆ blockstr

#define blockstr   3

Definition at line 666 of file scanner.cc.

◆ brace

#define brace   4

Definition at line 668 of file scanner.cc.

◆ bracestr

#define bracestr   5

Definition at line 670 of file scanner.cc.

◆ bracket

#define bracket   6

Definition at line 672 of file scanner.cc.

◆ ECHO

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

Definition at line 755 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   omFree

Definition at line 614 of file scanner.cc.

◆ INITIAL

#define INITIAL   0

Definition at line 559 of file scanner.cc.

◆ malloc

#define malloc   omAlloc

Definition at line 609 of file scanner.cc.

◆ realloc

#define realloc   omRealloc

Definition at line 611 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 662 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 661 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 814 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 644 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;

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

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 795 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 652 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 725 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 724 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 726 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 746 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   YY_USER_ACTION

Definition at line 817 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; \
}

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; \
}

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 790 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; }

Definition at line 656 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 )

Definition at line 2219 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 )

Definition at line 2219 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 785 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 615 of file scanner.cc.

617 {
618  char* s;
619  if (yyleng>0) yytext[yyleng-1] = '\0';
620  s = omStrDup((char *)yytext);
622  return s;

◆ dupyytextNL()

static char* dupyytextNL ( )
static

Definition at line 624 of file scanner.cc.

626 {
627  int i = yyleng;//strlen((char *)yytext);
628  char * rc = (char*)omAlloc( 3 + i );
629  omMarkAsStaticAddr(rc);
630  if (i>0)
631  {
632  strncpy( rc, (char *)yytext, i-1 );
633  }
634  else
635  {
636  i++;
637  }
638  rc[i-1] = '\n';
639  rc[i] = '\n';
640  rc[i+1] = '\0';
641  return rc;

◆ feReadLine()

int feReadLine ( char *  b,
int  l 
)

Definition at line 483 of file fevoices.cc.

486 {
487  char *s=NULL;
488  int offset = 0; /* will not be used if s==NULL*/
489  // try to read from the buffer into b, max l chars
490  if (currentVoice!=NULL)
491  {
492  if((currentVoice->buffer!=NULL)
493  && (currentVoice->buffer[currentVoice->fptr]!='\0'))
494  {
495  NewBuff:
496  REGISTER int i=0;
497  long startfptr=currentVoice->fptr;
498  long tmp_ptr=currentVoice->fptr;
499  l--;
500  loop
501  {
502  REGISTER char c=
503  b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
504  i++;
505  if (yy_noeof==noeof_block)
506  {
507  if (c<' ') yylineno++;
508  else if (c=='}') break;
509  }
510  else
511  {
512  if ((c<' ') ||
513  (c==';') ||
514  (c==')')
515  )
516  break;
517  }
518  if (i>=l) break;
519  tmp_ptr++;/*currentVoice->fptr++;*/
520  if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
521  }
522  currentVoice->fptr=tmp_ptr;
523  b[i]='\0';
524  if (currentVoice->sw==BI_buffer)
525  {
526  BOOLEAN show_echo=FALSE;
527  char *anf;
528  long len;
529  if (startfptr==0)
530  {
531  anf=currentVoice->buffer;
532  const char *ss=strchr(anf,'\n');
533  if (ss==NULL) len=strlen(anf);
534  else len=ss-anf;
535  show_echo=TRUE;
536  }
537  else if (/*(startfptr>0) &&*/
538  (currentVoice->buffer[startfptr-1]=='\n'))
539  {
540  anf=currentVoice->buffer+startfptr;
541  const char *ss=strchr(anf,'\n');
542  if (ss==NULL) len=strlen(anf);
543  else len=ss-anf;
544  yylineno++;
545  show_echo=TRUE;
546  }
547  if (show_echo)
548  {
549  char *s=(char *)omAlloc(len+2);
550  strncpy(s,anf,len+2);
551  s[len+1]='\0';
552  fePrintEcho(s,b);
553  omFree((ADDRESS)s);
554  }
555  }
556  currentVoice->fptr++;
557  return i;
558  }
559  // no buffer there or e-o-buffer or eoln:
560  if (currentVoice->sw!=BI_buffer)
561  {
562  currentVoice->fptr=0;
563  if (currentVoice->buffer==NULL)
564  {
567  }
568  }
569  offset=0;
570  NewRead:
571  yylineno++;
572  if (currentVoice->sw==BI_stdin)
573  {
574  feShowPrompt();
578  //int i=0;
579  //if (s!=NULL)
580  // while((s[i]!='\0') /*&& (i<MAX_FILE_BUFFER)*/) {s[i] &= (char)127;i++;}
581  }
582  else if (currentVoice->sw==BI_file)
583  {
587  if (s!=NULL)
588  {
590  // ftell returns -1 for non-seekable streams, such as pipes
591  if (currentVoice->ftellptr<0)
593  }
594  }
595  //else /* BI_buffer */ s==NULL => return 0
596  // done by the default return
597  }
598  if (s!=NULL)
599  {
600  // handle prot:
601  if (feProt&SI_PROT_I)
602  {
603  fputs(s,feProtFile);
604  }
605  int rc=fePrintEcho(s,b)+1;
606  //s[strlen(s)+1]='\0'; add an second \0 at the end of the string
607  s[rc]='\0';
608  // handel \\ :
609  rc-=3; if (rc<0) rc=0;
610  if ((s[rc]=='\\')&&(currentVoice->sw!=BI_buffer))
611  {
612  s[rc]='\0';
613  offset+=rc;
614  if (offset<(int)omSizeOfAddr(currentVoice->buffer)) goto NewRead;
615  }
616  goto NewBuff;
617  }
618  /* else if (s==NULL) */
619  {
620  const char *err;
621  switch(yy_noeof)
622  {
623  case noeof_brace:
624  case noeof_block:
625  err="{...}";
626  break;
627  case noeof_asstring:
628  err="till `.`";
629  break;
630  case noeof_string:
631  err="string";
632  break;
633  case noeof_bracket:
634  err="(...)";
635  break;
636  case noeof_procname:
637  err="proc";
638  break;
639  case noeof_comment:
640  err="/*...*/";
641  break;
642  default:
643  return 0;
644  }
645  Werror("premature end of file while reading %s",err);
646  return 0;

◆ if()

if ( yy_init  )

Definition at line 829 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 

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2336 of file scanner.cc.

2337 { YY_FLUSH_BUFFER;BEGIN(0); }

◆ myychangebuffer()

void myychangebuffer ( )

Definition at line 2329 of file scanner.cc.

◆ myynewbuffer()

void* myynewbuffer ( )

Definition at line 2315 of file scanner.cc.

2317 {
2318  void * oldb = YY_CURRENT_BUFFER;
2320  return oldb;

◆ myyoldbuffer()

void myyoldbuffer ( void *  oldb)

Definition at line 2322 of file scanner.cc.

2324 {
2326  yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
2327  //yy_flush_buffer((YY_BUFFER_STATE)oldb);

◆ while()

while ( )

Definition at line 853 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_match:
874  do
875  {
876  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
877  if ( yy_accept[yy_current_state] )
878  {
879  yy_last_accepting_state = yy_current_state;
881  }
882  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
883  {
884  yy_current_state = (int) yy_def[yy_current_state];
885  if ( yy_current_state >= 171 )
886  yy_c = yy_meta[(unsigned int) yy_c];
887  }
888  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
889  ++yy_cp;
890  }
891  while ( yy_base[yy_current_state] != 561 );
892 
893 yy_find_action:
894  yy_act = yy_accept[yy_current_state];
895  if ( yy_act == 0 )
896  { /* have to back up */
898  yy_current_state = yy_last_accepting_state;
899  yy_act = yy_accept[yy_current_state];
900  }
901 
903 
904 
905 do_action: /* This label is used only to access EOF actions. */
906 
907 
908  switch ( yy_act )
909  { /* beginning of action switch */
910  case 0: /* must back up */
911  /* undo the effects of YY_DO_BEFORE_ACTION */
912  *yy_cp = yy_hold_char;
914  yy_current_state = yy_last_accepting_state;
915  goto yy_find_action;
916 
917 case 1:
919 #line 122 "scanner.l"
920 { }
921  YY_BREAK
922 case 2:
924 #line 123 "scanner.l"
925 { }
926  YY_BREAK
927 case 3:
929 #line 124 "scanner.l"
930 {
932  loop
933  {
934  register int c;
935  while ( (c = yyinput()) != '*' && c != EOF );
936  if ( c == '*' )
937  {
938  while ( (c = yyinput()) == '*' );
939  if ( c == '/' ) break; /* found the end */
940  }
941  else
942  {
943  break;
944  }
945  }
946  yy_noeof=0;
947  }
948  YY_BREAK
949 case 4:
951 #line 142 "scanner.l"
952 { prompt_char='.';
954  return WHILE_CMD;}
955  YY_BREAK
956 case 5:
958 #line 145 "scanner.l"
959 { prompt_char='.';
961  return FOR_CMD;}
962  YY_BREAK
963 case 6:
965 #line 149 "scanner.l"
967  BEGIN(asstring);
968  return HELP_CMD;
969  }
970  YY_BREAK
971 case 7:
973 #line 154 "scanner.l"
975  BEGIN(asstring);
976  return EXAMPLE_CMD;
977  }
978  YY_BREAK
979 case 8:
981 #line 159 "scanner.l"
982 {
983  char c; char *cp;
984  lvalp->name = omStrDup(iiProcName((char *)yytext,c,cp));
986  blocknest = 1;
987  BEGIN(brace);
988  return PROC_DEF;
989  }
990  YY_BREAK
991 case 9:
993 #line 167 "scanner.l"
994 {
995  lvalp->name = omStrDup((char *)yytext);
996  yy_noeof = 0; BEGIN(INITIAL);
997  return STRINGTOK;
998  }
999  YY_BREAK
1000 case 10:
1002 #line 172 "scanner.l"
1003 {
1004  yy_noeof = 0; BEGIN(INITIAL);
1005  return *yytext;
1006  }
1007  YY_BREAK
1008 case 11:
1010 #line 177 "scanner.l"
1011 {
1013  BEGIN(bracestr);
1014  yymore();
1015  }
1016  YY_BREAK
1017 case 12:
1019 #line 182 "scanner.l"
1020 { if (blocknest++) yymore(); }
1021  YY_BREAK
1022 case 13:
1024 #line 183 "scanner.l"
1025 { if (blocknest) yymore(); }
1026  YY_BREAK
1027 case 14:
1029 #line 184 "scanner.l"
1030 {
1031  if (blocknest)
1032  {
1033  lvalp->name = dupyytext();
1034  return STRINGTOK;
1035  }
1036  }
1037  YY_BREAK
1038 case 15:
1040 #line 191 "scanner.l"
1041 {
1042  if (--blocknest <= 0)
1043  {
1044  yy_noeof = 0;
1045  BEGIN(INITIAL);
1046  lvalp->name = dupyytext();
1047  return STRINGTOK;
1048  }
1049  yymore();
1050  }
1051  YY_BREAK
1052 case 16:
1054 #line 201 "scanner.l"
1055 {
1057  BEGIN(brace);
1058  yymore();
1059  }
1060  YY_BREAK
1061 case 17:
1063 #line 206 "scanner.l"
1064 { yymore(); }
1065  YY_BREAK
1066 case 18:
1068 #line 207 "scanner.l"
1069 { return '('; }
1070  YY_BREAK
1071 case 19:
1073 #line 208 "scanner.l"
1074 { return ','; }
1075  YY_BREAK
1076 case 20:
1078 #line 209 "scanner.l"
1079 { ; }
1080  YY_BREAK
1081 case 21:
1083 #line 210 "scanner.l"
1084 {
1085  lvalp->name = omStrDup((char *)yytext);
1086  return STRINGTOK;
1087  }
1088  YY_BREAK
1089 case 22:
1091 #line 214 "scanner.l"
1092 {
1093  lvalp->name = omStrDup((char *)yytext);
1094  return STRINGTOK;
1095  }
1096  YY_BREAK
1097 case 23:
1099 #line 218 "scanner.l"
1100 {
1101  yy_noeof = 0; BEGIN(INITIAL);
1102  return ')';
1103  }
1104  YY_BREAK
1105 case 24:
1107 #line 223 "scanner.l"
1108 {
1110  blocknest = 1;
1112  BEGIN(block);
1113  }
1114  YY_BREAK
1115 case 25:
1117 #line 229 "scanner.l"
1118 {
1120  BEGIN(blockstr);
1121  yymore();
1122  }
1123  YY_BREAK
1124 case 26:
1126 #line 234 "scanner.l"
1127 { yymore(); }
1128  YY_BREAK
1129 case 27:
1131 #line 235 "scanner.l"
1132 { yymore(); }
1133  YY_BREAK
1134 case 28:
1136 #line 236 "scanner.l"
1137 { yymore(); }
1138  YY_BREAK
1139 case 29:
1141 #line 237 "scanner.l"
1142 {
1144  BEGIN(block);
1145  yymore();
1146  }
1147  YY_BREAK
1148 case 30:
1150 #line 242 "scanner.l"
1151 { yymore(); }
1152  YY_BREAK
1153 case 31:
1155 #line 243 "scanner.l"
1156 { yymore(); }
1157  YY_BREAK
1158 case 32:
1160 #line 244 "scanner.l"
1161 { blocknest++; yymore(); }
1162  YY_BREAK
1163 case 33:
1165 #line 245 "scanner.l"
1166 {
1167  if (--blocknest <= 0)
1168  {
1169  BEGIN(INITIAL);
1170  yy_noeof = 0;
1171  lvalp->name = dupyytextNL();
1172  return BLOCKTOK;
1173  }
1174  yymore();
1175  }
1176  YY_BREAK
1177 case 34:
1179 #line 255 "scanner.l"
1180 { BEGIN(string); yy_noeof = noeof_string;}
1181  YY_BREAK
1182 case 35:
1184 #line 256 "scanner.l"
1185 { return SYS_BREAK; }
1186  YY_BREAK
1187 case 36:
1189 #line 257 "scanner.l"
1190 { yymore(); }
1191  YY_BREAK
1192 case 37:
1194 #line 258 "scanner.l"
1195 { yymore(); }
1196  YY_BREAK
1197 case 38:
1199 #line 259 "scanner.l"
1200 { yymore(); }
1201  YY_BREAK
1202 case 39:
1204 #line 260 "scanner.l"
1205 {
1206  char * s;
1207  yy_noeof = 0;
1208  BEGIN(INITIAL);
1209  s = lvalp->name = dupyytext();
1210  while (*yytext)
1211  {
1212  if (*yytext == '\\') yytext++;
1213  *s++ = *yytext++;
1214  }
1215  *s++ = *yytext++;
1216  return STRINGTOK;
1217  }
1218  YY_BREAK
1219 case 40:
1221 #line 274 "scanner.l"
1222 /* skip whitespace */
1223  YY_BREAK
1224 case 41:
1226 #line 275 "scanner.l"
1227 { return DOTDOT; }
1228  YY_BREAK
1229 case 42:
1231 #line 276 "scanner.l"
1232 { return COLONCOLON; }
1233  YY_BREAK
1234 case 43:
1236 #line 277 "scanner.l"
1237 { return MINUSMINUS; }
1238  YY_BREAK
1239 case 44:
1241 #line 278 "scanner.l"
1242 { return PLUSPLUS ; }
1243  YY_BREAK
1244 case 45:
1246 #line 279 "scanner.l"
1247 { return EQUAL_EQUAL; }
1248  YY_BREAK
1249 case 46:
1251 #line 280 "scanner.l"
1252 { lvalp->i='&'; return LOGIC_OP; }
1253  YY_BREAK
1254 case 47:
1256 #line 281 "scanner.l"
1257 { lvalp->i='|'; return LOGIC_OP; }
1258  YY_BREAK
1259 case 48:
1261 #line 282 "scanner.l"
1262 { lvalp->i=LE; return COMP_OP; }
1263  YY_BREAK
1264 case 49:
1266 #line 283 "scanner.l"
1267 { lvalp->i=GE; return COMP_OP; }
1268  YY_BREAK
1269 case 50:
1271 #line 284 "scanner.l"
1272 { return NOT; }
1273  YY_BREAK
1274 case 51:
1276 #line 285 "scanner.l"
1277 { return NOTEQUAL; }
1278  YY_BREAK
1279 case 52:
1281 #line 286 "scanner.l"
1282 { return NOTEQUAL; }
1283  YY_BREAK
1284 case 53:
1286 #line 287 "scanner.l"
1287 { return '^'; }
1288  YY_BREAK
1289 case 54:
1291 #line 288 "scanner.l"
1292 { return ARROW; }
1293  YY_BREAK
1294 case 55:
1296 #line 289 "scanner.l"
1297 { return '\\'; }
1298  YY_BREAK
1299 case 56:
1301 #line 290 "scanner.l"
1302 {
1303  lvalp->name = omStrDup("\n");
1304  return STRINGTOK;
1305  }
1306  YY_BREAK
1307 case 57:
1309 #line 294 "scanner.l"
1310 {
1311  lvalp->name = (char *)yytext;
1312  return INT_CONST;
1313  }
1314  YY_BREAK
1315 case 58:
1317 #line 298 "scanner.l"
1318 {
1319  lvalp->name = (char *)yytext;
1320  return RINGVAR;
1321  }
1322  YY_BREAK
1323 case 59:
1325 #line 302 "scanner.l"
1326 {
1327  m2_end(-1);
1328  }
1329  YY_BREAK
1330 case 60:
1332 #line 305 "scanner.l"
1333 {
1334  #ifdef MM_STAT
1335  mmStat(-500);
1336  #endif
1337  #ifdef OM_TRACK
1338  #ifndef SING_NDEBUG
1339  omPrintUsedTrackAddrs(stdout, 10);
1340  #endif
1341  #endif
1342  m2_end(0);
1343  }
1344  YY_BREAK
1345 case 61:
1347 #line 317 "scanner.l"
1348 {
1349  lvalp->name = (char *)yytext;
1350  return RINGVAR;
1351  }
1352  YY_BREAK
1353 case 62:
1355 #line 321 "scanner.l"
1356 {
1357  lvalp->name = (char *)yytext;
1358  return RINGVAR;
1359  }
1360  YY_BREAK
1361 case 63:
1362 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
1363 yy_c_buf_p = yy_cp -= 1;
1364 YY_DO_BEFORE_ACTION; /* set up yytext again */
1366 #line 325 "scanner.l"
1367 {
1368  lvalp->name = (char *)yytext;
1369  return RINGVAR;
1370  }
1371  YY_BREAK
1372 case 64:
1374 #line 330 "scanner.l"
1375 {
1376  /* {name} */
1377  int rc=0;
1378  if (yytext[strlen((char *)yytext)-1] == '\n')
1379  {
1380  yytext[strlen((char *)yytext)-1] = '\0';
1381  }
1382  if (yyleng > 1)
1383  {
1384  rc = IsCmd((char *)yytext,lvalp->i);
1385  if (rc) return rc;
1386  }
1387  lvalp->name = omStrDup((char *)yytext);
1388  return UNKNOWN_IDENT;
1389  }
1390  YY_BREAK
1391 case 65:
1393 #line 346 "scanner.l"
1394 {
1395  /*if (*yytext == '\n') REJECT;*/
1396  register char ch= *yytext;
1397  lvalp->i = ch;
1398  switch(ch)
1399  {
1400  /* case '&': */
1401  case '|':
1402  return LOGIC_OP;
1403  /* case '/': */
1404  case '%':
1405  case '*':
1406  return MULDIV_OP;
1407  /* case '<': */
1408  case '>':
1409  return COMP_OP;
1410  default:
1411  break;
1412  }
1413  return ch;
1414  }
1415  YY_BREAK
1416 case 66:
1418 #line 367 "scanner.l"
1419 YY_FATAL_ERROR( "flex scanner jammed" );
1420  YY_BREAK
1421 case YY_STATE_EOF(INITIAL):
1422 case YY_STATE_EOF(string):
1423 case YY_STATE_EOF(block):
1424 case YY_STATE_EOF(blockstr):
1425 case YY_STATE_EOF(brace):
1426 case YY_STATE_EOF(bracestr):
1427 case YY_STATE_EOF(bracket):
1428 case YY_STATE_EOF(asstring):
1429  yyterminate();
1430 
1431  case YY_END_OF_BUFFER:
1432  {
1433  /* Amount of text matched not including the EOB char. */
1434  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1435 
1436  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1437  *yy_cp = yy_hold_char;
1439 
1440  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1441  {
1442  /* We're scanning a new file or input source. It's
1443  * possible that this happened because the user
1444  * just pointed yyin at a new source and called
1445  * yylex(). If so, then we have to assure
1446  * consistency between yy_current_buffer and our
1447  * globals. Here is the right place to do so, because
1448  * this is the first action (other than possibly a
1449  * back-up) that will match for the new input source.
1450  */
1451  yy_n_chars = yy_current_buffer->yy_n_chars;
1452  yy_current_buffer->yy_input_file = yyin;
1453  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1454  }
1455 
1456  /* Note that here we test for yy_c_buf_p "<=" to the position
1457  * of the first EOB in the buffer, since yy_c_buf_p will
1458  * already have been incremented past the NUL character
1459  * (since all states make transitions on EOB to the
1460  * end-of-buffer state). Contrast this with the test
1461  * in input().
1462  */
1463  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1464  { /* This was really a NUL. */
1465  yy_state_type yy_next_state;
1466 
1467  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1468 
1469  yy_current_state = yy_get_previous_state();
1470 
1471  /* Okay, we're now positioned to make the NUL
1472  * transition. We couldn't have
1473  * yy_get_previous_state() go ahead and do it
1474  * for us because it doesn't know how to deal
1475  * with the possibility of jamming (and we don't
1476  * want to build jamming into it because then it
1477  * will run more slowly).
1478  */
1479 
1480  yy_next_state = yy_try_NUL_trans( yy_current_state );
1481 
1483 
1484  if ( yy_next_state )
1485  {
1486  /* Consume the NUL. */
1487  yy_cp = ++yy_c_buf_p;
1488  yy_current_state = yy_next_state;
1489  goto yy_match;
1490  }
1491 
1492  else
1493  {
1494  yy_cp = yy_c_buf_p;
1495  goto yy_find_action;
1496  }
1497  }
1498 
1499  else switch ( yy_get_next_buffer() )
1500  {
1501  case EOB_ACT_END_OF_FILE:
1502  {
1504 
1505  if ( yywrap() )
1506  {
1507  /* Note: because we've taken care in
1508  * yy_get_next_buffer() to have set up
1509  * yytext, we can now set up
1510  * yy_c_buf_p so that if some total
1511  * hoser (like flex itself) wants to
1512  * call the scanner after we return the
1513  * YY_NULL, it'll still work - another
1514  * YY_NULL will get returned.
1515  */
1517 
1519  goto do_action;
1520  }
1521 
1522  else
1523  {
1525  YY_NEW_FILE;
1526  }
1527  break;
1528  }
1529 
1530  case EOB_ACT_CONTINUE_SCAN:
1531  yy_c_buf_p =
1532  yytext_ptr + yy_amount_of_matched_text;
1533 
1534  yy_current_state = yy_get_previous_state();
1535 
1536  yy_cp = yy_c_buf_p;
1538  goto yy_match;
1539 
1540  case EOB_ACT_LAST_MATCH:
1541  yy_c_buf_p =
1542  &yy_current_buffer->yy_ch_buf[yy_n_chars];
1543 
1544  yy_current_state = yy_get_previous_state();
1545 
1546  yy_cp = yy_c_buf_p;
1548  goto yy_find_action;
1549  }
1550  break;
1551  }
1552 
1553  default:
1555  "fatal flex scanner internal error--no action found" );
1556  } /* end of action switch */

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 1940 of file scanner.cc.

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

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 1971 of file scanner.cc.

1977  {
1978  if ( ! b )
1979  return;
1980 
1981  if ( b == yy_current_buffer )
1982  yy_current_buffer = (YY_BUFFER_STATE) 0;
1983 
1984  if ( b->yy_is_our_buffer )
1985  yy_flex_free( (void *) b->yy_ch_buf );
1986 
1987  yy_flex_free( (void *) b );

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 2204 of file scanner.cc.

2210  {
2211  (void) fprintf( stderr, "%s\n", msg );
2212  exit( YY_EXIT_FAILURE );

◆ yy_flex_alloc()

static void* yy_flex_alloc ( yy_size_t  size)
static

Definition at line 2268 of file scanner.cc.

2274  {
2275  return (void *) malloc( size );

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 2296 of file scanner.cc.

2302  {
2303  free( ptr );

◆ yy_flex_realloc()

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

Definition at line 2278 of file scanner.cc.

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

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 2024 of file scanner.cc.

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

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( )
static

Definition at line 1568 of file scanner.cc.

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

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( )
static

Definition at line 1700 of file scanner.cc.

1702  {
1703  register yy_state_type yy_current_state;
1704  register char *yy_cp;
1705 
1706  yy_current_state = yy_start;
1707 
1708  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1709  {
1710  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1711  if ( yy_accept[yy_current_state] )
1712  {
1713  yy_last_accepting_state = yy_current_state;
1715  }
1716  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1717  {
1718  yy_current_state = (int) yy_def[yy_current_state];
1719  if ( yy_current_state >= 171 )
1720  yy_c = yy_meta[(unsigned int) yy_c];
1721  }
1722  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1723  }
1724 
1725  return yy_current_state;

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 1997 of file scanner.cc.

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

◆ yy_load_buffer_state()

void yy_load_buffer_state ( void  )

Definition at line 1927 of file scanner.cc.

1932  {
1933  yy_n_chars = yy_current_buffer->yy_n_chars;
1934  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1935  yyin = yy_current_buffer->yy_input_file;

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

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

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 2110 of file scanner.cc.

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

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char *  yy_str)

Definition at line 2093 of file scanner.cc.

2099  {
2100  int len;
2101  for ( len = 0; yy_str[len]; ++len )
2102  ;
2103 
2104  return yy_scan_bytes( yy_str, len );

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 1897 of file scanner.cc.

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

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 1735 of file scanner.cc.

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

◆ yyinput()

static int yyinput ( )
static

Definition at line 1809 of file scanner.cc.

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

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 1882 of file scanner.cc.

1888  {
1889  if ( ! yy_current_buffer )
1891 
1892  yy_init_buffer( yy_current_buffer, input_file );

◆ yyunput()

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

Definition at line 1765 of file scanner.cc.

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

◆ yywrap()

int yywrap ( )

Definition at line 648 of file scanner.cc.

648 {

Variable Documentation

◆ blocknest

int blocknest = 0

Definition at line 580 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, 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 288 of file scanner.cc.

◆ yy_act

register int yy_act

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

◆ yy_bp

register char * yy_bp

Definition at line 823 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 823 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

Definition at line 821 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 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.

yy_bp
register char * yy_bp
Definition: scanner.cc:823
yy_noeof
int yy_noeof
Definition: fevoices.cc:44
yy_noeof
int yy_noeof
Definition: fevoices.cc:44
feProtFile
FILE * feProtFile
Definition: reporter.cc:56
yy_get_next_buffer
static int yy_get_next_buffer()
Definition: scanner.cc:1568
FALSE
#define FALSE
Definition: auxiliary.h:94
yy_buffer_state
Definition: libparse.cc:162
yy_more_len
static int yy_more_len
Definition: scanner.cc:553
MAX_FILE_BUFFER
#define MAX_FILE_BUFFER
Definition: fevoices.cc:37
PROC_DEF
Definition: grammar.cc:334
omPrintUsedTrackAddrs
void omPrintUsedTrackAddrs(FILE *fd, int max_frames)
Definition: omDebugCheck.c:571
yyleng
int yyleng
Definition: scanner.cc:216
INITIAL
#define INITIAL
Definition: scanner.cc:559
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: scanner.cc:187
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: scanner.cc:94
MULDIV_OP
#define MULDIV_OP
Definition: tok.h:25
REGISTER
#define REGISTER
Definition: omalloc.h:19
SEEK_SET
#define SEEK_SET
Definition: mod2.h:112
bracket
#define bracket
Definition: scanner.cc:672
yy_c_buf_p
static char * yy_c_buf_p
Definition: scanner.cc:219
Voice::buffer
char * buffer
Definition: fevoices.h:68
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: scanner.cc:186
iiProcName
char * iiProcName(char *buf, char &ct, char *&e)
Definition: iplib.cc:94
UNKNOWN_IDENT
Definition: grammar.cc:332
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: scanner.cc:89
noeof_asstring
Definition: fevoices.h:36
omFree
#define omFree(addr)
Definition: omAllocDecl.h:259
omSizeOfAddr
size_t omSizeOfAddr(const void *addr)
Definition: omAllocSystem.c:98
YY_NEW_FILE
#define YY_NEW_FILE
Definition: scanner.cc:92
INT_CONST
Definition: grammar.cc:331
YY_USER_INIT
#define YY_USER_INIT
Definition: libparse.cc:1207
yy_base
static yyconst short int yy_base[192]
Definition: scanner.cc:351
dupyytextNL
static char * dupyytextNL()
Definition: scanner.cc:624
yy_last_accepting_state
static yy_state_type yy_last_accepting_state
Definition: scanner.cc:545
yyterminate
#define yyterminate()
Definition: scanner.cc:785
yy_current_buffer
static YY_BUFFER_STATE yy_current_buffer
Definition: scanner.cc:201
COLONCOLON
Definition: grammar.cc:275
NOT
Definition: grammar.cc:272
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: scanner.cc:198
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
noeof_procname
Definition: fevoices.h:40
yy_flex_free
static void yy_flex_free(void *ptr)
Definition: scanner.cc:2296
BEGIN
#define BEGIN
Definition: scanner.cc:79
CxxTest::base
char N base
Definition: ValueTraits.h:144
free
#define free
Definition: scanner.cc:614
BLOCKTOK
Definition: grammar.cc:330
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition: scanner.cc:1735
yymore
#define yymore()
Definition: scanner.cc:554
bracestr
#define bracestr
Definition: scanner.cc:670
yy_def
static yyconst short int yy_def[192]
Definition: scanner.cc:377
yylineno
int yylineno
Definition: febase.cc:39
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: scanner.cc:226
YY_FLUSH_BUFFER
#define YY_FLUSH_BUFFER
Definition: scanner.cc:236
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:261
yy_delete_buffer
void yy_delete_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:1971
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: scanner.cc:795
yy_create_buffer
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size)
Definition: scanner.cc:1940
blockstr
#define blockstr
Definition: scanner.cc:666
yyinput
static int yyinput()
Definition: scanner.cc:1809
noeof_bracket
Definition: fevoices.h:38
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: scanner.cc:652
yy_nxt
static yyconst short int yy_nxt[610]
Definition: scanner.cc:403
yy_accept
static yyconst short int yy_accept[171]
Definition: scanner.cc:288
fe_fgets_stdin
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition: feread.cc:34
yy_flush_buffer
void yy_flush_buffer(YY_BUFFER_STATE b)
Definition: scanner.cc:2024
yy_ec
static yyconst int yy_ec[256]
Definition: scanner.cc:310
loop
#define loop
Definition: structs.h:77
b
CanonicalForm b
Definition: cfModGcd.cc:4044
m2_end
void m2_end(int i)
Definition: misc_ip.cc:1099
malloc
#define malloc
Definition: scanner.cc:609
yyrestart
void yyrestart(FILE *input_file)
Definition: scanner.cc:1882
yy_get_previous_state
static yy_state_type yy_get_previous_state()
Definition: scanner.cc:1700
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: scanner.cc:746
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: scanner.cc:105
TRUE
#define TRUE
Definition: auxiliary.h:98
i
int i
Definition: cfEzgcd.cc:125
YY_BREAK
#define YY_BREAK
Definition: scanner.cc:814
block
#define block
Definition: scanner.cc:664
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: scanner.cc:556
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: scanner.cc:106
buf
int status int void * buf
Definition: si_signals.h:58
YY_CHAR
unsigned char YY_CHAR
Definition: libparse.cc:282
BI_buffer
Definition: fevoices.h:30
yy_meta
static yyconst int yy_meta[49]
Definition: scanner.cc:342
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
WHILE_CMD
Definition: grammar.cc:345
SYS_BREAK
Definition: grammar.cc:344
yy_hold_char
static char yy_hold_char
Definition: scanner.cc:211
brace
#define brace
Definition: scanner.cc:668
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: scanner.cc:97
yy_flex_alloc
static void * yy_flex_alloc(yy_size_t size)
Definition: scanner.cc:2268
currentVoice
Voice * currentVoice
Definition: fevoices.cc:46
yy_size_t
unsigned int yy_size_t
Definition: libparse.cc:159
yytext
char * yytext
Definition: scanner.cc:557
EXAMPLE_CMD
Definition: grammar.cc:321
yy_state_type
int yy_state_type
Definition: libparse.cc:284
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: scanner.cc:73
yywrap
int yywrap()
Definition: scanner.cc:648
yytext_ptr
#define yytext_ptr
Definition: scanner.cc:268
yyout
FILE * yyout
Definition: scanner.cc:265
feShowPrompt
static void feShowPrompt(void)
Definition: fevoices.cc:399
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
EQUAL_EQUAL
Definition: grammar.cc:268
RINGVAR
Definition: grammar.cc:333
yyin
FILE * yyin
Definition: scanner.cc:265
LE
Definition: grammar.cc:270
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:208
PLUSPLUS
Definition: grammar.cc:274
BI_stdin
Definition: fevoices.h:29
noeof_brace
Definition: fevoices.h:35
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: scanner.cc:278
noeof_block
Definition: fevoices.h:37
yy_chk
static yyconst short int yy_chk[610]
Definition: scanner.cc:474
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: scanner.cc:817
yy_init_buffer
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file)
Definition: scanner.cc:1997
LOGIC_OP
#define LOGIC_OP
Definition: tok.h:24
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: scanner.cc:555
yy_n_chars
static int yy_n_chars
Definition: scanner.cc:213
fe_promptstr
char fe_promptstr[]
Definition: fevoices.cc:31
SI_PROT_I
#define SI_PROT_I
Definition: reporter.h:51
inerror
int inerror
Definition: grammar.cc:175
yy_act
register int yy_act
Definition: scanner.cc:824
IsCmd
int IsCmd(const char *n, int &tok)
Definition: iparith.cc:8679
ARROW
Definition: grammar.cc:276
dupyytext
static char * dupyytext()
Definition: scanner.cc:615
yy_start
static int yy_start
Definition: scanner.cc:221
Print
#define Print
Definition: emacs.cc:79
omMarkAsStaticAddr
void omMarkAsStaticAddr(void *addr)
yy_more_flag
static int yy_more_flag
Definition: scanner.cc:552
Werror
void Werror(const char *fmt,...)
Definition: reporter.cc:188
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: scanner.cc:287
noeof_string
Definition: fevoices.h:41
Voice::files
FILE * files
Definition: fevoices.h:66
yy_flex_realloc
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: scanner.cc:2278
fePrintEcho
static int fePrintEcho(char *anf, char *)
Definition: fevoices.cc:407
NULL
#define NULL
Definition: omList.c:9
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: scanner.cc:2200
l
int l
Definition: cfEzgcd.cc:93
yy_init
static int yy_init
Definition: scanner.cc:220
yy_blocklineno
int yy_blocklineno
Definition: fevoices.cc:45
YY_START
#define YY_START
Definition: scanner.cc:85
GE
Definition: grammar.cc:269
HELP_CMD
Definition: grammar.cc:323
s
const CanonicalForm int s
Definition: facAbsFact.cc:55
offset
int offset
Definition: libparse.cc:1090
asstring
#define asstring
Definition: scanner.cc:674
NOTEQUAL
Definition: grammar.cc:273
Voice::ftellptr
long ftellptr
Definition: fevoices.h:70
yy_last_accepting_cpos
static char * yy_last_accepting_cpos
Definition: scanner.cc:546
yy_load_buffer_state
void yy_load_buffer_state(void)
Definition: scanner.cc:1927
feProt
int feProt
Definition: reporter.cc:55
yy_switch_to_buffer
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer)
Definition: scanner.cc:1897
yy_scan_buffer
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size)
Definition: scanner.cc:2055
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: scanner.cc:207
FOR_CMD
Definition: grammar.cc:342
MINUSMINUS
Definition: grammar.cc:271
yy_cp
register char * yy_cp
Definition: scanner.cc:823
noeof_comment
Definition: fevoices.h:39
prompt_char
char prompt_char
Definition: febase.cc:38
BI_file
Definition: fevoices.h:31
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: scanner.cc:104
STRINGTOK
Definition: grammar.cc:329
blocknest
int blocknest
Definition: scanner.cc:580
COMP_OP
#define COMP_OP
Definition: tok.h:26
Voice::fptr
long fptr
Definition: fevoices.h:69
Voice::sw
feBufferInputs sw
Definition: fevoices.h:75
string
#define string
Definition: scanner.cc:662
realloc
#define realloc
Definition: scanner.cc:611
yy_scan_bytes
YY_BUFFER_STATE yy_scan_bytes(yyconst char *bytes, int len)
Definition: scanner.cc:2110
DOTDOT
Definition: grammar.cc:267