scanner.c File Reference

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include "config.h"
#include <ctype.h>
#include "cobc.h"
#include "tree.h"
#include "parser.h"

Include dependency graph for scanner.c:

Go to the source code of this file.

Data Structures
struct	yy_buffer_state
struct	yy_trans_info
struct	cb_level_78
struct	cb_top_level_78

Macros
#define	YY_INT_ALIGNED   short int
#define	FLEX_SCANNER
#define	YY_FLEX_MAJOR_VERSION   2
#define	YY_FLEX_MINOR_VERSION   5
#define	YY_FLEX_SUBMINOR_VERSION   39
#define	FLEX_BETA
#define	FLEXINT_H
#define	INT8_MIN   (-128)
#define	INT16_MIN   (-32767-1)
#define	INT32_MIN   (-2147483647-1)
#define	INT8_MAX   (127)
#define	INT16_MAX   (32767)
#define	INT32_MAX   (2147483647)
#define	UINT8_MAX   (255U)
#define	UINT16_MAX   (65535U)
#define	UINT32_MAX   (4294967295U)
#define	yyconst
#define	YY_NULL   0
#define	YY_SC_TO_UI(c)   ((unsigned int) (unsigned char) c)
#define	BEGIN   (yy_start) = 1 + 2 *
#define	YY_START   (((yy_start) - 1) / 2)
#define	YYSTATE   YY_START
#define	YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
#define	YY_NEW_FILE   yyrestart(yyin )
#define	YY_END_OF_BUFFER_CHAR   0
#define	YY_BUF_SIZE   16384
#define	YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
#define	YY_TYPEDEF_YY_BUFFER_STATE
#define	YY_TYPEDEF_YY_SIZE_T
#define	EOB_ACT_CONTINUE_SCAN   0
#define	EOB_ACT_END_OF_FILE   1
#define	EOB_ACT_LAST_MATCH   2
#define	YY_LESS_LINENO(n)
#define	YY_LINENO_REWIND_TO(ptr)
#define	yyless(n)
#define	unput(c)   yyunput( c, (yytext_ptr) )
#define	YY_STRUCT_YY_BUFFER_STATE
#define	YY_BUFFER_NEW   0
#define	YY_BUFFER_NORMAL   1
#define	YY_BUFFER_EOF_PENDING   2
#define	YY_CURRENT_BUFFER
#define	YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]
#define	YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )
#define	yy_new_buffer   yy_create_buffer
#define	yy_set_interactive(is_interactive)
#define	yy_set_bol(at_bol)
#define	YY_AT_BOL()   (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
#define	yytext_ptr   yytext
#define	YY_DO_BEFORE_ACTION
#define	YY_NUM_RULES   129
#define	YY_END_OF_BUFFER   130
#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	YY_INPUT(buf, result, max_size)
#define	YY_USER_INIT
#define	YY_NO_UNISTD_H   1
#define	COB_IN_SCANNER   1
#define	YYSTYPE   cb_tree
#define	INITIAL   0
#define	DECIMAL_IS_PERIOD   1
#define	DECIMAL_IS_COMMA   2
#define	PICTURE_STATE   3
#define	FUNCTION_STATE   4
#define	YY_EXTRA_TYPE   void *
#define	ECHO   do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
#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 yylex (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"
#define	INCREMENT_IF_SIGNED(text, sign)

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	yyrestart (FILE *input_file)
	Immediately switch to a different input stream. More...
void	yy_switch_to_buffer (YY_BUFFER_STATE new_buffer)
	Switch to a different input buffer. More...
YY_BUFFER_STATE	yy_create_buffer (FILE *file, int size)
	Allocate and initialize an input buffer state. More...
void	yy_delete_buffer (YY_BUFFER_STATE b)
	Destroy the buffer. More...
void	yy_flush_buffer (YY_BUFFER_STATE b)
	Discard all buffered characters. More...
void	yypush_buffer_state (YY_BUFFER_STATE new_buffer)
	Pushes the new state onto the stack. More...
void	yypop_buffer_state (void)
	Removes and deletes the top of the stack, if present. More...
static void	yyensure_buffer_stack (void)
static void	yy_load_buffer_state (void)
static void	yy_init_buffer (YY_BUFFER_STATE b, FILE *file)
YY_BUFFER_STATE	yy_scan_buffer (char *base, yy_size_t size)
YY_BUFFER_STATE	yy_scan_string (char *yy_str)
YY_BUFFER_STATE	yy_scan_bytes (char *bytes, yy_size_t len)
void *	yyalloc (yy_size_t)
void *	yyrealloc (void *, yy_size_t)
void	yyfree (void *)
static yy_state_type	yy_get_previous_state (void)
static yy_state_type	yy_try_NUL_trans (yy_state_type current_state)
static int	yy_get_next_buffer (void)
static void	yy_fatal_error (char msg[])
static int	yywrap (void)
static void	read_literal (const char)
static int	scan_x (const char *)
static int	scan_z (const char *, const cob_u32_t)
static int	scan_h (const char *, const cob_u32_t)
static int	scan_b (const char *, const cob_u32_t)
static int	scan_o (const char *)
static int	scan_numeric (const char *)
static int	scan_floating_numeric (const char *)
static void	scan_picture (const char *)
static void	count_lines (const char *)
static void	scan_define_options (const char *)
static void	scan_options (const char *, const unsigned int)
static int	yy_init_globals (void)
	Get the current token. More...
int	yylex_destroy (void)
static void	yyunput (int c, char *buf_ptr)
static int	input (void)
int	yylex (void)
	The main scanner function which does all the work. More...
static void	yyunput (int c, register char *yy_bp)
static void	yy_fatal_error (char *msg)
static void	error_literal (const char *type, const char *literal)
static int	get_sign (const char sign)
static int	all_zeroes (const char *str)
static int	significand_is_zero (const char *int_part, const char *dec_part)
static int	can_replace (const char *src1, const char *src2, const size_t size, const size_t iteration)
static const char *	check_78_replace (const cb_tree p)
static void	cb_add_const_var (const char *name, cb_tree value)
void	ylex_clear_all (void)
void	ylex_call_destroy (void)
void	cb_unput_dot (void)
void	cb_reset_78 (void)
void	cb_reset_global_78 (void)
void	cb_add_78 (struct cb_field *f)
struct cb_field *	check_level_78 (const char *name)
struct cb_program *	cb_find_defined_program_by_name (const char *name)
struct cb_program *	cb_find_defined_program_by_id (const char *orig_id)
void	cobc_init_scanner (void)

Variables
yy_size_t	yyleng
FILE *	yyin = (FILE *) 0
FILE *	yyout = (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	yylineno = 1
char *	yytext
static flex_int16_t	yy_accept [833]
static flex_int32_t	yy_ec [256]
static flex_int32_t	yy_meta [75]
static flex_int16_t	yy_base [865]
static flex_int16_t	yy_def [865]
static flex_int16_t	yy_nxt [2719]
static flex_int16_t	yy_chk [2719]
static yy_state_type	yy_last_accepting_state
static char *	yy_last_accepting_cpos
int	yy_flex_debug = 0
static struct cb_level_78 *	top78ptr = ((void*)0)
static struct cb_level_78 *	const78ptr = ((void*)0)
static struct cb_level_78 *	lev78ptr = ((void*)0)
static struct cb_level_78 *	globlev78ptr = ((void*)0)
static char *	plexbuff = ((void*)0)
static char *	picbuff1 = ((void*)0)
static char *	picbuff2 = ((void*)0)
static size_t	plexsize
static size_t	pic1size
static size_t	pic2size
static unsigned int	last_token_is_dot = 0
static unsigned int	integer_is_label = 0
static unsigned int	inside_bracket = 0
static unsigned int	literal_error
static char	err_msg [COB_MINI_BUFF]
static unsigned char	valid_char [256]
static const unsigned char	pvalid_char []

Macro Definition Documentation

#define BEGIN   (yy_start) = 1 + 2 *

Definition at line 127 of file scanner.c.

Referenced by yylex().

#define COB_IN_SCANNER   1

Definition at line 1409 of file scanner.c.

#define DECIMAL_IS_COMMA   2

Definition at line 1545 of file scanner.c.

Referenced by yylex().

#define DECIMAL_IS_PERIOD   1

Definition at line 1544 of file scanner.c.

Referenced by yylex().

#define ECHO   do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)

Definition at line 1615 of file scanner.c.

#define EOB_ACT_CONTINUE_SCAN   0

Definition at line 175 of file scanner.c.

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

#define EOB_ACT_END_OF_FILE   1

Definition at line 176 of file scanner.c.

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

#define EOB_ACT_LAST_MATCH   2

Definition at line 177 of file scanner.c.

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

#define FLEX_BETA

Definition at line 14 of file scanner.c.

#define FLEX_SCANNER

Definition at line 9 of file scanner.c.

#define FLEXINT_H

Definition at line 30 of file scanner.c.

#define FUNCTION_STATE   4

Definition at line 1547 of file scanner.c.

Referenced by yylex().

#define INCREMENT_IF_SIGNED	(		text,
			sign
	)

Value:

do {                \
        if (sign) {     \
            (text)++;   \
        }           \
    } ONCE_COB

Definition at line 4236 of file scanner.c.

Referenced by scan_define_options(), scan_floating_numeric(), and scan_numeric().

#define INITIAL   0

Definition at line 1543 of file scanner.c.

Referenced by yylex().

#define INT16_MAX   (32767)

Definition at line 73 of file scanner.c.

#define INT16_MIN   (-32767-1)

Definition at line 64 of file scanner.c.

#define INT32_MAX   (2147483647)

Definition at line 76 of file scanner.c.

#define INT32_MIN   (-2147483647-1)

Definition at line 67 of file scanner.c.

#define INT8_MAX   (127)

Definition at line 70 of file scanner.c.

#define INT8_MIN   (-128)

Definition at line 61 of file scanner.c.

#define PICTURE_STATE   3

Definition at line 1546 of file scanner.c.

Referenced by yylex().

#define REJECT   reject_used_but_not_detected

Definition at line 1336 of file scanner.c.

#define UINT16_MAX   (65535U)

Definition at line 82 of file scanner.c.

#define UINT32_MAX   (4294967295U)

Definition at line 85 of file scanner.c.

#define UINT8_MAX   (255U)

Definition at line 79 of file scanner.c.

#define unput

(

c

)

yyunput( c, (yytext_ptr) )

Definition at line 196 of file scanner.c.

Referenced by cb_unput_dot(), read_literal(), scan_picture(), and yylex().

#define YY_AT_BOL

(

)

(YY_CURRENT_BUFFER_LVALUE->yy_at_bol)

Definition at line 342 of file scanner.c.

Referenced by yy_get_previous_state(), and yylex().

#define YY_BREAK   break;

Definition at line 1694 of file scanner.c.

Referenced by yylex().

#define YY_BUF_SIZE   16384

Definition at line 1366 of file scanner.c.

Referenced by yylex(), and yyrestart().

#define YY_BUF_SIZE   32768

Definition at line 1366 of file scanner.c.

#define YY_BUFFER_EOF_PENDING   2

Definition at line 258 of file scanner.c.

Referenced by yy_get_next_buffer().

#define YY_BUFFER_NEW   0

Definition at line 246 of file scanner.c.

Referenced by yy_flush_buffer(), and yylex().

#define YY_BUFFER_NORMAL   1

Definition at line 247 of file scanner.c.

Referenced by yylex().

#define YY_CURRENT_BUFFER

Value:

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

Definition at line 274 of file scanner.c.

Referenced by yy_delete_buffer(), yy_flush_buffer(), yy_init_buffer(), yy_switch_to_buffer(), yylex(), yylex_destroy(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().

#define YY_CURRENT_BUFFER_LVALUE   (yy_buffer_stack)[(yy_buffer_stack_top)]

Definition at line 281 of file scanner.c.

Referenced by input(), yy_delete_buffer(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yylex(), yylex_destroy(), yypop_buffer_state(), yypush_buffer_state(), yyrestart(), and yyunput().

#define YY_DECL   int yylex (void)

Definition at line 1682 of file scanner.c.

#define YY_DECL_IS_OURS   1

Definition at line 1678 of file scanner.c.

#define YY_DO_BEFORE_ACTION

Value:

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

Definition at line 367 of file scanner.c.

Referenced by yylex().

#define YY_END_OF_BUFFER   130

Definition at line 375 of file scanner.c.

Referenced by yylex().

#define YY_END_OF_BUFFER_CHAR   0

Definition at line 142 of file scanner.c.

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

#define YY_EXIT_FAILURE   2

Definition at line 3709 of file scanner.c.

Referenced by yy_fatal_error().

#define YY_EXTRA_TYPE   void *

Definition at line 1558 of file scanner.c.

#define YY_FATAL_ERROR

(

msg

)

yy_fatal_error( msg )

Definition at line 1669 of file scanner.c.

Referenced by yy_create_buffer(), yy_get_next_buffer(), yyensure_buffer_stack(), yylex(), and yyunput().

#define YY_FLEX_MAJOR_VERSION   2

Definition at line 10 of file scanner.c.

#define YY_FLEX_MINOR_VERSION   5

Definition at line 11 of file scanner.c.

#define YY_FLEX_SUBMINOR_VERSION   39

Definition at line 12 of file scanner.c.

#define YY_FLUSH_BUFFER   yy_flush_buffer(YY_CURRENT_BUFFER )

Definition at line 310 of file scanner.c.

#define YY_INPUT	(		buf,
			result,
			max_size
	)

Value:

{   \
        if (fgets (buf, (int)max_size, yyin) == NULL) { \
            result = YY_NULL; \
        } else { \
            result = strlen (buf); \
        } \
    }

Definition at line 1373 of file scanner.c.

Referenced by yy_get_next_buffer().

#define YY_INT_ALIGNED   short int

Definition at line 5 of file scanner.c.

#define YY_LESS_LINENO

(

n

)

Definition at line 179 of file scanner.c.

#define YY_LINENO_REWIND_TO

(

ptr

)

Definition at line 180 of file scanner.c.

#define YY_MORE_ADJ   0

Definition at line 1338 of file scanner.c.

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

#define yy_new_buffer   yy_create_buffer

Definition at line 320 of file scanner.c.

#define YY_NEW_FILE   yyrestart(yyin )

Definition at line 140 of file scanner.c.

Referenced by input(), and yylex().

#define YY_NO_UNISTD_H   1

Definition at line 1406 of file scanner.c.

#define YY_NULL   0

Definition at line 114 of file scanner.c.

#define YY_NUM_RULES   129

Definition at line 374 of file scanner.c.

#define YY_READ_BUF_SIZE   32768

Definition at line 1364 of file scanner.c.

Referenced by yy_get_next_buffer().

#define YY_RESTORE_YY_MORE_OFFSET

Definition at line 1339 of file scanner.c.

Referenced by yylex().

#define YY_RULE_SETUP

Value:

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

Definition at line 1697 of file scanner.c.

Referenced by yylex().

#define YY_SC_TO_UI

(

c

)

((unsigned int) (unsigned char) c)

Definition at line 121 of file scanner.c.

Referenced by yy_get_previous_state(), and yylex().

#define yy_set_bol

(

at_bol

)

Value:

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

Definition at line 332 of file scanner.c.

#define yy_set_interactive

(

is_interactive

)

Value:

{ \
    if ( ! YY_CURRENT_BUFFER ){ \
        yyensure_buffer_stack (); \
		YY_CURRENT_BUFFER_LVALUE =    \
            yy_create_buffer(yyin,YY_BUF_SIZE ); \
    } \
	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
    }

Definition at line 322 of file scanner.c.

#define YY_SKIP_YYWRAP

Definition at line 1368 of file scanner.c.

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

Definition at line 133 of file scanner.c.

Referenced by yylex().

#define YY_START_STACK_INCR   25

Definition at line 1664 of file scanner.c.

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

Definition at line 159 of file scanner.c.

#define YY_STATE_EOF

(

state

)

(YY_END_OF_BUFFER + state + 1)

Definition at line 137 of file scanner.c.

Referenced by yylex().

#define YY_STRUCT_YY_BUFFER_STATE

Definition at line 199 of file scanner.c.

#define YY_TYPEDEF_YY_BUFFER_STATE

Definition at line 162 of file scanner.c.

#define YY_TYPEDEF_YY_SIZE_T

Definition at line 167 of file scanner.c.

#define YY_USER_ACTION

Definition at line 1689 of file scanner.c.

#define YY_USER_INIT

Value:

if (!plexbuff) {                    \
		plexsize = COB_MINI_BUFF;         \
		plexbuff = cobc_malloc (plexsize);    \
    }                           \
    if (!picbuff1) {                    \
		pic1size = COB_MINI_BUFF;         \
		picbuff1 = cobc_malloc (pic1size);    \
    }                           \
    if (!picbuff2) {                    \
		pic2size = COB_MINI_BUFF;         \
		picbuff2 = cobc_malloc (pic2size);    \
    }

Definition at line 1382 of file scanner.c.

Referenced by yylex().

#define yyconst

Definition at line 110 of file scanner.c.

#define yyless

(

n

)

Value:

do \
        { \
        /* Undo effects of setting up yytext. */ \
        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 yytext again */ \
        } \
    while ( 0 )

Definition at line 3721 of file scanner.c.

#define yyless

(

n

)

Value:

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

Definition at line 3721 of file scanner.c.

#define yymore

(

)

yymore_used_but_not_detected

Definition at line 1337 of file scanner.c.

#define YYSTATE   YY_START

Definition at line 134 of file scanner.c.

#define YYSTYPE   cb_tree

Definition at line 1413 of file scanner.c.

#define YYTABLES_NAME   "yytables"

Definition at line 3837 of file scanner.c.

#define yyterminate

(

)

return YY_NULL

Definition at line 1659 of file scanner.c.

Referenced by yylex().

#define yytext_ptr   yytext

Definition at line 357 of file scanner.c.

Referenced by input(), yy_get_next_buffer(), yy_get_previous_state(), yy_load_buffer_state(), yylex(), and yyunput().

Typedef Documentation

typedef short int flex_int16_t

Definition at line 53 of file scanner.c.

typedef int flex_int32_t

Definition at line 54 of file scanner.c.

typedef signed char flex_int8_t

Definition at line 52 of file scanner.c.

typedef unsigned short int flex_uint16_t

Definition at line 56 of file scanner.c.

typedef unsigned int flex_uint32_t

Definition at line 57 of file scanner.c.

typedef unsigned char flex_uint8_t

Definition at line 55 of file scanner.c.

typedef struct yy_buffer_state* YY_BUFFER_STATE

Definition at line 163 of file scanner.c.

typedef unsigned char YY_CHAR

Definition at line 346 of file scanner.c.

typedef size_t yy_size_t

Definition at line 168 of file scanner.c.

typedef int yy_state_type

Definition at line 350 of file scanner.c.

Function Documentation

static int all_zeroes ( const char *  str )

static

Definition at line 4288 of file scanner.c.

Referenced by significand_is_zero().

{
    int i;

    for (i = 0; str[i] != '\0'; ++i) {
        if (str[i] != '0') {
            return 0;
        }
    }

    return 1;
}

Here is the caller graph for this function:

static int can_replace ( const char *  src1, const char *  src2, const size_t  size, const size_t  iteration  )

static

Definition at line 4463 of file scanner.c.

Referenced by scan_picture().

{
    const unsigned char *p;

    /* Check if we can do a replacement */
    if (strncasecmp (src1, src2, size)) {
        return 0;
    }
    p = (const unsigned char *)src1 + size;
    if (valid_char[*p]) {
        return 0;
    }
    if (iteration) {
        p = (const unsigned char *)src1 - 1;
        if (valid_char[*p]) {
            return 0;
        }
    }
    return 1;
}

Here is the caller graph for this function:

void cb_add_78

(

struct cb_field *

f

)

Definition at line 4810 of file scanner.c.

References CB_VALUE, check_78_replace(), cb_level_78::chk_const, cob_u32_t, cobc_malloc(), const78ptr, current_program, cb_field::flag_is_global, cb_level_78::fld78, globlev78ptr, cb_level_78::globnext, cb_level_78::last, lev78ptr, cb_field::name, cb_level_78::name_len, cb_level_78::next, cb_level_78::pic_len, cb_level_78::pic_replace, cb_level_78::prog, and cb_field::values.

Referenced by cb_validate_78_item().

{
    struct cb_level_78  *p78;

    /* Add a constant (78 level) item */
    p78 = cobc_malloc (sizeof(struct cb_level_78));
    p78->fld78 = f;
    p78->prog = current_program;
    p78->pic_replace = check_78_replace (CB_VALUE(f->values));
    if (p78->pic_replace) {
        p78->pic_len = (cob_u32_t)strlen (p78->pic_replace);
    }
    p78->name_len = (cob_u32_t)strlen (f->name);
    if (f->flag_is_global) {
        if (!globlev78ptr) {
            p78->last = p78;
        } else {
            p78->last = globlev78ptr->last;
        }
        p78->last->globnext = const78ptr;
        p78->next = globlev78ptr;
        p78->globnext = globlev78ptr;
        p78->chk_const = 1;
        globlev78ptr = p78;
        if (lev78ptr) {
            lev78ptr->last->globnext = globlev78ptr;
        } else {
            top78ptr = globlev78ptr;
        }
    } else {
        if (!lev78ptr) {
            p78->last = p78;
        } else {
            p78->last = lev78ptr->last;
        }
        if (globlev78ptr) {
            p78->last->globnext = globlev78ptr;
        } else {
            p78->last->globnext = const78ptr;
        }
        p78->next = lev78ptr;
        p78->globnext = lev78ptr;
        lev78ptr = p78;
        top78ptr = lev78ptr;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cb_add_const_var ( const char *  name, cb_tree  value  )

static

Definition at line 4583 of file scanner.c.

References cb_build_constant(), cb_build_reference(), CB_FIELD, cb_validate_78_item(), CB_VALUE, check_78_replace(), cb_level_78::chk_const, cob_u32_t, cobc_malloc(), const78ptr, cb_field::flag_is_global, cb_field::flag_item_78, cb_level_78::fld78, cb_level_78::globnext, cb_level_78::last, cb_field::level, cb_field::name, cb_level_78::name_len, cb_level_78::next, NULL, cb_level_78::pic_len, cb_level_78::pic_replace, cb_level_78::prog, and cb_field::values.

Referenced by scan_define_options().

{
    cb_tree         x;
    struct cb_level_78  *p78;
    struct cb_field     *f;


    /* Add an inline constant */
    x = cb_build_constant (cb_build_reference (name), value);
    f = CB_FIELD (x);
    f->flag_item_78 = 1;
    f->flag_is_global = 1;
    f->level = 1;
    (void)cb_validate_78_item (f, 1);

    /* Add constant item */
    p78 = cobc_malloc (sizeof(struct cb_level_78));
    p78->fld78 = f;
    p78->prog = NULL;
    p78->pic_replace = check_78_replace (CB_VALUE(f->values));
    if (p78->pic_replace) {
        p78->pic_len = (cob_u32_t)strlen (p78->pic_replace);
    }
    p78->name_len = (cob_u32_t)strlen (f->name);
    /* RXWRXW - Check this */
    p78->chk_const = 0;
    if (!const78ptr) {
        p78->last = p78;
    } else {
        p78->last = const78ptr->last;
    }
    p78->next = const78ptr;
    p78->globnext = const78ptr;
    const78ptr = p78;
    if (globlev78ptr) {
        globlev78ptr->last->globnext = const78ptr;
    } else if (lev78ptr) {
        lev78ptr->last->globnext = const78ptr;
    } else {
        top78ptr = const78ptr;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct cb_program* cb_find_defined_program_by_id

(

const char *

orig_id

)

Definition at line 4905 of file scanner.c.

References CB_CHAIN, CB_PROGRAM, CB_VALUE, defined_prog_list, NULL, and cb_program::orig_program_id.

Referenced by check_prototype_seen().

{
    cb_tree l;
    cb_tree x;
    
    for (l = defined_prog_list; l; l = CB_CHAIN (l)) {
        x = CB_VALUE (l);
        if (strcmp (orig_id, CB_PROGRAM (x)->orig_program_id) == 0) {
            return CB_PROGRAM (x);
        }
    }

    return NULL;
}

Here is the caller graph for this function:

struct cb_program* cb_find_defined_program_by_name

(

const char *

name

)

Definition at line 4882 of file scanner.c.

References CB_CHAIN, CB_PROGRAM, CB_VALUE, defined_prog_list, NULL, and cb_program::program_name.

Referenced by yylex().

{
    int (*cmp_func)(const char *, const char *);
    cb_tree l;
    cb_tree x;
    
    if (cb_fold_call) {
        cmp_func = &strcasecmp;
    } else {
        cmp_func = &strcmp;
    }
    
    for (l = defined_prog_list; l; l = CB_CHAIN (l)) {
        x = CB_VALUE (l);
        if ((*cmp_func)(name, CB_PROGRAM (x)->program_name) == 0) {
            return CB_PROGRAM (x);
        }
    }

    return NULL;
}

Here is the caller graph for this function:

void cb_reset_78

(

void

)

Definition at line 4771 of file scanner.c.

References cobc_free(), const78ptr, globlev78ptr, cb_level_78::next, cb_level_78::not_const, and NULL.

Referenced by cb_build_program().

{
    struct cb_level_78  *p78;
    struct cb_level_78  *p782;

    /* Remove constant (78 level) items for current program */
    for (p78 = lev78ptr; p78; ) {
        p782 = p78->next;
        cobc_free (p78);
        p78 = p782;
    }
    lev78ptr = NULL;
    for (p78 = globlev78ptr; p78; p78 = p78->next) {
        p78->not_const = 0;
    }
    if (globlev78ptr) {
        top78ptr = globlev78ptr;
    } else {
        top78ptr = const78ptr;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cb_reset_global_78

(

void

)

Definition at line 4794 of file scanner.c.

References cobc_free(), const78ptr, cb_level_78::next, and NULL.

Referenced by cb_build_program().

{
    struct cb_level_78  *p78;
    struct cb_level_78  *p782;

    /* Remove constant (78 level) items for top program */
    for (p78 = globlev78ptr; p78; ) {
        p782 = p78->next;
        cobc_free (p78);
        p78 = p782;
    }
    globlev78ptr = NULL;
    top78ptr = const78ptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cb_unput_dot

(

void

)

Definition at line 4765 of file scanner.c.

References unput.

Referenced by yyparse().

{
    unput ('.');
}

Here is the caller graph for this function:

static const char* check_78_replace ( const cb_tree  p )

static

Definition at line 4486 of file scanner.c.

References cb_high, CB_LITERAL, CB_LITERAL_P, cb_low, cb_null, cb_quote, cb_space, cb_zero, and NULL.

Referenced by cb_add_78(), and cb_add_const_var().

{
    /* Check if we can do a constant replacement within PICTURE */
    if (CB_LITERAL_P (p)) {
        if (CB_LITERAL(p)->size > 50) {
            return NULL;
        }
        return (const char *)(CB_LITERAL(p)->data);
    }
    if (p == cb_low) {
        return "LOW-VALUE";
    }
    if (p == cb_high) {
        return "HIGH-VALUE";
    }
    if (p == cb_space) {
        return "SPACE";
    }
    if (p == cb_zero) {
        return "ZERO";
    }
    if (p == cb_quote) {
        return "QUOTE";
    }
    if (p == cb_null) {
        return "NULL";
    }
    return NULL;
}

Here is the caller graph for this function:

struct cb_field* check_level_78

(

const char *

name

)

Definition at line 4858 of file scanner.c.

References cb_level_78::fld78, cb_field::name, cb_level_78::next, and NULL.

Referenced by cb_validate_program_data().

{
    const struct cb_level_78    *p78;

    /* Check against a current constant (78 level) */
    for (p78 = lev78ptr; p78; p78 = p78->next) {
        if (strcasecmp (name, p78->fld78->name) == 0) {
            return p78->fld78;
        }
    }
    /* Check against a global constant (78 level) */
    for (p78 = globlev78ptr; p78; p78 = p78->next) {
        if (strcasecmp (name, p78->fld78->name) == 0) {
            return p78->fld78;
        }
    }
    return NULL;
}

Here is the caller graph for this function:

void cobc_init_scanner

(

void

)

Definition at line 4922 of file scanner.c.

Referenced by main().

{
    const unsigned char *p;

    memset (valid_char, 0, sizeof(valid_char));
    for (p = pvalid_char; *p; ++p) {
        valid_char[*p] = 1;
    }
}

Here is the caller graph for this function:

static void count_lines ( const char *  text )

static

Definition at line 4570 of file scanner.c.

References cb_source_line.

Referenced by yylex().

{
    const char  *p;

    /* Count newlines in text */
    for (p = text; *p; p++) {
        if (*p == '\n') {
            cb_source_line++;
        }
    }
}

Here is the caller graph for this function:

static void error_literal ( const char *  type, const char *  literal  )

static

Definition at line 3844 of file scanner.c.

References _, and cb_error().

Referenced by read_literal(), scan_b(), scan_floating_numeric(), scan_h(), scan_numeric(), scan_o(), scan_x(), and scan_z().

{
    char        lit_out[39];

    if (!literal_error) {
        /* snip literal for output, if too long */
        strncpy (lit_out, literal, 38);
        if (strlen (literal) > 38) {
            strcpy (lit_out + 35, "...");
        } else {
            lit_out[38] = '\0';
        }
        if (strcmp (type, "") == 0) {
            cb_error (_("Invalid literal: '%s'"), lit_out);
        } else if (strcmp (type, "hex") == 0) {
            cb_error (_("Invalid hexadecimal literal: '%s'"), lit_out);
        } else if (strcmp (type, "num") == 0) {
            cb_error (_("Invalid numeric literal: '%s'"), lit_out);
        } else if (strcmp (type, "float") == 0) {
            cb_error (_("Invalid floating-point literal: '%s'"), lit_out);
        } else {
            cb_error (_("Invalid %s literal: '%s'"), type, lit_out);
        }
    }
    literal_error++;
    cb_error (err_msg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int get_sign ( const char  sign )

static

Definition at line 4225 of file scanner.c.

Referenced by scan_define_options(), scan_floating_numeric(), and scan_numeric().

{
    if (sign == '+') {
        return 1;
    } else if (sign == '-') {
        return -1;
    } else {
        return 0;
    }
}

Here is the caller graph for this function:

static int input ( void  )

static

Definition at line 3373 of file scanner.c.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, 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, yyin, yyrestart(), yytext_ptr, and yywrap().

Referenced by read_literal(), and yylex().

{
    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. */
                    yyrestart(yyin );

                    /*FALLTHROUGH*/

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

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

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

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

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

    return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void read_literal ( const char  mark )

static

Definition at line 3873 of file scanner.c.

References _, cb_build_alphanumeric_literal(), cb_warning(), COB_MINI_MAX, cob_u8_t, cobc_realloc(), error_literal(), input(), unlikely, unput, and yylval.

Referenced by yylex().

{
    size_t      i;
    int     c;

    literal_error = 0;

    i = 0;
    while ((c = input ()) != EOF) {
        if (!literal_error) {
            if (unlikely(i == plexsize)) {
                plexsize *= 2;
                if (unlikely (plexsize > (cb_lit_length + 1))) {
                    plexsize = cb_lit_length + 1;
                }
                plexbuff = cobc_realloc (plexbuff, plexsize);
            }
            plexbuff[i] = (cob_u8_t)c;
        }
        if (c == mark && (c = input ()) != (int)mark) {
            if (c == '-') {
                /* Free format continuation ("a"- 'b'- ) */
                /* Hack it as concatenation */
                unput ('&');
            } else {
                unput (c);
            }
            break;
        }
        /* check literal size here as we have to adjust and check
           for (escaped) mark before checking the max length */
        if (unlikely (i++ == cb_lit_length)) {
            plexbuff[i] = 0;
            snprintf (err_msg, COB_MINI_MAX,
                _ ("Literal length exceeds %d characters"),
                cb_lit_length);
            error_literal ("", plexbuff);
        }
    }
    /* fixme: cobol 2014 allows this (and needs it for DYNAMIC LENGTH items),
       while other versions do not allow this at all
       --> add a compiler support configuration for "OK" => zero length,
       "warning" => current implementation, "error" (for example in cobol2002),
       "ignore" => assume a space without warning; make sure zero length items
       work everywhere (should do as we support zero lengths via ODO items already)
    */
    if (!i) {
        cb_warning (_("Alphanumeric literal has zero length"));
        cb_warning (_("A SPACE will be assumed"));
        plexbuff[0] = ' ';
        i = 1;
    }
    plexbuff[i] = 0;
    yylval = cb_build_alphanumeric_literal (plexbuff, i);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_b ( const char *  text, const cob_u32_t  with_mark  )

static

Definition at line 4112 of file scanner.c.

References _, cb_build_numeric_literal(), cb_error_node, CB_FMT_LLU, cb_verify(), COB_MINI_MAX, cob_u64_t, error_literal(), LITERAL, unlikely, and yylval.

Referenced by yylex().

{
    size_t      currlen;
    char        *p;
    cob_u64_t   val = 0;
    int     c;

    literal_error = 0;

    if (( with_mark &&
         !cb_verify (cb_numeric_boolean, _ ("Numeric boolean literal"))) ||
        (!with_mark &&
         !cb_verify (cb_acucobol_literals, _ ("ACUCOBOL numeric literal")))) {
        goto error;
    }

    /* currlen can include the terminating quote */
    currlen = strlen (text);
    memcpy (plexbuff, text, currlen + 1);
    if (with_mark) {
        currlen--;
        plexbuff[currlen] = 0;
    }
    if (unlikely(currlen > 64)) {
        snprintf (err_msg, COB_MINI_MAX,
            _("Literal length %d exceeds %d characters"),
              (int) currlen, 64);
        error_literal ("B", plexbuff);
        goto error;
    }

    for (p = plexbuff; *p != 0; p++) {
        c = (int) *p;
        if (c == '0') {
            c = 0;
        } else if (c == '1') {
            c = 1;
        } else {
            snprintf (err_msg, COB_MINI_MAX,
                _("Literal contains invalid character '%c'"), c);
            error_literal ("B", plexbuff);
            continue;
        }

        val = (val << 1) + c;
    }

    if (literal_error) {
        goto error;
    }

    sprintf ((char *)plexbuff, CB_FMT_LLU, val);
    yylval = cb_build_numeric_literal (0, (const void *)plexbuff, 0);

    return LITERAL;

 error:
    yylval = cb_error_node;
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void scan_define_options ( const char *  text )

static

Definition at line 4634 of file scanner.c.

References _, cb_add_const_var(), cb_build_alphanumeric_literal(), cb_build_numeric_literal(), cb_error(), COB_MAX_DIGITS, cobc_free(), cobc_strdup(), cb_level_78::fld78, get_sign(), cb_level_78::globnext, INCREMENT_IF_SIGNED, cb_field::name, NULL, and sign.

Referenced by yylex().

{
    char                *p;
    char                *s;
    char                *var;
    const struct cb_level_78    *p78;
    char                *q;
    unsigned char           *t;
    cb_tree             x;
    size_t              size;
    int             scale;
    int             sign;

    /* Scan a source inline define */
    p = cobc_strdup (text);

    /* Ignore first part */
    s = strtok (p, " ");

    /* Variable name */
    s = strtok (NULL, " \n");
    if (!s) {
        cobc_free (p);
        return;
    }

    /* Check for already defined constant */
    for (p78 = top78ptr; p78; p78 = p78->globnext) {
        if (strcasecmp (s, p78->fld78->name) == 0) {
            cobc_free (p);
            return;
        }
    }

    var = cobc_strdup (s);

    /* Value */
    s = strtok (NULL, "\n");
    if (!s) {
        cb_error (_("Invalid CONSTANT - %s"), var);
        goto freevar;
    }

    if (*s == '"' || *s == '\'') {
        /* Alphanumeric literal */
        sign = *s;
        size = strlen (s);
        q = s + size - 1;
        if (q == s || *q != sign) {
            cb_error (_("Invalid alphanumeric CONSTANT - %s"), s);
            goto freevar;
        }
        if (size < 3) {
            cb_error (_("Empty alphanumeric CONSTANT - %s"), s);
            goto freevar;
        }
        *q = 0;
        size -= 2;
        x = cb_build_alphanumeric_literal (s + 1, size);
    } else {
        /* Get sign */
        sign = get_sign (*s);
        INCREMENT_IF_SIGNED (s, sign);

        /* Get decimal point */
        scale = 0;
        q = strchr (s, '.');
        if (q) {
            scale = (int)strlen (q) - 1;
            if (scale < 1) {
                cb_error (_("Invalid numeric CONSTANT - %s"), s);
                goto freevar;
            }
            /* Remove decimal point */
            memmove (q, q + 1, (size_t)(scale + 1));
        }
        for (t = (unsigned char *)s; *t; ++t) {
            if (*t < '0' || *t  > '9') {
                cb_error (_("Invalid numeric CONSTANT - %s"), s);
                goto freevar;
            }
        }
        if (strlen (s) > COB_MAX_DIGITS) {
            cb_error (_("Invalid numeric CONSTANT - %s"), s);
            goto freevar;
        }

        x = cb_build_numeric_literal (sign, s, scale);
    }
    /* Add to constant list */
    cb_add_const_var (var, x);

freevar:
    cobc_free (p);
    cobc_free (var);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_floating_numeric ( const char *  text )

static

Definition at line 4309 of file scanner.c.

References _, cb_build_numeric_literal(), cb_error_node, COB_MINI_MAX, current_program, cb_program::decimal_point, error_literal(), get_sign(), INCREMENT_IF_SIGNED, LITERAL, significand_is_zero(), and yylval.

Referenced by yylex().

{
    size_t      sig_int_len;
    size_t      sig_dec_len;
    int     sig_sign;
    int     exp_sign;
    int     scale;
    int     exponent;
    int     n;
    char        significand_str[37];
    char        *significand_pos;
    char        significand_dec[36];
    char        significand_int[36];
    char        exponent_str[8];
    char        *exponent_pos;

    char        result[128];

    literal_error = 0;

    /* Separate into significand and exponent */
    n = sscanf (text, "%36[0-9.,+-]%*[Ee]%7[0-9.,+-]",
        significand_str, exponent_str);
    /* We check the return for silencing warnings,
        this should never happen as the flex rule ensures this */
    if (n == 0) {
        yylval = cb_error_node;
        return LITERAL;
    }

    /* Get signs and adjust string positions accordingly */
    significand_pos = &significand_str[0];
    sig_sign = get_sign (*significand_pos);
    INCREMENT_IF_SIGNED (significand_pos, sig_sign);

    exponent_pos = &exponent_str[0];
    exp_sign = get_sign (*exponent_pos);
    INCREMENT_IF_SIGNED (exponent_pos, exp_sign);

    /* Separate into integer and decimal */
    n = sscanf (significand_pos, "%35[0-9]%*[.,]%35[0-9]",
            significand_int, significand_dec);
    if (n == 0) { /* no integer part, copy after decimal-point */
        significand_int[0] = 0;
        strncpy (significand_dec, significand_pos + 1, 35);
        significand_dec[35] = 0;
    } else {
    /* silencing some warnings */
        significand_int[35] = significand_dec[35] = 0;
    }

    /* Validation */
    sig_int_len = strlen (significand_int);
    sig_dec_len = strlen (significand_dec);
    if (sig_int_len + sig_dec_len > 34U) {
        snprintf (err_msg, COB_MINI_MAX,
            _("Significand has more than 34 digits"));
        error_literal ("float", text);
    }
    if (strchr (exponent_pos, current_program->decimal_point)) {
        snprintf (err_msg, COB_MINI_MAX,
            _("Exponent has decimal point"));
        error_literal ("float", text);
        exponent = 0;
    } else {
        if (strlen (exponent_pos) > 4) {
            snprintf (err_msg, COB_MINI_MAX,
                _("Exponent has more than 4 digits"));
            error_literal ("float", text);
        }
        n = sscanf (exponent_pos, "%d", &exponent);
        /* We check the return for silencing warnings,
           this should never happen as the flex rule ensures this */
        if (n == 0) {
            yylval = cb_error_node;
            return LITERAL;
        }

        if (exp_sign == -1) {
            exponent = -exponent;
        }

        if (!(-78 <= exponent && exponent <= 76)) {
            snprintf (err_msg, COB_MINI_MAX,
                _("Exponent not between -78 and 76"));
            error_literal ("float", text);
        }
    }

    if (significand_is_zero (significand_int, significand_dec)) {
        if (sig_sign == -1) {
            snprintf (err_msg, COB_MINI_MAX,
                _("Significand of 0 must be positive"));
            error_literal ("float", text);
        }
        if (exponent != 0) {
            snprintf (err_msg, COB_MINI_MAX,
                _("Exponent of 0 must be 0"));
            error_literal ("float", text);
        }
        if (exp_sign == -1) {
            snprintf (err_msg, COB_MINI_MAX,
                _("Exponent of 0 must be positive"));
            error_literal ("float", text);
        }
    }

    if (literal_error) {
        yylval = cb_error_node;
        return LITERAL;
    }

    /* Determine scale */
    /* Base scale is decimal part of the significant */
    scale = (int)sig_dec_len;
    /* Adjust according to exponent */
    if (exponent < 0) {
        /* Decimals; power down by scale difference */
        exponent = -exponent;
        scale += exponent;
        result[0] = 0;
        if (exponent > (int)sig_int_len) {
            n = exponent - (int)sig_int_len;
            for (; n; --n) {
                strcat (result, "0");
            }
        }
        strcat (result, significand_int);
        strcat (result, significand_dec);
    } else if (exponent > 0) {
        /* No decimals; power up by scale difference */
        strcpy (result, significand_int);
        strcat (result, significand_dec);
        if (exponent >= scale) {
            n = exponent - scale;
            for (; n; --n) {
                strcat (result, "0");
            }
            scale = 0;
        } else {
            scale -= exponent;
        }
    } else {
        /* Exponent is 0; take as is */
        strcpy (result, significand_int);
        strcat (result, significand_dec);
    }

    yylval = cb_build_numeric_literal (sig_sign, result,
                       scale);
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_h ( const char *  text, const cob_u32_t  with_mark  )

static

Definition at line 4048 of file scanner.c.

References _, cb_build_numeric_literal(), cb_error_node, CB_FMT_LLU, cb_verify(), COB_MINI_MAX, cob_u64_t, error_literal(), LITERAL, unlikely, and yylval.

Referenced by yylex().

{
    size_t      currlen;
    char        *p;
    cob_u64_t   val = 0;
    int     c;

    literal_error = 0;

    if (!with_mark &&
        !cb_verify (cb_acucobol_literals, _("ACUCOBOL numeric literal"))) {
        goto error;
    }


    /* currlen can include the terminating quote */
    currlen = strlen (text);
    memcpy (plexbuff, text, currlen + 1);
    if (with_mark) {
        currlen--;
        plexbuff[currlen] = 0;
    }
    if (unlikely(currlen > 16)) {
        snprintf (err_msg, COB_MINI_MAX,
            _("Literal length %d exceeds %d characters"),
              (int) currlen,  16);
        error_literal ("hex", plexbuff);
        goto error;
    }

    for (p = plexbuff; *p != 0; p++) {
        c = (int)*p;
        if ('0' <= c && c <= '9') {
            c = c - '0';
        } else if ('A' <= c && c <= 'F') {
            c = c - 'A' + 10;
        } else if ('a' <= c && c <= 'f') {
            c = c - 'a' + 10;
        } else {
            snprintf (err_msg, COB_MINI_MAX,
                _("Literal contains invalid character '%c'"), c);
            error_literal ("hex", plexbuff);
            continue;
        }

        val = (val << 4) + c;
    }

    if (literal_error) {
        goto error;
    }

    /* Duplication? */
    sprintf ((char *)plexbuff, CB_FMT_LLU, val);
    yylval = cb_build_numeric_literal (0, (const void *)plexbuff, 0);

    return LITERAL;

error:
    yylval = cb_error_node;
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_numeric ( const char *  text )

static

Definition at line 4244 of file scanner.c.

References _, cb_build_numeric_literal(), cb_error_node, COB_MAX_DIGITS, COB_MINI_MAX, current_program, cb_program::decimal_point, error_literal(), get_sign(), INCREMENT_IF_SIGNED, LITERAL, sign, unlikely, and yylval.

Referenced by yylex().

{
    char        *p = (char *)text;
    char        *s;
    int         sign;
    int         scale;

    /* Get sign */
    sign = get_sign (*p);
    INCREMENT_IF_SIGNED (p, sign);

    /* Get decimal point */
    s = strchr (p, current_program->decimal_point);
    if (s) {
        scale = (int)strlen (s) - 1;
        /* Remove decimal point */
        /* Moves trailing null */
        memmove (s, s + 1, (size_t)(scale + 1));
    } else {
        scale = 0;
    }

    /* leading zeroes should be removed here, shouldn't they ? */

    if (unlikely(strlen (p) > COB_MAX_DIGITS)) {
        /* Absolute limit */
        snprintf (err_msg, COB_MINI_MAX,
              _("Literal length %d exceeds maximum of %d digits"),
              (int) strlen (p), COB_MAX_DIGITS);
        error_literal ("num", text);
        yylval = cb_error_node;
    } else if (unlikely(strlen (p) > cb_numlit_length)) {
        snprintf (err_msg, COB_MINI_MAX,
              _("Literal length %d exceeds %d digits"),
              (int) strlen (p), cb_numlit_length);
        error_literal ("num", text);
        yylval = cb_error_node;
    } else {
        yylval = cb_build_numeric_literal (sign, p, scale);
    }
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_o ( const char *  text )

static

Definition at line 4174 of file scanner.c.

References _, cb_build_numeric_literal(), cb_error_node, CB_FMT_LLU, cb_verify(), COB_MINI_MAX, cob_u64_t, error_literal(), LITERAL, unlikely, and yylval.

Referenced by yylex().

{
    size_t      currlen;
    char        *p;
    cob_u64_t   val = 0;
    int     c;

    literal_error = 0;

    if (!cb_verify (cb_acucobol_literals, _("ACUCOBOL numeric literal"))) {
        goto error;
    }

    currlen = strlen (text);
    memcpy (plexbuff, text, currlen + 1);
    if (unlikely(currlen > 22)) {
        snprintf (err_msg, COB_MINI_MAX,
              _("Literal length %d exceeds %d characters"),
              (int) currlen, 22);
        error_literal ("O", plexbuff);
        goto error;
    }

    for (p = plexbuff; *p != 0; p++) {
        c = (int) *p;
        if (!('0' <= c && c <= '7')) {
            snprintf (err_msg, COB_MINI_MAX,
                _("Literal contains invalid character '%c'"), c);
            error_literal ("O", plexbuff);
            continue;
        }

        c = c - '0';
        val = (val << 3) + c;
    }

    if (literal_error) {
        goto error;
    }

    sprintf ((char *)plexbuff, CB_FMT_LLU, val);
    yylval = cb_build_numeric_literal (0, (const void *)plexbuff, 0);

    return LITERAL;

 error:
    yylval = cb_error_node;
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void scan_options ( const char *  text, const unsigned int  optype  )

static

Definition at line 4627 of file scanner.c.

References COB_UNUSED.

Referenced by yylex().

{
    COB_UNUSED (text);
    COB_UNUSED (optype);
}

Here is the caller graph for this function:

static void scan_picture ( const char *  text )

static

Definition at line 4517 of file scanner.c.

References can_replace(), cb_build_picture(), cb_level_78::fld78, cb_level_78::globnext, cb_field::name, cb_level_78::name_len, cb_level_78::pic_len, cb_level_78::pic_replace, unput, and yylval.

Referenced by yylex().

{
    unsigned char           *p;
    const struct cb_level_78    *p78;
    size_t              n;
    size_t              i;
    size_t              size;
    size_t              sizep;

    /* Scan a PICTURE clause */
    /* Normalize the input */
    for (p = (unsigned char *)text; *p; p++) {
        /* unput trailing '.' or ',' */
        if (p[1] == 0 && (*p == '.' || *p == ',')) {
            unput (*p);
            *p = 0;
            break;
        }
        *p = (unsigned char)toupper (*p);
    }

    if (!top78ptr) {
        yylval = cb_build_picture (text);
        return;
    }

    memset (picbuff1, 0, pic1size);
    memset (picbuff2, 0, pic2size);
    strcpy (picbuff1, text);
    for (p78 = top78ptr; p78; p78 = p78->globnext) {
        if (!p78->pic_replace) {
            strcpy (picbuff2, picbuff1);
            continue;
        }
        size = p78->name_len;
        sizep = p78->pic_len;
        i = 0;
        for (n = 0; n < strlen (picbuff1); n++) {
            if (can_replace (&picbuff1[n], p78->fld78->name, size, n)) {
                memcpy (&picbuff2[i], p78->pic_replace, sizep);
                n += size - 1;
                i += sizep;
            } else {
                picbuff2[i++] = picbuff1[n];
            }
        }
        picbuff2[i] = 0;
        strcpy (picbuff1, picbuff2);
    }
    yylval = cb_build_picture (picbuff2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_x ( const char *  text )

static

Definition at line 3930 of file scanner.c.

References _, cb_build_alphanumeric_literal(), cb_error_node, COB_MINI_MAX, cob_u8_t, cobc_realloc(), error_literal(), likely, LITERAL, plexbuff, unlikely, and yylval.

Referenced by yylex().

{
    char        *p;
    char        *e;
    char        *dst;
    size_t      currlen;
    int         high = 1;
    int         c;

    literal_error = 0;

    /* currlen includes the terminating quote */
    currlen = strlen (text);
    if (unlikely(currlen - 1 > cb_lit_length)) {
        currlen--;
        snprintf (err_msg, COB_MINI_MAX,
            _("Literal length %d exceeds %d characters"),
              (int) currlen, cb_lit_length);
        error_literal ("X", text);
        goto error;
    }
    if (unlikely(currlen > plexsize)) {
        plexsize = currlen;
        plexbuff = cobc_realloc (plexbuff, plexsize);
    }
    p = (char *)text;
    e = (char *)p + currlen - 1;
    dst = plexbuff;
    for (; *p != *e; p++) {
        c = (int)*p;
        if ('0' <= c && c <= '9') {
            c = c - '0';
        } else if ('A' <= c && c <= 'F') {
            c = c - 'A' + 10;
        } else if ('a' <= c && c <= 'f') {
            c = c - 'a' + 10;
        } else {
            snprintf (err_msg, COB_MINI_MAX,
                _("Literal contains invalid character '%c'"), c);
            if (likely (literal_error == 0)) {
                memcpy (plexbuff, text, currlen);
                plexbuff[currlen - 1] = 0;
            }
            error_literal ("X", plexbuff);
            continue;
            /* By not breaking immediately, we detect any following
               invalid chars
            */
        }
        if (likely (literal_error == 0)) {
            if (high) {
                *dst = (cob_u8_t)(c << 4);
            } else {
                *dst++ += (cob_u8_t)c;
            }
        }
        high = 1 - high;
    }

    if (!high) {
        /* This is non-standard behaviour */
        snprintf (err_msg, COB_MINI_MAX,
            _("Literal does not have an even number of digits"));
        if (likely (literal_error == 0)) {
            memcpy (plexbuff, text, currlen);
            plexbuff[currlen - 1] = 0;
        }
        error_literal ("X", plexbuff);
    }

    if (unlikely(literal_error != 0)) {
        goto error;
    }

    yylval = cb_build_alphanumeric_literal (plexbuff, (size_t)(dst - plexbuff));
    return LITERAL;

error:
    yylval = cb_error_node;
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int scan_z ( const char *  text, const cob_u32_t  llit  )

static

Definition at line 4013 of file scanner.c.

References _, cb_build_alphanumeric_literal(), cb_error_node, CB_LITERAL, COB_MINI_MAX, cobc_realloc(), error_literal(), LITERAL, unlikely, and yylval.

Referenced by yylex().

{
    size_t      currlen;

    literal_error = 0;

    /* currlen includes the terminating quote */
    currlen = strlen (text);
    if (unlikely((currlen - 1) > cb_lit_length)) {
        currlen--;
        snprintf (err_msg, COB_MINI_MAX,
            _("Literal length %d exceeds %d characters"),
              (int) currlen, cb_lit_length);
        if (llit) {
            error_literal ("L", text);
        } else {
            error_literal ("Z", text);
        }
        yylval = cb_error_node;
        return LITERAL;
    }
    if (unlikely(currlen > plexsize)) {
        plexsize = currlen;
        plexbuff = cobc_realloc (plexbuff, plexsize);
    }
    memcpy (plexbuff, text, currlen);
    plexbuff[currlen - 1] = 0;

    /* Count is correct here as the trailing quote is now a null */
    yylval = cb_build_alphanumeric_literal (plexbuff, currlen);
    CB_LITERAL(yylval)->llit = llit;
    return LITERAL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int significand_is_zero ( const char *  int_part, const char *  dec_part  )

static

Definition at line 4302 of file scanner.c.

References all_zeroes().

Referenced by scan_floating_numeric().

{
    return all_zeroes (int_part)
        && all_zeroes (dec_part);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ylex_call_destroy

(

void

)

Definition at line 4757 of file scanner.c.

References NULL, and yylex_destroy().

Referenced by process_translate().

{
    /* Release flex buffers */
    (void)yylex_destroy ();
    const78ptr = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void ylex_clear_all

(

void

)

Definition at line 4736 of file scanner.c.

References cobc_free(), and NULL.

Referenced by main().

{
    /* Clear buffers after parsing all source elements */
    if (picbuff2) {
        cobc_free (picbuff2);
        picbuff2 = NULL;
    }
    if (picbuff1) {
        cobc_free (picbuff1);
        picbuff1 = NULL;
    }
    if (plexbuff) {
        cobc_free (plexbuff);
        plexbuff = NULL;
    }
    plexsize = 0;
    pic1size = 0;
    pic2size = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

YY_BUFFER_STATE yy_create_buffer	(	FILE *	file,
		int	size
	)

Allocate and initialize an input buffer state.

Parameters

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

Returns

the allocated buffer state.

Definition at line 3512 of file scanner.c.

References yy_buffer_state::yy_buf_size, yy_buffer_state::yy_ch_buf, YY_FATAL_ERROR, yy_init_buffer(), yy_buffer_state::yy_is_our_buffer, and yyalloc().

Referenced by yylex(), and yyrestart().

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

    b->yy_buf_size = size;

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

    b->yy_is_our_buffer = 1;

    yy_init_buffer(b,file );

    return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void yy_delete_buffer

(

YY_BUFFER_STATE

b

)

Destroy the buffer.

Parameters

b	a buffer created with yy_create_buffer()

Definition at line 3540 of file scanner.c.

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

Referenced by yylex_destroy(), and yypop_buffer_state().

{
    
    if ( ! b )
        return;

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

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

    yyfree((void *) b  );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void yy_fatal_error ( char  msg[] )

static

static void yy_fatal_error ( char *  msg )

static

Definition at line 3712 of file scanner.c.

References YY_EXIT_FAILURE.

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

void yy_flush_buffer

(

YY_BUFFER_STATE

b

)

Discard all buffered characters.

On the next scan, YY_INPUT will be called.

Parameters

b	the buffer state to be flushed, usually YY_CURRENT_BUFFER.

Definition at line 3587 of file scanner.c.

References 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, yy_load_buffer_state(), and yy_buffer_state::yy_n_chars.

Referenced by yy_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 )
        yy_load_buffer_state( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int yy_get_next_buffer ( void  )

static

Definition at line 3142 of file scanner.c.

References EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, 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, yyin, yyrealloc(), yyrestart(), and yytext_ptr.

Referenced by input(), and yylex().

{
        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. */
                    yyrealloc((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;
            yyrestart(yyin  );
            }

        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 *) yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size  );
        if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
            YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
    }

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

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

    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static yy_state_type yy_get_previous_state ( void  )

static

Definition at line 3276 of file scanner.c.

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

Referenced by yylex().

{
    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 >= 833 )
                yy_c = yy_meta[(unsigned int) yy_c];
            }
        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
        }

    return yy_current_state;
}

Here is the caller graph for this function:

static void yy_init_buffer ( YY_BUFFER_STATE  b, FILE *  file  )

static

Definition at line 3559 of file scanner.c.

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

Referenced by yy_create_buffer(), and yyrestart().

{
    int oerrno = errno;
    
    yy_flush_buffer(b );

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

static int yy_init_globals ( void  )

static

Get the current token.

Definition at line 3741 of file scanner.c.

References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, yy_c_buf_p, yy_init, yy_start, yyin, and yyout.

Referenced by yylex_destroy().

{
        /* Initialization is the same as for the non-reentrant scanner.
     * This function is called from yylex_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;

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

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

Here is the caller graph for this function:

static void yy_load_buffer_state ( void  )

static

Definition at line 3498 of file scanner.c.

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

Referenced by yy_flush_buffer(), yy_switch_to_buffer(), yylex(), yypop_buffer_state(), yypush_buffer_state(), and yyrestart().

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

Here is the caller graph for this function:

YY_BUFFER_STATE yy_scan_buffer	(	char *	base,
		yy_size_t	size
	)

YY_BUFFER_STATE yy_scan_bytes	(	char *	bytes,
		yy_size_t	len
	)

YY_BUFFER_STATE yy_scan_string

(

char *

yy_str

)

void yy_switch_to_buffer

(

YY_BUFFER_STATE

new_buffer

)

Switch to a different input buffer.

Parameters

new_buffer

The new input buffer.

Definition at line 3467 of file scanner.c.

References yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().

{
    
    /* TODO. We should be able to replace this entire function body
     * with
     *      yypop_buffer_state();
     *      yypush_buffer_state(new_buffer);
     */
    yyensure_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;
    yy_load_buffer_state( );

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

Here is the call graph for this function:

static yy_state_type yy_try_NUL_trans ( yy_state_type  current_state )

static

Definition at line 3309 of file scanner.c.

References yy_c_buf_p, yy_last_accepting_cpos, and yy_last_accepting_state.

Referenced by yylex().

{
    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 >= 833 )
            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 == 832);

        return yy_is_jam ? 0 : yy_current_state;
}

Here is the caller graph for this function:

void * yyalloc

(

yy_size_t

size

)

Definition at line 3815 of file scanner.c.

Referenced by yy_create_buffer(), and yyensure_buffer_stack().

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

Here is the caller graph for this function:

static void yyensure_buffer_stack ( void  )

static

Definition at line 3665 of file scanner.c.

References yy_buffer_stack, yy_buffer_stack_max, yy_buffer_stack_top, YY_FATAL_ERROR, yyalloc(), and yyrealloc().

Referenced by yy_switch_to_buffer(), yylex(), yypush_buffer_state(), and yyrestart().

{
    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**)yyalloc
                                (num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in yyensure_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**)yyrealloc
                                ((yy_buffer_stack),
                                num_to_alloc * sizeof(struct yy_buffer_state*)
                                );
        if ( ! (yy_buffer_stack) )
            YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

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

Here is the call graph for this function:

Here is the caller graph for this function:

void yyfree

(

void *

ptr

)

Definition at line 3832 of file scanner.c.

Referenced by yy_delete_buffer(), and yylex_destroy().

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

Here is the caller graph for this function:

int yylex

(

void

)

The main scanner function which does all the work.

Definition at line 1705 of file scanner.c.

References _, BEGIN, BOTTOM, cb_build_alphanumeric_literal(), cb_build_comment(), cb_build_numeric_literal(), cb_build_reference(), CB_CHAIN, CB_CS_EXIT, cb_error(), cb_error_node, cb_find_defined_program_by_name(), CB_FUNC_PROTOTYPE, CB_FUNCTION_TYPE, cb_intrinsic_list, CB_LITERAL, cb_source_file, cb_source_line, CB_SYSTEM_NAME_P, CB_VALUE, cb_warning(), CB_WORD_COUNT, CB_WORD_ITEMS, cb_level_78::chk_const, COB_MAX_WORDLEN, cobc_cs_check, cobc_force_literal, cobc_free(), cobc_in_procedure, cobc_in_repository, cobc_parse_strdup(), cobc_strdup(), COMMA_DELIM, count_lines(), current_program, DECIMAL_IS_COMMA, DECIMAL_IS_PERIOD, cb_program::decimal_point, EC, END, END_FUNCTION, END_PROGRAM, EOB_ACT_CONTINUE_SCAN, EOB_ACT_END_OF_FILE, EOB_ACT_LAST_MATCH, EOP, EQUAL, ESCAPE, EVENT_STATUS, EXCEPTION, EXCEPTION_CONDITION, EXPONENTIATION, cb_level_78::fld78, FROM_CRT, FUNCTION, FUNCTION_NAME, cb_program::function_spec_list, FUNCTION_STATE, functions_are_all, cb_level_78::globnext, GREATER, GREATER_OR_EQUAL, INITIAL, input(), INVALID_KEY, LENGTH_OF, LESS, LESS_OR_EQUAL, likely, LITERAL, lookup_intrinsic(), lookup_reserved_word(), MNEMONIC_NAME, cb_field::name, cb_intrinsic_table::name, cb_text_list::next, cb_level_78::next, NEXT_PAGE, NO_ADVANCING, cobc_reserved::nodegen, non_const_word, cb_level_78::not_const, NOT_END, NOT_EOP, NOT_EQUAL, NOT_ESCAPE, NOT_EXCEPTION, NOT_INVALID_KEY, NOT_OVERFLOW, NOT_SIZE_ERROR, NULL, cb_program::orig_program_id, PICTURE, PICTURE_STATE, PICTURE_SYMBOL, cb_level_78::prog, cb_program::prog_type, PROGRAM_NAME, read_literal(), READY_TRACE, REPLACING, RESET_TRACE, scan_b(), scan_define_options(), scan_floating_numeric(), scan_h(), scan_numeric(), scan_o(), scan_options(), scan_picture(), scan_x(), scan_z(), SCREEN_CONTROL, SEMI_COLON, SIZE_ERROR, cb_text_list::text, TOK_AMPER, TOK_CLOSE_PAREN, TOK_COLON, TOK_DIV, TOK_DOT, TOK_EQUAL, TOK_GREATER, TOK_LESS, TOK_MINUS, TOK_MUL, TOK_OPEN_PAREN, TOK_OVERFLOW, TOK_PLUS, cobc_reserved::token, cb_intrinsic_table::token, TOP, unlikely, unput, UPON_ARGUMENT_NUMBER, UPON_COMMAND_LINE, UPON_ENVIRONMENT_NAME, UPON_ENVIRONMENT_VALUE, USER_FUNCTION_NAME, cb_program::user_spec_list, cb_field::values, warningopt, WORD, YY_AT_BOL, YY_BREAK, YY_BUF_SIZE, YY_BUFFER_NEW, YY_BUFFER_NORMAL, yy_c_buf_p, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, YY_DO_BEFORE_ACTION, YY_END_OF_BUFFER, YY_FATAL_ERROR, yy_get_next_buffer(), yy_get_previous_state(), yy_hold_char, yy_init, yy_last_accepting_cpos, yy_last_accepting_state, yy_load_buffer_state(), YY_MORE_ADJ, yy_n_chars, YY_NEW_FILE, YY_RESTORE_YY_MORE_OFFSET, YY_RULE_SETUP, YY_SC_TO_UI, YY_START, yy_start, YY_STATE_EOF, yy_try_NUL_trans(), YY_USER_INIT, yyensure_buffer_stack(), yyin, yyleng, yylval, yyout, yyterminate, yytext_ptr, and yywrap().

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

#ifdef YY_USER_INIT
        YY_USER_INIT;
#endif

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

        if ( ! yyin )
            yyin = stdin;

        if ( ! yyout )
            yyout = stdout;

        if ( ! YY_CURRENT_BUFFER ) {
            yyensure_buffer_stack ();
            YY_CURRENT_BUFFER_LVALUE =
                yy_create_buffer(yyin,YY_BUF_SIZE );
        }

        yy_load_buffer_state( );
        }

    {
#line 229 "scanner.l"



    if (likely(current_program)) {
        if (current_program->decimal_point == '.') {
            BEGIN DECIMAL_IS_PERIOD;
        } else {
            BEGIN DECIMAL_IS_COMMA;
        }
    }

    /* We treat integer literals immediately after '.' as labels;
       that is, they must be level numbers or section names. */
    if (last_token_is_dot) {
        integer_is_label = 1;
        last_token_is_dot = 0;
    } else {
        integer_is_label = 0;
    }



#line 1761 "scanner.c"

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

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

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

        yy_current_state = (yy_start);
        yy_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 >= 833 )
                    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 != 832 );
        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:
/* rule 1 can match eol */
YY_RULE_SETUP
#line 251 "scanner.l"
{
    scan_define_options (yytext);
}
    YY_BREAK
case 2:
/* rule 2 can match eol */
YY_RULE_SETUP
#line 255 "scanner.l"
{
    scan_options (yytext, 1);
}
    YY_BREAK
case 3:
/* rule 3 can match eol */
YY_RULE_SETUP
#line 259 "scanner.l"
{
    scan_options (yytext, 2);
}
    YY_BREAK
case 4:
/* rule 4 can match eol */
YY_RULE_SETUP
#line 263 "scanner.l"
{
    scan_options (yytext, 3);
}
    YY_BREAK
case 5:
/* rule 5 can match eol */
YY_RULE_SETUP
#line 267 "scanner.l"
{
    cb_source_line++;
}
    YY_BREAK
case 6:
YY_RULE_SETUP
#line 271 "scanner.l"
{
    /* Line directive */
    char        *p1;
    char        *p2;

    p1 = strchr (yytext, '"');
    if (p1) {
        p2 = cobc_strdup (p1 + 1);
        p1 = strrchr (p2, '"');
        if (p1) {
            *p1 = 0;
            cb_source_file = cobc_parse_strdup (p2);
            cb_source_line = (int)strtol (yytext + 5, NULL, 10) - 1;
        }
        cobc_free (p2);
    }
}
    YY_BREAK
case 7:
YY_RULE_SETUP
#line 289 "scanner.l"
{
    /* Ignore */
}
    YY_BREAK
case 8:
#line 294 "scanner.l"
case 9:
YY_RULE_SETUP
#line 294 "scanner.l"
{
    BEGIN PICTURE_STATE;
}
    YY_BREAK
case 10:
YY_RULE_SETUP
#line 298 "scanner.l"
{
    if (cobc_in_repository || cobc_cs_check == CB_CS_EXIT) {
        yylval = NULL;
        return FUNCTION;
    }
    BEGIN FUNCTION_STATE;
}
    YY_BREAK
case 11:
YY_RULE_SETUP
#line 306 "scanner.l"
{
    /* String literal */
    cobc_force_literal = 0;
    read_literal (yytext[0]);
    return LITERAL;
}
    YY_BREAK
case 12:
#line 314 "scanner.l"
case 13:
YY_RULE_SETUP
#line 314 "scanner.l"
{
    /* X string literal */
    cobc_force_literal = 0;
    return scan_x (yytext + 2);
}
    YY_BREAK
case 14:
#line 321 "scanner.l"
case 15:
YY_RULE_SETUP
#line 321 "scanner.l"
{
    /* Z string literal */
    cobc_force_literal = 0;
    return scan_z (yytext + 2, 0);
}
    YY_BREAK
case 16:
#line 328 "scanner.l"
case 17:
YY_RULE_SETUP
#line 328 "scanner.l"
{
    /* L string literal */
    cobc_force_literal = 0;
    return scan_z (yytext + 2, 1);
}
    YY_BREAK
case 18:
#line 335 "scanner.l"
case 19:
YY_RULE_SETUP
#line 335 "scanner.l"
{
    /* H numeric literal */
    cobc_force_literal = 0;
    return scan_h (yytext + 2, 1);
}
    YY_BREAK
case 20:
#line 342 "scanner.l"
case 21:
YY_RULE_SETUP
#line 342 "scanner.l"
{
    /* B boolean/numeric literal */
    cobc_force_literal = 0;
    return scan_b (yytext + 2, 1);
}
    YY_BREAK
case 22:
YY_RULE_SETUP
#line 348 "scanner.l"
{
    /*
      To avoid subtle silent errors, such as B#021, this rule (and the ones
      following) here admit some invalid literals which emit errors when
      they are processed.
    */
    /* ACUCOBOL binary numeric literal */
    cobc_force_literal = 0;
    return scan_b (yytext + 2, 0);
}
    YY_BREAK
case 23:
YY_RULE_SETUP
#line 359 "scanner.l"
{
    /* ACUCOBOL octal numeric literal */
    cobc_force_literal = 0;
    return scan_o (yytext + 2);
}
    YY_BREAK
case 24:
#line 366 "scanner.l"
case 25:
YY_RULE_SETUP
#line 366 "scanner.l"
{
    /* ACUCOBOL hexadecimal numeric literal */
    cobc_force_literal = 0;
    return scan_h (yytext + 2, 0);
}
    YY_BREAK
case 26:
YY_RULE_SETUP
#line 372 "scanner.l"
{
    inside_bracket++;
    return TOK_OPEN_PAREN;
}
    YY_BREAK
case 27:
YY_RULE_SETUP
#line 377 "scanner.l"
{
    if (inside_bracket > 0) {
        inside_bracket--;
    }
    return TOK_CLOSE_PAREN;
}
    YY_BREAK
case 28:
YY_RULE_SETUP
#line 384 "scanner.l"
{
    cobc_force_literal = 0;
    if (integer_is_label) {
        /* Integer label or level number */
        yylval = cb_build_reference (yytext);
        return WORD;
    }
    /* Numeric literal or referenced integer label */
    /* All transformations/checks are postponed to tree.c */
    yylval = cb_build_numeric_literal (0, yytext, 0);
    return LITERAL;
}
    YY_BREAK
case 29:
YY_RULE_SETUP
#line 397 "scanner.l"
{
    /* Numeric literal (signed) */
    return scan_numeric (yytext);
}
    YY_BREAK
case 30:
YY_RULE_SETUP
#line 402 "scanner.l"
{
    /* Ignore */
}
    YY_BREAK
case 31:
YY_RULE_SETUP
#line 406 "scanner.l"
{
    if (inside_bracket) {
        return SEMI_COLON;
    }
    /* Ignore */
}
    YY_BREAK
case 32:
YY_RULE_SETUP
#line 413 "scanner.l"
{
    /* Numeric floating point literal */
    return scan_floating_numeric (yytext);
}
    YY_BREAK
case 33:
YY_RULE_SETUP
#line 418 "scanner.l"
{
    /* Invalid numeric floating point literal */
    return scan_floating_numeric (yytext);
}
    YY_BREAK
case 34:
YY_RULE_SETUP
#line 423 "scanner.l"
{
    /* Numeric literal */
    return scan_numeric (yytext);
}
    YY_BREAK
case 35:
YY_RULE_SETUP
#line 428 "scanner.l"
{
    if (inside_bracket) {
        return COMMA_DELIM;
    }
    /* Ignore */
}
    YY_BREAK
case 36:
YY_RULE_SETUP
#line 435 "scanner.l"
{
    /* Numeric floating point literal */
    return scan_floating_numeric (yytext);
}
    YY_BREAK
case 37:
YY_RULE_SETUP
#line 440 "scanner.l"
{
    /* Invalid numeric floating point literal */
    return scan_floating_numeric (yytext);
}
    YY_BREAK
case 38:
YY_RULE_SETUP
#line 445 "scanner.l"
{
    /* Numeric literal */
    return scan_numeric (yytext);
}
    YY_BREAK
case 39:
YY_RULE_SETUP
#line 450 "scanner.l"
{
    unput (',');
}
    YY_BREAK
case 40:
YY_RULE_SETUP
#line 454 "scanner.l"
{
    if (inside_bracket) {
        return COMMA_DELIM;
    }
    /* Ignore */
}
    YY_BREAK
case 41:
/* rule 41 can match eol */
YY_RULE_SETUP
#line 461 "scanner.l"
{
    cobc_force_literal = 1;
    count_lines (yytext);
    return END_PROGRAM;
}
    YY_BREAK
case 42:
/* rule 42 can match eol */
YY_RULE_SETUP
#line 467 "scanner.l"
{
    cobc_force_literal = 1;
    count_lines (yytext);
    return END_FUNCTION;
}
    YY_BREAK
case 43:
/* rule 43 can match eol */
YY_RULE_SETUP
#line 473 "scanner.l"
{
    count_lines (yytext);
    return PICTURE_SYMBOL;
}
    YY_BREAK
case 44:
/* rule 44 can match eol */
YY_RULE_SETUP
#line 478 "scanner.l"
{
    count_lines (yytext);
    return FROM_CRT;
}
    YY_BREAK
case 45:
/* rule 45 can match eol */
YY_RULE_SETUP
#line 483 "scanner.l"
{
    count_lines (yytext);
    return SCREEN_CONTROL;
}
    YY_BREAK
case 46:
/* rule 46 can match eol */
YY_RULE_SETUP
#line 488 "scanner.l"
{
    count_lines (yytext);
    return EVENT_STATUS;
}
    YY_BREAK
case 47:
/* rule 47 can match eol */
YY_RULE_SETUP
#line 493 "scanner.l"
{
    count_lines (yytext);
    return READY_TRACE;
}
    YY_BREAK
case 48:
/* rule 48 can match eol */
YY_RULE_SETUP
#line 498 "scanner.l"
{
    count_lines (yytext);
    return RESET_TRACE;
}
    YY_BREAK
case 49:
/* rule 49 can match eol */
#line 504 "scanner.l"
case 50:
/* rule 50 can match eol */
#line 505 "scanner.l"
case 51:
/* rule 51 can match eol */
#line 506 "scanner.l"
case 52:
/* rule 52 can match eol */
YY_RULE_SETUP
#line 506 "scanner.l"
{
    count_lines (yytext);
    return GREATER_OR_EQUAL;
}
    YY_BREAK
case 53:
/* rule 53 can match eol */
YY_RULE_SETUP
#line 511 "scanner.l"
{
    count_lines (yytext);
    return GREATER;
}
    YY_BREAK
case 54:
/* rule 54 can match eol */
#line 517 "scanner.l"
case 55:
/* rule 55 can match eol */
#line 518 "scanner.l"
case 56:
/* rule 56 can match eol */
#line 519 "scanner.l"
case 57:
/* rule 57 can match eol */
YY_RULE_SETUP
#line 519 "scanner.l"
{
    count_lines (yytext);
    return LESS_OR_EQUAL;
}
    YY_BREAK
case 58:
/* rule 58 can match eol */
YY_RULE_SETUP
#line 524 "scanner.l"
{
    count_lines (yytext);
    return LESS;
}
    YY_BREAK
case 59:
/* rule 59 can match eol */
YY_RULE_SETUP
#line 529 "scanner.l"
{
    count_lines (yytext);
    return EQUAL;
}
    YY_BREAK
case 60:
/* rule 60 can match eol */
YY_RULE_SETUP
#line 534 "scanner.l"
{
    count_lines (yytext);
    return REPLACING;
}
    YY_BREAK
case 61:
/* rule 61 can match eol */
#line 540 "scanner.l"
case 62:
/* rule 62 can match eol */
#line 541 "scanner.l"
case 63:
/* rule 63 can match eol */
YY_RULE_SETUP
#line 541 "scanner.l"
{
    count_lines (yytext);
    return TOP;
}
    YY_BREAK
case 64:
/* rule 64 can match eol */
#line 547 "scanner.l"
case 65:
/* rule 65 can match eol */
#line 548 "scanner.l"
case 66:
/* rule 66 can match eol */
YY_RULE_SETUP
#line 548 "scanner.l"
{
    count_lines (yytext);
    return BOTTOM;
}
    YY_BREAK
case 67:
/* rule 67 can match eol */
#line 554 "scanner.l"
case 68:
/* rule 68 can match eol */
YY_RULE_SETUP
#line 554 "scanner.l"
{
    count_lines (yytext);
    return NO_ADVANCING;
}
    YY_BREAK
case 69:
/* rule 69 can match eol */
#line 560 "scanner.l"
case 70:
/* rule 70 can match eol */
YY_RULE_SETUP
#line 560 "scanner.l"
{
    count_lines (yytext);
    return NEXT_PAGE;
}
    YY_BREAK
case 71:
/* rule 71 can match eol */
#line 566 "scanner.l"
case 72:
/* rule 72 can match eol */
YY_RULE_SETUP
#line 566 "scanner.l"
{
    count_lines (yytext);
    return NOT_SIZE_ERROR;
}
    YY_BREAK
case 73:
/* rule 73 can match eol */
#line 572 "scanner.l"
case 74:
/* rule 74 can match eol */
YY_RULE_SETUP
#line 572 "scanner.l"
{
    count_lines (yytext);
    return SIZE_ERROR;
}
    YY_BREAK
case 75:
/* rule 75 can match eol */
#line 578 "scanner.l"
case 76:
/* rule 76 can match eol */
YY_RULE_SETUP
#line 578 "scanner.l"
{
    count_lines (yytext);
    return NOT_ESCAPE;
}
    YY_BREAK
case 77:
/* rule 77 can match eol */
#line 584 "scanner.l"
case 78:
/* rule 78 can match eol */
YY_RULE_SETUP
#line 584 "scanner.l"
{
    count_lines (yytext);
    return NOT_EXCEPTION;
}
    YY_BREAK
case 79:
/* rule 79 can match eol */
YY_RULE_SETUP
#line 589 "scanner.l"
{
    count_lines (yytext);
    return ESCAPE;
}
    YY_BREAK
case 80:
/* rule 80 can match eol */
YY_RULE_SETUP
#line 594 "scanner.l"
{
    count_lines (yytext);
    return EXCEPTION;
}
    YY_BREAK
case 81:
/* rule 81 can match eol */
#line 600 "scanner.l"
case 82:
/* rule 82 can match eol */
YY_RULE_SETUP
#line 600 "scanner.l"
{
    count_lines (yytext);
    return NOT_OVERFLOW;
}
    YY_BREAK
case 83:
/* rule 83 can match eol */
#line 606 "scanner.l"
case 84:
/* rule 84 can match eol */
YY_RULE_SETUP
#line 606 "scanner.l"
{
    count_lines (yytext);
    return NOT_END;
}
    YY_BREAK
case 85:
/* rule 85 can match eol */
YY_RULE_SETUP
#line 611 "scanner.l"
{
    count_lines (yytext);
    return END;
}
    YY_BREAK
case 86:
/* rule 86 can match eol */
#line 617 "scanner.l"
case 87:
/* rule 87 can match eol */
YY_RULE_SETUP
#line 617 "scanner.l"
{
    count_lines (yytext);
    return TOK_OVERFLOW;
}
    YY_BREAK
case 88:
/* rule 88 can match eol */
#line 623 "scanner.l"
case 89:
/* rule 89 can match eol */
#line 624 "scanner.l"
case 90:
/* rule 90 can match eol */
#line 625 "scanner.l"
case 91:
/* rule 91 can match eol */
YY_RULE_SETUP
#line 625 "scanner.l"
{
    count_lines (yytext);
    return NOT_EOP;
}
    YY_BREAK
case 92:
/* rule 92 can match eol */
#line 631 "scanner.l"
case 93:
/* rule 93 can match eol */
#line 632 "scanner.l"
case 94:
/* rule 94 can match eol */
#line 633 "scanner.l"
case 95:
/* rule 95 can match eol */
YY_RULE_SETUP
#line 633 "scanner.l"
{
    count_lines (yytext);
    return EOP;
}
    YY_BREAK
case 96:
/* rule 96 can match eol */
YY_RULE_SETUP
#line 638 "scanner.l"
{
    count_lines (yytext);
    return NOT_INVALID_KEY;
}
    YY_BREAK
case 97:
/* rule 97 can match eol */
YY_RULE_SETUP
#line 643 "scanner.l"
{
    count_lines (yytext);
    return NOT_INVALID_KEY;
}
    YY_BREAK
case 98:
/* rule 98 can match eol */
YY_RULE_SETUP
#line 648 "scanner.l"
{
    count_lines (yytext);
    return INVALID_KEY;
}
    YY_BREAK
case 99:
/* rule 99 can match eol */
YY_RULE_SETUP
#line 653 "scanner.l"
{
    count_lines (yytext);
    return INVALID_KEY;
}
    YY_BREAK
case 100:
/* rule 100 can match eol */
YY_RULE_SETUP
#line 658 "scanner.l"
{
    count_lines (yytext);
    return UPON_ENVIRONMENT_NAME;
}
    YY_BREAK
case 101:
/* rule 101 can match eol */
YY_RULE_SETUP
#line 663 "scanner.l"
{
    count_lines (yytext);
    return UPON_ENVIRONMENT_VALUE;
}
    YY_BREAK
case 102:
/* rule 102 can match eol */
YY_RULE_SETUP
#line 668 "scanner.l"
{
    count_lines (yytext);
    return UPON_ARGUMENT_NUMBER;
}
    YY_BREAK
case 103:
/* rule 103 can match eol */
YY_RULE_SETUP
#line 673 "scanner.l"
{
    count_lines (yytext);
    return UPON_COMMAND_LINE;
}
    YY_BREAK
case 104:
/* rule 104 can match eol */
YY_RULE_SETUP
#line 678 "scanner.l"
{
    count_lines (yytext);
    return EXCEPTION_CONDITION;
}
    YY_BREAK
case 105:
/* rule 105 can match eol */
YY_RULE_SETUP
#line 683 "scanner.l"
{
    count_lines (yytext);
    return EXCEPTION_CONDITION;
}
    YY_BREAK
case 106:
/* rule 106 can match eol */
YY_RULE_SETUP
#line 688 "scanner.l"
{
    count_lines (yytext);
    return EC;
}
    YY_BREAK
case 107:
/* rule 107 can match eol */
YY_RULE_SETUP
#line 693 "scanner.l"
{
    count_lines (yytext);
    return LENGTH_OF;
}
    YY_BREAK
case 108:
/* rule 108 can match eol */
YY_RULE_SETUP
#line 698 "scanner.l"
{
    /* ACUCOBOL extension: switch-names with space and with letter */
    char suffix[3] = "";
    char name[10] = "";

    unput (yytext[yyleng-1]); /* unput seperator */
    if (cobc_in_procedure) {
         /* unput characters */
        yylval = cb_build_reference ("SWITCH");
        if (isdigit((unsigned char)yytext[yyleng-3])) {
            unput (yytext[yyleng-2]);
            unput (yytext[yyleng-3]);
        } else {
            unput (yytext[yyleng-2]);
        }
    } else {
         /* we need to return a single word, reverted later in parser.y */
        if (yytext[yyleng-3] == ' ' && isdigit((unsigned char)yytext[yyleng-2])) {
            /* SWITCH 0  to SWITCH 9 */
            suffix[0] = yytext[yyleng-2];
        } else if (isdigit((unsigned char)yytext[yyleng-3])) {
            /* SWITCH 00 to SWITCH 99 */
            suffix[0] = yytext[yyleng-3];
            suffix[1] = yytext[yyleng-2];
        } else {
            suffix[0] = yytext[yyleng-2];
        }
        strncpy(name, yytext, 6);
        strcat(name, "_");
        strcat(name, suffix);
        yylval = cb_build_reference (name);
    }
    return WORD;
}
    YY_BREAK
case 109:
YY_RULE_SETUP
#line 733 "scanner.l"
{
    struct cb_level_78      *p78;
    struct cb_intrinsic_table   *cbp;
    struct cobc_reserved        *resptr;
    struct cb_text_list     *tlp;
    cb_tree             x;
    cb_tree             l;
    struct cb_program       *program;

    /* Check word length */
    if (unlikely(yyleng > cb_word_length)) {
        if (yyleng > COB_MAX_WORDLEN) {
            /* Absolute limit */
            cb_error (_("Word length exceeds maximum of %d characters - '%s'"),
                  COB_MAX_WORDLEN, yytext);
        } else if (!cb_relaxed_syntax_check) {
            cb_error (_("Word length exceeds %d characters - '%s'"),
                  cb_word_length, yytext);
        } else if (warningopt) {
            cb_warning (_("Word length exceeds %d characters - '%s'"),
                  cb_word_length, yytext);
        }
    }

    /* Check Intrinsic FUNCTION name without keyword */
    if ((cobc_in_procedure && (functions_are_all || cb_intrinsic_list ||
         current_program->function_spec_list)) || cobc_in_repository) {
        cbp = lookup_intrinsic (yytext, 1, 0);
        if (cbp) {
            if (cobc_in_repository) {
                yylval = cb_build_alphanumeric_literal (yytext, (size_t)yyleng);
                return FUNCTION_NAME;
            }
            if (functions_are_all) {
                yylval = cb_build_reference (yytext);
                return (enum yytokentype)(cbp->token);
            }
            for (tlp = cb_intrinsic_list; tlp; tlp = tlp->next) {
                if (!strcasecmp (yytext, tlp->text)) {
                    yylval = cb_build_reference (yytext);
                    return (enum yytokentype)(cbp->token);
                }
            }
            l = current_program->function_spec_list;
            for (; l; l = CB_CHAIN(l)) {
                x = CB_VALUE (l);
                if (!strcasecmp (yytext,
                         (char *)(CB_LITERAL(x)->data))) {
                    yylval = cb_build_reference (yytext);
                    return (enum yytokentype)(cbp->token);
                }
            }
        }
    }

    /* Bail early for (END) PROGRAM-ID when not a literal */
    if (unlikely(cobc_force_literal)) {
        /* Force PROGRAM-ID / END PROGRAM */
        cobc_force_literal = 0;
        if (cb_fold_call) {
            yylval = cb_build_reference (yytext);
            return PROGRAM_NAME;
        } else {
            yylval = cb_build_alphanumeric_literal (yytext, (size_t)yyleng);
            return LITERAL;
        }
    }

    /* Check reserved word */
    resptr = lookup_reserved_word (yytext);
    if (resptr != NULL) {
        if (resptr->nodegen) {
            /* Save location for terminator checking */
            /* Misuse comment tree to mark statement */
            yylval = cb_build_comment (NULL);
        } else {
            yylval = NULL;
        }
        return resptr->token;
    }

    /* Check user function */
    if (cobc_in_repository) {
        yylval = cb_build_reference (yytext);
        return WORD;
    } else {
        if (current_program->prog_type == CB_FUNCTION_TYPE &&
            !functions_are_all &&
            !strcasecmp (yytext, current_program->orig_program_id)) {
            /* Direct recursive reference */
            yylval = cb_build_reference (yytext);
            return USER_FUNCTION_NAME;
        }
        for (l = current_program->user_spec_list; l; l = CB_CHAIN(l)) {
            x = CB_VALUE (l);
            if (!strcasecmp (yytext, CB_FUNC_PROTOTYPE (x)->name)) {
                yylval = cb_build_reference (yytext);
                return USER_FUNCTION_NAME;
            }
        }
    }

    /* Check user programs */
        program = cb_find_defined_program_by_name (yytext);
    if (program) {
        yylval = cb_build_reference (yytext);
        return PROGRAM_NAME;
    }

    /* User word */

    /* Check local, global and source global CONSTANT (78) items */

    for (p78 = top78ptr; p78; p78 = p78->globnext) {
        if (strcasecmp (yytext, p78->fld78->name) == 0) {
            if (unlikely(non_const_word)) {
                if (p78->prog == current_program) {
                    cb_error (_("A constant may not be used here - '%s'"), yytext);
                    yylval = cb_error_node;
                    return WORD;
                }
                if (p78->chk_const) {
                    p78->not_const = 1;
                }
                break;
            }
            if (p78->chk_const && p78->not_const) {
                break;
            }
            yylval = CB_VALUE (p78->fld78->values);
            return LITERAL;
        }
    }

    yylval = cb_build_reference (yytext);

    /* Special name handling */
    if (CB_WORD_COUNT (yylval) > 0 && CB_WORD_ITEMS (yylval)) {
        x = CB_VALUE (CB_WORD_ITEMS (yylval));
        if (CB_SYSTEM_NAME_P (x)) {
            return MNEMONIC_NAME;
        }
    }

    return WORD;
}
    YY_BREAK
case 110:
YY_RULE_SETUP
#line 880 "scanner.l"
{
    yylval = NULL;
    return LESS_OR_EQUAL;
}
    YY_BREAK
case 111:
YY_RULE_SETUP
#line 885 "scanner.l"
{
    yylval = NULL;
    return GREATER_OR_EQUAL;
}
    YY_BREAK
case 112:
YY_RULE_SETUP
#line 890 "scanner.l"
{
    yylval = NULL;
    return NOT_EQUAL;
}
    YY_BREAK
case 113:
YY_RULE_SETUP
#line 895 "scanner.l"
{
    yylval = NULL;
    return EXPONENTIATION;
}
    YY_BREAK
case 114:
YY_RULE_SETUP
#line 900 "scanner.l"
{
    last_token_is_dot = 1;
    yylval = NULL;
    return TOK_DOT;
}
    YY_BREAK
case 115:
YY_RULE_SETUP
#line 906 "scanner.l"
{
    yylval = NULL;
    return TOK_AMPER;
}
    YY_BREAK
case 116:
YY_RULE_SETUP
#line 911 "scanner.l"
{
    yylval = NULL;
    return TOK_COLON;
}
    YY_BREAK
case 117:
YY_RULE_SETUP
#line 916 "scanner.l"
{
    yylval = NULL;
    return TOK_EQUAL;
}
    YY_BREAK
case 118:
YY_RULE_SETUP
#line 921 "scanner.l"
{
    yylval = NULL;
    return TOK_DIV;
}
    YY_BREAK
case 119:
YY_RULE_SETUP
#line 926 "scanner.l"
{
    yylval = NULL;
    return TOK_MUL;
}
    YY_BREAK
case 120:
YY_RULE_SETUP
#line 931 "scanner.l"
{
    yylval = NULL;
    return TOK_PLUS;
}
    YY_BREAK
case 121:
YY_RULE_SETUP
#line 936 "scanner.l"
{
    yylval = NULL;
    return TOK_MINUS;
}
    YY_BREAK
case 122:
YY_RULE_SETUP
#line 941 "scanner.l"
{
    yylval = NULL;
    return TOK_LESS;
}
    YY_BREAK
case 123:
YY_RULE_SETUP
#line 946 "scanner.l"
{
    yylval = NULL;
    return TOK_GREATER;
}
    YY_BREAK
case 124:
YY_RULE_SETUP
#line 951 "scanner.l"
{
    int c;

    cb_error (_("Invalid symbol: %s - Skipping word"), yytext);
    while ((c = input ()) != EOF) {
        if (c == '\n' || c == ' ') {
            break;
        }
    }
    if (c != EOF) {
        unput (c);
    }
}
    YY_BREAK

case 125:
YY_RULE_SETUP
#line 967 "scanner.l"
{
    /* Ignore */
  }
    YY_BREAK
case 126:
YY_RULE_SETUP
#line 970 "scanner.l"
{
    BEGIN INITIAL;
    scan_picture (yytext);
    return PICTURE;
  }
    YY_BREAK


case 127:
YY_RULE_SETUP
#line 978 "scanner.l"
{
    struct cb_intrinsic_table   *cbp;
    cb_tree             l;
        cb_tree             x;

    BEGIN INITIAL;
    yylval = cb_build_reference (yytext);
    for (l = current_program->user_spec_list; l; l = CB_CHAIN(l)) {
        x = CB_VALUE (l);
        if (!strcasecmp (yytext, CB_FUNC_PROTOTYPE (x)->name)) {
            return USER_FUNCTION_NAME;
        }
    }
    cbp = lookup_intrinsic (yytext, 1, 0);
    if (cbp) {
        return (enum yytokentype)(cbp->token);
    }
    return FUNCTION_NAME;
  }
    YY_BREAK
case 128:
YY_RULE_SETUP
#line 997 "scanner.l"
{
    yylval = NULL;
    return yytext[0];
  }
    YY_BREAK

case YY_STATE_EOF(INITIAL):
case YY_STATE_EOF(DECIMAL_IS_PERIOD):
case YY_STATE_EOF(DECIMAL_IS_COMMA):
case YY_STATE_EOF(PICTURE_STATE):
case YY_STATE_EOF(FUNCTION_STATE):
#line 1003 "scanner.l"
{
    struct cb_level_78  *p78;
    struct cb_level_78  *p782;

    /* At EOF - Clear variables */
    for (p78 = lev78ptr; p78; ) {
        p782 = p78->next;
        cobc_free (p78);
        p78 = p782;
    }
    for (p78 = globlev78ptr; p78; ) {
        p782 = p78->next;
        cobc_free (p78);
        p78 = p782;
    }
    for (p78 = const78ptr; p78; ) {
        p782 = p78->next;
        cobc_free (p78);
        p78 = p782;
    }
    top78ptr = NULL;
    last_token_is_dot = 0;
    integer_is_label = 0;
    inside_bracket = 0;
    lev78ptr = NULL;
    globlev78ptr = NULL;
    cobc_force_literal = 0;
    yyterminate ();
}
    YY_BREAK
case 129:
YY_RULE_SETUP
#line 1033 "scanner.l"
YY_FATAL_ERROR( "flex scanner jammed" );
    YY_BREAK
#line 3002 "scanner.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 yyin at a new source and called
             * yylex().  If so, then we have to assure
             * consistency between YY_CURRENT_BUFFER and our
             * globals.  Here is the right place to do so, because
             * this is the first action (other than possibly a
             * back-up) that will match for the new input source.
             */
            (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
            YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
            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 ( yywrap( ) )
                    {
                    /* Note: because we've taken care in
                     * yy_get_next_buffer() to have set up
                     * yytext, we can now set up
                     * yy_c_buf_p so that if some total
                     * hoser (like flex itself) wants to
                     * call the scanner after we return the
                     * YY_NULL, it'll still work - another
                     * YY_NULL will get returned.
                     */
                    (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;

                    yy_act = YY_STATE_EOF(YY_START);
                    goto do_action;
                    }

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

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

                yy_current_state = yy_get_previous_state(  );

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

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

                yy_current_state = yy_get_previous_state(  );

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

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

Here is the call graph for this function:

int yylex_destroy

(

void

)

Definition at line 3770 of file scanner.c.

References NULL, yy_buffer_stack, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_init_globals(), yyfree(), and yypop_buffer_state().

Referenced by ylex_call_destroy().

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

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

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

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void yypop_buffer_state

(

void

)

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

The next element becomes the new top.

Definition at line 3646 of file scanner.c.

References NULL, yy_buffer_stack_top, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_delete_buffer(), yy_did_buffer_switch_on_eof, and yy_load_buffer_state().

Referenced by yylex_destroy().

{
        if (!YY_CURRENT_BUFFER)
        return;

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

void yypush_buffer_state

(

YY_BUFFER_STATE

new_buffer

)

Pushes the new state onto the stack.

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

Parameters

new_buffer

The new state.

Definition at line 3616 of file scanner.c.

References NULL, yy_buffer_stack_top, yy_c_buf_p, YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_did_buffer_switch_on_eof, yy_hold_char, yy_load_buffer_state(), yy_n_chars, and yyensure_buffer_stack().

{
        if (new_buffer == NULL)
        return;

    yyensure_buffer_stack();

    /* This block is copied from yy_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 yy_switch_to_buffer. */
    yy_load_buffer_state( );
    (yy_did_buffer_switch_on_eof) = 1;
}

Here is the call graph for this function:

void * yyrealloc	(	void *	ptr,
		yy_size_t	size
	)

Definition at line 3820 of file scanner.c.

Referenced by yy_get_next_buffer(), and yyensure_buffer_stack().

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

Here is the caller graph for this function:

void yyrestart

(

FILE *

input_file

)

Immediately switch to a different input stream.

Parameters

input_file

A readable stream.

Note

This function does not reset the start condition to INITIAL .

Definition at line 3450 of file scanner.c.

References YY_BUF_SIZE, yy_create_buffer(), YY_CURRENT_BUFFER, YY_CURRENT_BUFFER_LVALUE, yy_init_buffer(), yy_load_buffer_state(), yyensure_buffer_stack(), and yyin.

Referenced by input(), and yy_get_next_buffer().

{
    
    if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
        YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer(yyin,YY_BUF_SIZE );
    }

    yy_init_buffer(YY_CURRENT_BUFFER,input_file );
    yy_load_buffer_state( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void yyunput ( int  c, char *  buf_ptr  )

static

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

static

Definition at line 3332 of file scanner.c.

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

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

    /* undo effects of setting up yytext */
    *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;
}

static int yywrap ( void  )

static

Definition at line 1369 of file scanner.c.

Referenced by input(), and yylex().

                         {
    return 1;
}

Here is the caller graph for this function:

Variable Documentation

struct cb_level_78* const78ptr = ((void*)0)

static

Definition at line 1437 of file scanner.c.

Referenced by cb_add_78(), cb_add_const_var(), cb_reset_78(), and cb_reset_global_78().

char err_msg[COB_MINI_BUFF]

static

Definition at line 1450 of file scanner.c.

struct cb_level_78* globlev78ptr = ((void*)0)

static

Definition at line 1439 of file scanner.c.

Referenced by cb_add_78(), and cb_reset_78().

unsigned int inside_bracket = 0

static

Definition at line 1448 of file scanner.c.

unsigned int integer_is_label = 0

static

Definition at line 1447 of file scanner.c.

unsigned int last_token_is_dot = 0

static

Definition at line 1446 of file scanner.c.

struct cb_level_78* lev78ptr = ((void*)0)

static

Definition at line 1438 of file scanner.c.

Referenced by cb_add_78().

unsigned int literal_error

static

Definition at line 1449 of file scanner.c.

size_t pic1size

static

Definition at line 1444 of file scanner.c.

size_t pic2size

static

Definition at line 1445 of file scanner.c.

char* picbuff1 = ((void*)0)

static

Definition at line 1441 of file scanner.c.

char* picbuff2 = ((void*)0)

static

Definition at line 1442 of file scanner.c.

char* plexbuff = ((void*)0)

static

Definition at line 1440 of file scanner.c.

Referenced by scan_x().

size_t plexsize

static

Definition at line 1443 of file scanner.c.

const unsigned char pvalid_char[]

static

Initial value:

=
    "-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz"

Definition at line 1521 of file scanner.c.

struct cb_level_78* top78ptr = ((void*)0)

static

Definition at line 1436 of file scanner.c.

unsigned char valid_char[256]

static

Definition at line 1520 of file scanner.c.

flex_int16_t yy_accept[833]

static

Definition at line 383 of file scanner.c.

flex_int16_t yy_base[865]

static

Definition at line 523 of file scanner.c.

YY_BUFFER_STATE* yy_buffer_stack = 0

static

Stack as an array.

Definition at line 266 of file scanner.c.

Referenced by yy_init_globals(), yyensure_buffer_stack(), and yylex_destroy().

size_t yy_buffer_stack_max = 0

static

capacity of stack.

Definition at line 265 of file scanner.c.

Referenced by yy_init_globals(), and yyensure_buffer_stack().

size_t yy_buffer_stack_top = 0

static

index of top of stack.

Definition at line 264 of file scanner.c.

Referenced by yy_init_globals(), yyensure_buffer_stack(), yypop_buffer_state(), and yypush_buffer_state().

char* yy_c_buf_p = (char *) 0

static

Definition at line 289 of file scanner.c.

Referenced by input(), yy_get_next_buffer(), yy_get_previous_state(), yy_init_globals(), yy_load_buffer_state(), yy_switch_to_buffer(), yy_try_NUL_trans(), yylex(), yypush_buffer_state(), and yyunput().

flex_int16_t yy_chk[2719]

static

Definition at line 1024 of file scanner.c.

flex_int16_t yy_def[865]

static

Definition at line 622 of file scanner.c.

int yy_did_buffer_switch_on_eof

static

Definition at line 296 of file scanner.c.

Referenced by input(), yy_switch_to_buffer(), yylex(), yypop_buffer_state(), and yypush_buffer_state().

flex_int32_t yy_ec[256]

static

Definition at line 479 of file scanner.c.

int yy_flex_debug = 0

Definition at line 1331 of file scanner.c.

char yy_hold_char

static

Definition at line 284 of file scanner.c.

Referenced by input(), yy_load_buffer_state(), yy_switch_to_buffer(), yylex(), yypush_buffer_state(), and yyunput().

int yy_init = 0

static

Definition at line 290 of file scanner.c.

Referenced by yy_init_globals(), and yylex().

char* yy_last_accepting_cpos

static

Definition at line 1328 of file scanner.c.

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

yy_state_type yy_last_accepting_state

static

Definition at line 1327 of file scanner.c.

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

flex_int32_t yy_meta[75]

static

Initial value:

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

Definition at line 511 of file scanner.c.

yy_size_t yy_n_chars

static

Definition at line 285 of file scanner.c.

Referenced by input(), yy_get_next_buffer(), yy_load_buffer_state(), yy_switch_to_buffer(), yylex(), yypush_buffer_state(), and yyunput().

flex_int16_t yy_nxt[2719]

static

Definition at line 721 of file scanner.c.

int yy_start = 0

static

Definition at line 291 of file scanner.c.

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

FILE* yyin = (FILE *) 0

Definition at line 348 of file scanner.c.

Referenced by input(), yy_get_next_buffer(), yy_init_globals(), yy_load_buffer_state(), yylex(), and yyrestart().

yy_size_t yyleng

Definition at line 286 of file scanner.c.

Referenced by yylex().

int yylineno = 1

Definition at line 354 of file scanner.c.

FILE * yyout = (FILE *) 0

Definition at line 348 of file scanner.c.

Referenced by yy_init_globals(), and yylex().

char* yytext

Definition at line 1340 of file scanner.c.