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

Data Structures
struct	YY_BUFFER_STATE

Macros
#define	FLEX_SCANNER

#define	YY_FLEX_MAJOR_VERSION 2

#define	YY_FLEX_MINOR_VERSION 5

#define	YY_USE_PROTOS

#define	YY_USE_CONST

#define	yyconst const

#define	YY_PROTO(proto) proto

#define	YY_NULL 0

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

#define	BEGIN yy_start = 1 + 2 *

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

#define	YYSTATE YY_START

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

#define	YY_NEW_FILE yyrestart( yyin )

#define	YY_END_OF_BUFFER_CHAR 0

#define	YY_BUF_SIZE 16384

#define	EOB_ACT_CONTINUE_SCAN 0

#define	EOB_ACT_END_OF_FILE 1

#define	EOB_ACT_LAST_MATCH 2

#define	yyless(n)

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

#define	YY_BUFFER_NEW 0

#define	YY_BUFFER_NORMAL 1

#define	YY_BUFFER_EOF_PENDING 2

#define	YY_CURRENT_BUFFER yy_current_buffer

#define	YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )

#define	yy_new_buffer yy_create_buffer

#define	yy_set_interactive(is_interactive)

#define	yy_set_bol(at_bol)

#define	YY_AT_BOL() (yy_current_buffer->yy_at_bol)

#define	yytext_ptr yytext

#define	YY_DO_BEFORE_ACTION

#define	YY_NUM_RULES 66

#define	YY_END_OF_BUFFER 67

#define	REJECT reject_used_but_not_detected

#define	yymore() (yy_more_flag = 1)

#define	YY_MORE_ADJ yy_more_len

#define	YY_RESTORE_YY_MORE_OFFSET

#define	INITIAL 0

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

#define	malloc omAlloc

#define	realloc omRealloc

#define	free omFree

#define	YY_DECL int yylex(YYSTYPE* lvalp)

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

#define	YY_USER_ACTION

#define	YY_ALWAYS_INTERACTIVE 1

#define	string 1

#define	block 2

#define	blockstr 3

#define	brace 4

#define	bracestr 5

#define	bracket 6

#define	asstring 7

#define	YY_NO_PUSH_STATE 1

#define	YY_NO_POP_STATE 1

#define	YY_NO_TOP_STATE 1

#define	YY_READ_BUF_SIZE 8192

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

#define	yyterminate() return YY_NULL

#define	YY_START_STACK_INCR 25

#define	YY_FATAL_ERROR(msg) yy_fatal_error( msg )

#define	YY_BREAK break;

#define	YY_RULE_SETUP YY_USER_ACTION

#define	YY_EXIT_FAILURE 2

#define	yyless(n)

Typedefs
typedef unsigned int	yy_size_t

typedef unsigned char	YY_CHAR

typedef int	yy_state_type

Functions
void yyrestart	YY_PROTO ((FILE *input_file))

void yy_switch_to_buffer	YY_PROTO ((YY_BUFFER_STATE new_buffer))

void yy_load_buffer_state	YY_PROTO ((void))

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

void yy_delete_buffer	YY_PROTO ((YY_BUFFER_STATE b))

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

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

YY_BUFFER_STATE yy_scan_string	YY_PROTO ((yyconst char *yy_str))

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

static void *yy_flex_alloc	YY_PROTO ((yy_size_t))

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

static void yy_flex_free	YY_PROTO ((void *))

static yy_state_type yy_try_NUL_trans	YY_PROTO ((yy_state_type current_state))

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

int	feReadLine (char *b, int l)

static char *	dupyytext ()

static char *	dupyytextNL ()

int	yywrap ()

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

	if (yy_init)

	while (1)

static int	yy_get_next_buffer ()

static yy_state_type	yy_get_previous_state ()

static yy_state_type	yy_try_NUL_trans (yy_state_type yy_current_state)

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

static int	yyinput ()

void	yyrestart (FILE *input_file)

void	yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)

void	yy_load_buffer_state (void)

YY_BUFFER_STATE	yy_create_buffer (FILE *file, int size)

void	yy_delete_buffer (YY_BUFFER_STATE b)

void	yy_init_buffer (YY_BUFFER_STATE b, FILE *file)

void	yy_flush_buffer (YY_BUFFER_STATE b)

YY_BUFFER_STATE	yy_scan_buffer (char *base, yy_size_t size)

YY_BUFFER_STATE	yy_scan_string (yyconst char *yy_str)

YY_BUFFER_STATE	yy_scan_bytes (yyconst char *bytes, int len)

static void	yy_fatal_error (yyconst char msg[])

static void *	yy_flex_alloc (yy_size_t size)

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

static void	yy_flex_free (void *ptr)

void *	myynewbuffer ()

void	myyoldbuffer (void *oldb)

void	myychangebuffer ()

void	my_yy_flush ()

Variables
EXTERN_VAR int	yyleng

EXTERN_VAR FILE *	yyin = (FILE *) 0

EXTERN_VAR FILE *	yyout = (FILE *) 0

STATIC_VAR YY_BUFFER_STATE	yy_current_buffer = 0

STATIC_VAR char	yy_hold_char

STATIC_VAR int	yy_n_chars

STATIC_VAR char *	yy_c_buf_p = (char *) 0

STATIC_VAR int	yy_init = 1

STATIC_VAR int	yy_start = 0

STATIC_VAR int	yy_did_buffer_switch_on_eof

EXTERN_VAR char *	yytext

static yyconst short int	yy_accept [171]

static yyconst int	yy_ec [256]

static yyconst int	yy_meta [49]

static yyconst short int	yy_base [192]

static yyconst short int	yy_def [192]

static yyconst short int	yy_nxt [610]

static yyconst short int	yy_chk [610]

STATIC_VAR yy_state_type	yy_last_accepting_state

STATIC_VAR char *	yy_last_accepting_cpos

STATIC_VAR int	yy_more_flag = 0

STATIC_VAR int	yy_more_len = 0

VAR int	blocknest = 0

EXTERN_VAR int	inerror

	YY_DECL

register char *	yy_cp

register char *	yy_bp

register int	yy_act

Data Structure Documentation

◆ yy_buffer_state

struct yy_buffer_state

Definition at line 164 of file libparse.cc.

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

Macro Definition Documentation

◆ ALLOC

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

Definition at line 579 of file scanner.cc.

◆ asstring

#define asstring 7

Definition at line 656 of file scanner.cc.

◆ BEGIN

#define BEGIN yy_start = 1 + 2 *

Definition at line 80 of file scanner.cc.

◆ block

#define block 2

Definition at line 646 of file scanner.cc.

◆ blockstr

#define blockstr 3

Definition at line 648 of file scanner.cc.

◆ brace

#define brace 4

Definition at line 650 of file scanner.cc.

◆ bracestr

#define bracestr 5

Definition at line 652 of file scanner.cc.

◆ bracket

#define bracket 6

Definition at line 654 of file scanner.cc.

◆ ECHO

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

Definition at line 737 of file scanner.cc.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN 0

Definition at line 105 of file scanner.cc.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE 1

Definition at line 106 of file scanner.cc.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH 2

Definition at line 107 of file scanner.cc.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 7 of file scanner.cc.

◆ free

#define free omFree

Definition at line 594 of file scanner.cc.

◆ INITIAL

#define INITIAL 0

Definition at line 560 of file scanner.cc.

◆ malloc

#define malloc omAlloc

Definition at line 590 of file scanner.cc.

◆ realloc

#define realloc omRealloc

Definition at line 592 of file scanner.cc.

◆ REJECT

#define REJECT reject_used_but_not_detected

Definition at line 552 of file scanner.cc.

◆ string

#define string 1

Definition at line 644 of file scanner.cc.

◆ unput

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

Definition at line 136 of file scanner.cc.

◆ YY_ALWAYS_INTERACTIVE

#define YY_ALWAYS_INTERACTIVE 1

Definition at line 643 of file scanner.cc.

◆ YY_AT_BOL

#define YY_AT_BOL ( ) (yy_current_buffer->yy_at_bol)

Definition at line 263 of file scanner.cc.

◆ YY_BREAK

#define YY_BREAK break;

Definition at line 796 of file scanner.cc.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE 16384

Definition at line 98 of file scanner.cc.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING 2

Definition at line 199 of file scanner.cc.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW 0

Definition at line 187 of file scanner.cc.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL 1

Definition at line 188 of file scanner.cc.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER yy_current_buffer

Definition at line 208 of file scanner.cc.

◆ YY_DECL

#define YY_DECL int yylex(YYSTYPE* lvalp)

Definition at line 626 of file scanner.cc.

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION

Value:

        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;

Definition at line 279 of file scanner.cc.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER 67

Definition at line 288 of file scanner.cc.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR 0

Definition at line 95 of file scanner.cc.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE 2

Definition at line 2182 of file scanner.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR ( msg ) yy_fatal_error( msg )

Definition at line 777 of file scanner.cc.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION 2

Definition at line 8 of file scanner.cc.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION 5

Definition at line 9 of file scanner.cc.

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )

Definition at line 237 of file scanner.cc.

◆ YY_INPUT

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

Definition at line 634 of file scanner.cc.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ yy_more_len

Definition at line 556 of file scanner.cc.

◆ yy_new_buffer

#define yy_new_buffer yy_create_buffer

Definition at line 247 of file scanner.cc.

◆ YY_NEW_FILE

#define YY_NEW_FILE yyrestart( yyin )

Definition at line 93 of file scanner.cc.

◆ YY_NO_POP_STATE

#define YY_NO_POP_STATE 1

Definition at line 707 of file scanner.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE 1

Definition at line 706 of file scanner.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE 1

Definition at line 708 of file scanner.cc.

◆ YY_NULL

#define YY_NULL 0

Definition at line 67 of file scanner.cc.

◆ YY_NUM_RULES

#define YY_NUM_RULES 66

Definition at line 287 of file scanner.cc.

◆ YY_PROTO

#define YY_PROTO ( proto ) proto

Definition at line 61 of file scanner.cc.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE 8192

Definition at line 728 of file scanner.cc.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 557 of file scanner.cc.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP YY_USER_ACTION

Definition at line 799 of file scanner.cc.

◆ YY_SC_TO_UI

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

Definition at line 74 of file scanner.cc.

◆ yy_set_bol

#define yy_set_bol ( at_bol )

Value:

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

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_create_buffer( yyin, YY_BUF_SIZE ); \
        yy_current_buffer->yy_is_interactive = is_interactive; \
        }

Definition at line 249 of file scanner.cc.

◆ YY_START

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

Definition at line 86 of file scanner.cc.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR 25

Definition at line 772 of file scanner.cc.

◆ YY_STATE_EOF

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

Definition at line 90 of file scanner.cc.

◆ YY_USE_CONST

#define YY_USE_CONST

Definition at line 32 of file scanner.cc.

◆ YY_USE_PROTOS

#define YY_USE_PROTOS

Definition at line 29 of file scanner.cc.

◆ YY_USER_ACTION

#define YY_USER_ACTION

Value:

if ((inerror==1)&&(*yytext>=' '))\

{ Print(" skipping text from `%s`",yytext);inerror=2; }

Print

#define Print

Definition: emacs.cc:80

yytext

EXTERN_VAR char * yytext

Definition: scanner.cc:268

inerror

EXTERN_VAR int inerror

Definition: scanner.cc:586

Definition at line 638 of file scanner.cc.

◆ yyconst

#define yyconst const

Definition at line 54 of file scanner.cc.

◆ yyless [1/2]

#define yyless ( n )

Value:

        do \
                { \
                /* Undo effects of setting up yytext. */ \
                *yy_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 )

Definition at line 2201 of file scanner.cc.

◆ yyless [2/2]

#define yyless ( n )

Value:

        do \
                { \
                /* Undo effects of setting up yytext. */ \
                yytext[yyleng] = yy_hold_char; \
                yy_c_buf_p = yytext + n; \
                yy_hold_char = *yy_c_buf_p; \
                *yy_c_buf_p = '\0'; \
                yyleng = n; \
                } \
        while ( 0 )

Definition at line 2201 of file scanner.cc.

◆ yymore

#define yymore ( ) (yy_more_flag = 1)

Definition at line 555 of file scanner.cc.

◆ YYSTATE

#define YYSTATE YY_START

Definition at line 87 of file scanner.cc.

◆ yyterminate

#define yyterminate ( ) return YY_NULL

Definition at line 767 of file scanner.cc.

◆ yytext_ptr

#define yytext_ptr yytext

Definition at line 269 of file scanner.cc.

Typedef Documentation

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 265 of file scanner.cc.

◆ yy_size_t

typedef unsigned int yy_size_t

Definition at line 142 of file scanner.cc.

◆ yy_state_type

typedef int yy_state_type

Definition at line 267 of file scanner.cc.

Function Documentation

◆ dupyytext()

static char * dupyytext ( )

static

Definition at line 597 of file scanner.cc.

{
  char* s;
  if (yyleng>0) yytext[yyleng-1] = '\0';
  s = omStrDup((char *)yytext);
  omMarkAsStaticAddr(s);
  return s;
}

◆ dupyytextNL()

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

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

◆ 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();
                }

◆ my_yy_flush()

void my_yy_flush ( )

Definition at line 2318 of file scanner.cc.

2318{ YY_FLUSH_BUFFER;BEGIN(0); }

BEGIN

#define BEGIN

Definition: scanner.cc:80

YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER

Definition: scanner.cc:237

◆ 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));
}

◆ 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(0);
                         }
        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 */

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

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

static 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_flex_alloc()

static void * yy_flex_alloc ( yy_size_t size )

static

Definition at line 2250 of file scanner.cc.

        {
        return (void *) malloc( size );
        }

◆ yy_flex_free()

static void yy_flex_free ( void * ptr )

static

Definition at line 2278 of file scanner.cc.

        {
        free( ptr );
        }

◆ yy_flex_realloc()

static 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 );
        }

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

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

◆ yy_get_previous_state()

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

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

static

◆ YY_PROTO() [5/15]

static void yy_flex_free YY_PROTO ( (void *) )

static

◆ YY_PROTO() [6/15]

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

static

◆ YY_PROTO() [7/15]

void yy_load_buffer_state YY_PROTO ( (void) )

◆ YY_PROTO() [8/15]

void yy_delete_buffer YY_PROTO ( (YY_BUFFER_STATE b) )

◆ YY_PROTO() [9/15]

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

◆ YY_PROTO() [10/15]

void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer) )

◆ YY_PROTO() [11/15]

static void *yy_flex_alloc YY_PROTO ( (yy_size_t) )

static

◆ YY_PROTO() [12/15]

static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state) )

static

◆ YY_PROTO() [13/15]

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

◆ YY_PROTO() [14/15]

YY_BUFFER_STATE yy_scan_string YY_PROTO ( (yyconst char *yy_str) )

◆ YY_PROTO() [15/15]

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

static

◆ yy_scan_buffer()

YY_BUFFER_STATE yy_scan_buffer	(	char *	base,
		yy_size_t	size
	)

Definition at line 2037 of file scanner.cc.

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

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

static 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()

static 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()

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

◆ yywrap()

int yywrap ( )

Definition at line 630 of file scanner.cc.

630{ 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.

◆ yy_act

register int yy_act

Definition at line 806 of file scanner.cc.

◆ yy_base

yyconst short int yy_base[192]

static

Initial value:

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

Definition at line 352 of file scanner.cc.

◆ yy_bp

register char * yy_bp

Definition at line 805 of file scanner.cc.

◆ yy_c_buf_p

STATIC_VAR char* yy_c_buf_p = (char *) 0

Definition at line 220 of file scanner.cc.

◆ yy_chk

yyconst short int yy_chk[610]

static

Definition at line 475 of file scanner.cc.

◆ yy_cp

register char* yy_cp

Definition at line 805 of file scanner.cc.

◆ yy_current_buffer

STATIC_VAR YY_BUFFER_STATE yy_current_buffer = 0

Definition at line 202 of file scanner.cc.

◆ YY_DECL

YY_DECL

Initial value:

{

register yy_state_type yy_current_state

Definition at line 802 of file scanner.cc.

◆ yy_def

yyconst short int yy_def[192]

static

Initial value:

=
    {   0,
      170,    1,  171,  171,  172,  172,  173,  173,  174,  174,
      175,  175,  176,  176,  177,  177,  170,  170,  170,  170,
      170,  170,  170,  170,  170,  178,  170,  170,  170,  170,
      170,  179,  170,  170,  170,  170,  170,  170,  170,  178,
      178,  178,  178,  178,  178,  178,  170,  170,  170,  170,
      170,  170,  180,  170,  180,  170,  170,  170,  170,  170,
      170,  170,  170,  170,  170,  170,  170,  181,  170,  182,
      170,  170,  170,  183,  170,  170,  170,  184,  170,  178,
      178,  178,  170,  170,  170,  170,  170,  170,  170,  185,
      179,  186,  170,  179,  170,  170,  170,  170,  170,  170,
 
      178,  178,  178,  178,  178,  101,  101,  170,  170,  170,
      180,  187,  170,  170,  181,  170,  182,  188,  181,  183,
      184,  170,  185,  179,  170,  170,  170,  179,  101,  101,
      101,  101,  101,  101,  101,  101,  187,  189,  170,  170,
      170,  170,  101,  101,  144,  101,  101,  101,  170,  170,
      179,  101,  170,  170,  101,  190,  101,  101,  101,  191,
      170,  144,  101,  170,  191,  170,  191,  191,  170,    0,
      170,  170,  170,  170,  170,  170,  170,  170,  170,  170,
      170,  170,  170,  170,  170,  170,  170,  170,  170,  170,
      170
 
    }

Definition at line 378 of file scanner.cc.

◆ yy_did_buffer_switch_on_eof

STATIC_VAR int yy_did_buffer_switch_on_eof

Definition at line 227 of file scanner.cc.

◆ yy_ec

yyconst int yy_ec[256]

static

Definition at line 311 of file scanner.cc.

◆ yy_hold_char

STATIC_VAR char yy_hold_char

Definition at line 212 of file scanner.cc.

◆ yy_init

STATIC_VAR int yy_init = 1

Definition at line 221 of file scanner.cc.

◆ yy_last_accepting_cpos

STATIC_VAR char* yy_last_accepting_cpos

Definition at line 547 of file scanner.cc.

◆ yy_last_accepting_state

STATIC_VAR yy_state_type yy_last_accepting_state

Definition at line 546 of file scanner.cc.

◆ yy_meta

yyconst int yy_meta[49]

static

Initial value:

=
    {   0,
        1,    2,    3,    1,    1,    4,    1,    1,    1,    5,
        6,    7,    1,    1,    7,    1,    8,    9,   10,    1,
       11,    1,    1,    1,    1,    1,   12,    5,    5,    5,
        5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
        5,    5,    5,    5,    4,    1,    4,    1
    }

Definition at line 343 of file scanner.cc.

◆ yy_more_flag

STATIC_VAR int yy_more_flag = 0

Definition at line 553 of file scanner.cc.

◆ yy_more_len

STATIC_VAR int yy_more_len = 0

Definition at line 554 of file scanner.cc.

◆ yy_n_chars

STATIC_VAR int yy_n_chars

Definition at line 214 of file scanner.cc.

◆ yy_nxt

yyconst short int yy_nxt[610]

static

Definition at line 404 of file scanner.cc.

◆ yy_start

STATIC_VAR int yy_start = 0

Definition at line 222 of file scanner.cc.

◆ yyin

VAR FILE* yyin = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yyleng

EXTERN_VAR int yyleng

Definition at line 102 of file scanner.cc.

◆ yyout

VAR FILE * yyout = (FILE *) 0

Definition at line 103 of file scanner.cc.

◆ yytext

EXTERN_VAR char* yytext

Definition at line 268 of file scanner.cc.

Data Structures

Macros

Typedefs

Functions

Variables

Data Structure Documentation

◆ yy_buffer_state

Macro Definition Documentation

◆ ALLOC

◆ asstring

◆ BEGIN

◆ block

◆ blockstr

◆ brace

◆ bracestr

◆ bracket

◆ ECHO

◆ EOB_ACT_CONTINUE_SCAN

◆ EOB_ACT_END_OF_FILE

◆ EOB_ACT_LAST_MATCH

◆ FLEX_SCANNER

◆ free

◆ INITIAL

◆ malloc

◆ realloc

◆ REJECT

◆ string

◆ unput

◆ YY_ALWAYS_INTERACTIVE

◆ YY_AT_BOL

◆ YY_BREAK

◆ YY_BUF_SIZE

◆ YY_BUFFER_EOF_PENDING

◆ YY_BUFFER_NEW

◆ YY_BUFFER_NORMAL

◆ YY_CURRENT_BUFFER

◆ YY_DECL

◆ YY_DO_BEFORE_ACTION

◆ YY_END_OF_BUFFER

◆ YY_END_OF_BUFFER_CHAR

◆ YY_EXIT_FAILURE

◆ YY_FATAL_ERROR

◆ YY_FLEX_MAJOR_VERSION

◆ YY_FLEX_MINOR_VERSION

◆ YY_FLUSH_BUFFER

◆ YY_INPUT

◆ YY_MORE_ADJ

◆ yy_new_buffer

◆ YY_NEW_FILE

◆ YY_NO_POP_STATE

◆ YY_NO_PUSH_STATE

◆ YY_NO_TOP_STATE

◆ YY_NULL

◆ YY_NUM_RULES

◆ YY_PROTO

◆ YY_READ_BUF_SIZE

◆ YY_RESTORE_YY_MORE_OFFSET

◆ YY_RULE_SETUP

◆ YY_SC_TO_UI

◆ yy_set_bol

◆ yy_set_interactive

◆ YY_START

◆ YY_START_STACK_INCR

◆ YY_STATE_EOF

◆ YY_USE_CONST

◆ YY_USE_PROTOS

◆ YY_USER_ACTION

◆ yyconst

◆ yyless [1/2]

◆ yyless [2/2]

◆ yymore

◆ YYSTATE

◆ yyterminate

◆ yytext_ptr

Typedef Documentation

◆ YY_CHAR

◆ yy_size_t

◆ yy_state_type

Function Documentation

◆ dupyytext()