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))
omAlloc
#define omAlloc(size)
Definition omAllocDecl.h:210

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:
yyunput( c, yytext_ptr )
yytext_ptr
#define yytext_ptr
Definition libparse.cc:288
yyunput
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)
yy_current_buffer
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:
yytext_ptr = yy_bp; \
yytext_ptr -= yy_more_len; \
yyleng = (int) (yy_cp - yytext_ptr); \
yy_hold_char = *yy_cp; \
*yy_cp = '\0'; \
yy_c_buf_p = yy_cp;
yyleng
#define yyleng
Definition libparse.cc:12
yy_bp
REGISTER char * yy_bp
Definition libparse.cc:1414
yy_cp
REGISTER char * yy_cp
Definition libparse.cc:1414
yy_hold_char
STATIC_VAR char yy_hold_char
Definition libparse.cc:231
yy_c_buf_p
STATIC_VAR char * yy_c_buf_p
Definition libparse.cc:239
yy_more_len
STATIC_VAR int yy_more_len
Definition libparse.cc:1045

Definition at line 279 of file scanner.cc.

#define YY_DO_BEFORE_ACTION \
yytext_ptr = yy_bp; \
yytext_ptr -= yy_more_len; \
yyleng = (int) (yy_cp - yytext_ptr); \
yy_hold_char = *yy_cp; \
*yy_cp = '\0'; \
yy_c_buf_p = yy_cp;

## 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:
yy_fatal_error( msg )
yy_fatal_error
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) )
result
return result
Definition facAbsBiFact.cc:76
feReadLine
int feReadLine(char *b, int l)
Definition fevoices.cc:500
buf
int status int void * buf
Definition si_signals.h:69

Definition at line 634 of file scanner.cc.

#define YY_INPUT(buf,result,max_size) \
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.

#define YY_RULE_SETUP \
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_create_buffer( yyin, YY_BUF_SIZE ); \
yy_current_buffer->yy_at_bol = at_bol; \
}
yyin
#define yyin
Definition libparse.cc:11
yy_create_buffer
#define yy_create_buffer
Definition libparse.cc:1
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition libparse.cc:117

Definition at line 256 of file scanner.cc.

#define yy_set_bol(at_bol) \
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
yy_current_buffer->yy_at_bol = at_bol; \
}

## yy_set_interactive

#define yy_set_interactive | ( |  | is_interactive | ) |

Value:
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
yy_current_buffer->yy_is_interactive = is_interactive; \
}

Definition at line 249 of file scanner.cc.

#define yy_set_interactive(is_interactive) \
{ \
if ( ! yy_current_buffer ) \
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
yy_current_buffer->yy_is_interactive = is_interactive; \
}

## 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)
YY_END_OF_BUFFER
#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; }
Print
#define Print
Definition emacs.cc:80
inerror
EXTERN_VAR int inerror
Definition interpreter_support.cc:21
yytext
#define yytext
Definition libparse.cc:16

Definition at line 638 of file scanner.cc.

#define YY_USER_ACTION \
if ((inerror==1)&&(*yytext>=' '))\
{ 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. */ \
yytext[yyleng] = yy_hold_char; \
yy_c_buf_p = yytext + n; \
yy_hold_char = *yy_c_buf_p; \
*yy_c_buf_p = '\0'; \
yyleng = n; \
} \
while ( 0 )

Definition at line 125 of file scanner.cc.

#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
*yy_cp = yy_hold_char; \
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 )

## yyless [2/2]

#define yyless | ( |  | n | ) |

Value:
do \
{ \
/* Undo effects of setting up yytext. */ \
*yy_cp = yy_hold_char; \
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 )
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition libparse.cc:1047
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition libparse.cc:298

Definition at line 125 of file scanner.cc.

#define yyless(n) \
do \
{ \
/* Undo effects of setting up yytext. */ \
*yy_cp = yy_hold_char; \
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 )

## yymore

#define yymore | ( |  | ) |

Value:
(yy_more_flag = 1)
yy_more_flag
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
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()

char * dupyytext | ( |  | ) |

static

Definition at line 597 of file scanner.cc.

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

## dupyytextNL()

char * dupyytextNL | ( |  | ) |

static

Definition at line 606 of file scanner.cc.

{
int i = yyleng;//strlen((char *)yytext);
char * rc = (char*)omAlloc( 3 + i );
omMarkAsStaticAddr(rc);
if (i>0)
{
strncpy( rc, (char *)yytext, i-1 );
}
else
{
i++;
}
rc[i-1] = '\n';
rc[i] = '\n';
rc[i+1] = '\0';
return rc;
}
i
int i
Definition cfEzgcd.cc:132

## feReadLine()

int feReadLine | ( | char * | b,
|  | int | l )

Definition at line 500 of file fevoices.cc.

{
char *s=NULL;
int offset = 0; /* will not be used if s==NULL*/
// try to read from the buffer into b, max l chars
if (currentVoice!=NULL)
{
if((currentVoice->buffer!=NULL)
&& (currentVoice->buffer[currentVoice->fptr]!='\0'))
{
NewBuff:
REGISTER int i=0;
long startfptr=currentVoice->fptr;
long tmp_ptr=currentVoice->fptr;
l--;
loop
{
REGISTER char c=
b[i]=currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/];
i++;
if (yy_noeof==noeof_block)
{
if (c<' ') yylineno++;
else if (c=='}') break;
}
else
{
if ((c<' ') ||
(c==';') ||
(c==')')
)
break;
}
if (i>=l) break;
tmp_ptr++;/*currentVoice->fptr++;*/
if(currentVoice->buffer[tmp_ptr/*currentVoice->fptr*/]=='\0') break;
}
currentVoice->fptr=tmp_ptr;
b[i]='\0';
if (currentVoice->sw==BI_buffer)
{
BOOLEAN show_echo=FALSE;
char *anf;
long len;
if (startfptr==0)
{
anf=currentVoice->buffer;
const char *ss=strchr(anf,'\n');
if (ss==NULL) len=strlen(anf);
else len=ss-anf;
show_echo=TRUE;
}
else if /*(startfptr>0) &&*/
(currentVoice->buffer[startfptr-1]=='\n')
{
anf=currentVoice->buffer+startfptr;
const char *ss=strchr(anf,'\n');
if (ss==NULL) len=strlen(anf);
else len=ss-anf;
yylineno++;
show_echo=TRUE;
}
if (show_echo)
{
char *s=(char *)omAlloc(len+2);
strncpy(s,anf,len+2);
s[len+1]='\0';
fePrintEcho(s,b);
omFree((ADDRESS)s);
}
}
currentVoice->fptr++;
return i;
}
// no buffer there or e-o-buffer or eoln:
if (currentVoice->sw!=BI_buffer)
{
currentVoice->fptr=0;
if (currentVoice->buffer==NULL)
{
currentVoice->buff_size=MAX_FILE_BUFFER-sizeof(ADDRESS);
currentVoice->buffer=(char *)omAlloc(currentVoice->buff_size);
omMarkAsStaticAddr(currentVoice->buffer);
}
}
offset=0;
NewRead:
yylineno++;
if (currentVoice->sw==BI_stdin)
{
feShowPrompt();
s=fe_fgets_stdin(fe_promptstr,
&(currentVoice->buffer[offset]),
currentVoice->buff_size-1-offset);
//int i=0;
//if (s!=NULL)
// while((s[i]!='\0') /*&& (i<MAX_FILE_BUFFER)*/) {s[i] &= (char)127;i++;}
}
else if (currentVoice->sw==BI_file)
{
fseek(currentVoice->files,currentVoice->ftellptr,SEEK_SET);
s=fgets(currentVoice->buffer+offset,(MAX_FILE_BUFFER-1-sizeof(ADDRESS))-offset,
currentVoice->files);
if (s!=NULL)
{
currentVoice->ftellptr=ftell(currentVoice->files);
// ftell returns -1 for non-seekable streams, such as pipes
if (currentVoice->ftellptr<0)
currentVoice->ftellptr=0;
}
}
//else /* BI_buffer */ s==NULL => return 0
// done by the default return
}
if (s!=NULL)
{
// handle prot:
if (feProt&SI_PROT_I)
{
fputs(s,feProtFile);
}
if (File_Log!=NULL)
{
File_Log_written=TRUE;
fputs(s,File_Log);
}
int rc=fePrintEcho(s,b)+1;
//s[strlen(s)+1]='\0'; add an second \0 at the end of the string
s[rc]='\0';
// handel \\ :
rc-=3; if (rc<0) rc=0;
if ((s[rc]=='\\')&&(currentVoice->sw!=BI_buffer))
{
s[rc]='\0';
offset+=rc;
if (offset<currentVoice->buff_size) goto NewRead;
}
goto NewBuff;
}
/* else if (s==NULL) */
{
const char *err;
switch(yy_noeof)
{
case noeof_brace:
case noeof_block:
err="{...}";
break;
case noeof_asstring:
err="till `.`";
break;
case noeof_string:
err="string";
break;
case noeof_bracket:
err="(...)";
break;
case noeof_procname:
err="proc";
break;
case noeof_comment:
err="/*...*/";
break;
default:
return 0;
}
Werror("premature end of file while reading %s",err);
return 0;
}
}
BOOLEAN
int BOOLEAN
Definition auxiliary.h:88
TRUE
#define TRUE
Definition auxiliary.h:101
FALSE
#define FALSE
Definition auxiliary.h:97
ADDRESS
void * ADDRESS
Definition auxiliary.h:120
l
int l
Definition cfEzgcd.cc:100
b
CanonicalForm b
Definition cfModGcd.cc:4111
yylineno
VAR int yylineno
Definition febase.cc:40
fe_fgets_stdin
char *(* fe_fgets_stdin)(const char *pr, char *s, int size)
Definition feread.cc:32
fe_promptstr
VAR char fe_promptstr[]
Definition fevoices.cc:31
currentVoice
VAR Voice * currentVoice
Definition fevoices.cc:49
File_Log_written
VAR BOOLEAN File_Log_written
Definition fevoices.cc:34
File_Log
VAR FILE * File_Log
Definition fevoices.cc:33
fePrintEcho
static int fePrintEcho(char *anf, char *)
Definition fevoices.cc:418
feShowPrompt
static void feShowPrompt(void)
Definition fevoices.cc:410
BI_file
@ BI_file
Definition fevoices.h:32
BI_buffer
@ BI_buffer
Definition fevoices.h:31
BI_stdin
@ BI_stdin
Definition fevoices.h:30
noeof_string
@ noeof_string
Definition fevoices.h:42
noeof_brace
@ noeof_brace
Definition fevoices.h:36
noeof_comment
@ noeof_comment
Definition fevoices.h:40
noeof_asstring
@ noeof_asstring
Definition fevoices.h:37
noeof_block
@ noeof_block
Definition fevoices.h:38
noeof_procname
@ noeof_procname
Definition fevoices.h:41
noeof_bracket
@ noeof_bracket
Definition fevoices.h:39
offset
STATIC_VAR int offset
Definition janet.cc:29
SEEK_SET
#define SEEK_SET
Definition mod2.h:115
omFree
#define omFree(addr)
Definition omAllocDecl.h:261
NULL
#define NULL
Definition omList.c:12
REGISTER
#define REGISTER
Definition omalloc.h:27
MAX_FILE_BUFFER
#define MAX_FILE_BUFFER
Definition reporter.cc:38
feProt
VAR int feProt
Definition reporter.cc:56
feProtFile
VAR FILE * feProtFile
Definition reporter.cc:57
Werror
void Werror(const char *fmt,...)
Definition reporter.cc:189
yy_noeof
EXTERN_VAR int yy_noeof
Definition reporter.h:19
SI_PROT_I
#define SI_PROT_I
Definition reporter.h:53
loop
#define loop
Definition structs.h:71

## if()

if | ( | yy_init |  | ) |

Definition at line 811 of file scanner.cc.

{
yy_init = 0;
#ifdef YY_USER_INIT
YY_USER_INIT;
#endif
if ( ! yy_start )
yy_start = 1; /* first start state */
if ( ! yyin )
yyin = stdin;
if ( ! yyout )
yyout = stdout;
if ( ! yy_current_buffer )
yy_current_buffer =
yy_create_buffer( yyin, YY_BUF_SIZE );
yy_load_buffer_state();
}
yyout
#define yyout
Definition libparse.cc:14
YY_USER_INIT
#define YY_USER_INIT
Definition libparse.cc:1210
yy_start
STATIC_VAR int yy_start
Definition libparse.cc:241
yy_init
STATIC_VAR int yy_init
Definition libparse.cc:240
yy_load_buffer_state
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.

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

## myychangebuffer()

void myychangebuffer | ( |  | ) |

Definition at line 2311 of file scanner.cc.

{
yy_flush_buffer((YY_BUFFER_STATE)YY_CURRENT_BUFFER);
yy_delete_buffer(YY_CURRENT_BUFFER);
yy_switch_to_buffer(yy_create_buffer(NULL, YY_BUF_SIZE));
}
yy_switch_to_buffer
#define yy_switch_to_buffer
Definition libparse.cc:10
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition libparse.cc:227
yy_flush_buffer
#define yy_flush_buffer
Definition libparse.cc:8
yy_delete_buffer
#define yy_delete_buffer
Definition libparse.cc:2

## myynewbuffer()

void * myynewbuffer | ( |  | ) |

Definition at line 2297 of file scanner.cc.

{
void * oldb = YY_CURRENT_BUFFER;
yy_switch_to_buffer(yy_create_buffer(NULL, YY_BUF_SIZE));
return oldb;
}

## myyoldbuffer()

void myyoldbuffer | ( | void * | oldb | ) |

Definition at line 2304 of file scanner.cc.

{
yy_delete_buffer(YY_CURRENT_BUFFER);
yy_switch_to_buffer((YY_BUFFER_STATE)oldb);
//yy_flush_buffer((YY_BUFFER_STATE)oldb);
}

## while()

while | ( | 1 |  | ) |

Definition at line 835 of file scanner.cc.

{
yy_more_len = 0;
if ( yy_more_flag )
{
yy_more_len = yy_c_buf_p - yytext_ptr;
yy_more_flag = 0;
}
yy_cp = yy_c_buf_p;
/* Support of yytext. */
*yy_cp = yy_hold_char;
/* yy_bp points to the position in yy_ch_buf of the start of
* the current run.
*/
yy_bp = yy_cp;
yy_current_state = yy_start;
yy_match:
do
{
REGISTER YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
if ( yy_accept[yy_current_state] )
{
yy_last_accepting_state = yy_current_state;
yy_last_accepting_cpos = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 171 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
++yy_cp;
}
while ( yy_base[yy_current_state] != 561 );
yy_find_action:
yy_act = yy_accept[yy_current_state];
if ( yy_act == 0 )
{ /* have to back up */
yy_cp = yy_last_accepting_cpos;
yy_current_state = yy_last_accepting_state;
yy_act = yy_accept[yy_current_state];
}
YY_DO_BEFORE_ACTION;
do_action: /* This label is used only to access EOF actions. */
switch ( yy_act )
{ /* beginning of action switch */
case 0: /* must back up */
/* undo the effects of YY_DO_BEFORE_ACTION */
*yy_cp = yy_hold_char;
yy_cp = yy_last_accepting_cpos;
yy_current_state = yy_last_accepting_state;
goto yy_find_action;
case 1:
YY_RULE_SETUP
#line 122 "scanner.l"
{ }
YY_BREAK
case 2:
YY_RULE_SETUP
#line 123 "scanner.l"
{ }
YY_BREAK
case 3:
YY_RULE_SETUP
#line 124 "scanner.l"
{
yy_noeof=noeof_comment;
loop
{
REGISTER int c;
while ( (c = yyinput()) != '*' && c != EOF );
if ( c == '*' )
{
while ( (c = yyinput()) == '*' );
if ( c == '/' ) break; /* found the end */
}
else
{
break;
}
}
yy_noeof=0;
}
YY_BREAK
case 4:
YY_RULE_SETUP
#line 142 "scanner.l"
{ prompt_char='.';
blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);
return WHILE_CMD;}
YY_BREAK
case 5:
YY_RULE_SETUP
#line 145 "scanner.l"
{ prompt_char='.';
blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);
return FOR_CMD;}
YY_BREAK
case 6:
YY_RULE_SETUP
#line 149 "scanner.l"
{ yy_noeof = noeof_asstring;
BEGIN(asstring);
return HELP_CMD;
}
YY_BREAK
case 7:
YY_RULE_SETUP
#line 154 "scanner.l"
{ yy_noeof = noeof_asstring;
BEGIN(asstring);
return EXAMPLE_CMD;
}
YY_BREAK
case 8:
YY_RULE_SETUP
#line 159 "scanner.l"
{
char c; char *cp;
lvalp->name = omStrDup(iiProcName((char *)yytext,c,cp));
yy_noeof = noeof_procname;
blocknest = 1;
BEGIN(brace);
return PROC_DEF;
}
YY_BREAK
case 9:
YY_RULE_SETUP
#line 167 "scanner.l"
{
lvalp->name = omStrDup((char *)yytext);
yy_noeof = 0; BEGIN(INITIAL);
return STRINGTOK;
}
YY_BREAK
case 10:
YY_RULE_SETUP
#line 172 "scanner.l"
{
yy_noeof = 0; BEGIN(INITIAL);
return *yytext;
}
YY_BREAK
case 11:
YY_RULE_SETUP
#line 177 "scanner.l"
{
yy_noeof = noeof_string;
BEGIN(bracestr);
yymore();
}
YY_BREAK
case 12:
YY_RULE_SETUP
#line 182 "scanner.l"
{ if (blocknest++) yymore(); }
YY_BREAK
case 13:
YY_RULE_SETUP
#line 183 "scanner.l"
{ if (blocknest) yymore(); }
YY_BREAK
case 14:
YY_RULE_SETUP
#line 184 "scanner.l"
{
if (blocknest)
{
lvalp->name = dupyytext();
return STRINGTOK;
}
}
YY_BREAK
case 15:
YY_RULE_SETUP
#line 191 "scanner.l"
{
if (--blocknest <= 0)
{
yy_noeof = 0;
BEGIN(INITIAL);
lvalp->name = dupyytext();
return STRINGTOK;
}
yymore();
}
YY_BREAK
case 16:
YY_RULE_SETUP
#line 201 "scanner.l"
{
yy_noeof = noeof_brace;
BEGIN(brace);
yymore();
}
YY_BREAK
case 17:
YY_RULE_SETUP
#line 206 "scanner.l"
{ yymore(); }
YY_BREAK
case 18:
YY_RULE_SETUP
#line 207 "scanner.l"
{ return '('; }
YY_BREAK
case 19:
YY_RULE_SETUP
#line 208 "scanner.l"
{ return ','; }
YY_BREAK
case 20:
YY_RULE_SETUP
#line 209 "scanner.l"
{ ; }
YY_BREAK
case 21:
YY_RULE_SETUP
#line 210 "scanner.l"
{
lvalp->name = omStrDup((char *)yytext);
return STRINGTOK;
}
YY_BREAK
case 22:
YY_RULE_SETUP
#line 214 "scanner.l"
{
lvalp->name = omStrDup((char *)yytext);
return STRINGTOK;
}
YY_BREAK
case 23:
YY_RULE_SETUP
#line 218 "scanner.l"
{
yy_noeof = 0; BEGIN(INITIAL);
return ')';
}
YY_BREAK
case 24:
YY_RULE_SETUP
#line 223 "scanner.l"
{
yy_blocklineno = yylineno;
blocknest = 1;
yy_noeof = noeof_block;
BEGIN(block);
}
YY_BREAK
case 25:
YY_RULE_SETUP
#line 229 "scanner.l"
{
yy_noeof = noeof_string;
BEGIN(blockstr);
yymore();
}
YY_BREAK
case 26:
YY_RULE_SETUP
#line 234 "scanner.l"
{ yymore(); }
YY_BREAK
case 27:
YY_RULE_SETUP
#line 235 "scanner.l"
{ yymore(); }
YY_BREAK
case 28:
YY_RULE_SETUP
#line 236 "scanner.l"
{ yymore(); }
YY_BREAK
case 29:
YY_RULE_SETUP
#line 237 "scanner.l"
{
yy_noeof = noeof_block;
BEGIN(block);
yymore();
}
YY_BREAK
case 30:
YY_RULE_SETUP
#line 242 "scanner.l"
{ yymore(); }
YY_BREAK
case 31:
YY_RULE_SETUP
#line 243 "scanner.l"
{ yymore(); }
YY_BREAK
case 32:
YY_RULE_SETUP
#line 244 "scanner.l"
{ blocknest++; yymore(); }
YY_BREAK
case 33:
YY_RULE_SETUP
#line 245 "scanner.l"
{
if (--blocknest <= 0)
{
BEGIN(INITIAL);
yy_noeof = 0;
lvalp->name = dupyytextNL();
return BLOCKTOK;
}
yymore();
}
YY_BREAK
case 34:
YY_RULE_SETUP
#line 255 "scanner.l"
{ BEGIN(string); yy_noeof = noeof_string;}
YY_BREAK
case 35:
YY_RULE_SETUP
#line 256 "scanner.l"
{ return SYS_BREAK; }
YY_BREAK
case 36:
YY_RULE_SETUP
#line 257 "scanner.l"
{ yymore(); }
YY_BREAK
case 37:
YY_RULE_SETUP
#line 258 "scanner.l"
{ yymore(); }
YY_BREAK
case 38:
YY_RULE_SETUP
#line 259 "scanner.l"
{ yymore(); }
YY_BREAK
case 39:
YY_RULE_SETUP
#line 260 "scanner.l"
{
char * s;
yy_noeof = 0;
BEGIN(INITIAL);
s = lvalp->name = dupyytext();
while (*yytext)
{
if (*yytext == '\\') yytext++;
*s++ = *yytext++;
}
*s++ = *yytext++;
return STRINGTOK;
}
YY_BREAK
case 40:
YY_RULE_SETUP
#line 274 "scanner.l"
/* skip whitespace */
YY_BREAK
case 41:
YY_RULE_SETUP
#line 275 "scanner.l"
{ return DOTDOT; }
YY_BREAK
case 42:
YY_RULE_SETUP
#line 276 "scanner.l"
{ return COLONCOLON; }
YY_BREAK
case 43:
YY_RULE_SETUP
#line 277 "scanner.l"
{ return MINUSMINUS; }
YY_BREAK
case 44:
YY_RULE_SETUP
#line 278 "scanner.l"
{ return PLUSPLUS ; }
YY_BREAK
case 45:
YY_RULE_SETUP
#line 279 "scanner.l"
{ return EQUAL_EQUAL; }
YY_BREAK
case 46:
YY_RULE_SETUP
#line 280 "scanner.l"
{ lvalp->i='&'; return LOGIC_OP; }
YY_BREAK
case 47:
YY_RULE_SETUP
#line 281 "scanner.l"
{ lvalp->i='|'; return LOGIC_OP; }
YY_BREAK
case 48:
YY_RULE_SETUP
#line 282 "scanner.l"
{ lvalp->i=LE; return COMP_OP; }
YY_BREAK
case 49:
YY_RULE_SETUP
#line 283 "scanner.l"
{ lvalp->i=GE; return COMP_OP; }
YY_BREAK
case 50:
YY_RULE_SETUP
#line 284 "scanner.l"
{ return NOT; }
YY_BREAK
case 51:
YY_RULE_SETUP
#line 285 "scanner.l"
{ return NOTEQUAL; }
YY_BREAK
case 52:
YY_RULE_SETUP
#line 286 "scanner.l"
{ return NOTEQUAL; }
YY_BREAK
case 53:
YY_RULE_SETUP
#line 287 "scanner.l"
{ return '^'; }
YY_BREAK
case 54:
YY_RULE_SETUP
#line 288 "scanner.l"
{ return ARROW; }
YY_BREAK
case 55:
YY_RULE_SETUP
#line 289 "scanner.l"
{ return '\\'; }
YY_BREAK
case 56:
YY_RULE_SETUP
#line 290 "scanner.l"
{
lvalp->name = omStrDup("\n");
return STRINGTOK;
}
YY_BREAK
case 57:
YY_RULE_SETUP
#line 294 "scanner.l"
{
lvalp->name = (char *)yytext;
return INT_CONST;
}
YY_BREAK
case 58:
YY_RULE_SETUP
#line 298 "scanner.l"
{
lvalp->name = (char *)yytext;
return MONOM;
}
YY_BREAK
case 59:
YY_RULE_SETUP
#line 302 "scanner.l"
{
m2_end(1);
}
YY_BREAK
case 60:
YY_RULE_SETUP
#line 305 "scanner.l"
{
#ifdef MM_STAT
mmStat(-500);
#endif
#ifdef OM_TRACK
#ifndef SING_NDEBUG
omPrintUsedTrackAddrs(stdout, 10);
#endif
#endif
m2_end(1);
}
YY_BREAK
case 61:
YY_RULE_SETUP
#line 317 "scanner.l"
{
lvalp->name = (char *)yytext;
return MONOM;
}
YY_BREAK
case 62:
YY_RULE_SETUP
#line 321 "scanner.l"
{
lvalp->name = (char *)yytext;
return MONOM;
}
YY_BREAK
case 63:
*yy_cp = yy_hold_char; /* undo effects of setting up yytext */
yy_c_buf_p = yy_cp -= 1;
YY_DO_BEFORE_ACTION; /* set up yytext again */
YY_RULE_SETUP
#line 325 "scanner.l"
{
lvalp->name = (char *)yytext;
return MONOM;
}
YY_BREAK
case 64:
YY_RULE_SETUP
#line 330 "scanner.l"
{
/* {name} */
int rc=0;
if (yytext[strlen((char *)yytext)-1] == '\n')
{
yytext[strlen((char *)yytext)-1] = '\0';
}
if (yyleng > 1)
{
rc = IsCmd((char *)yytext,lvalp->i);
if (rc) return rc;
}
lvalp->name = omStrDup((char *)yytext);
return UNKNOWN_IDENT;
}
YY_BREAK
case 65:
YY_RULE_SETUP
#line 346 "scanner.l"
{
/*if (*yytext == '\n') REJECT;*/
REGISTER char ch= *yytext;
lvalp->i = ch;
switch(ch)
{
/* case '&': */
case '|':
return LOGIC_OP;
/* case '/': */
case '%':
case '*':
return MULDIV_OP;
/* case '<': */
case '>':
return COMP_OP;
default:
break;
}
return ch;
}
YY_BREAK
case 66:
YY_RULE_SETUP
#line 367 "scanner.l"
YY_FATAL_ERROR( "flex scanner jammed" );
YY_BREAK
case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(string):
case YY_STATE_EOF(block):
case YY_STATE_EOF(blockstr):
case YY_STATE_EOF(brace):
case YY_STATE_EOF(bracestr):
case YY_STATE_EOF(bracket):
case YY_STATE_EOF(asstring):
yyterminate();
case YY_END_OF_BUFFER:
{
/* Amount of text matched not including the EOB char. */
int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
/* Undo the effects of YY_DO_BEFORE_ACTION. */
*yy_cp = yy_hold_char;
YY_RESTORE_YY_MORE_OFFSET
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
{
/* We're scanning a new file or input source. It's
* possible that this happened because the user
* just pointed yyin at a new source and called
* yylex(). If so, then we have to assure
* consistency between yy_current_buffer and our
* globals. Here is the right place to do so, because
* this is the first action (other than possibly a
* back-up) that will match for the new input source.
*/
yy_n_chars = yy_current_buffer->yy_n_chars;
yy_current_buffer->yy_input_file = yyin;
yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
}
/* Note that here we test for yy_c_buf_p "<=" to the position
* of the first EOB in the buffer, since yy_c_buf_p will
* already have been incremented past the NUL character
* (since all states make transitions on EOB to the
* end-of-buffer state). Contrast this with the test
* in input().
*/
if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
{ /* This was really a NUL. */
yy_state_type yy_next_state;
yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state();
/* Okay, we're now positioned to make the NUL
* transition. We couldn't have
* yy_get_previous_state() go ahead and do it
* for us because it doesn't know how to deal
* with the possibility of jamming (and we don't
* want to build jamming into it because then it
* will run more slowly).
*/
yy_next_state = yy_try_NUL_trans( yy_current_state );
yy_bp = yytext_ptr + YY_MORE_ADJ;
if ( yy_next_state )
{
/* Consume the NUL. */
yy_cp = ++yy_c_buf_p;
yy_current_state = yy_next_state;
goto yy_match;
}
else
{
yy_cp = yy_c_buf_p;
goto yy_find_action;
}
}
else switch ( yy_get_next_buffer() )
{
case EOB_ACT_END_OF_FILE:
{
yy_did_buffer_switch_on_eof = 0;
if ( yywrap() )
{
/* Note: because we've taken care in
* yy_get_next_buffer() to have set up
* yytext, we can now set up
* yy_c_buf_p so that if some total
* hoser (like flex itself) wants to
* call the scanner after we return the
* YY_NULL, it'll still work - another
* YY_NULL will get returned.
*/
yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
yy_act = YY_STATE_EOF(YY_START);
goto do_action;
}
else
{
if ( ! yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
}
break;
}
case EOB_ACT_CONTINUE_SCAN:
yy_c_buf_p =
yytext_ptr + yy_amount_of_matched_text;
yy_current_state = yy_get_previous_state();
yy_cp = yy_c_buf_p;
yy_bp = yytext_ptr + YY_MORE_ADJ;
goto yy_match;
case EOB_ACT_LAST_MATCH:
yy_c_buf_p =
&yy_current_buffer->yy_ch_buf[yy_n_chars];
yy_current_state = yy_get_previous_state();
yy_cp = yy_c_buf_p;
yy_bp = yytext_ptr + YY_MORE_ADJ;
goto yy_find_action;
}
break;
}
default:
YY_FATAL_ERROR(
"fatal flex scanner internal error--no action found" );
} /* end of action switch */
} /* end of scanning one token */
prompt_char
EXTERN_VAR char prompt_char
Definition feread.h:10
blocknest
EXTERN_VAR int blocknest
Definition fevoices.cc:45
PLUSPLUS
@ PLUSPLUS
Definition grammar.cc:274
NOT
@ NOT
Definition grammar.cc:272
MINUSMINUS
@ MINUSMINUS
Definition grammar.cc:271
EXAMPLE_CMD
@ EXAMPLE_CMD
Definition grammar.cc:324
SYS_BREAK
@ SYS_BREAK
Definition grammar.cc:347
ARROW
@ ARROW
Definition grammar.cc:276
GE
@ GE
Definition grammar.cc:269
EQUAL_EQUAL
@ EQUAL_EQUAL
Definition grammar.cc:268
INT_CONST
@ INT_CONST
Definition grammar.cc:334
BLOCKTOK
@ BLOCKTOK
Definition grammar.cc:333
LE
@ LE
Definition grammar.cc:270
MONOM
@ MONOM
Definition grammar.cc:336
UNKNOWN_IDENT
@ UNKNOWN_IDENT
Definition grammar.cc:335
FOR_CMD
@ FOR_CMD
Definition grammar.cc:345
NOTEQUAL
@ NOTEQUAL
Definition grammar.cc:273
STRINGTOK
@ STRINGTOK
Definition grammar.cc:332
DOTDOT
@ DOTDOT
Definition grammar.cc:267
PROC_DEF
@ PROC_DEF
Definition grammar.cc:337
COLONCOLON
@ COLONCOLON
Definition grammar.cc:275
WHILE_CMD
@ WHILE_CMD
Definition grammar.cc:348
HELP_CMD
@ HELP_CMD
Definition grammar.cc:326
IsCmd
int IsCmd(const char *n, int &tok)
Definition iparith.cc:9773
iiProcName
char * iiProcName(char *buf, char &ct, char *&e)
Definition iplib.cc:100
YY_NEW_FILE
#define YY_NEW_FILE
Definition libparse.cc:112
YY_CHAR
unsigned char YY_CHAR
Definition libparse.cc:284
string
#define string
Definition libparse.cc:1252
YY_BREAK
#define YY_BREAK
Definition libparse.cc:1402
yy_ec
static yyconst int yy_ec[256]
Definition libparse.cc:365
yy_n_chars
STATIC_VAR int yy_n_chars
Definition libparse.cc:233
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition libparse.cc:206
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition libparse.cc:1048
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition libparse.cc:207
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition libparse.cc:1405
yy_base
static yyconst short int yy_base[533]
Definition libparse.cc:407
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition libparse.cc:125
yy_did_buffer_switch_on_eof
STATIC_VAR int yy_did_buffer_switch_on_eof
Definition libparse.cc:246
YY_START
#define YY_START
Definition libparse.cc:105
yy_state_type
int yy_state_type
Definition libparse.cc:286
yy_act
REGISTER int yy_act
Definition libparse.cc:1415
INITIAL
#define INITIAL
Definition libparse.cc:1051
yy_def
static yyconst short int yy_def[533]
Definition libparse.cc:470
yy_nxt
static yyconst short int yy_nxt[2253]
Definition libparse.cc:533
yy_accept
static yyconst short int yy_accept[485]
Definition libparse.cc:308
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition libparse.cc:109
yy_chk
static yyconst short int yy_chk[2253]
Definition libparse.cc:785
yyterminate
#define yyterminate()
Definition libparse.cc:1373
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition libparse.cc:126
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition libparse.cc:124
yy_meta
static yyconst int yy_meta[53]
Definition libparse.cc:397
yy_last_accepting_state
STATIC_VAR yy_state_type yy_last_accepting_state
Definition libparse.cc:1037
yy_last_accepting_cpos
STATIC_VAR char * yy_last_accepting_cpos
Definition libparse.cc:1038
m2_end
void m2_end(int i)
Definition misc_ip.cc:1104
yy_blocklineno
EXTERN_VAR int yy_blocklineno
Definition reporter.h:18
block
#define block
Definition scanner.cc:646
brace
#define brace
Definition scanner.cc:650
yymore
#define yymore()
Definition scanner.cc:555
yyinput
static int yyinput()
Definition scanner.cc:1791
bracestr
#define bracestr
Definition scanner.cc:652
yy_get_next_buffer
static int yy_get_next_buffer()
Definition scanner.cc:1550
blockstr
#define blockstr
Definition scanner.cc:648
asstring
#define asstring
Definition scanner.cc:656
bracket
#define bracket
Definition scanner.cc:654
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition scanner.cc:90
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition scanner.cc:777
yy_get_previous_state
static yy_state_type yy_get_previous_state()
Definition scanner.cc:1682
dupyytext
static char * dupyytext()
Definition scanner.cc:597
yywrap
int yywrap()
Definition scanner.cc:630
yy_c_buf_p
STATIC_VAR char * yy_c_buf_p
Definition scanner.cc:220
dupyytextNL
static char * dupyytextNL()
Definition scanner.cc:606
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition scanner.cc:1717
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition scanner.cc:74
LOGIC_OP
#define LOGIC_OP
Definition tok.h:25
COMP_OP
#define COMP_OP
Definition tok.h:27
MULDIV_OP
#define MULDIV_OP
Definition tok.h:26
omPrintUsedTrackAddrs
#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.

{
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_buf_size = size;
/* yy_ch_buf has to be 2 characters longer than the size given because
* we need to put in 2 end-of-buffer characters.
*/
b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
b->yy_is_our_buffer = 1;
yy_init_buffer( b, file );
return b;
}
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition cf_ops.cc:600
yy_init_buffer
#define yy_init_buffer
Definition libparse.cc:7
yy_flex_alloc
static void * yy_flex_alloc(yy_size_t size)
Definition scanner.cc:2250
yy_buffer_state
Definition libparse.cc:165

## yy_delete_buffer()

void yy_delete_buffer | ( | YY_BUFFER_STATE | b | ) |

Definition at line 1953 of file scanner.cc.

{
if ( ! b )
return;
if ( b == yy_current_buffer )
yy_current_buffer = (YY_BUFFER_STATE) 0;
if ( b->yy_is_our_buffer )
yy_flex_free( (void *) b->yy_ch_buf );
yy_flex_free( (void *) b );
}
yy_flex_free
static void yy_flex_free(void *ptr)
Definition scanner.cc:2278

## yy_fatal_error()

void yy_fatal_error | ( | yyconst char | msg[] | ) |

static

Definition at line 2186 of file scanner.cc.

{
(void) fprintf( stderr, "%s\n", msg );
exit( YY_EXIT_FAILURE );
}
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition libparse.cc:3231

## yy_flex_alloc()

void * yy_flex_alloc | ( | yy_size_t | size | ) |

static

Definition at line 2250 of file scanner.cc.

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

## yy_flex_free()

void yy_flex_free | ( | void * | ptr | ) |

static

Definition at line 2278 of file scanner.cc.

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

## yy_flex_realloc()

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

static

Definition at line 2260 of file scanner.cc.

{
/* The cast to (char *) in the following accommodates both
* implementations that use char* generic pointers, and those
* that use void* generic pointers. It works with the latter
* because both ANSI C and C++ allow castless assignment from
* any pointer type to void*, and deal with argument conversions
* as though doing an assignment.
*/
return (void *) realloc( (char *) ptr, size );
}
realloc
#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.

{
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == yy_current_buffer )
yy_load_buffer_state();
}
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition libparse.cc:114

## yy_get_next_buffer()

int yy_get_next_buffer | ( |  | ) |

static

Definition at line 1550 of file scanner.cc.

{
REGISTER char *dest = yy_current_buffer->yy_ch_buf;
REGISTER char *source = yytext_ptr;
REGISTER int number_to_move, i;
int ret_val;
if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
YY_FATAL_ERROR(
"fatal flex scanner internal error--end of buffer missed" );
if ( yy_current_buffer->yy_fill_buffer == 0 )
{ /* Don't try to fill the buffer, so this is an EOF. */
if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
{
/* We matched a single character, the EOB, so
* treat this as a final EOF.
*/
return EOB_ACT_END_OF_FILE;
}
else
{
/* We matched some text prior to the EOB, first
* process it.
*/
return EOB_ACT_LAST_MATCH;
}
}
/* Try to read more data. */
/* First move last chars to start of buffer. */
number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
for ( i = 0; i < number_to_move; ++i )
*(dest++) = *(source++);
if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
/* don't do the read, it's not guaranteed to return an EOF,
* just force an EOF
*/
yy_current_buffer->yy_n_chars = yy_n_chars = 0;
else
{
int num_to_read =
yy_current_buffer->yy_buf_size - number_to_move - 1;
while ( num_to_read <= 0 )
{ /* Not enough room in the buffer - grow it. */
#ifdef YY_USES_REJECT
YY_FATAL_ERROR(
"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
#else
/* just a shorter name for the current buffer */
YY_BUFFER_STATE b = yy_current_buffer;
int yy_c_buf_p_offset =
(int) (yy_c_buf_p - b->yy_ch_buf);
if ( b->yy_is_our_buffer )
{
int new_size = b->yy_buf_size * 2;
if ( new_size <= 0 )
b->yy_buf_size += b->yy_buf_size / 8;
else
b->yy_buf_size *= 2;
b->yy_ch_buf = (char *)
/* Include room in for 2 EOB chars. */
yy_flex_realloc( (void *) b->yy_ch_buf,
b->yy_buf_size + 2 );
}
else
/* Can't grow it, we don't own it. */
b->yy_ch_buf = 0;
if ( ! b->yy_ch_buf )
YY_FATAL_ERROR(
"fatal error - scanner input buffer overflow" );
yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
num_to_read = yy_current_buffer->yy_buf_size -
number_to_move - 1;
#endif
}
if ( num_to_read > YY_READ_BUF_SIZE )
num_to_read = YY_READ_BUF_SIZE;
/* Read in more data. */
YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
yy_n_chars, num_to_read );
yy_current_buffer->yy_n_chars = yy_n_chars;
}
if ( yy_n_chars == 0 )
{
if ( number_to_move == YY_MORE_ADJ )
{
ret_val = EOB_ACT_END_OF_FILE;
yyrestart( yyin );
}
else
{
ret_val = EOB_ACT_LAST_MATCH;
yy_current_buffer->yy_buffer_status =
YY_BUFFER_EOF_PENDING;
}
}
else
ret_val = EOB_ACT_CONTINUE_SCAN;
yy_n_chars += number_to_move;
yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
return ret_val;
}
yyrestart
#define yyrestart
Definition libparse.cc:15
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition libparse.cc:1334
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition libparse.cc:218
yy_flex_realloc
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition scanner.cc:2260
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition scanner.cc:634

## yy_get_previous_state()

yy_state_type yy_get_previous_state | ( |  | ) |

static

Definition at line 1682 of file scanner.cc.

{
REGISTER yy_state_type yy_current_state;
REGISTER char *yy_cp;
yy_current_state = yy_start;
for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
{
REGISTER YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
yy_last_accepting_state = yy_current_state;
yy_last_accepting_cpos = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 171 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
}
return yy_current_state;
}

## yy_init_buffer()

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

Definition at line 1979 of file scanner.cc.

{
yy_flush_buffer( b );
b->yy_input_file = file;
b->yy_fill_buffer = 1;
#if YY_ALWAYS_INTERACTIVE
b->yy_is_interactive = 1;
#else
#if YY_NEVER_INTERACTIVE
b->yy_is_interactive = 0;
#else
b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
#endif
#endif
}

## yy_load_buffer_state()

void yy_load_buffer_state | ( | void |  | ) |

Definition at line 1909 of file scanner.cc.

{
yy_n_chars = yy_current_buffer->yy_n_chars;
yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
yyin = yy_current_buffer->yy_input_file;
yy_hold_char = *yy_c_buf_p;
}

## 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]

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

static

## YY_PROTO() [5/15]

void yy_flex_free YY_PROTO | ( | (void *) |  | ) |

static

## YY_PROTO() [6/15]

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]

void *yy_flex_alloc YY_PROTO | ( | (yy_size_t) |  | ) |

static

## YY_PROTO() [12/15]

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]

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.

{
YY_BUFFER_STATE b;
if ( size < 2 ||
base[size-2] != YY_END_OF_BUFFER_CHAR ||
base[size-1] != YY_END_OF_BUFFER_CHAR )
/* They forgot to leave room for the EOB's. */
return 0;
b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
if ( ! b )
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
b->yy_buf_pos = b->yy_ch_buf = base;
b->yy_is_our_buffer = 0;
b->yy_input_file = 0;
b->yy_n_chars = b->yy_buf_size;
b->yy_is_interactive = 0;
b->yy_at_bol = 1;
b->yy_fill_buffer = 0;
b->yy_buffer_status = YY_BUFFER_NEW;
yy_switch_to_buffer( b );
return b;
}
CxxTest::base
char N base
Definition ValueTraits.h:144

## yy_scan_bytes()

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

Definition at line 2092 of file scanner.cc.

{
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
int i;
/* Get memory for full buffer, including space for trailing EOB's. */
n = len + 2;
buf = (char *) yy_flex_alloc( n );
if ( ! buf )
YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
for ( i = 0; i < len; ++i )
buf[i] = bytes[i];
buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
b = yy_scan_buffer( buf, n );
if ( ! b )
YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
/* It's okay to grow etc. this buffer, and we should throw it
* away when we're done.
*/
b->yy_is_our_buffer = 1;
return b;
}
yy_scan_buffer
#define yy_scan_buffer
Definition libparse.cc:3
yy_size_t
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.

{
int len;
for ( len = 0; yy_str[len]; ++len )
;
return yy_scan_bytes( yy_str, len );
}
yy_scan_bytes
#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.

{
if ( yy_current_buffer == new_buffer )
return;
if ( yy_current_buffer )
{
/* Flush out information for old buffer. */
*yy_c_buf_p = yy_hold_char;
yy_current_buffer->yy_buf_pos = yy_c_buf_p;
yy_current_buffer->yy_n_chars = yy_n_chars;
}
yy_current_buffer = new_buffer;
yy_load_buffer_state();
/* We don't actually know whether we did this switch during
* EOF (yywrap()) processing, but the only time this flag
* is looked at is after yywrap() is called, so it's safe
* to go ahead and always set it.
*/
yy_did_buffer_switch_on_eof = 1;
}

## yy_try_NUL_trans()

yy_state_type yy_try_NUL_trans | ( | yy_state_type | yy_current_state | ) |

static

Definition at line 1717 of file scanner.cc.

{
REGISTER int yy_is_jam;
REGISTER char *yy_cp = yy_c_buf_p;
REGISTER YY_CHAR yy_c = 1;
if ( yy_accept[yy_current_state] )
{
yy_last_accepting_state = yy_current_state;
yy_last_accepting_cpos = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 171 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
yy_is_jam = (yy_current_state == 170);
return yy_is_jam ? 0 : yy_current_state;
}

## yyinput()

int yyinput | ( |  | ) |

static

Definition at line 1791 of file scanner.cc.

{
int c;
*yy_c_buf_p = yy_hold_char;
if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
{
/* yy_c_buf_p now points to the character we want to return.
* If this occurs *before* the EOB characters, then it's a
* valid NUL; if not, then we've hit the end of the buffer.
*/
if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
/* This was really a NUL. */
*yy_c_buf_p = '\0';
else
{ /* need more input */
int offset = yy_c_buf_p - yytext_ptr;
++yy_c_buf_p;
switch ( yy_get_next_buffer() )
{
case EOB_ACT_LAST_MATCH:
/* This happens because yy_g_n_b()
* sees that we've accumulated a
* token and flags that we need to
* try matching the token before
* proceeding. But for input(),
* there's no matching to consider.
* So convert the EOB_ACT_LAST_MATCH
* to EOB_ACT_END_OF_FILE.
*/
/* Reset buffer status. */
yyrestart( yyin );
/* fall through */
case EOB_ACT_END_OF_FILE:
{
if ( yywrap() )
return EOF;
if ( ! yy_did_buffer_switch_on_eof )
YY_NEW_FILE;
#ifdef __cplusplus
return yyinput();
#else
return input();
#endif
}
case EOB_ACT_CONTINUE_SCAN:
yy_c_buf_p = yytext_ptr + offset;
break;
}
}
}
c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
*yy_c_buf_p = '\0'; /* preserve yytext */
yy_hold_char = *++yy_c_buf_p;
return c;
}

## yyrestart()

void yyrestart | ( | FILE * | input_file | ) |

Definition at line 1864 of file scanner.cc.

{
if ( ! yy_current_buffer )
yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
yy_init_buffer( yy_current_buffer, input_file );
yy_load_buffer_state();
}

## yyunput()

void yyunput | ( | int | c,
|  | REGISTER char * | yy_bp )

static

Definition at line 1747 of file scanner.cc.

{
REGISTER char *yy_cp = yy_c_buf_p;
/* undo effects of setting up yytext */
*yy_cp = yy_hold_char;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
{ /* need to shift things up to make room */
/* +2 for EOB chars. */
REGISTER int number_to_move = yy_n_chars + 2;
REGISTER char *dest = &yy_current_buffer->yy_ch_buf[
yy_current_buffer->yy_buf_size + 2];
REGISTER char *source =
&yy_current_buffer->yy_ch_buf[number_to_move];
while ( source > yy_current_buffer->yy_ch_buf )
*--dest = *--source;
yy_cp += (int) (dest - source);
yy_bp += (int) (dest - source);
yy_current_buffer->yy_n_chars =
yy_n_chars = yy_current_buffer->yy_buf_size;
if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
YY_FATAL_ERROR( "flex scanner push-back overflow" );
}
*--yy_cp = (char) c;
yytext_ptr = yy_bp;
yy_hold_char = *yy_cp;
yy_c_buf_p = yy_cp;
}
yy_cp
REGISTER char * yy_cp
Definition scanner.cc:805

## yywrap()

int yywrap | ( |  | ) |

Definition at line 630 of file scanner.cc.

{ return exitVoice(); }
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.

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

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

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

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

{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 3, 4,
5, 6, 7, 8, 30, 9, 30, 150, 26, 10,
9, 9, 5, 6, 10, 10, 26, 52, 3, 4,
9, 161, 7, 8, 10, 13, 13, 15, 16, 13,
161, 31, 34, 34, 13, 13, 31, 52, 13, 5,
6, 5, 6, 14, 14, 15, 16, 14, 149, 29,
37, 37, 14, 14, 40, 41, 14, 29, 32, 32,
32, 42, 40, 41, 60, 142, 43, 44, 45, 42,
46, 141, 42, 41, 43, 44, 45, 43, 46, 40,
69, 69, 80, 46, 60, 70, 70, 140, 44, 70,
80, 45, 81, 82, 70, 70, 88, 92, 70, 118,
81, 82, 91, 91, 91, 100, 100, 88, 92, 94,
94, 94, 101, 106, 102, 103, 104, 93, 106, 105,
101, 101, 102, 103, 104, 55, 101, 105, 107, 112,
103, 48, 112, 107, 122, 102, 122, 105, 116, 116,
104, 117, 117, 164, 126, 117, 124, 124, 124, 36,
117, 117, 164, 35, 117, 126, 127, 129, 127, 128,
128, 128, 129, 130, 129, 131, 33, 132, 130, 133,
131, 112, 132, 112, 133, 133, 130, 132, 134, 134,
135, 136, 147, 134, 143, 135, 136, 136, 137, 143,
28, 137, 27, 135, 143, 144, 144, 145, 145, 146,
148, 152, 148, 156, 146, 148, 152, 152, 147, 151,
151, 151, 25, 147, 144, 155, 145, 153, 153, 157,
155, 144, 163, 155, 157, 23, 144, 163, 156, 158,
137, 158, 137, 159, 158, 159, 153, 160, 159, 162,
162, 21, 165, 167, 168, 17, 160, 169, 169, 12,
11, 165, 167, 168, 160, 0, 0, 0, 162, 165,
167, 168, 160, 0, 0, 0, 0, 165, 167, 168,
171, 171, 171, 171, 171, 171, 171, 171, 171, 171,
171, 171, 172, 172, 172, 172, 172, 172, 172, 172,
172, 172, 172, 172, 173, 173, 173, 173, 173, 173,
173, 173, 173, 173, 173, 173, 174, 174, 174, 174,
174, 174, 174, 174, 174, 174, 174, 174, 175, 175,
175, 175, 175, 175, 175, 175, 175, 175, 175, 175,
176, 176, 176, 176, 176, 176, 176, 176, 176, 176,
176, 176, 177, 177, 177, 177, 177, 177, 177, 177,
177, 177, 177, 177, 178, 0, 0, 0, 0, 178,
0, 178, 179, 0, 0, 179, 179, 179, 180, 180,
180, 0, 180, 180, 180, 180, 180, 180, 180, 180,
181, 0, 0, 181, 181, 0, 0, 181, 181, 181,
181, 181, 182, 182, 182, 182, 182, 182, 182, 182,
182, 182, 182, 182, 183, 183, 0, 183, 183, 183,
183, 183, 183, 183, 0, 183, 184, 184, 0, 184,
184, 184, 184, 184, 184, 184, 184, 184, 185, 185,
0, 185, 185, 185, 185, 185, 185, 185, 185, 185,
186, 186, 186, 186, 186, 186, 186, 0, 186, 186,
186, 186, 187, 187, 187, 187, 187, 187, 187, 187,
187, 187, 187, 187, 188, 188, 188, 188, 188, 188,
188, 188, 188, 188, 188, 188, 189, 189, 0, 189,
189, 189, 189, 189, 189, 189, 189, 189, 190, 0,
0, 190, 0, 0, 0, 0, 0, 0, 190, 191,
0, 0, 191, 191, 0, 0, 0, 191, 0, 191,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170
} ;

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

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

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

{ 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 5, 6, 7, 8, 1, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 19, 19,
19, 19, 19, 19, 19, 19, 19, 20, 21, 22,
23, 24, 25, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
1, 26, 1, 1, 27, 1, 28, 10, 29, 10,
30, 31, 10, 32, 33, 10, 10, 34, 35, 36,
37, 38, 39, 40, 10, 41, 42, 10, 43, 44,
10, 10, 45, 46, 47, 48, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1
} ;

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

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

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

{ 0,
18, 19, 20, 19, 21, 22, 23, 24, 25, 26,
18, 18, 27, 28, 18, 29, 30, 31, 32, 33,
18, 34, 35, 36, 37, 38, 39, 26, 26, 40,
41, 42, 26, 26, 26, 43, 26, 44, 45, 26,
26, 26, 46, 26, 47, 48, 18, 49, 51, 51,
54, 54, 59, 59, 87, 62, 88, 150, 81, 62,
63, 64, 55, 55, 63, 64, 82, 109, 52, 52,
65, 164, 60, 60, 65, 69, 69, 75, 75, 70,
166, 89, 96, 97, 71, 72, 90, 110, 73, 56,
56, 57, 57, 69, 69, 76, 76, 70, 149, 85,
100, 100, 71, 72, 81, 81, 73, 86, 92, 93,
94, 81, 82, 82, 113, 151, 81, 81, 81, 82,
81, 150, 103, 102, 82, 82, 82, 104, 82, 101,
116, 116, 81, 107, 114, 118, 118, 149, 105, 119,
82, 106, 81, 81, 118, 118, 88, 126, 118, 139,
82, 82, 170, 170, 124, 100, 100, 122, 127, 92,
93, 94, 81, 80, 81, 81, 81, 128, 135, 81,
82, 129, 82, 82, 82, 112, 130, 82, 80, 111,
132, 108, 138, 136, 140, 131, 140, 134, 116, 116,
133, 118, 118, 164, 88, 119, 170, 170, 124, 99,
118, 118, 166, 98, 118, 122, 141, 80, 141, 170,
142, 128, 80, 80, 143, 80, 95, 80, 80, 80,
80, 138, 80, 138, 80, 146, 144, 145, 80, 147,
80, 80, 156, 80, 80, 80, 80, 148, 111, 80,
84, 138, 83, 144, 152, 153, 153, 100, 100, 80,
80, 80, 157, 156, 155, 80, 80, 158, 80, 170,
142, 151, 79, 80, 154, 80, 170, 153, 153, 80,
80, 80, 80, 159, 80, 78, 80, 80, 161, 80,
138, 162, 138, 80, 80, 163, 154, 164, 80, 169,
169, 77, 164, 164, 164, 170, 166, 169, 169, 67,
67, 166, 166, 166, 167, 170, 170, 170, 170, 167,
167, 167, 168, 170, 170, 170, 170, 168, 168, 168,
50, 50, 50, 50, 50, 50, 50, 50, 50, 50,
50, 50, 53, 53, 53, 53, 53, 53, 53, 53,
53, 53, 53, 53, 58, 58, 58, 58, 58, 58,
58, 58, 58, 58, 58, 58, 61, 61, 61, 61,
61, 61, 61, 61, 61, 61, 61, 61, 66, 66,
66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
68, 68, 74, 74, 74, 74, 74, 74, 74, 74,
74, 74, 74, 74, 80, 170, 170, 170, 170, 80,
170, 80, 91, 170, 170, 91, 91, 91, 111, 111,
111, 170, 111, 111, 111, 111, 111, 111, 111, 111,
115, 170, 170, 115, 115, 170, 170, 115, 115, 115,
115, 115, 117, 117, 117, 117, 117, 117, 117, 117,
117, 117, 117, 117, 120, 120, 170, 120, 120, 120,
120, 120, 120, 120, 170, 120, 121, 121, 170, 121,
121, 121, 121, 121, 121, 121, 121, 121, 123, 123,
170, 123, 123, 123, 123, 123, 123, 123, 123, 123,
125, 125, 125, 125, 125, 125, 125, 170, 125, 125,
125, 125, 137, 137, 137, 137, 137, 137, 137, 137,
137, 137, 137, 137, 118, 118, 118, 118, 118, 118,
118, 118, 118, 118, 118, 118, 138, 138, 170, 138,
138, 138, 138, 138, 138, 138, 138, 138, 160, 170,
170, 160, 170, 170, 170, 170, 170, 170, 160, 165,
170, 170, 165, 165, 170, 170, 170, 165, 170, 165,
17, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
170, 170, 170, 170, 170, 170, 170, 170, 170
} ;

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