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

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 37

#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	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	ppwrap() 1

#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 (yyconst char *yy_str)

YY_BUFFER_STATE	pp_scan_bytes (yyconst 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 (yyconst char msg[])

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)

	if (!(yy_init))

	while (1)

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

static void	yy_fatal_error (yyconst 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 yyconst flex_int16_t	yy_accept [1082]

static yyconst flex_int32_t	yy_ec [256]

static yyconst flex_int32_t	yy_meta [74]

static yyconst flex_int16_t	yy_base [1183]

static yyconst flex_int16_t	yy_def [1183]

static yyconst flex_int16_t	yy_nxt [5374]

static yyconst 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 = NULL

static char *	plexbuff2 = NULL

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 = NULL

static struct cb_replace_list *	save_current_replace = NULL

static struct cb_replace_list *	base_replace_list = NULL

static struct cb_text_list *	text_queue = NULL

static struct copy_info *	copy_stack = NULL

static struct plex_stack	plex_cond_stack [PLEX_COND_DEPTH]

static int	yy_start_stack_ptr = 0

static int	yy_start_stack_depth = 0

static int *	yy_start_stack = NULL

	YY_DECL
	The main scanner function which does all the work. More...

register char *	yy_cp

register char *	yy_bp

register int	yy_act

Macro Definition Documentation

#define BEGIN (yy_start) = 1 + 2 *

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

#define COB_IN_PPLEX 1

#define COPY_STATE 1

Referenced by while().

#define DEFINE_DIRECTIVE_STATE 4

Referenced by while().

#define ECHO fputs (pptext, ppout)

Referenced by while().

#define ELSE_DIRECTIVE_STATE 8

Referenced by while().

#define ENDIF_DIRECTIVE_STATE 9

Referenced by while().

#define EOB_ACT_CONTINUE_SCAN 0

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

#define EOB_ACT_END_OF_FILE 1

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

#define EOB_ACT_LAST_MATCH 2

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

#define FLEX_BETA

#define FLEX_SCANNER

#define FLEXINT_H

#define IF_DIRECTIVE_STATE 7

Referenced by while().

#define INITIAL 0

Referenced by while().

#define INT16_MAX (32767)

#define INT16_MIN (-32767-1)

#define INT32_MAX (2147483647)

#define INT32_MIN (-2147483647-1)

#define INT8_MAX (127)

#define INT8_MIN (-128)

#define PLEX_COND_DEPTH 16

Referenced by plex_action_directive().

#define PPLEX_BUFF_LEN 512

Referenced by ppinput().

#define ppwrap ( ) 1

Referenced by input(), and while().

#define PSEUDO_STATE 2

Referenced by while().

#define REJECT reject_used_but_not_detected

#define SET_DIRECTIVE_STATE 5

Referenced by while().

#define SOURCE_DIRECTIVE_STATE 3

Referenced by while().

#define TURN_DIRECTIVE_STATE 6

Referenced by while().

#define UINT16_MAX (65535U)

#define UINT32_MAX (4294967295U)

#define UINT8_MAX (255U)

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

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

#define YY_AT_BOL ( ) (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Referenced by while(), and yy_get_previous_state().

#define YY_BREAK break;

Referenced by while().

#define YY_BUF_SIZE 16384

Referenced by if(), ppopen(), pprestart(), and yyrestart().

#define YY_BUF_SIZE 32768

#define YY_BUFFER_EOF_PENDING 2

Referenced by yy_get_next_buffer().

#define YY_BUFFER_NEW 0

Referenced by pp_flush_buffer(), and while().

#define YY_BUFFER_NORMAL 1

Referenced by while().

#define yy_create_buffer pp_create_buffer

#define YY_CURRENT_BUFFER

Value:

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

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

#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]

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

#define YY_DECL int pplex (void)

#define YY_DECL_IS_OURS 1

#define yy_delete_buffer pp_delete_buffer

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

Referenced by while().

#define YY_END_OF_BUFFER 157

Referenced by while().

#define YY_END_OF_BUFFER_CHAR 0

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

#define YY_EXIT_FAILURE 2

Referenced by yy_fatal_error().

#define YY_EXTRA_TYPE void *

#define YY_FATAL_ERROR ( msg ) yy_fatal_error( msg )

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

int yy_flex_debug pp_flex_debug

#define YY_FLEX_MAJOR_VERSION 2

#define YY_FLEX_MINOR_VERSION 5

#define YY_FLEX_SUBMINOR_VERSION 37

#define yy_flush_buffer pp_flush_buffer

#define YY_FLUSH_BUFFER pp_flush_buffer(YY_CURRENT_BUFFER )

#define yy_init_buffer pp_init_buffer

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

Referenced by yy_get_next_buffer().

#define YY_INT_ALIGNED short int

#define YY_LESS_LINENO ( n )

#define yy_load_buffer_state pp_load_buffer_state

#define YY_MORE_ADJ 0

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

#define yy_new_buffer pp_create_buffer

#define YY_NEW_FILE pprestart(ppin )

Referenced by input(), and while().

#define YY_NO_UNISTD_H 1

#define YY_NULL 0

Referenced by ppinput().

#define YY_NUM_RULES 156

#define YY_READ_BUF_SIZE 32768

Referenced by yy_get_next_buffer().

#define YY_RESTORE_YY_MORE_OFFSET

Referenced by while().

#define YY_RULE_SETUP

Value:

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

Referenced by while().

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

Referenced by while(), 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; \
    }

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

#define YY_SKIP_YYWRAP

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

Referenced by while(), and yy_push_state().

#define YY_START_STACK_INCR 25

Referenced by yy_push_state().

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

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

Referenced by while().

#define YY_STRUCT_YY_BUFFER_STATE

#define yy_switch_to_buffer pp_switch_to_buffer

#define YY_TYPEDEF_YY_BUFFER_STATE

#define YY_TYPEDEF_YY_SIZE_T

#define YY_USER_ACTION

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

Referenced by if().

#define yyalloc ppalloc

#define yyconst

#define yyfree ppfree

FILE * yyin ppin

Referenced by cobc_clean_up(), if(), input(), main(), process_translate(), while(), yy_get_next_buffer(), yy_init_globals(), yy_load_buffer_state(), and yyrestart().

int yyleng ppleng

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

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

#define yylex pplex

int yylineno pplineno

#define yymore ( ) yymore_used_but_not_detected

FILE * yyout ppout

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

#define yyrealloc pprealloc

#define yyrestart pprestart

#define YYSTATE YY_START

#define YYTABLES_NAME "yytables"

#define yyterminate ( ) return YY_NULL

Referenced by while().

char * yytext pptext

#define yytext_ptr pptext

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

#define yywrap ppwrap

Typedef Documentation

typedef short int flex_int16_t

typedef int flex_int32_t

typedef signed char flex_int8_t

typedef unsigned short int flex_uint16_t

typedef unsigned int flex_uint32_t

typedef unsigned char flex_uint8_t

typedef struct yy_buffer_state* YY_BUFFER_STATE

typedef unsigned char YY_CHAR

typedef size_t yy_size_t

typedef int yy_state_type

Function Documentation

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

static

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

Referenced by while().

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

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

static

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

Referenced by ppecho(), and while().

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

static void display_to_eol ( void )

static

References input(), and unput.

Referenced by while().

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

if ( ! yy_init )

References pp_create_buffer(), pp_load_buffer_state(), ppensure_buffer_stack(), ppin, ppout, YY_BUF_SIZE, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init, yy_start, and YY_USER_INIT.

Referenced by check_picture_item(), cob_cmp_alnum(), cob_linage_write_opt(), cob_sys_system(), cob_unstring_into(), output_initialize_literal(), process_assemble(), and yyunput().

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

static int input ( void )

static

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

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

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.

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

void plex_call_destroy ( void )

References pplex_destroy().

Referenced by preprocess().

 {
     (void)pplex_destroy ();
 }

void plex_clear_all ( void )

References cobc_free(), and NULL.

Referenced by main().

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

void plex_clear_vars ( void )

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

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.

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

void pp_delete_buffer ( YY_BUFFER_STATE b )

Destroy the buffer.

Parameters

b	a buffer created with pp_create_buffer()

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_destroy(), pppop_buffer_state(), and while().

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

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

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

static void pp_init_buffer	(	YY_BUFFER_STATE	b,
		FILE *	file
	)

static

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

static void pp_load_buffer_state ( void )

static

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

Referenced by if(), pp_flush_buffer(), pp_switch_to_buffer(), 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);
 }

YY_BUFFER_STATE pp_scan_buffer	(	char *	base,
		yy_size_t	size
	)

YY_BUFFER_STATE pp_scan_bytes	(	yyconst char *	bytes,
		yy_size_t	len
	)

YY_BUFFER_STATE pp_scan_string ( yyconst char * yy_str )

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

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

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

void pp_switch_to_buffer ( YY_BUFFER_STATE new_buffer )

Switch to a different input buffer.

Parameters

new_buffer The new input buffer.

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

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

staticread

References cobc_plex_malloc(), cb_text_list::last, cb_text_list::next, p, 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;
 }

void * ppalloc ( yy_size_t size )

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

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

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

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.

 {
     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);
         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);
         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);
                 if (access (plexbuff2, R_OK) == 0) {
                     return ppopen (plexbuff2, replace_list);
                 }
             }
         }
     }
     cb_error ("%s: %s", name, _("No such file or directory"));
     return -1;
 }

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

static

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 while().

 {
     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) {
                 /* 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) {
                 /* 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;
     }
 }

static void ppensure_buffer_stack ( void )

static

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

Referenced by if(), pp_switch_to_buffer(), 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;
     }
 }

void ppfree ( void * ptr )

Referenced by pp_delete_buffer(), and pplex_destroy().

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

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

static

References _, CB_FORMAT_FIXED, CB_FORMAT_FREE, cb_plex_error(), cb_plex_warning(), cb_source_format, 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 much 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;
         }
         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 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;
 }

int pplex ( void )

int pplex_destroy ( void )

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

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

References _, copy_info::buffer, cb_error(), cb_source_file, cb_source_format, cb_source_line, 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, p, pp_create_buffer(), ppin, copy_info::quotation_mark, quotation_mark, copy_info::replacing, replacing_list, 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;
 
 #ifdef  _WIN32
     unsigned char       bom[4];
 #endif
 
     if (ppin) {
         for (; newline_count > 0; newline_count--) {
             ungetc ('\n', ppin);
         }
     }
 
     /* Open copy/source file */
 #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;
     }
 #ifdef  _WIN32
     /* Check for BOM */
     if (fread (bom, 3, 1, ppin) == 1) {
         if (bom[0] != 0xEF || bom[1] != 0xBB || bom[2] != 0xBF) {
             rewind (ppin);
         }
     } else {
         rewind (ppin);
     }
 #endif
 
     /* 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;
 }

void ppparse_error ( const char * msg )

References cb_plex_error().

 {
     cb_plex_error (newline_count, msg);
 }

void pppop_buffer_state ( void )

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

The next element becomes the new top.

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

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.

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

void * pprealloc	(	void *	ptr,
		yy_size_t	size
	)

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

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 .

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

static void skip_to_eol ( void )

static

References input(), and unput.

Referenced by check_comments(), and while().

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

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

static

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

Referenced by ppopen(), and while().

 {
     /* 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);
 }

while ( 1 )

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, p, PARAMETER, plex_cond_stack, plex_nest_depth, pp_delete_buffer(), ppecho(), ppin, ppleng, pplval, 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_BUFFER_NEW, YY_BUFFER_NORMAL, yy_c_buf_p, yy_cp, 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_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(), yyterminate, and yytext_ptr.

         {
         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 177 "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 185 "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 191 "pplex.l"
 {
     /* Define here to preempt next debug rule below */
     display_to_eol ();
 }
     YY_BREAK
 case 4:
 YY_RULE_SETUP
 #line 196 "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 205 "pplex.l"
 {
     BEGIN SOURCE_DIRECTIVE_STATE;
     return SOURCE_DIRECTIVE;
 }
     YY_BREAK
 case 6:
 YY_RULE_SETUP
 #line 210 "pplex.l"
 {
     /* OC extension */
     BEGIN SET_DIRECTIVE_STATE;
     return SET_DIRECTIVE;
 }
     YY_BREAK
 case 7:
 YY_RULE_SETUP
 #line 216 "pplex.l"
 {
     BEGIN TURN_DIRECTIVE_STATE;
     return TURN_DIRECTIVE;
 }
     YY_BREAK
 case 8:
 YY_RULE_SETUP
 #line 221 "pplex.l"
 {
     BEGIN IF_DIRECTIVE_STATE;
     return IF_DIRECTIVE;
 }
     YY_BREAK
 case 9:
 #line 227 "pplex.l"
 case 10:
 YY_RULE_SETUP
 #line 227 "pplex.l"
 {
     BEGIN IF_DIRECTIVE_STATE;
     return ELIF_DIRECTIVE;
 }
     YY_BREAK
 case 11:
 YY_RULE_SETUP
 #line 232 "pplex.l"
 {
     BEGIN ELSE_DIRECTIVE_STATE;
     return ELSE_DIRECTIVE;
 }
     YY_BREAK
 case 12:
 YY_RULE_SETUP
 #line 237 "pplex.l"
 {
     BEGIN ENDIF_DIRECTIVE_STATE;
     return ENDIF_DIRECTIVE;
 }
     YY_BREAK
 case 13:
 YY_RULE_SETUP
 #line 242 "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 249 "pplex.l"
 {
     cb_plex_warning (newline_count, _("Ignoring empty directive"));
     unput ('\n');
 }
     YY_BREAK
 case 15:
 YY_RULE_SETUP
 #line 254 "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 262 "pplex.l"
 {
     cb_plex_warning (newline_count, _("Ignoring invalid directive"));
     skip_to_eol ();
 }
     YY_BREAK
 case 17:
 YY_RULE_SETUP
 #line 267 "pplex.l"
 {
     display_to_eol ();
 }
     YY_BREAK
 case 18:
 YY_RULE_SETUP
 #line 271 "pplex.l"
 {
     BEGIN SET_DIRECTIVE_STATE;
     return SET_DIRECTIVE;
 }
     YY_BREAK
 case 19:
 YY_RULE_SETUP
 #line 276 "pplex.l"
 {
     BEGIN IF_DIRECTIVE_STATE;
     return IF_DIRECTIVE;
 }
     YY_BREAK
 case 20:
 #line 282 "pplex.l"
 case 21:
 YY_RULE_SETUP
 #line 282 "pplex.l"
 {
     BEGIN IF_DIRECTIVE_STATE;
     return ELIF_DIRECTIVE;
 }
     YY_BREAK
 case 22:
 YY_RULE_SETUP
 #line 287 "pplex.l"
 {
     BEGIN ELSE_DIRECTIVE_STATE;
     return ELSE_DIRECTIVE;
 }
     YY_BREAK
 case 23:
 YY_RULE_SETUP
 #line 292 "pplex.l"
 {
     BEGIN ENDIF_DIRECTIVE_STATE;
     return ENDIF_DIRECTIVE;
 }
     YY_BREAK
 case 24:
 YY_RULE_SETUP
 #line 297 "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 305 "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 313 "pplex.l"
 {
     cb_plex_warning (newline_count, _("Spurious '$' detected - ignoring"));
     skip_to_eol ();
 }
     YY_BREAK
 case 27:
 YY_RULE_SETUP
 #line 318 "pplex.l"
 {
     cb_plex_warning (newline_count, _("PROCESS statement ignored"));
     skip_to_eol ();
 }
     YY_BREAK
 case 28:
 YY_RULE_SETUP
 #line 323 "pplex.l"
 {
     yy_push_state (COPY_STATE);
     return COPY;
 }
     YY_BREAK
 case 29:
 YY_RULE_SETUP
 #line 328 "pplex.l"
 {
     yy_push_state (COPY_STATE);
     return COPY;
 }
     YY_BREAK
 case 30:
 YY_RULE_SETUP
 #line 333 "pplex.l"
 {
     yy_push_state (COPY_STATE);
     return REPLACE;
 }
     YY_BREAK
 case 31:
 #line 339 "pplex.l"
 case 32:
 YY_RULE_SETUP
 #line 339 "pplex.l"
 {
     /* Allow comment sentences/paragraphs */
     comment_allowed = 1;
     ppecho (pptext, 0, ppleng);
 }
     YY_BREAK
 case 33:
 YY_RULE_SETUP
 #line 345 "pplex.l"
 {
     /* Allow comment sentences/paragraphs */
     comment_allowed = 1;
     ppecho (pptext, 0, ppleng);
 }
     YY_BREAK
 case 34:
 YY_RULE_SETUP
 #line 351 "pplex.l"
 {
     /* Disallow comment sentences/paragraphs */
     comment_allowed = 0;
     ppecho (pptext, 0, ppleng);
 }
     YY_BREAK
 case 35:
 YY_RULE_SETUP
 #line 357 "pplex.l"
 {
     /* Disallow comment sentences/paragraphs */
     comment_allowed = 0;
     ppecho (pptext, 0, ppleng);
 }
     YY_BREAK
 case 36:
 YY_RULE_SETUP
 #line 363 "pplex.l"
 { check_comments ("AUTHOR", pptext); }
     YY_BREAK
 case 37:
 YY_RULE_SETUP
 #line 364 "pplex.l"
 { check_comments ("DATE-WRITTEN", pptext); }
     YY_BREAK
 case 38:
 YY_RULE_SETUP
 #line 365 "pplex.l"
 { check_comments ("DATE-MODIFIED", pptext); }
     YY_BREAK
 case 39:
 YY_RULE_SETUP
 #line 366 "pplex.l"
 { check_comments ("DATE-COMPILED", pptext); }
     YY_BREAK
 case 40:
 YY_RULE_SETUP
 #line 367 "pplex.l"
 { check_comments ("INSTALLATION", pptext); }
     YY_BREAK
 case 41:
 YY_RULE_SETUP
 #line 368 "pplex.l"
 { check_comments ("REMARKS", pptext); }
     YY_BREAK
 case 42:
 YY_RULE_SETUP
 #line 369 "pplex.l"
 { check_comments ("SECURITY", pptext); }
     YY_BREAK
 case 43:
 #line 372 "pplex.l"
 case 44:
 #line 373 "pplex.l"
 case 45:
 #line 374 "pplex.l"
 case 46:
 YY_RULE_SETUP
 #line 374 "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 385 "pplex.l"
 case 48:
 YY_RULE_SETUP
 #line 385 "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 391 "pplex.l"
 {
     ppecho ("\n", 0, 1);
     cb_source_line++;
 }
     YY_BREAK
 case 50:
 YY_RULE_SETUP
 #line 396 "pplex.l"
 {
     ppecho (" ", 1U, 1);
 }
     YY_BREAK
 case 51:
 YY_RULE_SETUP
 #line 400 "pplex.l"
 {
     if (inside_bracket) {
         ppecho (", ", 0, 2);
     } else {
         ppecho (" ", 1U, 1);
     }
 }
     YY_BREAK
 case 52:
 YY_RULE_SETUP
 #line 408 "pplex.l"
 {
     inside_bracket++;
     ppecho ("(", 0, 1);
 }
     YY_BREAK
 case 53:
 YY_RULE_SETUP
 #line 413 "pplex.l"
 {
     if (inside_bracket) {
         inside_bracket--;
     }
     ppecho (")", 0, 1);
 }
     YY_BREAK
 case 54:
 #line 421 "pplex.l"
 case 55:
 #line 422 "pplex.l"
 case 56:
 #line 423 "pplex.l"
 case 57:
 YY_RULE_SETUP
 #line 423 "pplex.l"
 {
     ppecho (pptext, 0, ppleng);
 }
     YY_BREAK
 
 case 58:
 /* rule 58 can match eol */
 YY_RULE_SETUP
 #line 428 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 59:
 YY_RULE_SETUP
 #line 433 "pplex.l"
 { return FORMAT; }
     YY_BREAK
 case 60:
 YY_RULE_SETUP
 #line 434 "pplex.l"
 { return IS; }
     YY_BREAK
 case 61:
 YY_RULE_SETUP
 #line 435 "pplex.l"
 { return FIXED; }
     YY_BREAK
 case 62:
 YY_RULE_SETUP
 #line 436 "pplex.l"
 { return FREE; }
     YY_BREAK
 case 63:
 YY_RULE_SETUP
 #line 437 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 case 64:
 YY_RULE_SETUP
 #line 438 "pplex.l"
 { }
     YY_BREAK
 
 
 case 65:
 /* rule 65 can match eol */
 YY_RULE_SETUP
 #line 442 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 66:
 YY_RULE_SETUP
 #line 447 "pplex.l"
 {
     return CONSTANT;
   }
     YY_BREAK
 case 67:
 YY_RULE_SETUP
 #line 450 "pplex.l"
 {
     return AS;
   }
     YY_BREAK
 case 68:
 YY_RULE_SETUP
 #line 453 "pplex.l"
 {
     return OFF;
   }
     YY_BREAK
 case 69:
 YY_RULE_SETUP
 #line 456 "pplex.l"
 {
     return OVERRIDE;
   }
     YY_BREAK
 case 70:
 YY_RULE_SETUP
 #line 459 "pplex.l"
 {
     return PARAMETER;
   }
     YY_BREAK
 case 71:
 #line 463 "pplex.l"
 case 72:
 YY_RULE_SETUP
 #line 463 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return LITERAL;
   }
     YY_BREAK
 case 73:
 YY_RULE_SETUP
 #line 467 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return VARIABLE;
   }
     YY_BREAK
 case 74:
 YY_RULE_SETUP
 #line 471 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 case 75:
 YY_RULE_SETUP
 #line 472 "pplex.l"
 { }
     YY_BREAK
 
 
 case 76:
 /* rule 76 can match eol */
 YY_RULE_SETUP
 #line 476 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 77:
 YY_RULE_SETUP
 #line 481 "pplex.l"
 {
     return CONSTANT;
   }
     YY_BREAK
 case 78:
 YY_RULE_SETUP
 #line 484 "pplex.l"
 {
     return SOURCEFORMAT;
   }
     YY_BREAK
 case 79:
 #line 488 "pplex.l"
 case 80:
 YY_RULE_SETUP
 #line 488 "pplex.l"
 {
     return FOLDCOPYNAME;
   }
     YY_BREAK
 case 81:
 #line 492 "pplex.l"
 case 82:
 YY_RULE_SETUP
 #line 492 "pplex.l"
 {
     return NOFOLDCOPYNAME;
   }
     YY_BREAK
 case 83:
 YY_RULE_SETUP
 #line 495 "pplex.l"
 {
     return AS;
   }
     YY_BREAK
 case 84:
 #line 499 "pplex.l"
 case 85:
 YY_RULE_SETUP
 #line 499 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return LITERAL;
   }
     YY_BREAK
 case 86:
 YY_RULE_SETUP
 #line 503 "pplex.l"
 {
     pptext[strlen (pptext) - 1] = 0;
     pplval.s = cobc_plex_strdup (pptext + 1);
     return LITERAL;
   }
     YY_BREAK
 case 87:
 YY_RULE_SETUP
 #line 508 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return VARIABLE;
   }
     YY_BREAK
 case 88:
 YY_RULE_SETUP
 #line 512 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 case 89:
 YY_RULE_SETUP
 #line 513 "pplex.l"
 { }
     YY_BREAK
 
 
 case 90:
 /* rule 90 can match eol */
 YY_RULE_SETUP
 #line 517 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 91:
 YY_RULE_SETUP
 #line 522 "pplex.l"
 {
     return ON;
   }
     YY_BREAK
 case 92:
 YY_RULE_SETUP
 #line 525 "pplex.l"
 {
     return OFF;
   }
     YY_BREAK
 case 93:
 YY_RULE_SETUP
 #line 528 "pplex.l"
 {
     return WITH;
   }
     YY_BREAK
 case 94:
 YY_RULE_SETUP
 #line 531 "pplex.l"
 {
     return LOCATION;
   }
     YY_BREAK
 case 95:
 YY_RULE_SETUP
 #line 534 "pplex.l"
 {
     return CHECKING;
   }
     YY_BREAK
 case 96:
 #line 538 "pplex.l"
 case 97:
 YY_RULE_SETUP
 #line 538 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return LITERAL;
   }
     YY_BREAK
 case 98:
 YY_RULE_SETUP
 #line 542 "pplex.l"
 {
     pptext[strlen (pptext) - 1] = 0;
     pplval.s = cobc_plex_strdup (pptext + 1);
     return LITERAL;
   }
     YY_BREAK
 case 99:
 YY_RULE_SETUP
 #line 547 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return VARIABLE;
   }
     YY_BREAK
 case 100:
 YY_RULE_SETUP
 #line 551 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 case 101:
 YY_RULE_SETUP
 #line 552 "pplex.l"
 { }
     YY_BREAK
 
 
 case 102:
 /* rule 102 can match eol */
 YY_RULE_SETUP
 #line 556 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 103:
 YY_RULE_SETUP
 #line 561 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 case 104:
 YY_RULE_SETUP
 #line 562 "pplex.l"
 { return IS; }
     YY_BREAK
 case 105:
 YY_RULE_SETUP
 #line 563 "pplex.l"
 { return NOT; }
     YY_BREAK
 case 106:
 YY_RULE_SETUP
 #line 564 "pplex.l"
 { return EQUAL; }
     YY_BREAK
 case 107:
 YY_RULE_SETUP
 #line 565 "pplex.l"
 { return TO; }
     YY_BREAK
 case 108:
 YY_RULE_SETUP
 #line 566 "pplex.l"
 { return OR; }
     YY_BREAK
 case 109:
 YY_RULE_SETUP
 #line 567 "pplex.l"
 { return GREATER; }
     YY_BREAK
 case 110:
 YY_RULE_SETUP
 #line 568 "pplex.l"
 { return LESS; }
     YY_BREAK
 case 111:
 YY_RULE_SETUP
 #line 569 "pplex.l"
 { return THAN; }
     YY_BREAK
 case 112:
 YY_RULE_SETUP
 #line 570 "pplex.l"
 { return DEFINED; }
     YY_BREAK
 case 113:
 YY_RULE_SETUP
 #line 571 "pplex.l"
 { return SET; }
     YY_BREAK
 case 114:
 YY_RULE_SETUP
 #line 572 "pplex.l"
 { return GE; }
     YY_BREAK
 case 115:
 YY_RULE_SETUP
 #line 573 "pplex.l"
 { return GT; }
     YY_BREAK
 case 116:
 YY_RULE_SETUP
 #line 574 "pplex.l"
 { return LE; }
     YY_BREAK
 case 117:
 YY_RULE_SETUP
 #line 575 "pplex.l"
 { return NE; }
     YY_BREAK
 case 118:
 YY_RULE_SETUP
 #line 576 "pplex.l"
 { return LT; }
     YY_BREAK
 case 119:
 YY_RULE_SETUP
 #line 577 "pplex.l"
 { return EQ; }
     YY_BREAK
 case 120:
 #line 579 "pplex.l"
 case 121:
 YY_RULE_SETUP
 #line 579 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return LITERAL;
   }
     YY_BREAK
 case 122:
 YY_RULE_SETUP
 #line 583 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (pptext);
     return VARIABLE;
   }
     YY_BREAK
 case 123:
 YY_RULE_SETUP
 #line 587 "pplex.l"
 { }
     YY_BREAK
 
 
 case 124:
 /* rule 124 can match eol */
 YY_RULE_SETUP
 #line 591 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 125:
 YY_RULE_SETUP
 #line 596 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 
 
 case 126:
 /* rule 126 can match eol */
 YY_RULE_SETUP
 #line 600 "pplex.l"
 {
     BEGIN INITIAL;
     unput ('\n');
     return TERMINATOR;
   }
     YY_BREAK
 case 127:
 YY_RULE_SETUP
 #line 605 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 
 
 case 128:
 /* rule 128 can match eol */
 YY_RULE_SETUP
 #line 609 "pplex.l"
 {
     ECHO;
     check_listing (pptext, 0);
     cb_source_line++;
   }
     YY_BREAK
 case 129:
 YY_RULE_SETUP
 #line 614 "pplex.l"
 { /* ignore */ }
     YY_BREAK
 case 130:
 YY_RULE_SETUP
 #line 615 "pplex.l"
 { yy_pop_state (); return DOT; }
     YY_BREAK
 case 131:
 YY_RULE_SETUP
 #line 616 "pplex.l"
 { yy_push_state (PSEUDO_STATE); return EQEQ; }
     YY_BREAK
 case 132:
 YY_RULE_SETUP
 #line 617 "pplex.l"
 { return '('; }
     YY_BREAK
 case 133:
 YY_RULE_SETUP
 #line 618 "pplex.l"
 { return ')'; }
     YY_BREAK
 case 134:
 YY_RULE_SETUP
 #line 619 "pplex.l"
 { return BY; }
     YY_BREAK
 case 135:
 YY_RULE_SETUP
 #line 620 "pplex.l"
 { return IN; }
     YY_BREAK
 case 136:
 YY_RULE_SETUP
 #line 621 "pplex.l"
 { return OF; }
     YY_BREAK
 case 137:
 YY_RULE_SETUP
 #line 622 "pplex.l"
 { return OFF; }
     YY_BREAK
 case 138:
 YY_RULE_SETUP
 #line 623 "pplex.l"
 { return SUPPRESS; }
     YY_BREAK
 case 139:
 YY_RULE_SETUP
 #line 624 "pplex.l"
 { return PRINTING; }
     YY_BREAK
 case 140:
 YY_RULE_SETUP
 #line 625 "pplex.l"
 { return REPLACING; }
     YY_BREAK
 case 141:
 YY_RULE_SETUP
 #line 626 "pplex.l"
 { return LEADING; }
     YY_BREAK
 case 142:
 YY_RULE_SETUP
 #line 627 "pplex.l"
 { return TRAILING; }
     YY_BREAK
 case 143:
 YY_RULE_SETUP
 #line 628 "pplex.l"
 { return ALSO; }
     YY_BREAK
 case 144:
 YY_RULE_SETUP
 #line 629 "pplex.l"
 { return LAST; }
     YY_BREAK
 case 145:
 #line 631 "pplex.l"
 case 146:
 #line 632 "pplex.l"
 case 147:
 #line 633 "pplex.l"
 case 148:
 YY_RULE_SETUP
 #line 633 "pplex.l"
 { pplval.s = cobc_plex_strdup (pptext); return TOKEN; }
     YY_BREAK
 
 
 case 149:
 /* rule 149 can match eol */
 YY_RULE_SETUP
 #line 637 "pplex.l"
 {
     ECHO;
     check_listing (pptext, 0);
     cb_source_line++;
   }
     YY_BREAK
 case 150:
 YY_RULE_SETUP
 #line 643 "pplex.l"
 {
     pplval.s = cobc_plex_strdup (" ");
     return TOKEN;
   }
     YY_BREAK
 case 151:
 YY_RULE_SETUP
 #line 648 "pplex.l"
 {
     yy_pop_state ();
     return EQEQ;
   }
     YY_BREAK
 case 152:
 #line 654 "pplex.l"
 case 153:
 #line 655 "pplex.l"
 case 154:
 #line 656 "pplex.l"
 case 155:
 YY_RULE_SETUP
 #line 656 "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 663 "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 715 "pplex.l"
 YY_FATAL_ERROR( "flex scanner jammed" );
     YY_BREAK
 #line 3493 "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 */

static void yy_fatal_error ( yyconst char msg[] )

static

static void yy_fatal_error ( yyconst char * msg )

static

References YY_EXIT_FAILURE.

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

static int yy_get_next_buffer ( void )

static

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 while().

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

static yy_state_type yy_get_previous_state ( void )

static

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

Referenced by while().

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

static int yy_init_globals ( void )

static

Get the current token.

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

static void yy_pop_state ( void )

static

References BEGIN, and YY_FATAL_ERROR.

Referenced by while().

 {
         if ( --(yy_start_stack_ptr) < 0 )
         YY_FATAL_ERROR( "start-condition stack underflow" );
 
     BEGIN((yy_start_stack)[(yy_start_stack_ptr)]);
 }

static void yy_push_state ( int new_state )

static

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

Referenced by while().

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

static yy_state_type yy_try_NUL_trans ( yy_state_type current_state )

static

References yy_c_buf_p, yy_last_accepting_cpos, and yy_last_accepting_state.

Referenced by while().

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

static void yyunput	(	int	c,
		char *	buf_ptr
	)

static

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

static

References if(), yy_c_buf_p, yy_cp, 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 = NULL

static

Referenced by pp_set_replace_list(), and ppecho().

size_t buffer_overflow = 0

static

Referenced by ppinput().

size_t comment_allowed

static

Referenced by check_comments().

size_t consecutive_quotation = 0

static

Referenced by ppinput().

struct copy_info* copy_stack = NULL

static

Referenced by ppopen(), and while().

struct cb_replace_list* current_replace_list = NULL

static

Referenced by ppecho(), and ppopen().

size_t inside_bracket = 0

static

int listing_line = 0

static

Referenced by check_listing().

size_t need_continuation = 0

static

Referenced by ppinput().

size_t newline_count = 0

static

Referenced by ppinput().

struct plex_stack plex_cond_stack[PLEX_COND_DEPTH]

static

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

unsigned int plex_nest_depth = 0

static

Referenced by plex_action_directive(), and while().

unsigned int plex_skip_input = 0

static

Referenced by display_to_eol(), and ppinput().

char* plexbuff1 = NULL

static

Referenced by ppcopy().

char* plexbuff2 = NULL

static

int pp_flex_debug = 0

FILE* ppin = (FILE *) 0

yy_size_t ppleng

Referenced by check_comments(), and while().

int pplineno = 1

FILE * ppout = (FILE *) 0

char * pptext

Referenced by ppecho().

int quotation_mark = 0

static

Referenced by ppinput(), and ppopen().

int requires_listing_line

static

Referenced by check_listing().

int requires_new_line = 0

static

Referenced by check_listing().

struct cb_replace_list* save_current_replace = NULL

static

struct cb_text_list* text_queue = NULL

static

Referenced by ppecho().

size_t within_comment = 0

static

Referenced by check_comments(), and ppinput().

yyconst flex_int16_t yy_accept[1082]

static

register int yy_act

yyconst flex_int16_t yy_base[1183]

static

register char * yy_bp

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

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

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Referenced by ppensure_buffer_stack(), and yy_init_globals().

size_t yy_buffer_stack_top = 0

static

index of top of stack.

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

char* yy_c_buf_p = (char *) 0

static

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

yyconst flex_int16_t yy_chk[5374]

static

register char* yy_cp

Referenced by while(), yy_get_previous_state(), and yyunput().

YY_DECL

Initial value:

{

register yy_state_type yy_current_state

The main scanner function which does all the work.

yyconst flex_int16_t yy_def[1183]

static

int yy_did_buffer_switch_on_eof

static

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

yyconst flex_int32_t yy_ec[256]

static

char yy_hold_char

static

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

int yy_init = 0

static

Referenced by if(), and yy_init_globals().

char* yy_last_accepting_cpos

static

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

yy_state_type yy_last_accepting_state

static

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

yyconst 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
    }