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

Go to the source code of this file.

Data Structures

struct  YY_BUFFER_STATE
 

Macros

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

Typedefs

typedef unsigned int yy_size_t
 
typedef unsigned char YY_CHAR
 
typedef int yy_state_type
 

Functions

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

Variables

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

Data Structure Documentation

◆ yy_buffer_state

struct yy_buffer_state

Definition at line 164 of file libparse.cc.

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

Macro Definition Documentation

◆ ALLOC

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

Definition at line 579 of file scanner.cc.

◆ asstring

#define asstring   7

Definition at line 656 of file scanner.cc.

◆ BEGIN

#define BEGIN   yy_start = 1 + 2 *

Definition at line 80 of file scanner.cc.

◆ block

#define block   2

Definition at line 646 of file scanner.cc.

◆ blockstr

#define blockstr   3

Definition at line 648 of file scanner.cc.

◆ brace

#define brace   4

Definition at line 650 of file scanner.cc.

◆ bracestr

#define bracestr   5

Definition at line 652 of file scanner.cc.

◆ bracket

#define bracket   6

Definition at line 654 of file scanner.cc.

◆ ECHO

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

Definition at line 737 of file scanner.cc.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 105 of file scanner.cc.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 106 of file scanner.cc.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 107 of file scanner.cc.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 7 of file scanner.cc.

◆ free

#define free   omFree

Definition at line 594 of file scanner.cc.

◆ INITIAL

#define INITIAL   0

Definition at line 560 of file scanner.cc.

◆ malloc

#define malloc   omAlloc

Definition at line 590 of file scanner.cc.

◆ realloc

#define realloc   omRealloc

Definition at line 592 of file scanner.cc.

◆ REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 552 of file scanner.cc.

◆ string

#define string   1

Definition at line 644 of file scanner.cc.

◆ unput

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

Definition at line 136 of file scanner.cc.

◆ YY_ALWAYS_INTERACTIVE

#define YY_ALWAYS_INTERACTIVE   1

Definition at line 643 of file scanner.cc.

◆ YY_AT_BOL

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 263 of file scanner.cc.

◆ YY_BREAK

#define YY_BREAK   break;

Definition at line 796 of file scanner.cc.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 98 of file scanner.cc.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 199 of file scanner.cc.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 187 of file scanner.cc.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 188 of file scanner.cc.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 208 of file scanner.cc.

◆ YY_DECL

#define YY_DECL   int yylex(YYSTYPE* lvalp)

Definition at line 626 of file scanner.cc.

◆ YY_DO_BEFORE_ACTION

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

Definition at line 279 of file scanner.cc.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   67

Definition at line 288 of file scanner.cc.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 95 of file scanner.cc.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 2182 of file scanner.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 777 of file scanner.cc.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 8 of file scanner.cc.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 9 of file scanner.cc.

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )

Definition at line 237 of file scanner.cc.

◆ YY_INPUT

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

Definition at line 634 of file scanner.cc.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ   yy_more_len

Definition at line 556 of file scanner.cc.

◆ yy_new_buffer

#define yy_new_buffer   yy_create_buffer

Definition at line 247 of file scanner.cc.

◆ YY_NEW_FILE

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 93 of file scanner.cc.

◆ YY_NO_POP_STATE

#define YY_NO_POP_STATE   1

Definition at line 707 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 706 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 708 of file scanner.cc.

◆ YY_NULL

#define YY_NULL   0

Definition at line 67 of file scanner.cc.

◆ YY_NUM_RULES

#define YY_NUM_RULES   66

Definition at line 287 of file scanner.cc.

◆ YY_PROTO

#define YY_PROTO (   proto)    proto

Definition at line 61 of file scanner.cc.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 728 of file scanner.cc.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 557 of file scanner.cc.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP    YY_USER_ACTION

Definition at line 799 of file scanner.cc.

◆ YY_SC_TO_UI

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

Definition at line 74 of file scanner.cc.

◆ yy_set_bol

#define yy_set_bol (   at_bol)
Value:
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer->yy_at_bol = at_bol; \
}
#define yy_create_buffer
Definition: libparse.cc:1
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_is_interactive = is_interactive; \
}

Definition at line 249 of file scanner.cc.

◆ YY_START

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

Definition at line 86 of file scanner.cc.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 772 of file scanner.cc.

◆ YY_STATE_EOF

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

Definition at line 90 of file scanner.cc.

◆ YY_USE_CONST

#define YY_USE_CONST

Definition at line 32 of file scanner.cc.

◆ YY_USE_PROTOS

#define YY_USE_PROTOS

Definition at line 29 of file scanner.cc.

◆ YY_USER_ACTION

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

Definition at line 638 of file scanner.cc.

◆ yyconst

#define yyconst   const

Definition at line 54 of file scanner.cc.

◆ yyless [1/2]

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

Definition at line 2201 of file scanner.cc.

◆ yyless [2/2]

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up yytext. */ \
yy_c_buf_p = yytext + n; \
*yy_c_buf_p = '\0'; \
yyleng = n; \
} \
while ( 0 )

Definition at line 2201 of file scanner.cc.

◆ yymore

#define yymore ( )    (yy_more_flag = 1)

Definition at line 555 of file scanner.cc.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 87 of file scanner.cc.

◆ yyterminate

#define yyterminate ( )    return YY_NULL

Definition at line 767 of file scanner.cc.

◆ yytext_ptr

#define yytext_ptr   yytext

Definition at line 269 of file scanner.cc.

Typedef Documentation

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 265 of file scanner.cc.

◆ yy_size_t

typedef unsigned int yy_size_t

Definition at line 142 of file scanner.cc.

◆ yy_state_type

typedef int yy_state_type

Definition at line 267 of file scanner.cc.

Function Documentation

◆ dupyytext()

static char * dupyytext ( )
static

Definition at line 597 of file scanner.cc.

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

◆ dupyytextNL()

static char * dupyytextNL ( )
static

Definition at line 606 of file scanner.cc.

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

◆ feReadLine()

int feReadLine ( char *  b,
int  l 
)

Definition at line 500 of file fevoices.cc.

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

◆ if()

if ( yy_init  )

Definition at line 811 of file scanner.cc.

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

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2318 of file scanner.cc.

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

◆ myychangebuffer()

void myychangebuffer ( )

Definition at line 2311 of file scanner.cc.

2312{
2313 yy_flush_buffer((YY_BUFFER_STATE)YY_CURRENT_BUFFER);
2316}
#define yy_switch_to_buffer
Definition: libparse.cc:10
#define yy_flush_buffer
Definition: libparse.cc:8
#define yy_delete_buffer
Definition: libparse.cc:2
#define YY_CURRENT_BUFFER
Definition: scanner.cc:208

◆ myynewbuffer()

void * myynewbuffer ( )

Definition at line 2297 of file scanner.cc.

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

◆ myyoldbuffer()

void myyoldbuffer ( void *  oldb)

Definition at line 2304 of file scanner.cc.

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

◆ while()

while ( )

Definition at line 835 of file scanner.cc.

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

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 1922 of file scanner.cc.

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

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 1953 of file scanner.cc.

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

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 2186 of file scanner.cc.

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

◆ yy_flex_alloc()

static void * yy_flex_alloc ( yy_size_t  size)
static

Definition at line 2250 of file scanner.cc.

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

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 2278 of file scanner.cc.

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

◆ yy_flex_realloc()

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

Definition at line 2260 of file scanner.cc.

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

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 2006 of file scanner.cc.

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

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( )
static

Definition at line 1550 of file scanner.cc.

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

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( )
static

Definition at line 1682 of file scanner.cc.

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

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 1979 of file scanner.cc.

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

◆ yy_load_buffer_state()

void yy_load_buffer_state ( void  )

Definition at line 1909 of file scanner.cc.

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

◆ YY_PROTO() [1/15]

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

◆ YY_PROTO() [2/15]

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

◆ YY_PROTO() [3/15]

void yyrestart YY_PROTO ( (FILE *input_file)  )

◆ YY_PROTO() [4/15]

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

◆ YY_PROTO() [5/15]

static void yy_flex_free YY_PROTO ( (void *)  )
static

◆ YY_PROTO() [6/15]

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

◆ YY_PROTO() [7/15]

void yy_load_buffer_state YY_PROTO ( (void)  )

◆ YY_PROTO() [8/15]

void yy_delete_buffer YY_PROTO ( (YY_BUFFER_STATE b )

◆ YY_PROTO() [9/15]

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

◆ YY_PROTO() [10/15]

void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer)  )

◆ YY_PROTO() [11/15]

static void *yy_flex_alloc YY_PROTO ( (yy_size_t )
static

◆ YY_PROTO() [12/15]

static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  )
static

◆ YY_PROTO() [13/15]

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

◆ YY_PROTO() [14/15]

YY_BUFFER_STATE yy_scan_string YY_PROTO ( (yyconst char *yy_str)  )

◆ YY_PROTO() [15/15]

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

◆ yy_scan_buffer()

YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Definition at line 2037 of file scanner.cc.

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

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 2092 of file scanner.cc.

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

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char *  yy_str)

Definition at line 2075 of file scanner.cc.

2080 {
2081 int len;
2082 for ( len = 0; yy_str[len]; ++len )
2083 ;
2084
2085 return yy_scan_bytes( yy_str, len );
2086 }
#define yy_scan_bytes
Definition: libparse.cc:5

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 1879 of file scanner.cc.

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

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 1717 of file scanner.cc.

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

◆ yyinput()

static int yyinput ( )
static

Definition at line 1791 of file scanner.cc.

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

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 1864 of file scanner.cc.

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

◆ yyunput()

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

Definition at line 1747 of file scanner.cc.

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

◆ yywrap()

int yywrap ( )

Definition at line 630 of file scanner.cc.

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

Variable Documentation

◆ blocknest

VAR int blocknest = 0

Definition at line 582 of file scanner.cc.

◆ inerror

EXTERN_VAR int inerror

Definition at line 586 of file scanner.cc.

◆ yy_accept

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

Definition at line 289 of file scanner.cc.

◆ yy_act

register int yy_act

Definition at line 806 of file scanner.cc.

◆ yy_base

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

Definition at line 352 of file scanner.cc.

◆ yy_bp

register char * yy_bp

Definition at line 805 of file scanner.cc.

◆ yy_c_buf_p

STATIC_VAR char* yy_c_buf_p = (char *) 0

Definition at line 220 of file scanner.cc.

◆ yy_chk

yyconst short int yy_chk[610]
static

Definition at line 475 of file scanner.cc.

◆ yy_cp

register char* yy_cp

Definition at line 805 of file scanner.cc.

◆ yy_current_buffer

STATIC_VAR YY_BUFFER_STATE yy_current_buffer = 0

Definition at line 202 of file scanner.cc.

◆ YY_DECL

YY_DECL
Initial value:
{
register yy_state_type yy_current_state

Definition at line 802 of file scanner.cc.

◆ yy_def

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

Definition at line 378 of file scanner.cc.

◆ yy_did_buffer_switch_on_eof

STATIC_VAR int yy_did_buffer_switch_on_eof

Definition at line 227 of file scanner.cc.

◆ yy_ec

yyconst int yy_ec[256]
static

Definition at line 311 of file scanner.cc.

◆ yy_hold_char

STATIC_VAR char yy_hold_char

Definition at line 212 of file scanner.cc.

◆ yy_init

STATIC_VAR int yy_init = 1

Definition at line 221 of file scanner.cc.

◆ yy_last_accepting_cpos

STATIC_VAR char* yy_last_accepting_cpos

Definition at line 547 of file scanner.cc.

◆ yy_last_accepting_state

STATIC_VAR yy_state_type yy_last_accepting_state

Definition at line 546 of file scanner.cc.

◆ yy_meta

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

Definition at line 343 of file scanner.cc.

◆ yy_more_flag

STATIC_VAR int yy_more_flag = 0

Definition at line 553 of file scanner.cc.

◆ yy_more_len

STATIC_VAR int yy_more_len = 0

Definition at line 554 of file scanner.cc.

◆ yy_n_chars

STATIC_VAR int yy_n_chars

Definition at line 214 of file scanner.cc.

◆ yy_nxt

yyconst short int yy_nxt[610]
static

Definition at line 404 of file scanner.cc.

◆ yy_start

STATIC_VAR int yy_start = 0

Definition at line 222 of file scanner.cc.

◆ yyin

VAR FILE* yyin = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yyleng

EXTERN_VAR int yyleng

Definition at line 102 of file scanner.cc.

◆ yyout

VAR FILE * yyout = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yytext

EXTERN_VAR char* yytext

Definition at line 268 of file scanner.cc.