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

◆ BEGIN

#define BEGIN   yy_start = 1 + 2 *

Definition at line 80 of file scanner.cc.

◆ block

#define block   2

Definition at line 666 of file scanner.cc.

◆ blockstr

#define blockstr   3

Definition at line 668 of file scanner.cc.

◆ brace

#define brace   4

Definition at line 670 of file scanner.cc.

◆ bracestr

#define bracestr   5

Definition at line 672 of file scanner.cc.

◆ bracket

#define bracket   6

Definition at line 674 of file scanner.cc.

◆ ECHO

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

Definition at line 757 of file scanner.cc.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 105 of file scanner.cc.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 106 of file scanner.cc.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 107 of file scanner.cc.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 7 of file scanner.cc.

◆ free

#define free   omFree

Definition at line 616 of file scanner.cc.

◆ INITIAL

#define INITIAL   0

Definition at line 560 of file scanner.cc.

◆ malloc

#define malloc   omAlloc

Definition at line 611 of file scanner.cc.

◆ realloc

#define realloc   omRealloc

Definition at line 613 of file scanner.cc.

◆ REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 552 of file scanner.cc.

◆ string

#define string   1

Definition at line 664 of file scanner.cc.

◆ unput

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

Definition at line 136 of file scanner.cc.

◆ YY_ALWAYS_INTERACTIVE

#define YY_ALWAYS_INTERACTIVE   1

Definition at line 663 of file scanner.cc.

◆ YY_AT_BOL

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 263 of file scanner.cc.

◆ YY_BREAK

#define YY_BREAK   break;

Definition at line 816 of file scanner.cc.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 98 of file scanner.cc.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 199 of file scanner.cc.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 187 of file scanner.cc.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 188 of file scanner.cc.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 208 of file scanner.cc.

◆ YY_DECL

#define YY_DECL   int yylex(YYSTYPE* lvalp)

Definition at line 646 of file scanner.cc.

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION
Value:
yyleng = (int) (yy_cp - yytext_ptr); \
*yy_cp = '\0'; \
register char * yy_bp
Definition: scanner.cc:825
#define yytext_ptr
Definition: scanner.cc:269
EXTERN_VAR int yyleng
Definition: scanner.cc:102
register char * yy_cp
Definition: scanner.cc:825
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 2202 of file scanner.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 797 of file scanner.cc.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 8 of file scanner.cc.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 9 of file scanner.cc.

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )

Definition at line 237 of file scanner.cc.

◆ YY_INPUT

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

Definition at line 654 of file scanner.cc.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ   yy_more_len

Definition at line 556 of file scanner.cc.

◆ yy_new_buffer

#define yy_new_buffer   yy_create_buffer

Definition at line 247 of file scanner.cc.

◆ YY_NEW_FILE

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 93 of file scanner.cc.

◆ YY_NO_POP_STATE

#define YY_NO_POP_STATE   1

Definition at line 727 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 726 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 728 of file scanner.cc.

◆ YY_NULL

#define YY_NULL   0

Definition at line 67 of file scanner.cc.

◆ YY_NUM_RULES

#define YY_NUM_RULES   66

Definition at line 287 of file scanner.cc.

◆ YY_PROTO

#define YY_PROTO (   proto)    proto

Definition at line 61 of file scanner.cc.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 748 of file scanner.cc.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 557 of file scanner.cc.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP    YY_USER_ACTION

Definition at line 819 of file scanner.cc.

◆ YY_SC_TO_UI

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

Definition at line 74 of file scanner.cc.

◆ yy_set_bol

#define yy_set_bol (   at_bol)
Value:
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer->yy_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 792 of file scanner.cc.

◆ YY_STATE_EOF

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

Definition at line 90 of file scanner.cc.

◆ YY_USE_CONST

#define YY_USE_CONST

Definition at line 32 of file scanner.cc.

◆ YY_USE_PROTOS

#define YY_USE_PROTOS

Definition at line 29 of file scanner.cc.

◆ YY_USER_ACTION

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

Definition at line 658 of file scanner.cc.

◆ yyconst

#define yyconst   const

Definition at line 54 of file scanner.cc.

◆ yyless [1/2]

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

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

◆ yymore

#define yymore ( )    (yy_more_flag = 1)

Definition at line 555 of file scanner.cc.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 87 of file scanner.cc.

◆ yyterminate

#define yyterminate ( )    return YY_NULL

Definition at line 787 of file scanner.cc.

◆ yytext_ptr

#define yytext_ptr   yytext

Definition at line 269 of file scanner.cc.

Typedef Documentation

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 265 of file scanner.cc.

◆ yy_size_t

typedef unsigned int yy_size_t

Definition at line 142 of file scanner.cc.

◆ yy_state_type

typedef int yy_state_type

Definition at line 267 of file scanner.cc.

Function Documentation

◆ dupyytext()

static char * dupyytext ( )
static

Definition at line 617 of file scanner.cc.

618{
619 char* s;
620 if (yyleng>0) yytext[yyleng-1] = '\0';
621 s = omStrDup((char *)yytext);
623 return s;
624}
const CanonicalForm int s
Definition: facAbsFact.cc:51
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omMarkAsStaticAddr(A)
Definition: xalloc.h:294

◆ dupyytextNL()

static char * dupyytextNL ( )
static

Definition at line 626 of file scanner.cc.

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

◆ feReadLine()

int feReadLine ( char *  b,
int  l 
)

Definition at line 498 of file fevoices.cc.

499{
500 char *s=NULL;
501 int offset = 0; /* will not be used if s==NULL*/
502 // try to read from the buffer into b, max l chars
503 if (currentVoice!=NULL)
504 {
506 && (currentVoice->buffer[currentVoice->fptr]!='\0'))
507 {
508 NewBuff:
509 REGISTER int i=0;
510 long startfptr=currentVoice->fptr;
511 long tmp_ptr=currentVoice->fptr;
512 l--;
513 loop
514 {
515 REGISTER char c=
516 b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
517 i++;
519 {
520 if (c<' ') yylineno++;
521 else if (c=='}') break;
522 }
523 else
524 {
525 if ((c<' ') ||
526 (c==';') ||
527 (c==')')
528 )
529 break;
530 }
531 if (i>=l) break;
532 tmp_ptr++;/*currentVoice->fptr++;*/
533 if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
534 }
535 currentVoice->fptr=tmp_ptr;
536 b[i]='\0';
538 {
539 BOOLEAN show_echo=FALSE;
540 char *anf;
541 long len;
542 if (startfptr==0)
543 {
544 anf=currentVoice->buffer;
545 const char *ss=strchr(anf,'\n');
546 if (ss==NULL) len=strlen(anf);
547 else len=ss-anf;
548 show_echo=TRUE;
549 }
550 else if (/*(startfptr>0) &&*/
551 (currentVoice->buffer[startfptr-1]=='\n'))
552 {
553 anf=currentVoice->buffer+startfptr;
554 const char *ss=strchr(anf,'\n');
555 if (ss==NULL) len=strlen(anf);
556 else len=ss-anf;
557 yylineno++;
558 show_echo=TRUE;
559 }
560 if (show_echo)
561 {
562 char *s=(char *)omAlloc(len+2);
563 strncpy(s,anf,len+2);
564 s[len+1]='\0';
565 fePrintEcho(s,b);
566 omFree((ADDRESS)s);
567 }
568 }
570 return i;
571 }
572 // no buffer there or e-o-buffer or eoln:
574 {
577 {
581 }
582 }
583 offset=0;
584 NewRead:
585 yylineno++;
587 {
588 feShowPrompt();
592 //int i=0;
593 //if (s!=NULL)
594 // while((s[i]!='\0') /*&& (i<MAX_FILE_BUFFER)*/) {s[i] &= (char)127;i++;}
595 }
596 else if (currentVoice->sw==BI_file)
597 {
601 if (s!=NULL)
602 {
604 // ftell returns -1 for non-seekable streams, such as pipes
605 if (currentVoice->ftellptr<0)
607 }
608 }
609 //else /* BI_buffer */ s==NULL => return 0
610 // done by the default return
611 }
612 if (s!=NULL)
613 {
614 // handle prot:
615 if (feProt&SI_PROT_I)
616 {
617 fputs(s,feProtFile);
618 }
619 int rc=fePrintEcho(s,b)+1;
620 //s[strlen(s)+1]='\0'; add an second \0 at the end of the string
621 s[rc]='\0';
622 // handel \\ :
623 rc-=3; if (rc<0) rc=0;
624 if ((s[rc]=='\\')&&(currentVoice->sw!=BI_buffer))
625 {
626 s[rc]='\0';
627 offset+=rc;
628 if (offset<currentVoice->buff_size) goto NewRead;
629 }
630 goto NewBuff;
631 }
632 /* else if (s==NULL) */
633 {
634 const char *err;
635 switch(yy_noeof)
636 {
637 case noeof_brace:
638 case noeof_block:
639 err="{...}";
640 break;
641 case noeof_asstring:
642 err="till `.`";
643 break;
644 case noeof_string:
645 err="string";
646 break;
647 case noeof_bracket:
648 err="(...)";
649 break;
650 case noeof_procname:
651 err="proc";
652 break;
653 case noeof_comment:
654 err="/*...*/";
655 break;
656 default:
657 return 0;
658 }
659 Werror("premature end of file while reading %s",err);
660 return 0;
661 }
662}
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:4102
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:30
#define MAX_FILE_BUFFER
Definition: fevoices.cc:37
VAR char fe_promptstr[]
Definition: fevoices.cc:31
VAR Voice * currentVoice
Definition: fevoices.cc:47
static int fePrintEcho(char *anf, char *)
Definition: fevoices.cc:416
VAR int yy_noeof
Definition: fevoices.cc:45
static void feShowPrompt(void)
Definition: fevoices.cc:408
@ BI_file
Definition: fevoices.h:32
@ BI_buffer
Definition: fevoices.h:31
@ BI_stdin
Definition: fevoices.h:30
@ noeof_string
Definition: fevoices.h:42
@ noeof_brace
Definition: fevoices.h:36
@ noeof_comment
Definition: fevoices.h:40
@ noeof_asstring
Definition: fevoices.h:37
@ noeof_block
Definition: fevoices.h:38
@ noeof_procname
Definition: fevoices.h:41
@ noeof_bracket
Definition: fevoices.h:39
STATIC_VAR int offset
Definition: janet.cc:29
#define SEEK_SET
Definition: mod2.h:113
#define omFree(addr)
Definition: omAllocDecl.h:261
#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 831 of file scanner.cc.

832 {
833 yy_init = 0;
834
835#ifdef YY_USER_INIT
837#endif
838
839 if ( ! yy_start )
840 yy_start = 1; /* first start state */
841
842 if ( ! yyin )
843 yyin = stdin;
844
845 if ( ! yyout )
846 yyout = stdout;
847
848 if ( ! yy_current_buffer )
851
853 }
#define YY_USER_INIT
Definition: libparse.cc:1210
EXTERN_VAR FILE * yyout
Definition: scanner.cc:103
STATIC_VAR int yy_start
Definition: scanner.cc:222
void yy_load_buffer_state(void)
Definition: scanner.cc:1929
STATIC_VAR int yy_init
Definition: scanner.cc:221

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2338 of file scanner.cc.

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

◆ myychangebuffer()

void myychangebuffer ( )

Definition at line 2331 of file scanner.cc.

2332{
2333 yy_flush_buffer((YY_BUFFER_STATE)YY_CURRENT_BUFFER);
2336}
#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 2317 of file scanner.cc.

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

◆ myyoldbuffer()

void myyoldbuffer ( void *  oldb)

Definition at line 2324 of file scanner.cc.

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

◆ while()

while ( )

Definition at line 855 of file scanner.cc.

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

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 1942 of file scanner.cc.

1948 {
1949 YY_BUFFER_STATE b;
1950
1951 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1952 if ( ! b )
1953 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1954
1955 b->yy_buf_size = size;
1956
1957 /* yy_ch_buf has to be 2 characters longer than the size given because
1958 * we need to put in 2 end-of-buffer characters.
1959 */
1960 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1961 if ( ! b->yy_ch_buf )
1962 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1963
1964 b->yy_is_our_buffer = 1;
1965
1966 yy_init_buffer( b, file );
1967
1968 return b;
1969 }
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
#define yy_init_buffer
Definition: libparse.cc:7
static void * yy_flex_alloc(yy_size_t size)
Definition: scanner.cc:2270

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 1973 of file scanner.cc.

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

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 2206 of file scanner.cc.

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

◆ yy_flex_alloc()

static void * yy_flex_alloc ( yy_size_t  size)
static

Definition at line 2270 of file scanner.cc.

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

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 2298 of file scanner.cc.

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

◆ yy_flex_realloc()

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

Definition at line 2280 of file scanner.cc.

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

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 2026 of file scanner.cc.

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

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( )
static

Definition at line 1570 of file scanner.cc.

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

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( )
static

Definition at line 1702 of file scanner.cc.

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

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 1999 of file scanner.cc.

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

◆ yy_load_buffer_state()

void yy_load_buffer_state ( void  )

Definition at line 1929 of file scanner.cc.

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

◆ YY_PROTO() [1/15]

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

◆ YY_PROTO() [2/15]

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

◆ YY_PROTO() [3/15]

void yyrestart YY_PROTO ( (FILE *input_file)  )

◆ YY_PROTO() [4/15]

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

◆ YY_PROTO() [5/15]

static void yy_flex_free YY_PROTO ( (void *)  )
static

◆ YY_PROTO() [6/15]

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

◆ YY_PROTO() [7/15]

void yy_load_buffer_state YY_PROTO ( (void)  )

◆ YY_PROTO() [8/15]

void yy_delete_buffer YY_PROTO ( (YY_BUFFER_STATE b )

◆ YY_PROTO() [9/15]

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

◆ YY_PROTO() [10/15]

void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer)  )

◆ YY_PROTO() [11/15]

static void *yy_flex_alloc YY_PROTO ( (yy_size_t )
static

◆ YY_PROTO() [12/15]

static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  )
static

◆ YY_PROTO() [13/15]

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

◆ YY_PROTO() [14/15]

YY_BUFFER_STATE yy_scan_string YY_PROTO ( (yyconst char *yy_str)  )

◆ YY_PROTO() [15/15]

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

◆ yy_scan_buffer()

YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Definition at line 2057 of file scanner.cc.

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

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 2112 of file scanner.cc.

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

2100 {
2101 int len;
2102 for ( len = 0; yy_str[len]; ++len )
2103 ;
2104
2105 return yy_scan_bytes( yy_str, len );
2106 }
#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 1899 of file scanner.cc.

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

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 1737 of file scanner.cc.

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

◆ yyinput()

static int yyinput ( )
static

Definition at line 1811 of file scanner.cc.

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

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 1884 of file scanner.cc.

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

◆ yyunput()

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

Definition at line 1767 of file scanner.cc.

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

◆ yywrap()

int yywrap ( )

Definition at line 650 of file scanner.cc.

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

Variable Documentation

◆ blocknest

VAR int blocknest = 0

Definition at line 582 of file scanner.cc.

◆ inerror

EXTERN_VAR int inerror

Definition at line 586 of file scanner.cc.

◆ yy_accept

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

Definition at line 289 of file scanner.cc.

◆ yy_act

register int yy_act

Definition at line 826 of file scanner.cc.

◆ yy_base

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

Definition at line 352 of file scanner.cc.

◆ yy_bp

register char * yy_bp

Definition at line 825 of file scanner.cc.

◆ yy_c_buf_p

STATIC_VAR char* yy_c_buf_p = (char *) 0

Definition at line 220 of file scanner.cc.

◆ yy_chk

yyconst short int yy_chk[610]
static

Definition at line 475 of file scanner.cc.

◆ yy_cp

register char* yy_cp

Definition at line 825 of file scanner.cc.

◆ yy_current_buffer

STATIC_VAR YY_BUFFER_STATE yy_current_buffer = 0

Definition at line 202 of file scanner.cc.

◆ YY_DECL

YY_DECL
Initial value:
{
register yy_state_type yy_current_state

Definition at line 822 of file scanner.cc.

◆ yy_def

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

Definition at line 378 of file scanner.cc.

◆ yy_did_buffer_switch_on_eof

STATIC_VAR int yy_did_buffer_switch_on_eof

Definition at line 227 of file scanner.cc.

◆ yy_ec

yyconst int yy_ec[256]
static

Definition at line 311 of file scanner.cc.

◆ yy_hold_char

STATIC_VAR char yy_hold_char

Definition at line 212 of file scanner.cc.

◆ yy_init

STATIC_VAR int yy_init = 1

Definition at line 221 of file scanner.cc.

◆ yy_last_accepting_cpos

STATIC_VAR char* yy_last_accepting_cpos

Definition at line 547 of file scanner.cc.

◆ yy_last_accepting_state

STATIC_VAR yy_state_type yy_last_accepting_state

Definition at line 546 of file scanner.cc.

◆ yy_meta

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

Definition at line 343 of file scanner.cc.

◆ yy_more_flag

STATIC_VAR int yy_more_flag = 0

Definition at line 553 of file scanner.cc.

◆ yy_more_len

STATIC_VAR int yy_more_len = 0

Definition at line 554 of file scanner.cc.

◆ yy_n_chars

STATIC_VAR int yy_n_chars

Definition at line 214 of file scanner.cc.

◆ yy_nxt

yyconst short int yy_nxt[610]
static

Definition at line 404 of file scanner.cc.

◆ yy_start

STATIC_VAR int yy_start = 0

Definition at line 222 of file scanner.cc.

◆ yyin

VAR FILE* yyin = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yyleng

EXTERN_VAR int yyleng

Definition at line 102 of file scanner.cc.

◆ yyout

VAR FILE * yyout = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yytext

EXTERN_VAR char* yytext

Definition at line 268 of file scanner.cc.