pplex.c File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "config.h"
#include <ctype.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "cobc.h"
#include "ppparse.h"

Include dependency graph for pplex.c:

Go to the source code of this file.

Data Structures
struct	yy_buffer_state
struct	yy_trans_info
struct	copy_info
struct	plex_stack

Macros
#define	YY_INT_ALIGNED   short int
#define	yy_create_buffer   pp_create_buffer
#define	yy_delete_buffer   pp_delete_buffer
#define	yy_flex_debug   pp_flex_debug
#define	yy_init_buffer   pp_init_buffer
#define	yy_flush_buffer   pp_flush_buffer
#define	yy_load_buffer_state   pp_load_buffer_state
#define	yy_switch_to_buffer   pp_switch_to_buffer
#define	yyin   ppin
#define	yyleng   ppleng
#define	yylex   pplex
#define	yylineno   pplineno
#define	yyout   ppout
#define	yyrestart   pprestart
#define	yytext   pptext
#define	yywrap   ppwrap
#define	yyalloc   ppalloc
#define	yyrealloc   pprealloc
#define	yyfree   ppfree
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   5
#define	YY_FLEX_SUBMINOR_VERSION   39
#define	FLEX_BETA
#define	FLEXINT_H
#define	INT8_MIN   (-128)
#define	INT16_MIN   (-32767-1)
#define	INT32_MIN   (-2147483647-1)
#define	INT8_MAX   (127)
#define	INT16_MAX   (32767)
#define	INT32_MAX   (2147483647)
#define	UINT8_MAX   (255U)
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	yyconst
#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   pprestart(ppin )
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   16384
#define	YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define	YY_TYPEDEF_YY_BUFFER_STATE
#define	YY_TYPEDEF_YY_SIZE_T
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	YY_LESS_LINENO(n)
#define	YY_LINENO_REWIND_TO(ptr)
#define	yyless(n)
#define	unput(c)   yyunput( c, (yytext_ptr) )
#define	YY_STRUCT_YY_BUFFER_STATE
#define	YY_BUFFER_NEW   0
#define	YY_BUFFER_NORMAL   1
#define	YY_BUFFER_EOF_PENDING   2
#define	YY_CURRENT_BUFFER
#define	YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define	YY_FLUSH_BUFFER   pp_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   pp_create_buffer
#define	yy_set_interactive(is_interactive)
#define	yy_set_bol(at_bol)
#define	YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define	yytext_ptr   pptext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   156
#define	YY_END_OF_BUFFER   157
#define	REJECT   reject_used_but_not_detected
#define	yymore()   yymore_used_but_not_detected
#define	YY_MORE_ADJ   0
#define	YY_RESTORE_YY_MORE_OFFSET
#define	YY_READ_BUF_SIZE   32768
#define	YY_BUF_SIZE   32768
#define	YY_SKIP_YYWRAP
#define	PPLEX_BUFF_LEN   512
#define	YY_INPUT(buf, result, max_size)   result = ppinput (buf, max_size);
#define	ECHO   fputs (pptext, ppout)
#define	YY_USER_INIT
#define	YY_NO_UNISTD_H   1
#define	COB_IN_PPLEX   1
#define	PLEX_COND_DEPTH   16
#define	INITIAL   0
#define	COPY_STATE   1
#define	PSEUDO_STATE   2
#define	SOURCE_DIRECTIVE_STATE   3
#define	DEFINE_DIRECTIVE_STATE   4
#define	SET_DIRECTIVE_STATE   5
#define	TURN_DIRECTIVE_STATE   6
#define	IF_DIRECTIVE_STATE   7
#define	ELSE_DIRECTIVE_STATE   8
#define	ENDIF_DIRECTIVE_STATE   9
#define	YY_EXTRA_TYPE   void *
#define	yyterminate()   return YY_NULL
#define	YY_START_STACK_INCR   25
#define	YY_FATAL_ERROR(msg)   yy_fatal_error( msg )
#define	YY_DECL_IS_OURS   1
#define	YY_DECL   int pplex (void)
#define	YY_USER_ACTION
#define	YY_BREAK   break;
#define	YY_RULE_SETUP
#define	YY_EXIT_FAILURE   2
#define	yyless(n)
#define	YYTABLES_NAME   "yytables"

Typedefs
typedef signed char	flex_int8_t
typedef short int	flex_int16_t
typedef int	flex_int32_t
typedef unsigned char	flex_uint8_t
typedef unsigned short int	flex_uint16_t
typedef unsigned int	flex_uint32_t
typedef struct yy_buffer_state *	YY_BUFFER_STATE
typedef size_t	yy_size_t
typedef unsigned char	YY_CHAR
typedef int	yy_state_type

Functions
void	pprestart (FILE *input_file)
	Immediately switch to a different input stream. More...
void	pp_switch_to_buffer (YY_BUFFER_STATE new_buffer)
	Switch to a different input buffer. More...
YY_BUFFER_STATE	pp_create_buffer (FILE *file, int size)
	Allocate and initialize an input buffer state. More...
void	pp_delete_buffer (YY_BUFFER_STATE b)
	Destroy the buffer. More...
void	pp_flush_buffer (YY_BUFFER_STATE b)
	Discard all buffered characters. More...
void	pppush_buffer_state (YY_BUFFER_STATE new_buffer)
	Pushes the new state onto the stack. More...
void	pppop_buffer_state (void)
	Removes and deletes the top of the stack, if present. More...
static void	ppensure_buffer_stack (void)
static void	pp_load_buffer_state (void)
static void	pp_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	pp_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	pp_scan_string (char *yy_str)
YY_BUFFER_STATE	pp_scan_bytes (char *bytes, yy_size_t len)
void *	ppalloc (yy_size_t)
void *	pprealloc (void *, yy_size_t)
void	ppfree (void *)
static yy_state_type	yy_get_previous_state (void)
static yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
static int	yy_get_next_buffer (void)
static void	yy_fatal_error (char msg[])
static int	ppwrap (void)
static int	ppinput (char *, const size_t)
static void	ppecho (const char *, const cob_u32_t, const int)
static void	switch_to_buffer (const int, const char *, const YY_BUFFER_STATE)
static void	check_listing (const char *, const unsigned int)
static void	skip_to_eol (void)
static void	display_to_eol (void)
static void	check_comments (const char *, const char *)
static int	yy_init_globals (void)
	Get the current token. More...
int	pplex_destroy (void)
static void	yyunput (int c, char *buf_ptr)
static int	input (void)
static void	yy_push_state (int new_state)
static void	yy_pop_state (void)
int	pplex (void)
	The main scanner function which does all the work. More...
static void	yyunput (int c, register char *yy_bp)
static void	yy_fatal_error (char *msg)
void	pp_set_replace_list (struct cb_replace_list *list, const cob_u32_t is_pushpop)
int	ppopen (const char *name, struct cb_replace_list *replacing_list)
int	ppcopy (const char *name, const char *lib, struct cb_replace_list *replace_list)
void	ppparse_error (const char *msg)
void	plex_clear_vars (void)
void	plex_clear_all (void)
void	plex_call_destroy (void)
void	plex_action_directive (const unsigned int cmdtype, const unsigned int is_true)
static struct cb_text_list *	pp_text_list_add (struct cb_text_list *list, const char *text, const size_t size)

Variables
yy_size_t	ppleng
FILE *	ppin = (FILE *) 0
FILE *	ppout = (FILE *) 0
static size_t	yy_buffer_stack_top = 0
	index of top of stack. More...
static size_t	yy_buffer_stack_max = 0
	capacity of stack. More...
static YY_BUFFER_STATE *	yy_buffer_stack = 0
	Stack as an array. More...
static char	yy_hold_char
static yy_size_t	yy_n_chars
static char *	yy_c_buf_p = (char *) 0
static int	yy_init = 0
static int	yy_start = 0
static int	yy_did_buffer_switch_on_eof
int	pplineno = 1
char *	pptext
static flex_int16_t	yy_accept [1082]
static flex_int32_t	yy_ec [256]
static flex_int32_t	yy_meta [74]
static flex_int16_t	yy_base [1183]
static flex_int16_t	yy_def [1183]
static flex_int16_t	yy_nxt [5374]
static flex_int16_t	yy_chk [5374]
static yy_state_type	yy_last_accepting_state
static char *	yy_last_accepting_cpos
int	pp_flex_debug = 0
static char *	plexbuff1 = ((void*)0)
static char *	plexbuff2 = ((void*)0)
static size_t	newline_count = 0
static size_t	within_comment = 0
static size_t	inside_bracket = 0
static size_t	consecutive_quotation = 0
static size_t	need_continuation = 0
static size_t	buffer_overflow = 0
static size_t	comment_allowed
static unsigned int	plex_skip_input = 0
static unsigned int	plex_nest_depth = 0
static int	quotation_mark = 0
static int	listing_line = 0
static int	requires_listing_line
static int	requires_new_line = 0
static struct cb_replace_list *	current_replace_list = ((void*)0)
static struct cb_replace_list *	save_current_replace = ((void*)0)
static struct cb_replace_list *	base_replace_list = ((void*)0)
static struct cb_text_list *	text_queue = ((void*)0)
static struct copy_info *	copy_stack = ((void*)0)
static struct plex_stack	plex_cond_stack [16]
static int	yy_start_stack_ptr = 0
static int	yy_start_stack_depth = 0
static int *	yy_start_stack = ((void*)0)

Macro Definition Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 146 of file pplex.c.

Referenced by pplex(), yy_pop_state(), and yy_push_state().

#define COB_IN_PPLEX   1

Definition at line 2101 of file pplex.c.

#define COPY_STATE   1

Definition at line 2178 of file pplex.c.

Referenced by pplex().

#define DEFINE_DIRECTIVE_STATE   4

Definition at line 2181 of file pplex.c.

Referenced by pplex().

#define ECHO   fputs (pptext, ppout)

Definition at line 2074 of file pplex.c.

Referenced by pplex().

#define ELSE_DIRECTIVE_STATE   8

Definition at line 2185 of file pplex.c.

Referenced by pplex().

#define ENDIF_DIRECTIVE_STATE   9

Definition at line 2186 of file pplex.c.

Referenced by pplex().

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 194 of file pplex.c.

Referenced by input(), pplex(), and yy_get_next_buffer().

#define EOB_ACT_END_OF_FILE   1

Definition at line 195 of file pplex.c.

Referenced by input(), pplex(), and yy_get_next_buffer().

#define EOB_ACT_LAST_MATCH   2

Definition at line 196 of file pplex.c.

Referenced by input(), pplex(), and yy_get_next_buffer().

#define FLEX_BETA

Definition at line 33 of file pplex.c.

#define FLEX_SCANNER

Definition at line 28 of file pplex.c.

#define FLEXINT_H

Definition at line 49 of file pplex.c.

#define IF_DIRECTIVE_STATE   7

Definition at line 2184 of file pplex.c.

Referenced by pplex().

#define INITIAL   0

Definition at line 2177 of file pplex.c.

Referenced by pplex().

#define INT16_MAX   (32767)

Definition at line 92 of file pplex.c.

#define INT16_MIN   (-32767-1)

Definition at line 83 of file pplex.c.

#define INT32_MAX   (2147483647)

Definition at line 95 of file pplex.c.

#define INT32_MIN   (-2147483647-1)

Definition at line 86 of file pplex.c.

#define INT8_MAX   (127)

Definition at line 89 of file pplex.c.

#define INT8_MIN   (-128)

Definition at line 80 of file pplex.c.

#define PLEX_COND_DEPTH   16

Definition at line 2105 of file pplex.c.

Referenced by plex_action_directive().

#define PPLEX_BUFF_LEN   512

Definition at line 2072 of file pplex.c.

Referenced by ppinput().

#define PSEUDO_STATE   2

Definition at line 2179 of file pplex.c.

Referenced by pplex().

#define REJECT   reject_used_but_not_detected

Definition at line 2036 of file pplex.c.

#define SET_DIRECTIVE_STATE   5

Definition at line 2182 of file pplex.c.

Referenced by pplex().

#define SOURCE_DIRECTIVE_STATE   3

Definition at line 2180 of file pplex.c.

Referenced by pplex().

#define TURN_DIRECTIVE_STATE   6

Definition at line 2183 of file pplex.c.

Referenced by pplex().

#define UINT16_MAX   (65535U)

Definition at line 101 of file pplex.c.

#define UINT32_MAX   (4294967295U)

Definition at line 104 of file pplex.c.

#define UINT8_MAX   (255U)

Definition at line 98 of file pplex.c.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 215 of file pplex.c.

Referenced by display_to_eol(), pplex(), and skip_to_eol().

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 361 of file pplex.c.

Referenced by pplex(), and yy_get_previous_state().

#define YY_BREAK   break;

Definition at line 2341 of file pplex.c.

Referenced by pplex().

#define YY_BUF_SIZE   16384

Definition at line 2065 of file pplex.c.

Referenced by pplex(), ppopen(), and pprestart().

#define YY_BUF_SIZE   32768

Definition at line 2065 of file pplex.c.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 277 of file pplex.c.

Referenced by yy_get_next_buffer().

#define YY_BUFFER_NEW   0

Definition at line 265 of file pplex.c.

Referenced by pp_flush_buffer(), and pplex().

#define YY_BUFFER_NORMAL   1

Definition at line 266 of file pplex.c.

Referenced by pplex().

#define yy_create_buffer   pp_create_buffer

Definition at line 9 of file pplex.c.

#define YY_CURRENT_BUFFER

Value:

( (yy_buffer_stack) \
                          ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
                          : NULL)

Definition at line 293 of file pplex.c.

Referenced by pp_delete_buffer(), pp_flush_buffer(), pp_init_buffer(), pp_switch_to_buffer(), pplex(), pplex_destroy(), ppopen(), pppop_buffer_state(), pppush_buffer_state(), and pprestart().

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 300 of file pplex.c.

Referenced by input(), pp_delete_buffer(), pp_load_buffer_state(), pp_switch_to_buffer(), pplex(), pplex_destroy(), pppop_buffer_state(), pppush_buffer_state(), pprestart(), yy_get_next_buffer(), and yyunput().

#define YY_DECL   int pplex (void)

Definition at line 2329 of file pplex.c.

#define YY_DECL_IS_OURS   1

Definition at line 2325 of file pplex.c.

#define yy_delete_buffer   pp_delete_buffer

Definition at line 10 of file pplex.c.

#define YY_DO_BEFORE_ACTION

Value:

(yytext_ptr) = yy_bp; \
	ppleng = (size_t) (yy_cp - yy_bp); \
    (yy_hold_char) = *yy_cp; \
    *yy_cp = '\0'; \
    (yy_c_buf_p) = yy_cp;

Definition at line 386 of file pplex.c.

Referenced by pplex().

#define YY_END_OF_BUFFER   157

Definition at line 394 of file pplex.c.

Referenced by pplex().

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 161 of file pplex.c.

Referenced by input(), pp_flush_buffer(), and yy_get_next_buffer().

#define YY_EXIT_FAILURE   2

Definition at line 4249 of file pplex.c.

Referenced by yy_fatal_error().

#define YY_EXTRA_TYPE   void *

Definition at line 2197 of file pplex.c.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 2316 of file pplex.c.

Referenced by pp_create_buffer(), ppensure_buffer_stack(), pplex(), yy_get_next_buffer(), yy_pop_state(), yy_push_state(), and yyunput().

int yy_flex_debug   pp_flex_debug

Definition at line 11 of file pplex.c.

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 29 of file pplex.c.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 30 of file pplex.c.

#define YY_FLEX_SUBMINOR_VERSION   39

Definition at line 31 of file pplex.c.

#define yy_flush_buffer   pp_flush_buffer

Definition at line 13 of file pplex.c.

#define YY_FLUSH_BUFFER   pp_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 329 of file pplex.c.

#define yy_init_buffer   pp_init_buffer

Definition at line 12 of file pplex.c.

#define YY_INPUT	(		buf,
			result,
			max_size
	)		result = ppinput (buf, max_size);

Definition at line 2073 of file pplex.c.

Referenced by yy_get_next_buffer().

#define YY_INT_ALIGNED   short int

Definition at line 5 of file pplex.c.

#define YY_LESS_LINENO

(

n

)

Definition at line 198 of file pplex.c.

#define YY_LINENO_REWIND_TO

(

ptr

)

Definition at line 199 of file pplex.c.

#define yy_load_buffer_state   pp_load_buffer_state

Definition at line 14 of file pplex.c.

#define YY_MORE_ADJ   0

Definition at line 2038 of file pplex.c.

Referenced by pplex(), yy_get_next_buffer(), and yy_get_previous_state().

#define yy_new_buffer   pp_create_buffer

Definition at line 339 of file pplex.c.

#define YY_NEW_FILE   pprestart(ppin )

Definition at line 159 of file pplex.c.

Referenced by input(), and pplex().

#define YY_NO_UNISTD_H   1

Definition at line 2094 of file pplex.c.

#define YY_NULL   0

Definition at line 133 of file pplex.c.

Referenced by ppinput().

#define YY_NUM_RULES   156

Definition at line 393 of file pplex.c.

#define YY_READ_BUF_SIZE   32768

Definition at line 2063 of file pplex.c.

Referenced by yy_get_next_buffer().

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 2039 of file pplex.c.

Referenced by pplex().

#define YY_RULE_SETUP

Value:

if ( ppleng > 0 ) \
		YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
                (pptext[ppleng - 1] == '\n'); \
	YY_USER_ACTION

Definition at line 2344 of file pplex.c.

Referenced by pplex().

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 140 of file pplex.c.

Referenced by pplex(), and yy_get_previous_state().

#define yy_set_bol

(

at_bol

)

Value:

{ \
    if ( ! YY_CURRENT_BUFFER ){\
        ppensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            pp_create_buffer(ppin,YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
    }

Definition at line 351 of file pplex.c.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
    if ( ! YY_CURRENT_BUFFER ){ \
        ppensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            pp_create_buffer(ppin,YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    }

Definition at line 341 of file pplex.c.

#define YY_SKIP_YYWRAP

Definition at line 2067 of file pplex.c.

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

Definition at line 152 of file pplex.c.

Referenced by pplex(), and yy_push_state().

#define YY_START_STACK_INCR   25

Definition at line 2311 of file pplex.c.

Referenced by yy_push_state().

#define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))

Definition at line 178 of file pplex.c.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 156 of file pplex.c.

Referenced by pplex().

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 218 of file pplex.c.

#define yy_switch_to_buffer   pp_switch_to_buffer

Definition at line 15 of file pplex.c.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 181 of file pplex.c.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 186 of file pplex.c.

#define YY_USER_ACTION

Definition at line 2336 of file pplex.c.

#define YY_USER_INIT

Value:

if (!plexbuff1) {                       \
		plexbuff1 = cobc_malloc ((size_t)COB_SMALL_BUFF); \
    }                               \
    if (!plexbuff2) {                       \
		plexbuff2 = cobc_malloc ((size_t)COB_SMALL_BUFF); \
    }                               \
	requires_listing_line = 1;                 \
	comment_allowed = 1;

Definition at line 2076 of file pplex.c.

Referenced by pplex().

#define yyalloc   ppalloc

Definition at line 24 of file pplex.c.

#define yyconst

Definition at line 129 of file pplex.c.

#define yyfree   ppfree

Definition at line 26 of file pplex.c.

FILE * yyin   ppin

Definition at line 16 of file pplex.c.

Referenced by cobc_clean_up(), main(), and process_translate().

yy_size_t yyleng   ppleng

Definition at line 17 of file pplex.c.

#define yyless

(

n

)

Value:

do \
        { \
        /* Undo effects of setting up pptext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
        *yy_cp = (yy_hold_char); \
		YY_RESTORE_YY_MORE_OFFSET \
        (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
		YY_DO_BEFORE_ACTION; /* set up pptext again */ \
        } \
    while ( 0 )

Definition at line 4261 of file pplex.c.

#define yyless

(

n

)

Value:

do \
        { \
        /* Undo effects of setting up pptext. */ \
        int yyless_macro_arg = (n); \
        YY_LESS_LINENO(yyless_macro_arg);\
		pptext[ppleng] = (yy_hold_char); \
        (yy_c_buf_p) = pptext + yyless_macro_arg; \
        (yy_hold_char) = *(yy_c_buf_p); \
        *(yy_c_buf_p) = '\0'; \
		ppleng = yyless_macro_arg; \
        } \
    while ( 0 )

Definition at line 4261 of file pplex.c.

#define yylex   pplex

Definition at line 18 of file pplex.c.

Referenced by yyparse().

int yylineno   pplineno

Definition at line 19 of file pplex.c.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 2037 of file pplex.c.

FILE * yyout   ppout

Definition at line 20 of file pplex.c.

Referenced by cobc_clean_up(), codegen(), main(), and process_translate().

#define yyrealloc   pprealloc

Definition at line 25 of file pplex.c.

#define yyrestart   pprestart

Definition at line 21 of file pplex.c.

#define YYSTATE   YY_START

Definition at line 153 of file pplex.c.

#define YYTABLES_NAME   "yytables"

Definition at line 4385 of file pplex.c.

#define yyterminate

(

)

return YY_NULL

Definition at line 2306 of file pplex.c.

Referenced by pplex().

char * yytext   pptext

Definition at line 22 of file pplex.c.

#define yytext_ptr   pptext

Definition at line 376 of file pplex.c.

Referenced by input(), pp_load_buffer_state(), pplex(), yy_get_next_buffer(), yy_get_previous_state(), and yyunput().

#define yywrap   ppwrap

Definition at line 23 of file pplex.c.

Typedef Documentation

typedef short int flex_int16_t

Definition at line 72 of file pplex.c.

typedef int flex_int32_t

Definition at line 73 of file pplex.c.

typedef signed char flex_int8_t

Definition at line 71 of file pplex.c.

typedef unsigned short int flex_uint16_t

Definition at line 75 of file pplex.c.

typedef unsigned int flex_uint32_t

Definition at line 76 of file pplex.c.

typedef unsigned char flex_uint8_t

Definition at line 74 of file pplex.c.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 182 of file pplex.c.

typedef unsigned char YY_CHAR

Definition at line 365 of file pplex.c.

typedef size_t yy_size_t

Definition at line 187 of file pplex.c.

typedef int yy_state_type

Definition at line 369 of file pplex.c.

Function Documentation

static void check_comments ( const char *  keyword, const char *  text  )

static

Definition at line 5305 of file pplex.c.

References cb_verify(), ppecho(), ppleng, and skip_to_eol().

Referenced by pplex().

{
    /* Treated as comments when in Identification Division */
    if (comment_allowed) {
        cb_verify (cb_comment_paragraphs, keyword);
        /* Skip comments until the end of line. */
        within_comment = 1;
        skip_to_eol ();
    } else {
        ppecho (text, 0, ppleng);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void check_listing ( const char *  text, const unsigned int  comment  )

static

Definition at line 5319 of file pplex.c.

References CB_FORMAT_FIXED, cb_listing_file, cb_source_format, cobc_gen_listing, and cb_text_list::text.

Referenced by ppecho(), and pplex().

{
    const char  *s;
    char        c;

    /* Check for listing */
    if (!cb_listing_file) {
        /* Nothing to do */
        return;
    }
    if (!text) {
        return;
    }
    if (cobc_gen_listing > 1) {
        /* Passed to cobxref */
        fputs (text, cb_listing_file);
        return;
    }
    if (comment) {
        c = '*';
    } else {
        c = ' ';
    }

    if (requires_listing_line) {
        if (requires_new_line) {
            requires_new_line = 0;
            putc ('\n', cb_listing_file);
        }
        fprintf (cb_listing_file, "%6d%c", ++listing_line, c);
    }

    if (requires_listing_line && cb_source_format == CB_FORMAT_FIXED &&
        strlen (text) > 6) {
        s = &text[6];
    } else {
        s = text;
    }
    fputs (s, cb_listing_file);
    if (strchr (text, '\n')) {
        requires_listing_line = 1;
    } else {
        requires_listing_line = 0;
    }
}

Here is the caller graph for this function:

static void display_to_eol ( void  )

static

Definition at line 5284 of file pplex.c.

References input(), and unput.

Referenced by pplex().

{
    int c;

    while ((c = input ()) != EOF) {
        if (c == '\n') {
            break;
        }
        if (!plex_skip_input) {
            putchar (c);
        }
    }
    if (!plex_skip_input) {
        putchar ('\n');
    }
    if (c != EOF) {
        unput (c);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int input ( void  )

static

Definition at line 3881 of file pplex.c.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, ppin, pprestart(), ppwrap(), yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, YY_END_OF_BUFFER_CHAR, yy_get_next_buffer(), yy_hold_char, yy_n_chars, YY_NEW_FILE, and yytext_ptr.

Referenced by display_to_eol(), and skip_to_eol().

{
    int c;
    
    *(yy_c_buf_p) = (yy_hold_char);

    if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
        {
        /* yy_c_buf_p now points to the character we want to return.
         * If this occurs *before* the EOB characters, then it's a
         * valid NUL; if not, then we've hit the end of the buffer.
         */
        if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
            /* This was really a NUL. */
            *(yy_c_buf_p) = '\0';

        else
            { /* need more input */
            yy_size_t offset = (yy_c_buf_p) - (yytext_ptr);
            ++(yy_c_buf_p);

            switch ( yy_get_next_buffer(  ) )
                {
                case EOB_ACT_LAST_MATCH:
                    /* This happens because yy_g_n_b()
                     * sees that we've accumulated a
                     * token and flags that we need to
                     * try matching the token before
                     * proceeding.  But for input(),
                     * there's no matching to consider.
                     * So convert the EOB_ACT_LAST_MATCH
                     * to EOB_ACT_END_OF_FILE.
                     */

                    /* Reset buffer status. */
                    pprestart(ppin );

                    /*FALLTHROUGH*/

                case EOB_ACT_END_OF_FILE:
                    {
                    if ( ppwrap( ) )
                        return EOF;

                    if ( ! (yy_did_buffer_switch_on_eof) )
                        YY_NEW_FILE;
#ifdef __cplusplus
                    return yyinput();
#else
                    return input();
#endif
                    }

                case EOB_ACT_CONTINUE_SCAN:
                    (yy_c_buf_p) = (yytext_ptr) + offset;
                    break;
                }
            }
        }

    c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
    *(yy_c_buf_p) = '\0';   /* preserve pptext */
    (yy_hold_char) = *++(yy_c_buf_p);

    YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');

    return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plex_action_directive	(	const unsigned int	cmdtype,
		const unsigned int	is_true
	)

Definition at line 4589 of file pplex.c.

References _, cb_plex_error(), cb_source_line, plex_stack::cmd, COBC_ABORT, cobc_abort_pr(), plex_stack::cond, plex_stack::line, PLEX_ACT_ELIF, PLEX_ACT_ELSE, PLEX_ACT_END, PLEX_ACT_IF, PLEX_COND_DEPTH, plex_cond_stack, plex_nest_depth, and plex_stack::skip.

Referenced by ppparse().

{
    unsigned int    n;

    /* Action IF/ELSE/END-IF/ELIF */
    switch (cmdtype) {
    case PLEX_ACT_IF:
        /* Push stack - First occurrence is dummy */
        if (++plex_nest_depth >= PLEX_COND_DEPTH) {
            cobc_abort_pr (_("Directive nest depth exceeded - %d"),
                    PLEX_COND_DEPTH);
            COBC_ABORT ();
        }
        plex_cond_stack[plex_nest_depth].cmd = 1U;
        /* Intersection with previous - first is always 0 */
        n = plex_cond_stack[plex_nest_depth - 1].skip | !is_true;
        plex_cond_stack[plex_nest_depth].skip = n;
        plex_cond_stack[plex_nest_depth].cond = is_true;
        plex_cond_stack[plex_nest_depth].line = cb_source_line;
        plex_skip_input = n;
        return;
    case PLEX_ACT_ELSE:
        /* Must have an associated IF/ELIF */
        if (!plex_nest_depth ||
            plex_cond_stack[plex_nest_depth].cmd != 1) {
            cb_plex_error (newline_count,
                _("ELSE directive without matching IF/ELIF"));
            return;
        }
        plex_cond_stack[plex_nest_depth].cmd = 2U;
        /* Reverse any IF/ELIF condition */
        n = plex_cond_stack[plex_nest_depth].cond;
        plex_cond_stack[plex_nest_depth].skip = n;
        plex_cond_stack[plex_nest_depth].line = cb_source_line;
        /* Intersection with previous */
        plex_skip_input = plex_cond_stack[plex_nest_depth - 1].skip | n;
        return;
    case PLEX_ACT_END:
        /* Must have an associated IF/ELIF/ELSE */
        if (!plex_nest_depth ||
            !plex_cond_stack[plex_nest_depth].cmd) {
            cb_plex_error (newline_count,
                _("END-IF directive without matching IF/ELIF/ELSE"));
            return;
        }
        plex_cond_stack[plex_nest_depth].cmd = 0;
        plex_cond_stack[plex_nest_depth].skip = 0;
        plex_cond_stack[plex_nest_depth].cond = 0;
        plex_cond_stack[plex_nest_depth].line = 0;
        /* Pop stack - set skip to previous */
        plex_nest_depth--;
        plex_skip_input = plex_cond_stack[plex_nest_depth].skip;
        return;
    case PLEX_ACT_ELIF:
        /* Must have an associated IF/ELIF */
        if (!plex_nest_depth ||
            plex_cond_stack[plex_nest_depth].cmd != 1) {
            cb_plex_error (newline_count,
                _("ELIF directive without matching IF/ELIF"));
            return;
        }
        plex_cond_stack[plex_nest_depth].line = cb_source_line;
        if (plex_cond_stack[plex_nest_depth].cond) {
            /* Previous IF or one of previous ELIF was true */
            /* Set to skip */
            n = 1U;
        } else if (is_true) {
            /* Condition is true */
            plex_cond_stack[plex_nest_depth].cond = 1U;
            n = 0;
        } else {
            /* Set to skip */
            n = 1U;
        }
        plex_cond_stack[plex_nest_depth].skip = n;
        /* Intersection with previous */
        plex_skip_input = plex_cond_stack[plex_nest_depth - 1].skip | n;
        return;
    default:
        cobc_abort_pr (_("Invalid internal case - %u"),
                cmdtype);
        COBC_ABORT ();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plex_call_destroy

(

void

)

Definition at line 4583 of file pplex.c.

References pplex_destroy().

Referenced by preprocess().

{
    (void)pplex_destroy ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plex_clear_all

(

void

)

Definition at line 4570 of file pplex.c.

References cobc_free(), and NULL.

Referenced by main().

{
    if (plexbuff1) {
        cobc_free (plexbuff1);
        plexbuff1 = NULL;
    }
    if (plexbuff2) {
        cobc_free (plexbuff2);
        plexbuff2 = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void plex_clear_vars

(

void

)

Definition at line 4559 of file pplex.c.

References plex_cond_stack.

Referenced by preprocess().

{
    /* Reset variables */
    plex_skip_input = 0;
    plex_nest_depth = 0;
    memset (plex_cond_stack, 0, sizeof(plex_cond_stack));
    requires_listing_line = 1;
    comment_allowed = 1;
}

Here is the caller graph for this function:

YY_BUFFER_STATE pp_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

file	A readable stream.
size	The character buffer size in bytes. When in doubt, use YY_BUF_SIZE.

Returns

the allocated buffer state.

Definition at line 4020 of file pplex.c.

References pp_init_buffer(), ppalloc(), yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, and yy_buffer_state::yy_is_our_buffer.

Referenced by pplex(), ppopen(), and pprestart().

{
    YY_BUFFER_STATE b;
    
    b = (YY_BUFFER_STATE) ppalloc(sizeof( struct yy_buffer_state )  );
    if ( ! b )
        YY_FATAL_ERROR( "out of dynamic memory in pp_create_buffer()" );

    b->yy_buf_size = size;

    /* yy_ch_buf has to be 2 characters longer than the size given because
     * we need to put in 2 end-of-buffer characters.
     */
    b->yy_ch_buf = (char *) ppalloc(b->yy_buf_size + 2  );
    if ( ! b->yy_ch_buf )
        YY_FATAL_ERROR( "out of dynamic memory in pp_create_buffer()" );

    b->yy_is_our_buffer = 1;

    pp_init_buffer(b,file );

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pp_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with pp_create_buffer()

Definition at line 4048 of file pplex.c.

References ppfree(), yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_buffer_state::yy_is_our_buffer.

Referenced by pplex(), pplex_destroy(), and pppop_buffer_state().

{
    
    if ( ! b )
        return;

    if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
        YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;

    if ( b->yy_is_our_buffer )
        ppfree((void *) b->yy_ch_buf  );

    ppfree((void *) b  );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pp_flush_buffer

(

YY_BUFFER_STATE

b

)

Discard all buffered characters.

On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 4095 of file pplex.c.

References pp_load_buffer_state(), yy_buffer_state::yy_at_bol, yy_buffer_state::yy_buf_pos, YY_BUFFER_NEW, yy_buffer_state::yy_buffer_status, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER, YY_END_OF_BUFFER_CHAR, and yy_buffer_state::yy_n_chars.

Referenced by pp_init_buffer().

{
        if ( ! b )
        return;

    b->yy_n_chars = 0;

    /* We always need two end-of-buffer characters.  The first causes
     * a transition to the end-of-buffer state.  The second causes
     * a jam in that state.
     */
    b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;

    b->yy_buf_pos = &b->yy_ch_buf[0];

    b->yy_at_bol = 1;
    b->yy_buffer_status = YY_BUFFER_NEW;

    if ( b == YY_CURRENT_BUFFER )
        pp_load_buffer_state( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pp_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 4067 of file pplex.c.

References file, pp_flush_buffer(), yy_buffer_state::yy_bs_column, yy_buffer_state::yy_bs_lineno, YY_CURRENT_BUFFER, yy_buffer_state::yy_fill_buffer, yy_buffer_state::yy_input_file, and yy_buffer_state::yy_is_interactive.

Referenced by pp_create_buffer(), and pprestart().

{
    int oerrno = errno;
    
    pp_flush_buffer(b );

    b->yy_input_file = file;
    b->yy_fill_buffer = 1;

    /* If b is the current buffer, then pp_init_buffer was _probably_
     * called from pprestart() or through yy_get_next_buffer.
     * In that case, we don't want to reset the lineno or column.
     */
    if (b != YY_CURRENT_BUFFER){
        b->yy_bs_lineno = 1;
        b->yy_bs_column = 0;
    }

        b->yy_is_interactive = 0;
    
    errno = oerrno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void pp_load_buffer_state ( void  )

static

Definition at line 4006 of file pplex.c.

References ppin, yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, yy_hold_char, yy_n_chars, and yytext_ptr.

Referenced by pp_flush_buffer(), pp_switch_to_buffer(), pplex(), pppop_buffer_state(), pppush_buffer_state(), and pprestart().

{
        (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
    (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
    ppin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
    (yy_hold_char) = *(yy_c_buf_p);
}

Here is the caller graph for this function:

YY_BUFFER_STATE pp_scan_buffer	(	char *	base,
		yy_size_t	size
	)

YY_BUFFER_STATE pp_scan_bytes	(	char *	bytes,
		yy_size_t	len
	)

YY_BUFFER_STATE pp_scan_string

(

char *

yy_str

)

void pp_set_replace_list	(	struct cb_replace_list *	list,
		const cob_u32_t	is_pushpop
	)

Definition at line 4394 of file pplex.c.

References base_replace_list, cb_replace_list::last, cb_replace_list::next, NULL, and cb_replace_list::prev.

Referenced by ppparse().

{
    /* Handle REPLACE verb */
    if (!list) {
        /* REPLACE [LAST] OFF */
        if (!is_pushpop) {
            base_replace_list = NULL;
            return;
        }
        if (!base_replace_list) {
            return;
        }
        base_replace_list = base_replace_list->prev;
        return;
    }
    /* REPLACE [ALSO] ... */
    if (base_replace_list && is_pushpop) {
        list->last->next = base_replace_list;
        list->prev = base_replace_list;
    } else {
        list->prev = NULL;
    }
    base_replace_list = list;
}

Here is the caller graph for this function:

void pp_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 3975 of file pplex.c.

References pp_load_buffer_state(), ppensure_buffer_stack(), yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, and yy_n_chars.

Referenced by switch_to_buffer().

{
    
    /* TODO. We should be able to replace this entire function body
     * with
     *      pppop_buffer_state();
     *      pppush_buffer_state(new_buffer);
     */
    ppensure_buffer_stack ();
    if ( YY_CURRENT_BUFFER == new_buffer )
        return;

    if ( YY_CURRENT_BUFFER )
        {
        /* Flush out information for old buffer. */
        *(yy_c_buf_p) = (yy_hold_char);
        YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
        }

    YY_CURRENT_BUFFER_LVALUE = new_buffer;
    pp_load_buffer_state( );

    /* We don't actually know whether we did this switch during
     * EOF (ppwrap()) processing, but the only time this flag
     * is looked at is after ppwrap() is called, so it's safe
     * to go ahead and always set it.
     */
    (yy_did_buffer_switch_on_eof) = 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct cb_text_list* pp_text_list_add ( struct cb_text_list *  list, const char *  text, const size_t  size  )

static

Definition at line 5097 of file pplex.c.

References cobc_plex_malloc(), cb_text_list::last, cb_text_list::next, and cb_text_list::text.

Referenced by ppecho().

{
    struct cb_text_list *p;
    void            *tp;

    p = cobc_plex_malloc (sizeof (struct cb_text_list));
    tp = cobc_plex_malloc (size + 1);
    memcpy (tp, text, size);
    p->text = tp;
    if (!list) {
        p->last = p;
        return p;
    }
    list->last->next = p;
    list->last = p;
    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void * ppalloc

(

yy_size_t

size

)

Definition at line 4363 of file pplex.c.

Referenced by pp_create_buffer(), ppensure_buffer_stack(), and yy_push_state().

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

Here is the caller graph for this function:

int ppcopy	(	const char *	name,
		const char *	lib,
		struct cb_replace_list *	replace_list
	)

Definition at line 4508 of file pplex.c.

References _, cb_error(), cb_extension_list, cb_include_list, COB_SMALL_MAX, cb_text_list::next, plexbuff1, ppopen(), R_OK, and cb_text_list::text.

Referenced by ppparse().

{
    struct cb_text_list *il;
    struct cb_text_list *el;
    const char      *s;

    /* Locate and open COPY file */
    if (lib) {
        snprintf (plexbuff1, (size_t)COB_SMALL_MAX, "%s/%s", lib, name);
        plexbuff1[COB_SMALL_MAX] = 0;
        s = plexbuff1;
    } else {
        s = name;
    }

    /* Find the file */
    if (access (s, R_OK) == 0) {
        return ppopen (s, replace_list);
    }

    for (el = cb_extension_list; el; el = el->next) {
        snprintf (plexbuff2, (size_t)COB_SMALL_MAX, "%s%s", s, el->text);
        plexbuff2[COB_SMALL_MAX] = 0;
        if (access (plexbuff2, R_OK) == 0) {
            return ppopen (plexbuff2, replace_list);
        }
    }

    if (*s != '/') {
        for (il = cb_include_list; il; il = il->next) {
            for (el = cb_extension_list; el; el = el->next) {
                snprintf (plexbuff2, (size_t)COB_SMALL_MAX,
                      "%s/%s%s", il->text, name, el->text);
                plexbuff2[COB_SMALL_MAX] = 0;
                if (access (plexbuff2, R_OK) == 0) {
                    return ppopen (plexbuff2, replace_list);
                }
            }
        }
    }
    cb_error ("%s: %s", name, _("No such file or directory"));
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ppecho ( const char *  text, const cob_u32_t  alt_space, const int  textlen  )

static

Definition at line 5117 of file pplex.c.

References base_replace_list, cb_listing_file, CB_REPLACE_LEADING, CB_REPLACE_TRAILING, check_listing(), cobc_free(), cobc_strdup(), cb_replace_list::last, cb_replace_list::lead_trail, cb_replace_list::new_text, cb_text_list::next, cb_replace_list::next, NULL, cb_replace_list::old_text, pp_text_list_add(), ppout, pptext, cb_text_list::text, and text_queue.

Referenced by check_comments(), and pplex().

{
    struct cb_replace_list      *r;
    struct cb_replace_list      *save_ptr;
    const struct cb_text_list   *lno;
    struct cb_text_list     *queue;
    struct cb_text_list     *save_queue;
    const char          *s;
    char                *temp_ptr;
    size_t              size;
    size_t              size2;

    /* Check for replacement text before outputting */
    if (alt_space) {
        s = pptext;
    } else {
        s = text;
    }

    if (text_queue == NULL && (text[0] == ' ' || text[0] == '\n')) {
        /* No replacement */
        fwrite (text, (size_t)textlen, (size_t)1, ppout);
        if (cb_listing_file) {
            check_listing (s, 0);
        }
        return;
    }
    if (!current_replace_list && !base_replace_list) {
        /* Ouput queue */
        for (; text_queue; text_queue = text_queue->next) {
            fputs (text_queue->text, ppout);
        }
        fwrite (text, (size_t)textlen, (size_t)1, ppout);
        if (cb_listing_file) {
            check_listing (s, 0);
        }
        return;
    }
    if (!current_replace_list) {
        current_replace_list = base_replace_list;
        save_ptr = NULL;
    } else {
        current_replace_list->last->next = base_replace_list;
        save_ptr = current_replace_list->last;
    }

    /* Do replacement */
    text_queue = pp_text_list_add (text_queue, text, (size_t)textlen);

    save_queue = NULL;
    size = 0;
    size2 = 0;
    for (r = current_replace_list; r; r = r->next) {
        queue = text_queue;
        /* The LEADING/TRAILING code looks peculiar as we use */
        /* variables after breaking out of the loop BUT */
        /* ppparse.y guarantees that we have only one token */
        /* and therefore only one iteration of this loop */
        for (lno = r->old_text; lno; lno = lno->next) {
            if (lno->text[0] == ' ' || lno->text[0] == '\n') {
                continue;
            }
            while (queue && (queue->text[0] == ' ' ||
                   queue->text[0] == '\n')) {
                queue = queue->next;
            }
            if (queue == NULL) {
                /* Partial match */
                if (!save_ptr) {
                    current_replace_list = NULL;
                } else {
                    save_ptr->next = NULL;
                }
                return;
            }
            if (r->lead_trail == CB_REPLACE_LEADING) {
                /* Check leading text */
                size = strlen (lno->text);
                if (strncasecmp (lno->text, queue->text, size)) {
                    /* No match */
                    break;
                }
                save_queue = queue;
            } else if (r->lead_trail == CB_REPLACE_TRAILING) {
                /* Check trailing text */
                size = strlen (lno->text);
                size2 = strlen (queue->text);
                if (size2 < size) {
                    /* No match */
                    break;
                }
                size2 -= size;
                if (strncasecmp (lno->text, queue->text + size2, size)) {
                    /* No match */
                    break;
                }
                save_queue = queue;
            } else if (strcasecmp (lno->text, queue->text)) {
                /* No match */
                break;
            }
            queue = queue->next;
        }
        if (lno == NULL) {
            /* Match */
            if (r->lead_trail == CB_REPLACE_TRAILING
                && save_queue /* <- silence warnings */) {
                /* Non-matched part of original text */
                fprintf (ppout, "%*.*s", (int)size2, (int)size2,
                     save_queue->text);
                if (cb_listing_file) {
                    temp_ptr = cobc_strdup (save_queue->text);
                    *(temp_ptr + size2) = 0;
                    check_listing (temp_ptr, 0);
                    cobc_free (temp_ptr);
                }
            }
            for (lno = r->new_text; lno; lno = lno->next) {
                fputs (lno->text, ppout);
                if (cb_listing_file) {
                    check_listing (lno->text, 0);
                }
            }
            if (r->lead_trail == CB_REPLACE_LEADING
                && save_queue /* <- silence warnings */) {
                /* Non-matched part of original text */
                fputs (save_queue->text + size, ppout);
                if (cb_listing_file) {
                    check_listing (save_queue->text + size, 0);
                }
            }
            text_queue = queue;
            continue;
        }
    }

    /* No match */
    for (; text_queue; text_queue = text_queue->next) {
        fputs (text_queue->text, ppout);
        if (cb_listing_file) {
            check_listing (text_queue->text, 0);
        }
    }
    if (!save_ptr) {
        current_replace_list = NULL;
    } else {
        save_ptr->next = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ppensure_buffer_stack ( void  )

static

Definition at line 4173 of file pplex.c.

References ppalloc(), pprealloc(), yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, and YY_FATAL_ERROR.

Referenced by pp_switch_to_buffer(), pplex(), pppush_buffer_state(), and pprestart().

{
    yy_size_t num_to_alloc;
    
    if (!(yy_buffer_stack)) {

        /* First allocation is just for 2 elements, since we don't know if this
         * scanner will even need a stack. We use 2 instead of 1 to avoid an
         * immediate realloc on the next call.
         */
        num_to_alloc = 1;
        (yy_buffer_stack) = (struct yy_buffer_state**)ppalloc
                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in ppensure_buffer_stack()" );
                                  
        memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
                
        (yy_buffer_stack_max) = num_to_alloc;
        (yy_buffer_stack_top) = 0;
        return;
    }

    if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

        /* Increase the buffer to prepare for a possible push. */
        int grow_size = 8 /* arbitrary grow size */;

        num_to_alloc = (yy_buffer_stack_max) + grow_size;
        (yy_buffer_stack) = (struct yy_buffer_state**)pprealloc
                                ((yy_buffer_stack),
                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in ppensure_buffer_stack()" );

        /* zero only the new slots.*/
        memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
        (yy_buffer_stack_max) = num_to_alloc;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ppfree

(

void *

ptr

)

Definition at line 4380 of file pplex.c.

Referenced by pp_delete_buffer(), and pplex_destroy().

{
    free( (char *) ptr );   /* see pprealloc() for (char *) cast */
}

Here is the caller graph for this function:

static int ppinput ( char *  buff, const size_t  max_size  )

static

Definition at line 4688 of file pplex.c.

References _, CB_FORMAT_FIXED, CB_FORMAT_FREE, cb_plex_error(), cb_plex_warning(), cb_source_format, cb_verify(), likely, newline_count, ppin, PPLEX_BUFF_LEN, unlikely, and YY_NULL.

{
    char    *bp;
    size_t  gotcr;
    size_t  line_overflow;
    size_t  continuation;
    int ipchar;
    int i;
    int n;
    int coln;

    /* Read line(s) */

    continuation = 0;
start:
    if (unlikely(buffer_overflow ||
             (newline_count + PPLEX_BUFF_LEN) >= max_size)) {
        if (need_continuation || continuation) {
            cb_plex_error (newline_count,
                    _("Buffer overrun - Too many continuation lines"));
            return YY_NULL;
        }
        if (newline_count < max_size) {
            memset (buff, '\n', newline_count);
            buff[newline_count] = 0;
            ipchar = (int)newline_count;
            newline_count = 0;
            buffer_overflow = 0;
            return ipchar;
        }
        buffer_overflow = 1;
        ipchar = max_size - 1;
        memset (buff, '\n', (size_t)ipchar);
        buff[ipchar] = 0;
        newline_count -= ipchar;
        return ipchar;
    }
    gotcr = 0;
    line_overflow = 0;
    ipchar = 0;
    for (n = 0; ipchar != '\n';) {
        if (unlikely(n == PPLEX_BUFF_LEN)) {
            if (line_overflow != 2) {
                line_overflow = 1;
            }
        }
        ipchar = getc (ppin);
        if (unlikely(ipchar == EOF)) {
            if (n > 0) {
                /* No end of line at end of file */
                break;
            }
            if (newline_count == 0) {
                return YY_NULL;
            }
            memset (buff, '\n', newline_count);
            buff[newline_count] = 0;
            ipchar = (int)newline_count;
            newline_count = 0;
            return ipchar;
        }
#ifndef COB_EBCDIC_MACHINE
        if (unlikely(ipchar == 0x1A && !n)) {
            continue;
        }
#endif
        if (unlikely(gotcr)) {
            gotcr = 0;
            if (ipchar != '\n') {
                if (likely(line_overflow == 0)) {
                    buff[n++] = '\r';
                } else {
                    line_overflow = 2;
                }
            }
        }
        if (unlikely(ipchar == '\r')) {
            gotcr = 1;
            continue;
        }
        if (unlikely(ipchar == '\t')) {
            if (likely(line_overflow == 0)) {
                buff[n++] = ' ';
                while (n % cb_tab_width != 0) {
                    buff[n++] = ' ';
                }
                if (unlikely(n > PPLEX_BUFF_LEN)) {
                    n = PPLEX_BUFF_LEN;
                }
            }
            continue;
        }
        if (likely(line_overflow == 0)) {
            buff[n++] = (char)ipchar;
        } else if ((char)ipchar != ' ' && (char)ipchar != '\n') {
            line_overflow = 2;
        }
    }

    if (buff[n - 1] != '\n') {
        /* FIXME: cb_source_line is one too low when CB_FORMAT_FREE is used
           [but only during ppinput() in pplex.l ?] - Workaround for now:
           Temporary newline_count + 1
        */
        if (cb_source_format == CB_FORMAT_FREE) {
            if (line_overflow == 0) {
                cb_plex_warning (newline_count + 1,
                         _("Line not terminated by a newline"));
            } else if (line_overflow == 2) {
                cb_plex_warning (newline_count + 1,
                         _("Source text exceeds %d bytes, will be truncated"), PPLEX_BUFF_LEN);
            }
        } else {
            if (line_overflow == 0) {
                cb_plex_warning (newline_count,
                         _("Line not terminated by a newline"));
            } else if (line_overflow == 2) {
                cb_plex_warning (newline_count,
                         _("Source text exceeds %d bytes, will be truncated"), PPLEX_BUFF_LEN);
            }
        }
        buff[n++] = '\n';
    }
    buff[n] = 0;

    if (cb_source_format == CB_FORMAT_FIXED) {
        if (n < 8) {
            /* Line too short */
            newline_count++;
            goto start;
        }

        if (cb_flag_mfcomment) {
            if (buff[0] == '*' || buff[0] == '/') {
                newline_count++;
                goto start;
            }
        }

        /* Check if text is longer than cb_text_column */
        if (n > cb_text_column + 1) {
            /* Show warning if it is not whitespace
               (postponed after checking for comments by setting
                line_overflow to first column that leads to
                "source text too long")
            */
            if (cb_warn_column_overflow && line_overflow == 0) {
                for (coln = cb_text_column; coln < n; ++coln) {
                    if (buff[coln] != ' ' && buff[coln] != '\n') {
                        line_overflow = coln;
                        break;
                    }
                }
            } else {
                line_overflow = 0;
            }
            /* Remove it */
            buff[cb_text_column] = '\n';
            buff[cb_text_column + 1] = 0;
            n = cb_text_column + 1;
        } else {
            line_overflow = 0;
        }

        memset (buff, ' ', (size_t)6);
        /* Note we allow directive lines to start at column 7 */
        bp = &buff[6];
    } else {
        bp = buff;
    }

    /* Check for directives/floating comment at first non-space of line */
    ipchar = 0;
    i = 0;
    for (; *bp; bp++) {
        if (*bp != ' ') {
            if ((*bp == '$' && !(cb_source_format == CB_FORMAT_FIXED && i == 0)) ||
                (*bp == '>' && bp[1] == '>'                                    )   ) {
                /* Directive */
                ipchar = 1;
            } else if ((*bp == '*' && bp[1] == '>'      ) ||
                       (cb_flag_acucomment && *bp == '|')   ) {
                /* Float comment */
                newline_count++;
                goto start;
            }
            break;
        }
        i = 1;
    }
    if (ipchar) {
        /* Directive - pass complete line with NL to ppparse */
        if (newline_count) {
            /* Move including NL and NULL byte */
            memmove (buff + newline_count, buff, (size_t)(n + 1));
            memset (buff, '\n', newline_count);
            n += newline_count;
            newline_count = 0;
        }
        return n;
    }

    if (plex_skip_input) {
        /* Skipping input */
        newline_count++;
        goto start;
    }

    /* Return when free format (no floating comments removed!) */
    if (cb_source_format == CB_FORMAT_FREE) {
        within_comment = 0;
        if (newline_count) {
            memmove (buff + newline_count, buff, (size_t)(n + 1));
            memset (buff, '\n', newline_count);
            n += newline_count;
            newline_count = 0;
        }
        return n;
    }

    /* Fixed format */

    /* Check the indicator (column 7) */
    if (cb_flag_acucomment && buff[6] == '$') {
        buff[6] = '*';
    }
    switch (buff[6]) {
    case ' ':
        break;
    case '-':
        if (unlikely(within_comment)) {
            cb_plex_error (newline_count,
                    _("Invalid continuation in comment entry"));
            newline_count++;
            goto start;
        } else if (!need_continuation) {
            cb_verify (cb_word_continuation, _("Continuation of COBOL words"));
        }
        continuation = 1;
        break;
    case 'd':
    case 'D':
        /* Debugging line */
        if (cb_flag_debugging_line) {
            break;
        }
        newline_count++;
        goto start;
    case '*':
    case '/':
        /* Comment line */
        newline_count++;
        goto start;
    default:
        /* Invalid indicator */
        cb_plex_error (newline_count,
                _("Invalid indicator '%c' at column 7"), buff[6]);
        newline_count++;
        return YY_NULL;
    }

    /* Skip comments that follow after AUTHORS, etc. */
    if (unlikely(within_comment)) {
        /* Check all of "Area A" */
        for (ipchar = 7; ipchar < (n - 1) && ipchar < 11; ++ipchar) {
            if (buff[ipchar] != ' ') {
                ipchar = 0;
                break;
            }
        }
        if (ipchar) {
            newline_count++;
            goto start;
        }
        within_comment = 0;
    }

    /* Skip blank lines */
    for (i = 7; buff[i] == ' '; ++i) {
        ;
    }

    if (buff[i] == '\n') {
        newline_count++;
        goto start;
    }

    buff[6] = ' ';
    bp = buff + 7;

    if (unlikely(continuation)) {
        /* Line continuation */
        need_continuation = 0;
        for (; *bp == ' '; ++bp) {
            ;
        }
        /* Validate concatenation */
        if (consecutive_quotation) {
            if (bp[0] == quotation_mark && bp[1] == quotation_mark) {
                bp++;
            } else {
                cb_plex_error (newline_count,
                        _("Invalid line continuation"));
                return YY_NULL;
            }
            quotation_mark = 0;
            consecutive_quotation = 0;
        } else if (quotation_mark) {
            /* Literal concatenation */
            if (*bp == quotation_mark) {
                bp++;
            } else {
                cb_plex_error (newline_count,
                        _("Invalid line continuation"));
                return YY_NULL;
            }
        }
    } else {
        /* Normal line */
        if (need_continuation) {
            cb_plex_error (newline_count,
                    _("Continuation character expected"));
            need_continuation = 0;
        }
        quotation_mark = 0;
        consecutive_quotation = 0;
    }

    /* Check if string literal is to be continued */
    for (i = bp - buff; buff[i] != '\n'; ++i) {
        /* Pick up floating comment and force loop exit */
        if (!quotation_mark && ((buff[i] == '*' && buff[i + 1] == '>') ||
                                (cb_flag_acucomment && buff[i] == '|') ) ) {
            /* remove indicator "source text too long" if the column
               leading to the indicator comes after the floating comment
            */
            if (i < cb_text_column) {
                line_overflow = 0;
            }
            /* Set to null, 'i' is predecremented further below */
            buff[i] = 0;
            break;
        } else if (buff[i] == '\'' || buff[i] == '"') {
            if (quotation_mark == 0) {
                /* Literal start */
                quotation_mark = buff[i];
            } else if (quotation_mark == buff[i]) {
                if (i == cb_text_column - 1) {
                    /* Consecutive quotation */
                    consecutive_quotation = 1;
                } else {
                    /* Literal end */
                    quotation_mark = 0;
                }
            }
        }
    }

    if (unlikely(quotation_mark)) {
        /* Expecting continuation */
        if (!consecutive_quotation) {
            need_continuation = 1;
        }
        for (; i < cb_text_column;) {
            buff[i++] = ' ';
        }
        buff[i] = 0;
    } else {
        /* Truncate trailing spaces, including the newline */
        for (i--; i >= 0 && buff[i] == ' '; i--) {
            ;
        }
        if (i < 0) {
            /* Empty line after removing floating comment */
            newline_count++;
            goto start;
        }
        if (buff[i] == '\'' || buff[i] == '\"') {
            buff[++i] = ' ';
        }
        buff[i + 1] = 0;
    }

    /* Show warning if text is longer than cb_text_column
       and not whitespace (postponed here) */
    if (line_overflow != 0) {
        cb_plex_warning (newline_count,
                    _("Source text after program-text area (column %d)"),
                cb_text_column);
    }

    if (unlikely(continuation)) {
        gotcr = strlen (bp);
        memmove (buff, bp, gotcr + 1);
        newline_count++;
    } else {
        /* Insert newlines at the start of the buffer */
        gotcr = strlen (buff);
        if (newline_count != 0) {
            memmove (buff + newline_count, buff, gotcr + 1);
            memset (buff, '\n', newline_count);
            gotcr += newline_count;
        }
        newline_count = 1;
    }
    return (int)gotcr;
}

Here is the call graph for this function:

int pplex

(

void

)

The main scanner function which does all the work.

Definition at line 2352 of file pplex.c.

References _, ALSO, AS, BEGIN, copy_info::buffer, BY, cb_error(), CB_FORMAT_FREE, cb_plex_warning(), cb_source_format, cb_source_line, cb_verify(), check_comments(), check_listing(), CHECKING, cobc_free(), cobc_plex_strdup(), CONSTANT, COPY, copy_stack, COPY_STATE, DEFINE_DIRECTIVE, DEFINE_DIRECTIVE_STATE, DEFINED, display_to_eol(), copy_info::dname, DOT, ECHO, ELIF_DIRECTIVE, ELSE_DIRECTIVE, ELSE_DIRECTIVE_STATE, ENDIF_DIRECTIVE, ENDIF_DIRECTIVE_STATE, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, EQ, EQEQ, EQUAL, copy_info::file, FIXED, FOLDCOPYNAME, FORMAT, FREE, GE, GREATER, GT, IF_DIRECTIVE, IF_DIRECTIVE_STATE, IN, INITIAL, IS, LAST, LE, LEADING, LESS, copy_info::line, plex_stack::line, LITERAL, LOCATION, LT, NE, copy_info::next, NOFOLDCOPYNAME, NOT, NULL, OF, OFF, ON, OR, OVERRIDE, PARAMETER, plex_cond_stack, plex_nest_depth, pp_create_buffer(), pp_delete_buffer(), pp_load_buffer_state(), ppecho(), ppensure_buffer_stack(), ppin, ppleng, pplval, ppout, ppwrap(), PRINTING, PSEUDO_STATE, copy_info::quotation_mark, REPLACE, REPLACING, copy_info::replacing, YYSTYPE::s, SET, SET_DIRECTIVE, SET_DIRECTIVE_STATE, skip_to_eol(), SOURCE_DIRECTIVE, SOURCE_DIRECTIVE_STATE, copy_info::source_format, SOURCEFORMAT, SUPPRESS, switch_to_buffer(), TERMINATOR, THAN, TO, TOKEN, TRAILING, TURN_DIRECTIVE, TURN_DIRECTIVE_STATE, unput, VARIABLE, warningopt, WITH, YY_AT_BOL, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, YY_DO_BEFORE_ACTION, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yy_hold_char, yy_init, yy_last_accepting_cpos, yy_last_accepting_state, YY_MORE_ADJ, yy_n_chars, YY_NEW_FILE, yy_pop_state(), yy_push_state(), YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, yy_start, YY_STATE_EOF, yy_try_NUL_trans(), YY_USER_INIT, yyterminate, and yytext_ptr.

{
    register yy_state_type yy_current_state;
    register char *yy_cp, *yy_bp;
    register int yy_act;
    
    if ( !(yy_init) )
        {
        (yy_init) = 1;

#ifdef YY_USER_INIT
        YY_USER_INIT;
#endif

        if ( ! (yy_start) )
            (yy_start) = 1; /* first start state */

        if ( ! ppin )
            ppin = stdin;

        if ( ! ppout )
            ppout = stdout;

        if ( ! YY_CURRENT_BUFFER ) {
            ppensure_buffer_stack ();
            YY_CURRENT_BUFFER_LVALUE =
                pp_create_buffer(ppin,YY_BUF_SIZE );
        }

        pp_load_buffer_state( );
        }

    {
#line 174 "pplex.l"





#line 2391 "pplex.c"

    while ( 1 )     /* loops until end-of-file is reached */
        {
        yy_cp = (yy_c_buf_p);

        /* Support of pptext. */
        *yy_cp = (yy_hold_char);

        /* yy_bp points to the position in yy_ch_buf of the start of
         * the current run.
         */
        yy_bp = yy_cp;

        yy_current_state = (yy_start);
        yy_current_state += YY_AT_BOL();
yy_match:
        do
            {
            register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
            if ( yy_accept[yy_current_state] )
                {
                (yy_last_accepting_state) = yy_current_state;
                (yy_last_accepting_cpos) = yy_cp;
                }
            while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                {
                yy_current_state = (int) yy_def[yy_current_state];
                if ( yy_current_state >= 1082 )
                    yy_c = yy_meta[(unsigned int) yy_c];
                }
            yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
            ++yy_cp;
            }
        while ( yy_current_state != 1081 );
        yy_cp = (yy_last_accepting_cpos);
        yy_current_state = (yy_last_accepting_state);

yy_find_action:
        yy_act = yy_accept[yy_current_state];

        YY_DO_BEFORE_ACTION;

do_action:  /* This label is used only to access EOF actions. */

        switch ( yy_act )
    { /* beginning of action switch */
            case 0: /* must back up */
            /* undo the effects of YY_DO_BEFORE_ACTION */
            *yy_cp = (yy_hold_char);
            yy_cp = (yy_last_accepting_cpos);
            yy_current_state = (yy_last_accepting_state);
            goto yy_find_action;

case 1:
YY_RULE_SETUP
#line 179 "pplex.l"
{
    #if 0   /* RXWRXW - Directive state */
    if (YY_START != DIRECTIVE_STATE && YY_START != SET_DIRECTIVE_STATE) {
        ppecho (" ", 0, 1);
    }
    #endif
}
    YY_BREAK
case 2:
YY_RULE_SETUP
#line 187 "pplex.l"
{
    /* Define here to preempt next debug rule below */
    BEGIN DEFINE_DIRECTIVE_STATE;
    return DEFINE_DIRECTIVE;
}
    YY_BREAK
case 3:
YY_RULE_SETUP
#line 193 "pplex.l"
{
    /* Define here to preempt next debug rule below */
    display_to_eol ();
}
    YY_BREAK
case 4:
YY_RULE_SETUP
#line 198 "pplex.l"
{
    /* OC extension for floating debug line */
    /* Remove line if debugging lines not activated */
    /* Otherwise ignore the directive part of the line */
    if (!cb_flag_debugging_line) {
        skip_to_eol ();
    }
}
    YY_BREAK
case 5:
YY_RULE_SETUP
#line 207 "pplex.l"
{
    BEGIN SOURCE_DIRECTIVE_STATE;
    return SOURCE_DIRECTIVE;
}
    YY_BREAK
case 6:
YY_RULE_SETUP
#line 212 "pplex.l"
{
    /* OC extension */
    BEGIN SET_DIRECTIVE_STATE;
    return SET_DIRECTIVE;
}
    YY_BREAK
case 7:
YY_RULE_SETUP
#line 218 "pplex.l"
{
    BEGIN TURN_DIRECTIVE_STATE;
    return TURN_DIRECTIVE;
}
    YY_BREAK
case 8:
YY_RULE_SETUP
#line 223 "pplex.l"
{
    BEGIN IF_DIRECTIVE_STATE;
    return IF_DIRECTIVE;
}
    YY_BREAK
case 9:
#line 229 "pplex.l"
case 10:
YY_RULE_SETUP
#line 229 "pplex.l"
{
    BEGIN IF_DIRECTIVE_STATE;
    return ELIF_DIRECTIVE;
}
    YY_BREAK
case 11:
YY_RULE_SETUP
#line 234 "pplex.l"
{
    BEGIN ELSE_DIRECTIVE_STATE;
    return ELSE_DIRECTIVE;
}
    YY_BREAK
case 12:
YY_RULE_SETUP
#line 239 "pplex.l"
{
    BEGIN ENDIF_DIRECTIVE_STATE;
    return ENDIF_DIRECTIVE;
}
    YY_BREAK
case 13:
YY_RULE_SETUP
#line 244 "pplex.l"
{
    if (warningopt) {
        cb_plex_warning (newline_count, _("Ignoring LEAP-SECOND directive"));
    }
    skip_to_eol ();
}
    YY_BREAK
case 14:
/* rule 14 can match eol */
YY_RULE_SETUP
#line 251 "pplex.l"
{
    cb_plex_warning (newline_count, _("Ignoring empty directive"));
    unput ('\n');
}
    YY_BREAK
case 15:
YY_RULE_SETUP
#line 256 "pplex.l"
{
    char    *s;

    s = strchr (pptext, '>');
    cb_plex_warning (newline_count, _("Ignoring invalid directive - '%s'"), s);
    skip_to_eol ();
}
    YY_BREAK
case 16:
YY_RULE_SETUP
#line 264 "pplex.l"
{
    cb_plex_warning (newline_count, _("Ignoring invalid directive"));
    skip_to_eol ();
}
    YY_BREAK
case 17:
YY_RULE_SETUP
#line 269 "pplex.l"
{
    display_to_eol ();
}
    YY_BREAK
case 18:
YY_RULE_SETUP
#line 273 "pplex.l"
{
    BEGIN SET_DIRECTIVE_STATE;
    return SET_DIRECTIVE;
}
    YY_BREAK
case 19:
YY_RULE_SETUP
#line 278 "pplex.l"
{
    BEGIN IF_DIRECTIVE_STATE;
    return IF_DIRECTIVE;
}
    YY_BREAK
case 20:
#line 284 "pplex.l"
case 21:
YY_RULE_SETUP
#line 284 "pplex.l"
{
    BEGIN IF_DIRECTIVE_STATE;
    return ELIF_DIRECTIVE;
}
    YY_BREAK
case 22:
YY_RULE_SETUP
#line 289 "pplex.l"
{
    BEGIN ELSE_DIRECTIVE_STATE;
    return ELSE_DIRECTIVE;
}
    YY_BREAK
case 23:
YY_RULE_SETUP
#line 294 "pplex.l"
{
    BEGIN ENDIF_DIRECTIVE_STATE;
    return ENDIF_DIRECTIVE;
}
    YY_BREAK
case 24:
YY_RULE_SETUP
#line 299 "pplex.l"
{
    char    *s;

    s = strchr (pptext, '$');
    cb_plex_warning (newline_count, _("Ignoring invalid directive - '%s'"), s);
    skip_to_eol ();
}
    YY_BREAK
case 25:
YY_RULE_SETUP
#line 307 "pplex.l"
{
    /* Allow $ in column 7 for acucomment in fixed format */
    if (cb_source_format == CB_FORMAT_FREE) {
        cb_plex_warning (newline_count, _("Spurious '$' detected - ignoring"));
        skip_to_eol ();
    }
}
    YY_BREAK
case 26:
YY_RULE_SETUP
#line 315 "pplex.l"
{
    cb_plex_warning (newline_count, _("Spurious '$' detected - ignoring"));
    skip_to_eol ();
}
    YY_BREAK
case 27:
YY_RULE_SETUP
#line 320 "pplex.l"
{
    cb_plex_warning (newline_count, _("PROCESS statement ignored"));
    skip_to_eol ();
}
    YY_BREAK
case 28:
YY_RULE_SETUP
#line 325 "pplex.l"
{
    yy_push_state (COPY_STATE);
    return COPY;
}
    YY_BREAK
case 29:
YY_RULE_SETUP
#line 330 "pplex.l"
{
    yy_push_state (COPY_STATE);
    return COPY;
}
    YY_BREAK
case 30:
YY_RULE_SETUP
#line 335 "pplex.l"
{
    yy_push_state (COPY_STATE);
    return REPLACE;
}
    YY_BREAK
case 31:
#line 341 "pplex.l"
case 32:
YY_RULE_SETUP
#line 341 "pplex.l"
{
    /* Allow comment sentences/paragraphs */
    comment_allowed = 1;
    ppecho (pptext, 0, ppleng);
}
    YY_BREAK
case 33:
YY_RULE_SETUP
#line 347 "pplex.l"
{
    /* Allow comment sentences/paragraphs */
    comment_allowed = 1;
    ppecho (pptext, 0, ppleng);
}
    YY_BREAK
case 34:
YY_RULE_SETUP
#line 353 "pplex.l"
{
    /* Disallow comment sentences/paragraphs */
    comment_allowed = 0;
    ppecho (pptext, 0, ppleng);
}
    YY_BREAK
case 35:
YY_RULE_SETUP
#line 359 "pplex.l"
{
    /* Disallow comment sentences/paragraphs */
    comment_allowed = 0;
    ppecho (pptext, 0, ppleng);
}
    YY_BREAK
case 36:
YY_RULE_SETUP
#line 365 "pplex.l"
{ check_comments ("AUTHOR", pptext); }
    YY_BREAK
case 37:
YY_RULE_SETUP
#line 366 "pplex.l"
{ check_comments ("DATE-WRITTEN", pptext); }
    YY_BREAK
case 38:
YY_RULE_SETUP
#line 367 "pplex.l"
{ check_comments ("DATE-MODIFIED", pptext); }
    YY_BREAK
case 39:
YY_RULE_SETUP
#line 368 "pplex.l"
{ check_comments ("DATE-COMPILED", pptext); }
    YY_BREAK
case 40:
YY_RULE_SETUP
#line 369 "pplex.l"
{ check_comments ("INSTALLATION", pptext); }
    YY_BREAK
case 41:
YY_RULE_SETUP
#line 370 "pplex.l"
{ check_comments ("REMARKS", pptext); }
    YY_BREAK
case 42:
YY_RULE_SETUP
#line 371 "pplex.l"
{ check_comments ("SECURITY", pptext); }
    YY_BREAK
case 43:
#line 374 "pplex.l"
case 44:
#line 375 "pplex.l"
case 45:
#line 376 "pplex.l"
case 46:
YY_RULE_SETUP
#line 376 "pplex.l"
{
    /* These words are comments in various COBOL dialects */
    if (cb_verify (cb_eject_statement, pptext)) {
        /* Ignore */
    } else {
        ECHO;
        check_listing (pptext, 0);
    }
}
    YY_BREAK
case 47:
#line 387 "pplex.l"
case 48:
YY_RULE_SETUP
#line 387 "pplex.l"
{
    /* Pick up early - Also activates debugging lines */
    cb_flag_debugging_line = 1;
    ppecho (pptext, 0, ppleng);
}
    YY_BREAK
case 49:
/* rule 49 can match eol */
YY_RULE_SETUP
#line 393 "pplex.l"
{
    ppecho ("\n", 0, 1);
    cb_source_line++;
}
    YY_BREAK
case 50:
YY_RULE_SETUP
#line 398 "pplex.l"
{
    ppecho (" ", 1U, 1);
}
    YY_BREAK
case 51:
YY_RULE_SETUP
#line 402 "pplex.l"
{
    if (inside_bracket) {
        ppecho (", ", 0, 2);
    } else {
        ppecho (" ", 1U, 1);
    }
}
    YY_BREAK
case 52:
YY_RULE_SETUP
#line 410 "pplex.l"
{
    inside_bracket++;
    ppecho ("(", 0, 1);
}
    YY_BREAK
case 53:
YY_RULE_SETUP
#line 415 "pplex.l"
{
    if (inside_bracket) {
        inside_bracket--;
    }
    ppecho (")", 0, 1);
}
    YY_BREAK
case 54:
#line 423 "pplex.l"
case 55:
#line 424 "pplex.l"
case 56:
#line 425 "pplex.l"
case 57:
YY_RULE_SETUP
#line 425 "pplex.l"
{
    ppecho (pptext, 0, ppleng);
}
    YY_BREAK

case 58:
/* rule 58 can match eol */
YY_RULE_SETUP
#line 430 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 59:
YY_RULE_SETUP
#line 435 "pplex.l"
{ return FORMAT; }
    YY_BREAK
case 60:
YY_RULE_SETUP
#line 436 "pplex.l"
{ return IS; }
    YY_BREAK
case 61:
YY_RULE_SETUP
#line 437 "pplex.l"
{ return FIXED; }
    YY_BREAK
case 62:
YY_RULE_SETUP
#line 438 "pplex.l"
{ return FREE; }
    YY_BREAK
case 63:
YY_RULE_SETUP
#line 439 "pplex.l"
{ /* ignore */ }
    YY_BREAK
case 64:
YY_RULE_SETUP
#line 440 "pplex.l"
{ }
    YY_BREAK


case 65:
/* rule 65 can match eol */
YY_RULE_SETUP
#line 444 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 66:
YY_RULE_SETUP
#line 449 "pplex.l"
{
    return CONSTANT;
  }
    YY_BREAK
case 67:
YY_RULE_SETUP
#line 452 "pplex.l"
{
    return AS;
  }
    YY_BREAK
case 68:
YY_RULE_SETUP
#line 455 "pplex.l"
{
    return OFF;
  }
    YY_BREAK
case 69:
YY_RULE_SETUP
#line 458 "pplex.l"
{
    return OVERRIDE;
  }
    YY_BREAK
case 70:
YY_RULE_SETUP
#line 461 "pplex.l"
{
    return PARAMETER;
  }
    YY_BREAK
case 71:
#line 465 "pplex.l"
case 72:
YY_RULE_SETUP
#line 465 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return LITERAL;
  }
    YY_BREAK
case 73:
YY_RULE_SETUP
#line 469 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return VARIABLE;
  }
    YY_BREAK
case 74:
YY_RULE_SETUP
#line 473 "pplex.l"
{ /* ignore */ }
    YY_BREAK
case 75:
YY_RULE_SETUP
#line 474 "pplex.l"
{ }
    YY_BREAK


case 76:
/* rule 76 can match eol */
YY_RULE_SETUP
#line 478 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 77:
YY_RULE_SETUP
#line 483 "pplex.l"
{
    return CONSTANT;
  }
    YY_BREAK
case 78:
YY_RULE_SETUP
#line 486 "pplex.l"
{
    return SOURCEFORMAT;
  }
    YY_BREAK
case 79:
#line 490 "pplex.l"
case 80:
YY_RULE_SETUP
#line 490 "pplex.l"
{
    return FOLDCOPYNAME;
  }
    YY_BREAK
case 81:
#line 494 "pplex.l"
case 82:
YY_RULE_SETUP
#line 494 "pplex.l"
{
    return NOFOLDCOPYNAME;
  }
    YY_BREAK
case 83:
YY_RULE_SETUP
#line 497 "pplex.l"
{
    return AS;
  }
    YY_BREAK
case 84:
#line 501 "pplex.l"
case 85:
YY_RULE_SETUP
#line 501 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return LITERAL;
  }
    YY_BREAK
case 86:
YY_RULE_SETUP
#line 505 "pplex.l"
{
    pptext[strlen (pptext) - 1] = 0;
    pplval.s = cobc_plex_strdup (pptext + 1);
    return LITERAL;
  }
    YY_BREAK
case 87:
YY_RULE_SETUP
#line 510 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return VARIABLE;
  }
    YY_BREAK
case 88:
YY_RULE_SETUP
#line 514 "pplex.l"
{ /* ignore */ }
    YY_BREAK
case 89:
YY_RULE_SETUP
#line 515 "pplex.l"
{ }
    YY_BREAK


case 90:
/* rule 90 can match eol */
YY_RULE_SETUP
#line 519 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 91:
YY_RULE_SETUP
#line 524 "pplex.l"
{
    return ON;
  }
    YY_BREAK
case 92:
YY_RULE_SETUP
#line 527 "pplex.l"
{
    return OFF;
  }
    YY_BREAK
case 93:
YY_RULE_SETUP
#line 530 "pplex.l"
{
    return WITH;
  }
    YY_BREAK
case 94:
YY_RULE_SETUP
#line 533 "pplex.l"
{
    return LOCATION;
  }
    YY_BREAK
case 95:
YY_RULE_SETUP
#line 536 "pplex.l"
{
    return CHECKING;
  }
    YY_BREAK
case 96:
#line 540 "pplex.l"
case 97:
YY_RULE_SETUP
#line 540 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return LITERAL;
  }
    YY_BREAK
case 98:
YY_RULE_SETUP
#line 544 "pplex.l"
{
    pptext[strlen (pptext) - 1] = 0;
    pplval.s = cobc_plex_strdup (pptext + 1);
    return LITERAL;
  }
    YY_BREAK
case 99:
YY_RULE_SETUP
#line 549 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return VARIABLE;
  }
    YY_BREAK
case 100:
YY_RULE_SETUP
#line 553 "pplex.l"
{ /* ignore */ }
    YY_BREAK
case 101:
YY_RULE_SETUP
#line 554 "pplex.l"
{ }
    YY_BREAK


case 102:
/* rule 102 can match eol */
YY_RULE_SETUP
#line 558 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 103:
YY_RULE_SETUP
#line 563 "pplex.l"
{ /* ignore */ }
    YY_BREAK
case 104:
YY_RULE_SETUP
#line 564 "pplex.l"
{ return IS; }
    YY_BREAK
case 105:
YY_RULE_SETUP
#line 565 "pplex.l"
{ return NOT; }
    YY_BREAK
case 106:
YY_RULE_SETUP
#line 566 "pplex.l"
{ return EQUAL; }
    YY_BREAK
case 107:
YY_RULE_SETUP
#line 567 "pplex.l"
{ return TO; }
    YY_BREAK
case 108:
YY_RULE_SETUP
#line 568 "pplex.l"
{ return OR; }
    YY_BREAK
case 109:
YY_RULE_SETUP
#line 569 "pplex.l"
{ return GREATER; }
    YY_BREAK
case 110:
YY_RULE_SETUP
#line 570 "pplex.l"
{ return LESS; }
    YY_BREAK
case 111:
YY_RULE_SETUP
#line 571 "pplex.l"
{ return THAN; }
    YY_BREAK
case 112:
YY_RULE_SETUP
#line 572 "pplex.l"
{ return DEFINED; }
    YY_BREAK
case 113:
YY_RULE_SETUP
#line 573 "pplex.l"
{ return SET; }
    YY_BREAK
case 114:
YY_RULE_SETUP
#line 574 "pplex.l"
{ return GE; }
    YY_BREAK
case 115:
YY_RULE_SETUP
#line 575 "pplex.l"
{ return GT; }
    YY_BREAK
case 116:
YY_RULE_SETUP
#line 576 "pplex.l"
{ return LE; }
    YY_BREAK
case 117:
YY_RULE_SETUP
#line 577 "pplex.l"
{ return NE; }
    YY_BREAK
case 118:
YY_RULE_SETUP
#line 578 "pplex.l"
{ return LT; }
    YY_BREAK
case 119:
YY_RULE_SETUP
#line 579 "pplex.l"
{ return EQ; }
    YY_BREAK
case 120:
#line 581 "pplex.l"
case 121:
YY_RULE_SETUP
#line 581 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return LITERAL;
  }
    YY_BREAK
case 122:
YY_RULE_SETUP
#line 585 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return VARIABLE;
  }
    YY_BREAK
case 123:
YY_RULE_SETUP
#line 589 "pplex.l"
{ }
    YY_BREAK


case 124:
/* rule 124 can match eol */
YY_RULE_SETUP
#line 593 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 125:
YY_RULE_SETUP
#line 598 "pplex.l"
{ /* ignore */ }
    YY_BREAK


case 126:
/* rule 126 can match eol */
YY_RULE_SETUP
#line 602 "pplex.l"
{
    BEGIN INITIAL;
    unput ('\n');
    return TERMINATOR;
  }
    YY_BREAK
case 127:
YY_RULE_SETUP
#line 607 "pplex.l"
{ /* ignore */ }
    YY_BREAK


case 128:
/* rule 128 can match eol */
YY_RULE_SETUP
#line 611 "pplex.l"
{
    ECHO;
    check_listing (pptext, 0);
    cb_source_line++;
  }
    YY_BREAK
case 129:
YY_RULE_SETUP
#line 616 "pplex.l"
{ /* ignore */ }
    YY_BREAK
case 130:
YY_RULE_SETUP
#line 617 "pplex.l"
{ yy_pop_state (); return DOT; }
    YY_BREAK
case 131:
YY_RULE_SETUP
#line 618 "pplex.l"
{ yy_push_state (PSEUDO_STATE); return EQEQ; }
    YY_BREAK
case 132:
YY_RULE_SETUP
#line 619 "pplex.l"
{ return '('; }
    YY_BREAK
case 133:
YY_RULE_SETUP
#line 620 "pplex.l"
{ return ')'; }
    YY_BREAK
case 134:
YY_RULE_SETUP
#line 621 "pplex.l"
{ return BY; }
    YY_BREAK
case 135:
YY_RULE_SETUP
#line 622 "pplex.l"
{ return IN; }
    YY_BREAK
case 136:
YY_RULE_SETUP
#line 623 "pplex.l"
{ return OF; }
    YY_BREAK
case 137:
YY_RULE_SETUP
#line 624 "pplex.l"
{ return OFF; }
    YY_BREAK
case 138:
YY_RULE_SETUP
#line 625 "pplex.l"
{ return SUPPRESS; }
    YY_BREAK
case 139:
YY_RULE_SETUP
#line 626 "pplex.l"
{ return PRINTING; }
    YY_BREAK
case 140:
YY_RULE_SETUP
#line 627 "pplex.l"
{ return REPLACING; }
    YY_BREAK
case 141:
YY_RULE_SETUP
#line 628 "pplex.l"
{ return LEADING; }
    YY_BREAK
case 142:
YY_RULE_SETUP
#line 629 "pplex.l"
{ return TRAILING; }
    YY_BREAK
case 143:
YY_RULE_SETUP
#line 630 "pplex.l"
{ return ALSO; }
    YY_BREAK
case 144:
YY_RULE_SETUP
#line 631 "pplex.l"
{ return LAST; }
    YY_BREAK
case 145:
#line 633 "pplex.l"
case 146:
#line 634 "pplex.l"
case 147:
#line 635 "pplex.l"
case 148:
YY_RULE_SETUP
#line 635 "pplex.l"
{ pplval.s = cobc_plex_strdup (pptext); return TOKEN; }
    YY_BREAK


case 149:
/* rule 149 can match eol */
YY_RULE_SETUP
#line 639 "pplex.l"
{
    ECHO;
    check_listing (pptext, 0);
    cb_source_line++;
  }
    YY_BREAK
case 150:
YY_RULE_SETUP
#line 645 "pplex.l"
{
    pplval.s = cobc_plex_strdup (" ");
    return TOKEN;
  }
    YY_BREAK
case 151:
YY_RULE_SETUP
#line 650 "pplex.l"
{
    yy_pop_state ();
    return EQEQ;
  }
    YY_BREAK
case 152:
#line 656 "pplex.l"
case 153:
#line 657 "pplex.l"
case 154:
#line 658 "pplex.l"
case 155:
YY_RULE_SETUP
#line 658 "pplex.l"
{
    pplval.s = cobc_plex_strdup (pptext);
    return TOKEN;
  }
    YY_BREAK

case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(COPY_STATE):
case YY_STATE_EOF(PSEUDO_STATE):
case YY_STATE_EOF(SOURCE_DIRECTIVE_STATE):
case YY_STATE_EOF(DEFINE_DIRECTIVE_STATE):
case YY_STATE_EOF(SET_DIRECTIVE_STATE):
case YY_STATE_EOF(TURN_DIRECTIVE_STATE):
case YY_STATE_EOF(IF_DIRECTIVE_STATE):
case YY_STATE_EOF(ELSE_DIRECTIVE_STATE):
case YY_STATE_EOF(ENDIF_DIRECTIVE_STATE):
#line 665 "pplex.l"
{
    struct copy_info *p;

    p = copy_stack;

    pp_delete_buffer (YY_CURRENT_BUFFER);

    /* Terminate at the end of all input */
    if (p->next == NULL) {
        /* Check dangling IF/ELSE */
        for (; plex_nest_depth > 0; --plex_nest_depth) {
            cb_source_line = plex_cond_stack[plex_nest_depth].line;
            cb_error (_("Dangling IF/ELSE directive"));
        }
        plex_nest_depth = 0;
        cobc_free (p->dname);
        cobc_free (p);
        listing_line = 0;
        requires_listing_line = 1;
        requires_new_line = 0;
        need_continuation = 0;
        buffer_overflow = 0;
        within_comment = 0;
        newline_count = 0;
        inside_bracket = 0;
        comment_allowed = 1;
        current_replace_list = NULL;
        base_replace_list = NULL;
        save_current_replace = NULL;
        text_queue = NULL;
        copy_stack = NULL;
        quotation_mark = 0;
        consecutive_quotation = 0;
        yyterminate ();
    }

    /* Close the current file */
    fclose (ppin);

    /* Switch to previous buffer */
    switch_to_buffer (p->line, p->file, p->buffer);

    /* Restore variables */
    current_replace_list = p->replacing;
    quotation_mark = p->quotation_mark;
    cb_source_format = p->source_format;

    copy_stack = p->next;
    cobc_free (p->dname);
    cobc_free (p);
}
    YY_BREAK
case 156:
YY_RULE_SETUP
#line 717 "pplex.l"
YY_FATAL_ERROR( "flex scanner jammed" );
    YY_BREAK
#line 3510 "pplex.c"

    case YY_END_OF_BUFFER:
        {
        /* Amount of text matched not including the EOB char. */
        int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;

        /* Undo the effects of YY_DO_BEFORE_ACTION. */
        *yy_cp = (yy_hold_char);
        YY_RESTORE_YY_MORE_OFFSET

        if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
            {
            /* We're scanning a new file or input source.  It's
             * possible that this happened because the user
             * just pointed ppin at a new source and called
             * pplex().  If so, then we have to assure
             * consistency between YY_CURRENT_BUFFER and our
             * globals.  Here is the right place to do so, because
             * this is the first action (other than possibly a
             * back-up) that will match for the new input source.
             */
            (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
            YY_CURRENT_BUFFER_LVALUE->yy_input_file = ppin;
            YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
            }

        /* Note that here we test for yy_c_buf_p "<=" to the position
         * of the first EOB in the buffer, since yy_c_buf_p will
         * already have been incremented past the NUL character
         * (since all states make transitions on EOB to the
         * end-of-buffer state).  Contrast this with the test
         * in input().
         */
        if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
            { /* This was really a NUL. */
            yy_state_type yy_next_state;

            (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;

            yy_current_state = yy_get_previous_state(  );

            /* Okay, we're now positioned to make the NUL
             * transition.  We couldn't have
             * yy_get_previous_state() go ahead and do it
             * for us because it doesn't know how to deal
             * with the possibility of jamming (and we don't
             * want to build jamming into it because then it
             * will run more slowly).
             */

            yy_next_state = yy_try_NUL_trans( yy_current_state );

            yy_bp = (yytext_ptr) + YY_MORE_ADJ;

            if ( yy_next_state )
                {
                /* Consume the NUL. */
                yy_cp = ++(yy_c_buf_p);
                yy_current_state = yy_next_state;
                goto yy_match;
                }

            else
                {
                yy_cp = (yy_last_accepting_cpos);
                yy_current_state = (yy_last_accepting_state);
                goto yy_find_action;
                }
            }

        else switch ( yy_get_next_buffer(  ) )
            {
            case EOB_ACT_END_OF_FILE:
                {
                (yy_did_buffer_switch_on_eof) = 0;

                if ( ppwrap( ) )
                    {
                    /* Note: because we've taken care in
                     * yy_get_next_buffer() to have set up
                     * pptext, we can now set up
                     * yy_c_buf_p so that if some total
                     * hoser (like flex itself) wants to
                     * call the scanner after we return the
                     * YY_NULL, it'll still work - another
                     * YY_NULL will get returned.
                     */
                    (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

                    yy_act = YY_STATE_EOF(YY_START);
                    goto do_action;
                    }

                else
                    {
                    if ( ! (yy_did_buffer_switch_on_eof) )
                        YY_NEW_FILE;
                    }
                break;
                }

            case EOB_ACT_CONTINUE_SCAN:
                (yy_c_buf_p) =
                    (yytext_ptr) + yy_amount_of_matched_text;

                yy_current_state = yy_get_previous_state(  );

                yy_cp = (yy_c_buf_p);
                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                goto yy_match;

            case EOB_ACT_LAST_MATCH:
                (yy_c_buf_p) =
                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];

                yy_current_state = yy_get_previous_state(  );

                yy_cp = (yy_c_buf_p);
                yy_bp = (yytext_ptr) + YY_MORE_ADJ;
                goto yy_find_action;
            }
        break;
        }

    default:
        YY_FATAL_ERROR(
            "fatal flex scanner internal error--no action found" );
    } /* end of action switch */
        } /* end of scanning one token */
    } /* end of user's declarations */
} /* end of pplex */

Here is the call graph for this function:

int pplex_destroy

(

void

)

Definition at line 4314 of file pplex.c.

References NULL, pp_delete_buffer(), ppfree(), pppop_buffer_state(), yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_globals(), and yy_start_stack.

Referenced by plex_call_destroy().

{
    
    /* Pop the buffer stack, destroying each element. */
    while(YY_CURRENT_BUFFER){
        pp_delete_buffer(YY_CURRENT_BUFFER  );
        YY_CURRENT_BUFFER_LVALUE = NULL;
        pppop_buffer_state();
    }

    /* Destroy the stack itself. */
    ppfree((yy_buffer_stack) );
    (yy_buffer_stack) = NULL;

    /* Destroy the start condition stack. */
        ppfree((yy_start_stack)  );
        (yy_start_stack) = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * pplex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int ppopen	(	const char *	name,
		struct cb_replace_list *	replacing_list
	)

Definition at line 4420 of file pplex.c.

References _, copy_info::buffer, cb_error(), cb_source_file, cb_source_format, cb_source_line, COB_DASH, cobc_malloc(), cobc_strdup(), copy_stack, current_replace_list, copy_info::dname, errorcount, copy_info::file, cb_replace_list::last, copy_info::line, cb_replace_list::next, copy_info::next, pp_create_buffer(), ppin, copy_info::quotation_mark, quotation_mark, copy_info::replacing, copy_info::source_format, switch_to_buffer(), YY_BUF_SIZE, and YY_CURRENT_BUFFER.

Referenced by ppcopy(), and preprocess().

{
    struct copy_info    *p;
    char            *s;
    char            *dname;

    unsigned char       bom[4];

    if (ppin) {
        for (; newline_count > 0; newline_count--) {
            ungetc ('\n', ppin);
        }
    }

    /* Open copy/source file, or use stdin */
    if (strcmp(name, COB_DASH) == 0) {
        ppin = stdin;
    } else {
#ifdef  __OS400__
        ppin = fopen (name, "r");
#else
        ppin = fopen (name, "rb");
#endif
    }

    if (!ppin) {
        if (cb_source_file) {
            cb_error ("%s: %s", name,
                  _("No such file or directory"));
        } else {
            fflush (stderr);
            fprintf (stderr, "%s: %s", name,
                 _("No such file or directory"));
            fflush (stderr);
            errorcount++;
        }
        return -1;
    }

    /* Check for BOM - *not* for input from stdin as rewind() clears the input
      buffer if used on stdin and output in console has normally no BOM at all */
    if (strcmp(name, COB_DASH) != 0) {
        if (fread (bom, 3, 1, ppin) == 1) {
            if (bom[0] != 0xEF || bom[1] != 0xBB || bom[2] != 0xBF) {
                rewind (ppin);
            }
        } else {
            rewind (ppin);
        }
    }

    /* Preserve the current buffer */
    p = cobc_malloc (sizeof (struct copy_info));
    p->file = cb_source_file;
    p->buffer = YY_CURRENT_BUFFER;

    /* Save variables */
    p->replacing = current_replace_list;
    p->line = cb_source_line;
    p->quotation_mark = quotation_mark;
    p->source_format = cb_source_format;

    p->next = copy_stack;
    copy_stack = p;

    /* Set replacing list */
    if (replacing_list) {
        if (current_replace_list) {
            replacing_list->last->next = current_replace_list;
            replacing_list->last = current_replace_list->last;
        }
        current_replace_list = replacing_list;
    }

    dname = cobc_strdup (name);
    p->dname = dname;
    for (s = dname; *s; ++s) {
        if (*s == '\\') {
            *s = '/';
        }
    }

    /* Switch to new buffer */
    switch_to_buffer (1, dname, pp_create_buffer (ppin, YY_BUF_SIZE));
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ppparse_error

(

const char *

msg

)

Definition at line 4553 of file pplex.c.

References cb_plex_error().

{
    cb_plex_error (newline_count, msg);
}

Here is the call graph for this function:

void pppop_buffer_state

(

void

)

Removes and deletes the top of the stack, if present.

The next element becomes the new top.

Definition at line 4154 of file pplex.c.

References NULL, pp_delete_buffer(), pp_load_buffer_state(), yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, and yy_did_buffer_switch_on_eof.

Referenced by pplex_destroy().

{
        if (!YY_CURRENT_BUFFER)
        return;

    pp_delete_buffer(YY_CURRENT_BUFFER );
    YY_CURRENT_BUFFER_LVALUE = NULL;
    if ((yy_buffer_stack_top) > 0)
        --(yy_buffer_stack_top);

    if (YY_CURRENT_BUFFER) {
        pp_load_buffer_state( );
        (yy_did_buffer_switch_on_eof) = 1;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void pppush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

Pushes the new state onto the stack.

The new state becomes the current state. This function will allocate the stack if necessary.

Parameters

new_buffer

The new state.

Definition at line 4124 of file pplex.c.

References NULL, pp_load_buffer_state(), ppensure_buffer_stack(), yy_buffer_stack_top, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, and yy_n_chars.

{
        if (new_buffer == NULL)
        return;

    ppensure_buffer_stack();

    /* This block is copied from pp_switch_to_buffer. */
    if ( YY_CURRENT_BUFFER )
        {
        /* Flush out information for old buffer. */
        *(yy_c_buf_p) = (yy_hold_char);
        YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
        }

    /* Only push if top exists. Otherwise, replace top. */
    if (YY_CURRENT_BUFFER)
        (yy_buffer_stack_top)++;
    YY_CURRENT_BUFFER_LVALUE = new_buffer;

    /* copied from pp_switch_to_buffer. */
    pp_load_buffer_state( );
    (yy_did_buffer_switch_on_eof) = 1;
}

Here is the call graph for this function:

void * pprealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 4368 of file pplex.c.

Referenced by ppensure_buffer_stack(), yy_get_next_buffer(), and yy_push_state().

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

Here is the caller graph for this function:

void pprestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 3958 of file pplex.c.

References pp_create_buffer(), pp_init_buffer(), pp_load_buffer_state(), ppensure_buffer_stack(), ppin, YY_BUF_SIZE, YY_CURRENT_BUFFER, and YY_CURRENT_BUFFER_LVALUE.

Referenced by input(), and yy_get_next_buffer().

{
    
    if ( ! YY_CURRENT_BUFFER ){
        ppensure_buffer_stack ();
        YY_CURRENT_BUFFER_LVALUE =
            pp_create_buffer(ppin,YY_BUF_SIZE );
    }

    pp_init_buffer(YY_CURRENT_BUFFER,input_file );
    pp_load_buffer_state( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int ppwrap ( void  )

static

Definition at line 2068 of file pplex.c.

Referenced by input(), and pplex().

                         {
    return 1;
}

Here is the caller graph for this function:

static void skip_to_eol ( void  )

static

Definition at line 5268 of file pplex.c.

References input(), and unput.

Referenced by check_comments(), and pplex().

{
    int c;

    /* Skip bytes to end of line */
    while ((c = input ()) != EOF) {
        if (c == '\n') {
            break;
        }
    }
    if (c != EOF) {
        unput (c);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void switch_to_buffer ( const int  line, const char *  file, const YY_BUFFER_STATE  buffer  )

static

Definition at line 4677 of file pplex.c.

References cb_source_file, cb_source_line, cobc_plex_strdup(), line, pp_switch_to_buffer(), and ppout.

Referenced by pplex(), and ppopen().

{
    /* Reset file/line */
    cb_source_line = line;
    cb_source_file = cobc_plex_strdup (file);
    fprintf (ppout, "#line %d \"%s\"\n", line, file);
    /* Switch buffer */
    pp_switch_to_buffer (buffer);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void yy_fatal_error ( char  msg[] )

static

static void yy_fatal_error ( char *  msg )

static

Definition at line 4252 of file pplex.c.

References YY_EXIT_FAILURE.

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

static int yy_get_next_buffer ( void  )

static

Definition at line 3650 of file pplex.c.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, ppin, pprealloc(), pprestart(), yy_buffer_state::yy_buf_size, YY_BUFFER_EOF_PENDING, yy_c_buf_p, yy_buffer_state::yy_ch_buf, YY_CURRENT_BUFFER_LVALUE, YY_END_OF_BUFFER_CHAR, YY_FATAL_ERROR, YY_INPUT, yy_buffer_state::yy_is_our_buffer, YY_MORE_ADJ, yy_n_chars, YY_READ_BUF_SIZE, and yytext_ptr.

Referenced by input(), and pplex().

{
        register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
    register char *source = (yytext_ptr);
    register int number_to_move, i;
    int ret_val;

    if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
        YY_FATAL_ERROR(
        "fatal flex scanner internal error--end of buffer missed" );

    if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
        { /* Don't try to fill the buffer, so this is an EOF. */
        if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
            {
            /* We matched a single character, the EOB, so
             * treat this as a final EOF.
             */
            return EOB_ACT_END_OF_FILE;
            }

        else
            {
            /* We matched some text prior to the EOB, first
             * process it.
             */
            return EOB_ACT_LAST_MATCH;
            }
        }

    /* Try to read more data. */

    /* First move last chars to start of buffer. */
    number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;

    for ( i = 0; i < number_to_move; ++i )
        *(dest++) = *(source++);

    if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
        /* don't do the read, it's not guaranteed to return an EOF,
         * just force an EOF
         */
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;

    else
        {
            yy_size_t num_to_read =
            YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;

        while ( num_to_read <= 0 )
            { /* Not enough room in the buffer - grow it. */

            /* just a shorter name for the current buffer */
            YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;

            int yy_c_buf_p_offset =
                (int) ((yy_c_buf_p) - b->yy_ch_buf);

            if ( b->yy_is_our_buffer )
                {
                yy_size_t new_size = b->yy_buf_size * 2;

                if ( new_size <= 0 )
                    b->yy_buf_size += b->yy_buf_size / 8;
                else
                    b->yy_buf_size *= 2;

                b->yy_ch_buf = (char *)
                    /* Include room in for 2 EOB chars. */
                    pprealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
                }
            else
                /* Can't grow it, we don't own it. */
                b->yy_ch_buf = 0;

            if ( ! b->yy_ch_buf )
                YY_FATAL_ERROR(
                "fatal error - scanner input buffer overflow" );

            (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];

            num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
                        number_to_move - 1;

            }

        if ( num_to_read > YY_READ_BUF_SIZE )
            num_to_read = YY_READ_BUF_SIZE;

        /* Read in more data. */
        YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
            (yy_n_chars), num_to_read );

        YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
        }

    if ( (yy_n_chars) == 0 )
        {
        if ( number_to_move == YY_MORE_ADJ )
            {
            ret_val = EOB_ACT_END_OF_FILE;
            pprestart(ppin  );
            }

        else
            {
            ret_val = EOB_ACT_LAST_MATCH;
            YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
                YY_BUFFER_EOF_PENDING;
            }
        }

    else
        ret_val = EOB_ACT_CONTINUE_SCAN;

    if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
        /* Extend the array by 50%, plus the number we really need. */
        yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
        YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) pprealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
        if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    }

    (yy_n_chars) += number_to_move;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
    YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;

    (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];

    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static yy_state_type yy_get_previous_state ( void  )

static

Definition at line 3784 of file pplex.c.

References YY_AT_BOL, yy_c_buf_p, yy_last_accepting_cpos, yy_last_accepting_state, YY_MORE_ADJ, YY_SC_TO_UI, yy_start, and yytext_ptr.

Referenced by pplex().

{
    register yy_state_type yy_current_state;
    register char *yy_cp;
    
    yy_current_state = (yy_start);
    yy_current_state += YY_AT_BOL();

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

    return yy_current_state;
}

Here is the caller graph for this function:

static int yy_init_globals ( void  )

static

Get the current token.

Definition at line 4281 of file pplex.c.

References NULL, ppin, ppout, yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yy_c_buf_p, yy_init, yy_start, yy_start_stack, yy_start_stack_depth, and yy_start_stack_ptr.

Referenced by pplex_destroy().

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from pplex_destroy(), so don't allocate here.
     */

    (yy_buffer_stack) = 0;
    (yy_buffer_stack_top) = 0;
    (yy_buffer_stack_max) = 0;
    (yy_c_buf_p) = (char *) 0;
    (yy_init) = 0;
    (yy_start) = 0;

    (yy_start_stack_ptr) = 0;
    (yy_start_stack_depth) = 0;
    (yy_start_stack) =  NULL;

/* Defined in main.c */
#ifdef YY_STDINIT
    ppin = stdin;
    ppout = stdout;
#else
    ppin = (FILE *) 0;
    ppout = (FILE *) 0;
#endif

    /* For future reference: Set errno on error, since we are called by
     * pplex_init()
     */
    return 0;
}

Here is the caller graph for this function:

static void yy_pop_state ( void  )

static

Definition at line 4240 of file pplex.c.

References BEGIN, and YY_FATAL_ERROR.

Referenced by pplex().

{
        if ( --(yy_start_stack_ptr) < 0 )
        YY_FATAL_ERROR( "start-condition stack underflow" );

    BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
}

Here is the caller graph for this function:

static void yy_push_state ( int  new_state )

static

Definition at line 4216 of file pplex.c.

References BEGIN, ppalloc(), pprealloc(), YY_FATAL_ERROR, YY_START, yy_start_stack, yy_start_stack_depth, and YY_START_STACK_INCR.

Referenced by pplex().

{
        if ( (yy_start_stack_ptr) >= (yy_start_stack_depth) )
        {
        yy_size_t new_size;

        (yy_start_stack_depth) += YY_START_STACK_INCR;
        new_size = (yy_start_stack_depth) * sizeof( int );

        if ( ! (yy_start_stack) )
            (yy_start_stack) = (int *) ppalloc(new_size  );

        else
            (yy_start_stack) = (int *) pprealloc((void *) (yy_start_stack),new_size  );

        if ( ! (yy_start_stack) )
            YY_FATAL_ERROR( "out of memory expanding start-condition stack" );
        }

    (yy_start_stack)[(yy_start_stack_ptr)++] = YY_START;

    BEGIN(new_state);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 3817 of file pplex.c.

References yy_c_buf_p, yy_last_accepting_cpos, and yy_last_accepting_state.

Referenced by pplex().

{
    register int yy_is_jam;
        register char *yy_cp = (yy_c_buf_p);

    register YY_CHAR yy_c = 1;
    if ( yy_accept[yy_current_state] )
        {
        (yy_last_accepting_state) = yy_current_state;
        (yy_last_accepting_cpos) = yy_cp;
        }
    while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
        {
        yy_current_state = (int) yy_def[yy_current_state];
        if ( yy_current_state >= 1082 )
            yy_c = yy_meta[(unsigned int) yy_c];
        }
    yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    yy_is_jam = (yy_current_state == 1081);

        return yy_is_jam ? 0 : yy_current_state;
}

Here is the caller graph for this function:

static void yyunput ( int  c, char *  buf_ptr  )

static

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

static

Definition at line 3840 of file pplex.c.

References yy_c_buf_p, YY_CURRENT_BUFFER_LVALUE, YY_FATAL_ERROR, yy_hold_char, yy_n_chars, and yytext_ptr.

{
    register char *yy_cp;
    
    yy_cp = (yy_c_buf_p);

    /* undo effects of setting up pptext */
    *yy_cp = (yy_hold_char);

    if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
        { /* need to shift things up to make room */
        /* +2 for EOB chars. */
        register yy_size_t number_to_move = (yy_n_chars) + 2;
        register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
                    YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
        register char *source =
                &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];

        while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            *--dest = *--source;

        yy_cp += (int) (dest - source);
        yy_bp += (int) (dest - source);
        YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
            (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;

        if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
            YY_FATAL_ERROR( "flex scanner push-back overflow" );
        }

    *--yy_cp = (char) c;

    (yytext_ptr) = yy_bp;
    (yy_hold_char) = *yy_cp;
    (yy_c_buf_p) = yy_cp;
}

Variable Documentation

struct cb_replace_list* base_replace_list = ((void*)0)

static

Definition at line 2147 of file pplex.c.

Referenced by pp_set_replace_list(), and ppecho().

size_t buffer_overflow = 0

static

Definition at line 2136 of file pplex.c.

size_t comment_allowed

static

Definition at line 2137 of file pplex.c.

size_t consecutive_quotation = 0

static

Definition at line 2134 of file pplex.c.

struct copy_info* copy_stack = ((void*)0)

static

Definition at line 2151 of file pplex.c.

Referenced by pplex(), and ppopen().

struct cb_replace_list* current_replace_list = ((void*)0)

static

Definition at line 2145 of file pplex.c.

Referenced by ppopen().

size_t inside_bracket = 0

static

Definition at line 2133 of file pplex.c.

int listing_line = 0

static

Definition at line 2141 of file pplex.c.

size_t need_continuation = 0

static

Definition at line 2135 of file pplex.c.

size_t newline_count = 0

static

Definition at line 2131 of file pplex.c.

Referenced by ppinput().

struct plex_stack plex_cond_stack[16]

static

Definition at line 2153 of file pplex.c.

Referenced by plex_action_directive(), plex_clear_vars(), and pplex().

unsigned int plex_nest_depth = 0

static

Definition at line 2139 of file pplex.c.

Referenced by plex_action_directive(), and pplex().

unsigned int plex_skip_input = 0

static

Definition at line 2138 of file pplex.c.

char* plexbuff1 = ((void*)0)

static

Definition at line 2129 of file pplex.c.

Referenced by ppcopy().

char* plexbuff2 = ((void*)0)

static

Definition at line 2130 of file pplex.c.

int pp_flex_debug = 0

Definition at line 2031 of file pplex.c.

FILE* ppin = (FILE *) 0

Definition at line 367 of file pplex.c.

Referenced by input(), pp_load_buffer_state(), ppinput(), pplex(), ppopen(), pprestart(), yy_get_next_buffer(), and yy_init_globals().

yy_size_t ppleng

Definition at line 305 of file pplex.c.

Referenced by check_comments(), and pplex().

int pplineno = 1

Definition at line 373 of file pplex.c.

FILE * ppout = (FILE *) 0

Definition at line 367 of file pplex.c.

Referenced by ppecho(), pplex(), switch_to_buffer(), and yy_init_globals().

char * pptext

Definition at line 2040 of file pplex.c.

Referenced by ppecho().

int quotation_mark = 0

static

Definition at line 2140 of file pplex.c.

Referenced by ppopen().

int requires_listing_line

static

Definition at line 2142 of file pplex.c.

int requires_new_line = 0

static

Definition at line 2143 of file pplex.c.

struct cb_replace_list* save_current_replace = ((void*)0)

static

Definition at line 2146 of file pplex.c.

struct cb_text_list* text_queue = ((void*)0)

static

Definition at line 2149 of file pplex.c.

Referenced by ppecho().

size_t within_comment = 0

static

Definition at line 2132 of file pplex.c.

flex_int16_t yy_accept[1082]

static

Definition at line 402 of file pplex.c.

flex_int16_t yy_base[1183]

static

Definition at line 569 of file pplex.c.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 285 of file pplex.c.

Referenced by ppensure_buffer_stack(), pplex_destroy(), and yy_init_globals().

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 284 of file pplex.c.

Referenced by ppensure_buffer_stack(), and yy_init_globals().

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 283 of file pplex.c.

Referenced by ppensure_buffer_stack(), pppop_buffer_state(), pppush_buffer_state(), and yy_init_globals().

char* yy_c_buf_p = (char *) 0

static

Definition at line 308 of file pplex.c.

Referenced by input(), pp_load_buffer_state(), pp_switch_to_buffer(), pplex(), pppush_buffer_state(), yy_get_next_buffer(), yy_get_previous_state(), yy_init_globals(), yy_try_NUL_trans(), and yyunput().

flex_int16_t yy_chk[5374]

static

Definition at line 1432 of file pplex.c.

flex_int16_t yy_def[1183]

static

Definition at line 703 of file pplex.c.

int yy_did_buffer_switch_on_eof

static

Definition at line 315 of file pplex.c.

Referenced by input(), pp_switch_to_buffer(), pplex(), pppop_buffer_state(), and pppush_buffer_state().

flex_int32_t yy_ec[256]

static

Definition at line 525 of file pplex.c.

char yy_hold_char

static

Definition at line 303 of file pplex.c.

Referenced by input(), pp_load_buffer_state(), pp_switch_to_buffer(), pplex(), pppush_buffer_state(), and yyunput().

int yy_init = 0

static

Definition at line 309 of file pplex.c.

Referenced by pplex(), and yy_init_globals().

char* yy_last_accepting_cpos

static

Definition at line 2028 of file pplex.c.

Referenced by pplex(), yy_get_previous_state(), and yy_try_NUL_trans().

yy_state_type yy_last_accepting_state

static

Definition at line 2027 of file pplex.c.

Referenced by pplex(), yy_get_previous_state(), and yy_try_NUL_trans().

flex_int32_t yy_meta[74]

static

Initial value:

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

Definition at line 557 of file pplex.c.

yy_size_t yy_n_chars

static

Definition at line 304 of file pplex.c.

Referenced by input(), pp_load_buffer_state(), pp_switch_to_buffer(), pplex(), pppush_buffer_state(), yy_get_next_buffer(), and yyunput().

flex_int16_t yy_nxt[5374]

static

Definition at line 837 of file pplex.c.

int yy_start = 0

static

Definition at line 310 of file pplex.c.

Referenced by pplex(), yy_get_previous_state(), and yy_init_globals().

int* yy_start_stack = ((void*)0)

static

Definition at line 2241 of file pplex.c.

Referenced by pplex_destroy(), yy_init_globals(), and yy_push_state().

int yy_start_stack_depth = 0

static

Definition at line 2240 of file pplex.c.

Referenced by yy_init_globals(), and yy_push_state().

int yy_start_stack_ptr = 0

static

Definition at line 2239 of file pplex.c.

Referenced by yy_init_globals().