cobc.c File Reference

#include "config.h"
#include "defaults.h"
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdarg.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include "tarstamp.h"
#include "cobc.h"
#include "tree.h"
#include "lib/gettext.h"
#include "libcob.h"
#include "libcob/cobgetopt.h"
#include "libcob/exception.def"
#include "flag.def"
#include "warning.def"

Include dependency graph for cobc.c:

Go to the source code of this file.

Data Structures
struct	strcache

Macros
#define	CB_LEVEL_PREPROCESS   1
#define	CB_LEVEL_TRANSLATE   2
#define	CB_LEVEL_COMPILE   3
#define	CB_LEVEL_ASSEMBLE   4
#define	CB_LEVEL_MODULE   5
#define	CB_LEVEL_LIBRARY   6
#define	CB_LEVEL_EXECUTABLE   7
#define	CB_IMSG_SIZE   24
#define	CB_IVAL_SIZE   (74 - CB_IMSG_SIZE - 4)
#define	COBC_ADD_STR(v, x, y, z)   cobc_add_str (&v, &v##_size, x, y, z);
#define	COBC_INV_PAR   _("Invalid %s parameter")
#define	OC_C_VERSION_PRF   ""
#define	OC_C_VERSION   "unknown"
#define	CB_TEXT_LIST_ADD(y, z)   y = cb_text_list_add (y, z)
#define	CB_TEXT_LIST_CHK(y, z)   y = cb_text_list_chk (y, z)
#define	CB_COPT_1   " -O"
#define	CB_COPT_2   " -O2"
#define	CB_COPT_S   " -Os"
#define	COB_EXCEPTION(code, tag, name, critical)   {name, 0x##code, 0},
#define	CB_FLAG(var, pdok, name, doc)   int var = 0;
#define	CB_FLAG_RQ(var, pdok, name, def, opt, doc)   int var = def;
#define	CB_FLAG_NQ(pdok, name, opt, doc)
#define	CB_WARNDEF(var, name, doc)   int var = 0;
#define	CB_NOWARNDEF(var, name, doc)   int var = 0;
#define	COB_NUM_CSYNS   sizeof(cob_csyns) / sizeof(char *)
#define	CB_NO_ARG   no_argument
#define	CB_RQ_ARG   required_argument
#define	CB_OP_ARG   optional_argument
#define	CB_FLAG(var, pdok, name, doc)
#define	CB_FLAG_RQ(var, pdok, name, def, opt, doc)   {"f"name, CB_RQ_ARG, NULL, opt},
#define	CB_FLAG_NQ(pdok, name, opt, doc)   {"f"name, CB_RQ_ARG, NULL, opt},
#define	CB_WARNDEF(var, name, doc)
#define	CB_NOWARNDEF(var, name, doc)
#define	CB_WARNDEF(var, name, doc)   cobc_print_warn (name, doc, 1);
#define	CB_NOWARNDEF(var, name, doc)   cobc_print_warn (name, doc, 0);
#define	CB_FLAG(var, pdok, name, doc)   cobc_print_flag (name, doc, pdok, 0);
#define	CB_FLAG_RQ(var, pdok, name, def, opt, doc)   cobc_print_flag (name, doc, pdok, 1);
#define	CB_FLAG_NQ(pdok, name, opt, doc)   cobc_print_flag (name, doc, pdok, 1);
#define	CB_WARNDEF(var, name, doc)   var = 0;
#define	CB_NOWARNDEF(var, name, doc)   var = 0;
#define	CB_WARNDEF(var, name, doc)   var = 1;
#define	CB_NOWARNDEF(var, name, doc)
#define	CB_WARNDEF(var, name, doc)   var = 1;
#define	CB_NOWARNDEF(var, name, doc)   var = 1;

Functions
static DECLNORET void COB_A_NORETURN	cobc_abort_terminate (void)
static void	cobc_free_mem (void)
static const char *	cobc_enum_explain (const enum cb_tag tag)
void	cobc_abort_pr (const char *fmt,...)
void	cobc_too_many_errors (void)
void	cobc_abort (const char *filename, const int linenum)
void	cobc_dumb_abort (const char *filename, const int linenum)
void	cobc_tree_cast_error (const cb_tree x, const char *filename, const int linenum, const enum cb_tag tagnum)
void *	cobc_malloc (const size_t size)
void	cobc_free (void *mptr)
void *	cobc_strdup (const char *dupstr)
void *	cobc_realloc (void *prevptr, const size_t size)
void *	cobc_main_malloc (const size_t size)
void *	cobc_main_strdup (const char *dupstr)
void *	cobc_main_realloc (void *prevptr, const size_t size)
void	cobc_main_free (void *prevptr)
void *	cobc_parse_malloc (const size_t size)
void *	cobc_parse_strdup (const char *dupstr)
void *	cobc_parse_realloc (void *prevptr, const size_t size)
void	cobc_parse_free (void *prevptr)
void *	cobc_plex_malloc (const size_t size)
void *	cobc_plex_strdup (const char *dupstr)
void *	cobc_check_string (const char *dupstr)
static struct cb_text_list *	cb_text_list_add (struct cb_text_list *list, const char *text)
static struct cb_text_list *	cb_text_list_chk (struct cb_text_list *list, const char *text)
static unsigned int	cobc_set_value (struct cb_define_struct *p, const char *value)
static int	cobc_bcompare (const void *p1, const void *p2)
static void	cobc_error_name (const char *name, const unsigned int source, const unsigned int reason)
size_t	cobc_check_valid_name (const char *name, const unsigned int prechk)
static void	cobc_chk_buff_size (const size_t bufflen)
static int	cobc_deciph_optarg (const char *p, const int allow_quote)
static DECLNORET void COB_A_NORETURN	cobc_err_exit (const char *fmt,...)
static struct cb_define_struct *	cb_define_list_add (struct cb_define_struct *list, const char *text)
static char *	cobc_stradd_dup (const char *str1, const char *str2)
static char *	cobc_getenv (const char *env)
static void	cobc_add_str (char **var, size_t *cursize, const char *s1, const char *s2, const char *s3)
static void	cobc_check_action (const char *name)
static void	cobc_clean_up (const int status)
static DECLNORET void COB_A_NORETURN	cobc_terminate (const char *str)
static void	cobc_print_version (void)
static void	cobc_cmd_print (const char *cmd)
static void	cobc_var_print (const char *msg, const char *val, const unsigned int env)
static void	cobc_print_info (void)
static void	cobc_print_warn (const char *name, const char *doc, const int wall)
static void	cobc_print_flag (const char *name, const char *doc, const int pdok, const int exten)
static void	cobc_print_usage (char *prog)
static void	cobc_options_error_nonfinal (void)
static void	cobc_options_error_build (void)
static void	cobc_deciph_funcs (const char *opt)
static int	process_command_line (const int argc, char **argv)
static struct cb_program *	program_list_reverse (struct cb_program *p)
static void	process_env_copy_path (const char *p)
static char *	file_basename (const char *filename)
static const char *	file_extension (const char *filename)
static struct filename *	process_filename (const char *filename)
static int	process_run (const char *name)
	-j run job after build More...
static int	process (const char *cmd)
static int	preprocess (struct filename *fn)
static int	process_translate (struct filename *fn)
static int	process_compile (struct filename *fn)
static int	process_assemble (struct filename *fn)
static int	process_module_direct (struct filename *fn)
static int	process_module (struct filename *fn)
static int	process_library (struct filename *l)
static int	process_link (struct filename *l)
int	main (int argc, char **argv)

Variables
const char *	cb_source_file = ((void*)0)
char *	cb_oc_build_stamp = ((void*)0)
const char *	demangle_name = ((void*)0)
const char *	cb_storage_file_name = ((void*)0)
struct cb_text_list *	cb_include_list = ((void*)0)
struct cb_text_list *	cb_intrinsic_list = ((void*)0)
struct cb_text_list *	cb_extension_list = ((void*)0)
struct cb_text_list *	cb_static_call_list = ((void*)0)
struct cb_text_list *	cb_early_exit_list = ((void*)0)
char **	cb_saveargv = ((void*)0)
const char *	cob_config_dir = ((void*)0)
FILE *	cb_storage_file = ((void*)0)
FILE *	cb_listing_file = ((void*)0)
int	cb_source_format = 0
int	cb_id = 0
int	cb_attr_id = 0
int	cb_literal_id = 0
int	cb_field_id = 0
int	cobc_flag_main = 0
int	cb_flag_main = 0
int	cobc_wants_debug = 0
int	cb_flag_functions_all = 0
int	cobc_seen_stdin = 0
int	errorcount = 0
int	warningcount = 0
int	exit_option = 0
int	warningopt = 0
int	no_physical_cancel = 0
int	cb_source_line = 0
int	cb_saveargc = 0
unsigned int	cobc_gen_listing = 0
cob_u32_t	optimize_defs [COB_OPTIM_MAX] = { 0 }
struct cb_exception	cb_exception_table []
static struct cb_define_struct *	cb_define_list = ((void*)0)
static struct cobc_mem_struct *	cobc_mainmem_base = ((void*)0)
static struct cobc_mem_struct *	cobc_parsemem_base = ((void*)0)
static struct cobc_mem_struct *	cobc_plexmem_base = ((void*)0)
static const char *	cobc_cc
static char *	cobc_cflags
static char *	cobc_libs
static char *	cobc_lib_paths
static char *	cobc_include
static char *	cobc_ldflags
static size_t	cobc_cflags_size
static size_t	cobc_libs_size
static size_t	cobc_lib_paths_size
static size_t	cobc_include_size
static size_t	cobc_ldflags_size
static size_t	cobc_cc_len
static size_t	cobc_cflags_len
static size_t	cobc_libs_len
static size_t	cobc_lib_paths_len
static size_t	cobc_include_len
static size_t	cobc_ldflags_len
static size_t	cobc_export_dyn_len
static size_t	cobc_shared_opt_len
static size_t	cobc_pic_flags_len
static char *	save_temps_dir
static struct strcache *	base_string
static char *	cobc_list_dir
static char *	cobc_list_file
static char *	output_name
static char *	cobc_buffer
static char *	cobc_objects_buffer
static char *	output_name_buff
static char *	basename_buffer
static size_t	cobc_objects_len
static size_t	basename_len
static size_t	cobc_buffer_size
static struct filename *	file_list
static unsigned int	cb_compile_level = 0
static int	iargs
static size_t	wants_nonfinal = 0
static size_t	cobc_flag_module = 0
static size_t	cobc_flag_library = 0
static size_t	cobc_flag_run = 0
static size_t	save_temps = 0
static size_t	save_all_src = 0
static size_t	save_c_src = 0
static size_t	verbose_output = 0
static size_t	cob_optimize = 0
static size_t	strip_output = 0
static size_t	gflag_set = 0
static size_t	aflag_set = 0
static const char *const	cob_csyns []
static const char	short_options [] = "hVivECScbmxjdFOPgwo:I:L:l:D:K:k:"
static const struct option	long_options []
int	yydebug

Macro Definition Documentation

#define CB_COPT_1   " -O"

Definition at line 138 of file cobc.c.

Referenced by main(), and process_command_line().

#define CB_COPT_2   " -O2"

Definition at line 139 of file cobc.c.

Referenced by process_command_line().

#define CB_COPT_S   " -Os"

Definition at line 140 of file cobc.c.

Referenced by process_command_line().

#define CB_FLAG	(		var,
			pdok,
			name,
			doc
	)		int var = 0;

Definition at line 196 of file cobc.c.

#define CB_FLAG	(		var,
			pdok,
			name,
			doc
	)

Value:

{"f"name,       CB_NO_ARG, &var, 1},    \
    {"fno-"name,        CB_NO_ARG, &var, 0},

Definition at line 196 of file cobc.c.

#define CB_FLAG	(		var,
			pdok,
			name,
			doc
	)		cobc_print_flag (name, doc, pdok, 0);

Definition at line 196 of file cobc.c.

#define CB_FLAG_NQ	(		pdok,
			name,
			opt,
			doc
	)

Definition at line 198 of file cobc.c.

#define CB_FLAG_NQ	(		pdok,
			name,
			opt,
			doc
	)		{"f"name, CB_RQ_ARG, NULL, opt},

Definition at line 198 of file cobc.c.

#define CB_FLAG_NQ	(		pdok,
			name,
			opt,
			doc
	)		cobc_print_flag (name, doc, pdok, 1);

Definition at line 198 of file cobc.c.

#define CB_FLAG_RQ	(		var,
			pdok,
			name,
			def,
			opt,
			doc
	)		int var = def;

Definition at line 197 of file cobc.c.

#define CB_FLAG_RQ	(		var,
			pdok,
			name,
			def,
			opt,
			doc
	)		{"f"name, CB_RQ_ARG, NULL, opt},

Definition at line 197 of file cobc.c.

#define CB_FLAG_RQ	(		var,
			pdok,
			name,
			def,
			opt,
			doc
	)		cobc_print_flag (name, doc, pdok, 1);

Definition at line 197 of file cobc.c.

#define CB_IMSG_SIZE   24

Definition at line 80 of file cobc.c.

Referenced by cobc_var_print().

#define CB_IVAL_SIZE   (74 - CB_IMSG_SIZE - 4)

Definition at line 81 of file cobc.c.

Referenced by cobc_var_print().

#define CB_LEVEL_ASSEMBLE   4

Definition at line 74 of file cobc.c.

Referenced by cobc_clean_up(), main(), process_assemble(), process_command_line(), and process_filename().

#define CB_LEVEL_COMPILE   3

Definition at line 73 of file cobc.c.

Referenced by main(), and process_command_line().

#define CB_LEVEL_EXECUTABLE   7

Definition at line 77 of file cobc.c.

Referenced by main().

#define CB_LEVEL_LIBRARY   6

Definition at line 76 of file cobc.c.

Referenced by main(), process_assemble(), and process_run().

#define CB_LEVEL_MODULE   5

Definition at line 75 of file cobc.c.

Referenced by main(), process_assemble(), and process_run().

#define CB_LEVEL_PREPROCESS   1

Definition at line 71 of file cobc.c.

Referenced by cobc_clean_up(), main(), process_command_line(), and process_filename().

#define CB_LEVEL_TRANSLATE   2

Definition at line 72 of file cobc.c.

Referenced by cobc_clean_up(), main(), process_command_line(), and process_filename().

#define CB_NO_ARG   no_argument

Definition at line 392 of file cobc.c.

#define CB_NOWARNDEF	(		var,
			name,
			doc
	)		int var = 0;

Definition at line 207 of file cobc.c.

#define CB_NOWARNDEF	(		var,
			name,
			doc
	)

Value:

{"W"name,       CB_NO_ARG, &var, 1},    \
    {"Wno-"name,        CB_NO_ARG, &var, 0},

Definition at line 207 of file cobc.c.

#define CB_NOWARNDEF	(		var,
			name,
			doc
	)		cobc_print_warn (name, doc, 0);

Definition at line 207 of file cobc.c.

#define CB_NOWARNDEF	(		var,
			name,
			doc
	)		var = 0;

Definition at line 207 of file cobc.c.

#define CB_NOWARNDEF	(		var,
			name,
			doc
	)

Definition at line 207 of file cobc.c.

#define CB_NOWARNDEF	(		var,
			name,
			doc
	)		var = 1;

Definition at line 207 of file cobc.c.

#define CB_OP_ARG   optional_argument

Definition at line 394 of file cobc.c.

#define CB_RQ_ARG   required_argument

Definition at line 393 of file cobc.c.

#define CB_TEXT_LIST_ADD	(		y,
			z
	)		y = cb_text_list_add (y, z)

Definition at line 110 of file cobc.c.

Referenced by cobc_deciph_funcs(), main(), and process_command_line().

#define CB_TEXT_LIST_CHK	(		y,
			z
	)		y = cb_text_list_chk (y, z)

Definition at line 111 of file cobc.c.

Referenced by main(), and process_env_copy_path().

#define CB_WARNDEF	(		var,
			name,
			doc
	)		int var = 0;

Definition at line 206 of file cobc.c.

#define CB_WARNDEF	(		var,
			name,
			doc
	)

Value:

{"W"name,       CB_NO_ARG, &var, 1},    \
    {"Wno-"name,        CB_NO_ARG, &var, 0},

Definition at line 206 of file cobc.c.

#define CB_WARNDEF	(		var,
			name,
			doc
	)		cobc_print_warn (name, doc, 1);

Definition at line 206 of file cobc.c.

#define CB_WARNDEF	(		var,
			name,
			doc
	)		var = 0;

Definition at line 206 of file cobc.c.

#define CB_WARNDEF	(		var,
			name,
			doc
	)		var = 1;

Definition at line 206 of file cobc.c.

#define CB_WARNDEF	(		var,
			name,
			doc
	)		var = 1;

Definition at line 206 of file cobc.c.

#define COB_EXCEPTION	(		code,
			tag,
			name,
			critical
	)		{name, 0x##code, 0},

Definition at line 185 of file cobc.c.

#define COB_NUM_CSYNS   sizeof(cob_csyns) / sizeof(char *)

Definition at line 388 of file cobc.c.

Referenced by cobc_check_valid_name().

#define COBC_ADD_STR	(		v,
			x,
			y,
			z
	)		cobc_add_str (&v, &v##_size, x, y, z);

Definition at line 83 of file cobc.c.

Referenced by main(), and process_command_line().

#define COBC_INV_PAR   _("Invalid %s parameter")

Definition at line 84 of file cobc.c.

Referenced by process_command_line().

#define OC_C_VERSION   "unknown"

Definition at line 107 of file cobc.c.

Referenced by cobc_print_version().

#define OC_C_VERSION_PRF   ""

Definition at line 106 of file cobc.c.

Referenced by cobc_print_version().

Function Documentation

static struct cb_define_struct* cb_define_list_add ( struct cb_define_struct *  list, const char *  text  )

static

Definition at line 1245 of file cobc.c.

References _, cobc_abort_pr(), cobc_check_string(), cobc_free(), cobc_main_malloc(), cobc_set_value(), cobc_strdup(), cb_define_struct::deftype, cb_define_struct::last, cb_define_struct::name, cb_define_struct::next, NULL, and PLEX_DEF_NONE.

Referenced by process_command_line().

{
    struct cb_define_struct *p;
    struct cb_define_struct *l;
    char            *s;
    char            *x;

    x = cobc_strdup (text);
    s = strtok (x, "=");

    /* Check duplicate */
    for (l = list; l; l = l->next) {
        if (!strcasecmp (s, l->name)) {
            cobc_abort_pr (_("Duplicate define '%s' - Ignoring"), s);
            cobc_free (x);
            return list;
        }
    }

    p = cobc_main_malloc (sizeof (struct cb_define_struct));
    p->next = NULL;
    p->name = cobc_check_string (s);
    p->deftype = PLEX_DEF_NONE;
    s = strtok (NULL, "");
    if (cobc_set_value (p, s)) {
        cobc_free (x);
        return NULL;
    }

    cobc_free (x);

    if (!list) {
        p->last = p;
        return p;
    }
    list->last->next = p;
    list->last = p;
    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct cb_text_list* cb_text_list_add ( struct cb_text_list *  list, const char *  text  )

static

Definition at line 974 of file cobc.c.

References cobc_main_malloc(), cobc_main_strdup(), cb_text_list::last, cb_text_list::next, and cb_text_list::text.

Referenced by cb_text_list_chk().

{
    struct cb_text_list *p;

    p = cobc_main_malloc (sizeof (struct cb_text_list));
    p->text = cobc_main_strdup (text);
    if (!list) {
        p->last = p;
        return p;
    }
    list->last->next = p;
    list->last = p;
    return list;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct cb_text_list* cb_text_list_chk ( struct cb_text_list *  list, const char *  text  )

static

Definition at line 990 of file cobc.c.

References cb_text_list_add(), cb_text_list::next, and cb_text_list::text.

{
    struct cb_text_list *p;

    for (p = list; p; p = p->next) {
        if (!strcmp (text, p->text)) {
            return list;
        }
    }
    return cb_text_list_add (list, text);
}

Here is the call graph for this function:

void cobc_abort	(	const char *	filename,
		const int	linenum
	)

Definition at line 606 of file cobc.c.

References _, cobc_abort_pr(), and cobc_abort_terminate().

Referenced by cobc_dumb_abort().

{
    cobc_abort_pr (_("%s:%d Internal compiler error"), filename, linenum);
    cobc_abort_terminate ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cobc_abort_pr	(	const char *	fmt,
			...
	)

Definition at line 587 of file cobc.c.

Referenced by cb_build_binary_op(), cb_define_list_add(), cb_field_size(), cb_get_int(), cb_get_long_long(), cb_tree_category(), cb_tree_type(), cob_gen_optim(), cobc_abort(), cobc_abort_terminate(), cobc_check_action(), cobc_check_string(), cobc_error_name(), cobc_free(), cobc_main_free(), cobc_main_malloc(), cobc_main_realloc(), cobc_main_strdup(), cobc_malloc(), cobc_parse_free(), cobc_parse_malloc(), cobc_parse_realloc(), cobc_parse_strdup(), cobc_plex_malloc(), cobc_plex_strdup(), cobc_realloc(), cobc_set_value(), cobc_stradd_dup(), cobc_strdup(), cobc_too_many_errors(), cobc_tree_cast_error(), compute_size(), decimal_alloc(), decimal_compute(), decimal_expand(), file_basename(), initialize_type(), output_attr(), output_base(), output_call_by_value_args(), output_cond(), output_data(), output_funcall(), output_initialize_one(), output_integer(), output_internal_function(), output_long_integer(), output_param(), output_search_whens(), output_size(), output_stmt(), plex_action_directive(), process_command_line(), process_filename(), process_library(), process_link(), and validate_move().

{
    va_list     ap;

    va_start (ap, fmt);
    vfprintf (stderr, fmt, ap);
    va_end (ap);
    putc ('\n', stderr);
    fflush (stderr);
}

static DECLNORET void COB_A_NORETURN cobc_abort_terminate ( void  )

static

Definition at line 1486 of file cobc.c.

References _, cb_source_file, cb_source_line, cobc_abort_pr(), and cobc_clean_up().

Referenced by cobc_abort(), cobc_check_string(), cobc_free(), cobc_main_free(), cobc_main_malloc(), cobc_main_realloc(), cobc_main_strdup(), cobc_malloc(), cobc_parse_free(), cobc_parse_malloc(), cobc_parse_realloc(), cobc_parse_strdup(), cobc_plex_malloc(), cobc_plex_strdup(), cobc_realloc(), cobc_stradd_dup(), cobc_strdup(), cobc_too_many_errors(), and cobc_tree_cast_error().

{
    if (cb_source_file) {
        cobc_abort_pr (_("Aborting compile of %s at line %d"),
             cb_source_file, cb_source_line);
    }
    cobc_clean_up (99);
    exit (99);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_add_str ( char **  var, size_t *  cursize, const char *  s1, const char *  s2, const char *  s3  )

static

Definition at line 1318 of file cobc.c.

References _, cobc_err_exit(), and cobc_main_realloc().

{
    size_t  calcsize;

    if (!s1) {
        return;
    }

    calcsize = strlen (*var);
    calcsize += strlen (s1);
    if (s2) {
        calcsize += strlen (s2);
    }
    if (s3) {
        calcsize += strlen (s3);
    }
    if (calcsize >= 131072) {
        /* Arbitrary limit */
        cobc_err_exit (_("Parameter buffer size exceeded"));
    }
    if (calcsize >= *cursize) {
        while (*cursize <= calcsize) {
            *cursize *= 2;
        }
        *var = cobc_main_realloc (*var, *cursize);
    }
    strcat (*var, s1);
    if (s2) {
        strcat (*var, s2);
    }
    if (s3) {
        strcat (*var, s3);
    }
}

Here is the call graph for this function:

static int cobc_bcompare ( const void *  p1, const void *  p2  )

static

Definition at line 1086 of file cobc.c.

Referenced by cobc_check_valid_name().

{
    const void  **tptr;

    tptr = (const void **)p2;
    return strcmp (p1, *tptr);
}

Here is the caller graph for this function:

static void cobc_check_action ( const char *  name )

static

Definition at line 1355 of file cobc.c.

References _, COB_MEDIUM_BUFF, COB_MEDIUM_MAX, cobc_abort_pr(), F_OK, save_temps, save_temps_dir, and SLASH_STR.

Referenced by cobc_clean_up(), process_library(), process_link(), process_module(), and process_module_direct().

{
    if (!name || access (name, F_OK)) {
        return;
    }
    if (!save_temps) {
        (void)unlink (name);
        return;
    }
    if (save_temps_dir) {
        char    temp_buff[COB_MEDIUM_BUFF];

        snprintf (temp_buff, (size_t)COB_MEDIUM_MAX,
              "%s%s%s", save_temps_dir, SLASH_STR, name);
        temp_buff[COB_MEDIUM_MAX] = 0;
        /* Remove possible target file - ignore return */
        (void)unlink (temp_buff);
        if (rename (name, temp_buff)) {
            cobc_abort_pr (_("Warning - Could not move temporary file to %s"),
                    temp_buff);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_check_string

(

const char *

dupstr

)

Definition at line 951 of file cobc.c.

References _, base_string, cobc_abort_pr(), cobc_abort_terminate(), cobc_main_malloc(), cobc_main_strdup(), strcache::next, unlikely, and strcache::val.

Referenced by cb_build_binary_picture(), cb_build_picture(), cb_define_list_add(), and cb_encode_program_id().

{
    struct strcache *s;

#ifdef  COB_TREE_DEBUG
    if (unlikely(!dupstr)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_check_string");
        cobc_abort_terminate ();
    }
#endif
    for (s = base_string; s; s = s->next) {
        if (!strcmp (dupstr, (const char *)s->val)) {
            return s->val;
        }
    }
    s = cobc_main_malloc (sizeof(struct strcache));
    s->next = base_string;
    s->val = cobc_main_strdup (dupstr);
    base_string = s;
    return s->val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

size_t cobc_check_valid_name	(	const char *	name,
		const unsigned int	prechk
	)

Definition at line 1142 of file cobc.c.

References cob_csyns, COB_NUM_CSYNS, cobc_bcompare(), and cobc_error_name().

Referenced by cb_build_program_id(), process_filename(), and yyparse().

{
    const char  *p;
    size_t      len;

    for (p = name, len = 0; *p; p++, len++) {
        if (*p == '/' || *p == '\\') {
            cobc_error_name (name, prechk, 5U);
            return 1;
        }
    }
    if (len < 1) {
        cobc_error_name (name, prechk, 1U);
        return 1;
    }
    if (!cb_relaxed_syntax_check && len > 31) {
        cobc_error_name (name, prechk, 1U);
        return 1;
    }
    if (*name == '_' || *name == ' ') {
        cobc_error_name (name, prechk, 2U);
        return 1;
    }
    if (prechk && len > 3 &&
        (!memcmp (name, "cob_", (size_t)4) ||
         !memcmp (name, "COB_", (size_t)4))) {
        cobc_error_name (name, prechk, 3U);
        return 1;
    }
    if (bsearch (name, cob_csyns, COB_NUM_CSYNS,
             sizeof (char *), cobc_bcompare)) {
        cobc_error_name (name, prechk, 4U);
        return 1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_chk_buff_size ( const size_t  bufflen )

static

Definition at line 1182 of file cobc.c.

References cobc_buffer, cobc_buffer_size, and cobc_main_realloc().

Referenced by process_assemble(), process_compile(), process_library(), process_link(), process_module(), and process_module_direct().

{
    if (bufflen >= cobc_buffer_size) {
        cobc_buffer_size = bufflen + 32;
        cobc_buffer = cobc_main_realloc (cobc_buffer, cobc_buffer_size);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_clean_up ( const int  status )

static

Definition at line 1380 of file cobc.c.

References cb_compile_level, CB_LEVEL_ASSEMBLE, CB_LEVEL_PREPROCESS, CB_LEVEL_TRANSLATE, cb_listing_file, cb_storage_file, cob_u32_t, cobc_buffer, cobc_buffer_size, cobc_check_action(), cobc_free_mem(), F_OK, local_filename::local_fp, local_filename::local_name, filename::localfile, filename::need_assemble, filename::need_preprocess, filename::need_translate, local_filename::next, filename::next, NULL, filename::object, ppin, ppout, filename::preprocess, save_all_src, save_c_src, save_temps, filename::translate, filename::trstorage, unlikely, yyin, and yyout.

Referenced by cobc_abort_terminate(), cobc_terminate(), and main().

{
    struct filename     *fn;
    struct local_filename   *lf;
    cob_u32_t       i;

    if (cb_listing_file) {
        fclose (cb_listing_file);
        cb_listing_file = NULL;
    }
    if (cb_storage_file) {
        fclose (cb_storage_file);
        cb_storage_file = NULL;
    }
    if (ppin) {
        fclose (ppin);
        ppin = NULL;
    }

    if (ppout) {
        fclose (ppout);
        ppout = NULL;
    }
    if (yyin) {
        fclose (yyin);
        yyin = NULL;
    }

    if (yyout) {
        fclose (yyout);
        yyout = NULL;
    }

    for (fn = file_list; fn; fn = fn->next) {
        for (lf = fn->localfile; lf; lf = lf->next) {
            if (unlikely(lf->local_fp)) {
                fclose (lf->local_fp);
                lf->local_fp = NULL;
            }
        }
        if (fn->need_assemble &&
            (status || cb_compile_level > CB_LEVEL_ASSEMBLE ||
             (cb_compile_level == CB_LEVEL_ASSEMBLE && save_temps))) {
            cobc_check_action (fn->object);
        }
        if (save_all_src) {
            continue;
        }
        if (fn->need_preprocess &&
            (status || cb_compile_level > CB_LEVEL_PREPROCESS ||
             (cb_compile_level == CB_LEVEL_PREPROCESS && save_temps))) {
            cobc_check_action (fn->preprocess);
        }
        if (save_c_src) {
            continue;
        }
        if (fn->need_translate &&
            (status || cb_compile_level > CB_LEVEL_TRANSLATE ||
             (cb_compile_level == CB_LEVEL_TRANSLATE && save_temps))) {
            cobc_check_action (fn->translate);
            cobc_check_action (fn->trstorage);
            if (fn->localfile) {
                for (lf = fn->localfile; lf; lf = lf->next) {
                    cobc_check_action (lf->local_name);
                }
            } else if (fn->translate) {
                /* If we get syntax errors, we do not
                   know the number of local include files */
                snprintf (cobc_buffer, cobc_buffer_size,
                     "%s.l.h", fn->translate);
                cobc_buffer[cobc_buffer_size] = 0;
                for (i = 0; i < 30U; ++i) {
                    if (i) {
                        snprintf (cobc_buffer, cobc_buffer_size,
                             "%s.l%u.h", fn->translate, i);
                        cobc_buffer[cobc_buffer_size] = 0;
                    }
                    if (!access (cobc_buffer, F_OK)) {
                        unlink (cobc_buffer);
                    } else if (i) {
                        break;
                    }
                }
            }
        }
    }
    cobc_free_mem ();
    file_list = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_cmd_print ( const char *  cmd )

static

Definition at line 1558 of file cobc.c.

References _, cobc_free(), cobc_strdup(), and NULL.

Referenced by preprocess(), process(), and process_run().

{
    char    *p;
    char    *token;
    size_t  n;
    size_t  toklen;

    fputs (_("Executing:"), stderr);
    /* Check if it fits in 80 characters */
    if (strlen (cmd) < 64) {
        fprintf (stderr, "\t%s\n", (char *)cmd);
        fflush (stderr);
        return;
    }
    putc ('\t', stderr);
    p = cobc_strdup (cmd);
    n = 0;
    token = strtok (p, " ");
    for (; token; token = strtok (NULL, " ")) {
        toklen = strlen (token) + 1;
        if ((n + toklen) > 63) {
            fprintf(stderr, "\n\t\t");
            n = 0;
        }
        fprintf (stderr, "%s%s", (n ? " " : ""), token);
        n += toklen;
    }
    cobc_free (p);
    putc ('\n', stderr);
    fflush (stderr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_deciph_funcs ( const char *  opt )

static

Definition at line 1888 of file cobc.c.

References _, cb_flag_functions_all, CB_TEXT_LIST_ADD, cobc_err_exit(), cobc_free(), cobc_strdup(), lookup_intrinsic(), and NULL.

Referenced by process_command_line().

{
    char    *p;
    char    *q;

    if (!strcasecmp (opt, "ALL")) {
        cb_flag_functions_all = 1;
        return;
    }

    p = cobc_strdup (opt);
    q = strtok (p, ",");
    while (q) {
        if (!lookup_intrinsic (q, 0, 1)) {
            cobc_err_exit (_("'%s' is not an intrinsic function"), q);
        }
        CB_TEXT_LIST_ADD (cb_intrinsic_list, q);
        q = strtok (NULL, ",");
    }
    cobc_free (p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int cobc_deciph_optarg ( const char *  p, const int  allow_quote  )

static

Definition at line 1191 of file cobc.c.

Referenced by process_command_line().

{
    const unsigned char *s;
    size_t          len;
    size_t          i;
    int         n;

    len = strlen (p);
    if (!len) {
        return -1;
    }
    s = (const unsigned char *)p;
    if (allow_quote) {
        if (*s == '"' || *s == '\'') {
            if (len != 3 || *(s + 2) != *s) {
                return -1;
            }
            return (int)(*(s + 1));
        }
        if (*s < '0' || *s > '9') {
            if (len != 1) {
                return -1;
            }
            return (int)*s;
        }
    }
    n = 0;
    for (i = 0; i < len; ++i) {
        if (s[i] < '0' || s[i] > '9') {
            return -1;
        }
        n *= 10;
        n += (s[i] & 0x0F);
    }
    return n;
}

Here is the caller graph for this function:

void cobc_dumb_abort	(	const char *	filename,
		const int	linenum
	)

Definition at line 613 of file cobc.c.

References cobc_abort().

{
    cobc_abort (filename, linenum);
}

Here is the call graph for this function:

static const char* cobc_enum_explain ( const enum cb_tag  tag )

static

Definition at line 503 of file cobc.c.

References CB_TAG_ALPHABET_NAME, CB_TAG_ALTER, CB_TAG_ASSIGN, CB_TAG_BINARY_OP, CB_TAG_CALL, CB_TAG_CANCEL, CB_TAG_CAST, CB_TAG_CLASS_NAME, CB_TAG_CONST, CB_TAG_CONTINUE, CB_TAG_DEBUG, CB_TAG_DEBUG_CALL, CB_TAG_DECIMAL, CB_TAG_DIRECT, CB_TAG_FIELD, CB_TAG_FILE, CB_TAG_FUNCALL, CB_TAG_GOTO, CB_TAG_IF, CB_TAG_INITIALIZE, CB_TAG_INTEGER, CB_TAG_INTRINSIC, CB_TAG_LABEL, CB_TAG_LIST, CB_TAG_LITERAL, CB_TAG_LOCALE_NAME, CB_TAG_PERFORM, CB_TAG_PERFORM_VARYING, CB_TAG_PICTURE, CB_TAG_REFERENCE, CB_TAG_REPORT, CB_TAG_SEARCH, CB_TAG_SET_ATTR, CB_TAG_STATEMENT, CB_TAG_STRING, and CB_TAG_SYSTEM_NAME.

Referenced by cobc_tree_cast_error().

{
    switch (tag) {
    case CB_TAG_CONST:
        return "CONSTANT";
    case CB_TAG_INTEGER:
        return "INTEGER";
    case CB_TAG_STRING:
        return "STRING";
    case CB_TAG_ALPHABET_NAME:
        return "ALPHABET";
    case CB_TAG_CLASS_NAME:
        return "CLASS";
    case CB_TAG_LOCALE_NAME:
        return "LOCALE";
    case CB_TAG_SYSTEM_NAME:
        return "SYSTEM";
    case CB_TAG_LITERAL:
        return "LITERAL";
    case CB_TAG_DECIMAL:
        return "DECIMAL";
    case CB_TAG_FIELD:
        return "FIELD";
    case CB_TAG_FILE:
        return "FILE";
    case CB_TAG_REPORT:
        return "REPORT";
    case CB_TAG_REFERENCE:
        return "REFERENCE";
    case CB_TAG_BINARY_OP:
        return "BINARY OP";
    case CB_TAG_FUNCALL:
        return "FUNCTION CALL";
    case CB_TAG_CAST:
        return "CAST";
    case CB_TAG_INTRINSIC:
        return "INTRINSIC";
    case CB_TAG_LABEL:
        return "LABEL";
    case CB_TAG_ASSIGN:
        return "ASSIGN";
    case CB_TAG_INITIALIZE:
        return "INITIALIZE";
    case CB_TAG_SEARCH:
        return "SEARCH";
    case CB_TAG_CALL:
        return "CALL";
    case CB_TAG_GOTO:
        return "GO TO";
    case CB_TAG_IF:
        return "IF";
    case CB_TAG_PERFORM:
        return "PERFORM";
    case CB_TAG_STATEMENT:
        return "STATEMENT";
    case CB_TAG_CONTINUE:
        return "CONTINUE";
    case CB_TAG_CANCEL:
        return "CANCEL";
    case CB_TAG_ALTER:
        return "ALTER";
    case CB_TAG_SET_ATTR:
        return "SET ATTRIBUTE";
    case CB_TAG_PERFORM_VARYING:
        return "PERFORM";
    case CB_TAG_PICTURE:
        return "PICTURE";
    case CB_TAG_LIST:
        return "LIST";
    case CB_TAG_DIRECT:
        return "DIRECT";
    case CB_TAG_DEBUG:
        return "DEBUG";
    case CB_TAG_DEBUG_CALL:
        return "DEBUG CALL";
    default:
        break;
    }
    return "UNKNOWN";
}

Here is the caller graph for this function:

static DECLNORET void COB_A_NORETURN cobc_err_exit ( const char *  fmt,   ...  )

static

Definition at line 1229 of file cobc.c.

References _, and cobc_free_mem().

Referenced by cobc_add_str(), cobc_deciph_funcs(), cobc_options_error_build(), cobc_options_error_nonfinal(), main(), and process_command_line().

{
    va_list     ap;

    fputs ("cobc: ", stderr);
    fputs (_("Error: "), stderr);
    va_start (ap, fmt);
    vfprintf (stderr, fmt, ap);
    va_end (ap);
    putc ('\n', stderr);
    fflush (stderr);
    cobc_free_mem ();
    exit (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_error_name ( const char *  name, const unsigned int  source, const unsigned int  reason  )

static

Definition at line 1095 of file cobc.c.

References _, cb_error(), and cobc_abort_pr().

Referenced by cobc_check_valid_name().

{
    const char  *s;

    s = "";
    switch (reason) {
    case 1:
        s = _(" - Length is < 1 or > 31");
        break;
    case 2:
        s = _(" - Name cannot begin with space or underscore");
        break;
    case 3:
        s = _(" - Name cannot begin with 'cob_' or 'COB_'");
        break;
    case 4:
        s = _(" - Name duplicates a 'C' keyword");
        break;
    case 5:
        s = _(" - Name cannot contain a directory separator");
        break;
    default:
        break;
    }
    switch (source) {
    case 0:
        /* basename */
        cobc_abort_pr (_("Invalid file base name '%s'%s"),
                name, s);
        break;
    case 1:
        /* ENTRY */
        cb_error (_("Invalid ENTRY '%s'%s"), name, s);
        break;
    case 2:
        /* PROGRAM-ID */
        cb_error (_("Invalid PROGRAM-ID '%s'%s"), name, s);
        break;
    default:
        cobc_abort_pr (_("Unknown name error '%s'%s"),
                name, s);
        break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cobc_free

(

void *

mptr

)

Definition at line 657 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), and unlikely.

Referenced by cb_define_list_add(), cb_reset_78(), cb_reset_global_78(), clear_initial_values(), cobc_cmd_print(), cobc_deciph_funcs(), cobc_free_mem(), cobc_main_free(), cobc_main_realloc(), cobc_parse_free(), cobc_parse_realloc(), cobc_var_print(), main(), plex_clear_all(), ppecho(), pplex(), preprocess(), process(), process_env_copy_path(), scan_define_options(), ylex_clear_all(), and yylex().

{
#ifdef  COB_TREE_DEBUG
    if (unlikely(!mptr)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_free");
        cobc_abort_terminate ();
    }
#endif
    free(mptr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_free_mem ( void  )

static

Definition at line 465 of file cobc.c.

References cobc_free(), cobc_list_dir, cobc_list_file, cobc_mem_struct::next, NULL, and save_temps_dir.

Referenced by cobc_clean_up(), cobc_err_exit(), preprocess(), and process_command_line().

{
    struct cobc_mem_struct  *reps;
    struct cobc_mem_struct  *repsl;

    if (save_temps_dir) {
        cobc_free (save_temps_dir);
        save_temps_dir = NULL;
    }
    if (cobc_list_dir) {
        cobc_free (cobc_list_dir);
        cobc_list_dir = NULL;
    }
    if (cobc_list_file) {
        cobc_free (cobc_list_file);
        cobc_list_file = NULL;
    }
    for (reps = cobc_plexmem_base; reps; ) {
        repsl = reps;
        reps = reps->next;
        cobc_free (repsl);
    }
    cobc_plexmem_base = NULL;
    for (reps = cobc_parsemem_base; reps; ) {
        repsl = reps;
        reps = reps->next;
        cobc_free (repsl);
    }
    cobc_parsemem_base = NULL;
    for (reps = cobc_mainmem_base; reps; ) {
        repsl = reps;
        reps = reps->next;
        cobc_free (repsl);
    }
    cobc_mainmem_base = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* cobc_getenv ( const char *  env )

static

Definition at line 1306 of file cobc.c.

References cobc_main_strdup(), and NULL.

Referenced by main().

{
    char    *p;

    p = getenv (env);
    if (!p || *p == 0 || *p == ' ') {
        return NULL;
    }
    return cobc_main_strdup (p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cobc_main_free

(

void *

prevptr

)

Definition at line 778 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_free(), cobc_mem_struct::memptr, cobc_mem_struct::next, NULL, and unlikely.

Referenced by delete_reserved_word_from_list().

{
    struct cobc_mem_struct  *curr;
    struct cobc_mem_struct  *prev;

    prev = NULL;
    for (curr = cobc_mainmem_base; curr; curr = curr->next) {
        if (curr->memptr == prevptr) {
            break;
        }
        prev = curr;
    }
    if (unlikely(!curr)) {
#ifdef  COB_TREE_DEBUG
        cobc_abort_pr (_("Call to %s with invalid pointer, as it is missing in list"), "cobc_main_free");
        cobc_abort_terminate ();
#else
        return;
#endif
    }
    if (prev) {
        prev->next = curr->next;
    } else {
        /* At mainmem_base */
        cobc_mainmem_base = curr->next;
    }
    cobc_free (curr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_main_malloc

(

const size_t

size

)

Definition at line 702 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_mainmem_base, cobc_mem_struct::memlen, cobc_mem_struct::memptr, cobc_mem_struct::next, and unlikely.

Referenced by add_reserved_word_without_init(), allocate_str_removing_asterisk(), ambiguous_error(), cb_build_class_name(), cb_build_picture(), cb_define_list_add(), cb_expr_init(), cb_int(), cb_text_list_add(), cobc_check_string(), cobc_main_strdup(), cobc_set_value(), cobc_stradd_dup(), codegen(), finalize_file(), get_reserved_words_from_user_list(), main(), output_initialize_one(), process_assemble(), process_command_line(), process_filename(), process_module_direct(), process_translate(), and undefined_error().

{
    struct cobc_mem_struct  *m;

    m = calloc ((size_t)1, sizeof(struct cobc_mem_struct) + size);
    if (unlikely(!m)) {
        cobc_abort_pr (_("Cannot allocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    m->next = cobc_mainmem_base;
    m->memptr = (char *)m + sizeof(struct cobc_mem_struct);
    m->memlen = size;
    cobc_mainmem_base = m;
    return m->memptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_main_realloc	(	void *	prevptr,
		const size_t	size
	)

Definition at line 738 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_free(), cobc_mem_struct::memlen, cobc_mem_struct::memptr, cobc_mem_struct::next, NULL, and unlikely.

Referenced by cb_expr_shift(), cobc_add_str(), cobc_chk_buff_size(), file_basename(), and output_initialize_one().

{
    struct cobc_mem_struct  *m;
    struct cobc_mem_struct  *curr;
    struct cobc_mem_struct  *prev;

    m = calloc ((size_t)1, sizeof(struct cobc_mem_struct) + size);
    if (unlikely(!m)) {
        cobc_abort_pr (_("Cannot allocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    m->memptr = (char *)m + sizeof(struct cobc_mem_struct);
    m->memlen = size;

    prev = NULL;
    for (curr = cobc_mainmem_base; curr; curr = curr->next) {
        if (curr->memptr == prevptr) {
            break;
        }
        prev = curr;
    }
    if (unlikely(!curr)) {
        cobc_abort_pr (_("Attempt to reallocate non-allocated memory - Aborting"));
        cobc_abort_terminate ();
    }
    m->next = curr->next;
    if (prev) {
        prev->next = m;
    } else {
        /* At mainmem_base */
        cobc_mainmem_base = m;
    }
    memcpy (m->memptr, curr->memptr, curr->memlen);
    cobc_free (curr);
    
    return m->memptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_main_strdup

(

const char *

dupstr

)

Definition at line 720 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_main_malloc(), and unlikely.

Referenced by cb_text_list_add(), cobc_check_string(), cobc_getenv(), cobc_set_value(), main(), process_command_line(), process_filename(), process_link(), and read_string().

{
    void    *p;
    size_t  n;

#ifdef  COB_TREE_DEBUG
    if (unlikely(!dupstr)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_main_strdup");
        cobc_abort_terminate ();
    }
#endif
    n = strlen (dupstr);
    p = cobc_main_malloc (n + 1);
    memcpy (p, dupstr, n);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_malloc

(

const size_t

size

)

Definition at line 643 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), and unlikely.

Referenced by cb_add_78(), cb_add_const_var(), cobc_strdup(), ppopen(), and process().

{
    void    *mptr;

    mptr = calloc ((size_t)1, size);
    if (unlikely(!mptr)) {
        cobc_abort_pr (_("Cannot allocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    return mptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_options_error_build ( void  )

static

Definition at line 1882 of file cobc.c.

References _, and cobc_err_exit().

Referenced by process_command_line().

{
    cobc_err_exit (_("Only one of options 'm', 'x', 'b' may be specified"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_options_error_nonfinal ( void  )

static

Definition at line 1876 of file cobc.c.

References _, and cobc_err_exit().

Referenced by process_command_line().

{
    cobc_err_exit (_("Only one of options 'E', 'S', 'C', 'c' may be specified"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cobc_parse_free

(

void *

prevptr

)

Definition at line 885 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_free(), cobc_mem_struct::memptr, cobc_mem_struct::next, NULL, and unlikely.

Referenced by cb_build_move_literal(), remove_program_name(), terminator_clear(), terminator_error(), terminator_warning(), and yyparse().

{
    struct cobc_mem_struct  *curr;
    struct cobc_mem_struct  *prev;

    prev = NULL;
    for (curr = cobc_parsemem_base; curr; curr = curr->next) {
        if (curr->memptr == prevptr) {
            break;
        }
        prev = curr;
    }
    if (unlikely(!curr)) {
#ifdef  COB_TREE_DEBUG
        cobc_abort_pr (_("Call to %s with invalid pointer, as it is missing in list"), "cobc_parse_free");
        cobc_abort_terminate ();
#else
        return;
#endif
    }
    if (prev) {
        prev->next = curr->next;
    } else {
        /* At parsemem_base */
        cobc_parsemem_base = curr->next;
    }
    cobc_free (curr);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_parse_malloc

(

const size_t

size

)

Definition at line 809 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_parsemem_base, cobc_mem_struct::memlen, cobc_mem_struct::memptr, cobc_mem_struct::next, and unlikely.

Referenced by add_contained_prog(), attach_attrib_to_cur_stmt(), build_literal(), cb_build_label(), cb_build_move(), cb_build_move_literal(), cb_build_picture(), cb_build_program(), cb_name(), cb_validate_program_body(), cobc_parse_strdup(), concat_literals(), lookup_attr(), lookup_call(), lookup_func_call(), lookup_literal(), lookup_string(), lookup_word(), make_tree(), output_base(), output_internal_function(), output_param(), output_perform_call(), set_up_use_file(), validate_field_1(), and yyparse().

{
    struct cobc_mem_struct  *m;

    m = calloc ((size_t)1, sizeof(struct cobc_mem_struct) + size);
    if (unlikely(!m)) {
        cobc_abort_pr (_("Cannot allocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    m->next = cobc_parsemem_base;
    m->memptr = (char *)m + sizeof(struct cobc_mem_struct);
    m->memlen = size;
    cobc_parsemem_base = m;
    return m->memptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_parse_realloc	(	void *	prevptr,
		const size_t	size
	)

Definition at line 845 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_free(), cobc_mem_struct::memlen, cobc_mem_struct::memptr, cobc_mem_struct::next, NULL, and unlikely.

{
    struct cobc_mem_struct  *m;
    struct cobc_mem_struct  *curr;
    struct cobc_mem_struct  *prev;

    m = calloc ((size_t)1, sizeof(struct cobc_mem_struct) + size);
    if (unlikely(!m)) {
        cobc_abort_pr (_("Cannot allocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    m->memptr = (char *)m + sizeof(struct cobc_mem_struct);
    m->memlen = size;

    prev = NULL;
    for (curr = cobc_parsemem_base; curr; curr = curr->next) {
        if (curr->memptr == prevptr) {
            break;
        }
        prev = curr;
    }
    if (unlikely(!curr)) {
        cobc_abort_pr (_("Attempt to reallocate non-allocated memory - Aborting"));
        cobc_abort_terminate ();
    }
    m->next = curr->next;
    if (prev) {
        prev->next = m;
    } else {
        /* At parsemem_base */
        cobc_parsemem_base = m;
    }
    memcpy (m->memptr, curr->memptr, curr->memlen);
    cobc_free (curr);
    
    return m->memptr;
}

Here is the call graph for this function:

void* cobc_parse_strdup

(

const char *

dupstr

)

Definition at line 827 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_parse_malloc(), and unlikely.

Referenced by cb_build_class_name(), cb_build_debug(), cb_emit_evaluate(), cb_to_cname(), lookup_string(), lookup_word(), and yylex().

{
    void    *p;
    size_t  n;

#ifdef  COB_TREE_DEBUG
    if (unlikely(!dupstr)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_parse_strdup");
        cobc_abort_terminate ();
    }
#endif
    n = strlen (dupstr);
    p = cobc_parse_malloc (n + 1);
    memcpy (p, dupstr, n);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_plex_malloc

(

const size_t

size

)

Definition at line 916 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_plexmem_base, cobc_mem_struct::memptr, cobc_mem_struct::next, and unlikely.

Referenced by cobc_plex_strdup(), pp_text_list_add(), ppp_define_add(), ppp_list_add(), ppp_replace_list_add(), and ppparse().

{
    struct cobc_mem_struct  *m;

    m = calloc ((size_t)1, sizeof(struct cobc_mem_struct) + size);
    if (unlikely(!m)) {
        cobc_abort_pr (_("Cannot allocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    m->memptr = (char *)m + sizeof(struct cobc_mem_struct);
    m->next = cobc_plexmem_base;
    cobc_plexmem_base = m;
    return m->memptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_plex_strdup

(

const char *

dupstr

)

Definition at line 933 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_plex_malloc(), and unlikely.

Referenced by pplex(), ppp_define_add(), ppp_list_add(), ppp_set_value(), and switch_to_buffer().

{
    void    *p;
    size_t  n;

#ifdef  COB_TREE_DEBUG
    if (unlikely(!dupstr)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_plex_strdup");
        cobc_abort_terminate ();
    }
#endif
    n = strlen (dupstr);
    p = cobc_plex_malloc (n + 1);
    memcpy (p, dupstr, n);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_print_flag ( const char *  name, const char *  doc, const int  pdok, const int  exten  )

static

Definition at line 1767 of file cobc.c.

{
    const char  *bptr;
    char        buff[32];

    if (!pdok) {
        return;
    }
    if (!exten) {
        bptr = name;
    } else {
        snprintf (buff, sizeof(buff), "%s=<value>", name);
        bptr = buff;
    }
    printf ("  -f%-19s %s\n", bptr, doc);
}

static void cobc_print_info ( void  )

static

Definition at line 1630 of file cobc.c.

References _, cb_msg_style, CB_MSG_STYLE_MSC, COB_BLD_BUILD, COB_BLD_CC, COB_BLD_CFLAGS, COB_BLD_CPPFLAGS, COB_BLD_LD, COB_BLD_LDFLAGS, COB_CC, COB_CFLAGS, COB_CONFIG_DIR, COB_COPY_DIR, COB_EXEEXT, COB_LDFLAGS, COB_LIBS, COB_MODULE_EXT, cobc_print_version(), cobc_var_print(), NULL, WITH_CURSES, and WITH_VARSEQ.

Referenced by process_command_line().

{
    char    buff[16];
    char    *s;

    cobc_print_version ();
    putchar ('\n');
    puts (_("build information"));
    cobc_var_print (_("build environment"), COB_BLD_BUILD, 0);
    cobc_var_print ("CC",           COB_BLD_CC, 0);
    cobc_var_print ("CPPFLAGS",     COB_BLD_CPPFLAGS, 0);
    cobc_var_print ("CFLAGS",       COB_BLD_CFLAGS, 0);
    cobc_var_print ("LD",           COB_BLD_LD, 0);
    cobc_var_print ("LDFLAGS",      COB_BLD_LDFLAGS, 0);
    putchar ('\n');
    puts (_("GnuCOBOL information"));
    cobc_var_print ("COB_CC",       COB_CC, 0);
    if ((s = getenv ("COB_CC")) != NULL) {
        cobc_var_print ("COB_CC",   s, 1);
    }
    cobc_var_print ("COB_CFLAGS",       COB_CFLAGS, 0);
    if ((s = getenv ("COB_CFLAGS")) != NULL) {
        cobc_var_print ("COB_CFLAGS",   s, 1);
    }
    cobc_var_print ("COB_LDFLAGS",      COB_LDFLAGS, 0);
    if ((s = getenv ("COB_LDFLAGS")) != NULL) {
        cobc_var_print ("COB_LDFLAGS",  s, 1);
    }
    cobc_var_print ("COB_LIBS",     COB_LIBS, 0);
    if ((s = getenv ("COB_LIBS")) != NULL) {
        cobc_var_print ("COB_LIBS", s, 1);
    }
    cobc_var_print ("COB_CONFIG_DIR",   COB_CONFIG_DIR, 0);
    if ((s = getenv ("COB_CONFIG_DIR")) != NULL) {
        cobc_var_print ("COB_CONFIG_DIR",   s, 1);
    }
    cobc_var_print ("COB_COPY_DIR",     COB_COPY_DIR, 0);
    if ((s = getenv ("COB_COPY_DIR")) != NULL) {
        cobc_var_print ("COB_COPY_DIR", s, 1);
    }
    if ((s = getenv ("COBCPY")) != NULL) {
        cobc_var_print ("COBCPY",   s, 1);
    }
    if (cb_msg_style == CB_MSG_STYLE_MSC) {
        cobc_var_print ("COB_MSG_FORMAT",   "MSC", 0);
    } else {
        cobc_var_print ("COB_MSG_FORMAT",   "GCC", 0);
    }
    if ((s = getenv ("COB_MSG_FORMAT")) != NULL) {
        cobc_var_print ("COB_MSG_FORMAT",   s, 1);
    }
#if 0 /* Simon: only relevant for libcob */
    if ((s = getenv ("COB_LIBRARY_PATH")) != NULL) {
        cobc_var_print ("COB_LIBRARY_PATH", s, 1);
    }
#endif
    cobc_var_print ("COB_MODULE_EXT",   COB_MODULE_EXT, 0);
    cobc_var_print ("COB_EXEEXT",       COB_EXEEXT, 0);

#if 0 /* Simon: only relevant for libcob */
#if defined(USE_LIBDL) || defined(_WIN32)
    cobc_var_print (_("Dynamic loading"),   _("System"), 0);
#else
    cobc_var_print (_("Dynamic loading"),   _("Libtool"), 0);
#endif

#ifdef  COB_PARAM_CHECK
    cobc_var_print ("\"CBL_\" param check", _("Enabled"), 0);
#else
    cobc_var_print ("\"CBL_\" param check", _("Disabled"), 0);
#endif
#endif

    if (sizeof (void *) > 4U) {
        cobc_var_print ("64bit-mode",   _("yes"), 0);
    } else {
        cobc_var_print ("64bit-mode",   _("no"), 0);
    }

#ifdef  COB_LI_IS_LL
    cobc_var_print ("BINARY-C-LONG",    _("8 bytes"), 0);
#else
    cobc_var_print ("BINARY-C-LONG",    _("4 bytes"), 0);
#endif

    cobc_var_print (_("Extended screen I/O"),   WITH_CURSES, 0);

    snprintf (buff, sizeof(buff), "%d", WITH_VARSEQ);
    cobc_var_print (_("Variable format"),   buff, 0);
    if ((s = getenv ("COB_VARSEQ_FORMAT")) != NULL) {
        cobc_var_print ("COB_VARSEQ_FORMAT", s, 1);
    }

#ifdef  WITH_SEQRA_EXTFH
    cobc_var_print (_("Sequential handler"),    _("External"), 0);
#else
    cobc_var_print (_("Sequential handler"),    _("Internal"), 0);
#endif

#if defined (WITH_INDEX_EXTFH)
    cobc_var_print (_("ISAM handler"),      _("External"), 0);
#elif defined   (WITH_DB)
    cobc_var_print (_("ISAM handler"),      "BDB", 0);
#elif defined   (WITH_CISAM)
    cobc_var_print (_("ISAM handler"),      "C-ISAM", 0);
#elif defined   (WITH_DISAM)
    cobc_var_print (_("ISAM handler"),      "D-ISAM", 0);
#elif defined   (WITH_VBISAM)
    cobc_var_print (_("ISAM handler"),      "VBISAM", 0);
#else
    cobc_var_print (_("ISAM handler"),      _("Not available"), 0);
#endif

#ifdef  WITH_INDEX_EXTFH
#endif
#ifdef  WITH_DB
#endif
#ifdef  WITH_CISAM
#endif
#ifdef  WITH_DISAM
#endif
#ifdef  WITH_VBISAM
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void cobc_print_usage ( char *  prog )

static

Definition at line 1786 of file cobc.c.

References _.

Referenced by process_command_line().

{
    puts (_("GnuCOBOL compiler for most COBOL dialects with lots of extensions"));
    putchar ('\n');
    printf (_("usage: %s [options]... file..."), prog);
    putchar ('\n');
    putchar ('\n');
    puts (_("options:"));
    puts (_("  -h, -help             display this help and exit"));
    puts (_("  -V, -version          display compiler version and exit"));
    puts (_("  -i, -info             display compiler information (build/environment)"));
    puts (_("  -v, -verbose          display the commands invoked by the compiler"));
    puts (_("  -vv                   display compiler version and the commands\n" \
            "                        invoked by the compiler"));
    puts (_("  -x                    build an executable program"));
    puts (_("  -m                    build a dynamically loadable module (default)"));
    puts (_("  -j                    run job, after build"));
    puts (_("  -std=<dialect>        warnings/features for a specific dialect\n" 
            "                        <dialect> can be one of:\n"
            "                        cobol2014, cobol2002, cobol85, default,\n"
            "                        ibm, mvs, bs2000, mf, acu;\n" 
            "                        see configuration files in directory config"));
    puts (_("  -F, -free             use free source format"));
    puts (_("  -free                 use free source format"));
    puts (_("  -fixed                use fixed source format (default)"));
    puts (_("  -O, -O2, -Os          enable optimization"));
    puts (_("  -g                    enable C compiler debug / stack check / trace"));
    puts (_("  -d, -debug            enable all run-time error checking"));
    puts (_("  -o <file>             place the output into <file>"));
    puts (_("  -b                    combine all input files into a single\n"
            "                        dynamically loadable module"));
    puts (_("  -E                    preprocess only; do not compile or link"));
    puts (_("  -C                    translation only; convert COBOL to C"));
    puts (_("  -S                    compile only; output assembly file"));
    puts (_("  -c                    compile and assemble, but do not link"));
    puts (_("  -P(=<dir or file>)    generate preprocessed program listing (.lst)"));
    puts (_("  -Xref                 generate cross reference through 'cobxref'\n"
            "                        (V. Coen's 'cobxref' must be in path)"));
    puts (_("  -I <directory>        add <directory> to copy/include search path"));
    puts (_("  -L <directory>        add <directory> to library search path"));
    puts (_("  -l <lib>              link the library <lib>"));
    puts (_("  -A <options>          add <options> to the C compile phase"));
    puts (_("  -Q <options>          add <options> to the C link phase"));
    puts (_("  -D <define>           define <define> for COBOL compilation"));
    puts (_("  -K <entry>            generate CALL to <entry> as static"));
    puts (_("  -conf=<file>          user defined dialect configuration - See -std="));
    puts (_("  -cb_conf=<tag:value>  override configuration entry"));
    puts (_("  -list-reserved        display reserved words"));
    puts (_("  -list-intrinsics      display intrinsic functions"));
    puts (_("  -list-mnemonics       display mnemonic names"));
    puts (_("  -list-system          display system routines"));
    puts (_("  -save-temps(=<dir>)   save intermediate files\n"
            "                        - default: current directory"));
    puts (_("  -ext <extension>      add default file extension"));

    putchar ('\n');

    puts (_("  -W                    enable ALL warnings"));
    puts (_("  -Wall                 enable all warnings except as noted below"));
    puts (_("  -Wno-<feature>        disable warning enabled by -W or -Wall"));
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
#define CB_WARNDEF(var,name,doc)        \
    cobc_print_warn (name, doc, 1);
#define CB_NOWARNDEF(var,name,doc)      \
    cobc_print_warn (name, doc, 0);
#include "warning.def"
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF

    putchar ('\n');

#undef  CB_FLAG
#undef  CB_FLAG_RQ
#undef  CB_FLAG_NQ
#define CB_FLAG(var,pdok,name,doc)      \
    cobc_print_flag (name, doc, pdok, 0);
#define CB_FLAG_RQ(var,pdok,name,def,opt,doc)   \
    cobc_print_flag (name, doc, pdok, 1);
#define CB_FLAG_NQ(pdok,name,opt,doc)       \
    cobc_print_flag (name, doc, pdok, 1);
#include "flag.def"
#undef  CB_FLAG
#undef  CB_FLAG_RQ
#undef  CB_FLAG_NQ

    putchar ('\n');
}

Here is the caller graph for this function:

static void cobc_print_version ( void  )

static

Definition at line 1541 of file cobc.c.

References _, cb_oc_build_stamp, COB_TAR_DATE, OC_C_VERSION, OC_C_VERSION_PRF, PACKAGE_NAME, PACKAGE_VERSION, and PATCH_LEVEL.

Referenced by cobc_print_info(), and process_command_line().

{
    printf ("cobc (%s) %s.%d\n",
        PACKAGE_NAME, PACKAGE_VERSION, PATCH_LEVEL);
    puts ("Copyright (C) 2001-2016 Free Software Foundation, Inc.");
    printf (_("Written by %s\n"), "Keisuke Nishida, Roger While, Ron Norman, Simon Sobisch");
    puts (_("This is free software; see the source for copying conditions.  There is NO\n" 
            "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."));
    printf (_("Built     %s"), cb_oc_build_stamp);
    putchar ('\n');
    printf (_("Packaged  %s"), COB_TAR_DATE);
    putchar ('\n');
    printf (_("C version %s%s"), OC_C_VERSION_PRF, OC_C_VERSION);
    putchar ('\n');
}

Here is the caller graph for this function:

static void cobc_print_warn ( const char *  name, const char *  doc, const int  wall  )

static

Definition at line 1756 of file cobc.c.

References _.

{
    printf ("  -W%-19s %s", name, doc);
    if (!wall) {
        fputs ("\n\t\t\t", stdout);
        fputs (_("- NOT set with -Wall"), stdout);
    }
    putchar ('\n');
}

void* cobc_realloc	(	void *	prevptr,
		const size_t	size
	)

Definition at line 687 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), and unlikely.

Referenced by read_literal(), scan_x(), and scan_z().

{
    void    *mptr;

    mptr = realloc (prevptr, size);
    if (unlikely(!mptr)) {
        cobc_abort_pr (_("Cannot reallocate %d bytes of memory - Aborting"),
                (int)size);
        cobc_abort_terminate ();
    }
    return mptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static unsigned int cobc_set_value ( struct cb_define_struct *  p, const char *  value  )

static

Definition at line 1003 of file cobc.c.

References _, cobc_abort_pr(), cobc_main_malloc(), cobc_main_strdup(), cb_define_struct::dec_part, cb_define_struct::deftype, cb_define_struct::int_part, NULL, PLEX_DEF_LIT, PLEX_DEF_NONE, PLEX_DEF_NUM, cb_define_struct::sign, value, and cb_define_struct::value.

Referenced by cb_define_list_add().

{
    const char  *s;
    size_t      size;
    unsigned int    dot_seen;
    unsigned int    sign_seen;

    if (!value) {
        p->deftype = PLEX_DEF_NONE;
        p->value = NULL;
        p->sign = 0;
        p->int_part = 0;
        p->dec_part = 0;
        return 0;
    }

    /* Quoted value */
    if (*value == '"' || *value == '\'') {
        size = strlen (value) - 1U;
        if (value[0] != value[size]) {
            p->value = NULL;
            p->deftype = PLEX_DEF_NONE;
            return 1;
        }
        p->value = cobc_main_strdup (value);

        p->deftype = PLEX_DEF_LIT;
        p->sign = 0;
        p->int_part = 0;
        p->dec_part = 0;
        return 0;
    }

    /* Non-quoted value - Check if possible numeric */
    dot_seen = 0;
    sign_seen = 0;
    size = 0;
    s = value;
    if (*s == '+' || *s == '-') {
        sign_seen = 1;
        size++;
        s++;
    }
    for (; *s; ++s) {
        if (*s == '.') {
            if (dot_seen) {
                break;
            }
            dot_seen = 1;
            size++;
            continue;
        }
        if (*s > '9' || *s < '0') {
            break;
        }
        size++;
    }

    if (*s || size <= (dot_seen + sign_seen)) {
        /* Not numeric */
#if 0   /* RXWRXW - Lit warn */
        cobc_abort_pr (_("Warning - Assuming literal for unquoted '%s'"),
                value);
#endif
        size = strlen (value);
        p->value = cobc_main_malloc (size + 4U);
        sprintf (p->value, "'%s'", value);
        p->deftype = PLEX_DEF_LIT;
        p->sign = 0;
        p->int_part = 0;
        p->dec_part = 0;
        return 0;
    }

    p->value = cobc_main_strdup (value);
    p->deftype = PLEX_DEF_NUM;
    p->sign = 0;
    p->int_part = 0;
    p->dec_part = 0;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* cobc_stradd_dup ( const char *  str1, const char *  str2  )

static

Definition at line 1286 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_main_malloc(), and unlikely.

Referenced by process_filename(), process_library(), process_link(), process_module(), and process_module_direct().

{
    char    *p;
    size_t  m, n;

#ifdef  COB_TREE_DEBUG
    if (unlikely(!str1 || !str2)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_stradd_dup");
        cobc_abort_terminate ();
    }
#endif
    m = strlen (str1);
    n = strlen (str2);
    p = cobc_main_malloc (m + n + 1);
    memcpy (p, str1, m);
    memcpy (p + m, str2, n);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* cobc_strdup

(

const char *

dupstr

)

Definition at line 669 of file cobc.c.

References _, cobc_abort_pr(), cobc_abort_terminate(), cobc_malloc(), and unlikely.

Referenced by cb_build_program_id(), cb_define_list_add(), cobc_cmd_print(), cobc_deciph_funcs(), cobc_var_print(), ppecho(), ppopen(), process_command_line(), process_env_copy_path(), scan_define_options(), and yylex().

{
    void    *p;
    size_t  n;

#ifdef  COB_TREE_DEBUG
    if (unlikely(!dupstr)) {
        cobc_abort_pr (_("Call to %s with NULL pointer"), "cobc_strdup");
        cobc_abort_terminate ();
    }
#endif
    n = strlen (dupstr);
    p = cobc_malloc (n + 1);
    memcpy (p, dupstr, n);
    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static DECLNORET void COB_A_NORETURN cobc_terminate ( const char *  str )

static

Definition at line 1471 of file cobc.c.

References cobc_clean_up().

Referenced by main(), preprocess(), process_filename(), and process_translate().

{
    int save_errno;

    save_errno = errno;
    fprintf (stderr, "cobc: ");
    fflush (stderr);
    errno = save_errno;
    perror (str);
    fflush (stderr);
    cobc_clean_up (1);
    exit (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cobc_too_many_errors

(

void

)

Definition at line 599 of file cobc.c.

References _, cobc_abort_pr(), and cobc_abort_terminate().

Referenced by cb_error(), cb_error_x(), and cb_plex_error().

{
    cobc_abort_pr (_("Too many errors - Aborting compilation"));
    cobc_abort_terminate ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cobc_tree_cast_error	(	const cb_tree	x,
		const char *	filename,
		const int	linenum,
		const enum cb_tag	tagnum
	)

Definition at line 619 of file cobc.c.

References _, cb_name(), CB_TREE_TAG, cobc_abort_pr(), cobc_abort_terminate(), and cobc_enum_explain().

{
    cobc_abort_pr (_("%s:%d Invalid cast from '%s' type %s to type %s"),
        filename, linenum,
        x ? cb_name (x) : "NULL", 
        x ? cobc_enum_explain (CB_TREE_TAG(x)) : "None",
        cobc_enum_explain (tagnum));
    cobc_abort_terminate ();
}

Here is the call graph for this function:

static void cobc_var_print ( const char *  msg, const char *  val, const unsigned int  env  )

static

Definition at line 1591 of file cobc.c.

References _, CB_IMSG_SIZE, CB_IVAL_SIZE, cobc_free(), cobc_strdup(), and NULL.

Referenced by cobc_print_info().

{
    char    *p;
    char    *token;
    size_t  n;
    int     lablen;
    size_t  toklen;

    if (!env) {
        printf ("%-*.*s : ", CB_IMSG_SIZE, CB_IMSG_SIZE, msg);
    } else {
        printf ("  %s: ", _("env"));
        lablen = CB_IMSG_SIZE - 2 - (int)strlen(_("env")) - 2;
        printf ("%-*.*s : ", lablen, lablen, msg);
    }
    if (strlen(val) <= CB_IVAL_SIZE) {
        printf("%s\n", val);
        return;
    }
    p = cobc_strdup (val);
    n = 0;
    token = strtok (p, " ");
    for (; token; token = strtok (NULL, " ")) {
        toklen = (int)strlen (token) + 1;
        if ((n + toklen) > CB_IVAL_SIZE) {
            if (n) {
                printf ("\n%*.*s", CB_IMSG_SIZE + 3,
                    CB_IMSG_SIZE + 3, " ");
            }
            n = 0;
        }
        printf ("%s%s", (n ? " " : ""), token);
        n += toklen;
    }
    putchar ('\n');
    cobc_free (p);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* file_basename ( const char *  filename )

static

Definition at line 2573 of file cobc.c.

References _, basename_buffer, basename_len, COBC_ABORT, cobc_abort_pr(), cobc_main_realloc(), and NULL.

Referenced by process_compile(), process_filename(), process_library(), process_link(), process_module(), process_module_direct(), and process_run().

{
    const char  *p;
    const char  *startp;
    const char  *endp;
    size_t      len;

    if (!filename) {
        cobc_abort_pr (_("Call to '%s' with invalid parameter '%s'"),
            "file_basename", "filename");
        COBC_ABORT ();
    }

    /* Remove directory name */
    startp = NULL;
    for (p = filename; *p; p++) {
        if (*p == '/' || *p == '\\') {
            startp = p;
        }
    }
    if (startp) {
        startp++;
    } else {
        startp = filename;
    }

    /* Remove extension */
    endp = strrchr (filename, '.');
    if (endp > startp) {
        len = endp - startp;
    } else {
        len = strlen (startp);
    }

    if (len >= basename_len) {
        basename_len = len + 16;
        basename_buffer = cobc_main_realloc (basename_buffer, basename_len);
    }
    /* Copy base name */
    memcpy (basename_buffer, startp, len);
    basename_buffer[len] = 0;
    return basename_buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* file_extension ( const char *  filename )

static

Definition at line 2618 of file cobc.c.

Referenced by process_filename().

{
    const char *p;

    p = strrchr (filename, '.');
    if (p) {
        return p + 1;
    }
    return "";
}

Here is the caller graph for this function:

int main	(	int	argc,
		char **	argv
	)

Definition at line 4152 of file cobc.c.

References _, aflag_set, basename_buffer, basename_len, bindtextdomain, cb_attr_id, cb_compile_level, CB_COPT_1, CB_EXCEPTION_ENABLE, cb_field_id, cb_id, CB_LEVEL_ASSEMBLE, CB_LEVEL_COMPILE, CB_LEVEL_EXECUTABLE, CB_LEVEL_LIBRARY, CB_LEVEL_MODULE, CB_LEVEL_PREPROCESS, CB_LEVEL_TRANSLATE, cb_listing_file, cb_literal_id, cb_msg_style, CB_MSG_STYLE_GCC, CB_MSG_STYLE_MSC, cb_oc_build_stamp, cb_saveargc, cb_saveargv, cb_source_file, CB_TEXT_LIST_ADD, CB_TEXT_LIST_CHK, COB_CC, COB_CFLAGS, COB_CONFIG_DIR, cob_config_dir, COB_COPY_DIR, COB_EC_I_O, COB_EXPORT_DYN, COB_LARGE_BUFF, COB_LARGE_MAX, COB_LDFLAGS, COB_LIBS, COB_MINI_BUFF, COB_MINI_MAX, cob_optimize, COB_PIC_FLAGS, COB_SHARED_OPT, COB_SMALL_BUFF, COB_SMALL_MAX, COBC_ADD_STR, cobc_buffer, cobc_buffer_size, cobc_cc, cobc_cc_len, cobc_cflags, cobc_cflags_len, cobc_cflags_size, cobc_clean_up(), cobc_err_exit(), cobc_export_dyn_len, cobc_flag_library, cobc_flag_main, cobc_flag_module, cobc_free(), cobc_getenv(), cobc_include, cobc_include_len, cobc_include_size, cobc_init_reserved(), cobc_init_scanner(), cobc_init_typeck(), cobc_ldflags, cobc_ldflags_len, cobc_ldflags_size, cobc_lib_paths, cobc_lib_paths_len, cobc_lib_paths_size, cobc_libs, cobc_libs_len, cobc_libs_size, cobc_list_file, cobc_main_malloc(), cobc_main_strdup(), cobc_objects_buffer, cobc_objects_len, cobc_pic_flags_len, cobc_shared_opt_len, cobc_terminate(), cobc_wants_debug, demangle_name, filename::demangle_source, gflag_set, filename::has_error, iargs, LOCALEDIR, filename::need_assemble, filename::need_preprocess, filename::need_translate, cobc_mem_struct::next, NULL, optimize_defs, output_name, PACKAGE, plex_clear_all(), ppin, ppout, preprocess(), process_assemble(), process_command_line(), process_compile(), process_env_copy_path(), process_filename(), process_library(), process_link(), process_module(), process_module_direct(), process_translate(), save_temps_dir, textdomain, verbose_output, wants_nonfinal, ylex_clear_all(), yyin, and yyout.

{
    struct filename     *fn;
    char            *p;
    struct cobc_mem_struct  *mptr;
    struct cobc_mem_struct  *mptrt;
    unsigned int        iparams;
    unsigned int        local_level;
    int         status;
    int         year;
    int         day;
    int         i;
    char            month[32];

#if defined(HAVE_SIGNAL_H) && defined(HAVE_SIGACTION)
    struct sigaction    sa;
    struct sigaction    osa;
#endif
#ifdef  ENABLE_NLS
    struct stat localest;
    const char* localedir;
#endif

        yydebug = 0;
    file_list = NULL;
    cb_listing_file = NULL;
    ppin = NULL;
    ppout = NULL;
    yyin = NULL;
    yyout = NULL;

#ifdef  HAVE_SIGNAL_H

#ifdef  HAVE_SIGACTION
    memset (&sa, 0, sizeof(sa));
    sa.sa_handler = cobc_sig_handler;
#ifdef  SA_RESETHAND
    sa.sa_flags = SA_RESETHAND;
#else
    sa.sa_flags = 0;
#endif
#ifdef  SA_NOCLDSTOP
    sa.sa_flags |= SA_NOCLDSTOP;
#endif
#ifdef  SIGINT
    (void)sigaction (SIGINT, NULL, &osa);
    if (osa.sa_handler != SIG_IGN) {
        (void)sigemptyset (&sa.sa_mask);
        (void)sigaction (SIGINT, &sa, NULL);
    }
#endif
#ifdef  SIGHUP
    (void)sigaction (SIGHUP, NULL, &osa);
    if (osa.sa_handler != SIG_IGN) {
        (void)sigemptyset (&sa.sa_mask);
        (void)sigaction (SIGHUP, &sa, NULL);
    }
#endif
#ifdef  SIGQUIT
    (void)sigaction (SIGQUIT, NULL, &osa);
    if (osa.sa_handler != SIG_IGN) {
        (void)sigemptyset (&sa.sa_mask);
        (void)sigaction (SIGQUIT, &sa, NULL);
    }
#endif
#ifdef  SIGTERM
    (void)sigaction (SIGTERM, NULL, &osa);
    if (osa.sa_handler != SIG_IGN) {
        (void)sigemptyset (&sa.sa_mask);
        (void)sigaction (SIGTERM, &sa, NULL);
    }
#endif
#ifdef  SIGPIPE
    (void)sigaction (SIGPIPE, NULL, &osa);
    if (osa.sa_handler != SIG_IGN) {
        (void)sigemptyset (&sa.sa_mask);
        (void)sigaction (SIGPIPE, &sa, NULL);
    }
#endif
#ifdef  SIGSEGV
    /* Take direct control of segementation violation */
    (void)sigemptyset (&sa.sa_mask);
    (void)sigaction (SIGSEGV, &sa, NULL);
#endif

#else

#ifdef  SIGINT
    if (signal (SIGINT, SIG_IGN) != SIG_IGN) {
        (void)signal (SIGINT, cobc_sig_handler);
    }
#endif
#ifdef  SIGHUP
    if (signal (SIGHUP, SIG_IGN) != SIG_IGN) {
        (void)signal (SIGHUP, cobc_sig_handler);
    }
#endif
#ifdef  SIGQUIT
    if (signal (SIGQUIT, SIG_IGN) != SIG_IGN) {
        (void)signal (SIGQUIT, cobc_sig_handler);
    }
#endif
#ifdef  SIGTERM
    if (signal (SIGTERM, SIG_IGN) != SIG_IGN) {
        (void)signal (SIGTERM, cobc_sig_handler);
    }
#endif
#ifdef  SIGPIPE
    if (signal (SIGPIPE, SIG_IGN) != SIG_IGN) {
        (void)signal (SIGPIPE, cobc_sig_handler);
    }
#endif
    /* Take direct control of segmentation violation */
#ifdef  SIGSEGV
    (void)signal (SIGSEGV, cobc_sig_handler);
#endif
#endif

#endif

    cb_saveargc = argc;
    cb_saveargv = argv;

    /* General buffers */
    cobc_buffer = cobc_main_malloc ((size_t)COB_LARGE_BUFF);
    cobc_buffer_size = COB_LARGE_MAX;
    basename_buffer = cobc_main_malloc ((size_t)COB_MINI_BUFF);
    basename_len = COB_MINI_MAX - 16;

    cobc_libs = cobc_main_malloc ((size_t)COB_SMALL_BUFF);
    cobc_lib_paths = cobc_main_malloc ((size_t)COB_SMALL_BUFF);
    cobc_cflags = cobc_main_malloc ((size_t)COB_MINI_BUFF);
    cobc_ldflags = cobc_main_malloc ((size_t)COB_MINI_BUFF);
    cobc_include = cobc_main_malloc ((size_t)COB_MINI_BUFF);

    cobc_libs_size = COB_SMALL_MAX;
    cobc_lib_paths_size = COB_SMALL_MAX;
    cobc_cflags_size = COB_MINI_MAX;
    cobc_include_size = COB_MINI_MAX;
    cobc_ldflags_size = COB_MINI_MAX;

    cb_source_file = NULL;
    save_temps_dir = NULL;
    base_string = NULL;
    cobc_objects_len = 0;
    cb_id = 1;
    cb_attr_id = 1;
    cb_literal_id = 1;
    cb_field_id = 1;
#ifdef  COB_EBCDIC_MACHINE
    cb_ebcdic_sign = 1;
#else
    cb_ebcdic_sign = 0;
#endif

#ifdef  _WIN32
    /* Allows running tests under Win */
    p = getenv ("COB_UNIX_LF");
    if (p && (*p == 'Y' || *p == 'y' || *p == '1')) {
        (void)_setmode (_fileno (stdin), _O_BINARY);
        (void)_setmode (_fileno (stdout), _O_BINARY);
        (void)_setmode (_fileno (stderr), _O_BINARY);
    }
#endif

#ifdef  HAVE_SETLOCALE
    setlocale (LC_ALL, "");
    setlocale (LC_NUMERIC, "C");
#endif

#ifdef  ENABLE_NLS
    localedir = getenv("LOCALEDIR");
    if (localedir != NULL
    && !stat (localedir, &localest)
    && (S_ISDIR (localest.st_mode))) {
        bindtextdomain (PACKAGE, localedir);
    } else {
        bindtextdomain (PACKAGE, LOCALEDIR);
    }
    textdomain (PACKAGE);
#endif

    /* Initialize variables */

    /* Set up build time stamp */
    memset (month, 0, sizeof(month));
    day = 0;
    year = 0;
    status = sscanf (__DATE__, "%s %d %d", month, &day, &year);
    if (status == 3) {
        snprintf (cobc_buffer, (size_t)COB_MINI_MAX,
              "%s %2.2d %4.4d %s", month, day, year, __TIME__);
    } else {
        snprintf (cobc_buffer, (size_t)COB_MINI_MAX,
              "%s %s", __DATE__, __TIME__);
    }
    cb_oc_build_stamp = cobc_main_strdup (cobc_buffer);

    output_name = NULL;

    cobc_cc = cobc_getenv ("COB_CC");
    if (cobc_cc == NULL) {
        cobc_cc = COB_CC;
    }

    cob_config_dir = cobc_getenv ("COB_CONFIG_DIR");
    if (cob_config_dir == NULL) {
        cob_config_dir = COB_CONFIG_DIR;
    }

    p = cobc_getenv ("COB_CFLAGS");
    if (p) {
        COBC_ADD_STR (cobc_cflags, p, NULL, NULL);
    } else {
        COBC_ADD_STR (cobc_cflags, COB_CFLAGS, NULL, NULL);
    }

    p = cobc_getenv ("COB_LDFLAGS");
    if (p) {
        COBC_ADD_STR (cobc_ldflags, p, NULL, NULL);
    } else {
        COBC_ADD_STR (cobc_ldflags, COB_LDFLAGS, NULL, NULL);
    }

    p = cobc_getenv ("COB_LIBS");
    if (p) {
        COBC_ADD_STR (cobc_libs, p, NULL, NULL);
    } else {
        COBC_ADD_STR (cobc_libs, COB_LIBS, NULL, NULL);
    }

    p = cobc_getenv ("COB_LDADD");
    if (p) {
        COBC_ADD_STR (cobc_libs, " ", p, NULL);
    }

    p = cobc_getenv ("COB_LIB_PATHS");
    if (p) {
        COBC_ADD_STR (cobc_lib_paths, p, NULL, NULL);
    } else {
        COBC_ADD_STR (cobc_lib_paths, " ", NULL, NULL);
    }

    /* Different styles for warning/error messages */
    p = cobc_getenv ("COB_MSG_FORMAT");
#if defined (_MSC_VER)
    if (p && strcasecmp(p, "GCC") == 0) {
        cb_msg_style = CB_MSG_STYLE_GCC;
    } else {
        cb_msg_style = CB_MSG_STYLE_MSC;
    }
#else
    if (p && strcasecmp(p, "MSC") == 0) {
        cb_msg_style = CB_MSG_STYLE_MSC;
    } else {
        cb_msg_style = CB_MSG_STYLE_GCC;
    }
#endif

    /* Set default computed goto usage if appropriate */
#if defined(__GNUC__) && !defined(__clang__)
    cb_flag_computed_goto = 1;
#elif   defined(__SUNPRO_C) && __SUNPRO_C >= 0x570
    cb_flag_computed_goto = 1;
#elif   defined(__xlc__) && defined(__IBMC__) && __IBMC__ >= 700
    cb_flag_computed_goto = 1;
    COBC_ADD_STR (cobc_cflags, " -qlanglvl=extended",
              NULL, NULL);
#endif

    /* Compiler special options */

#ifdef  __WATCOMC__
    /* -s = no overflow checks, otherwise need to code/link a CHK routine */
    COBC_ADD_STR (cobc_cflags, " -s -wcd=118", NULL, NULL);
#endif

#ifdef  __INTEL_COMPILER
    COBC_ADD_STR (cobc_cflags, " -vec-report0 -opt-report 0",
              NULL, NULL);
#elif   defined(__GNUC__)
#if 0   /* RXWRXW - gcse */
    COBC_ADD_STR (cobc_cflags, " -Wno-unused -fsigned-char -fno-gcse",
              NULL, NULL);
#else
    COBC_ADD_STR (cobc_cflags, " -Wno-unused -fsigned-char",
              NULL, NULL);
#endif
    /* --param max-goto-duplication-insns=100000 */
#ifdef  HAVE_PSIGN_OPT
    COBC_ADD_STR (cobc_cflags, " -Wno-pointer-sign", NULL, NULL);
#endif

#elif defined(__xlc__)
    COBC_ADD_STR (cobc_cflags, " -qro -qroconst",
              NULL, NULL);
#endif

    /* Enable default I/O exceptions */
    CB_EXCEPTION_ENABLE (COB_EC_I_O) = 1;

    /* Compiler initialization I */
#ifndef HAVE_DESIGNATED_INITS
    cobc_init_reserved ();
#endif

    /* Process command line arguments */
    iargs = process_command_line (argc, argv);

    /* Check the filename */
    if (iargs == argc) {
        cobc_err_exit (_("No input files"));
    }

    /* Windows stuff reliant upon verbose option */
#ifdef  _MSC_VER
    if (!verbose_output) {
        COBC_ADD_STR (cobc_cflags, " /nologo", NULL, NULL);
    }
#if defined(_MSC_VER) && COB_USE_VC2005_OR_GREATER
    if (!verbose_output) {
        manicmd = "mt /nologo";
        manilink = "/link /nologo /manifest";
    } else {
        manicmd = "mt";
        manilink = "/link /manifest";
    }
#else
    if (!verbose_output) {
        manilink = "/link /nologo";
    } else {
        manilink = "/link";
    }
#endif
    manilink_len = strlen (manilink);
#endif

#ifdef  __WATCOMC__
    if (!verbose_output) {
        COBC_ADD_STR (cobc_cflags, " -q", NULL, NULL);
    }
#endif

#if 0   /* gcc opts */

#if defined(__GNUC__) && !defined (__INTEL_COMPILER)
    if (!gflag_set && !cobc_wants_debug && !aflag_set) {
        COBC_ADD_STR (cobc_cflags, " -fomit-frame-pointer",
                  " -fno-asynchronous-unwind-tables",
                  " -U_FORTIFY_SOURCE");
#if 0   /* RXWRXW - Default opt */
        if (!cob_optimize) {
            COBC_ADD_STR (cobc_cflags, CB_COPT_1, NULL, NULL);
        }
#endif
#ifdef  HAVE_UNWIND_OPT
#endif
    }
#endif

#endif

    /* Append default extensions */
    CB_TEXT_LIST_ADD (cb_extension_list, ".CPY");
    CB_TEXT_LIST_ADD (cb_extension_list, ".CBL");
    CB_TEXT_LIST_ADD (cb_extension_list, ".COB");
    CB_TEXT_LIST_ADD (cb_extension_list, ".cpy");
    CB_TEXT_LIST_ADD (cb_extension_list, ".cbl");
    CB_TEXT_LIST_ADD (cb_extension_list, ".cob");
    CB_TEXT_LIST_ADD (cb_extension_list, "");

    /* Process COB_COPY_DIR and COBCPY environment variables */
    process_env_copy_path (getenv ("COB_COPY_DIR"));
    process_env_copy_path (getenv ("COBCPY"));

    /* Add default COB_COPY_DIR directory */
    CB_TEXT_LIST_CHK (cb_include_list, COB_COPY_DIR);

    /* Defaults are set here */
    if (!cb_flag_syntax_only) {
        if (!wants_nonfinal) {
            if (cobc_flag_main) {
                cb_compile_level = CB_LEVEL_EXECUTABLE;
            } else if (cobc_flag_module) {
                cb_compile_level = CB_LEVEL_MODULE;
            } else if (cobc_flag_library) {
                cb_compile_level = CB_LEVEL_LIBRARY;
            } else if (cb_compile_level == 0) {
                cb_compile_level = CB_LEVEL_MODULE;
                cobc_flag_module = 1;
            }
        }
        if (wants_nonfinal && cb_compile_level != CB_LEVEL_PREPROCESS &&
            !cobc_flag_main && !cobc_flag_module && !cobc_flag_library) {
            cobc_flag_module = 1;
        }
    } else {
        cb_compile_level = CB_LEVEL_TRANSLATE;
        cobc_flag_main = 0;
        cobc_flag_module = 0;
        cobc_flag_library = 0;
    }

    if (output_name && cb_compile_level < CB_LEVEL_LIBRARY &&
        (argc - iargs) > 1) {
        cobc_err_exit (_("%s option invalid in this combination"), "-o");
    }

    if (cb_flag_notrunc) {
        cb_binary_truncate = 0;
        cb_pretty_display = 0;
    }

    /* Compiler initialization II */
#ifndef HAVE_DESIGNATED_INITS
    cobc_init_scanner ();
    cobc_init_typeck ();
#endif

    /* If -P=file specified, all lists go to this file */
    if (cobc_list_file) {
        cb_listing_file = fopen (cobc_list_file, "w");
        if (!cb_listing_file) {
            cobc_terminate (cobc_list_file);
        }
    }

    if (verbose_output) {
        fputs (_("Command line:"), stderr);
        putc ('\t', stderr);
        for (i = 0; i < argc; ++i) {
            fprintf (stderr, "%s ", argv[i]);
        }
        putc ('\n', stderr);
        fflush (stderr);
    }

    cobc_cc_len = strlen (cobc_cc);
    cobc_cflags_len = strlen (cobc_cflags);
    cobc_libs_len = strlen (cobc_libs);
    cobc_lib_paths_len = strlen (cobc_lib_paths);
    cobc_include_len = strlen (cobc_include);
    cobc_ldflags_len = strlen (cobc_ldflags);
    cobc_export_dyn_len = strlen (COB_EXPORT_DYN);
    cobc_shared_opt_len = strlen (COB_SHARED_OPT);
    cobc_pic_flags_len = strlen (COB_PIC_FLAGS);

    /* Process input files */
    status = 0;
    iparams = 0;
    local_level = 0;

    while (iargs < argc) {
        /* Set up file parameters */
        fn = process_filename (argv[iargs++]);
        if (!fn) {
            cobc_clean_up (1);
            return 1;
        }
        cb_id = 1;
        cb_attr_id = 1;
        cb_literal_id = 1;
        cb_field_id = 1;
        demangle_name = fn->demangle_source;
        memset (optimize_defs, 0, sizeof(optimize_defs));
        iparams++;
        if (iparams > 1 && cb_compile_level == CB_LEVEL_EXECUTABLE) {
            local_level = cb_compile_level;
            cb_compile_level = CB_LEVEL_ASSEMBLE;
            cobc_flag_main = 0;
        }

        if (cb_compile_level >= CB_LEVEL_PREPROCESS &&
            fn->need_preprocess) {
            /* Preprocess */
            fn->has_error = preprocess (fn);
            status |= fn->has_error;
        }
        if (cobc_list_file) {
            putc ('\n', cb_listing_file);
        }

        if (cb_compile_level < CB_LEVEL_TRANSLATE || fn->has_error) {
            continue;
        }
        if (fn->need_translate) {
            /* Parse / Translate (to C code) */
            fn->has_error = process_translate (fn);
            status |= fn->has_error;
            /* Free parse memory */
            for (mptr = cobc_parsemem_base; mptr; ) {
                mptrt = mptr;
                mptr = mptr->next;
                cobc_free (mptrt);
            }
            cobc_parsemem_base = NULL;
        }
        if (cb_compile_level < CB_LEVEL_COMPILE ||
            cb_flag_syntax_only || fn->has_error) {
            continue;
        }
        if (cb_compile_level == CB_LEVEL_COMPILE) {
            /* Compile to assembler code */
            fn->has_error = process_compile (fn);
            status |= fn->has_error;
            continue;
        }

        if (cb_compile_level == CB_LEVEL_MODULE && fn->need_assemble) {
            /* Build module direct */
            fn->has_error = process_module_direct (fn);
            status |= fn->has_error;
        } else {
            /* Compile to object code */
            if (cb_compile_level >= CB_LEVEL_ASSEMBLE &&
                fn->need_assemble) {
                fn->has_error = process_assemble (fn);
                status |= fn->has_error;
            }
            if (fn->has_error) {
                continue;
            }

            /* Build module */
            if (cb_compile_level == CB_LEVEL_MODULE) {
                fn->has_error = process_module (fn);
                status |= fn->has_error;
            }
        }
    }

    if (cobc_list_file) {
        fclose (cb_listing_file);
        cb_listing_file = NULL;
    }

    /* Clear rest of preprocess stuff */
    plex_clear_all ();

    /* Clear rest of parser stuff */
    ylex_clear_all ();

    if (local_level == CB_LEVEL_EXECUTABLE) {
        cb_compile_level = CB_LEVEL_EXECUTABLE;
    }

    if (cb_compile_level < CB_LEVEL_LIBRARY ||
        status || cb_flag_syntax_only) {
        /* Finished */
        cobc_clean_up (status);
        return status;
    }

    /* Allocate objects buffer */
    cobc_objects_buffer = cobc_main_malloc (cobc_objects_len);

    if (file_list) {
        /* Link */
        if (cb_compile_level == CB_LEVEL_LIBRARY) {
            /* Multi-program module */
            status = process_library (file_list);
        } else {
            /* Executable */
            status = process_link (file_list);
        }
    }

    /* We have completed */
    cobc_clean_up (status);

    return status;
}

Here is the call graph for this function:

static int preprocess ( struct filename *  fn )

static

Definition at line 3262 of file cobc.c.

References _, cb_listing_file, cb_source_format, COB_DASH, cobc_buffer, cobc_buffer_size, cobc_cmd_print(), cobc_free(), cobc_free_mem(), cobc_gen_listing, cobc_list_file, cobc_terminate(), errorcount, filename::file_is_stdin, filename::listing_file, cobc_mem_struct::next, NULL, plex_call_destroy(), plex_clear_vars(), ppin, ppopen(), ppout, ppparse(), ppparse_clear_vars(), filename::preprocess, filename::source, unlikely, and verbose_output.

Referenced by main().

{
    struct cobc_mem_struct  *m;
    struct cobc_mem_struct  *ml;
    const char      *sourcename;
    int         save_source_format;
    int         save_fold_copy;
    int         save_fold_call;
    int         ret;

    errorcount = 0;

    ppout = fopen (fn->preprocess, "w");
    if (!ppout) {
        cobc_terminate (fn->preprocess);
    }

    if (fn->file_is_stdin) {
        sourcename = COB_DASH;
    } else {
        sourcename = fn->source;
    }
    if (ppopen (sourcename, NULL) != 0) {
        fclose (ppout);
        ppout = NULL;
        if (fn->preprocess) {
            (void)unlink (fn->preprocess);
        }
        cobc_free_mem ();
        exit (1);
    }

    if (verbose_output) {
        fputs (_("Preprocessing:"), stderr);
        fprintf (stderr, "\t%s -> %s\n",
             sourcename, fn->preprocess);
        fflush (stderr);
    }

    if (cobc_gen_listing && !cobc_list_file) {
        cb_listing_file = fopen (fn->listing_file, "w");
        if (!cb_listing_file) {
            cobc_terminate (fn->listing_file);
        }
    }

    /* Reset pplex/ppparse variables */
    plex_clear_vars ();
    ppparse_clear_vars (cb_define_list);

    /* Save default flags in case program directives change them */
    save_source_format = cb_source_format;
    save_fold_copy = cb_fold_copy;
    save_fold_call = cb_fold_call;

    /* Preprocess */
    ppparse ();

    /* Restore default flags */
    cb_source_format = save_source_format;
    cb_fold_copy = save_fold_copy;
    cb_fold_call = save_fold_call;

    if (ppin) {
        fclose (ppin);
        ppin = NULL;
    }

    if (ppout) {
        if (unlikely(fclose(ppout) != 0)) {
            cobc_terminate(fn->preprocess);
        }
        ppout = NULL;
    }

    /* Release flex buffers - After file close */
    plex_call_destroy ();

    for (m = cobc_plexmem_base; m; ) {
        ml = m;
        m = m->next;
        cobc_free (ml);
    }
    cobc_plexmem_base = NULL;

    if (cobc_gen_listing && !cobc_list_file) {
        if (unlikely(fclose (cb_listing_file) != 0)) {
            cobc_terminate(fn->listing_file);
        }
        if (cobc_gen_listing > 1) {
            snprintf (cobc_buffer, cobc_buffer_size,
                 "cobxref %s -R", fn->listing_file);
            cobc_buffer[cobc_buffer_size] = 0;
            if (verbose_output) {
                cobc_cmd_print (cobc_buffer);
            }
            ret = system (cobc_buffer);
            if (verbose_output) {
                fputs (_("Return status:"), stderr);
                fprintf (stderr, "\t%d\n", ret);
                fflush (stderr);
            }
            if (ret) {
                fputs (_("'cobxref' execution unsuccessful"),
                    stderr);
                putc ('\n', stderr);
#ifdef  _WIN32
                fprintf (stderr, _("Check that 'cobxref' is in %s"),
                    "%%PATH%%");
#else
                fprintf (stderr, _("Check that 'cobxref' is in %s"),
                    "$PATH");
#endif
                putc ('\n', stderr);
                fputs (_("No listing produced"),
                    stderr);
                putc ('\n', stderr);
                fflush (stderr);
            }
            unlink (fn->listing_file);
        }
        cb_listing_file = NULL;
    }

    if (verbose_output) {
        fputs (_("Return status:"), stderr);
        fprintf (stderr, "\t%d\n", errorcount);
        fflush (stderr);
    }
    return !!errorcount;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process ( const char *  cmd )

static

Definition at line 3201 of file cobc.c.

References _, cobc_cmd_print(), cobc_free(), cobc_malloc(), likely, NULL, unlikely, and verbose_output.

Referenced by process_assemble(), process_compile(), process_library(), process_link(), process_module(), and process_module_direct().

{
    char    *p;
    char    *buffptr;
    size_t  clen;
    int ret;

    if (likely(strchr (cmd, '$') == NULL)) {
        buffptr = (char *)cmd;
    } else {
        clen = strlen (cmd) + 64U;
        clen = clen + 6U;
        buffptr = (char *)cobc_malloc (clen);
        p = buffptr;
        /* Quote '$' */
        for (; *cmd; ++cmd) {
            if (*cmd == '$') {
                p += sprintf (p, "\\$");
            } else {
                *p++ = *cmd;
            }
        }
        *p = 0;
    }

    if (verbose_output) {
        cobc_cmd_print (buffptr);
    }

    ret = system (buffptr);

    if (unlikely(buffptr != cmd)) {
        cobc_free (buffptr);
    }

#ifdef  WIFSIGNALED
    if (WIFSIGNALED(ret)) {
#ifdef  SIGINT
        if (WTERMSIG(ret) == SIGINT) {
            cobc_sig_handler (SIGINT);
        }
#endif
#ifdef  SIGQUIT
        if (WTERMSIG(ret) == SIGQUIT) {
            cobc_sig_handler (SIGQUIT);
        }
#endif
    }
#endif
    if (verbose_output) {
        fputs (_("Return status:"), stderr);
        fprintf (stderr, "\t%d\n", ret);
        fflush (stderr);
    }
    return !!ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_assemble ( struct filename *  fn )

static

Definition at line 3611 of file cobc.c.

References cb_compile_level, CB_LEVEL_ASSEMBLE, CB_LEVEL_LIBRARY, CB_LEVEL_MODULE, COB_LARGE_BUFF, COB_PIC_FLAGS, cobc_buffer, cobc_cc, cobc_cc_len, cobc_cflags, cobc_cflags_len, cobc_chk_buff_size(), cobc_flag_run, cobc_include, cobc_include_len, cobc_main_malloc(), cobc_pic_flags_len, gflag_set, filename::object, filename::object_len, process(), process_run(), filename::translate, filename::translate_len, and verbose_output.

Referenced by main().

{
#ifndef _MSC_VER
    int     ret;
#endif
    size_t      bufflen;
#ifdef  __OS400__
    char    *name;
#endif

    bufflen = cobc_cc_len + cobc_cflags_len + fn->object_len
            + fn->translate_len + cobc_include_len
            + cobc_pic_flags_len + 64U;

    cobc_chk_buff_size (bufflen);

#ifdef  _MSC_VER
    sprintf (cobc_buffer, gflag_set ?
        "%s /c %s %s /Od /MDd /Zi /FR /Fo\"%s\" \"%s\"" :
        "%s /c %s %s     /MD          /Fo\"%s\" \"%s\"",
            cobc_cc, cobc_cflags, cobc_include,
            fn->object, fn->translate);
    if (verbose_output) {
        return process (cobc_buffer);
    } else {
        return process_filtered (cobc_buffer, fn);
    }
#elif defined(__OS400__)
    name = (char *) fn->translate;
    if (name[0] != '/') {
        char    *p;

        p = cobc_main_malloc (COB_LARGE_BUFF);
        getcwd (p, COB_LARGE_BUFF);
        strcat (p, "/");
        strcat (p, name);
        name = p;
    }
    file_stripext ((char *) fn->object);
    sprintf (cobc_buffer, "%s -c %s %s -o %s %s",
         cobc_cc, cobc_cflags, cobc_include,
         fn->object, name);
    ret = process (cobc_buffer);
    if ((ret == 0) && cobc_flag_run) {
        ret = process_run (name);
    }
    return ret;
#elif defined(__WATCOMC__)
    if (cb_compile_level == CB_LEVEL_MODULE ||
        cb_compile_level == CB_LEVEL_LIBRARY) {
        sprintf (cobc_buffer, "%s -c %s %s %s -fe=\"%s\" \"%s\"",
             cobc_cc, cobc_cflags, cobc_include,
             COB_PIC_FLAGS, fn->object, fn->translate);
    } else {
        sprintf (cobc_buffer, "%s -c %s %s -fe=\"%s\" \"%s\"",
             cobc_cc, cobc_cflags, cobc_include,
             fn->object, fn->translate);
    }
    ret = process (cobc_buffer);
    if ((ret == 0) && cobc_flag_run) {
        ret = process_run (fn->object);
    }
    return ret;
#else
    if (cb_compile_level == CB_LEVEL_MODULE ||
        cb_compile_level == CB_LEVEL_LIBRARY ||
        cb_compile_level == CB_LEVEL_ASSEMBLE) {
        sprintf (cobc_buffer, "%s -c %s %s %s -o \"%s\" \"%s\"",
             cobc_cc, cobc_cflags, cobc_include,
             COB_PIC_FLAGS, fn->object, fn->translate);
    } else {
        // Only for CB_LEVEL_EXECUTABLE
        sprintf (cobc_buffer, "%s -c %s %s -o \"%s\" \"%s\"",
             cobc_cc, cobc_cflags, cobc_include,
             fn->object, fn->translate);
    }
    ret = process (cobc_buffer);
    return ret;
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_command_line ( const int  argc, char **  argv  )

static

Definition at line 1911 of file cobc.c.

References _, aflag_set, cb_compile_level, cb_config_entry(), CB_COPT_1, CB_COPT_2, CB_COPT_S, cb_define_list_add(), CB_EXCEPTION_ENABLE, cb_flag_main, CB_FORMAT_FREE, CB_LEVEL_ASSEMBLE, CB_LEVEL_COMPILE, CB_LEVEL_PREPROCESS, CB_LEVEL_TRANSLATE, cb_list_intrinsics(), cb_list_mnemonics(), cb_list_reserved(), cb_list_system(), cb_load_conf(), cb_load_std(), CB_OK, cb_source_format, CB_TEXT_LIST_ADD, COB_EC_MAX, COB_FOLD_LOWER, COB_FOLD_UPPER, cob_getopt_long_long(), COB_MINI_BUFF, COB_MINI_MAX, cob_optarg, cob_optimize, cob_optind, COB_SMALL_MAX, cobc_abort_pr(), COBC_ADD_STR, cobc_cflags, cobc_deciph_funcs(), cobc_deciph_optarg(), cobc_err_exit(), cobc_flag_library, cobc_flag_main, cobc_flag_module, cobc_flag_run, cobc_free_mem(), cobc_gen_listing, cobc_include, COBC_INV_PAR, cobc_ldflags, cobc_lib_paths, cobc_libs, cobc_list_dir, cobc_list_file, cobc_main_malloc(), cobc_main_strdup(), cobc_options_error_build(), cobc_options_error_nonfinal(), cobc_print_info(), cobc_print_usage(), cobc_print_version(), cobc_strdup(), cobc_wants_debug, exit_option, gflag_set, no_physical_cancel, NULL, output_name, output_name_buff, save_all_src, save_c_src, save_temps, save_temps_dir, short_options, strip_output, verbose_output, wants_nonfinal, and warningopt.

Referenced by main().

{
    struct cb_define_struct *p;
    size_t          osize;
    int         c;
    int         idx;
    int         n;
    int         list_reserved = 0;
#ifdef _WIN32
    int             argnum;
#endif
    enum cob_exception_id   i;
    struct stat     st;
    char            ext[COB_MINI_BUFF];
    
    int         conf_ret = 0;
    int         sub_ret;

#ifdef _WIN32
    /* Translate command line arguments from WIN to UNIX style */
    argnum = 1;
    while (++argnum <= argc) {
        if (strrchr(argv[argnum - 1], '/') == argv[argnum - 1]) {
            argv[argnum - 1][0] = '-';
        }
    }
#endif
    
    /* First run of getopt: handle std/conf and all listing options
       We need to postpone single configuration flags as we need
       a full configuration to be loaded before */
    cob_optind = 1;
    while ((c = cob_getopt_long_long (argc, argv, short_options,
                      long_options, &idx, 1)) >= 0) {
        switch (c) {

        case '?':
            /* Unknown option or ambiguous */
            cobc_free_mem ();
            exit (1);

        case 'h':
            /* --help */
            cobc_print_usage (argv[0]);
            cobc_free_mem ();
            exit (0);

        case 'V':
            /* --version */
            cobc_print_version ();
            exit (0);

        case 'i':
            /* --info */
            cobc_print_info ();
            exit_option = 1;
            break;

        case '5':
            /* --list-reserved */
            /*
              This must be postponed until after the configuration
              is loaded.
            */
            list_reserved = 1;
            break;

        case '6':
            /* --list-intrinsics */
            cb_list_intrinsics ();
            exit_option = 1;
            break;

        case '7':
            /* --list-mnemonics */
            cb_list_mnemonics ();
            exit_option = 1;
            break;

        case '8':
            /* --list-system */
            cb_list_system ();
            exit_option = 1;
            break;

        case 'v':
            /* --verbose : Verbose reporting */
            /* VERY special case as we set different level by mutliple calls */
            /* Output version information when running very verbose */
            if (++verbose_output == 2) {
                cobc_print_version ();
            }
            break;

        case '$':
            /* -std=<xx> : Specify dialect */
            if (!exit_option) {
                snprintf (ext, (size_t)COB_MINI_MAX, "%s.conf", cob_optarg);
                if (cb_load_std (ext) != 0) {
                    cobc_err_exit (_("Invalid option -std=%s"),
                               cob_optarg);
                }
            }
            break;

        case '&':
            /* -conf=<xx> : Specify dialect configuration file */
            if (!exit_option) {
                if (strlen (cob_optarg) > COB_SMALL_MAX) {
                    cobc_err_exit (COBC_INV_PAR, "-conf");
                }
                sub_ret = cb_load_conf (cob_optarg, 0);
                if (sub_ret != 0) conf_ret = sub_ret;
            }
            break;

        default:
            /* as we postpone most options simply skip everything other here */
            break;
        }
    }

    /* Exit if list options were specified */
    if (exit_option) {
        cobc_free_mem ();
        exit (0);
    }

    /* Load default configuration file if necessary */
    if (cb_config_name == NULL) {
        if (verbose_output) {
            fputs (_("Loading standard configuration file 'default.conf'"), stderr);
            fputc ('\n', stderr);
        }
        sub_ret = cb_load_std ("default.conf");
        if (sub_ret != 0) conf_ret = sub_ret;
    }

    /* Exit for configuration errors resulting from -std/-conf/default.conf */
    if (conf_ret != 0) {
        cobc_free_mem ();
        exit (1);
    }

    /* Set relaxed syntax configuration options if requested */
    if (cb_flag_relaxed_syntax) {
        cb_relaxed_syntax_check = 1;
        cb_larger_redefines_ok = 1;
        cb_relax_level_hierarchy = 1;
        cb_top_level_occurs_clause = CB_OK;
    }
    
    cob_optind = 1;
    while ((c = cob_getopt_long_long (argc, argv, short_options,
                      long_options, &idx, 1)) >= 0) {
        switch (c) {
        case 0:
            /* Defined flag */
            break;
        
        case 'h':
            /* --help */
        case 'V':
            /* --version */
        case 'i':
            /* --info */
        case '5':
            /* --list-reserved */
        case '6':
            /* --list-intrinsics */
        case '7':
            /* --list-mnemonics */
        case '8':
            /* --list-system */
            /* These options were all processed in the first getopt-run */
            break;

        case 'E':
            /* -E : Preprocess */
            if (wants_nonfinal) {
                cobc_options_error_nonfinal ();
            }
            wants_nonfinal = 1;
            cb_compile_level = CB_LEVEL_PREPROCESS;
            break;

        case 'C':
            /* -C : Generate C code */
            if (wants_nonfinal) {
                cobc_options_error_nonfinal ();
            }
            save_c_src = 1;
            wants_nonfinal = 1;
            cb_compile_level = CB_LEVEL_TRANSLATE;
            break;

        case 'S':
            /* -S : Generate assembler code */
            if (wants_nonfinal) {
                cobc_options_error_nonfinal ();
            }
            wants_nonfinal = 1;
            cb_compile_level = CB_LEVEL_COMPILE;
            break;

        case 'c':
            /* -c : Generate C object code */
            if (wants_nonfinal) {
                cobc_options_error_nonfinal ();
            }
            wants_nonfinal = 1;
            cb_compile_level = CB_LEVEL_ASSEMBLE;
            break;

        case 'b':
            /* -b : Generate combined library module */
            if (cobc_flag_main || cobc_flag_module) {
                cobc_options_error_build ();
            }
            cobc_flag_library = 1;
            no_physical_cancel = 1;
            cb_flag_implicit_init = 1;
            break;

        case 'm':
            /* -m : Generate loadable module (default) */
            if (cobc_flag_main || cobc_flag_library) {
                cobc_options_error_build ();
            }
            cobc_flag_module = 1;
            break;

        case 'x':
            /* -x : Generate executable */
            if (cobc_flag_module || cobc_flag_library) {
                cobc_options_error_build ();
            }
            cobc_flag_main = 1;
            cb_flag_main = 1;
            no_physical_cancel = 1;
            break;

        case 'j':
            /* -j : Run job; compile, link and go, either by ./ or cobcrun */
            cobc_flag_run = 1;
            break;

        case 'F':
            /* -F : short option for -free */
            cb_source_format = CB_FORMAT_FREE;
            break;

        case 'v':
            /* --verbose : Verbose reporting */
            /* This option was processed in the first getopt-run */
            break;

        case 'o':
            /* -o : Output file */
            osize = strlen (cob_optarg);
            if (osize > COB_SMALL_MAX) {
                cobc_err_exit (_("Invalid output file name"));
            }
            output_name = cobc_main_strdup (cob_optarg);
            /* Allocate buffer plus extension reserve */
            output_name_buff = cobc_main_malloc (osize + 32U);
            break;

        case 'O':
            /* -O : Optimize */
            cob_optimize = 1;
            COBC_ADD_STR (cobc_cflags, CB_COPT_1, NULL, NULL);
            break;

        case '9':
            /* -O2 : Optimize */
            cob_optimize = 1;
            strip_output = 1;
            COBC_ADD_STR (cobc_cflags, CB_COPT_2, NULL, NULL);
            break;

        case 's':
            /* -Os : Optimize */
            cob_optimize = 1;
            strip_output = 1;
            COBC_ADD_STR (cobc_cflags, CB_COPT_S, NULL, NULL);
            break;

        case 'g':
            /* -g : Generate C debug code */
            save_all_src = 1;
            gflag_set = 1;
            cb_flag_stack_check = 1;
            cb_flag_source_location = 1;
#ifndef _MSC_VER
            COBC_ADD_STR (cobc_cflags, " -g", NULL, NULL);
#endif
            break;

        case '$':
            /* -std=<xx> : Specify dialect */
        case '&':
            /* -conf=<xx> : Specify dialect configuration file */
            /* These options were all processed in the first getopt-run */
            break;

        case '%':
            /* -cb_conf=<xx:yy> : Override configuration entry */
            if (strlen (cob_optarg) > COB_SMALL_MAX) {
                cobc_err_exit (COBC_INV_PAR , "-cb_conf");
            }
            sub_ret = cb_config_entry (cob_optarg, NULL, 0);
            if (sub_ret != 0) conf_ret = sub_ret;
            break;

        case 'd':
            /* -debug : Turn on OC debugging */
            cb_flag_source_location = 1;
            cb_flag_trace = 1;
            cb_flag_stack_check = 1;
            cobc_wants_debug = 1;
            break;

        case '_':
            /* --save-temps : Save intermediary files */
            save_temps = 1;
            if (cob_optarg) {
                if (stat (cob_optarg, &st) != 0 ||
                    !(S_ISDIR (st.st_mode))) {
                    cobc_abort_pr (_("Warning - '%s' is not a directory, defaulting to current directory"),
                        cob_optarg);
                } else {
                    save_temps_dir = cobc_strdup (cob_optarg);
                }
            }
            break;

        case 'P':
            /* -P : Generate listing */
            if (cob_optarg) {
                if (!stat (cob_optarg, &st) && S_ISDIR (st.st_mode)) {
                    cobc_list_dir = cobc_strdup (cob_optarg);
                } else {
                    cobc_list_file = cobc_strdup (cob_optarg);
                }
            }
            if (!cobc_gen_listing) {
                cobc_gen_listing = 1;
            }
            break;

        case 'X':
            /* -Xref : Generate listing through 'cobxref' */
            cobc_gen_listing = 2;
            break;

        case 'D':
            /* -D xx(=yy) : Define variables */
            if (strlen (cob_optarg) > 64U) {
                cobc_err_exit (COBC_INV_PAR, "-D");
            }
            if (!strcasecmp (cob_optarg, "ebug")) {
                cobc_abort_pr (_("Warning - assuming '%s' is a DEFINE - did you intend to use -debug?"),
                        cob_optarg);
            }
            p = cb_define_list_add (cb_define_list, cob_optarg);
            if (!p) {
                cobc_err_exit (COBC_INV_PAR, "-D");
            }
            cb_define_list = p;
            break;

        case 'I':
            /* -I <xx> : Include/copy directory */
            if (strlen (cob_optarg) > COB_SMALL_MAX) {
                cobc_err_exit (COBC_INV_PAR, "-I");
            }
            if (stat (cob_optarg, &st) != 0 ||
                !(S_ISDIR (st.st_mode))) {
                break;
            }
#ifdef  _MSC_VER
            COBC_ADD_STR (cobc_include, " /I \"", cob_optarg, "\"");
#elif   defined (__WATCOMC__)
            COBC_ADD_STR (cobc_include, " -i\"", cob_optarg, "\"");
#else
            COBC_ADD_STR (cobc_include, " -I\"", cob_optarg, "\"");
#endif
            CB_TEXT_LIST_ADD (cb_include_list, cob_optarg);
            break;

        case 'L':
            /* -L <xx> : Directory for library search */
            if (strlen (cob_optarg) > COB_SMALL_MAX) {
                cobc_err_exit (COBC_INV_PAR, "-L");
            }
            if (stat (cob_optarg, &st) != 0 ||
                !(S_ISDIR (st.st_mode))) {
                break;
            }
#ifdef  _MSC_VER
            COBC_ADD_STR (cobc_lib_paths, " /LIBPATH:\"", cob_optarg, "\"");
#else
            COBC_ADD_STR (cobc_lib_paths, " -L\"", cob_optarg, "\"");
#endif
            break;

        case 'l':
            /* -l <xx> : Add library to link phase */
            if (strlen (cob_optarg) > COB_SMALL_MAX) {
                cobc_err_exit (COBC_INV_PAR, "-l");
            }
#ifdef  _MSC_VER
            COBC_ADD_STR (cobc_libs, " \"", cob_optarg, ".lib\"");
#else
            COBC_ADD_STR (cobc_libs, " -l\"", cob_optarg, "\"");
#endif
            break;

        case 'e':
            /* -e <xx> : Add an extension suffix */
            if (strlen (cob_optarg) > 15U) {
                cobc_err_exit (COBC_INV_PAR, "--ext");
            }
            snprintf (ext, (size_t)COB_MINI_MAX, ".%s", cob_optarg);
            CB_TEXT_LIST_ADD (cb_extension_list, ext);
            break;

        case 'K':
            /* -K <xx> : Define literal CALL to xx as static */
            if (strlen (cob_optarg) > 32U) {
                cobc_err_exit (COBC_INV_PAR, "-K");
            }
            CB_TEXT_LIST_ADD (cb_static_call_list, cob_optarg);
            break;

        case 'k':
            /* -k <xx> : Check for exit after CALL to xx  */
            /* This is to cater for legacy German DIN standard */
            /* Check after CALL if an exit program required */
            /* Not in --help as subject to change and highly specific */
            if (strlen (cob_optarg) > 32U) {
                cobc_err_exit (COBC_INV_PAR, "-k");
            }
            CB_TEXT_LIST_ADD (cb_early_exit_list, cob_optarg);
            break;

        case 1:
            /* -fstack-size=<xx> : Specify stack (perform) size */
            n = cobc_deciph_optarg (cob_optarg, 0);
            if (n < 16 || n > 512) {
                cobc_err_exit (COBC_INV_PAR, "-fstack-size");
            }
            cb_stack_size = n;
            break;

        case 2:
            /* -fif-cutoff=<xx> : Specify IF cutoff level */
            n = cobc_deciph_optarg (cob_optarg, 0);
            if (n < 1 || n > 512) {
                cobc_err_exit (COBC_INV_PAR, "-fif-cutoff");
            }
            cb_if_cutoff = n;
            break;

        case 3:
            /* -fsign=<ASCII/EBCDIC> : Specify display sign */
            if (!strcasecmp (cob_optarg, "EBCDIC")) {
                cb_ebcdic_sign = 1;
            } else if (!strcasecmp (cob_optarg, "ASCII")) {
                cb_ebcdic_sign = 0;
            } else {
                cobc_err_exit (COBC_INV_PAR, "-fsign");
            }
            break;

        case 4:
            /* -ffold-copy=<UPPER/LOWER> : COPY fold case */
            if (!strcasecmp (cob_optarg, "UPPER")) {
                cb_fold_copy = COB_FOLD_UPPER;
            } else if (!strcasecmp (cob_optarg, "LOWER")) {
                cb_fold_copy = COB_FOLD_LOWER;
            } else {
                cobc_err_exit (COBC_INV_PAR, "-ffold-copy");
            }
            break;

        case 5:
            /* -ffold-call=<UPPER/LOWER> : CALL/PROG-ID fold case */
            if (!strcasecmp (cob_optarg, "UPPER")) {
                cb_fold_call = COB_FOLD_UPPER;
            } else if (!strcasecmp (cob_optarg, "LOWER")) {
                cb_fold_call = COB_FOLD_LOWER;
            } else {
                cobc_err_exit (COBC_INV_PAR, "-ffold-call");
            }
            break;

        case 6:
            /* -fdefaultbyte=<xx> : Default initialization byte */
            n = cobc_deciph_optarg (cob_optarg, 1);
            if (n < 0 || n > 255) {
                cobc_err_exit (COBC_INV_PAR, "-fdefaultbyte");
            }
            cb_default_byte = n;
            break;

        case 10:
            /* -fintrinsics=<xx> : Intrinsic name or ALL */
            cobc_deciph_funcs (cob_optarg);
            break;

        case 'A':
            /* -A <xx> : Add options to C compile phase */
            COBC_ADD_STR (cobc_cflags, " ", cob_optarg, NULL);
            aflag_set = 1;
            break;

        case 'Q':
            /* -Q <xx> : Add options to C link phase */
            COBC_ADD_STR (cobc_ldflags, " ", cob_optarg, NULL);
            break;

        case 'w':
            /* -w(xx) : Turn off warnings */
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
#define CB_WARNDEF(var,name,doc)    var = 0;
#define CB_NOWARNDEF(var,name,doc)  var = 0;
#include "warning.def"
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
            break;

        case 'W':
            /* -W : Turn on warnings */
            warningopt = 1;
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
#define CB_WARNDEF(var,name,doc)    var = 1;
#define CB_NOWARNDEF(var,name,doc)
#include "warning.def"
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
            break;

        case 'Z':
            /* -W : Turn on all warnings */
            warningopt = 1;
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
#define CB_WARNDEF(var,name,doc)    var = 1;
#define CB_NOWARNDEF(var,name,doc)  var = 1;
#include "warning.def"
#undef  CB_WARNDEF
#undef  CB_NOWARNDEF
            break;

        default:
            cobc_err_exit (_("Invalid option detected"));
        }
    }

    /* Exit for configuration errors resulting from -cb_conf */
    if (conf_ret != 0) {
        cobc_free_mem ();
        exit (1);
    }

    if (list_reserved) {
        cb_list_reserved ();
        cobc_free_mem ();
        exit (0);
    }
    
    /* debug: Turn on all exception conditions */
    if (cobc_wants_debug) {
        for (i = (enum cob_exception_id)1; i < COB_EC_MAX; ++i) {
            CB_EXCEPTION_ENABLE (i) = 1;
        }
        if (verbose_output > 1) {
            fputs (_("All runtime checks are enabled"), stderr);
            fputc ('\n', stderr);
        }
    }

    /* If C debug, do not strip output */
    if (gflag_set) {
        strip_output = 0;
    }

    if (cb_flag_traceall) {
        cb_flag_trace = 1;
        cb_flag_source_location = 1;
    }

    return cob_optind;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_compile ( struct filename *  fn )

static

Definition at line 3560 of file cobc.c.

References cobc_buffer, cobc_cc, cobc_cc_len, cobc_cflags, cobc_cflags_len, cobc_chk_buff_size(), cobc_include, cobc_include_len, file_basename(), gflag_set, output_name, process(), filename::source, filename::translate, filename::translate_len, and verbose_output.

Referenced by main().

{
    char    *name;
    size_t  bufflen;
    size_t  size;

    if (output_name) {
        name = output_name;
    } else {
        name = file_basename (fn->source);
#ifndef _MSC_VER
        strcat (name, ".s");
#endif
    }
    size = strlen (name);
#ifdef  _MSC_VER
    size *= 2U;
#endif

    bufflen = cobc_cc_len + cobc_cflags_len
            + size + fn->translate_len
            + cobc_include_len + 64U;

    cobc_chk_buff_size (bufflen);

#ifdef  _MSC_VER
    sprintf (cobc_buffer, gflag_set ?
        "%s /c %s %s /Od /MDd /Zi /FR /c /Fa\"%s\" /Fo\"%s\" \"%s\"" :
        "%s /c %s %s /MD /c /Fa\"%s\" /Fo\"%s\" \"%s\"",
            cobc_cc, cobc_cflags, cobc_include, name,
            name, fn->translate);
    if (verbose_output) {
        return process (cobc_buffer);
    } else {
        return process_filtered (cobc_buffer, fn);
    }
#elif defined(__WATCOMC__)
    sprintf (cobc_buffer, "%s -fe=\"%s\" -s %s %s %s", cobc_cc, name,
            cobc_cflags, cobc_include, fn->translate);
    return process (cobc_buffer);
#else
    sprintf (cobc_buffer, "%s -S -o \"%s\" %s %s %s", cobc_cc, name,
            cobc_cflags, cobc_include, fn->translate);
    return process(cobc_buffer);
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

static void process_env_copy_path ( const char *  p )

static

Definition at line 2527 of file cobc.c.

References CB_TEXT_LIST_CHK, cobc_free(), cobc_strdup(), NULL, PATHSEP_STR, and value.

Referenced by main().

{
    char        *value;
    char        *token;
    struct stat st;

    if (p == NULL || !*p || *p == ' ') {
        return;
    }

    /* Clone value for destructive strtok */
    value = cobc_strdup (p);

    /* Tokenize for path sep. */
    token = strtok (value, PATHSEP_STR);
    while (token) {
        if (!stat (token, &st) && (S_ISDIR (st.st_mode))) {
            CB_TEXT_LIST_CHK (cb_include_list, token);
        }
        token = strtok (NULL, PATHSEP_STR);
    }

    cobc_free (value);
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct filename* process_filename ( const char *  filename )

static

Definition at line 2630 of file cobc.c.

References _, cb_compile_level, cb_encode_program_id(), CB_LEVEL_ASSEMBLE, CB_LEVEL_PREPROCESS, CB_LEVEL_TRANSLATE, COB_DASH, COB_DASH_NAME, COB_FILE_MAX, cob_incr_temp_iteration(), COB_NORMAL_MAX, COB_OBJECT_EXT, cob_temp_name(), cobc_abort_pr(), cobc_check_valid_name(), cobc_gen_listing, cobc_list_dir, cobc_list_file, cobc_main_malloc(), cobc_main_strdup(), cobc_objects_len, cobc_seen_stdin, cobc_stradd_dup(), cobc_terminate(), filename::demangle_source, extension, file_basename(), file_extension(), filename::file_is_stdin, filename::listing_file, filename::need_assemble, filename::need_preprocess, filename::need_translate, filename::next, NULL, filename::object, filename::object_len, output_name, filename::preprocess, R_OK, save_all_src, save_c_src, save_temps, SLASH_CHAR, filename::source, filename::translate, filename::translate_len, and filename::trstorage.

Referenced by main().

{
    const char  *extension;
    struct filename *fn;
    struct filename *ffn;
    char        *fbasename;
    char        *listptr;
    size_t      fsize;
    int     file_is_stdin;

    if (strcmp(filename, COB_DASH) == 0) {
        if (cobc_seen_stdin == 0) {
            cobc_seen_stdin = 1;
            file_is_stdin = 1;
            filename = COB_DASH_NAME;
        } else {
            cobc_abort_pr (_("Only one stdin input allowed"));
            return NULL;
        }
    } else {
        file_is_stdin = 0;
    }

    fsize = strlen (filename);
    if (fsize > COB_NORMAL_MAX) {
        cobc_abort_pr (_("Invalid file name parameter"));
        return NULL;
    }

#ifdef  __OS400__
    if (strchr (filename, '.') != NULL) {
#endif

    if (!file_is_stdin && access (filename, R_OK) != 0) {
        cobc_terminate (filename);
    }

#ifdef  __OS400__
    }
#endif

    fbasename = file_basename (filename);
    extension = file_extension (filename);
    if (strcmp(extension, "lib") && strcmp(extension, "a") &&
        strcmp(extension, COB_OBJECT_EXT)) {
        if (cobc_check_valid_name (fbasename, 0)) {
            return NULL;
        }
    }
    fn = cobc_main_malloc (sizeof (struct filename));
    fn->need_preprocess = 1;
    fn->need_translate = 1;
    fn->need_assemble = 1;
    fn->file_is_stdin = file_is_stdin;
    fn->next = NULL;

    if (!file_list) {
        file_list = fn;
    } else {
        for (ffn = file_list; ffn->next; ffn = ffn->next)
            ;
        ffn->next = fn;
    }

    fn->demangle_source = cb_encode_program_id (fbasename);

    /* Check input file type */
    if (strcmp (extension, "i") == 0) {
        /* Already preprocessed */
        fn->need_preprocess = 0;
    } else if (strcmp (extension, "c") == 0 ||
           strcmp (extension, "s") == 0) {
        /* Already compiled */
        fn->need_preprocess = 0;
        fn->need_translate = 0;
    }
    else if (
#if defined(__OS400__)
            extension[0] == 0
#else   
            strcmp (extension, COB_OBJECT_EXT) == 0
#if defined(_WIN32)
            || strcmp(extension, "lib") == 0
#endif
#if !defined(_WIN32) || defined(__MINGW32__) || defined(__MINGW64__)
            || strcmp(extension, "a") == 0
            || strcmp(extension, "so") == 0
            || strcmp(extension, "dylib") == 0
            || strcmp(extension, "sl") == 0
#endif
#endif
    ) {
        /* Already assembled */
        fn->need_preprocess = 0;
        fn->need_translate = 0;
        fn->need_assemble = 0;
    }

    /* Set source filename */
    fn->source = cobc_main_strdup (filename);

    /* Set preprocess filename */
    if (!fn->need_preprocess) {
        fn->preprocess = cobc_main_strdup (fn->source);
    } else if (output_name && cb_compile_level == CB_LEVEL_PREPROCESS) {
        fn->preprocess = cobc_main_strdup (output_name);
    } else if (save_all_src || save_temps ||
           cb_compile_level == CB_LEVEL_PREPROCESS) {
        fn->preprocess = cobc_stradd_dup (fbasename, ".i");
    } else {
        fn->preprocess = cobc_main_malloc(COB_FILE_MAX);
        cob_temp_name ((char *)fn->preprocess, ".cob");
    }

    /* Set translate filename */
    if (!fn->need_translate) {
        fn->translate = cobc_main_strdup (fn->source);
    } else if (output_name && cb_compile_level == CB_LEVEL_TRANSLATE) {
        fn->translate = cobc_main_strdup (output_name);
    } else if (save_all_src || save_temps || save_c_src ||
           cb_compile_level == CB_LEVEL_TRANSLATE) {
        fn->translate = cobc_stradd_dup (fbasename, ".c");
    } else {
        fn->translate = cobc_main_malloc(COB_FILE_MAX);
        cob_temp_name ((char *)fn->translate, ".c");
    }
    fn->translate_len = strlen (fn->translate);

    /* Set storage filename */
    if (fn->need_translate) {
        fn->trstorage = cobc_stradd_dup (fn->translate, ".h");
    }

    /* Set object filename */
    if (!fn->need_assemble) {
        fn->object = cobc_main_strdup (fn->source);
    } else if (output_name && cb_compile_level == CB_LEVEL_ASSEMBLE) {
        fn->object = cobc_main_strdup (output_name);
    } else if (save_temps || cb_compile_level == CB_LEVEL_ASSEMBLE) {
        fn->object = cobc_stradd_dup(fbasename, "." COB_OBJECT_EXT);
    } else {
        fn->object = cobc_main_malloc(COB_FILE_MAX);
        cob_temp_name ((char *)fn->object, "." COB_OBJECT_EXT);
    }
    fn->object_len = strlen (fn->object);
    cobc_objects_len += fn->object_len + 8U;

    /* Set listing filename */
    if (cobc_gen_listing == 1) {
        if (cobc_list_file) {
            fn->listing_file = cobc_list_file;
        } else if (cobc_list_dir) {
            fsize = strlen (cobc_list_dir) + strlen (fbasename) + 8U;
            listptr = cobc_main_malloc (fsize);
            snprintf (listptr, fsize, "%s%c%s.lst",
                  cobc_list_dir, SLASH_CHAR, fbasename);
            fn->listing_file = listptr;
        } else {
            fn->listing_file = cobc_stradd_dup (fbasename, ".lst");
        }
    } else if (cobc_gen_listing > 1) {
        fn->listing_file = cobc_stradd_dup (fbasename, ".xrf");
    }

    cob_incr_temp_iteration();
    return fn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_library ( struct filename *  l )

static

Definition at line 3913 of file cobc.c.

References _, COB_EXPORT_DYN, COB_MODULE_EXT, COB_PIC_FLAGS, COB_SHARED_OPT, COB_STRIP_CMD, COBC_ABORT, cobc_abort_pr(), cobc_buffer, cobc_cc, cobc_cc_len, cobc_check_action(), cobc_chk_buff_size(), cobc_export_dyn_len, cobc_flag_run, cobc_ldflags, cobc_ldflags_len, cobc_lib_paths, cobc_lib_paths_len, cobc_libs, cobc_libs_len, cobc_objects_buffer, cobc_objects_len, cobc_pic_flags_len, cobc_shared_opt_len, cobc_stradd_dup(), file_basename(), gflag_set, filename::next, NULL, filename::object, output_name, output_name_buff, process(), process_run(), filename::source, strip_output, and verbose_output.

Referenced by main().

{
    struct filename *f;
    char        *name;
#ifdef  _MSC_VER
    char    *exename;
#endif
    size_t      bufflen;
    size_t      size;
    int     ret;

    if (!l) {
        cobc_abort_pr (_("Call to '%s' with invalid parameter '%s'"),
            "process_library", "l");
        COBC_ABORT ();
    }

    for (f = l; f; f = f->next) {
        strcat (cobc_objects_buffer, "\"");
        strcat (cobc_objects_buffer, f->object);
        strcat (cobc_objects_buffer, "\" ");
    }

    if (output_name) {
        name = output_name_buff;
        strcpy (name, output_name);
#if defined(_MSC_VER) || defined(__OS400__) || defined(__WATCOMC__) || defined(__BORLANDC__)
        file_stripext (name);
#else
        if (strchr (output_name, '.') == NULL) {
            strcat (name, ".");
            strcat (name, COB_MODULE_EXT);
        }
#endif
    } else {
        name = file_basename (l->source);
#if !defined(_MSC_VER) && !defined(__OS400__) && !defined(__WATCOMC__) && !defined(__BORLANDC__)
        strcat (name, ".");
        strcat (name, COB_MODULE_EXT);
#endif
    }
#ifdef  _MSC_VER
    exename = cobc_stradd_dup (name, ".dll");
#endif

    size = strlen (name);
    bufflen = cobc_cc_len + cobc_ldflags_len
            + cobc_export_dyn_len + cobc_shared_opt_len
            + size + cobc_objects_len + cobc_libs_len
#ifdef  _MSC_VER
            + manilink_len
#endif
            + cobc_lib_paths_len + cobc_pic_flags_len + 64U;

    cobc_chk_buff_size (bufflen);

#ifdef  _MSC_VER
    sprintf (cobc_buffer, gflag_set ?
        "%s /Od /MDd /LDd /Zi /FR /Fe\"%s\" %s %s %s %s %s" :
        "%s     /MD  /LD          /Fe\"%s\" %s %s %s %s %s",
        cobc_cc, exename, cobc_objects_buffer,
        manilink, cobc_ldflags, cobc_libs, cobc_lib_paths);
    if (verbose_output) {
        ret = process (cobc_buffer);
    } else {
        ret = process_filtered (cobc_buffer, l);
    }
#if defined(_MSC_VER) && COB_USE_VC2005_OR_GREATER
    /* Embedding manifest */
    if (ret == 0) {
        sprintf (cobc_buffer,
             "%s /manifest \"%s.manifest\" /outputresource:\"%s\";#2",
             manicmd, exename, exename);
        ret = process (cobc_buffer);
        sprintf (cobc_buffer, "%s.manifest", exename);
        cobc_check_action (cobc_buffer);
    }
#endif
    sprintf (cobc_buffer, "%s.exp", name);
    cobc_check_action (cobc_buffer);
    sprintf (cobc_buffer, "%s.lib", name);

    for (f = l; f; f = f->next) {
        if (strstr (f->source, cobc_buffer) != NULL) {
            break;
        }
    }
    if (!f) cobc_check_action (cobc_buffer);
#else   /* _MSC_VER */
#ifdef  __WATCOMC__
    sprintf (cobc_buffer, "%s %s %s %s -fe=\"%s\" %s %s %s %s",
         cobc_cc, COB_SHARED_OPT, COB_PIC_FLAGS,
         COB_EXPORT_DYN, name, cobc_objects_buffer,
         cobc_ldflags, cobc_libs, cobc_lib_paths);
#else
    sprintf (cobc_buffer, "%s %s %s %s -o \"%s\" %s %s %s %s",
         cobc_cc, COB_SHARED_OPT, COB_PIC_FLAGS,
         COB_EXPORT_DYN, name, cobc_objects_buffer,
         cobc_ldflags, cobc_libs, cobc_lib_paths);
#endif
    ret = process (cobc_buffer);
#ifdef  COB_STRIP_CMD
    if (strip_output && ret == 0) {
        sprintf (cobc_buffer, "%s \"%s\"", COB_STRIP_CMD, name);
        ret = process (cobc_buffer);
    }
#endif
#endif  /* _MSC_VER */
    /* cobcrun job? */
    if ((ret == 0) && cobc_flag_run) {
        ret = process_run (name);
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_link ( struct filename *  l )

static

Definition at line 4031 of file cobc.c.

References _, COB_DASH_OUT, COB_EXEEXT, COB_EXPORT_DYN, COB_STRIP_CMD, COBC_ABORT, cobc_abort_pr(), cobc_buffer, cobc_cc, cobc_cc_len, cobc_check_action(), cobc_chk_buff_size(), cobc_export_dyn_len, cobc_flag_run, cobc_ldflags, cobc_ldflags_len, cobc_lib_paths, cobc_lib_paths_len, cobc_libs, cobc_libs_len, cobc_main_strdup(), cobc_objects_buffer, cobc_objects_len, cobc_stradd_dup(), file_basename(), filename::file_is_stdin, gflag_set, filename::next, filename::object, output_name, process(), process_run(), filename::source, strip_output, and verbose_output.

Referenced by main().

{
    struct filename *f;
    const char      *name;
#ifdef  _MSC_VER
    const char      *exename;
#endif
    size_t      bufflen;
    size_t      size;
    int     ret;

    if (!l) {
        cobc_abort_pr (_("Call to '%s' with invalid parameter '%s'"),
            "process_link", "l");
        COBC_ABORT ();
    }

    for (f = l; f; f = f->next) {
#ifdef  __OS400__
        file_stripext ((char *) f->object);
        strcat (cobc_objects_buffer, f->object);
        strcat (cobc_objects_buffer, " ");
#else
        strcat (cobc_objects_buffer, "\"");
        strcat (cobc_objects_buffer, f->object);
        strcat (cobc_objects_buffer, "\" ");
#endif
    }

    if (output_name) {
#if defined(_MSC_VER) || defined(__OS400__) || defined(__WATCOMC__) || defined(__BORLANDC__)
        name = cobc_main_strdup (output_name);
        file_stripext ((char *)name);
#else
        name = output_name;
#endif
    } else {
        if (l->file_is_stdin) {
            name = COB_DASH_OUT;
        } else {
            name = file_basename (l->source);
        }
    }
#ifdef  _MSC_VER
    exename = cobc_stradd_dup (name, ".exe");
#endif
    
    size = strlen (name);
    bufflen = cobc_cc_len + cobc_ldflags_len
            + cobc_export_dyn_len + size
            + cobc_objects_len + cobc_libs_len
#ifdef  _MSC_VER
            + manilink_len
#endif
            + cobc_lib_paths_len + 64U;

    cobc_chk_buff_size (bufflen);

#ifdef  _MSC_VER
    sprintf (cobc_buffer, gflag_set ?
        "%s /Od /MDd /Zi /FR /Fe\"%s\" %s %s %s %s %s" :
        "%s     /MD          /Fe\"%s\" %s %s %s %s %s",
        cobc_cc, exename, cobc_objects_buffer,
        manilink, cobc_ldflags, cobc_libs, cobc_lib_paths);
    if (verbose_output) {
        ret = process (cobc_buffer);
    } else {
        ret = process_filtered (cobc_buffer, l);
    }
#if defined(_MSC_VER) && COB_USE_VC2005_OR_GREATER
    /* Embedding manifest */
    if (ret == 0) {
        sprintf (cobc_buffer,
             "%s /manifest \"%s.manifest\" /outputresource:\"%s\";#1",
             manicmd, exename, exename);
        ret = process (cobc_buffer);
        sprintf (cobc_buffer, "%s.manifest", exename);
        cobc_check_action (cobc_buffer);
    }
#endif
#else   /* _MSC_VER */
#ifdef  __WATCOMC__
    sprintf (cobc_buffer, "%s %s -fe=\"%s\" %s %s %s %s",
         cobc_cc, COB_EXPORT_DYN, name, cobc_objects_buffer,
         cobc_ldflags, cobc_libs, cobc_lib_paths);
#else
    sprintf (cobc_buffer, "%s %s -o \"%s\" %s %s %s %s",
         cobc_cc, COB_EXPORT_DYN, name, cobc_objects_buffer,
         cobc_ldflags, cobc_libs, cobc_lib_paths);
#endif

    ret = process (cobc_buffer);

#ifdef  __hpux
    if (ret == 0) {
        sprintf (cobc_buffer, "chatr -s +s enable \"%s%s\" 1>/dev/null 2>&1",
             name, COB_EXEEXT);
        process (cobc_buffer);
    }
#endif

#ifdef  COB_STRIP_CMD
    if (strip_output && ret == 0) {
        sprintf (cobc_buffer, "%s \"%s%s\"",
             COB_STRIP_CMD, name, COB_EXEEXT);
        ret = process (cobc_buffer);
    }
#endif

#endif  /* _MSC_VER */

    /* run job? */
    if ((ret == 0) && cobc_flag_run) {
        ret = process_run (name);
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_module ( struct filename *  fn )

static

Definition at line 3814 of file cobc.c.

References COB_EXPORT_DYN, COB_MODULE_EXT, COB_PIC_FLAGS, COB_SHARED_OPT, COB_STRIP_CMD, cobc_buffer, cobc_cc, cobc_cc_len, cobc_check_action(), cobc_chk_buff_size(), cobc_export_dyn_len, cobc_flag_run, cobc_ldflags, cobc_ldflags_len, cobc_lib_paths, cobc_lib_paths_len, cobc_libs, cobc_libs_len, cobc_pic_flags_len, cobc_shared_opt_len, cobc_stradd_dup(), file_basename(), gflag_set, NULL, filename::object, filename::object_len, output_name, output_name_buff, process(), process_run(), filename::source, strip_output, and verbose_output.

Referenced by main().

{
    char    *name;
#ifdef  _MSC_VER
    char    *exename;
#endif
    size_t  bufflen;
    size_t  size;
    int ret;

    if (output_name) {
        name = output_name_buff;
        strcpy (name, output_name);
#if defined(_MSC_VER) || defined(__OS400__) || defined(__WATCOMC__) || defined(__BORLANDC__)
        file_stripext (name);
#else
        if (strchr (output_name, '.') == NULL) {
            strcat (name, ".");
            strcat (name, COB_MODULE_EXT);
        }
#endif
    } else {
        name = file_basename (fn->source);
#if !defined(_MSC_VER) && !defined(__OS400__) && !defined(__WATCOMC__) &&! defined(__BORLANDC__)
        strcat (name, ".");
        strcat (name, COB_MODULE_EXT);
#endif
    }
#ifdef  _MSC_VER
    exename = cobc_stradd_dup (name, ".dll");
#endif

    size = strlen (name);
    bufflen = cobc_cc_len + cobc_ldflags_len
            + cobc_export_dyn_len + cobc_shared_opt_len
            + size + fn->object_len + cobc_libs_len
#ifdef  _MSC_VER
            + manilink_len
#endif
            + cobc_lib_paths_len + cobc_pic_flags_len + 128U;

    cobc_chk_buff_size (bufflen);

#ifdef  _MSC_VER
    sprintf (cobc_buffer, gflag_set ?
        "%s /Od /MDd /LDd /Zi /FR /Fe\"%s\" \"%s\" %s %s %s %s" :
        "%s     /MD  /LD          /Fe\"%s\" \"%s\" %s %s %s %s",
        cobc_cc, exename, fn->object,
        manilink, cobc_ldflags, cobc_libs, cobc_lib_paths);
    if (verbose_output) {
        ret = process (cobc_buffer);
    } else {
        ret = process_filtered (cobc_buffer, fn);
    }
#if defined(_MSC_VER) && COB_USE_VC2005_OR_GREATER
    /* Embedding manifest */
    if (ret == 0) {
        sprintf (cobc_buffer,
             "%s /manifest \"%s.manifest\" /outputresource:\"%s\";#2",
             manicmd, exename, exename);
        ret = process (cobc_buffer);
        sprintf (cobc_buffer, "%s.manifest", exename);
        cobc_check_action (cobc_buffer);
    }
#endif
    sprintf (cobc_buffer, "%s.exp", name);
    cobc_check_action (cobc_buffer);
    sprintf (cobc_buffer, "%s.lib", name);
    if (strstr(fn->source, cobc_buffer) == NULL)    cobc_check_action (cobc_buffer);
    sprintf (cobc_buffer, "%s.obj", name);
    if (strstr(fn->source, cobc_buffer) == NULL)    cobc_check_action (cobc_buffer);
#else   /* _MSC_VER */
#ifdef  __WATCOMC__
    sprintf (cobc_buffer, "%s %s %s %s -fe=\"%s\" \"%s\" %s %s %s",
         cobc_cc, COB_SHARED_OPT, COB_PIC_FLAGS, COB_EXPORT_DYN,
         name, fn->object, cobc_ldflags, cobc_libs, cobc_lib_paths);
#else
    sprintf (cobc_buffer, "%s %s %s %s -o \"%s\" \"%s\" %s %s %s",
         cobc_cc, COB_SHARED_OPT, COB_PIC_FLAGS, COB_EXPORT_DYN,
         name, fn->object, cobc_ldflags, cobc_libs, cobc_lib_paths);
#endif
    ret = process (cobc_buffer);
#ifdef  COB_STRIP_CMD
    if (strip_output && ret == 0) {
        sprintf (cobc_buffer, "%s %s", COB_STRIP_CMD, name);
        ret = process (cobc_buffer);
    }
#endif
#endif  /* _MSC_VER */
    /* cobcrun job? */
    if ((ret == 0) && cobc_flag_run) {
        ret = process_run (name);
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_module_direct ( struct filename *  fn )

static

Definition at line 3696 of file cobc.c.

References COB_EXPORT_DYN, COB_LARGE_BUFF, COB_MODULE_EXT, COB_OBJECT_EXT, COB_PIC_FLAGS, COB_SHARED_OPT, COB_STRIP_CMD, cobc_buffer, cobc_cc, cobc_cc_len, cobc_cflags, cobc_cflags_len, cobc_check_action(), cobc_chk_buff_size(), cobc_export_dyn_len, cobc_flag_run, cobc_include, cobc_include_len, cobc_ldflags, cobc_ldflags_len, cobc_lib_paths, cobc_lib_paths_len, cobc_libs, cobc_libs_len, cobc_main_malloc(), cobc_pic_flags_len, cobc_shared_opt_len, cobc_stradd_dup(), file_basename(), gflag_set, NULL, output_name, output_name_buff, process(), process_run(), filename::source, strip_output, filename::translate, filename::translate_len, and verbose_output.

Referenced by main().

{
    char    *name;
#ifdef  _MSC_VER
    char    *exename;
#endif
    size_t  bufflen;
    size_t  size;
    int ret;

    if (output_name) {
        name = output_name_buff;
        strcpy (name, output_name);
#if defined(_MSC_VER) || defined(__OS400__) || defined(__WATCOMC__) || defined(__BORLANDC__)
        file_stripext (name);
#else
        if (strchr (output_name, '.') == NULL) {
            strcat (name, ".");
            strcat (name, COB_MODULE_EXT);
        }
#endif
    } else {
        name = file_basename (fn->source);
#if !defined(_MSC_VER) && !defined(__OS400__) && !defined(__WATCOMC__) && !defined(__BORLANDC__)
        strcat (name, ".");
        strcat (name, COB_MODULE_EXT);
#endif
    }
#ifdef  _MSC_VER
    exename = cobc_stradd_dup (name, ".dll");
#endif

    size = strlen (name);
#ifdef  _MSC_VER
    size *= 2U;
#endif

    bufflen = cobc_cc_len + cobc_cflags_len
            + cobc_export_dyn_len + cobc_shared_opt_len
            + size + fn->translate_len
            + cobc_libs_len + cobc_ldflags_len + cobc_include_len
#ifdef  _MSC_VER
            + manilink_len
#endif
            + cobc_lib_paths_len + cobc_pic_flags_len + 128U;

    cobc_chk_buff_size (bufflen);

#ifdef  _MSC_VER
    sprintf (cobc_buffer, gflag_set ?
        "%s %s %s /Od /MDd /LDd /Zi /FR /Fe\"%s\" /Fo\"%s\" \"%s\" %s %s %s %s" :
        "%s %s %s     /MD  /LD          /Fe\"%s\" /Fo\"%s\" \"%s\" %s %s %s %s",
            cobc_cc, cobc_cflags, cobc_include, exename, name,
            fn->translate,
            manilink, cobc_ldflags, cobc_libs, cobc_lib_paths);
    if (verbose_output) {
        ret = process (cobc_buffer);
    } else {
        ret = process_filtered (cobc_buffer, fn);
    }
#if defined(_MSC_VER) && COB_USE_VC2005_OR_GREATER
    /* Embedding manifest */
    if (ret == 0) {
        sprintf (cobc_buffer,
             "%s /manifest \"%s.manifest\" /outputresource:\"%s\";#2",
             manicmd, exename, exename);
        ret = process (cobc_buffer);
        sprintf (cobc_buffer, "%s.manifest", exename);
        cobc_check_action (cobc_buffer);
    }
#endif
    sprintf (cobc_buffer, "%s.exp", name);
    cobc_check_action (cobc_buffer);
    sprintf (cobc_buffer, "%s.lib", name);
    if (strstr(fn->source, cobc_buffer) == NULL)    cobc_check_action (cobc_buffer);
    sprintf (cobc_buffer, "%s.%s", name, COB_OBJECT_EXT);
    if (strstr(fn->source, cobc_buffer) == NULL)    cobc_check_action (cobc_buffer);
#else   /* _MSC_VER */
#ifdef  __OS400__
    if (fn->translate[0] != '/') {
        char    *p;

        p = cobc_main_malloc (COB_LARGE_BUFF);
        getcwd (p, COB_LARGE_BUFF);
        strcat (p, "/");
        strcat (p, fn->translate);
        fn->translate = p;
        fn->translate_len = strlen (p);
    }
#endif
#ifdef  __WATCOMC__
    sprintf (cobc_buffer, "%s %s %s %s %s %s -fe=\"%s\" \"%s\" %s %s %s",
         cobc_cc, cobc_cflags, cobc_include, COB_SHARED_OPT,
         COB_PIC_FLAGS, COB_EXPORT_DYN, name,
         fn->translate, cobc_ldflags, cobc_libs, cobc_lib_paths);
#else
    sprintf (cobc_buffer, "%s %s %s %s %s %s -o \"%s\" \"%s\" %s %s %s",
         cobc_cc, cobc_cflags, cobc_include, COB_SHARED_OPT,
         COB_PIC_FLAGS, COB_EXPORT_DYN, name,
         fn->translate, cobc_ldflags, cobc_libs, cobc_lib_paths);
#endif
    ret = process (cobc_buffer);
#ifdef  COB_STRIP_CMD
    if (strip_output && ret == 0) {
        sprintf (cobc_buffer, "%s \"%s\"", COB_STRIP_CMD, name);
        ret = process (cobc_buffer);
    }
#endif
#endif  /* _MSC_VER */
    if ((ret == 0) && cobc_flag_run) {
        ret = process_run (name);
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_run ( const char *  name )

static

-j run job after build

Definition at line 2836 of file cobc.c.

References _, cb_compile_level, CB_LEVEL_LIBRARY, CB_LEVEL_MODULE, cobc_buffer, cobc_buffer_size, cobc_cmd_print(), file_basename(), SLASH_CHAR, and verbose_output.

Referenced by process_assemble(), process_library(), process_link(), process_module(), and process_module_direct().

                               {
    int ret;

    if (cb_compile_level < CB_LEVEL_MODULE) {
        fputs (_("Nothing for -j to run"), stderr);
        fflush (stderr);
        return 0;
    }

    if (cb_compile_level == CB_LEVEL_MODULE ||
        cb_compile_level == CB_LEVEL_LIBRARY) {
        snprintf (cobc_buffer, cobc_buffer_size, "cobcrun %s",
            file_basename(name));
    } else {  /* executable */
        snprintf (cobc_buffer, cobc_buffer_size, ".%c%s",
            SLASH_CHAR, name);
    }
    cobc_buffer[cobc_buffer_size] = 0;
    if (verbose_output) {
        cobc_cmd_print (cobc_buffer);
    }
    ret = system (cobc_buffer);
    if (verbose_output) {
        fputs (_("Return status:"), stderr);
        fprintf (stderr, "\t%d\n", ret);
        fflush (stderr);
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int process_translate ( struct filename *  fn )

static

Definition at line 3397 of file cobc.c.

References _, cb_init_constants(), cb_insert_common_prog(), cb_list_reverse(), cb_source_file, cb_source_line, cb_storage_file, cb_storage_file_name, COB_OPEN_EXTEND, COB_OPEN_INPUT, cobc_main_malloc(), cobc_terminate(), codegen(), cb_program::common_prog_list, current_program, cb_program::entry_list, errorcount, cb_label::flag_global, cb_program::global_file_list, cb_program::global_handler, handler_struct::handler_label, handler_struct::handler_prog, local_filename::local_fp, cb_program::local_include, local_filename::local_name, filename::localfile, cb_program::nested_level, nested_list::nested_prog, local_filename::next, nested_list::next, cb_program::next_program, NULL, filename::preprocess, program_list_reverse(), filename::source, filename::translate, filename::translate_len, filename::trstorage, unlikely, verbose_output, ylex_call_destroy(), yyin, yyout, and yyparse.

Referenced by main().

{
    struct cb_program   *p;
    struct cb_program   *q;
    struct cb_program   *r;
    struct nested_list  *nlp;
    struct handler_struct   *hstr1;
    struct handler_struct   *hstr2;
    struct local_filename   *lf;
    int         ret;
    int         i;

    /* Initialize */
    cb_source_file = NULL;
    cb_source_line = 0;
    errorcount = 0;

    /* Open the input file */
    yyin = fopen (fn->preprocess, "r");
    if (!yyin) {
        cobc_terminate (fn->preprocess);
    }

    if (verbose_output) {
        fputs (_("Parsing:"), stderr);
        fprintf (stderr, "\t%s (%s)\n", fn->preprocess, fn->source);
        fflush (stderr);
    }

    current_program = NULL;
    cb_init_constants ();

    /* Parse */
    ret = yyparse ();

    fclose (yyin);
    yyin = NULL;

    /* Release flex buffers - After file close */
    ylex_call_destroy ();

    if (verbose_output) {
        fputs (_("Return status:"), stderr);
        fprintf (stderr, "\t%d\n", ret);
        fflush (stderr);
    }

    if (ret || cb_flag_syntax_only) {
        return !!ret;
    }
    if (current_program && current_program->entry_list == NULL) {
        return 0;
    }

    /* Set up USE GLOBAL handlers */
    p = current_program;
    for (q = p; q; q = q->next_program) {
        q->global_file_list = cb_list_reverse (q->global_file_list);
        if (q->nested_level) {
            for (r = q->next_program; r; r = r->next_program) {
                if (r->nested_level >= q->nested_level) {
                    continue;
                }
                for (i = COB_OPEN_INPUT; i <= COB_OPEN_EXTEND; ++i) {
                    hstr1 = &q->global_handler[i];
                    hstr2 = &r->global_handler[i];
                    if (!hstr1->handler_label &&
                        hstr2->handler_label &&
                        hstr2->handler_label->flag_global) {
                        hstr1->handler_label = hstr2->handler_label;
                        hstr1->handler_prog = r;
                    }
                }
                if (!r->nested_level) {
                    break;
                }
            }
        }
    }

    if (verbose_output) {
        fputs (_("Translating:"), stderr);
        fprintf (stderr, "\t%s -> %s (%s)\n",
             fn->preprocess, fn->translate, fn->source);
        fflush (stderr);
    }

    /* Open the output file */
    yyout = fopen (fn->translate, "w");
    if (!yyout) {
        cobc_terminate (fn->translate);
    }

    /* Open the common storage file */
    cb_storage_file_name = fn->trstorage;
    cb_storage_file = fopen (cb_storage_file_name, "w");
    if (!cb_storage_file) {
        cobc_terminate (cb_storage_file_name);
    }

    p = program_list_reverse (current_program);

    /* Set up local storage files */
    lf = NULL;
    ret = 1;
    for (q = p; q; q = q->next_program, ret++) {
        lf = cobc_main_malloc (sizeof(struct local_filename));
        lf->local_name = cobc_main_malloc (fn->translate_len + 12U);
        if (q == p && !q->next_program) {
            sprintf (lf->local_name, "%s.l.h", fn->translate);
        } else {
            sprintf (lf->local_name, "%s.l%d.h", fn->translate, ret);
        }
        lf->local_fp = fopen (lf->local_name, "w");
        if (!lf->local_fp) {
            cobc_terminate (lf->local_name);
        }
        q->local_include = lf;
        lf->next = fn->localfile;
        fn->localfile = lf;
    }

    /* Entries for COMMON programs */
    for (q = p; q; q = q->next_program) {
        i = q->nested_level;
        for (nlp = q->common_prog_list; nlp; nlp = nlp->next) {
            for (r = q->next_program; r; r = r->next_program) {
                if (r->nested_level <= i) {
                    break;
                }
                cb_insert_common_prog (r, nlp->nested_prog);
            }
        }
    }

    errorcount = 0;
    /* Translate to C */
    codegen (p, 0);

    /* Close files */
    if(unlikely(fclose (cb_storage_file) != 0)) {
        cobc_terminate (cb_storage_file_name);
    }
    cb_storage_file = NULL;
    if(unlikely(fclose (yyout) != 0)) {
        cobc_terminate (fn->translate);
    }
    yyout = NULL;
    for (q = p; q; q = q->next_program) {
        if (unlikely(!q->local_include->local_fp)) {
            continue;
        }
        if (unlikely(fclose (q->local_include->local_fp) != 0)) {
            cobc_terminate(lf->local_name);
        }
        q->local_include->local_fp = NULL;
    }
    return !!errorcount;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct cb_program* program_list_reverse ( struct cb_program *  p )

static

Definition at line 2512 of file cobc.c.

References cb_program::next_program, and NULL.

Referenced by process_translate().

{
    struct cb_program   *next;
    struct cb_program   *last;

    last = NULL;
    for (; p; p = next) {
        next = p->next_program;
        p->next_program = last;
        last = p;
    }
    return last;
}

Here is the caller graph for this function:

Variable Documentation

size_t aflag_set = 0

static

Definition at line 290 of file cobc.c.

Referenced by main(), and process_command_line().

struct strcache* base_string

static

Definition at line 248 of file cobc.c.

Referenced by cobc_check_string().

char* basename_buffer

static

Definition at line 257 of file cobc.c.

Referenced by file_basename(), and main().

size_t basename_len

static

Definition at line 260 of file cobc.c.

Referenced by file_basename(), and main().

int cb_attr_id = 0

Definition at line 164 of file cobc.c.

Referenced by lookup_attr(), and main().

unsigned int cb_compile_level = 0

static

Definition at line 265 of file cobc.c.

Referenced by cobc_clean_up(), main(), process_assemble(), process_command_line(), process_filename(), and process_run().

struct cb_define_struct* cb_define_list = ((void*)0)

static

Definition at line 218 of file cobc.c.

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

Definition at line 153 of file cobc.c.

Referenced by output_call().

struct cb_exception cb_exception_table[]

Definition at line 186 of file cobc.c.

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

Definition at line 151 of file cobc.c.

Referenced by ppcopy().

int cb_field_id = 0

Definition at line 166 of file cobc.c.

Referenced by cb_build_field(), and main().

int cb_flag_functions_all = 0

Definition at line 170 of file cobc.c.

Referenced by cb_build_program(), and cobc_deciph_funcs().

int cb_flag_main = 0

Definition at line 168 of file cobc.c.

Referenced by process_command_line().

int cb_id = 0

Definition at line 163 of file cobc.c.

Referenced by cb_build_label(), cb_emit_evaluate(), main(), output_perform_call(), output_stmt(), and yyparse().

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

Definition at line 149 of file cobc.c.

Referenced by ppcopy().

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

Definition at line 150 of file cobc.c.

Referenced by yylex().

FILE* cb_listing_file = ((void*)0)

Definition at line 157 of file cobc.c.

Referenced by check_listing(), cobc_clean_up(), main(), ppecho(), and preprocess().

int cb_literal_id = 0

Definition at line 165 of file cobc.c.

Referenced by lookup_literal(), and main().

char* cb_oc_build_stamp = ((void*)0)

Definition at line 146 of file cobc.c.

Referenced by cobc_print_version(), main(), and output_header().

int cb_saveargc = 0

Definition at line 179 of file cobc.c.

Referenced by main(), and output_header().

char** cb_saveargv = ((void*)0)

Definition at line 154 of file cobc.c.

Referenced by main(), and output_header().

const char* cb_source_file = ((void*)0)

Definition at line 145 of file cobc.c.

Referenced by begin_statement(), cb_build_alphanumeric_literal(), cb_build_comment(), cb_build_debug(), cb_build_debug_call(), cb_build_numeric_literal(), cb_build_numsize_literal(), cb_build_reference(), cb_expr_finish(), cobc_abort_terminate(), codegen(), emit_entry(), main(), output_header(), ppopen(), print_error(), process_translate(), switch_to_buffer(), yylex(), and yyparse().

int cb_source_format = 0

Definition at line 162 of file cobc.c.

Referenced by check_listing(), ppinput(), pplex(), ppopen(), ppparse(), preprocess(), and process_command_line().

int cb_source_line = 0

Definition at line 178 of file cobc.c.

Referenced by begin_statement(), cb_build_alphanumeric_literal(), cb_build_comment(), cb_build_debug(), cb_build_debug_call(), cb_build_filler(), cb_build_numeric_literal(), cb_build_numsize_literal(), cb_build_reference(), cb_plex_error(), cb_plex_warning(), cobc_abort_terminate(), count_lines(), emit_entry(), plex_action_directive(), pplex(), ppopen(), print_error(), process_translate(), switch_to_buffer(), yylex(), and yyparse().

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

Definition at line 152 of file cobc.c.

Referenced by output_call().

FILE* cb_storage_file = ((void*)0)

Definition at line 156 of file cobc.c.

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

const char* cb_storage_file_name = ((void*)0)

Definition at line 148 of file cobc.c.

Referenced by codegen(), and process_translate().

const char* cob_config_dir = ((void*)0)

Definition at line 155 of file cobc.c.

Referenced by cb_load_conf(), cb_load_conf_file(), and main().

const char* const cob_csyns[]

static

Definition at line 292 of file cobc.c.

Referenced by cobc_check_valid_name().

size_t cob_optimize = 0

static

Definition at line 277 of file cobc.c.

Referenced by main(), and process_command_line().

char* cobc_buffer

static

Definition at line 254 of file cobc.c.

Referenced by cobc_chk_buff_size(), cobc_clean_up(), main(), preprocess(), process_assemble(), process_compile(), process_library(), process_link(), process_module(), process_module_direct(), and process_run().

size_t cobc_buffer_size

static

Definition at line 261 of file cobc.c.

Referenced by cobc_chk_buff_size(), cobc_clean_up(), main(), preprocess(), and process_run().

const char* cobc_cc

static

Definition at line 224 of file cobc.c.

Referenced by main(), process_assemble(), process_compile(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_cc_len

static

Definition at line 237 of file cobc.c.

Referenced by main(), process_assemble(), process_compile(), process_library(), process_link(), process_module(), and process_module_direct().

char* cobc_cflags

static

Definition at line 225 of file cobc.c.

Referenced by main(), process_assemble(), process_command_line(), process_compile(), and process_module_direct().

size_t cobc_cflags_len

static

Definition at line 238 of file cobc.c.

Referenced by main(), process_assemble(), process_compile(), and process_module_direct().

size_t cobc_cflags_size

static

Definition at line 231 of file cobc.c.

Referenced by main().

size_t cobc_export_dyn_len

static

Definition at line 243 of file cobc.c.

Referenced by main(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_flag_library = 0

static

Definition at line 271 of file cobc.c.

Referenced by main(), and process_command_line().

int cobc_flag_main = 0

Definition at line 167 of file cobc.c.

Referenced by codegen(), main(), output_internal_function(), output_module_init(), process_command_line(), set_up_program(), and yyparse().

size_t cobc_flag_module = 0

static

Definition at line 270 of file cobc.c.

Referenced by main(), and process_command_line().

size_t cobc_flag_run = 0

static

Definition at line 272 of file cobc.c.

Referenced by process_assemble(), process_command_line(), process_library(), process_link(), process_module(), and process_module_direct().

unsigned int cobc_gen_listing = 0

Definition at line 180 of file cobc.c.

Referenced by check_listing(), preprocess(), process_command_line(), and process_filename().

char* cobc_include

static

Definition at line 228 of file cobc.c.

Referenced by main(), process_assemble(), process_command_line(), process_compile(), and process_module_direct().

size_t cobc_include_len

static

Definition at line 241 of file cobc.c.

Referenced by main(), process_assemble(), process_compile(), and process_module_direct().

size_t cobc_include_size

static

Definition at line 234 of file cobc.c.

Referenced by main().

char* cobc_ldflags

static

Definition at line 229 of file cobc.c.

Referenced by main(), process_command_line(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_ldflags_len

static

Definition at line 242 of file cobc.c.

Referenced by main(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_ldflags_size

static

Definition at line 235 of file cobc.c.

Referenced by main().

char* cobc_lib_paths

static

Definition at line 227 of file cobc.c.

Referenced by main(), process_command_line(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_lib_paths_len

static

Definition at line 240 of file cobc.c.

Referenced by main(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_lib_paths_size

static

Definition at line 233 of file cobc.c.

Referenced by main().

char* cobc_libs

static

Definition at line 226 of file cobc.c.

Referenced by main(), process_command_line(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_libs_len

static

Definition at line 239 of file cobc.c.

Referenced by main(), process_library(), process_link(), process_module(), and process_module_direct().

size_t cobc_libs_size

static

Definition at line 232 of file cobc.c.

Referenced by main().

char* cobc_list_dir

static

Definition at line 250 of file cobc.c.

Referenced by cobc_free_mem(), process_command_line(), and process_filename().

char* cobc_list_file

static

Definition at line 251 of file cobc.c.

Referenced by cobc_free_mem(), main(), preprocess(), process_command_line(), and process_filename().

struct cobc_mem_struct* cobc_mainmem_base = ((void*)0)

static

Definition at line 220 of file cobc.c.

Referenced by cobc_main_malloc().

char* cobc_objects_buffer

static

Definition at line 255 of file cobc.c.

Referenced by main(), process_library(), and process_link().

size_t cobc_objects_len

static

Definition at line 259 of file cobc.c.

Referenced by main(), process_filename(), process_library(), and process_link().

struct cobc_mem_struct* cobc_parsemem_base = ((void*)0)

static

Definition at line 221 of file cobc.c.

Referenced by cobc_parse_malloc().

size_t cobc_pic_flags_len

static

Definition at line 245 of file cobc.c.

Referenced by main(), process_assemble(), process_library(), process_module(), and process_module_direct().

struct cobc_mem_struct* cobc_plexmem_base = ((void*)0)

static

Definition at line 222 of file cobc.c.

Referenced by cobc_plex_malloc().

int cobc_seen_stdin = 0

Definition at line 171 of file cobc.c.

Referenced by process_filename().

size_t cobc_shared_opt_len

static

Definition at line 244 of file cobc.c.

Referenced by main(), process_library(), process_module(), and process_module_direct().

int cobc_wants_debug = 0

Definition at line 169 of file cobc.c.

Referenced by main(), and process_command_line().

const char* demangle_name = ((void*)0)

Definition at line 147 of file cobc.c.

Referenced by main(), and yyparse().

int errorcount = 0

Definition at line 173 of file cobc.c.

Referenced by cb_error(), cb_error_x(), cb_plex_error(), ppopen(), preprocess(), process_translate(), and yyparse().

int exit_option = 0

Definition at line 175 of file cobc.c.

Referenced by process_command_line().

struct filename* file_list

static

Definition at line 263 of file cobc.c.

size_t gflag_set = 0

static

Definition at line 289 of file cobc.c.

Referenced by main(), process_assemble(), process_command_line(), process_compile(), process_library(), process_link(), process_module(), and process_module_direct().

int iargs

static

Definition at line 267 of file cobc.c.

Referenced by main().

const struct option long_options[]

static

Definition at line 396 of file cobc.c.

int no_physical_cancel = 0

Definition at line 177 of file cobc.c.

Referenced by output_module_init(), and process_command_line().

cob_u32_t optimize_defs[COB_OPTIM_MAX] = { 0 }

Definition at line 182 of file cobc.c.

Referenced by cb_build_add(), cb_build_move_literal(), cb_build_optim_add(), cb_build_optim_cond(), cb_build_optim_sub(), cb_build_sub(), codegen(), main(), output_integer(), and output_internal_function().

char* output_name

static

Definition at line 253 of file cobc.c.

Referenced by main(), process_command_line(), process_compile(), process_filename(), process_library(), process_link(), process_module(), and process_module_direct().

char* output_name_buff

static

Definition at line 256 of file cobc.c.

Referenced by process_command_line(), process_library(), process_module(), and process_module_direct().

size_t save_all_src = 0

static

Definition at line 274 of file cobc.c.

Referenced by cobc_clean_up(), process_command_line(), and process_filename().

size_t save_c_src = 0

static

Definition at line 275 of file cobc.c.

Referenced by cobc_clean_up(), process_command_line(), and process_filename().

size_t save_temps = 0

static

Definition at line 273 of file cobc.c.

Referenced by cobc_check_action(), cobc_clean_up(), process_command_line(), and process_filename().

char* save_temps_dir

static

Definition at line 247 of file cobc.c.

Referenced by cobc_check_action(), cobc_free_mem(), main(), and process_command_line().

const char short_options[] = "hVivECScbmxjdFOPgwo:I:L:l:D:K:k:"

static

Definition at line 390 of file cobc.c.

Referenced by process_command_line().

size_t strip_output = 0

static

Definition at line 288 of file cobc.c.

Referenced by process_command_line(), process_library(), process_link(), process_module(), and process_module_direct().

size_t verbose_output = 0

static

Definition at line 276 of file cobc.c.

Referenced by main(), preprocess(), process(), process_assemble(), process_command_line(), process_compile(), process_library(), process_link(), process_module(), process_module_direct(), process_run(), and process_translate().

size_t wants_nonfinal = 0

static

Definition at line 269 of file cobc.c.

Referenced by main(), and process_command_line().

int warningcount = 0

Definition at line 174 of file cobc.c.

Referenced by cb_plex_warning(), cb_warning(), and cb_warning_x().

int warningopt = 0

Definition at line 176 of file cobc.c.

Referenced by cb_build_assignment_name(), cb_emit_call(), cb_verify(), check_picture_item(), compute_size(), pplex(), process_command_line(), validate_move(), yylex(), and yyparse().

int yydebug