My Project  UNKNOWN_GIT_VERSION
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)
 
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 [1024]
 
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 char * yy_cp
 
register char * yy_bp
 
register int yy_act
 

Data Structure Documentation

◆ yy_buffer_state

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

◆ BEGIN

#define BEGIN   yy_start = 1 + 2 *

Definition at line 97 of file libparse.cc.

◆ category

#define category   16

Definition at line 1256 of file libparse.cc.

◆ comment

#define comment   14

Definition at line 1252 of file libparse.cc.

◆ ECHO

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

Definition at line 1341 of file libparse.cc.

◆ EOB_ACT_CONTINUE_SCAN

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 122 of file libparse.cc.

◆ EOB_ACT_END_OF_FILE

#define EOB_ACT_END_OF_FILE   1

Definition at line 123 of file libparse.cc.

◆ EOB_ACT_LAST_MATCH

#define EOB_ACT_LAST_MATCH   2

Definition at line 124 of file libparse.cc.

◆ FLEX_SCANNER

#define FLEX_SCANNER

Definition at line 25 of file libparse.cc.

◆ header

#define header   1

Definition at line 1226 of file libparse.cc.

◆ help

#define help   2

Definition at line 1228 of file libparse.cc.

◆ IncrCheckSum

#define IncrCheckSum (   c)
Value:
do \
{ \
ROTATE_RIGHT(help_chksum); \
help_chksum += c; \
help_chksum &= 0xffff; \
} \
while(0)

Definition at line 1189 of file libparse.cc.

◆ info

#define info   15

Definition at line 1254 of file libparse.cc.

◆ INITIAL

#define INITIAL   0

Definition at line 1049 of file libparse.cc.

◆ libcmd

#define libcmd   3

Definition at line 1230 of file libparse.cc.

◆ libcmd2

#define libcmd2   4

Definition at line 1232 of file libparse.cc.

◆ pbody

#define pbody   9

Definition at line 1242 of file libparse.cc.

◆ pdef

#define pdef   5

Definition at line 1234 of file libparse.cc.

◆ pestr

#define pestr   12

Definition at line 1248 of file libparse.cc.

◆ pexample

#define pexample   11

Definition at line 1246 of file libparse.cc.

◆ phead

#define phead   6

Definition at line 1236 of file libparse.cc.

◆ phelp

#define phelp   8

Definition at line 1240 of file libparse.cc.

◆ pi

#define pi   IDPROC(h0)

Definition at line 1143 of file libparse.cc.

◆ poldhelp

#define poldhelp   7

Definition at line 1238 of file libparse.cc.

◆ pstr

#define pstr   10

Definition at line 1244 of file libparse.cc.

◆ REJECT

#define REJECT   reject_used_but_not_detected

Definition at line 1041 of file libparse.cc.

◆ ROTATE_RIGHT

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

Definition at line 1188 of file libparse.cc.

◆ SET_BODY_END

#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; \
}

Definition at line 1167 of file libparse.cc.

◆ SET_BODY_START

#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; \
}

Definition at line 1161 of file libparse.cc.

◆ SET_DEF_END

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

◆ SET_EXAMPLE_START

#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; \
}

Definition at line 1174 of file libparse.cc.

◆ SET_HELP_END

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

Definition at line 1157 of file libparse.cc.

◆ SET_HELP_START

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

◆ SET_PROC_END

#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; \
}

Definition at line 1180 of file libparse.cc.

◆ string

#define string   13

Definition at line 1250 of file libparse.cc.

◆ unput

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

Definition at line 153 of file libparse.cc.

◆ url

#define url   17

Definition at line 1258 of file libparse.cc.

◆ version

#define version   18

Definition at line 1260 of file libparse.cc.

◆ YY_AT_BOL

#define YY_AT_BOL ( )    (yy_current_buffer->yy_at_bol)

Definition at line 280 of file libparse.cc.

◆ YY_BREAK

#define YY_BREAK   break;

Definition at line 1400 of file libparse.cc.

◆ YY_BUF_SIZE

#define YY_BUF_SIZE   16384

Definition at line 115 of file libparse.cc.

◆ YY_BUFFER_EOF_PENDING

#define YY_BUFFER_EOF_PENDING   2

Definition at line 216 of file libparse.cc.

◆ YY_BUFFER_NEW

#define YY_BUFFER_NEW   0

Definition at line 204 of file libparse.cc.

◆ YY_BUFFER_NORMAL

#define YY_BUFFER_NORMAL   1

Definition at line 205 of file libparse.cc.

◆ yy_create_buffer

#define yy_create_buffer   yylp_create_buffer

Definition at line 1 of file libparse.cc.

◆ YY_CURRENT_BUFFER

#define YY_CURRENT_BUFFER   yy_current_buffer

Definition at line 225 of file libparse.cc.

◆ YY_DECL

#define YY_DECL
Value:
int yylex(const char *newlib, const char *libfile, \
lib_style_types *lib_style, \
idhdl pl, BOOLEAN autoexport, lp_modes mode)

Definition at line 1199 of file libparse.cc.

◆ yy_delete_buffer

#define yy_delete_buffer   yylp_delete_buffer

Definition at line 2 of file libparse.cc.

◆ YY_DO_BEFORE_ACTION

#define YY_DO_BEFORE_ACTION
Value:
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 296 of file libparse.cc.

◆ YY_END_OF_BUFFER

#define YY_END_OF_BUFFER   97

Definition at line 305 of file libparse.cc.

◆ YY_END_OF_BUFFER_CHAR

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 112 of file libparse.cc.

◆ YY_EXIT_FAILURE

#define YY_EXIT_FAILURE   2

Definition at line 3229 of file libparse.cc.

◆ YY_FATAL_ERROR

#define YY_FATAL_ERROR (   msg)    yy_fatal_error( msg )

Definition at line 1381 of file libparse.cc.

◆ yy_flex_debug

#define yy_flex_debug   yylp_flex_debug

Definition at line 6 of file libparse.cc.

◆ YY_FLEX_MAJOR_VERSION

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 26 of file libparse.cc.

◆ YY_FLEX_MINOR_VERSION

#define YY_FLEX_MINOR_VERSION   5

Definition at line 27 of file libparse.cc.

◆ yy_flush_buffer

#define yy_flush_buffer   yylp_flush_buffer

Definition at line 8 of file libparse.cc.

◆ YY_FLUSH_BUFFER

#define YY_FLUSH_BUFFER   yy_flush_buffer( yy_current_buffer )

Definition at line 254 of file libparse.cc.

◆ yy_init_buffer

#define yy_init_buffer   yylp_init_buffer

Definition at line 7 of file libparse.cc.

◆ YY_INPUT

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

Definition at line 1203 of file libparse.cc.

◆ yy_load_buffer_state

void yy_load_buffer_state (   void)    yylp_load_buffer_state

Definition at line 9 of file libparse.cc.

◆ YY_MORE_ADJ

#define YY_MORE_ADJ   yy_more_len

Definition at line 1045 of file libparse.cc.

◆ yy_new_buffer

#define yy_new_buffer   yy_create_buffer

Definition at line 264 of file libparse.cc.

◆ YY_NEW_FILE

#define YY_NEW_FILE   yyrestart( yyin )

Definition at line 110 of file libparse.cc.

◆ YY_NO_POP_STATE

#define YY_NO_POP_STATE   1

Definition at line 1311 of file libparse.cc.

◆ YY_NO_PUSH_STATE

#define YY_NO_PUSH_STATE   1

Definition at line 1310 of file libparse.cc.

◆ YY_NO_TOP_STATE

#define YY_NO_TOP_STATE   1

Definition at line 1312 of file libparse.cc.

◆ YY_NULL

#define YY_NULL   0

Definition at line 84 of file libparse.cc.

◆ YY_NUM_RULES

#define YY_NUM_RULES   96

Definition at line 304 of file libparse.cc.

◆ YY_PROTO

#define YY_PROTO (   proto)    proto

Definition at line 78 of file libparse.cc.

◆ YY_READ_BUF_SIZE

#define YY_READ_BUF_SIZE   8192

Definition at line 1332 of file libparse.cc.

◆ YY_RESTORE_YY_MORE_OFFSET

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 1046 of file libparse.cc.

◆ YY_RULE_SETUP

#define YY_RULE_SETUP
Value:
if ( yyleng > 0 ) \
yy_current_buffer->yy_at_bol = \
(yytext[yyleng - 1] == '\n'); \
YY_USER_ACTION

Definition at line 1403 of file libparse.cc.

◆ YY_SC_TO_UI

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

Definition at line 91 of file libparse.cc.

◆ yy_scan_buffer

#define yy_scan_buffer   yylp_scan_buffer

Definition at line 3 of file libparse.cc.

◆ yy_scan_bytes

#define yy_scan_bytes   yylp_scan_bytes

Definition at line 5 of file libparse.cc.

◆ yy_scan_string

#define yy_scan_string   yylp_scan_string

Definition at line 4 of file libparse.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 273 of file libparse.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 266 of file libparse.cc.

◆ YY_SKIP_YYWRAP

#define YY_SKIP_YYWRAP

Definition at line 1077 of file libparse.cc.

◆ YY_START

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

Definition at line 103 of file libparse.cc.

◆ YY_START_STACK_INCR

#define YY_START_STACK_INCR   25

Definition at line 1376 of file libparse.cc.

◆ YY_STATE_EOF

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

Definition at line 107 of file libparse.cc.

◆ yy_switch_to_buffer

#define yy_switch_to_buffer   yylp_switch_to_buffer

Definition at line 10 of file libparse.cc.

◆ YY_USE_CONST

#define YY_USE_CONST

Definition at line 49 of file libparse.cc.

◆ YY_USE_PROTOS

#define YY_USE_PROTOS

Definition at line 46 of file libparse.cc.

◆ YY_USER_ACTION

#define YY_USER_ACTION

Definition at line 1395 of file libparse.cc.

◆ YY_USER_INIT

#define YY_USER_INIT
Value:
{ \
BEGIN(header); \
yylplineno = 1; \
yylp_errno = 0; \
*lib_style = OLD_LIBSTYLE; \
strcpy(libnamebuf,"(**unknown version**)"); \
}

Definition at line 1208 of file libparse.cc.

◆ yyconst

#define yyconst   const

Definition at line 71 of file libparse.cc.

◆ yyin

FILE * yyin   yylpin

Definition at line 11 of file libparse.cc.

◆ yyleng

int yyleng   yylpleng

Definition at line 12 of file libparse.cc.

◆ yyless [1/2]

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

Definition at line 3248 of file libparse.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 3248 of file libparse.cc.

◆ yylex

int yylex   yylplex

Definition at line 13 of file libparse.cc.

◆ yymore

#define yymore ( )    (yy_more_flag = 1)

Definition at line 1044 of file libparse.cc.

◆ yyout

FILE * yyout   yylpout

Definition at line 14 of file libparse.cc.

◆ yyrestart

#define yyrestart   yylprestart

Definition at line 15 of file libparse.cc.

◆ YYSTATE

#define YYSTATE   YY_START

Definition at line 104 of file libparse.cc.

◆ yyterminate

#define yyterminate ( )    return YY_NULL

Definition at line 1371 of file libparse.cc.

◆ yytext

char * yytext   yylptext

Definition at line 16 of file libparse.cc.

◆ yytext_ptr

#define yytext_ptr   yytext

Definition at line 286 of file libparse.cc.

◆ yywrap

#define yywrap   yylpwrap

Definition at line 17 of file libparse.cc.

Typedef Documentation

◆ YY_CHAR

typedef unsigned char YY_CHAR

Definition at line 282 of file libparse.cc.

◆ yy_size_t

typedef unsigned int yy_size_t

Definition at line 159 of file libparse.cc.

◆ yy_state_type

typedef int yy_state_type

Definition at line 284 of file libparse.cc.

Enumeration Type Documentation

◆ lib_cmds

enum lib_cmds
Enumerator
LP_NONE 
LP_INFO 
LP_CATEGORY 
LP_URL 
LP_VERSION 

Definition at line 1079 of file libparse.cc.

Function Documentation

◆ copy_string()

void copy_string ( lp_modes  mode)

Definition at line 3404 of file libparse.cc.

3405 {
3406 #ifdef STANDALONE_PARSER
3407  if ((texinfo_out
3408  && (last_cmd == LP_INFO || last_cmd == LP_CATEGORY || last_cmd == LP_URL))
3409  || (category_out && last_cmd == LP_CATEGORY)
3410 )
3411  {
3412  long current_location = ftell(yylpin), i = string_start, quote = 0;
3413  char c;
3414  if (texinfo_out)
3415  {
3416  if (last_cmd == LP_INFO)
3417  {
3418  printf("$info = <<EOT;\n");
3419  }
3420  else if (last_cmd == LP_URL)
3421  {
3422  printf("$url = <<EOT;\n");
3423  }
3424  else
3425  {
3426  printf("$category = <<EOT;\n");
3427  }
3428  }
3429  fseek (yylpin, i, SEEK_SET);
3430  while (i< current_location)
3431  {
3432  c = fgetc(yylpin);
3433  if (c == '\\')
3434  {
3435  quote = (! quote);
3436  }
3437  else if (c == '"')
3438  {
3439  if (! quote) break;
3440  }
3441  else
3442  quote = 0;
3443  if (c == '@' || c == '$') putchar('\\');
3444  if (c != '\r') putchar(c);
3445  i++;
3446  }
3447  if (category_out) exit(0);
3448  fseek (yylpin, current_location, SEEK_SET);
3449  printf("\nEOT\n");
3450  }
3451 #else
3452  if((last_cmd == LP_INFO)&&(mode == GET_INFO))
3453  {
3454  int i, offset=0;
3455  long current_location = ftell(yylpin);
3456  int len = (int)(current_pos(0) - string_start);
3457  fseek(yylpin, string_start, SEEK_SET);
3459  text_buffer = (char *)omAlloc(len+2);
3461  myfread(text_buffer, len, 1, yylpin);
3462  fseek(yylpin, current_location, SEEK_SET);
3463  text_buffer[len]='\0';
3464  offset=0;
3465  for(i=0;i<=len; i++)
3466  {
3467  if(text_buffer[i]=='\\' &&
3468  (text_buffer[i+1]=='\"' || text_buffer[i+1]=='{' ||
3469  text_buffer[i+1]=='}' || text_buffer[i+1]=='\\'))
3470  {
3471  i++;
3472  offset++;
3473  }
3474  if(offset>0) text_buffer[i-offset] = text_buffer[i];
3475  }
3476  }
3477 #endif /* STANDALONE_PARSER */
3478 }

◆ current_pos()

int current_pos ( int  i)

Definition at line 3344 of file libparse.cc.

3345 {
3346  return(i+offset+(int)(yytext-yylp_buffer_start));
3347 }

◆ if()

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  }

◆ libread()

int libread ( FILE *  f,
char *  buf,
int  max_size 
)

Definition at line 3349 of file libparse.cc.

3350 { int rc;
3351 
3352  offset = ftell(f);
3353  rc = myfread( buf, 1, max_size, f );
3354  #if YYLPDEBUG >2
3355  printf("fread: %d of %d\n", rc, max_size);
3356  #endif
3358  return rc;
3359 }

◆ make_version()

void make_version ( char *  p,
int  what 
)

Definition at line 3384 of file libparse.cc.

3385 {
3386  char ver[11];
3387  char date[17];
3388  ver[0]='?'; ver[1]='.'; ver[2]='?'; ver[3]='\0';
3389  date[0]='?'; date[1]='\0';
3390  if(what) sscanf(p,"%*[^=]= %*s %*s %10s %16s",ver,date);
3391  else sscanf(p,"// %*s %*s %10s %16s",ver,date);
3392  strcpy(libnamebuf,"(");
3393  strcat(libnamebuf,ver);
3394  strcat(libnamebuf,",");
3395  strcat(libnamebuf,date);
3396  strcat(libnamebuf,")");
3397  if(what && strcmp(libnamebuf, "(?.?,?)")==0)
3398  {
3399  sscanf(p,"%*[^\"]\"%[^\"]\"",libnamebuf);
3400  }
3401  //printf("ID=(%d)%s; \n", what, p);
3402 }

◆ print_init()

void print_init ( )

Definition at line 3480 of file libparse.cc.

3481 {
3482  printf("Init=%d\n", yy_init);
3483 }

◆ print_version()

void print_version ( lp_modes  mode,
char *  p 
)

Definition at line 3485 of file libparse.cc.

3486 {
3487 #ifdef STANDALONE_PARSER
3488  //printf("loading %s%s", p, libnamebuf);
3489 #else
3490  if ( mode == LOAD_LIB )
3491  {
3492  if (BVERBOSE(V_LOAD_LIB) && p!=NULL ) Print(" %s...", p);
3493  //Warn( "loading %s%s", p, libnamebuf);
3494  }
3495 #endif
3496 }

◆ reinit_yylp()

void reinit_yylp ( )

Definition at line 3374 of file libparse.cc.

3375 {
3376  brace1 = 0;
3377  brace2 = 0;
3378  brace3 = 0;
3379  quote = 0;
3380  yy_init=1;
3382 }

◆ while()

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 
1460  yy_current_state = yy_start;
1461  yy_current_state += YY_AT_BOL();
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  {
1468  yy_last_accepting_state = yy_current_state;
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_current_state != 484 );
1482  yy_current_state = yy_last_accepting_state;
1483 
1484 yy_find_action:
1485  yy_act = yy_accept[yy_current_state];
1486 
1488 
1489 
1490 do_action: /* This label is used only to access EOF actions. */
1491 
1492 
1493  switch ( yy_act )
1494  { /* beginning of action switch */
1495  case 0: /* must back up */
1496  /* undo the effects of YY_DO_BEFORE_ACTION */
1497  *yy_cp = yy_hold_char;
1499  yy_current_state = yy_last_accepting_state;
1500  goto yy_find_action;
1501 
1502 case 1:
1504 #line 230 "libparse.l"
1505 { }
1506  YY_BREAK
1507 case 2:
1509 #line 231 "libparse.l"
1510 { old_state = YYSTATE; BEGIN(comment); }
1511  YY_BREAK
1512 case 3:
1514 #line 233 "libparse.l"
1515 {
1516  yyless(4); old_state = YYSTATE; BEGIN(info);
1517  }
1518  YY_BREAK
1519 case 4:
1521 #line 236 "libparse.l"
1522 {
1524  }
1525  YY_BREAK
1526 case 5:
1528 #line 239 "libparse.l"
1529 {
1530  if ( mode != GET_INFO )
1531  {
1532  #ifdef STANDALONE_PARSER
1533  if (texinfo_out)
1534  {
1535  char *c = yytext;
1536  printf("$url = \"");
1537  while ((*c != '\0') && (*c != '"')) c++;
1538  c++;
1539  while ((*c != '\0') && (*c != '"'))
1540  {
1541  if (*c != '\r') putchar(*c);
1542  c++;
1543  }
1544  printf("\";\n");
1545  }
1546  #endif
1547  }
1548  }
1549  YY_BREAK
1550 case 6:
1552 #line 260 "libparse.l"
1553 {
1554  found_version++;
1555  if ( mode != GET_INFO )
1556  {
1557  make_version(yytext,1);
1558  #ifdef STANDALONE_PARSER
1559  if (texinfo_out)
1560  {
1561  char *c = libnamebuf;
1562  printf("$version = \"");
1563  while (*c != '\0')
1564  {
1565  if (*c == '$' || *c == '@') putchar('\\');
1566  if (*c != '\r') putchar(*c);
1567  if (*c == '\\')
1568  {
1569  c++;
1570  if (*c != '"') putchar('\\');
1571  }
1572  else
1573  c++;
1574  }
1575  printf("\";\n");
1576  }
1577  else if (!category_out)
1578  printf("Version:%s;\n", libnamebuf);
1579  #else
1583  #endif
1584  }
1585  }
1586  YY_BREAK
1587 case 7:
1589 #line 294 "libparse.l"
1590 { p_static=TRUE; }
1591  YY_BREAK
1592 case 8:
1594 #line 296 "libparse.l"
1595 {
1596  char proc[256];
1597  BEGIN(pdef);
1598  found_proc_in_proc = 0;
1599  proc[0]='\0';
1600  sscanf( yytext, "%*[^p]proc %s", proc);
1601  if(strlen(proc)<1) sscanf( yytext, "proc %s", proc);
1602  #if YYLPDEBUG > 1
1603  printf("Newlib:%s\n", newlib);
1604  #endif
1605  #ifdef STANDALONE_PARSER
1606  if ( pi != NULL )
1607  {
1608  printpi(pi);
1609  pi_clear(pi);
1610  }
1611  pi = (procinfo *)malloc(sizeof(procinfo));
1613  current_pos(0), p_static);
1614  #else /*STANDALONE_PARSER*/
1615  if( mode == LOAD_LIB)
1616  {
1617  h0 = enterid( proc, 0 /*myynest*/, PROC_CMD,
1618  &(IDPACKAGE(pl)->idroot), TRUE, !p_static);
1619  if (h0==NULL) return(1);
1620  if((!p_static) && autoexport)
1621  {
1622  package save=currPack;
1624  h_top = enterid( proc, 0 /*myynest*/, PROC_CMD,
1625  &(basePack->idroot), FALSE );
1626  currPack=save;
1627  if (h_top==NULL) return(1);
1628  }
1629  /* omCheckAddr(IDID(h0)); */
1630  if (h0!=NULL)
1631  {
1634  if ((!p_static) && (h_top != NULL) && autoexport)
1635  {
1637  IDPROC(h_top)=IDPROC(h0);
1638  IDPROC(h_top)->ref++;
1639  }
1640  IDPROC(h0)->pack=IDPACKAGE(pl);
1641  if (BVERBOSE(V_LOAD_PROC))
1642  Warn( " proc '%s' registered", proc );
1643  }
1644  #endif /*STANDALONE_PARSER*/
1645  SET_DEF_END(mode, pi, current_pos(yyleng+1));
1646  #if YYLPDEBUG
1647  if(lpverbose)
1648  {
1649  printf("// PROCEDURE '%s' status: %s, ", proc,
1650  p_static ? "local" : "global");
1651  printf("starting at line %d,%d: definition end: %d (%d).\n",
1652  yylplineno, current_pos(0), (int)pi->data.s.def_end, brace1);
1653  }
1654  #endif
1655  p_static=FALSE;
1656  #ifndef STANDALONE_PARSER
1657  }
1658  #endif /*STANDALONE_PARSER*/
1659  }
1660  YY_BREAK
1661 case 9:
1663 #line 361 "libparse.l"
1664 {
1665  BEGIN(pexample);
1667  #if YYLPDEBUG
1668  if(lpverbose)
1669  {
1670  printf("// EXAMPLE at line %d,%d (%d)\n", yylplineno,
1671  current_pos(0), brace1);
1672  }
1673  #endif
1674  }
1675  YY_BREAK
1676 case 10:
1678 #line 373 "libparse.l"
1679 { quote++;
1680  BEGIN(libcmd);
1681  }
1682  YY_BREAK
1683 case 11:
1685 #line 377 "libparse.l"
1686 { quote++; brace2++;
1687  BEGIN(libcmd2);
1688  }
1689  YY_BREAK
1690 case 12:
1692 #line 381 "libparse.l"
1693 {
1694  make_version(yytext, 0);
1695  #if YYLPDEBUG > 1
1696  printf("+(id)HEAD:%s\n", yytext);
1697  #endif
1698  }
1699  YY_BREAK
1700 case 13:
1702 #line 387 "libparse.l"
1703 {
1704  #if YYLPDEBUG
1705  printf("+(cmt)HEAD:%s\n", yytext);
1706  #endif
1707  }
1708  YY_BREAK
1709 case 14:
1711 #line 392 "libparse.l"
1712 {
1713  #if YYLPDEBUG > 1
1714  printf("-HEAD:%s\n", yytext);
1715  #endif
1716  }
1717  YY_BREAK
1718 case 15:
1720 #line 397 "libparse.l"
1721 { yyless(0);
1722  BEGIN(INITIAL);
1723  yymore();
1724  }
1725  YY_BREAK
1726 case 16:
1728 #line 401 "libparse.l"
1729 {
1730  yyless(0);
1731  *lib_style = NEW_LIBSTYLE;
1732  BEGIN(INITIAL);
1733  yymore();
1734  }
1735  YY_BREAK
1736 case 17:
1738 #line 408 "libparse.l"
1739 { quote++;
1740  BEGIN(libcmd);
1741  }
1742  YY_BREAK
1743 case 18:
1745 #line 411 "libparse.l"
1746 { quote++; brace2++;
1747  BEGIN(libcmd2);
1748  }
1749  YY_BREAK
1750 case 19:
1752 #line 414 "libparse.l"
1753 { yylplineno++; }
1754  YY_BREAK
1755 case 20:
1757 #line 415 "libparse.l"
1758 {
1759  #if YYLPDEBUG > 1
1760  printf(" HEAD:%s\n", yytext);
1761  #endif
1762  yyless(0);
1763  BEGIN(help);
1764  }
1765  YY_BREAK
1766 case 21:
1768 #line 422 "libparse.l"
1769 {
1770  #if YYLPDEBUG > 1
1771  printf(" HELP:%s\n", yytext);
1772  #endif
1773  BEGIN(INITIAL); }
1774  YY_BREAK
1775 case 22:
1777 #line 427 "libparse.l"
1778 {
1779  #if YYLPDEBUG > 1
1780  printf(" HELP:%s\n", yytext);
1781  #endif
1782  BEGIN(INITIAL);
1783  }
1784  YY_BREAK
1785 case 23:
1787 #line 433 "libparse.l"
1788 {
1789  yyless(0);
1790  *lib_style = NEW_LIBSTYLE;
1791  BEGIN(INITIAL);
1792  yymore();
1793  }
1794  YY_BREAK
1795 case 24:
1797 #line 439 "libparse.l"
1798 {
1799  yyless(0);
1800  //printf("2) proc found.\n");
1801  BEGIN(INITIAL);
1802  yymore();
1803  }
1804  YY_BREAK
1805 case 25:
1807 #line 445 "libparse.l"
1808 { quote++;
1809  BEGIN(libcmd);
1810  }
1811  YY_BREAK
1812 case 26:
1814 #line 448 "libparse.l"
1815 { quote++; brace2++;
1816  BEGIN(libcmd2);
1817  }
1818  YY_BREAK
1819 case 27:
1821 #line 452 "libparse.l"
1822 { yylplineno++; }
1823  YY_BREAK
1824 case 28:
1826 #line 453 "libparse.l"
1827 {
1828  #if YYLPDEBUG
1829  if(lpverbose>2) printf("--->%s<---\n", yytext);
1830  #endif
1831  }
1832  YY_BREAK
1833 case 29:
1835 #line 458 "libparse.l"
1836 {
1837  found_oldhelp=1;
1838  #if YYLPDEBUG > 1
1839  printf("-HELP:%s\n", yytext);
1840  #endif
1841  }
1842  YY_BREAK
1843 case 30:
1845 #line 466 "libparse.l"
1846 { quote--;
1847  yytext[yyleng-1] = '\0';
1848  #ifndef STANDALONE_PARSER
1849  if ( mode == LOAD_LIB )
1850  {
1851  library_stack->push(newlib, yytext);
1852  }
1853  #endif /* STANDALONE_PARSER */
1854  #if YYLPDEBUG
1855  if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1856  #endif
1857  BEGIN(INITIAL);
1858  }
1859  YY_BREAK
1860 case 31:
1862 #line 479 "libparse.l"
1863 { quote--; brace2--;
1864  yytext[yyleng-1] = '\0';
1865  #ifndef STANDALONE_PARSER
1866  if ( mode == LOAD_LIB )
1867  {
1868  library_stack->push(newlib, yytext);
1869  }
1870  #endif /* STANDALONE_PARSER */
1871  #if YYLPDEBUG
1872  if(lpverbose>1) printf("LIB:'%s'\n", yytext);
1873  #endif
1874  BEGIN(INITIAL);
1875  }
1876  YY_BREAK
1877 case 32:
1879 #line 493 "libparse.l"
1880 { }
1881  YY_BREAK
1882 case 33:
1884 #line 494 "libparse.l"
1885 {
1886  brace2++;
1887  #if YYLPDEBUG > 1
1888  printf("%s", yytext);
1889  #endif
1890  }
1891  YY_BREAK
1892 case 34:
1894 #line 500 "libparse.l"
1895 {
1896  brace2--;
1897  #if YYLPDEBUG > 1
1898  printf(">%s<\n", yytext);
1899  printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1900  #endif
1901  if(brace2<=0)
1902  {
1903  #if YYLPDEBUG > 1
1904  printf("BEGIN(phead){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1905  #endif
1906  SET_DEF_END(mode, pi, current_pos(yyleng));
1907  BEGIN(phead);
1908  }
1909  }
1910  YY_BREAK
1911 case 35:
1913 #line 515 "libparse.l"
1914 {
1915  if(brace2>0)
1916  {
1917  #if YYLPDEBUG > 1
1918  printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1919  #endif
1921  return(1);
1922  }
1923  else
1924  {
1925  brace1++; BEGIN(pbody);
1926  if(lpverbose)
1927  printf("// BODY at line %d,%d (%d)\n", yylplineno,
1928  current_pos(0), brace1);
1930  }
1931  }
1932  YY_BREAK
1933 case 36:
1935 #line 533 "libparse.l"
1936 { yylplineno++;
1937  if(brace2<=0)
1938  {
1939 #if YYLPDEBUG > 1
1940  printf("BEGIN(phead-2){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
1941 #endif
1942  BEGIN(phead);
1943  }
1944  }
1945  YY_BREAK
1946 case 37:
1948 #line 542 "libparse.l"
1949 { }
1950  YY_BREAK
1951 case 38:
1953 #line 543 "libparse.l"
1954 { old_state = YYSTATE; BEGIN(comment); }
1955  YY_BREAK
1956 case 39:
1958 #line 544 "libparse.l"
1959 {
1960  if(brace2<=0)
1961  {
1962  BEGIN(phead);
1963  yyless(0);
1964  }
1965  }
1966  YY_BREAK
1967 case 40:
1969 #line 552 "libparse.l"
1970 {
1971  #if YYLPDEBUG
1972  if(lpverbose>2)printf("0-Len=%d;\n", yyleng);
1973  #endif
1974  if(check)
1975  {
1976  printf("Procedure %s has OLD-STYLE-HELP!\n",
1977  pi->procname);
1978  }
1979  SET_HELP_START(mode, pi, current_pos(0));
1980  BEGIN(poldhelp);
1981  yyless(0);
1982  }
1983  YY_BREAK
1984 case 41:
1986 #line 565 "libparse.l"
1987 {
1988  #if YYLPDEBUG
1989  if(lpverbose>2)printf("1-Len=%d;\n", yyleng);
1990  #endif
1991  BEGIN(phelp);
1992  yyless(0);
1993  }
1994  YY_BREAK
1995 case 42:
1997 #line 572 "libparse.l"
1998 {
1999  if(check && yyleng>2)
2000  {
2001  printf("Procedure %s has OLD-STYLE-HELP!\n",
2002  pi->procname);
2003  }
2004  #if YYLPDEBUG
2005  if(lpverbose>2 && yyleng>2)
2006  printf("2-Len=%d, %s;\n", yyleng, pi->procname);
2007  #endif
2008  SET_HELP_START(mode, pi, current_pos(0));
2009  BEGIN(poldhelp);
2010  yyless(0);
2011  }
2012  YY_BREAK
2013 case 43:
2015 #line 586 "libparse.l"
2016 { printf("[%s]", yytext); }
2017  YY_BREAK
2018 case 44:
2020 #line 588 "libparse.l"
2021 { }
2022  YY_BREAK
2023 case 45:
2025 #line 589 "libparse.l"
2026 {
2027  SET_HELP_END(mode, pi, current_pos(0));
2028  brace1++; BEGIN(pbody);
2029  if(lpverbose)
2030  {
2031  printf("// HELP from %d to %d\n",
2032  (int)pi->data.s.help_start, (int)pi->data.s.help_end);
2033  printf("// BODY at line %d,%d (%d)\n", yylplineno,
2034  current_pos(0), brace1);
2035  }
2036 #if YYLPDEBUG > 1
2037  printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2038 #endif
2040 #if YYLPDEBUG > 1
2041  printf("BODY at %d/%d", yylplineno, current_pos(0));
2042 #endif
2043  }
2044  YY_BREAK
2045 case 46:
2047 #line 607 "libparse.l"
2048 { yylplineno++; }
2049  YY_BREAK
2050 case 47:
2052 #line 608 "libparse.l"
2053 { }
2054  YY_BREAK
2055 case 48:
2057 #line 610 "libparse.l"
2058 {
2059  old_state = YYSTATE;
2060  BEGIN(string);
2061  SET_HELP_START(mode, pi, current_pos(1));
2062  }
2063  YY_BREAK
2064 case 49:
2066 #line 615 "libparse.l"
2067 {}
2068  YY_BREAK
2069 case 50:
2071 #line 616 "libparse.l"
2072 {
2073  brace1++; BEGIN(pbody);
2074  if(lpverbose)
2075  {
2076  printf("// HELP from %d to %d\n",
2077  (int)pi->data.s.help_start, (int)pi->data.s.help_end);
2078  printf("// BODY at line %d,%d (%d)\n", yylplineno,
2079  current_pos(0), brace1);
2080  }
2081  #if YYLPDEBUG > 1
2082  printf("BEGIN(pbody){=%d, (=%d, [=%d\n", brace1, brace2, brace3);
2083  #endif
2085  #if YYLPDEBUG > 1
2086  printf("BODY at %d/%d", yylplineno, current_pos(0));
2087  #endif
2088  }
2089  YY_BREAK
2090 case 51:
2092 #line 633 "libparse.l"
2093 { yylplineno++;}
2094  YY_BREAK
2095 case 52:
2097 #line 635 "libparse.l"
2098 { }
2099  YY_BREAK
2100 case 53:
2102 #line 636 "libparse.l"
2103 { quote++; old_state = YYSTATE;
2104  BEGIN(string); /* printf("%s", yytext); */
2105  }
2106  YY_BREAK
2107 case 54:
2109 #line 640 "libparse.l"
2110 {
2111  if(check) printf("*** found 2 proc whithin procedure '%s'.\n",
2112  pi->procname);
2113  yyless(yyleng-1);
2114  }
2115  YY_BREAK
2116 case 55:
2118 #line 645 "libparse.l"
2119 {
2120  if(check) printf("*** found 1 proc whithin procedure '%s'.\n",
2121  pi->procname);
2122  yyless(yyleng-1);
2123  }
2124  YY_BREAK
2125 case 56:
2127 #line 650 "libparse.l"
2128 {
2129  brace1++;
2130  #if YYLPDEBUG > 1
2131  printf("line: %d, (%d)%s\n", yylplineno, brace1, yytext);
2132  #endif
2133  }
2134  YY_BREAK
2135 case 57:
2137 #line 656 "libparse.l"
2138 {
2139  #if YYLPDEBUG > 1
2140  printf("line: %d, (%d)%s\n",
2142  #endif
2143  brace1--;
2144  if(brace2>0)
2145  {
2147  return(1);
2148  }
2149  if(brace3>0)
2150  {
2152  return(1);
2153  }
2154  if(brace1<=0)
2155  {
2156  SET_BODY_END(mode, pi, current_pos(yyleng));
2157  SET_PROC_END(mode, pi, current_pos(yyleng));
2158  #if YYLPDEBUG > 1
2159  printf("-%d\n", current_pos(0));
2160  #endif
2161  BEGIN(INITIAL);
2162  }
2163  }
2164  YY_BREAK
2165 case 58:
2167 #line 682 "libparse.l"
2168 {
2169  brace2++; /* printf("%s", yytext); */
2170  }
2171  YY_BREAK
2172 case 59:
2174 #line 685 "libparse.l"
2175 {
2176  brace2--; /* printf("%s", yytext); */
2177  if(brace2<0) {
2179  return(1);
2180  }
2181  }
2182  YY_BREAK
2183 case 60:
2185 #line 692 "libparse.l"
2186 {
2187  brace3++; /* printf("%s", yytext); */
2188  }
2189  YY_BREAK
2190 case 61:
2192 #line 695 "libparse.l"
2193 {
2194  brace3--; /* printf("%s", yytext); */
2195  if(brace3<0) {
2197  return(1);
2198  }
2199  }
2200  YY_BREAK
2201 case 62:
2203 #line 702 "libparse.l"
2204 { yylplineno++; }
2205  YY_BREAK
2206 case 63:
2208 #line 703 "libparse.l"
2209 { }
2210  YY_BREAK
2211 case 64:
2213 #line 705 "libparse.l"
2214 {
2215  quote++; BEGIN(string);
2216  found_info++;
2218  *lib_style = NEW_LIBSTYLE;
2219  last_cmd = LP_INFO;
2220  }
2221  YY_BREAK
2222 case 65:
2224 #line 712 "libparse.l"
2225 { yylplineno++; }
2226  YY_BREAK
2227 case 66:
2229 #line 713 "libparse.l"
2230 { }
2231  YY_BREAK
2232 case 67:
2234 #line 715 "libparse.l"
2235 {
2236  quote++; BEGIN(string);
2237  found_cat++;
2239  *lib_style = NEW_LIBSTYLE;
2241  }
2242  YY_BREAK
2243 case 68:
2245 #line 722 "libparse.l"
2246 { yylplineno++; }
2247  YY_BREAK
2248 case 69:
2250 #line 723 "libparse.l"
2251 { }
2252  YY_BREAK
2253 case 70:
2255 #line 726 "libparse.l"
2256 { quote--;
2257  copy_string(mode);
2258  last_cmd = LP_NONE;
2259  if(old_state==phelp)
2260  {
2261  SET_HELP_END(mode, pi, current_pos(0));
2262  }
2263  BEGIN(old_state); /* printf("%s", yytext); */
2264  }
2265  YY_BREAK
2266 case 71:
2268 #line 735 "libparse.l"
2269 { if (old_state == phelp) IncrCheckSum(*yytext);}
2270  YY_BREAK
2271 case 72:
2273 #line 736 "libparse.l"
2274 { yylplineno++; if (old_state == phelp) IncrCheckSum('\n');}
2275  YY_BREAK
2276 case 73:
2278 #line 737 "libparse.l"
2279 { if (old_state == phelp) IncrCheckSum(*yytext);}
2280  YY_BREAK
2281 case 74:
2283 #line 739 "libparse.l"
2284 { }
2285  YY_BREAK
2286 case 75:
2288 #line 740 "libparse.l"
2289 { quote++; old_state = YYSTATE;
2290  BEGIN(string); /* printf("%s", yytext); */
2291  }
2292  YY_BREAK
2293 case 76:
2295 #line 743 "libparse.l"
2296 {
2297  brace1++; /* printf("(%d)%s", brace1, yytext); */
2298  }
2299  YY_BREAK
2300 case 77:
2302 #line 746 "libparse.l"
2303 {
2304  brace1--; /* printf("(%d)%s", brace1, yytext); */
2305  if(brace1<=0) {
2306  if(brace2>0) { yylp_errno=YYLP_EX_BR2; return(1); }
2307  if(brace3>0) { yylp_errno=YYLP_EX_BR3; return(1); }
2308  BEGIN(INITIAL);
2309  SET_PROC_END(mode, pi, current_pos(yyleng));
2310  }
2311  }
2312  YY_BREAK
2313 case 78:
2315 #line 755 "libparse.l"
2316 {
2317  brace2++; /* printf("%s", yytext); */
2318  }
2319  YY_BREAK
2320 case 79:
2322 #line 758 "libparse.l"
2323 {
2324  brace2--; /* printf("%s", yytext); */
2325  }
2326  YY_BREAK
2327 case 80:
2329 #line 761 "libparse.l"
2330 {
2331  brace3++; /* printf("%s", yytext); */
2332  }
2333  YY_BREAK
2334 case 81:
2336 #line 764 "libparse.l"
2337 {
2338  brace3--; /* printf("%s", yytext); */
2339  }
2340  YY_BREAK
2341 case 82:
2343 #line 767 "libparse.l"
2344 { yylplineno++; }
2345  YY_BREAK
2346 case 83:
2348 #line 768 "libparse.l"
2349 { }
2350  YY_BREAK
2351 case 84:
2353 #line 770 "libparse.l"
2354 { quote--;
2355  BEGIN(pexample); /* printf("%s", yytext); */
2356  }
2357  YY_BREAK
2358 case 85:
2360 #line 773 "libparse.l"
2361 { }
2362  YY_BREAK
2363 case 86:
2365 #line 774 "libparse.l"
2366 { }
2367  YY_BREAK
2368 case 87:
2370 #line 775 "libparse.l"
2371 { yylplineno++; }
2372  YY_BREAK
2373 case 88:
2375 #line 776 "libparse.l"
2376 { }
2377  YY_BREAK
2378 case 89:
2380 #line 778 "libparse.l"
2381 { BEGIN(old_state); }
2382  YY_BREAK
2383 case 90:
2385 #line 779 "libparse.l"
2386 { yylplineno++; }
2387  YY_BREAK
2388 case 91:
2390 #line 780 "libparse.l"
2391 { }
2392  YY_BREAK
2393 case 92:
2395 #line 782 "libparse.l"
2396 { yylplineno++; }
2397  YY_BREAK
2398 case 93:
2400 #line 783 "libparse.l"
2401 { }
2402  YY_BREAK
2403 case 94:
2405 #line 784 "libparse.l"
2406 { p_static = FALSE;
2407  #if YYLPDEBUG > 1
2408  printf("%s", yytext);
2409  #endif
2410  }
2411  YY_BREAK
2412 case 95:
2414 #line 789 "libparse.l"
2415 { p_static = FALSE;
2417  #ifdef STANDALONE_PARSER
2418  printf("[%d]", *yytext);
2419  #else
2423  #endif
2424  #if YYLPDEBUG > 1
2425  printf("[%s]", yytext);
2426  #endif
2427  return(1);
2428  }
2429  YY_BREAK
2430 case 96:
2432 #line 804 "libparse.l"
2433 ECHO;
2434  YY_BREAK
2435 case YY_STATE_EOF(INITIAL):
2436 case YY_STATE_EOF(header):
2437 case YY_STATE_EOF(help):
2438 case YY_STATE_EOF(libcmd):
2439 case YY_STATE_EOF(libcmd2):
2440 case YY_STATE_EOF(pdef):
2441 case YY_STATE_EOF(phead):
2442 case YY_STATE_EOF(poldhelp):
2443 case YY_STATE_EOF(phelp):
2444 case YY_STATE_EOF(pbody):
2445 case YY_STATE_EOF(pstr):
2446 case YY_STATE_EOF(pexample):
2447 case YY_STATE_EOF(pestr):
2448 case YY_STATE_EOF(string):
2449 case YY_STATE_EOF(comment):
2450 case YY_STATE_EOF(info):
2451 case YY_STATE_EOF(category):
2452 case YY_STATE_EOF(url):
2453 case YY_STATE_EOF(version):
2454  yyterminate();
2455 
2456  case YY_END_OF_BUFFER:
2457  {
2458  /* Amount of text matched not including the EOB char. */
2459  int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2460 
2461  /* Undo the effects of YY_DO_BEFORE_ACTION. */
2462  *yy_cp = yy_hold_char;
2464 
2465  if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2466  {
2467  /* We're scanning a new file or input source. It's
2468  * possible that this happened because the user
2469  * just pointed yyin at a new source and called
2470  * yylex(). If so, then we have to assure
2471  * consistency between yy_current_buffer and our
2472  * globals. Here is the right place to do so, because
2473  * this is the first action (other than possibly a
2474  * back-up) that will match for the new input source.
2475  */
2476  yy_n_chars = yy_current_buffer->yy_n_chars;
2477  yy_current_buffer->yy_input_file = yyin;
2478  yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2479  }
2480 
2481  /* Note that here we test for yy_c_buf_p "<=" to the position
2482  * of the first EOB in the buffer, since yy_c_buf_p will
2483  * already have been incremented past the NUL character
2484  * (since all states make transitions on EOB to the
2485  * end-of-buffer state). Contrast this with the test
2486  * in input().
2487  */
2488  if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2489  { /* This was really a NUL. */
2490  yy_state_type yy_next_state;
2491 
2492  yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2493 
2494  yy_current_state = yy_get_previous_state();
2495 
2496  /* Okay, we're now positioned to make the NUL
2497  * transition. We couldn't have
2498  * yy_get_previous_state() go ahead and do it
2499  * for us because it doesn't know how to deal
2500  * with the possibility of jamming (and we don't
2501  * want to build jamming into it because then it
2502  * will run more slowly).
2503  */
2504 
2505  yy_next_state = yy_try_NUL_trans( yy_current_state );
2506 
2508 
2509  if ( yy_next_state )
2510  {
2511  /* Consume the NUL. */
2512  yy_cp = ++yy_c_buf_p;
2513  yy_current_state = yy_next_state;
2514  goto yy_match;
2515  }
2516 
2517  else
2518  {
2520  yy_current_state = yy_last_accepting_state;
2521  goto yy_find_action;
2522  }
2523  }
2524 
2525  else switch ( yy_get_next_buffer() )
2526  {
2527  case EOB_ACT_END_OF_FILE:
2528  {
2530 
2531  if ( yywrap() )
2532  {
2533  /* Note: because we've taken care in
2534  * yy_get_next_buffer() to have set up
2535  * yytext, we can now set up
2536  * yy_c_buf_p so that if some total
2537  * hoser (like flex itself) wants to
2538  * call the scanner after we return the
2539  * YY_NULL, it'll still work - another
2540  * YY_NULL will get returned.
2541  */
2543 
2545  goto do_action;
2546  }
2547 
2548  else
2549  {
2551  YY_NEW_FILE;
2552  }
2553  break;
2554  }
2555 
2556  case EOB_ACT_CONTINUE_SCAN:
2557  yy_c_buf_p =
2558  yytext_ptr + yy_amount_of_matched_text;
2559 
2560  yy_current_state = yy_get_previous_state();
2561 
2562  yy_cp = yy_c_buf_p;
2564  goto yy_match;
2565 
2566  case EOB_ACT_LAST_MATCH:
2567  yy_c_buf_p =
2568  &yy_current_buffer->yy_ch_buf[yy_n_chars];
2569 
2570  yy_current_state = yy_get_previous_state();
2571 
2572  yy_cp = yy_c_buf_p;
2574  goto yy_find_action;
2575  }
2576  break;
2577  }
2578 
2579  default:
2581  "fatal flex scanner internal error--no action found" );
2582  } /* end of action switch */
2583  } /* end of scanning one token */

◆ yy_create_buffer()

YY_BUFFER_STATE yy_create_buffer ( FILE *  file,
int  size 
)

Definition at line 2969 of file libparse.cc.

2975  {
2976  YY_BUFFER_STATE b;
2977 
2978  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2979  if ( ! b )
2980  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2981 
2982  b->yy_buf_size = size;
2983 
2984  /* yy_ch_buf has to be 2 characters longer than the size given because
2985  * we need to put in 2 end-of-buffer characters.
2986  */
2987  b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2988  if ( ! b->yy_ch_buf )
2989  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2990 
2991  b->yy_is_our_buffer = 1;
2992 
2993  yy_init_buffer( b, file );
2994 
2995  return b;
2996  }

◆ yy_delete_buffer()

void yy_delete_buffer ( YY_BUFFER_STATE  b)

Definition at line 3000 of file libparse.cc.

3005  {
3006  if ( ! b )
3007  return;
3008 
3009  if ( b == yy_current_buffer )
3010  yy_current_buffer = (YY_BUFFER_STATE) 0;
3011 
3012  if ( b->yy_is_our_buffer )
3013  yy_flex_free( (void *) b->yy_ch_buf );
3014 
3015  yy_flex_free( (void *) b );
3016  }

◆ yy_fatal_error()

static void yy_fatal_error ( yyconst char  msg[])
static

Definition at line 3233 of file libparse.cc.

3238  {
3239  (void) fprintf( stderr, "%s\n", msg );
3240  exit( YY_EXIT_FAILURE );
3241  }

◆ yy_flex_alloc()

static void* yy_flex_alloc ( yy_size_t  size)
static

Definition at line 3297 of file libparse.cc.

3302  {
3303  return (void *) malloc( size );
3304  }

◆ yy_flex_free()

static void yy_flex_free ( void *  ptr)
static

Definition at line 3325 of file libparse.cc.

3330  {
3331  free( ptr );
3332  }

◆ yy_flex_realloc()

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

Definition at line 3307 of file libparse.cc.

3313  {
3314  /* The cast to (char *) in the following accommodates both
3315  * implementations that use char* generic pointers, and those
3316  * that use void* generic pointers. It works with the latter
3317  * because both ANSI C and C++ allow castless assignment from
3318  * any pointer type to void*, and deal with argument conversions
3319  * as though doing an assignment.
3320  */
3321  return (void *) realloc( (char *) ptr, size );
3322  }

◆ yy_flush_buffer()

void yy_flush_buffer ( YY_BUFFER_STATE  b)

Definition at line 3053 of file libparse.cc.

3059  {
3060  if ( ! b )
3061  return;
3062 
3063  b->yy_n_chars = 0;
3064 
3065  /* We always need two end-of-buffer characters. The first causes
3066  * a transition to the end-of-buffer state. The second causes
3067  * a jam in that state.
3068  */
3069  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
3070  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
3071 
3072  b->yy_buf_pos = &b->yy_ch_buf[0];
3073 
3074  b->yy_at_bol = 1;
3075  b->yy_buffer_status = YY_BUFFER_NEW;
3076 
3077  if ( b == yy_current_buffer )
3079  }

◆ yy_get_next_buffer()

static int yy_get_next_buffer ( )
static

Definition at line 2595 of file libparse.cc.

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

◆ yy_get_previous_state()

static yy_state_type yy_get_previous_state ( )
static

Definition at line 2727 of file libparse.cc.

2728  {
2729  register yy_state_type yy_current_state;
2730  register char *yy_cp;
2731 
2732  yy_current_state = yy_start;
2733  yy_current_state += YY_AT_BOL();
2734 
2735  for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2736  {
2737  register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2738  if ( yy_accept[yy_current_state] )
2739  {
2740  yy_last_accepting_state = yy_current_state;
2742  }
2743  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2744  {
2745  yy_current_state = (int) yy_def[yy_current_state];
2746  if ( yy_current_state >= 485 )
2747  yy_c = yy_meta[(unsigned int) yy_c];
2748  }
2749  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2750  }
2751 
2752  return yy_current_state;
2753  }

◆ yy_init_buffer()

void yy_init_buffer ( YY_BUFFER_STATE  b,
FILE *  file 
)

Definition at line 3026 of file libparse.cc.

3034  {
3035  yy_flush_buffer( b );
3036 
3037  b->yy_input_file = file;
3038  b->yy_fill_buffer = 1;
3039 
3040 #if YY_ALWAYS_INTERACTIVE
3041  b->yy_is_interactive = 1;
3042 #else
3043 #if YY_NEVER_INTERACTIVE
3044  b->yy_is_interactive = 0;
3045 #else
3046  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
3047 #endif
3048 #endif
3049  }

◆ YY_PROTO() [1/16]

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

◆ YY_PROTO() [2/16]

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

◆ YY_PROTO() [3/16]

void yyrestart YY_PROTO ( (FILE *input_file)  )

◆ YY_PROTO() [4/16]

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

◆ YY_PROTO() [5/16]

int isatty YY_PROTO ( (int)  )

◆ YY_PROTO() [6/16]

static void yy_flex_free YY_PROTO ( (void *)  )
static

◆ YY_PROTO() [7/16]

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

◆ YY_PROTO() [8/16]

static int yyinput YY_PROTO ( (void)  )

◆ YY_PROTO() [9/16]

void yy_flush_buffer YY_PROTO ( (YY_BUFFER_STATE b )

◆ YY_PROTO() [10/16]

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

◆ YY_PROTO() [11/16]

void yy_switch_to_buffer YY_PROTO ( (YY_BUFFER_STATE new_buffer)  )

◆ YY_PROTO() [12/16]

static void* yy_flex_alloc YY_PROTO ( (yy_size_t )
static

◆ YY_PROTO() [13/16]

static yy_state_type yy_try_NUL_trans YY_PROTO ( (yy_state_type current_state)  )
static

◆ YY_PROTO() [14/16]

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

◆ YY_PROTO() [15/16]

YY_BUFFER_STATE yy_scan_string YY_PROTO ( (yyconst char *yy_str)  )

◆ YY_PROTO() [16/16]

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 3084 of file libparse.cc.

3090  {
3091  YY_BUFFER_STATE b;
3092 
3093  if ( size < 2 ||
3096  /* They forgot to leave room for the EOB's. */
3097  return 0;
3098 
3099  b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
3100  if ( ! b )
3101  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
3102 
3103  b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
3104  b->yy_buf_pos = b->yy_ch_buf = base;
3105  b->yy_is_our_buffer = 0;
3106  b->yy_input_file = 0;
3107  b->yy_n_chars = b->yy_buf_size;
3108  b->yy_is_interactive = 0;
3109  b->yy_at_bol = 1;
3110  b->yy_fill_buffer = 0;
3111  b->yy_buffer_status = YY_BUFFER_NEW;
3112 
3114 
3115  return b;
3116  }

◆ yy_scan_bytes()

YY_BUFFER_STATE yy_scan_bytes ( yyconst char *  bytes,
int  len 
)

Definition at line 3139 of file libparse.cc.

3145  {
3146  YY_BUFFER_STATE b;
3147  char *buf;
3148  yy_size_t n;
3149  int i;
3150 
3151  /* Get memory for full buffer, including space for trailing EOB's. */
3152  n = len + 2;
3153  buf = (char *) yy_flex_alloc( n );
3154  if ( ! buf )
3155  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
3156 
3157  for ( i = 0; i < len; ++i )
3158  buf[i] = bytes[i];
3159 
3160  buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
3161 
3162  b = yy_scan_buffer( buf, n );
3163  if ( ! b )
3164  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
3165 
3166  /* It's okay to grow etc. this buffer, and we should throw it
3167  * away when we're done.
3168  */
3169  b->yy_is_our_buffer = 1;
3170 
3171  return b;
3172  }

◆ yy_scan_string()

YY_BUFFER_STATE yy_scan_string ( yyconst char *  yy_str)

Definition at line 3122 of file libparse.cc.

3127  {
3128  int len;
3129  for ( len = 0; yy_str[len]; ++len )
3130  ;
3131 
3132  return yy_scan_bytes( yy_str, len );
3133  }

◆ yy_switch_to_buffer()

void yy_switch_to_buffer ( YY_BUFFER_STATE  new_buffer)

Definition at line 2926 of file libparse.cc.

2931  {
2932  if ( yy_current_buffer == new_buffer )
2933  return;
2934 
2935  if ( yy_current_buffer )
2936  {
2937  /* Flush out information for old buffer. */
2939  yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2940  yy_current_buffer->yy_n_chars = yy_n_chars;
2941  }
2942 
2943  yy_current_buffer = new_buffer;
2945 
2946  /* We don't actually know whether we did this switch during
2947  * EOF (yywrap()) processing, but the only time this flag
2948  * is looked at is after yywrap() is called, so it's safe
2949  * to go ahead and always set it.
2950  */
2952  }

◆ yy_try_NUL_trans()

static yy_state_type yy_try_NUL_trans ( yy_state_type  yy_current_state)
static

Definition at line 2763 of file libparse.cc.

2768  {
2769  register int yy_is_jam;
2770  register char *yy_cp = yy_c_buf_p;
2771 
2772  register YY_CHAR yy_c = 1;
2773  if ( yy_accept[yy_current_state] )
2774  {
2775  yy_last_accepting_state = yy_current_state;
2777  }
2778  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2779  {
2780  yy_current_state = (int) yy_def[yy_current_state];
2781  if ( yy_current_state >= 485 )
2782  yy_c = yy_meta[(unsigned int) yy_c];
2783  }
2784  yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2785  yy_is_jam = (yy_current_state == 484);
2786 
2787  return yy_is_jam ? 0 : yy_current_state;
2788  }

◆ yyinput()

static int yyinput ( )
static

Definition at line 2837 of file libparse.cc.

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

◆ yylpwrap()

int yylpwrap ( )

Definition at line 3362 of file libparse.cc.

3363  {
3364  //printf("======================= YYWRAP ====================\n");
3365  if(brace1>0) { yylp_errno=YYLP_MISS_BR1; }
3366  if(brace2>0) { yylp_errno=YYLP_MISS_BR2; }
3367  if(brace3>0) { yylp_errno=YYLP_MISS_BR3; }
3368  if(quote>0) { yylp_errno=YYLP_MISSQUOT; }
3369  //printf("{=%d, (=%d, [=%d\n", brace1, brace2, brace3);
3370  if(feof(yyin)) return 1; else return 0;
3371  }

◆ yyrestart()

void yyrestart ( FILE *  input_file)

Definition at line 2911 of file libparse.cc.

2916  {
2917  if ( ! yy_current_buffer )
2919 
2920  yy_init_buffer( yy_current_buffer, input_file );
2922  }

◆ yyunput()

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

Definition at line 2793 of file libparse.cc.

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

Variable Documentation

◆ brace1

int brace1 = 0

Definition at line 1087 of file libparse.cc.

◆ brace2

int brace2 = 0

Definition at line 1088 of file libparse.cc.

◆ brace3

int brace3 = 0

Definition at line 1089 of file libparse.cc.

◆ check

int check = 0

Definition at line 1104 of file libparse.cc.

◆ found_cat

int found_cat =0

Definition at line 1107 of file libparse.cc.

◆ found_info

int found_info =0

Definition at line 1106 of file libparse.cc.

◆ found_oldhelp

int found_oldhelp = 0

Definition at line 1109 of file libparse.cc.

◆ found_proc_in_proc

int found_proc_in_proc = 0

Definition at line 1110 of file libparse.cc.

◆ found_version

int found_version =0

Definition at line 1108 of file libparse.cc.

◆ h0

idhdl h0

Definition at line 1141 of file libparse.cc.

◆ h_top

idhdl h_top

Definition at line 1142 of file libparse.cc.

◆ help_chksum

unsigned long help_chksum
static

Definition at line 1151 of file libparse.cc.

◆ last_cmd

lib_cmds last_cmd = LP_NONE

Definition at line 1094 of file libparse.cc.

◆ libnamebuf

char libnamebuf[1024]

Definition at line 1096 of file libparse.cc.

◆ library_stack

libstackv library_stack
extern

Definition at line 65 of file iplib.cc.

◆ lpverbose

int lpverbose = 0

Definition at line 1104 of file libparse.cc.

◆ offset

int offset = 0

Definition at line 1091 of file libparse.cc.

◆ old_state

int old_state = 0

Definition at line 1093 of file libparse.cc.

◆ p_static

BOOLEAN p_static = FALSE

Definition at line 1092 of file libparse.cc.

◆ quote

int quote = 0

Definition at line 1090 of file libparse.cc.

◆ string_start

long string_start

Definition at line 1098 of file libparse.cc.

◆ texinfo_out

int texinfo_out = 0

Definition at line 1105 of file libparse.cc.

◆ text_buffer

char* text_buffer =NULL

Definition at line 1097 of file libparse.cc.

◆ yy_accept

yyconst short int yy_accept[485]
static

Definition at line 306 of file libparse.cc.

◆ yy_act

register int yy_act

Definition at line 1413 of file libparse.cc.

◆ yy_base

yyconst short int yy_base[533]
static

Definition at line 405 of file libparse.cc.

◆ yy_bp

register char * yy_bp

Definition at line 1412 of file libparse.cc.

◆ yy_c_buf_p

char* yy_c_buf_p = (char *) 0
static

Definition at line 237 of file libparse.cc.

◆ yy_chk

yyconst short int yy_chk[2253]
static

Definition at line 783 of file libparse.cc.

◆ yy_cp

register char* yy_cp

Definition at line 1412 of file libparse.cc.

◆ yy_current_buffer

YY_BUFFER_STATE yy_current_buffer = 0
static

Definition at line 219 of file libparse.cc.

◆ YY_DECL

YY_DECL
Initial value:
{
register yy_state_type yy_current_state

Definition at line 1409 of file libparse.cc.

◆ yy_def

yyconst short int yy_def[533]
static

Definition at line 468 of file libparse.cc.

◆ yy_did_buffer_switch_on_eof

int yy_did_buffer_switch_on_eof
static

Definition at line 244 of file libparse.cc.

◆ yy_ec

yyconst int yy_ec[256]
static

Definition at line 363 of file libparse.cc.

◆ yy_hold_char

char yy_hold_char
static

Definition at line 229 of file libparse.cc.

◆ yy_init

int yy_init = 1
static

Definition at line 238 of file libparse.cc.

◆ yy_last_accepting_cpos

char* yy_last_accepting_cpos
static

Definition at line 1036 of file libparse.cc.

◆ yy_last_accepting_state

yy_state_type yy_last_accepting_state
static

Definition at line 1035 of file libparse.cc.

◆ yy_meta

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.

◆ yy_more_flag

int yy_more_flag = 0
static

Definition at line 1042 of file libparse.cc.

◆ yy_more_len

int yy_more_len = 0
static

Definition at line 1043 of file libparse.cc.

◆ yy_n_chars

int yy_n_chars
static

Definition at line 231 of file libparse.cc.

◆ yy_nxt

yyconst short int yy_nxt[2253]
static

Definition at line 531 of file libparse.cc.

◆ yy_start

int yy_start = 0
static

Definition at line 239 of file libparse.cc.

◆ yyin

FILE* yyin = (FILE *) 0

Definition at line 283 of file libparse.cc.

◆ yyleng

int yyleng

Definition at line 234 of file libparse.cc.

◆ yylp_buffer_start

char* yylp_buffer_start

Definition at line 1100 of file libparse.cc.

◆ yylp_errlist

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.",
}

Definition at line 1112 of file libparse.cc.

◆ yylp_errno

int yylp_errno = 0

Definition at line 1128 of file libparse.cc.

◆ yylplineno

int yylplineno = 1

Definition at line 1102 of file libparse.cc.

◆ yyout

FILE * yyout = (FILE *) 0

Definition at line 120 of file libparse.cc.

◆ yytext

char* yytext

Definition at line 1047 of file libparse.cc.

YYLP_BODY_BR3
#define YYLP_BODY_BR3
Definition: libparse.h:88
yy_accept
static yyconst short int yy_accept[485]
Definition: libparse.cc:306
FALSE
#define FALSE
Definition: auxiliary.h:94
yy_buffer_state
Definition: libparse.cc:163
YYLP_MISS_BR2
#define YYLP_MISS_BR2
Definition: libparse.h:96
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: libparse.cc:305
yyinput
static int yyinput()
Definition: libparse.cc:2837
SET_HELP_END
#define SET_HELP_END(mode, pi, p)
Definition: libparse.cc:1157
lp_modes
lp_modes
Definition: libparse.h:10
SEEK_SET
#define SEEK_SET
Definition: mod2.h:116
help_chksum
static unsigned long help_chksum
Definition: libparse.cc:1151
f
FILE * f
Definition: checklibs.c:9
omFree
#define omFree(addr)
Definition: omAllocDecl.h:261
yy_init_buffer
#define yy_init_buffer
Definition: libparse.cc:7
yy_more_flag
static int yy_more_flag
Definition: libparse.cc:1042
yy_chk
static yyconst short int yy_chk[2253]
Definition: libparse.cc:783
yy_base
static yyconst short int yy_base[533]
Definition: libparse.cc:405
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: libparse.cc:1045
YYLP_EX_BR3
#define YYLP_EX_BR3
Definition: libparse.h:92
YY_USER_INIT
#define YY_USER_INIT
Definition: libparse.cc:1208
LP_VERSION
@ LP_VERSION
Definition: libparse.cc:1079
SET_PROC_END
#define SET_PROC_END(mode, pi, p)
Definition: libparse.cc:1180
yy_start
static int yy_start
Definition: libparse.cc:239
yy_get_next_buffer
static int yy_get_next_buffer()
Definition: libparse.cc:2595
yy_act
register int yy_act
Definition: libparse.cc:1413
result
return result
Definition: facAbsBiFact.cc:76
version
#define version
Definition: libparse.cc:1260
string_start
long string_start
Definition: libparse.cc:1098
copy_string
void copy_string(lp_modes mode)
Definition: libparse.cc:3404
YYLP_BODY_BR2
#define YYLP_BODY_BR2
Definition: libparse.h:87
ADDRESS
void * ADDRESS
Definition: auxiliary.h:133
OLD_LIBSTYLE
@ OLD_LIBSTYLE
Definition: libparse.h:9
enterid
idhdl enterid(const char *s, int lev, int t, idhdl *root, BOOLEAN init, BOOLEAN search)
Definition: ipid.cc:267
YYLP_EX_BR2
#define YYLP_EX_BR2
Definition: libparse.h:91
YY_BREAK
#define YY_BREAK
Definition: libparse.cc:1400
YYLP_MISSQUOT
#define YYLP_MISSQUOT
Definition: libparse.h:94
CxxTest::base
char N base
Definition: ValueTraits.h:144
h0
idhdl h0
Definition: libparse.cc:1141
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: libparse.cc:244
info
#define info
Definition: libparse.cc:1254
current_pos
int current_pos(int i)
Definition: libparse.cc:3344
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: libparse.cc:107
pexample
#define pexample
Definition: libparse.cc:1246
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: libparse.cc:296
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: libparse.cc:1046
SET_BODY_END
#define SET_BODY_END(mode, pi, p)
Definition: libparse.cc:1167
yy_bp
register char * yy_bp
Definition: libparse.cc:1412
procinfo
Definition: subexpr.h:54
yy_flex_realloc
static void * yy_flex_realloc(void *ptr, yy_size_t size)
Definition: libparse.cc:3307
lib_cmds
lib_cmds
Definition: libparse.cc:1079
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: libparse.cc:115
omStrDup
#define omStrDup(s)
Definition: omAllocDecl.h:263
brace3
int brace3
Definition: libparse.cc:1089
yyless
#define yyless(n)
Definition: libparse.cc:3248
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: libparse.cc:1332
BEGIN
#define BEGIN
Definition: libparse.cc:97
yytext
#define yytext
Definition: libparse.cc:16
V_LOAD_LIB
#define V_LOAD_LIB
Definition: options.h:47
pestr
#define pestr
Definition: libparse.cc:1248
h_top
idhdl h_top
Definition: libparse.cc:1142
ECHO
#define ECHO
Definition: libparse.cc:1341
currPack
package currPack
Definition: ipid.cc:59
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: libparse.cc:1381
YYLP_BODY_TMBR3
#define YYLP_BODY_TMBR3
Definition: libparse.h:90
header
#define header
Definition: libparse.cc:1226
yylplineno
int yylplineno
Definition: libparse.cc:1102
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: libparse.cc:1203
b
CanonicalForm b
Definition: cfModGcd.cc:4044
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: libparse.cc:112
libstack::push
void push(const char *p, char *libname)
Definition: iplib.cc:1401
NEW_LIBSTYLE
@ NEW_LIBSTYLE
Definition: libparse.h:9
YYLP_BAD_CHAR
#define YYLP_BAD_CHAR
Definition: libparse.h:93
IncrCheckSum
#define IncrCheckSum(c)
Definition: libparse.cc:1189
found_info
int found_info
Definition: libparse.cc:1106
yy_flex_free
static void yy_flex_free(void *ptr)
Definition: libparse.cc:3325
pi
#define pi
Definition: libparse.cc:1143
url
#define url
Definition: libparse.cc:1258
yylex
#define yylex
Definition: libparse.cc:13
TRUE
#define TRUE
Definition: auxiliary.h:98
yylp_errno
int yylp_errno
Definition: libparse.cc:1128
i
int i
Definition: cfEzgcd.cc:125
found_oldhelp
int found_oldhelp
Definition: libparse.cc:1109
yy_last_accepting_state
static yy_state_type yy_last_accepting_state
Definition: libparse.cc:1035
yy_more_len
static int yy_more_len
Definition: libparse.cc:1043
buf
int status int void * buf
Definition: si_signals.h:59
YY_CHAR
unsigned char YY_CHAR
Definition: libparse.cc:282
yy_switch_to_buffer
#define yy_switch_to_buffer
Definition: libparse.cc:10
yylp_buffer_start
char * yylp_buffer_start
Definition: libparse.cc:1100
yy_load_buffer_state
#define yy_load_buffer_state
Definition: libparse.cc:9
BOOLEAN
int BOOLEAN
Definition: auxiliary.h:85
brace1
int brace1
Definition: libparse.cc:1087
yy_ec
static yyconst int yy_ec[256]
Definition: libparse.cc:363
YY_AT_BOL
#define YY_AT_BOL()
Definition: libparse.cc:280
PROC_CMD
@ PROC_CMD
Definition: grammar.cc:280
malloc
void * malloc(size_t size)
Definition: omalloc.c:92
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: libparse.cc:123
library_stack
libstackv library_stack
Definition: iplib.cc:65
found_version
int found_version
Definition: libparse.cc:1108
SET_EXAMPLE_START
#define SET_EXAMPLE_START(mode, pi, l, p)
Definition: libparse.cc:1174
yy_size_t
unsigned int yy_size_t
Definition: libparse.cc:159
yy_init
static int yy_init
Definition: libparse.cc:238
yy_flex_alloc
static void * yy_flex_alloc(yy_size_t size)
Definition: libparse.cc:3297
yy_state_type
int yy_state_type
Definition: libparse.cc:284
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: libparse.cc:216
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: libparse.cc:124
category
#define category
Definition: libparse.cc:1256
yy_last_accepting_cpos
static char * yy_last_accepting_cpos
Definition: libparse.cc:1036
size
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600
piKill
BOOLEAN piKill(procinfov pi)
Definition: ipid.cc:666
IDPROC
#define IDPROC(a)
Definition: ipid.h:135
YY_START
#define YY_START
Definition: libparse.cc:103
libread
int libread(FILE *f, char *buf, int max_size)
Definition: libparse.cc:3349
yy_current_buffer
static YY_BUFFER_STATE yy_current_buffer
Definition: libparse.cc:219
SET_HELP_START
#define SET_HELP_START(mode, pi, p)
Definition: libparse.cc:1155
omAlloc
#define omAlloc(size)
Definition: omAllocDecl.h:210
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: libparse.cc:91
yy_delete_buffer
#define yy_delete_buffer
Definition: libparse.cc:2
free
#define free
Definition: omAllocFunc.c:12
poldhelp
#define poldhelp
Definition: libparse.cc:1238
yy_c_buf_p
static char * yy_c_buf_p
Definition: libparse.cc:237
found_proc_in_proc
int found_proc_in_proc
Definition: libparse.cc:1110
old_state
int old_state
Definition: libparse.cc:1093
yy_n_chars
static int yy_n_chars
Definition: libparse.cc:231
YYLP_BODY_TMBR2
#define YYLP_BODY_TMBR2
Definition: libparse.h:89
LP_INFO
@ LP_INFO
Definition: libparse.cc:1079
yy_nxt
static yyconst short int yy_nxt[2253]
Definition: libparse.cc:531
LP_NONE
@ LP_NONE
Definition: libparse.cc:1079
yy_flush_buffer
#define yy_flush_buffer
Definition: libparse.cc:8
p_static
BOOLEAN p_static
Definition: libparse.cc:1092
yyin
#define yyin
Definition: libparse.cc:11
yymore
#define yymore()
Definition: libparse.cc:1044
help
#define help
Definition: libparse.cc:1228
realloc
#define realloc
Definition: omAllocFunc.c:14
yyleng
#define yyleng
Definition: libparse.cc:12
libnamebuf
char libnamebuf[1024]
Definition: libparse.cc:1096
V_LOAD_PROC
#define V_LOAD_PROC
Definition: options.h:49
yyrestart
#define yyrestart
Definition: libparse.cc:15
yyout
#define yyout
Definition: libparse.cc:14
INITIAL
#define INITIAL
Definition: libparse.cc:1049
yy_get_previous_state
static yy_state_type yy_get_previous_state()
Definition: libparse.cc:2727
idrec
Definition: idrec.h:35
iiInitSingularProcinfo
procinfo * iiInitSingularProcinfo(procinfov pi, const char *libname, const char *procname, int, long pos, BOOLEAN pstatic)
Definition: iplib.cc:991
YY_NEW_FILE
#define YY_NEW_FILE
Definition: libparse.cc:110
make_version
void make_version(char *p, int what)
Definition: libparse.cc:3384
yy_hold_char
static char yy_hold_char
Definition: libparse.cc:229
yy_scan_bytes
#define yy_scan_bytes
Definition: libparse.cc:5
YYSTATE
#define YYSTATE
Definition: libparse.cc:104
text_buffer
char * text_buffer
Definition: libparse.cc:1097
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: libparse.cc:3229
IDPACKAGE
#define IDPACKAGE(a)
Definition: ipid.h:134
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
Definition: libparse.cc:2763
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: libparse.cc:225
phelp
#define phelp
Definition: libparse.cc:1240
comment
#define comment
Definition: libparse.cc:1252
BVERBOSE
#define BVERBOSE(a)
Definition: options.h:35
Print
#define Print
Definition: emacs.cc:80
omMarkAsStaticAddr
void omMarkAsStaticAddr(void *addr)
lib_style_types
lib_style_types
Definition: libparse.h:9
yy_def
static yyconst short int yy_def[533]
Definition: libparse.cc:468
libcmd
#define libcmd
Definition: libparse.cc:1230
pbody
#define pbody
Definition: libparse.cc:1242
yy_create_buffer
#define yy_create_buffer
Definition: libparse.cc:1
basePack
package basePack
Definition: ipid.cc:60
YYLP_MISS_BR1
#define YYLP_MISS_BR1
Definition: libparse.h:95
yywrap
#define yywrap
Definition: libparse.cc:17
NULL
#define NULL
Definition: omList.c:10
string
#define string
Definition: libparse.cc:1250
check
int check
Definition: libparse.cc:1104
pstr
#define pstr
Definition: libparse.cc:1244
l
int l
Definition: cfEzgcd.cc:93
YYLP_MISS_BR3
#define YYLP_MISS_BR3
Definition: libparse.h:97
quote
int quote
Definition: libparse.cc:1090
LOAD_LIB
@ LOAD_LIB
Definition: libparse.h:10
phead
#define phead
Definition: libparse.cc:1236
Warn
#define Warn
Definition: emacs.cc:77
yyterminate
#define yyterminate()
Definition: libparse.cc:1371
GET_INFO
@ GET_INFO
Definition: libparse.h:10
lpverbose
int lpverbose
Definition: libparse.cc:1104
texinfo_out
int texinfo_out
Definition: libparse.cc:1105
brace2
int brace2
Definition: libparse.cc:1088
p
int p
Definition: cfModGcd.cc:4019
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: libparse.cc:1403
yytext_ptr
#define yytext_ptr
Definition: libparse.cc:286
offset
int offset
Definition: libparse.cc:1091
pdef
#define pdef
Definition: libparse.cc:1234
found_cat
int found_cat
Definition: libparse.cc:1107
last_cmd
lib_cmds last_cmd
Definition: libparse.cc:1094
proc
unsigned char * proc[NUM_PROC]
Definition: checklibs.c:16
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: libparse.cc:205
myfread
size_t myfread(void *ptr, size_t size, size_t nmemb, FILE *stream)
Definition: feFopen.cc:195
libcmd2
#define libcmd2
Definition: libparse.cc:1232
SET_BODY_START
#define SET_BODY_START(mode, pi, l, p)
Definition: libparse.cc:1161
yy_meta
static yyconst int yy_meta[53]
Definition: libparse.cc:395
LP_URL
@ LP_URL
Definition: libparse.cc:1079
SET_DEF_END
#define SET_DEF_END(mode, pi, p)
Definition: libparse.cc:1153
yy_cp
register char * yy_cp
Definition: libparse.cc:1412
yy_scan_buffer
#define yy_scan_buffer
Definition: libparse.cc:3
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: libparse.cc:122
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: libparse.cc:204
LP_CATEGORY
@ LP_CATEGORY
Definition: libparse.cc:1079
YYLP_DEF_BR2
#define YYLP_DEF_BR2
Definition: libparse.h:86