My Project
Loading...
Searching...
No Matches
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)
 
#define YY_NULL   0
 
#define YY_SC_TO_UI(c)
 
#define BEGIN   yy_start = 1 + 2 *
 
#define YY_START   ((yy_start - 1) / 2)
 
#define YYSTATE   YY_START
 
#define YY_STATE_EOF(state)
 
#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)
 
#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()
 
#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()
 
#define YY_MORE_ADJ   yy_more_len
 
#define YY_RESTORE_YY_MORE_OFFSET
 
#define INITIAL   0
 
#define ALLOC(a)
 
#define malloc   omAlloc
 
#define realloc   omRealloc
 
#define free   omFree
 
#define YY_DECL   int yylex(YYSTYPE* lvalp)
 
#define YY_INPUT(buf, result, 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()
 
#define YY_START_STACK_INCR   25
 
#define YY_FATAL_ERROR(msg)
 
#define YY_BREAK   break;
 
#define YY_RULE_SETUP    YY_USER_ACTION
 
#define YY_EXIT_FAILURE   2
 
#define yyless(n)
 

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)
Value:
omAlloc((a))
#define omAlloc(size)

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)
Value:
#define yytext_ptr
Definition libparse.cc:288
static void yyunput(int c, REGISTER char *yy_bp)
Definition libparse.cc:2795

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 ( )
Value:
(yy_current_buffer->yy_at_bol)
STATIC_VAR YY_BUFFER_STATE yy_current_buffer
Definition libparse.cc:221

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'; \
#define yyleng
Definition libparse.cc:12
REGISTER char * yy_bp
Definition libparse.cc:1414
REGISTER char * yy_cp
Definition libparse.cc:1414
STATIC_VAR char yy_hold_char
Definition libparse.cc:231
STATIC_VAR char * yy_c_buf_p
Definition libparse.cc:239
STATIC_VAR int yy_more_len
Definition libparse.cc:1045

Definition at line 279 of file scanner.cc.

279#define YY_DO_BEFORE_ACTION \
280 yytext_ptr = yy_bp; \
281 yytext_ptr -= yy_more_len; \
282 yyleng = (int) (yy_cp - yytext_ptr); \
283 yy_hold_char = *yy_cp; \
284 *yy_cp = '\0'; \
285 yy_c_buf_p = yy_cp;

◆ 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)
Value:
static void yy_fatal_error(yyconst char msg[])
Definition libparse.cc:3235

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 )
Value:
result = feReadLine( (char *) (buf), (max_size) )
return result
int feReadLine(char *b, int l)
Definition fevoices.cc:500
int status int void * buf
Definition si_signals.h:69

Definition at line 634 of file scanner.cc.

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

◆ 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)
Value:
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.

799#define YY_RULE_SETUP \
800 YY_USER_ACTION

◆ YY_SC_TO_UI

#define YY_SC_TO_UI ( c)
Value:
((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 yyin
Definition libparse.cc:11
#define yy_create_buffer
Definition libparse.cc:1
#define YY_BUF_SIZE
Definition libparse.cc:117

Definition at line 256 of file scanner.cc.

256#define yy_set_bol(at_bol) \
257 { \
258 if ( ! yy_current_buffer ) \
259 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
260 yy_current_buffer->yy_at_bol = at_bol; \
261 }

◆ 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.

249#define yy_set_interactive(is_interactive) \
250 { \
251 if ( ! yy_current_buffer ) \
252 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
253 yy_current_buffer->yy_is_interactive = is_interactive; \
254 }

◆ 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)
Value:
(YY_END_OF_BUFFER + state + 1)
#define YY_END_OF_BUFFER
Definition libparse.cc:307

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 int inerror
#define yytext
Definition libparse.cc:16

Definition at line 638 of file scanner.cc.

638 #define YY_USER_ACTION \
639 if ((inerror==1)&&(*yytext>=' '))\
640 { Print(" skipping text from `%s`",yytext);inerror=2; }

◆ 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 libparse.cc:1047
#define YY_DO_BEFORE_ACTION
Definition libparse.cc:298

Definition at line 125 of file scanner.cc.

125#define yyless(n) \
126 do \
127 { \
128 /* Undo effects of setting up yytext. */ \
129 *yy_cp = yy_hold_char; \
130 YY_RESTORE_YY_MORE_OFFSET \
131 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
132 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
133 } \
134 while ( 0 )

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

125#define yyless(n) \
126 do \
127 { \
128 /* Undo effects of setting up yytext. */ \
129 *yy_cp = yy_hold_char; \
130 YY_RESTORE_YY_MORE_OFFSET \
131 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
132 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
133 } \
134 while ( 0 )

◆ yymore

#define yymore ( )
Value:
STATIC_VAR int yy_more_flag
Definition libparse.cc:1044

Definition at line 555 of file scanner.cc.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 87 of file scanner.cc.

◆ yyterminate

#define yyterminate ( )
Value:
return YY_NULL
#define YY_NULL
Definition libparse.cc:86

Definition at line 767 of file scanner.cc.

◆ yytext_ptr

#define yytext_ptr   yytext

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

◆ feReadLine()

int feReadLine ( char * b,
int l )

Definition at line 500 of file fevoices.cc.

501{
502 char *s=NULL;
503 int offset = 0; /* will not be used if s==NULL*/
504 // try to read from the buffer into b, max l chars
505 if (currentVoice!=NULL)
506 {
507 if((currentVoice->buffer!=NULL)
508 && (currentVoice->buffer[currentVoice->fptr]!='\0'))
509 {
510 NewBuff:
511 REGISTER int i=0;
512 long startfptr=currentVoice->fptr;
513 long tmp_ptr=currentVoice->fptr;
514 l--;
515 loop
516 {
517 REGISTER char c=
518 b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
519 i++;
521 {
522 if (c<' ') yylineno++;
523 else if (c=='}') break;
524 }
525 else
526 {
527 if ((c<' ') ||
528 (c==';') ||
529 (c==')')
530 )
531 break;
532 }
533 if (i>=l) break;
534 tmp_ptr++;/*currentVoice->fptr++;*/
535 if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
536 }
537 currentVoice->fptr=tmp_ptr;
538 b[i]='\0';
539 if (currentVoice->sw==BI_buffer)
540 {
541 BOOLEAN show_echo=FALSE;
542 char *anf;
543 long len;
544 if (startfptr==0)
545 {
546 anf=currentVoice->buffer;
547 const char *ss=strchr(anf,'\n');
548 if (ss==NULL) len=strlen(anf);
549 else len=ss-anf;
550 show_echo=TRUE;
551 }
552 else if /*(startfptr>0) &&*/
553 (currentVoice->buffer[startfptr-1]=='\n')
554 {
555 anf=currentVoice->buffer+startfptr;
556 const char *ss=strchr(anf,'\n');
557 if (ss==NULL) len=strlen(anf);
558 else len=ss-anf;
559 yylineno++;
560 show_echo=TRUE;
561 }
562 if (show_echo)
563 {
564 char *s=(char *)omAlloc(len+2);
565 strncpy(s,anf,len+2);
566 s[len+1]='\0';
567 fePrintEcho(s,b);
568 omFree((ADDRESS)s);
569 }
570 }
571 currentVoice->fptr++;
572 return i;
573 }
574 // no buffer there or e-o-buffer or eoln:
575 if (currentVoice->sw!=BI_buffer)
576 {
577 currentVoice->fptr=0;
578 if (currentVoice->buffer==NULL)
579 {
580 currentVoice->buff_size=MAX_FILE_BUFFER-sizeof(ADDRESS);
581 currentVoice->buffer=(char *)omAlloc(currentVoice->buff_size);
583 }
584 }
585 offset=0;
586 NewRead:
587 yylineno++;
588 if (currentVoice->sw==BI_stdin)
589 {
590 feShowPrompt();
592 &(currentVoice->buffer[offset]),
593 currentVoice->buff_size-1-offset);
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 {
600 fseek(currentVoice->files,currentVoice->ftellptr,SEEK_SET);
601 s=fgets(currentVoice->buffer+offset,(MAX_FILE_BUFFER-1-sizeof(ADDRESS))-offset,
602 currentVoice->files);
603 if (s!=NULL)
604 {
605 currentVoice->ftellptr=ftell(currentVoice->files);
606 // ftell returns -1 for non-seekable streams, such as pipes
607 if (currentVoice->ftellptr<0)
608 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:88
#define TRUE
Definition auxiliary.h:101
#define FALSE
Definition auxiliary.h:97
void * ADDRESS
Definition auxiliary.h:120
int l
Definition cfEzgcd.cc:100
CanonicalForm b
Definition cfModGcd.cc:4111
VAR int yylineno
Definition febase.cc:40
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition feread.cc:32
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
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)
#define NULL
Definition omList.c:12
#define REGISTER
Definition omalloc.h:27
#define MAX_FILE_BUFFER
Definition reporter.cc:38
VAR int feProt
Definition reporter.cc:56
VAR FILE * feProtFile
Definition reporter.cc:57
void Werror(const char *fmt,...)
Definition reporter.cc:189
EXTERN_VAR int yy_noeof
Definition reporter.h:19
#define SI_PROT_I
Definition reporter.h:53
#define loop
Definition structs.h:71

◆ 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 yyout
Definition libparse.cc:14
#define YY_USER_INIT
Definition libparse.cc:1210
STATIC_VAR int yy_start
Definition libparse.cc:241
STATIC_VAR int yy_init
Definition libparse.cc:240
void yy_load_buffer_state(void)
Definition scanner.cc:1909

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2318 of file scanner.cc.

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

◆ 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_CURRENT_BUFFER
Definition libparse.cc:227
#define yy_flush_buffer
Definition libparse.cc:8
#define yy_delete_buffer
Definition libparse.cc:2

◆ 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 ( 1 )

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 {
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 */
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
EXTERN_VAR int blocknest
Definition fevoices.cc:45
@ PLUSPLUS
Definition grammar.cc:274
@ NOT
Definition grammar.cc:272
@ MINUSMINUS
Definition grammar.cc:271
@ EXAMPLE_CMD
Definition grammar.cc:324
@ SYS_BREAK
Definition grammar.cc:347
@ ARROW
Definition grammar.cc:276
@ GE
Definition grammar.cc:269
@ EQUAL_EQUAL
Definition grammar.cc:268
@ INT_CONST
Definition grammar.cc:334
@ BLOCKTOK
Definition grammar.cc:333
@ LE
Definition grammar.cc:270
@ MONOM
Definition grammar.cc:336
@ UNKNOWN_IDENT
Definition grammar.cc:335
@ FOR_CMD
Definition grammar.cc:345
@ NOTEQUAL
Definition grammar.cc:273
@ STRINGTOK
Definition grammar.cc:332
@ DOTDOT
Definition grammar.cc:267
@ PROC_DEF
Definition grammar.cc:337
@ COLONCOLON
Definition grammar.cc:275
@ WHILE_CMD
Definition grammar.cc:348
@ HELP_CMD
Definition grammar.cc:326
int IsCmd(const char *n, int &tok)
Definition iparith.cc:9738
char * iiProcName(char *buf, char &ct, char *&e)
Definition iplib.cc:100
#define YY_NEW_FILE
Definition libparse.cc:112
unsigned char YY_CHAR
Definition libparse.cc:284
#define string
Definition libparse.cc:1252
#define YY_BREAK
Definition libparse.cc:1402
static yyconst int yy_ec[256]
Definition libparse.cc:365
STATIC_VAR int yy_n_chars
Definition libparse.cc:233
#define YY_BUFFER_NEW
Definition libparse.cc:206
#define YY_RESTORE_YY_MORE_OFFSET
Definition libparse.cc:1048
#define YY_BUFFER_NORMAL
Definition libparse.cc:207
#define YY_RULE_SETUP
Definition libparse.cc:1405
static yyconst short int yy_base[533]
Definition libparse.cc:407
#define EOB_ACT_END_OF_FILE
Definition libparse.cc:125
STATIC_VAR int yy_did_buffer_switch_on_eof
Definition libparse.cc:246
#define YY_START
Definition libparse.cc:105
int yy_state_type
Definition libparse.cc:286
REGISTER int yy_act
Definition libparse.cc:1415
#define INITIAL
Definition libparse.cc:1051
static yyconst short int yy_def[533]
Definition libparse.cc:470
static yyconst short int yy_nxt[2253]
Definition libparse.cc:533
static yyconst short int yy_accept[485]
Definition libparse.cc:308
#define YY_STATE_EOF(state)
Definition libparse.cc:109
static yyconst short int yy_chk[2253]
Definition libparse.cc:785
#define yyterminate()
Definition libparse.cc:1373
#define EOB_ACT_LAST_MATCH
Definition libparse.cc:126
#define EOB_ACT_CONTINUE_SCAN
Definition libparse.cc:124
static yyconst int yy_meta[53]
Definition libparse.cc:397
STATIC_VAR yy_state_type yy_last_accepting_state
Definition libparse.cc:1037
STATIC_VAR char * yy_last_accepting_cpos
Definition libparse.cc:1038
void m2_end(int i)
Definition misc_ip.cc:1102
EXTERN_VAR int yy_blocklineno
Definition reporter.h:18
#define block
Definition scanner.cc:646
#define brace
Definition scanner.cc:650
#define yymore()
Definition scanner.cc:555
static int yyinput()
Definition scanner.cc:1791
#define bracestr
Definition scanner.cc:652
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 YY_STATE_EOF(state)
Definition scanner.cc:90
#define YY_FATAL_ERROR(msg)
Definition scanner.cc:777
static yy_state_type yy_get_previous_state()
Definition scanner.cc:1682
static char * dupyytext()
Definition scanner.cc:597
int yywrap()
Definition scanner.cc:630
STATIC_VAR char * yy_c_buf_p
Definition scanner.cc:220
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
#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 libparse.cc:3231

◆ 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 libparse.cc:114

◆ 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
#define YY_READ_BUF_SIZE
Definition libparse.cc:1334
#define YY_BUFFER_EOF_PENDING
Definition libparse.cc:218
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition scanner.cc:2260
#define YY_INPUT(buf, result, max_size)
Definition scanner.cc:634

◆ 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

◆ 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

◆ 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 */
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 }
REGISTER char * yy_cp
Definition scanner.cc:805

◆ 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.

290 { 0,
291 0, 0, 0, 0, 30, 30, 0, 0, 0, 0,
292 0, 0, 20, 20, 0, 0, 67, 65, 40, 40,
293 50, 34, 64, 59, 65, 64, 65, 65, 65, 65,
294 65, 57, 65, 65, 65, 65, 6, 55, 64, 64,
295 64, 64, 64, 64, 64, 64, 24, 65, 35, 36,
296 39, 36, 30, 25, 30, 32, 33, 26, 29, 26,
297 13, 11, 12, 15, 14, 17, 16, 21, 20, 21,
298 18, 23, 19, 9, 66, 10, 51, 2, 46, 64,
299 64, 64, 53, 44, 43, 54, 41, 61, 3, 1,
300 61, 0, 0, 57, 42, 48, 52, 45, 49, 6,
301
302 64, 64, 64, 64, 64, 64, 64, 47, 38, 37,
303 30, 30, 28, 27, 21, 20, 21, 0, 21, 9,
304 2, 0, 1, 61, 63, 61, 63, 58, 64, 64,
305 5, 64, 64, 64, 64, 64, 30, 31, 22, 0,
306 0, 0, 64, 64, 6, 64, 64, 64, 61, 62,
307 0, 64, 0, 60, 64, 0, 4, 64, 64, 0,
308 0, 7, 56, 0, 0, 8, 0, 0, 7, 0
309 } ;

◆ 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.

353 { 0,
354 0, 0, 43, 44, 45, 46, 47, 48, 50, 54,
355 295, 294, 74, 92, 75, 76, 296, 561, 561, 561,
356 269, 561, 271, 561, 254, 40, 230, 227, 84, 38,
357 69, 92, 197, 60, 181, 177, 99, 561, 561, 86,
358 87, 93, 98, 99, 100, 102, 561, 136, 561, 561,
359 561, 62, 0, 561, 158, 561, 561, 561, 561, 109,
360 561, 561, 561, 561, 561, 561, 561, 0, 129, 134,
361 561, 561, 561, 0, 561, 561, 561, 0, 561, 114,
362 124, 125, 561, 561, 561, 561, 561, 128, 561, 0,
363 136, 129, 149, 143, 561, 561, 561, 561, 561, 154,
364
365 144, 146, 147, 148, 151, 136, 151, 561, 561, 561,
366 0, 177, 561, 561, 0, 187, 190, 144, 0, 0,
367 0, 171, 0, 180, 561, 176, 193, 193, 180, 186,
368 188, 190, 192, 201, 203, 204, 236, 0, 561, 119,
369 103, 97, 207, 244, 246, 222, 231, 223, 80, 39,
370 243, 224, 266, 561, 238, 252, 242, 252, 256, 286,
371 70, 288, 245, 192, 291, 561, 292, 293, 296, 561,
372 320, 332, 344, 356, 368, 380, 392, 400, 408, 418,
373 430, 442, 454, 466, 478, 490, 502, 514, 526, 537,
374 548
375
376 } ;

◆ 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.

476 { 0,
477 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
478 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
479 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
480 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
481 1, 1, 1, 1, 1, 1, 1, 1, 3, 4,
482 5, 6, 7, 8, 30, 9, 30, 150, 26, 10,
483 9, 9, 5, 6, 10, 10, 26, 52, 3, 4,
484 9, 161, 7, 8, 10, 13, 13, 15, 16, 13,
485 161, 31, 34, 34, 13, 13, 31, 52, 13, 5,
486 6, 5, 6, 14, 14, 15, 16, 14, 149, 29,
487
488 37, 37, 14, 14, 40, 41, 14, 29, 32, 32,
489 32, 42, 40, 41, 60, 142, 43, 44, 45, 42,
490 46, 141, 42, 41, 43, 44, 45, 43, 46, 40,
491 69, 69, 80, 46, 60, 70, 70, 140, 44, 70,
492 80, 45, 81, 82, 70, 70, 88, 92, 70, 118,
493 81, 82, 91, 91, 91, 100, 100, 88, 92, 94,
494 94, 94, 101, 106, 102, 103, 104, 93, 106, 105,
495 101, 101, 102, 103, 104, 55, 101, 105, 107, 112,
496 103, 48, 112, 107, 122, 102, 122, 105, 116, 116,
497 104, 117, 117, 164, 126, 117, 124, 124, 124, 36,
498
499 117, 117, 164, 35, 117, 126, 127, 129, 127, 128,
500 128, 128, 129, 130, 129, 131, 33, 132, 130, 133,
501 131, 112, 132, 112, 133, 133, 130, 132, 134, 134,
502 135, 136, 147, 134, 143, 135, 136, 136, 137, 143,
503 28, 137, 27, 135, 143, 144, 144, 145, 145, 146,
504 148, 152, 148, 156, 146, 148, 152, 152, 147, 151,
505 151, 151, 25, 147, 144, 155, 145, 153, 153, 157,
506 155, 144, 163, 155, 157, 23, 144, 163, 156, 158,
507 137, 158, 137, 159, 158, 159, 153, 160, 159, 162,
508 162, 21, 165, 167, 168, 17, 160, 169, 169, 12,
509
510 11, 165, 167, 168, 160, 0, 0, 0, 162, 165,
511 167, 168, 160, 0, 0, 0, 0, 165, 167, 168,
512 171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
513 171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
514 172, 172, 172, 172, 173, 173, 173, 173, 173, 173,
515 173, 173, 173, 173, 173, 173, 174, 174, 174, 174,
516 174, 174, 174, 174, 174, 174, 174, 174, 175, 175,
517 175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
518 176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
519 176, 176, 177, 177, 177, 177, 177, 177, 177, 177,
520
521 177, 177, 177, 177, 178, 0, 0, 0, 0, 178,
522 0, 178, 179, 0, 0, 179, 179, 179, 180, 180,
523 180, 0, 180, 180, 180, 180, 180, 180, 180, 180,
524 181, 0, 0, 181, 181, 0, 0, 181, 181, 181,
525 181, 181, 182, 182, 182, 182, 182, 182, 182, 182,
526 182, 182, 182, 182, 183, 183, 0, 183, 183, 183,
527 183, 183, 183, 183, 0, 183, 184, 184, 0, 184,
528 184, 184, 184, 184, 184, 184, 184, 184, 185, 185,
529 0, 185, 185, 185, 185, 185, 185, 185, 185, 185,
530 186, 186, 186, 186, 186, 186, 186, 0, 186, 186,
531
532 186, 186, 187, 187, 187, 187, 187, 187, 187, 187,
533 187, 187, 187, 187, 188, 188, 188, 188, 188, 188,
534 188, 188, 188, 188, 188, 188, 189, 189, 0, 189,
535 189, 189, 189, 189, 189, 189, 189, 189, 190, 0,
536 0, 190, 0, 0, 0, 0, 0, 0, 190, 191,
537 0, 0, 191, 191, 0, 0, 0, 191, 0, 191,
538 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
539 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
540 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
541 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
542
543 170, 170, 170, 170, 170, 170, 170, 170, 170
544 } ;

◆ 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.

379 { 0,
380 170, 1, 171, 171, 172, 172, 173, 173, 174, 174,
381 175, 175, 176, 176, 177, 177, 170, 170, 170, 170,
382 170, 170, 170, 170, 170, 178, 170, 170, 170, 170,
383 170, 179, 170, 170, 170, 170, 170, 170, 170, 178,
384 178, 178, 178, 178, 178, 178, 170, 170, 170, 170,
385 170, 170, 180, 170, 180, 170, 170, 170, 170, 170,
386 170, 170, 170, 170, 170, 170, 170, 181, 170, 182,
387 170, 170, 170, 183, 170, 170, 170, 184, 170, 178,
388 178, 178, 170, 170, 170, 170, 170, 170, 170, 185,
389 179, 186, 170, 179, 170, 170, 170, 170, 170, 170,
390
391 178, 178, 178, 178, 178, 101, 101, 170, 170, 170,
392 180, 187, 170, 170, 181, 170, 182, 188, 181, 183,
393 184, 170, 185, 179, 170, 170, 170, 179, 101, 101,
394 101, 101, 101, 101, 101, 101, 187, 189, 170, 170,
395 170, 170, 101, 101, 144, 101, 101, 101, 170, 170,
396 179, 101, 170, 170, 101, 190, 101, 101, 101, 191,
397 170, 144, 101, 170, 191, 170, 191, 191, 170, 0,
398 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
399 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
400 170
401
402 } ;

◆ 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.

312 { 0,
313 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
314 1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
315 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
316 1, 2, 5, 6, 7, 8, 1, 9, 10, 11,
317 12, 13, 14, 15, 16, 17, 18, 19, 19, 19,
318 19, 19, 19, 19, 19, 19, 19, 20, 21, 22,
319 23, 24, 25, 10, 10, 10, 10, 10, 10, 10,
320 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
321 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
322 1, 26, 1, 1, 27, 1, 28, 10, 29, 10,
323
324 30, 31, 10, 32, 33, 10, 10, 34, 35, 36,
325 37, 38, 39, 40, 10, 41, 42, 10, 43, 44,
326 10, 10, 45, 46, 47, 48, 1, 1, 1, 1,
327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
328 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
329 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
330 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
331 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
334
335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
336 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
337 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
339 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
340 1, 1, 1, 1, 1
341 } ;

◆ 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.

344 { 0,
345 1, 2, 3, 1, 1, 4, 1, 1, 1, 5,
346 6, 7, 1, 1, 7, 1, 8, 9, 10, 1,
347 11, 1, 1, 1, 1, 1, 12, 5, 5, 5,
348 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
349 5, 5, 5, 5, 4, 1, 4, 1
350 } ;

◆ 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.

405 { 0,
406 18, 19, 20, 19, 21, 22, 23, 24, 25, 26,
407 18, 18, 27, 28, 18, 29, 30, 31, 32, 33,
408 18, 34, 35, 36, 37, 38, 39, 26, 26, 40,
409 41, 42, 26, 26, 26, 43, 26, 44, 45, 26,
410 26, 26, 46, 26, 47, 48, 18, 49, 51, 51,
411 54, 54, 59, 59, 87, 62, 88, 150, 81, 62,
412 63, 64, 55, 55, 63, 64, 82, 109, 52, 52,
413 65, 164, 60, 60, 65, 69, 69, 75, 75, 70,
414 166, 89, 96, 97, 71, 72, 90, 110, 73, 56,
415 56, 57, 57, 69, 69, 76, 76, 70, 149, 85,
416
417 100, 100, 71, 72, 81, 81, 73, 86, 92, 93,
418 94, 81, 82, 82, 113, 151, 81, 81, 81, 82,
419 81, 150, 103, 102, 82, 82, 82, 104, 82, 101,
420 116, 116, 81, 107, 114, 118, 118, 149, 105, 119,
421 82, 106, 81, 81, 118, 118, 88, 126, 118, 139,
422 82, 82, 170, 170, 124, 100, 100, 122, 127, 92,
423 93, 94, 81, 80, 81, 81, 81, 128, 135, 81,
424 82, 129, 82, 82, 82, 112, 130, 82, 80, 111,
425 132, 108, 138, 136, 140, 131, 140, 134, 116, 116,
426 133, 118, 118, 164, 88, 119, 170, 170, 124, 99,
427
428 118, 118, 166, 98, 118, 122, 141, 80, 141, 170,
429 142, 128, 80, 80, 143, 80, 95, 80, 80, 80,
430 80, 138, 80, 138, 80, 146, 144, 145, 80, 147,
431 80, 80, 156, 80, 80, 80, 80, 148, 111, 80,
432 84, 138, 83, 144, 152, 153, 153, 100, 100, 80,
433 80, 80, 157, 156, 155, 80, 80, 158, 80, 170,
434 142, 151, 79, 80, 154, 80, 170, 153, 153, 80,
435 80, 80, 80, 159, 80, 78, 80, 80, 161, 80,
436 138, 162, 138, 80, 80, 163, 154, 164, 80, 169,
437 169, 77, 164, 164, 164, 170, 166, 169, 169, 67,
438
439 67, 166, 166, 166, 167, 170, 170, 170, 170, 167,
440 167, 167, 168, 170, 170, 170, 170, 168, 168, 168,
441 50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
442 50, 50, 53, 53, 53, 53, 53, 53, 53, 53,
443 53, 53, 53, 53, 58, 58, 58, 58, 58, 58,
444 58, 58, 58, 58, 58, 58, 61, 61, 61, 61,
445 61, 61, 61, 61, 61, 61, 61, 61, 66, 66,
446 66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
447 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
448 68, 68, 74, 74, 74, 74, 74, 74, 74, 74,
449
450 74, 74, 74, 74, 80, 170, 170, 170, 170, 80,
451 170, 80, 91, 170, 170, 91, 91, 91, 111, 111,
452 111, 170, 111, 111, 111, 111, 111, 111, 111, 111,
453 115, 170, 170, 115, 115, 170, 170, 115, 115, 115,
454 115, 115, 117, 117, 117, 117, 117, 117, 117, 117,
455 117, 117, 117, 117, 120, 120, 170, 120, 120, 120,
456 120, 120, 120, 120, 170, 120, 121, 121, 170, 121,
457 121, 121, 121, 121, 121, 121, 121, 121, 123, 123,
458 170, 123, 123, 123, 123, 123, 123, 123, 123, 123,
459 125, 125, 125, 125, 125, 125, 125, 170, 125, 125,
460
461 125, 125, 137, 137, 137, 137, 137, 137, 137, 137,
462 137, 137, 137, 137, 118, 118, 118, 118, 118, 118,
463 118, 118, 118, 118, 118, 118, 138, 138, 170, 138,
464 138, 138, 138, 138, 138, 138, 138, 138, 160, 170,
465 170, 160, 170, 170, 170, 170, 170, 170, 160, 165,
466 170, 170, 165, 165, 170, 170, 170, 165, 170, 165,
467 17, 170, 170, 170, 170, 170, 170, 170, 170, 170,
468 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
469 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
470 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
471
472 170, 170, 170, 170, 170, 170, 170, 170, 170
473 } ;

◆ 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.