Data Structures | Macros | Typedefs | Enumerations | Functions | Variables
libparse.cc File Reference
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
#include <kernel/mod2.h>
#include <Singular/subexpr.h>
#include <Singular/grammar.h>
#include <Singular/ipshell.h>
#include <Singular/ipid.h>
#include <Singular/tok.h>
#include <misc/options.h>
#include <omalloc/omalloc.h>
#include <Singular/libparse.h>

Go to the source code of this file.

Data Structures

struct  YY_BUFFER_STATE
 

Macros

#define yy_create_buffer   yylp_create_buffer
 
#define yy_delete_buffer   yylp_delete_buffer
 
#define yy_scan_buffer   yylp_scan_buffer
 
#define yy_scan_string   yylp_scan_string
 
#define yy_scan_bytes   yylp_scan_bytes
 
#define yy_flex_debug   yylp_flex_debug
 
#define yy_init_buffer   yylp_init_buffer
 
#define yy_flush_buffer   yylp_flush_buffer
 
#define yy_load_buffer_state   yylp_load_buffer_state
 
#define yy_switch_to_buffer   yylp_switch_to_buffer
 
#define yyin   yylpin
 
#define yyleng   yylpleng
 
#define yylex   yylplex
 
#define yyout   yylpout
 
#define yyrestart   yylprestart
 
#define yytext   yylptext
 
#define yywrap   yylpwrap
 
#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   96
 
#define YY_END_OF_BUFFER   97
 
#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 YY_SKIP_YYWRAP
 
#define pi   IDPROC(h0)
 
#define SET_DEF_END(mode, pi, p)   if ( mode == LOAD_LIB) pi->data.s.def_end = p;
 
#define SET_HELP_START(mode, pi, p)   if ( mode == LOAD_LIB) {pi->data.s.help_start = p; help_chksum = 0;}
 
#define SET_HELP_END(mode, pi, p)
 
#define SET_BODY_START(mode, pi, l, p)
 
#define SET_BODY_END(mode, pi, p)
 
#define SET_EXAMPLE_START(mode, pi, l, p)
 
#define SET_PROC_END(mode, pi, p)
 
#define ROTATE_RIGHT(c)   if ((c) & 01) (c) = ((c) >>1) + 0x8000; else (c) >>= 1;
 
#define IncrCheckSum(c)
 
#define YY_DECL
 
#define YY_INPUT(buf, result, max_size)
 
#define YY_USER_INIT
 
#define header   1
 
#define help   2
 
#define libcmd   3
 
#define libcmd2   4
 
#define pdef   5
 
#define phead   6
 
#define poldhelp   7
 
#define phelp   8
 
#define pbody   9
 
#define pstr   10
 
#define pexample   11
 
#define pestr   12
 
#define string   13
 
#define comment   14
 
#define info   15
 
#define category   16
 
#define url   17
 
#define version   18
 
#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_USER_ACTION
 
#define YY_BREAK   break;
 
#define YY_RULE_SETUP
 
#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
 

Enumerations

enum  lib_cmds {
  LP_NONE, LP_INFO, LP_CATEGORY, LP_URL,
  LP_VERSION
}
 

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 libread (FILE *f, char *buf, int max_size)
 
int current_pos (int i)
 
void print_version (lp_modes mode, char *p)
 
void copy_string (lp_modes mode)
 
void make_version (char *p, int what)
 
int yylpwrap ()
 
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)
 
int isatty YY_PROTO ((int))
 
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 reinit_yylp ()
 
void print_init ()
 

Variables

int yyleng
 
FILE * yyin = (FILE *) 0
 
FILE * yyout = (FILE *) 0
 
static YY_BUFFER_STATE yy_current_buffer = 0
 
static char yy_hold_char
 
static int yy_n_chars
 
static char * yy_c_buf_p = (char *) 0
 
static int yy_init = 1
 
static int yy_start = 0
 
static int yy_did_buffer_switch_on_eof
 
char * yytext
 
static yyconst short int yy_accept [485]
 
static yyconst int yy_ec [256]
 
static yyconst int yy_meta [53]
 
static yyconst short int yy_base [533]
 
static yyconst short int yy_def [533]
 
static yyconst short int yy_nxt [2253]
 
static yyconst short int yy_chk [2253]
 
static yy_state_type yy_last_accepting_state
 
static char * yy_last_accepting_cpos
 
static int yy_more_flag = 0
 
static int yy_more_len = 0
 
int brace1 = 0
 
int brace2 = 0
 
int brace3 = 0
 
int quote = 0
 
int offset = 0
 
BOOLEAN p_static = FALSE
 
int old_state = 0
 
lib_cmds last_cmd = LP_NONE
 
char libnamebuf [128]
 
char * text_buffer =NULL
 
long string_start
 
char * yylp_buffer_start
 
int yylplineno = 1
 
int lpverbose = 0
 
int check = 0
 
int texinfo_out = 0
 
int found_info =0
 
int found_cat =0
 
int found_version =0
 
int found_oldhelp = 0
 
int found_proc_in_proc = 0
 
const char * yylp_errlist []
 
int yylp_errno = 0
 
idhdl h0
 
idhdl h_top
 
libstackv library_stack
 
static unsigned long help_chksum
 
YY_DECL register yy_state_type yy_current_state
 
register char * yy_cp
 
register char * yy_bp
 
register int yy_act
 

Data Structure Documentation

struct yy_buffer_state

Definition at line 162 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

#define BEGIN   yy_start = 1 + 2 *

Definition at line 97 of file libparse.cc.

#define category   16

Definition at line 1256 of file libparse.cc.

#define comment   14

Definition at line 1252 of file libparse.cc.

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

Definition at line 1341 of file libparse.cc.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 122 of file libparse.cc.

#define EOB_ACT_END_OF_FILE   1

Definition at line 123 of file libparse.cc.

#define EOB_ACT_LAST_MATCH   2

Definition at line 124 of file libparse.cc.

#define FLEX_SCANNER

Definition at line 25 of file libparse.cc.

#define header   1

Definition at line 1226 of file libparse.cc.

#define help   2

Definition at line 1228 of file libparse.cc.

#define IncrCheckSum (   c)
Value:
do \
{ \
help_chksum &= 0xffff; \
} \
static unsigned long help_chksum
Definition: libparse.cc:1151
while(1)
Definition: libparse.cc:1442
#define ROTATE_RIGHT(c)
Definition: libparse.cc:1188

Definition at line 1189 of file libparse.cc.

#define info   15

Definition at line 1254 of file libparse.cc.

#define INITIAL   0

Definition at line 1049 of file libparse.cc.

#define libcmd   3

Definition at line 1230 of file libparse.cc.

#define libcmd2   4

Definition at line 1232 of file libparse.cc.

#define pbody   9

Definition at line 1242 of file libparse.cc.

#define pdef   5

Definition at line 1234 of file libparse.cc.

#define pestr   12

Definition at line 1248 of file libparse.cc.

#define pexample   11

Definition at line 1246 of file libparse.cc.

#define phead   6

Definition at line 1236 of file libparse.cc.

#define phelp   8

Definition at line 1240 of file libparse.cc.

#define pi   IDPROC(h0)

Definition at line 1143 of file libparse.cc.

#define poldhelp   7

Definition at line 1238 of file libparse.cc.

#define pstr   10

Definition at line 1244 of file libparse.cc.

#define REJECT   reject_used_but_not_detected

Definition at line 1041 of file libparse.cc.

#define ROTATE_RIGHT (   c)    if ((c) & 01) (c) = ((c) >>1) + 0x8000; else (c) >>= 1;

Definition at line 1188 of file libparse.cc.

#define SET_BODY_END (   mode,
  pi,
  p 
)
Value:
if ( mode == LOAD_LIB) \
{ \
pi->data.s.body_end = p-1; \
pi->data.s.proc_end = p-1; \
}
return P p
Definition: myNF.cc:203
#define pi
Definition: libparse.cc:1143

Definition at line 1167 of file libparse.cc.

#define SET_BODY_START (   mode,
  pi,
  l,
  p 
)
Value:
if ( mode == LOAD_LIB) \
{ \
pi->data.s.body_lineno = l; \
pi->data.s.body_start = p; \
}
return P p
Definition: myNF.cc:203
#define pi
Definition: libparse.cc:1143
int l
Definition: cfEzgcd.cc:94

Definition at line 1161 of file libparse.cc.

#define SET_DEF_END (   mode,
  pi,
  p 
)    if ( mode == LOAD_LIB) pi->data.s.def_end = p;

Definition at line 1153 of file libparse.cc.

#define SET_EXAMPLE_START (   mode,
  pi,
  l,
  p 
)
Value:
if ( mode == LOAD_LIB) \
{ \
pi->data.s.example_lineno = l; \
pi->data.s.example_start = p; \
}
return P p
Definition: myNF.cc:203
#define pi
Definition: libparse.cc:1143
int l
Definition: cfEzgcd.cc:94

Definition at line 1174 of file libparse.cc.

#define SET_HELP_END (   mode,
  pi,
  p 
)
Value:
if ( mode == LOAD_LIB) {pi->data.s.help_end = p; \
pi->data.s.help_chksum = help_chksum;}
static unsigned long help_chksum
Definition: libparse.cc:1151
return P p
Definition: myNF.cc:203
#define pi
Definition: libparse.cc:1143

Definition at line 1157 of file libparse.cc.

#define SET_HELP_START (   mode,
  pi,
  p 
)    if ( mode == LOAD_LIB) {pi->data.s.help_start = p; help_chksum = 0;}

Definition at line 1155 of file libparse.cc.

#define SET_PROC_END (   mode,
  pi,
  p 
)
Value:
if ( mode == LOAD_LIB) \
{ \
pi->data.s.proc_end = p-1; \
if(pi->data.s.body_end==0) \
pi->data.s.body_end = p-1; \
}
return P p
Definition: myNF.cc:203
if(yy_init)
Definition: libparse.cc:1418
#define pi
Definition: libparse.cc:1143

Definition at line 1180 of file libparse.cc.

#define string   13

Definition at line 1250 of file libparse.cc.

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

Definition at line 153 of file libparse.cc.

#define url   17

Definition at line 1258 of file libparse.cc.

#define version   18

Definition at line 1260 of file libparse.cc.

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 280 of file libparse.cc.

#define YY_BREAK   break;

Definition at line 1400 of file libparse.cc.

#define YY_BUF_SIZE   16384

Definition at line 115 of file libparse.cc.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 216 of file libparse.cc.

#define YY_BUFFER_NEW   0

Definition at line 204 of file libparse.cc.

#define YY_BUFFER_NORMAL   1

Definition at line 205 of file libparse.cc.

#define yy_create_buffer   yylp_create_buffer

Definition at line 1 of file libparse.cc.

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 225 of file libparse.cc.

#define YY_DECL
Value:
int yylex(const char *newlib, const char *libfile, \
lib_style_types *lib_style, \
idhdl pl, BOOLEAN autoexport, lp_modes mode)
lp_modes
Definition: libparse.h:10
Definition: idrec.h:34
lib_style_types
Definition: libparse.h:9
int BOOLEAN
Definition: auxiliary.h:131
#define yylex
Definition: libparse.cc:13

Definition at line 1199 of file libparse.cc.

#define yy_delete_buffer   yylp_delete_buffer

Definition at line 2 of file libparse.cc.

#define YY_DO_BEFORE_ACTION
Value:
yyleng = (int) (yy_cp - yytext_ptr); \
*yy_cp = '\0'; \
#define yytext_ptr
Definition: libparse.cc:286
#define yyleng
Definition: libparse.cc:12
static char yy_hold_char
Definition: libparse.cc:229
register char * yy_cp
Definition: libparse.cc:1412
register char * yy_bp
Definition: libparse.cc:1412
static char * yy_c_buf_p
Definition: libparse.cc:237
static int yy_more_len
Definition: libparse.cc:1043

Definition at line 296 of file libparse.cc.

#define YY_END_OF_BUFFER   97

Definition at line 305 of file libparse.cc.

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 112 of file libparse.cc.

#define YY_EXIT_FAILURE   2

Definition at line 3232 of file libparse.cc.

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 1381 of file libparse.cc.

#define yy_flex_debug   yylp_flex_debug

Definition at line 6 of file libparse.cc.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 26 of file libparse.cc.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 27 of file libparse.cc.

#define yy_flush_buffer   yylp_flush_buffer

Definition at line 8 of file libparse.cc.

#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )

Definition at line 254 of file libparse.cc.

#define yy_init_buffer   yylp_init_buffer

Definition at line 7 of file libparse.cc.

#define YY_INPUT (   buf,
  result,
  max_size 
)
Value:
if ( ((result = libread( (yyin), (char *) buf, max_size )) < 0 ) \
&& ferror( yyin ) ) \
YY_FATAL_ERROR( "read in flex scanner failed" );
#define yyin
Definition: libparse.cc:11
int libread(FILE *f, char *buf, int max_size)
Definition: libparse.cc:3352
int status int void * buf
Definition: si_signals.h:59
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
return result
Definition: facAbsBiFact.cc:76

Definition at line 1203 of file libparse.cc.

#define yy_load_buffer_state   yylp_load_buffer_state

Definition at line 9 of file libparse.cc.

#define YY_MORE_ADJ   yy_more_len

Definition at line 1045 of file libparse.cc.

#define yy_new_buffer   yy_create_buffer

Definition at line 264 of file libparse.cc.

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 110 of file libparse.cc.

#define YY_NO_POP_STATE   1

Definition at line 1311 of file libparse.cc.

#define YY_NO_PUSH_STATE   1

Definition at line 1310 of file libparse.cc.

#define YY_NO_TOP_STATE   1

Definition at line 1312 of file libparse.cc.

#define YY_NULL   0

Definition at line 84 of file libparse.cc.

#define YY_NUM_RULES   96

Definition at line 304 of file libparse.cc.

#define YY_PROTO (   proto)    proto

Definition at line 78 of file libparse.cc.

#define YY_READ_BUF_SIZE   8192

Definition at line 1332 of file libparse.cc.

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 1046 of file libparse.cc.

#define YY_RULE_SETUP
Value:
if ( yyleng > 0 ) \
yy_current_buffer->yy_at_bol = \
(yytext[yyleng - 1] == '\n'); \
#define yyleng
Definition: libparse.cc:12
#define yytext
Definition: libparse.cc:16
#define YY_USER_ACTION
Definition: libparse.cc:1395
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219

Definition at line 1403 of file libparse.cc.

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

Definition at line 91 of file libparse.cc.

#define yy_scan_buffer   yylp_scan_buffer

Definition at line 3 of file libparse.cc.

#define yy_scan_bytes   yylp_scan_bytes

Definition at line 5 of file libparse.cc.

#define yy_scan_string   yylp_scan_string

Definition at line 4 of file libparse.cc.

#define yy_set_bol (   at_bol)
Value:
{ \
yy_current_buffer->yy_at_bol = at_bol; \
}
#define yy_create_buffer
Definition: libparse.cc:1
#define yyin
Definition: libparse.cc:11
if(yy_init)
Definition: libparse.cc:1418
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define YY_BUF_SIZE
Definition: libparse.cc:115

Definition at line 273 of file libparse.cc.

#define yy_set_interactive (   is_interactive)
Value:
{ \
yy_current_buffer->yy_is_interactive = is_interactive; \
}
#define yy_create_buffer
Definition: libparse.cc:1
#define yyin
Definition: libparse.cc:11
if(yy_init)
Definition: libparse.cc:1418
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define YY_BUF_SIZE
Definition: libparse.cc:115

Definition at line 266 of file libparse.cc.

#define YY_SKIP_YYWRAP

Definition at line 1077 of file libparse.cc.

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

Definition at line 103 of file libparse.cc.

#define YY_START_STACK_INCR   25

Definition at line 1376 of file libparse.cc.

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

Definition at line 107 of file libparse.cc.

#define yy_switch_to_buffer   yylp_switch_to_buffer

Definition at line 10 of file libparse.cc.

#define YY_USE_CONST

Definition at line 49 of file libparse.cc.

#define YY_USE_PROTOS

Definition at line 46 of file libparse.cc.

#define YY_USER_ACTION

Definition at line 1395 of file libparse.cc.

#define YY_USER_INIT
Value:
{ \
*lib_style = OLD_LIBSTYLE; \
strcpy(libnamebuf,"(**unknown version**)"); \
}
#define BEGIN
Definition: libparse.cc:97
#define header
Definition: libparse.cc:1226
int yylplineno
Definition: libparse.cc:1102
char libnamebuf[128]
Definition: libparse.cc:1096
int yylp_errno
Definition: libparse.cc:1128

Definition at line 1208 of file libparse.cc.

#define yyconst   const

Definition at line 71 of file libparse.cc.

FILE * yyin   yylpin

Definition at line 11 of file libparse.cc.

int yyleng   yylpleng

Definition at line 12 of file libparse.cc.

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up yytext. */ \
YY_DO_BEFORE_ACTION; /* set up yytext again */ \
} \
while ( 0 )
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static char yy_hold_char
Definition: libparse.cc:229
register char * yy_cp
Definition: libparse.cc:1412
while(1)
Definition: libparse.cc:1442
#define YY_DO_BEFORE_ACTION
Definition: libparse.cc:296
register char * yy_bp
Definition: libparse.cc:1412
static char * yy_c_buf_p
Definition: libparse.cc:237
#define YY_MORE_ADJ
Definition: libparse.cc:1045

Definition at line 3251 of file libparse.cc.

#define yyless (   n)
Value:
do \
{ \
/* Undo effects of setting up yytext. */ \
*yy_c_buf_p = '\0'; \
yyleng = n; \
} \
while ( 0 )
#define yyleng
Definition: libparse.cc:12
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
static char yy_hold_char
Definition: libparse.cc:229
#define yytext
Definition: libparse.cc:16
while(1)
Definition: libparse.cc:1442
static char * yy_c_buf_p
Definition: libparse.cc:237

Definition at line 3251 of file libparse.cc.

#define yylex   yylplex

Definition at line 13 of file libparse.cc.

#define yymore ( )    (yy_more_flag = 1)

Definition at line 1044 of file libparse.cc.

FILE * yyout   yylpout

Definition at line 14 of file libparse.cc.

#define yyrestart   yylprestart

Definition at line 15 of file libparse.cc.

#define YYSTATE   YY_START

Definition at line 104 of file libparse.cc.

#define yyterminate ( )    return YY_NULL

Definition at line 1371 of file libparse.cc.

char * yytext   yylptext

Definition at line 16 of file libparse.cc.

#define yytext_ptr   yytext

Definition at line 286 of file libparse.cc.

#define yywrap   yylpwrap

Definition at line 17 of file libparse.cc.

Typedef Documentation

typedef unsigned char YY_CHAR

Definition at line 282 of file libparse.cc.

typedef unsigned int yy_size_t

Definition at line 159 of file libparse.cc.

typedef int yy_state_type

Definition at line 284 of file libparse.cc.

Enumeration Type Documentation

enum lib_cmds
Enumerator
LP_NONE 
LP_INFO 
LP_CATEGORY 
LP_URL 
LP_VERSION 

Definition at line 1079 of file libparse.cc.

Function Documentation

void copy_string ( lp_modes  mode)

Definition at line 3407 of file libparse.cc.

3408 {
3409 #ifdef STANDALONE_PARSER
3410  if ((texinfo_out
3411  && (last_cmd == LP_INFO || last_cmd == LP_CATEGORY || last_cmd == LP_URL))
3412  || (category_out && last_cmd == LP_CATEGORY)
3413 )
3414  {
3415  long current_location = ftell(yylpin), i = string_start, quote = 0;
3416  char c;
3417  if (texinfo_out)
3418  {
3419  if (last_cmd == LP_INFO)
3420  {
3421  printf("$info = <<EOT;\n");
3422  }
3423  else if (last_cmd == LP_URL)
3424  {
3425  printf("$url = <<EOT;\n");
3426  }
3427  else
3428  {
3429  printf("$category = <<EOT;\n");
3430  }
3431  }
3432  fseek (yylpin, i, SEEK_SET);
3433  while (i< current_location)
3434  {
3435  c = fgetc(yylpin);
3436  if (c == '\\')
3437  {
3438  quote = (! quote);
3439  }
3440  else if (c == '"')
3441  {
3442  if (! quote) break;
3443  }
3444  else
3445  quote = 0;
3446  if (c == '@' || c == '$') putchar('\\');
3447  if (c != '\r') putchar(c);
3448  i++;
3449  }
3450  if (category_out) exit(0);
3451  fseek (yylpin, current_location, SEEK_SET);
3452  printf("\nEOT\n");
3453  }
3454 #else
3455  if((last_cmd == LP_INFO)&&(mode == GET_INFO))
3456  {
3457  int i, offset=0;
3458  long current_location = ftell(yylpin);
3459  int len = (int)(current_pos(0) - string_start);
3460  fseek(yylpin, string_start, SEEK_SET);
3462  text_buffer = (char *)omAlloc(len+2);
3464  myfread(text_buffer, len, 1, yylpin);
3465  fseek(yylpin, current_location, SEEK_SET);
3466  text_buffer[len]='\0';
3467  offset=0;
3468  for(i=0;i<=len; i++)
3469  {
3470  if(text_buffer[i]=='\\' &&
3471  (text_buffer[i+1]=='\"' || text_buffer[i+1]=='{' ||
3472  text_buffer[i+1]=='}' || text_buffer[i+1]=='\\'))
3473  {
3474  i++;
3475  offset++;
3476  }
3477  if(offset>0) text_buffer[i-offset] = text_buffer[i];
3478  }
3479  }
3480 #endif /* STANDALONE_PARSER */
3481 }
lib_cmds last_cmd
Definition: libparse.cc:1094
long string_start
Definition: libparse.cc:1098
int quote
Definition: libparse.cc:1090
void * ADDRESS
Definition: auxiliary.h:161
#define omAlloc(size)
Definition: omAllocDecl.h:210
int current_pos(int i)
Definition: libparse.cc:3347
#define omFree(addr)
Definition: omAllocDecl.h:261
size_t myfread(void *ptr, size_t size, size_t nmemb, FILE *stream)
Definition: feFopen.cc:194
int i
Definition: cfEzgcd.cc:123
int texinfo_out
Definition: libparse.cc:1105
#define NULL
Definition: omList.c:10
char * text_buffer
Definition: libparse.cc:1097
void omMarkAsStaticAddr(void *addr)
#define SEEK_SET
Definition: mod2.h:125
int offset
Definition: libparse.cc:1091
int current_pos ( int  i)

Definition at line 3347 of file libparse.cc.

3348 {
3349  return(i+offset+(int)(yytext-yylp_buffer_start));
3350 }
#define yytext
Definition: libparse.cc:16
int i
Definition: cfEzgcd.cc:123
char * yylp_buffer_start
Definition: libparse.cc:1100
int offset
Definition: libparse.cc:1091
if ( yy_init  )

Definition at line 1418 of file libparse.cc.

1419  {
1420  yy_init = 0;
1421 
1422 #ifdef YY_USER_INIT
1423  YY_USER_INIT;
1424 #endif
1425 
1426  if ( ! yy_start )
1427  yy_start = 1; /* first start state */
1428 
1429  if ( ! yyin )
1430  yyin = stdin;
1431 
1432  if ( ! yyout )
1433  yyout = stdout;
1434 
1435  if ( ! yy_current_buffer )
1438 
1440  }
#define yy_load_buffer_state
Definition: libparse.cc:9
#define yy_create_buffer
Definition: libparse.cc:1
#define yyin
Definition: libparse.cc:11
static int yy_start
Definition: libparse.cc:239
#define yyout
Definition: libparse.cc:14
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define YY_BUF_SIZE
Definition: libparse.cc:115
static int yy_init
Definition: libparse.cc:238
#define YY_USER_INIT
Definition: libparse.cc:1208
int libread ( FILE *  f,
char *  buf,
int  max_size 
)

Definition at line 3352 of file libparse.cc.

3353 { int rc;
3354 
3355  offset = ftell(f);
3356  rc = myfread( buf, 1, max_size, f );
3357  #if YYLPDEBUG >2
3358  printf("fread: %d of %d\n", rc, max_size);
3359  #endif
3361  return rc;
3362 }
size_t myfread(void *ptr, size_t size, size_t nmemb, FILE *stream)
Definition: feFopen.cc:194
int status int void * buf
Definition: si_signals.h:59
FILE * f
Definition: checklibs.c:7
char * yylp_buffer_start
Definition: libparse.cc:1100
int offset
Definition: libparse.cc:1091
void make_version ( char *  p,
int  what 
)

Definition at line 3387 of file libparse.cc.

3388 {
3389  char ver[10];
3390  char date[16];
3391  ver[0]='?'; ver[1]='.'; ver[2]='?'; ver[3]='\0';
3392  date[0]='?'; date[1]='\0';
3393  if(what) sscanf(p,"%*[^=]= %*s %*s %10s %16s",ver,date);
3394  else sscanf(p,"// %*s %*s %10s %16s",ver,date);
3395  strcpy(libnamebuf,"(");
3396  strcat(libnamebuf,ver);
3397  strcat(libnamebuf,",");
3398  strcat(libnamebuf,date);
3399  strcat(libnamebuf,")");
3400  if(what && strcmp(libnamebuf, "(?.?,?)")==0)
3401  {
3402  sscanf(p,"%*[^\"]\"%[^\"]\"",libnamebuf);
3403  }
3404  //printf("ID=(%d)%s; \n", what, p);
3405 }
return P p
Definition: myNF.cc:203
char libnamebuf[128]
Definition: libparse.cc:1096
void print_init ( )

Definition at line 3483 of file libparse.cc.

3484 {
3485  printf("Init=%d\n", yy_init);
3486 }
static int yy_init
Definition: libparse.cc:238
void print_version ( lp_modes  mode,
char *  p 
)

Definition at line 3488 of file libparse.cc.

3489 {
3490 #ifdef STANDALONE_PARSER
3491  //printf("loading %s%s", p, libnamebuf);
3492 #else
3493  if ( mode == LOAD_LIB )
3494  {
3495  if (BVERBOSE(V_LOAD_LIB) && p!=NULL ) Print(" %s...", p);
3496  //Warn( "loading %s%s", p, libnamebuf);
3497  }
3498 #endif
3499 }
#define Print
Definition: emacs.cc:83
return P p
Definition: myNF.cc:203
#define V_LOAD_LIB
Definition: options.h:45
#define BVERBOSE(a)
Definition: options.h:33
#define NULL
Definition: omList.c:10
void reinit_yylp ( )

Definition at line 3377 of file libparse.cc.

3378 {
3379  brace1 = 0;
3380  brace2 = 0;
3381  brace3 = 0;
3382  quote = 0;
3383  yy_init=1;
3385 }
int brace1
Definition: libparse.cc:1087
int brace3
Definition: libparse.cc:1089
#define YY_CURRENT_BUFFER
Definition: libparse.cc:225
int quote
Definition: libparse.cc:1090
static int yy_init
Definition: libparse.cc:238
#define yy_delete_buffer
Definition: libparse.cc:2
int brace2
Definition: libparse.cc:1088
while ( )

Definition at line 1442 of file libparse.cc.

1443  {
1444  yy_more_len = 0;
1445  if ( yy_more_flag )
1446  {
1448  yy_more_flag = 0;
1449  }
1450  yy_cp = yy_c_buf_p;
1451 
1452  /* Support of yytext. */
1453  *yy_cp = yy_hold_char;
1454 
1455  /* yy_bp points to the position in yy_ch_buf of the start of
1456  * the current run.
1457  */
1458  yy_bp = yy_cp;
1459 
1462 yy_match:
1463  do
1464  {
1465  register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1466  if ( yy_accept[yy_current_state] )
1467  {
1470  }
1471  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1472  {
1473  yy_current_state = (int) yy_def[yy_current_state];
1474  if ( yy_current_state >= 485 )
1475  yy_c = yy_meta[(unsigned int) yy_c];
1476  }
1477  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1478  ++yy_cp;
1479  }
1480  while ( yy_base[yy_current_state] != 2200 );
1481 
1482 yy_find_action:
1484  if ( yy_act == 0 )
1485  { /* have to back up */
1487  yy_current_state = yy_last_accepting_state;
1489  }
1490 
1492 
1493 
1494 do_action: /* This label is used only to access EOF actions. */
1495 
1496 
1497  switch ( yy_act )
1498  { /* beginning of action switch */
1499  case 0: /* must back up */
1500  /* undo the effects of YY_DO_BEFORE_ACTION */
1501  *yy_cp = yy_hold_char;
1503  yy_current_state = yy_last_accepting_state;
1504  goto yy_find_action;
1505 
1506 case 1:
1508 #line 230 "libparse.l"
1509 { }
1510  YY_BREAK
1511 case 2:
1513 #line 231 "libparse.l"
1514 { old_state = YYSTATE; BEGIN(comment); }
1515  YY_BREAK
1516 case 3:
1518 #line 233 "libparse.l"
1519 {
1520  yyless(4); old_state = YYSTATE; BEGIN(info);
1521  }
1522  YY_BREAK
1523 case 4:
1525 #line 236 "libparse.l"
1526 {
1528  }
1529  YY_BREAK
1530 case 5:
1532 #line 239 "libparse.l"
1533 {
1534  if ( mode != GET_INFO )
1535  {
1536  #ifdef STANDALONE_PARSER
1537  if (texinfo_out)
1538  {
1539  char *c = yytext;
1540  printf("$url = \"");
1541  while ((*c != '\0') && (*c != '"')) c++;
1542  c++;
1543  while ((*c != '\0') && (*c != '"'))
1544  {
1545  if (*c != '\r') putchar(*c);
1546  c++;
1547  }
1548  printf("\";\n");
1549  }
1550  #endif
1551  }
1552  }
1553  YY_BREAK
1554 case 6:
1556 #line 260 "libparse.l"
1557 {
1558  found_version++;
1559  if ( mode != GET_INFO )
1560  {
1561  make_version(yytext,1);
1562  #ifdef STANDALONE_PARSER
1563  if (texinfo_out)
1564  {
1565  char *c = libnamebuf;
1566  printf("$version = \"");
1567  while (*c != '\0')
1568  {
1569  if (*c == '$' || *c == '@') putchar('\\');
1570  if (*c != '\r') putchar(*c);
1571  if (*c == '\\')
1572  {
1573  c++;
1574  if (*c != '"') putchar('\\');
1575  }
1576  else
1577  c++;
1578  }
1579  printf("\";\n");
1580  }
1581  else if (!category_out)
1582  printf("Version:%s;\n", libnamebuf);
1583  #else
1587  #endif
1588  }
1589  }
1590  YY_BREAK
1591 case 7:
1593 #line 294 "libparse.l"
1594 { p_static=TRUE; }
1595  YY_BREAK
1596 case 8:
1598 #line 296 "libparse.l"
1599 {
1600  char proc[256];
1601  BEGIN(pdef);
1602  found_proc_in_proc = 0;
1603  proc[0]='\0';
1604  sscanf( yytext, "%*[^p]proc %s", proc);
1605  if(strlen(proc)<1) sscanf( yytext, "proc %s", proc);
1606  #if YYLPDEBUG > 1
1607  printf("Newlib:%s\n", newlib);
1608  #endif
1609  #ifdef STANDALONE_PARSER
1610  if ( pi != NULL )
1611  {
1612  printpi(pi);
1613  pi_clear(pi);
1614  }
1615  pi = (procinfo *)malloc(sizeof(procinfo));
1616  iiInitSingularProcinfo(pi, newlib, proc, yylplineno,
1617  current_pos(0), p_static);
1618  #else /*STANDALONE_PARSER*/
1619  if( mode == LOAD_LIB)
1620  {
1621  h0 = enterid( proc, 0 /*myynest*/, PROC_CMD,
1622  &(IDPACKAGE(pl)->idroot), TRUE, !p_static);
1623  if (h0==NULL) return(1);
1624  if((!p_static) && autoexport)
1625  {
1626  package save=currPack;
1628  h_top = enterid( proc, 0 /*myynest*/, PROC_CMD,
1629  &(basePack->idroot), FALSE );
1630  currPack=save;
1631  if (h_top==NULL) return(1);
1632  }
1633  /* omCheckAddr(IDID(h0)); */
1634  if (h0!=NULL)
1635  {
1636  iiInitSingularProcinfo(IDPROC(h0), newlib, proc,
1638  if ((!p_static) && (h_top != NULL) && autoexport)
1639  {
1641  IDPROC(h_top)=IDPROC(h0);
1642  IDPROC(h_top)->ref++;
1643  }
1644  IDPROC(h0)->pack=IDPACKAGE(pl);
1645  if (BVERBOSE(V_LOAD_PROC))
1646  Warn( " proc '%s' registered", proc );
1647  }
1648  #endif /*STANDALONE_PARSER*/
1649  SET_DEF_END(mode, pi, current_pos(yyleng+1));
1650  #if YYLPDEBUG
1651  if(lpverbose)
1652  {
1653  printf("// PROCEDURE '%s' status: %s, ", proc,
1654  p_static ? "local" : "global");
1655  printf("starting at line %d,%d: definition end: %d (%d).\n",
1656  yylplineno, current_pos(0), (int)pi->data.s.def_end, brace1);
1657  }
1658  #endif
1659  p_static=FALSE;
1660  #ifndef STANDALONE_PARSER
1661  }
1662  #endif /*STANDALONE_PARSER*/
1663  }
1664  YY_BREAK
1665 case 9:
1667 #line 361 "libparse.l"
1668 {
1669  BEGIN(pexample);
1671  #if YYLPDEBUG
1672  if(lpverbose)
1673  {
1674  printf("// EXAMPLE at line %d,%d (%d)\n", yylplineno,
1675  current_pos(0), brace1);
1676  }
1677  #endif
1678  }
1679  YY_BREAK
1680 case 10:
1682 #line 373 "libparse.l"
1683 { quote++;
1684  BEGIN(libcmd);
1685  }
1686  YY_BREAK
1687 case 11:
1689 #line 377 "libparse.l"
1690 { quote++; brace2++;
1691  BEGIN(libcmd2);
1692  }
1693  YY_BREAK
1694 case 12:
1696 #line 381 "libparse.l"
1697 {
1698  make_version(yytext, 0);
1699  #if YYLPDEBUG > 1
1700  printf("+(id)HEAD:%s\n", yytext);
1701  #endif
1702  }
1703  YY_BREAK
1704 case 13:
1706 #line 387 "libparse.l"
1707 {
1708  #if YYLPDEBUG
1709  printf("+(cmt)HEAD:%s\n", yytext);
1710  #endif
1711  }
1712  YY_BREAK
1713 case 14:
1715 #line 392 "libparse.l"
1716 {
1717  #if YYLPDEBUG > 1
1718  printf("-HEAD:%s\n", yytext);
1719  #endif
1720  }
1721  YY_BREAK
1722 case 15:
1724 #line 397 "libparse.l"
1725 { yyless(0);
1726  BEGIN(INITIAL);
1727  yymore();
1728  }
1729  YY_BREAK
1730 case 16:
1732 #line 401 "libparse.l"
1733 {
1734  yyless(0);
1735  *lib_style = NEW_LIBSTYLE;
1736  BEGIN(INITIAL);
1737  yymore();
1738  }
1739  YY_BREAK
1740 case 17:
1742 #line 408 "libparse.l"
1743 { quote++;
1744  BEGIN(libcmd);
1745  }
1746  YY_BREAK
1747 case 18:
1749 #line 411 "libparse.l"
1750 { quote++; brace2++;
1751  BEGIN(libcmd2);
1752  }
1753  YY_BREAK
1754 case 19:
1756 #line 414 "libparse.l"
1757 { yylplineno++; }
1758  YY_BREAK
1759 case 20:
1761 #line 415 "libparse.l"
1762 {
1763  #if YYLPDEBUG > 1
1764  printf(" HEAD:%s\n", yytext);
1765  #endif
1766  yyless(0);
1767  BEGIN(help);
1768  }
1769  YY_BREAK
1770 case 21:
1772 #line 422 "libparse.l"
1773 {
1774  #if YYLPDEBUG > 1
1775  printf(" HELP:%s\n", yytext);
1776  #endif
1777  BEGIN(INITIAL); }
1778  YY_BREAK
1779 case 22:
1781 #line 427 "libparse.l"
1782 {
1783  #if YYLPDEBUG > 1
1784  printf(" HELP:%s\n", yytext);
1785  #endif
1786  BEGIN(INITIAL);
1787  }
1788  YY_BREAK
1789 case 23:
1791 #line 433 "libparse.l"
1792 {
1793  yyless(0);
1794  *lib_style = NEW_LIBSTYLE;
1795  BEGIN(INITIAL);
1796  yymore();
1797  }
1798  YY_BREAK
1799 case 24:
1801 #line 439 "libparse.l"
1802 {
1803  yyless(0);
1804  //printf("2) proc found.\n");
1805  BEGIN(INITIAL);
1806  yymore();
1807  }
1808  YY_BREAK
1809 case 25:
1811 #line 445 "libparse.l"
1812 { quote++;
1813  BEGIN(libcmd);
1814  }
1815  YY_BREAK
1816 case 26:
1818 #line 448 "libparse.l"
1819 { quote++; brace2++;
1820  BEGIN(libcmd2);
1821  }
1822  YY_BREAK
1823 case 27:
1825 #line 452 "libparse.l"
1826 { yylplineno++; }
1827  YY_BREAK
1828 case 28:
1830 #line 453 "libparse.l"
1831 {
1832  #if YYLPDEBUG
1833  if(lpverbose>2) printf("--->%s<---\n", yytext);
1834  #endif
1835  }
1836  YY_BREAK
1837 case 29:
1839 #line 458 "libparse.l"
1840 {
1841  found_oldhelp=1;
1842  #if YYLPDEBUG > 1
1843  printf("-HELP:%s\n", yytext);
1844  #endif
1845  }
1846  YY_BREAK
1847 case 30:
1849 #line 466 "libparse.l"
1850 { quote--;
1851  yytext[yyleng-1] = '\0';
1852  #ifndef STANDALONE_PARSER
1853  if ( mode == LOAD_LIB )
1854  {
1855  library_stack->push(newlib, yytext);
1856  }
1857  #endif /* STANDALONE_PARSER */
1858  #if YYLPDEBUG
1859  if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1860  #endif
1861  BEGIN(INITIAL);
1862  }
1863  YY_BREAK
1864 case 31:
1866 #line 479 "libparse.l"
1867 { quote--; brace2--;
1868  yytext[yyleng-1] = '\0';
1869  #ifndef STANDALONE_PARSER
1870  if ( mode == LOAD_LIB )
1871  {
1872  library_stack->push(newlib, yytext);
1873  }
1874  #endif /* STANDALONE_PARSER */
1875  #if YYLPDEBUG
1876  if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1877  #endif
1878  BEGIN(INITIAL);
1879  }
1880  YY_BREAK
1881 case 32:
1883 #line 493 "libparse.l"
1884 { }
1885  YY_BREAK
1886 case 33:
1888 #line 494 "libparse.l"
1889 {
1890  brace2++;
1891  #if YYLPDEBUG > 1
1892  printf("%s", yytext);
1893  #endif
1894  }
1895  YY_BREAK
1896 case 34:
1898 #line 500 "libparse.l"
1899 {
1900  brace2--;
1901  #if YYLPDEBUG > 1
1902  printf(">%s<\n", yytext);
1903  printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1904  #endif
1905  if(brace2<=0)
1906  {
1907  #if YYLPDEBUG > 1
1908  printf("BEGIN(phead){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1909  #endif
1910  SET_DEF_END(mode, pi, current_pos(yyleng));
1911  BEGIN(phead);
1912  }
1913  }
1914  YY_BREAK
1915 case 35:
1917 #line 515 "libparse.l"
1918 {
1919  if(brace2>0)
1920  {
1921  #if YYLPDEBUG > 1
1922  printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1923  #endif
1925  return(1);
1926  }
1927  else
1928  {
1929  brace1++; BEGIN(pbody);
1930  if(lpverbose)
1931  printf("// BODY at line %d,%d (%d)\n", yylplineno,
1932  current_pos(0), brace1);
1934  }
1935  }
1936  YY_BREAK
1937 case 36:
1939 #line 533 "libparse.l"
1940 { yylplineno++;
1941  if(brace2<=0)
1942  {
1943 #if YYLPDEBUG > 1
1944  printf("BEGIN(phead-2){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1945 #endif
1946  BEGIN(phead);
1947  }
1948  }
1949  YY_BREAK
1950 case 37:
1952 #line 542 "libparse.l"
1953 { }
1954  YY_BREAK
1955 case 38:
1957 #line 543 "libparse.l"
1958 { old_state = YYSTATE; BEGIN(comment); }
1959  YY_BREAK
1960 case 39:
1962 #line 544 "libparse.l"
1963 {
1964  if(brace2<=0)
1965  {
1966  BEGIN(phead);
1967  yyless(0);
1968  }
1969  }
1970  YY_BREAK
1971 case 40:
1973 #line 552 "libparse.l"
1974 {
1975  #if YYLPDEBUG
1976  if(lpverbose>2)printf("0-Len=%d;\n", yyleng);
1977  #endif
1978  if(check)
1979  {
1980  printf("Procedure %s (line %d) has OLD-STYLE-HELP!\n",
1981  pi->procname, pi->data.s.proc_lineno);
1982  }
1983  SET_HELP_START(mode, pi, current_pos(0));
1984  BEGIN(poldhelp);
1985  yyless(0);
1986  }
1987  YY_BREAK
1988 case 41:
1990 #line 565 "libparse.l"
1991 {
1992  #if YYLPDEBUG
1993  if(lpverbose>2)printf("1-Len=%d;\n", yyleng);
1994  #endif
1995  BEGIN(phelp);
1996  yyless(0);
1997  }
1998  YY_BREAK
1999 case 42:
2001 #line 572 "libparse.l"
2002 {
2003  if(check && yyleng>2)
2004  {
2005  printf("Procedure %s (line %d) has OLD-STYLE-HELP!\n",
2006  pi->procname, pi->data.s.proc_lineno);
2007  }
2008  #if YYLPDEBUG
2009  if(lpverbose>2 && yyleng>2)
2010  printf("2-Len=%d, %s;\n", yyleng, pi->procname);
2011  #endif
2012  SET_HELP_START(mode, pi, current_pos(0));
2013  BEGIN(poldhelp);
2014  yyless(0);
2015  }
2016  YY_BREAK
2017 case 43:
2019 #line 586 "libparse.l"
2020 { printf("[%s]", yytext); }
2021  YY_BREAK
2022 case 44:
2024 #line 588 "libparse.l"
2025 { }
2026  YY_BREAK
2027 case 45:
2029 #line 589 "libparse.l"
2030 {
2031  SET_HELP_END(mode, pi, current_pos(0));
2032  brace1++; BEGIN(pbody);
2033  if(lpverbose)
2034  {
2035  printf("// HELP from %d to %d\n",
2036  (int)pi->data.s.help_start, (int)pi->data.s.help_end);
2037  printf("// BODY at line %d,%d (%d)\n", yylplineno,
2038  current_pos(0), brace1);
2039  }
2040 #if YYLPDEBUG > 1
2041  printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2042 #endif
2044 #if YYLPDEBUG > 1
2045  printf("BODY at %d/%d", yylplineno, current_pos(0));
2046 #endif
2047  }
2048  YY_BREAK
2049 case 46:
2051 #line 607 "libparse.l"
2052 { yylplineno++; }
2053  YY_BREAK
2054 case 47:
2056 #line 608 "libparse.l"
2057 { }
2058  YY_BREAK
2059 case 48:
2061 #line 610 "libparse.l"
2062 {
2063  old_state = YYSTATE;
2064  BEGIN(string);
2065  SET_HELP_START(mode, pi, current_pos(1));
2066  }
2067  YY_BREAK
2068 case 49:
2070 #line 615 "libparse.l"
2071 {}
2072  YY_BREAK
2073 case 50:
2075 #line 616 "libparse.l"
2076 {
2077  brace1++; BEGIN(pbody);
2078  if(lpverbose)
2079  {
2080  printf("// HELP from %d to %d\n",
2081  (int)pi->data.s.help_start, (int)pi->data.s.help_end);
2082  printf("// BODY at line %d,%d (%d)\n", yylplineno,
2083  current_pos(0), brace1);
2084  }
2085  #if YYLPDEBUG > 1
2086  printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2087  #endif
2089  #if YYLPDEBUG > 1
2090  printf("BODY at %d/%d", yylplineno, current_pos(0));
2091  #endif
2092  }
2093  YY_BREAK
2094 case 51:
2096 #line 633 "libparse.l"
2097 { yylplineno++;}
2098  YY_BREAK
2099 case 52:
2101 #line 635 "libparse.l"
2102 { }
2103  YY_BREAK
2104 case 53:
2106 #line 636 "libparse.l"
2107 { quote++; old_state = YYSTATE;
2108  BEGIN(string); /* printf("%s", yytext); */
2109  }
2110  YY_BREAK
2111 case 54:
2113 #line 640 "libparse.l"
2114 {
2115  if(check) printf("*** found 2 proc whithin procedure '%s'.\n",
2116  pi->procname);
2117  yyless(yyleng-1);
2118  }
2119  YY_BREAK
2120 case 55:
2122 #line 645 "libparse.l"
2123 {
2124  if(check) printf("*** found 1 proc whithin procedure '%s'.\n",
2125  pi->procname);
2126  yyless(yyleng-1);
2127  }
2128  YY_BREAK
2129 case 56:
2131 #line 650 "libparse.l"
2132 {
2133  brace1++;
2134  #if YYLPDEBUG > 1
2135  printf("line: %d, (%d)%s\n", yylplineno, brace1, yytext);
2136  #endif
2137  }
2138  YY_BREAK
2139 case 57:
2141 #line 656 "libparse.l"
2142 {
2143  #if YYLPDEBUG > 1
2144  printf("line: %d, (%d)%s\n",
2146  #endif
2147  brace1--;
2148  if(brace2>0)
2149  {
2151  return(1);
2152  }
2153  if(brace3>0)
2154  {
2156  return(1);
2157  }
2158  if(brace1<=0)
2159  {
2160  SET_BODY_END(mode, pi, current_pos(yyleng));
2161  SET_PROC_END(mode, pi, current_pos(yyleng));
2162  #if YYLPDEBUG > 1
2163  printf("-%d\n", current_pos(0));
2164  #endif
2165  BEGIN(INITIAL);
2166  }
2167  }
2168  YY_BREAK
2169 case 58:
2171 #line 682 "libparse.l"
2172 {
2173  brace2++; /* printf("%s", yytext); */
2174  }
2175  YY_BREAK
2176 case 59:
2178 #line 685 "libparse.l"
2179 {
2180  brace2--; /* printf("%s", yytext); */
2181  if(brace2<0) {
2183  return(1);
2184  }
2185  }
2186  YY_BREAK
2187 case 60:
2189 #line 692 "libparse.l"
2190 {
2191  brace3++; /* printf("%s", yytext); */
2192  }
2193  YY_BREAK
2194 case 61:
2196 #line 695 "libparse.l"
2197 {
2198  brace3--; /* printf("%s", yytext); */
2199  if(brace3<0) {
2201  return(1);
2202  }
2203  }
2204  YY_BREAK
2205 case 62:
2207 #line 702 "libparse.l"
2208 { yylplineno++; }
2209  YY_BREAK
2210 case 63:
2212 #line 703 "libparse.l"
2213 { }
2214  YY_BREAK
2215 case 64:
2217 #line 705 "libparse.l"
2218 {
2219  quote++; BEGIN(string);
2220  found_info++;
2222  *lib_style = NEW_LIBSTYLE;
2223  last_cmd = LP_INFO;
2224  }
2225  YY_BREAK
2226 case 65:
2228 #line 712 "libparse.l"
2229 { yylplineno++; }
2230  YY_BREAK
2231 case 66:
2233 #line 713 "libparse.l"
2234 { }
2235  YY_BREAK
2236 case 67:
2238 #line 715 "libparse.l"
2239 {
2240  quote++; BEGIN(string);
2241  found_cat++;
2243  *lib_style = NEW_LIBSTYLE;
2245  }
2246  YY_BREAK
2247 case 68:
2249 #line 722 "libparse.l"
2250 { yylplineno++; }
2251  YY_BREAK
2252 case 69:
2254 #line 723 "libparse.l"
2255 { }
2256  YY_BREAK
2257 case 70:
2259 #line 726 "libparse.l"
2260 { quote--;
2261  copy_string(mode);
2262  last_cmd = LP_NONE;
2263  if(old_state==phelp)
2264  {
2265  SET_HELP_END(mode, pi, current_pos(0));
2266  }
2267  BEGIN(old_state); /* printf("%s", yytext); */
2268  }
2269  YY_BREAK
2270 case 71:
2272 #line 735 "libparse.l"
2273 { if (old_state == phelp) IncrCheckSum(*yytext);}
2274  YY_BREAK
2275 case 72:
2277 #line 736 "libparse.l"
2278 { yylplineno++; if (old_state == phelp) IncrCheckSum('\n');}
2279  YY_BREAK
2280 case 73:
2282 #line 737 "libparse.l"
2283 { if (old_state == phelp) IncrCheckSum(*yytext);}
2284  YY_BREAK
2285 case 74:
2287 #line 739 "libparse.l"
2288 { }
2289  YY_BREAK
2290 case 75:
2292 #line 740 "libparse.l"
2293 { quote++; old_state = YYSTATE;
2294  BEGIN(string); /* printf("%s", yytext); */
2295  }
2296  YY_BREAK
2297 case 76:
2299 #line 743 "libparse.l"
2300 {
2301  brace1++; /* printf("(%d)%s", brace1, yytext); */
2302  }
2303  YY_BREAK
2304 case 77:
2306 #line 746 "libparse.l"
2307 {
2308  brace1--; /* printf("(%d)%s", brace1, yytext); */
2309  if(brace1<=0) {
2310  if(brace2>0) { yylp_errno=YYLP_EX_BR2; return(1); }
2311  if(brace3>0) { yylp_errno=YYLP_EX_BR3; return(1); }
2312  BEGIN(INITIAL);
2313  SET_PROC_END(mode, pi, current_pos(yyleng));
2314  }
2315  }
2316  YY_BREAK
2317 case 78:
2319 #line 755 "libparse.l"
2320 {
2321  brace2++; /* printf("%s", yytext); */
2322  }
2323  YY_BREAK
2324 case 79:
2326 #line 758 "libparse.l"
2327 {
2328  brace2--; /* printf("%s", yytext); */
2329  }
2330  YY_BREAK
2331 case 80:
2333 #line 761 "libparse.l"
2334 {
2335  brace3++; /* printf("%s", yytext); */
2336  }
2337  YY_BREAK
2338 case 81:
2340 #line 764 "libparse.l"
2341 {
2342  brace3--; /* printf("%s", yytext); */
2343  }
2344  YY_BREAK
2345 case 82:
2347 #line 767 "libparse.l"
2348 { yylplineno++; }
2349  YY_BREAK
2350 case 83:
2352 #line 768 "libparse.l"
2353 { }
2354  YY_BREAK
2355 case 84:
2357 #line 770 "libparse.l"
2358 { quote--;
2359  BEGIN(pexample); /* printf("%s", yytext); */
2360  }
2361  YY_BREAK
2362 case 85:
2364 #line 773 "libparse.l"
2365 { }
2366  YY_BREAK
2367 case 86:
2369 #line 774 "libparse.l"
2370 { }
2371  YY_BREAK
2372 case 87:
2374 #line 775 "libparse.l"
2375 { yylplineno++; }
2376  YY_BREAK
2377 case 88:
2379 #line 776 "libparse.l"
2380 { }
2381  YY_BREAK
2382 case 89:
2384 #line 778 "libparse.l"
2385 { BEGIN(old_state); }
2386  YY_BREAK
2387 case 90:
2389 #line 779 "libparse.l"
2390 { yylplineno++; }
2391  YY_BREAK
2392 case 91:
2394 #line 780 "libparse.l"
2395 { }
2396  YY_BREAK
2397 case 92:
2399 #line 782 "libparse.l"
2400 { yylplineno++; }
2401  YY_BREAK
2402 case 93:
2404 #line 783 "libparse.l"
2405 { }
2406  YY_BREAK
2407 case 94:
2409 #line 784 "libparse.l"
2410 { p_static = FALSE;
2411  #if YYLPDEBUG > 1
2412  printf("%s", yytext);
2413  #endif
2414  }
2415  YY_BREAK
2416 case 95:
2418 #line 789 "libparse.l"
2419 { p_static = FALSE;
2421  #ifdef STANDALONE_PARSER
2422  printf("[%d]", *yytext);
2423  #else
2427  #endif
2428  #if YYLPDEBUG > 1
2429  printf("[%s]", yytext);
2430  #endif
2431  return(1);
2432  }
2433  YY_BREAK
2434 case 96:
2436 #line 804 "libparse.l"
2437 ECHO;
2438  YY_BREAK
2439 case YY_STATE_EOF(INITIAL):
2440 case YY_STATE_EOF(header):
2441 case YY_STATE_EOF(help):
2442 case YY_STATE_EOF(libcmd):
2443 case YY_STATE_EOF(libcmd2):
2444 case YY_STATE_EOF(pdef):
2445 case YY_STATE_EOF(phead):
2446 case YY_STATE_EOF(poldhelp):
2447 case YY_STATE_EOF(phelp):
2448 case YY_STATE_EOF(pbody):
2449 case YY_STATE_EOF(pstr):
2450 case YY_STATE_EOF(pexample):
2451 case YY_STATE_EOF(pestr):
2452 case YY_STATE_EOF(string):
2453 case YY_STATE_EOF(comment):
2454 case YY_STATE_EOF(info):
2455 case YY_STATE_EOF(category):
2456 case YY_STATE_EOF(url):
2457 case YY_STATE_EOF(version):
2458  yyterminate();
2459 
2460  case YY_END_OF_BUFFER:
2461  {
2462  /* Amount of text matched not including the EOB char. */
2463  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2464 
2465  /* Undo the effects of YY_DO_BEFORE_ACTION. */
2466  *yy_cp = yy_hold_char;
2468 
2469  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2470  {
2471  /* We're scanning a new file or input source. It's
2472  * possible that this happened because the user
2473  * just pointed yyin at a new source and called
2474  * yylex(). If so, then we have to assure
2475  * consistency between yy_current_buffer and our
2476  * globals. Here is the right place to do so, because
2477  * this is the first action (other than possibly a
2478  * back-up) that will match for the new input source.
2479  */
2480  yy_n_chars = yy_current_buffer->yy_n_chars;
2481  yy_current_buffer->yy_input_file = yyin;
2482  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2483  }
2484 
2485  /* Note that here we test for yy_c_buf_p "<=" to the position
2486  * of the first EOB in the buffer, since yy_c_buf_p will
2487  * already have been incremented past the NUL character
2488  * (since all states make transitions on EOB to the
2489  * end-of-buffer state). Contrast this with the test
2490  * in input().
2491  */
2492  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2493  { /* This was really a NUL. */
2494  yy_state_type yy_next_state;
2495 
2496  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2497 
2498  yy_current_state = yy_get_previous_state();
2499 
2500  /* Okay, we're now positioned to make the NUL
2501  * transition. We couldn't have
2502  * yy_get_previous_state() go ahead and do it
2503  * for us because it doesn't know how to deal
2504  * with the possibility of jamming (and we don't
2505  * want to build jamming into it because then it
2506  * will run more slowly).
2507  */
2508 
2509  yy_next_state = yy_try_NUL_trans( yy_current_state );
2510 
2512 
2513  if ( yy_next_state )
2514  {
2515  /* Consume the NUL. */
2516  yy_cp = ++yy_c_buf_p;
2517  yy_current_state = yy_next_state;
2518  goto yy_match;
2519  }
2520 
2521  else
2522  {
2523  yy_cp = yy_c_buf_p;
2524  goto yy_find_action;
2525  }
2526  }
2527 
2528  else switch ( yy_get_next_buffer() )
2529  {
2530  case EOB_ACT_END_OF_FILE:
2531  {
2533 
2534  if ( yywrap() )
2535  {
2536  /* Note: because we've taken care in
2537  * yy_get_next_buffer() to have set up
2538  * yytext, we can now set up
2539  * yy_c_buf_p so that if some total
2540  * hoser (like flex itself) wants to
2541  * call the scanner after we return the
2542  * YY_NULL, it'll still work - another
2543  * YY_NULL will get returned.
2544  */
2546 
2548  goto do_action;
2549  }
2550 
2551  else
2552  {
2554  YY_NEW_FILE;
2555  }
2556  break;
2557  }
2558 
2559  case EOB_ACT_CONTINUE_SCAN:
2560  yy_c_buf_p =
2561  yytext_ptr + yy_amount_of_matched_text;
2562 
2563  yy_current_state = yy_get_previous_state();
2564 
2565  yy_cp = yy_c_buf_p;
2567  goto yy_match;
2568 
2569  case EOB_ACT_LAST_MATCH:
2570  yy_c_buf_p =
2571  &yy_current_buffer->yy_ch_buf[yy_n_chars];
2572 
2573  yy_current_state = yy_get_previous_state();
2574 
2575  yy_cp = yy_c_buf_p;
2577  goto yy_find_action;
2578  }
2579  break;
2580  }
2581 
2582  default:
2584  "fatal flex scanner internal error--no action found" );
2585  } /* end of action switch */
2586  } /* end of scanning one token */
unsigned char YY_CHAR
Definition: libparse.cc:282
static yyconst short int yy_def[533]
Definition: libparse.cc:468
#define yytext_ptr
Definition: libparse.cc:286
#define YY_BREAK
Definition: libparse.cc:1400
#define ECHO
Definition: libparse.cc:1341
#define yywrap
Definition: libparse.cc:17
#define pstr
Definition: libparse.cc:1244
unsigned char * proc[NUM_PROC]
Definition: checklibs.c:14
#define yyleng
Definition: libparse.cc:12
int found_oldhelp
Definition: libparse.cc:1109
lib_cmds last_cmd
Definition: libparse.cc:1094
libstackv library_stack
Definition: iplib.cc:74
#define pexample
Definition: libparse.cc:1246
#define SET_EXAMPLE_START(mode, pi, l, p)
Definition: libparse.cc:1174
void make_version(char *p, int what)
Definition: libparse.cc:3387
long string_start
Definition: libparse.cc:1098
int found_version
Definition: libparse.cc:1108
#define pestr
Definition: libparse.cc:1248
#define IncrCheckSum(c)
Definition: libparse.cc:1189
#define EOB_ACT_LAST_MATCH
Definition: libparse.cc:124
int brace1
Definition: libparse.cc:1087
int found_info
Definition: libparse.cc:1106
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int line, long pos, BOOLEAN pstatic)
Definition: iplib.cc:976
int check
Definition: libparse.cc:1104
#define YY_START
Definition: libparse.cc:103
#define FALSE
Definition: auxiliary.h:140
int brace3
Definition: libparse.cc:1089
register int yy_act
Definition: libparse.cc:1413
int quote
Definition: libparse.cc:1090
#define string
Definition: libparse.cc:1250
int found_cat
Definition: libparse.cc:1107
#define YY_AT_BOL()
Definition: libparse.cc:280
#define phead
Definition: libparse.cc:1236
#define YY_RESTORE_YY_MORE_OFFSET
Definition: libparse.cc:1046
#define TRUE
Definition: auxiliary.h:144
void * ADDRESS
Definition: auxiliary.h:161
static char yy_hold_char
Definition: libparse.cc:229
#define pdef
Definition: libparse.cc:1234
#define BEGIN
Definition: libparse.cc:97
#define yytext
Definition: libparse.cc:16
void push(const char *p, char *libname)
Definition: iplib.cc:1345
YY_DECL register yy_state_type yy_current_state
Definition: libparse.cc:1411
BOOLEAN piKill(procinfov pi)
Definition: ipid.cc:644
static int yy_get_next_buffer()
Definition: libparse.cc:2598
#define libcmd
Definition: libparse.cc:1230
#define SET_BODY_START(mode, pi, l, p)
Definition: libparse.cc:1161
#define yyless(n)
Definition: libparse.cc:3251
#define yyin
Definition: libparse.cc:11
static yyconst int yy_ec[256]
Definition: libparse.cc:363
#define YY_STATE_EOF(state)
Definition: libparse.cc:107
int current_pos(int i)
Definition: libparse.cc:3347
#define EOB_ACT_END_OF_FILE
Definition: libparse.cc:123
#define IDPACKAGE(a)
Definition: ipid.h:138
#define poldhelp
Definition: libparse.cc:1238
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:256
#define YYLP_BAD_CHAR
Definition: libparse.h:93
int lpverbose
Definition: libparse.cc:1104
#define YYLP_BODY_TMBR2
Definition: libparse.h:89
static yy_state_type yy_get_previous_state()
Definition: libparse.cc:2730
#define SET_DEF_END(mode, pi, p)
Definition: libparse.cc:1153
static yy_state_type yy_last_accepting_state
Definition: libparse.cc:1035
#define comment
Definition: libparse.cc:1252
register char * yy_cp
Definition: libparse.cc:1412
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition: libparse.cc:2766
static yyconst short int yy_base[533]
Definition: libparse.cc:405
#define omFree(addr)
Definition: omAllocDecl.h:261
static int yy_more_flag
Definition: libparse.cc:1042
static int yy_start
Definition: libparse.cc:239
#define YYLP_EX_BR3
Definition: libparse.h:92
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
#define YY_BUFFER_NORMAL
Definition: libparse.cc:205
static yyconst short int yy_accept[485]
Definition: libparse.cc:306
void * malloc(size_t size)
Definition: omalloc.c:92
#define YYLP_BODY_BR3
Definition: libparse.h:88
BOOLEAN p_static
Definition: libparse.cc:1092
#define category
Definition: libparse.cc:1256
static int yy_did_buffer_switch_on_eof
Definition: libparse.cc:244
#define YYLP_BODY_BR2
Definition: libparse.h:87
#define SET_BODY_END(mode, pi, p)
Definition: libparse.cc:1167
#define info
Definition: libparse.cc:1254
#define url
Definition: libparse.cc:1258
#define INITIAL
Definition: libparse.cc:1049
#define YY_DO_BEFORE_ACTION
Definition: libparse.cc:296
int found_proc_in_proc
Definition: libparse.cc:1110
#define version
Definition: libparse.cc:1260
#define EOB_ACT_CONTINUE_SCAN
Definition: libparse.cc:122
idhdl h_top
Definition: libparse.cc:1142
#define help
Definition: libparse.cc:1228
#define BVERBOSE(a)
Definition: options.h:33
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define V_LOAD_PROC
Definition: options.h:47
#define IDPROC(a)
Definition: ipid.h:139
#define header
Definition: libparse.cc:1226
int yylplineno
Definition: libparse.cc:1102
#define pi
Definition: libparse.cc:1143
#define YY_SC_TO_UI(c)
Definition: libparse.cc:91
register char * yy_bp
Definition: libparse.cc:1412
#define SET_HELP_END(mode, pi, p)
Definition: libparse.cc:1157
#define SET_PROC_END(mode, pi, p)
Definition: libparse.cc:1180
int texinfo_out
Definition: libparse.cc:1105
#define NULL
Definition: omList.c:10
static yyconst int yy_meta[53]
Definition: libparse.cc:395
#define YYLP_DEF_BR2
Definition: libparse.h:86
char * text_buffer
Definition: libparse.cc:1097
package basePack
Definition: ipid.cc:63
static char * yy_c_buf_p
Definition: libparse.cc:237
package currPack
Definition: ipid.cc:62
int yy_state_type
Definition: libparse.cc:284
#define YY_END_OF_BUFFER
Definition: libparse.cc:305
#define YYLP_BODY_TMBR3
Definition: libparse.h:90
static int yy_more_len
Definition: libparse.cc:1043
#define pbody
Definition: libparse.cc:1242
#define YY_MORE_ADJ
Definition: libparse.cc:1045
#define yymore()
Definition: libparse.cc:1044
static int yy_n_chars
Definition: libparse.cc:231
static char * yy_last_accepting_cpos
Definition: libparse.cc:1036
#define YYLP_EX_BR2
Definition: libparse.h:91
#define phelp
Definition: libparse.cc:1240
char libnamebuf[128]
Definition: libparse.cc:1096
#define SET_HELP_START(mode, pi, p)
Definition: libparse.cc:1155
void omMarkAsStaticAddr(void *addr)
static yyconst short int yy_chk[2253]
Definition: libparse.cc:783
#define YY_RULE_SETUP
Definition: libparse.cc:1403
#define YY_NEW_FILE
Definition: libparse.cc:110
int old_state
Definition: libparse.cc:1093
#define YYSTATE
Definition: libparse.cc:104
void copy_string(lp_modes mode)
Definition: libparse.cc:3407
#define YY_BUFFER_NEW
Definition: libparse.cc:204
idhdl h0
Definition: libparse.cc:1141
int yylp_errno
Definition: libparse.cc:1128
int brace2
Definition: libparse.cc:1088
#define libcmd2
Definition: libparse.cc:1232
#define yyterminate()
Definition: libparse.cc:1371
static yyconst short int yy_nxt[2253]
Definition: libparse.cc:531
#define Warn
Definition: emacs.cc:80
#define omStrDup(s)
Definition: omAllocDecl.h:263
YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 2972 of file libparse.cc.

2978  {
2979  YY_BUFFER_STATE b;
2980 
2981  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2982  if ( ! b )
2983  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2984 
2985  b->yy_buf_size = size;
2986 
2987  /* yy_ch_buf has to be 2 characters longer than the size given because
2988  * we need to put in 2 end-of-buffer characters.
2989  */
2990  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2991  if ( ! b->yy_ch_buf )
2992  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2993 
2994  b->yy_is_our_buffer = 1;
2995 
2996  yy_init_buffer( b, file );
2997 
2998  return b;
2999  }
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
static void * yy_flex_alloc(yy_size_t size)
Definition: libparse.cc:3300
const poly b
Definition: syzextra.cc:213
#define yy_init_buffer
Definition: libparse.cc:7
void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 3003 of file libparse.cc.

3008  {
3009  if ( ! b )
3010  return;
3011 
3012  if ( b == yy_current_buffer )
3013  yy_current_buffer = (YY_BUFFER_STATE) 0;
3014 
3015  if ( b->yy_is_our_buffer )
3016  yy_flex_free( (void *) b->yy_ch_buf );
3017 
3018  yy_flex_free( (void *) b );
3019  }
static void yy_flex_free(void *ptr)
Definition: libparse.cc:3328
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
const poly b
Definition: syzextra.cc:213
static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 3236 of file libparse.cc.

3241  {
3242  (void) fprintf( stderr, "%s\n", msg );
3243  exit( YY_EXIT_FAILURE );
3244  }
#define YY_EXIT_FAILURE
Definition: libparse.cc:3232
static void* yy_flex_alloc ( yy_size_t  size)
static

Definition at line 3300 of file libparse.cc.

3305  {
3306  return (void *) malloc( size );
3307  }
void * malloc(size_t size)
Definition: omalloc.c:92
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
static void yy_flex_free ( void *  ptr)
static

Definition at line 3328 of file libparse.cc.

3333  {
3334  free( ptr );
3335  }
#define free
Definition: omAllocFunc.c:12
static void* yy_flex_realloc ( void *  ptr,
yy_size_t  size 
)
static

Definition at line 3310 of file libparse.cc.

3316  {
3317  /* The cast to (char *) in the following accommodates both
3318  * implementations that use char* generic pointers, and those
3319  * that use void* generic pointers. It works with the latter
3320  * because both ANSI C and C++ allow castless assignment from
3321  * any pointer type to void*, and deal with argument conversions
3322  * as though doing an assignment.
3323  */
3324  return (void *) realloc( (char *) ptr, size );
3325  }
#define realloc
Definition: omAllocFunc.c:14
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 3056 of file libparse.cc.

3062  {
3063  if ( ! b )
3064  return;
3065 
3066  b->yy_n_chars = 0;
3067 
3068  /* We always need two end-of-buffer characters. The first causes
3069  * a transition to the end-of-buffer state. The second causes
3070  * a jam in that state.
3071  */
3072  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3073  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3074 
3075  b->yy_buf_pos = &b->yy_ch_buf[0];
3076 
3077  b->yy_at_bol = 1;
3078  b->yy_buffer_status = YY_BUFFER_NEW;
3079 
3080  if ( b == yy_current_buffer )
3082  }
#define yy_load_buffer_state
Definition: libparse.cc:9
#define YY_END_OF_BUFFER_CHAR
Definition: libparse.cc:112
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
const poly b
Definition: syzextra.cc:213
#define YY_BUFFER_NEW
Definition: libparse.cc:204
static int yy_get_next_buffer ( )
static

Definition at line 2598 of file libparse.cc.

2599  {
2600  register char *dest = yy_current_buffer->yy_ch_buf;
2601  register char *source = yytext_ptr;
2602  register int number_to_move, i;
2603  int ret_val;
2604 
2605  if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2607  "fatal flex scanner internal error--end of buffer missed" );
2608 
2609  if ( yy_current_buffer->yy_fill_buffer == 0 )
2610  { /* Don't try to fill the buffer, so this is an EOF. */
2611  if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2612  {
2613  /* We matched a single character, the EOB, so
2614  * treat this as a final EOF.
2615  */
2616  return EOB_ACT_END_OF_FILE;
2617  }
2618 
2619  else
2620  {
2621  /* We matched some text prior to the EOB, first
2622  * process it.
2623  */
2624  return EOB_ACT_LAST_MATCH;
2625  }
2626  }
2627 
2628  /* Try to read more data. */
2629 
2630  /* First move last chars to start of buffer. */
2631  number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2632 
2633  for ( i = 0; i < number_to_move; ++i )
2634  *(dest++) = *(source++);
2635 
2636  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2637  /* don't do the read, it's not guaranteed to return an EOF,
2638  * just force an EOF
2639  */
2640  yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2641 
2642  else
2643  {
2644  int num_to_read =
2645  yy_current_buffer->yy_buf_size - number_to_move - 1;
2646 
2647  while ( num_to_read <= 0 )
2648  { /* Not enough room in the buffer - grow it. */
2649 #ifdef YY_USES_REJECT
2651 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2652 #else
2653 
2654  /* just a shorter name for the current buffer */
2655  YY_BUFFER_STATE b = yy_current_buffer;
2656 
2657  int yy_c_buf_p_offset =
2658  (int) (yy_c_buf_p - b->yy_ch_buf);
2659 
2660  if ( b->yy_is_our_buffer )
2661  {
2662  int new_size = b->yy_buf_size * 2;
2663 
2664  if ( new_size <= 0 )
2665  b->yy_buf_size += b->yy_buf_size / 8;
2666  else
2667  b->yy_buf_size *= 2;
2668 
2669  b->yy_ch_buf = (char *)
2670  /* Include room in for 2 EOB chars. */
2671  yy_flex_realloc( (void *) b->yy_ch_buf,
2672  b->yy_buf_size + 2 );
2673  }
2674  else
2675  /* Can't grow it, we don't own it. */
2676  b->yy_ch_buf = 0;
2677 
2678  if ( ! b->yy_ch_buf )
2680  "fatal error - scanner input buffer overflow" );
2681 
2682  yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2683 
2684  num_to_read = yy_current_buffer->yy_buf_size -
2685  number_to_move - 1;
2686 #endif
2687  }
2688 
2689  if ( num_to_read > YY_READ_BUF_SIZE )
2690  num_to_read = YY_READ_BUF_SIZE;
2691 
2692  /* Read in more data. */
2693  YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2694  yy_n_chars, num_to_read );
2695 
2696  yy_current_buffer->yy_n_chars = yy_n_chars;
2697  }
2698 
2699  if ( yy_n_chars == 0 )
2700  {
2701  if ( number_to_move == YY_MORE_ADJ )
2702  {
2703  ret_val = EOB_ACT_END_OF_FILE;
2704  yyrestart( yyin );
2705  }
2706 
2707  else
2708  {
2709  ret_val = EOB_ACT_LAST_MATCH;
2710  yy_current_buffer->yy_buffer_status =
2712  }
2713  }
2714 
2715  else
2716  ret_val = EOB_ACT_CONTINUE_SCAN;
2717 
2718  yy_n_chars += number_to_move;
2721 
2722  yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2723 
2724  return ret_val;
2725  }
#define yytext_ptr
Definition: libparse.cc:286
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: libparse.cc:3310
#define YY_READ_BUF_SIZE
Definition: libparse.cc:1332
#define YY_INPUT(buf, result, max_size)
Definition: libparse.cc:1203
#define EOB_ACT_LAST_MATCH
Definition: libparse.cc:124
#define YY_END_OF_BUFFER_CHAR
Definition: libparse.cc:112
#define yyin
Definition: libparse.cc:11
#define EOB_ACT_END_OF_FILE
Definition: libparse.cc:123
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
int i
Definition: cfEzgcd.cc:123
#define EOB_ACT_CONTINUE_SCAN
Definition: libparse.cc:122
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define yyrestart
Definition: libparse.cc:15
static char * yy_c_buf_p
Definition: libparse.cc:237
#define YY_MORE_ADJ
Definition: libparse.cc:1045
static int yy_n_chars
Definition: libparse.cc:231
#define YY_BUFFER_EOF_PENDING
Definition: libparse.cc:216
const poly b
Definition: syzextra.cc:213
static yy_state_type yy_get_previous_state ( )
static

Definition at line 2730 of file libparse.cc.

2731  {
2733  register char *yy_cp;
2734 
2735  yy_current_state = yy_start;
2736  yy_current_state += YY_AT_BOL();
2737 
2738  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2739  {
2740  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2741  if ( yy_accept[yy_current_state] )
2742  {
2745  }
2746  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2747  {
2748  yy_current_state = (int) yy_def[yy_current_state];
2749  if ( yy_current_state >= 485 )
2750  yy_c = yy_meta[(unsigned int) yy_c];
2751  }
2752  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2753  }
2754 
2755  return yy_current_state;
2756  }
unsigned char YY_CHAR
Definition: libparse.cc:282
static yyconst short int yy_def[533]
Definition: libparse.cc:468
#define yytext_ptr
Definition: libparse.cc:286
#define YY_AT_BOL()
Definition: libparse.cc:280
YY_DECL register yy_state_type yy_current_state
Definition: libparse.cc:1411
static yyconst int yy_ec[256]
Definition: libparse.cc:363
static yy_state_type yy_last_accepting_state
Definition: libparse.cc:1035
register char * yy_cp
Definition: libparse.cc:1412
static yyconst short int yy_base[533]
Definition: libparse.cc:405
static int yy_start
Definition: libparse.cc:239
static yyconst short int yy_accept[485]
Definition: libparse.cc:306
#define YY_SC_TO_UI(c)
Definition: libparse.cc:91
static yyconst int yy_meta[53]
Definition: libparse.cc:395
static char * yy_c_buf_p
Definition: libparse.cc:237
int yy_state_type
Definition: libparse.cc:284
#define YY_MORE_ADJ
Definition: libparse.cc:1045
static char * yy_last_accepting_cpos
Definition: libparse.cc:1036
static yyconst short int yy_chk[2253]
Definition: libparse.cc:783
static yyconst short int yy_nxt[2253]
Definition: libparse.cc:531
void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 3029 of file libparse.cc.

3037  {
3038  yy_flush_buffer( b );
3039 
3040  b->yy_input_file = file;
3041  b->yy_fill_buffer = 1;
3042 
3043 #if YY_ALWAYS_INTERACTIVE
3044  b->yy_is_interactive = 1;
3045 #else
3046 #if YY_NEVER_INTERACTIVE
3047  b->yy_is_interactive = 0;
3048 #else
3049  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3050 #endif
3051 #endif
3052  }
#define yy_flush_buffer
Definition: libparse.cc:8
const poly b
Definition: syzextra.cc:213
void yy_load_buffer_state ( void  )

Definition at line 2959 of file libparse.cc.

2963  {
2964  yy_n_chars = yy_current_buffer->yy_n_chars;
2965  yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2966  yyin = yy_current_buffer->yy_input_file;
2968  }
#define yytext_ptr
Definition: libparse.cc:286
static char yy_hold_char
Definition: libparse.cc:229
#define yyin
Definition: libparse.cc:11
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
static char * yy_c_buf_p
Definition: libparse.cc:237
static int yy_n_chars
Definition: libparse.cc:231
void yyrestart YY_PROTO ( (FILE *input_file)  )
void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer)  )
static int yyinput YY_PROTO ( (void)  )
YY_BUFFER_STATE yy_create_buffer YY_PROTO ( (FILE *file, int size )
void yy_flush_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
static void* yy_flex_realloc YY_PROTO ( (void *, yy_size_t )
static
static void yy_flex_free YY_PROTO ( (void *)  )
static
static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  )
static
static void yy_fatal_error YY_PROTO ( (yyconst char msg[])  )
static
static void yyunput YY_PROTO ( (int c, char *buf_ptr)  )
static
int isatty YY_PROTO ( (int)  )
YY_BUFFER_STATE yy_scan_buffer ( char *  base,
yy_size_t  size 
)

Definition at line 3087 of file libparse.cc.

3093  {
3094  YY_BUFFER_STATE b;
3095 
3096  if ( size < 2 ||
3099  /* They forgot to leave room for the EOB's. */
3100  return 0;
3101 
3102  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
3103  if ( ! b )
3104  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3105 
3106  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3107  b->yy_buf_pos = b->yy_ch_buf = base;
3108  b->yy_is_our_buffer = 0;
3109  b->yy_input_file = 0;
3110  b->yy_n_chars = b->yy_buf_size;
3111  b->yy_is_interactive = 0;
3112  b->yy_at_bol = 1;
3113  b->yy_fill_buffer = 0;
3114  b->yy_buffer_status = YY_BUFFER_NEW;
3115 
3116  yy_switch_to_buffer( b );
3117 
3118  return b;
3119  }
#define yy_switch_to_buffer
Definition: libparse.cc:10
#define YY_END_OF_BUFFER_CHAR
Definition: libparse.cc:112
char N base
Definition: ValueTraits.h:144
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
static void * yy_flex_alloc(yy_size_t size)
Definition: libparse.cc:3300
const poly b
Definition: syzextra.cc:213
#define YY_BUFFER_NEW
Definition: libparse.cc:204
YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 3142 of file libparse.cc.

3148  {
3149  YY_BUFFER_STATE b;
3150  char *buf;
3151  yy_size_t n;
3152  int i;
3153 
3154  /* Get memory for full buffer, including space for trailing EOB's. */
3155  n = len + 2;
3156  buf = (char *) yy_flex_alloc( n );
3157  if ( ! buf )
3158  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3159 
3160  for ( i = 0; i < len; ++i )
3161  buf[i] = bytes[i];
3162 
3163  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
3164 
3165  b = yy_scan_buffer( buf, n );
3166  if ( ! b )
3167  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3168 
3169  /* It's okay to grow etc. this buffer, and we should throw it
3170  * away when we're done.
3171  */
3172  b->yy_is_our_buffer = 1;
3173 
3174  return b;
3175  }
unsigned int yy_size_t
Definition: libparse.cc:159
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
#define YY_END_OF_BUFFER_CHAR
Definition: libparse.cc:112
int status int void * buf
Definition: si_signals.h:59
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
#define yy_scan_buffer
Definition: libparse.cc:3
int i
Definition: cfEzgcd.cc:123
static void * yy_flex_alloc(yy_size_t size)
Definition: libparse.cc:3300
const poly b
Definition: syzextra.cc:213
YY_BUFFER_STATE yy_scan_string ( yyconst char *  yy_str)

Definition at line 3125 of file libparse.cc.

3130  {
3131  int len;
3132  for ( len = 0; yy_str[len]; ++len )
3133  ;
3134 
3135  return yy_scan_bytes( yy_str, len );
3136  }
#define yy_scan_bytes
Definition: libparse.cc:5
void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 2929 of file libparse.cc.

2934  {
2935  if ( yy_current_buffer == new_buffer )
2936  return;
2937 
2938  if ( yy_current_buffer )
2939  {
2940  /* Flush out information for old buffer. */
2942  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2943  yy_current_buffer->yy_n_chars = yy_n_chars;
2944  }
2945 
2946  yy_current_buffer = new_buffer;
2948 
2949  /* We don't actually know whether we did this switch during
2950  * EOF (yywrap()) processing, but the only time this flag
2951  * is looked at is after yywrap() is called, so it's safe
2952  * to go ahead and always set it.
2953  */
2955  }
#define yy_load_buffer_state
Definition: libparse.cc:9
static char yy_hold_char
Definition: libparse.cc:229
static int yy_did_buffer_switch_on_eof
Definition: libparse.cc:244
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
static char * yy_c_buf_p
Definition: libparse.cc:237
static int yy_n_chars
Definition: libparse.cc:231
static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 2766 of file libparse.cc.

2771  {
2772  register int yy_is_jam;
2773  register char *yy_cp = yy_c_buf_p;
2774 
2775  register YY_CHAR yy_c = 1;
2776  if ( yy_accept[yy_current_state] )
2777  {
2780  }
2781  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2782  {
2783  yy_current_state = (int) yy_def[yy_current_state];
2784  if ( yy_current_state >= 485 )
2785  yy_c = yy_meta[(unsigned int) yy_c];
2786  }
2787  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2788  yy_is_jam = (yy_current_state == 484);
2789 
2790  return yy_is_jam ? 0 : yy_current_state;
2791  }
unsigned char YY_CHAR
Definition: libparse.cc:282
static yyconst short int yy_def[533]
Definition: libparse.cc:468
YY_DECL register yy_state_type yy_current_state
Definition: libparse.cc:1411
static yy_state_type yy_last_accepting_state
Definition: libparse.cc:1035
register char * yy_cp
Definition: libparse.cc:1412
static yyconst short int yy_base[533]
Definition: libparse.cc:405
static yyconst short int yy_accept[485]
Definition: libparse.cc:306
static yyconst int yy_meta[53]
Definition: libparse.cc:395
static char * yy_c_buf_p
Definition: libparse.cc:237
static char * yy_last_accepting_cpos
Definition: libparse.cc:1036
static yyconst short int yy_chk[2253]
Definition: libparse.cc:783
static yyconst short int yy_nxt[2253]
Definition: libparse.cc:531
static int yyinput ( )
static

Definition at line 2840 of file libparse.cc.

2844  {
2845  int c;
2846 
2848 
2850  {
2851  /* yy_c_buf_p now points to the character we want to return.
2852  * If this occurs *before* the EOB characters, then it's a
2853  * valid NUL; if not, then we've hit the end of the buffer.
2854  */
2855  if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2856  /* This was really a NUL. */
2857  *yy_c_buf_p = '\0';
2858 
2859  else
2860  { /* need more input */
2861  int offset = yy_c_buf_p - yytext_ptr;
2862  ++yy_c_buf_p;
2863 
2864  switch ( yy_get_next_buffer() )
2865  {
2866  case EOB_ACT_LAST_MATCH:
2867  /* This happens because yy_g_n_b()
2868  * sees that we've accumulated a
2869  * token and flags that we need to
2870  * try matching the token before
2871  * proceeding. But for input(),
2872  * there's no matching to consider.
2873  * So convert the EOB_ACT_LAST_MATCH
2874  * to EOB_ACT_END_OF_FILE.
2875  */
2876 
2877  /* Reset buffer status. */
2878  yyrestart( yyin );
2879 
2880  /* fall through */
2881 
2882  case EOB_ACT_END_OF_FILE:
2883  {
2884  if ( yywrap() )
2885  return EOF;
2886 
2888  YY_NEW_FILE;
2889 #ifdef __cplusplus
2890  return yyinput();
2891 #else
2892  return input();
2893 #endif
2894  }
2895 
2896  case EOB_ACT_CONTINUE_SCAN:
2897  yy_c_buf_p = yytext_ptr + offset;
2898  break;
2899  }
2900  }
2901  }
2902 
2903  c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
2904  *yy_c_buf_p = '\0'; /* preserve yytext */
2905  yy_hold_char = *++yy_c_buf_p;
2906 
2907  yy_current_buffer->yy_at_bol = (c == '\n');
2908 
2909  return c;
2910  }
#define yytext_ptr
Definition: libparse.cc:286
#define yywrap
Definition: libparse.cc:17
#define EOB_ACT_LAST_MATCH
Definition: libparse.cc:124
#define YY_END_OF_BUFFER_CHAR
Definition: libparse.cc:112
static char yy_hold_char
Definition: libparse.cc:229
static int yy_get_next_buffer()
Definition: libparse.cc:2598
#define yyin
Definition: libparse.cc:11
#define EOB_ACT_END_OF_FILE
Definition: libparse.cc:123
static int yy_did_buffer_switch_on_eof
Definition: libparse.cc:244
#define EOB_ACT_CONTINUE_SCAN
Definition: libparse.cc:122
static int yyinput()
Definition: libparse.cc:2840
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define yyrestart
Definition: libparse.cc:15
static char * yy_c_buf_p
Definition: libparse.cc:237
static int yy_n_chars
Definition: libparse.cc:231
#define YY_NEW_FILE
Definition: libparse.cc:110
int offset
Definition: libparse.cc:1091
int yylpwrap ( )

Definition at line 3365 of file libparse.cc.

3366  {
3367  //printf("======================= YYWRAP ====================\n");
3368  if(brace1>0) { yylp_errno=YYLP_MISS_BR1; }
3369  if(brace2>0) { yylp_errno=YYLP_MISS_BR2; }
3370  if(brace3>0) { yylp_errno=YYLP_MISS_BR3; }
3371  if(quote>0) { yylp_errno=YYLP_MISSQUOT; }
3372  //printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
3373  if(feof(yyin)) return 1; else return 0;
3374  }
#define YYLP_MISS_BR2
Definition: libparse.h:96
int brace1
Definition: libparse.cc:1087
#define YYLP_MISS_BR3
Definition: libparse.h:97
int brace3
Definition: libparse.cc:1089
int quote
Definition: libparse.cc:1090
#define yyin
Definition: libparse.cc:11
#define YYLP_MISS_BR1
Definition: libparse.h:95
#define YYLP_MISSQUOT
Definition: libparse.h:94
int yylp_errno
Definition: libparse.cc:1128
int brace2
Definition: libparse.cc:1088
void yyrestart ( FILE *  input_file)

Definition at line 2914 of file libparse.cc.

2919  {
2920  if ( ! yy_current_buffer )
2922 
2923  yy_init_buffer( yy_current_buffer, input_file );
2925  }
#define yy_load_buffer_state
Definition: libparse.cc:9
#define yy_create_buffer
Definition: libparse.cc:1
#define yyin
Definition: libparse.cc:11
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
#define YY_BUF_SIZE
Definition: libparse.cc:115
#define yy_init_buffer
Definition: libparse.cc:7
static void yyunput ( int  c,
register char *  yy_bp 
)
static

Definition at line 2796 of file libparse.cc.

2802  {
2803  register char *yy_cp = yy_c_buf_p;
2804 
2805  /* undo effects of setting up yytext */
2806  *yy_cp = yy_hold_char;
2807 
2808  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2809  { /* need to shift things up to make room */
2810  /* +2 for EOB chars. */
2811  register int number_to_move = yy_n_chars + 2;
2812  register char *dest = &yy_current_buffer->yy_ch_buf[
2813  yy_current_buffer->yy_buf_size + 2];
2814  register char *source =
2815  &yy_current_buffer->yy_ch_buf[number_to_move];
2816 
2817  while ( source > yy_current_buffer->yy_ch_buf )
2818  *--dest = *--source;
2819 
2820  yy_cp += (int) (dest - source);
2821  yy_bp += (int) (dest - source);
2822  yy_current_buffer->yy_n_chars =
2823  yy_n_chars = yy_current_buffer->yy_buf_size;
2824 
2825  if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2826  YY_FATAL_ERROR( "flex scanner push-back overflow" );
2827  }
2828 
2829  *--yy_cp = (char) c;
2830 
2831 
2832  yytext_ptr = yy_bp;
2833  yy_hold_char = *yy_cp;
2834  yy_c_buf_p = yy_cp;
2835  }
#define yytext_ptr
Definition: libparse.cc:286
static char yy_hold_char
Definition: libparse.cc:229
register char * yy_cp
Definition: libparse.cc:1412
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
register char * yy_bp
Definition: libparse.cc:1412
static char * yy_c_buf_p
Definition: libparse.cc:237
static int yy_n_chars
Definition: libparse.cc:231

Variable Documentation

int brace1 = 0

Definition at line 1087 of file libparse.cc.

int brace2 = 0

Definition at line 1088 of file libparse.cc.

int brace3 = 0

Definition at line 1089 of file libparse.cc.

int check = 0

Definition at line 1104 of file libparse.cc.

int found_cat =0

Definition at line 1107 of file libparse.cc.

int found_info =0

Definition at line 1106 of file libparse.cc.

int found_oldhelp = 0

Definition at line 1109 of file libparse.cc.

int found_proc_in_proc = 0

Definition at line 1110 of file libparse.cc.

int found_version =0

Definition at line 1108 of file libparse.cc.

idhdl h0

Definition at line 1141 of file libparse.cc.

idhdl h_top

Definition at line 1142 of file libparse.cc.

unsigned long help_chksum
static

Definition at line 1151 of file libparse.cc.

lib_cmds last_cmd = LP_NONE

Definition at line 1094 of file libparse.cc.

char libnamebuf[128]

Definition at line 1096 of file libparse.cc.

libstackv library_stack

Definition at line 74 of file iplib.cc.

int lpverbose = 0

Definition at line 1104 of file libparse.cc.

int offset = 0

Definition at line 1091 of file libparse.cc.

int old_state = 0

Definition at line 1093 of file libparse.cc.

BOOLEAN p_static = FALSE

Definition at line 1092 of file libparse.cc.

int quote = 0

Definition at line 1090 of file libparse.cc.

long string_start

Definition at line 1098 of file libparse.cc.

int texinfo_out = 0

Definition at line 1105 of file libparse.cc.

char* text_buffer =NULL

Definition at line 1097 of file libparse.cc.

yyconst short int yy_accept[485]
static

Definition at line 306 of file libparse.cc.

register int yy_act

Definition at line 1413 of file libparse.cc.

yyconst short int yy_base[533]
static

Definition at line 405 of file libparse.cc.

register char * yy_bp

Definition at line 1412 of file libparse.cc.

char* yy_c_buf_p = (char *) 0
static

Definition at line 237 of file libparse.cc.

yyconst short int yy_chk[2253]
static

Definition at line 783 of file libparse.cc.

register char* yy_cp

Definition at line 1412 of file libparse.cc.

YY_BUFFER_STATE yy_current_buffer = 0
static

Definition at line 219 of file libparse.cc.

YY_DECL register yy_state_type yy_current_state

Definition at line 1411 of file libparse.cc.

yyconst short int yy_def[533]
static

Definition at line 468 of file libparse.cc.

int yy_did_buffer_switch_on_eof
static

Definition at line 244 of file libparse.cc.

yyconst int yy_ec[256]
static

Definition at line 363 of file libparse.cc.

char yy_hold_char
static

Definition at line 229 of file libparse.cc.

int yy_init = 1
static

Definition at line 238 of file libparse.cc.

char* yy_last_accepting_cpos
static

Definition at line 1036 of file libparse.cc.

yy_state_type yy_last_accepting_state
static

Definition at line 1035 of file libparse.cc.

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

Definition at line 395 of file libparse.cc.

int yy_more_flag = 0
static

Definition at line 1042 of file libparse.cc.

int yy_more_len = 0
static

Definition at line 1043 of file libparse.cc.

int yy_n_chars
static

Definition at line 231 of file libparse.cc.

yyconst short int yy_nxt[2253]
static

Definition at line 531 of file libparse.cc.

int yy_start = 0
static

Definition at line 239 of file libparse.cc.

FILE* yyin = (FILE *) 0

Definition at line 283 of file libparse.cc.

int yyleng

Definition at line 234 of file libparse.cc.

char* yylp_buffer_start

Definition at line 1100 of file libparse.cc.

const char* yylp_errlist[]
Initial value:
= {
"",
"missing close bracket ')' for proc definition in line %d.",
"missing close bracket ')' for procbody in line %d.",
"missing close bracket ']' for procbody in line %d.",
"too many ')' closed brackets in line %d.",
"too many ']' closed brackets in line %d.",
"missing close bracket ')' for example in line %d.",
"missing close bracket ']' for example in line %d.",
"cannot assign character '%c' in line %d to any group.",
"there must be a quote missing somewhere before line %d.",
"missing close bracket '}' at end of library in line %d.",
"missing close bracket ')' at end of library in line %d.",
"missing close bracket ']' at end of library in line %d.",
}
#define NULL
Definition: omList.c:10

Definition at line 1112 of file libparse.cc.

int yylp_errno = 0

Definition at line 1128 of file libparse.cc.

int yylplineno = 1

Definition at line 1102 of file libparse.cc.

FILE * yyout = (FILE *) 0

Definition at line 283 of file libparse.cc.

char* yytext

Definition at line 1047 of file libparse.cc.