reserved.c File Reference

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

Include dependency graph for reserved.c:

Go to the source code of this file.

Data Structures
struct	system_struct

Macros
#define	SYSTEM_TAB_SIZE   sizeof(system_table) / sizeof(struct system_struct)
#define	EXT_SYSTEM_TAB_SIZE   sizeof(ext_system_table) / sizeof(struct system_struct)
#define	NUM_DEFAULT_RESERVED_WORDS   sizeof (default_reserved_words) / sizeof (struct cobc_reserved)
#define	NUM_INTRINSICS   sizeof(function_list) / sizeof(struct cb_intrinsic_table)

Enumerations
enum	free_word_action { FREE_WORD_STR, DONT_FREE_WORD_STR }

Functions
static int	cob_strcasecmp (const void *s1, const void *s2)
static int	reserve_comp (const void *p1, const void *p2)
static int	intrinsic_comp (const void *p1, const void *p2)
static const char *	res_get_feature (const enum cb_system_name_category category)
static struct cobc_reserved	create_dummy_reserved (const char *word)
static void	delete_reserved_word_from_list (struct reserved_word_list *const prev, const enum free_word_action action, struct reserved_word_list *to_delete)
static COB_INLINE COB_A_INLINE int	has_context_sensitive_indicator (const char *word, const size_t size)
static void	allocate_str_removing_asterisk (const char *word, const size_t size, char **const out_str)
static COB_INLINE COB_A_INLINE void	initialize_word (const char *word, const size_t size, struct reserved_word_list *const reserved)
static void	initialize_alias_for (const char *alias_for, struct reserved_word_list *const reserved, const char *fname, const int line)
static void	add_reserved_word_without_init (const char *word, const char *fname, const int line)
static void	initialize_user_res_list_if_needed (void)
static size_t	get_length_of_user_res_list (void)
static COB_INLINE COB_A_INLINE struct cobc_reserved *	find_default_reserved_word (struct cobc_reserved *to_find)
static struct cobc_reserved	get_user_specified_reserved_word (struct reserved_word_list user_reserved)
static COB_INLINE COB_A_INLINE void	pop_reserved_word (const enum free_word_action action)
static void	get_reserved_words_from_user_list (void)
static void	get_reserved_words_from_default_list (void)
static void	initialize_reserved_words_if_needed (void)
cb_tree	lookup_system_name (const char *name)
void	remove_reserved_word (const char *word)
void	add_reserved_word (const char *word, const char *fname, const int line)
struct cobc_reserved *	lookup_reserved_word (const char *name)
struct cb_intrinsic_table *	lookup_intrinsic (const char *name, const int checkres, const int checkimpl)
void	cb_list_reserved (void)
void	cb_list_intrinsics (void)
void	cb_list_mnemonics (void)
void	cobc_init_reserved (void)

Variables
struct reserved_word_list *	cobc_user_res_list = ((void*)0)
static const struct system_struct	system_table []
static const struct system_struct	ext_system_table []
static struct cobc_reserved *	reserved_words
static struct cobc_reserved	default_reserved_words []
static size_t	num_reserved_words
static const struct cb_intrinsic_table	function_list []
static unsigned char	cob_lower_tab [256]
static const unsigned char	pcob_lower_tab [] = "abcdefghijklmnopqrstuvwxyz"
static const unsigned char	pcob_lower_val [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

Macro Definition Documentation

#define EXT_SYSTEM_TAB_SIZE   sizeof(ext_system_table) / sizeof(struct system_struct)

Definition at line 188 of file reserved.c.

Referenced by cb_list_mnemonics(), and lookup_system_name().

#define NUM_DEFAULT_RESERVED_WORDS   sizeof (default_reserved_words) / sizeof (struct cobc_reserved)

Definition at line 1954 of file reserved.c.

Referenced by find_default_reserved_word(), get_reserved_words_from_default_list(), and initialize_user_res_list_if_needed().

#define NUM_INTRINSICS   sizeof(function_list) / sizeof(struct cb_intrinsic_table)

Definition at line 2490 of file reserved.c.

Referenced by cb_list_intrinsics(), and lookup_intrinsic().

#define SYSTEM_TAB_SIZE   sizeof(system_table) / sizeof(struct system_struct)

Definition at line 114 of file reserved.c.

Referenced by cb_list_mnemonics(), and lookup_system_name().

Enumeration Type Documentation

enum free_word_action

Enumerator
FREE_WORD_STR
DONT_FREE_WORD_STR

Definition at line 2613 of file reserved.c.

                      {
    FREE_WORD_STR,
        DONT_FREE_WORD_STR
};

Function Documentation

void add_reserved_word	(	const char *	word,
		const char *	fname,
		const int	line
	)

Definition at line 2903 of file reserved.c.

References add_reserved_word_without_init(), and initialize_user_res_list_if_needed().

Referenced by cb_config_entry().

{
    initialize_user_res_list_if_needed ();
    add_reserved_word_without_init (word, fname, line);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void add_reserved_word_without_init ( const char *  word, const char *  fname, const int  line  )

static

Definition at line 2683 of file reserved.c.

References reserved_word_list::alias_for, cob_strcasecmp(), cobc_main_malloc(), cobc_user_res_list, has_context_sensitive_indicator(), initialize_alias_for(), initialize_word(), reserved_word_list::is_context_sensitive, reserved_word_list::next, NULL, and reserved_word_list::word.

Referenced by add_reserved_word(), and initialize_user_res_list_if_needed().

{
        struct reserved_word_list   *reserved;
    size_t              size;
    char                *equal_sign_pos;

    /* Check the word has not already been specified */
    for (reserved = cobc_user_res_list; reserved; reserved = reserved->next)
    {
        if (cob_strcasecmp (reserved->word, word) == 0) {
            return;
        }
    }

    /* Find how the length of the word */
    equal_sign_pos = strchr (word, '=');
    if (equal_sign_pos) {
        size = equal_sign_pos - word;
    } else {
        size = strlen (word);
    }

    reserved = cobc_main_malloc (sizeof (struct reserved_word_list));
    reserved->is_context_sensitive
        = has_context_sensitive_indicator (word, size);
    initialize_word (word, size, reserved);

    /* If it is an alias, copy what it is an alias for */
    if (equal_sign_pos) {
        initialize_alias_for (equal_sign_pos + 1, reserved, fname,
                      line);
    } else {
        reserved->alias_for = NULL;
    }

    /* Insert word at beginning of cobc_user_res_list. */
    reserved->next = cobc_user_res_list;
    cobc_user_res_list = reserved;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void allocate_str_removing_asterisk ( const char *  word, const size_t  size, char **const  out_str  )

static

Definition at line 2646 of file reserved.c.

References cobc_main_malloc(), and has_context_sensitive_indicator().

Referenced by initialize_alias_for(), and initialize_word().

{
    size_t  chars_to_copy;

    if (has_context_sensitive_indicator (word, size)) {
        /* Don't copy the trailing asterisk */
        chars_to_copy = size - 1;
    } else {
        chars_to_copy = size;
    }

    *out_str = cobc_main_malloc (chars_to_copy + 1U);
    strncpy (*out_str, word, chars_to_copy);
    (*out_str)[chars_to_copy] = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cb_list_intrinsics

(

void

)

Definition at line 3052 of file reserved.c.

References _, cb_intrinsic_table::args, cob_free(), cob_malloc(), cb_intrinsic_table::implemented, cb_intrinsic_table::min_args, and NUM_INTRINSICS.

Referenced by process_command_line().

{
    const char  *s;
    const char  *t;
    char    *argnum;
    size_t      i;
    size_t      n;

    putchar ('\n');
    puts (_("Intrinsic Function\t\tImplemented\tParameters"));
    for (i = 0; i < NUM_INTRINSICS; ++i) {
        n = strlen (function_list[i].name);
        switch (n / 8) {
        case 0:
            s = "\t\t\t\t";
            break;
        case 1:
            s = "\t\t\t";
            break;
        case 2:
            s = "\t\t";
            break;
        default:
            s = "\t";
            break;
        }
        if (function_list[i].implemented) {
            t = _("Y");
        } else {
            t = _("N");
        }
        if (function_list[i].args == -1) {
            printf ("%s%s%s\t\t%s\n", function_list[i].name, s, t, _("Unlimited"));
        } else {
            if (function_list[i].args != function_list[i].min_args) {
                argnum = cob_malloc (7);
                snprintf (argnum, 7, "%d - %d", (int)function_list[i].min_args,
                    (int)function_list[i].args);
            } else {
                argnum = cob_malloc (3);
                snprintf (argnum, 3, "%d", (int)function_list[i].args);
            }
            printf ("%s%s%s\t\t%s\n", function_list[i].name, s, t, argnum);
            cob_free (argnum);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cb_list_mnemonics

(

void

)

Definition at line 3101 of file reserved.c.

References _, cb_intrinsic_table::category, EXT_SYSTEM_TAB_SIZE, res_get_feature(), and SYSTEM_TAB_SIZE.

Referenced by process_command_line().

{
    const char  *tabs;
    const char  *feature;
    size_t      i;

    putchar ('\n');
    puts (_("Mnemonic names"));
    for (i = 0; i < SYSTEM_TAB_SIZE; ++i) {
        if (strlen (system_table[i].name) < 8) {
            tabs = "\t\t";
        } else {
            tabs = "\t";
        }
        feature = res_get_feature (system_table[i].category);
        printf ("%s%s%s\n", system_table[i].name, tabs, feature);
    }
    putchar ('\n');
    puts (_("Extended mnemonic names (with -fsyntax-extension)"));
    for (i = 0; i < EXT_SYSTEM_TAB_SIZE; ++i) {
        if (strlen (ext_system_table[i].name) < 8) {
            tabs = "\t\t";
        } else {
            tabs = "\t";
        }
        feature = res_get_feature (ext_system_table[i].category);
        printf ("%s%s%s\n", ext_system_table[i].name, tabs, feature);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void cb_list_reserved

(

void

)

Definition at line 2989 of file reserved.c.

References _, initialize_reserved_words_if_needed(), num_reserved_words, and cb_intrinsic_table::token.

Referenced by process_command_line().

{
    const char  *s;
    const char  *p;
    size_t      i;
    size_t      n;

    initialize_reserved_words_if_needed ();

    putchar ('\n');
    printf (_("Reserved Words\t\t\tImplemented (Y/N)"));
    puts ("\n");
    for (i = 0; i < num_reserved_words; ++i) {
        n = strlen (reserved_words[i].name);
        switch (n / 8) {
        case 0:
            s = "\t\t\t\t";
            break;
        case 1:
            s = "\t\t\t";
            break;
        case 2:
            s = "\t\t";
            break;
        default:
            s = "\t";
            break;
        }
        if (reserved_words[i].token > 0) {
            if (reserved_words[i].context_sens) {
                p = _("Y (Context sensitive)");
            } else {
                p = _("Y");
            }
        } else {
            if (reserved_words[i].context_sens) {
                p = _("N (Context sensitive)");
            } else {
                p = _("N");
            }
        }
        printf ("%s%s%s\n", reserved_words[i].name, s, p);
    }
    putchar ('\n');
    puts (_("Extra (obsolete) context sensitive words"));
    puts ("AUTHOR");
    puts ("DATE-COMPILED");
    puts ("DATE-MODIFIED");
    puts ("DATE-WRITTEN");
    puts ("INSTALLATION");
    puts ("REMARKS");
    puts ("SECURITY");
    putchar ('\n');
    puts (_("Extra internal registers\tDefinition"));
    puts ("RETURN-CODE\t\t\tUSAGE BINARY-LONG");
    puts ("SORT-RETURN\t\t\tUSAGE BINARY-LONG");
    puts ("NUMBER-OF-CALL-PARAMETERS\tUSAGE BINARY-LONG");
    puts ("COB-CRT-STATUS\t\t\tPIC 9(4)");
    puts ("TALLY\t\t\t\tGLOBAL PIC 9(5) USAGE BINARY VALUE ZERO");
    puts ("'LENGTH OF' phrase\t\tUSAGE BINARY-LONG");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int cob_strcasecmp ( const void *  s1, const void *  s2  )

static

Definition at line 2530 of file reserved.c.

References cob_lower_tab.

Referenced by add_reserved_word_without_init(), intrinsic_comp(), lookup_system_name(), remove_reserved_word(), and reserve_comp().

{
    const unsigned char *p1;
    const unsigned char *p2;
    unsigned char       c1;
    unsigned char       c2;

    p1 = (const unsigned char *)s1;
    p2 = (const unsigned char *)s2;

    for (;;) {
        if (cob_lower_tab[*p1]) {
            c1 = cob_lower_tab[*p1++];
        } else {
            c1 = *p1++;
        }

        if (cob_lower_tab[*p2]) {
            c2 = cob_lower_tab[*p2++];
        } else {
            c2 = *p2++;
        }

        if (c1 != c2) {
            return c1 < c2 ? -1 : 1;
        }
        if (!c1) {
            break;
        }
    }
    return 0;
}

Here is the caller graph for this function:

void cobc_init_reserved

(

void

)

Definition at line 3133 of file reserved.c.

References cob_lower_tab, pcob_lower_tab, and pcob_lower_val.

Referenced by main().

{
    const unsigned char *p;
    const unsigned char *v;

    memset (cob_lower_tab, 0, sizeof(cob_lower_tab));
    p = pcob_lower_tab;
    v = pcob_lower_val;
    for (; *p; ++p, ++v) {
        cob_lower_tab[*p] = *v;
    }
}

Here is the caller graph for this function:

static struct cobc_reserved create_dummy_reserved ( const char *  word )

static

Definition at line 2599 of file reserved.c.

References cobc_reserved::context_sens, cobc_reserved::context_set, cobc_reserved::context_test, cobc_reserved::name, cobc_reserved::nodegen, and cobc_reserved::token.

Referenced by get_reserved_words_from_user_list(), get_user_specified_reserved_word(), and lookup_reserved_word().

{
    struct cobc_reserved    ret;

    ret.name = word;
    ret.nodegen = 0;
    ret.context_sens = 0;
    ret.token = -1;
    ret.context_set = 0;
    ret.context_test = 0;

    return ret;
}

Here is the caller graph for this function:

static void delete_reserved_word_from_list ( struct reserved_word_list *const  prev, const enum free_word_action  action, struct reserved_word_list *  to_delete  )

static

Definition at line 2619 of file reserved.c.

References reserved_word_list::alias_for, cobc_main_free(), FREE_WORD_STR, reserved_word_list::next, and reserved_word_list::word.

Referenced by pop_reserved_word(), and remove_reserved_word().

{
    if (prev) {
        prev->next = to_delete->next;
    }
    if (to_delete == cobc_user_res_list) {
        cobc_user_res_list = to_delete->next;
    }

    if (action == FREE_WORD_STR) {
        cobc_main_free (to_delete->word);
    }

    cobc_main_free (to_delete->alias_for);

    cobc_main_free (to_delete);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE struct cobc_reserved* find_default_reserved_word ( struct cobc_reserved *  to_find )

static

Definition at line 2752 of file reserved.c.

References NUM_DEFAULT_RESERVED_WORDS, and reserve_comp().

Referenced by get_reserved_words_from_user_list(), and get_user_specified_reserved_word().

{
    return bsearch (to_find, default_reserved_words,
            NUM_DEFAULT_RESERVED_WORDS,
            sizeof (struct cobc_reserved), reserve_comp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static size_t get_length_of_user_res_list ( void  )

static

Definition at line 2742 of file reserved.c.

References cobc_user_res_list, and reserved_word_list::next.

Referenced by get_reserved_words_from_user_list().

{
    struct reserved_word_list   *l = cobc_user_res_list;
    size_t              length;

    for (length = 0; l; ++length, l = l->next);
    return length;
}

Here is the caller graph for this function:

static void get_reserved_words_from_default_list ( void  )

static

Definition at line 2839 of file reserved.c.

References default_reserved_words, NUM_DEFAULT_RESERVED_WORDS, and num_reserved_words.

Referenced by initialize_reserved_words_if_needed().

{
    reserved_words = default_reserved_words;
    num_reserved_words = NUM_DEFAULT_RESERVED_WORDS;
}

Here is the caller graph for this function:

static void get_reserved_words_from_user_list ( void  )

static

Definition at line 2793 of file reserved.c.

References cobc_main_malloc(), cobc_user_res_list, create_dummy_reserved(), DONT_FREE_WORD_STR, find_default_reserved_word(), FREE_WORD_STR, get_length_of_user_res_list(), get_user_specified_reserved_word(), num_reserved_words, pop_reserved_word(), reserve_comp(), and reserved_word_list::word.

Referenced by initialize_reserved_words_if_needed().

{
    int i;
    struct cobc_reserved        to_find;
    struct cobc_reserved        *p;

    num_reserved_words = get_length_of_user_res_list ();
    reserved_words = cobc_main_malloc (num_reserved_words
                       * sizeof (struct cobc_reserved));

    /*
      Populate reserved_words array with data from default_reserved_words,
      where possible. Free each word once processed.
    */
    for (i = 0; cobc_user_res_list; ++i) {
        to_find = create_dummy_reserved (cobc_user_res_list->word);
        p = find_default_reserved_word (&to_find);
        if (p) {
            reserved_words[i] = *p;
            /*
              Note that we ignore if the user specified this word
              as context-sensitive.
            */

            /*
              We use the string literal in the default_reserved_
              words array.
            */
                pop_reserved_word (FREE_WORD_STR);
        } else {
                reserved_words[i] = get_user_specified_reserved_word (*cobc_user_res_list);

            /*
              We use the string copy allocated for cobc_user_res_
              list.
            */
            pop_reserved_word (DONT_FREE_WORD_STR);
        }
    }

    /* Later code assumes the array to be sorted */
    qsort (reserved_words, num_reserved_words,
           sizeof (struct cobc_reserved), reserve_comp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct cobc_reserved get_user_specified_reserved_word ( struct reserved_word_list  user_reserved )

static

Definition at line 2760 of file reserved.c.

References _, configuration_error(), cobc_reserved::context_sens, create_dummy_reserved(), find_default_reserved_word(), NULL, and cobc_reserved::token.

Referenced by get_reserved_words_from_user_list().

{
    struct cobc_reserved    to_find;
    struct cobc_reserved    cobc_reserved
        = create_dummy_reserved (user_reserved.word);
    struct cobc_reserved    *p;

    if (!user_reserved.alias_for) {
        cobc_reserved.context_sens
            = user_reserved.is_context_sensitive;
    } else {
        to_find = create_dummy_reserved (user_reserved.alias_for);
        p = find_default_reserved_word (&to_find);

        if (p) {
            cobc_reserved.token = p->token;
        } else {
                configuration_error (NULL, 0, 1,
                         _("Alias target '%s' is not a default reserved word"),
                         user_reserved.alias_for);
        }
    }

    return cobc_reserved;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE int has_context_sensitive_indicator ( const char *  word, const size_t  size  )

static

Definition at line 2640 of file reserved.c.

Referenced by add_reserved_word_without_init(), allocate_str_removing_asterisk(), and initialize_alias_for().

{
    return word[size - 1] == '*';
}

Here is the caller graph for this function:

static void initialize_alias_for ( const char *  alias_for, struct reserved_word_list *const  reserved, const char *  fname, const int  line  )

static

Definition at line 2670 of file reserved.c.

References _, reserved_word_list::alias_for, allocate_str_removing_asterisk(), configuration_warning(), and has_context_sensitive_indicator().

Referenced by add_reserved_word_without_init().

{
    const size_t    size = strlen (alias_for);

    if (has_context_sensitive_indicator (alias_for, size)) {
        configuration_warning (fname, line, _("Ignored asterisk at end of alias target"));
    }
    allocate_str_removing_asterisk (alias_for, size, &reserved->alias_for);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void initialize_reserved_words_if_needed ( void  )

static

Definition at line 2846 of file reserved.c.

References get_reserved_words_from_default_list(), and get_reserved_words_from_user_list().

Referenced by cb_list_reserved(), and lookup_reserved_word().

{
    if (!reserved_words) {
        if (cobc_user_res_list) {
            get_reserved_words_from_user_list ();
        } else {
            get_reserved_words_from_default_list ();
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void initialize_user_res_list_if_needed ( void  )

static

Definition at line 2725 of file reserved.c.

References add_reserved_word_without_init(), likely, NULL, and NUM_DEFAULT_RESERVED_WORDS.

Referenced by add_reserved_word(), and remove_reserved_word().

{
    const size_t    num_default_words = NUM_DEFAULT_RESERVED_WORDS;
    int     i;

    if (likely (cobc_user_res_list || cb_specify_all_reserved)) {
        return;
    }

    /* Initialize the list with the words from the default list. */
    for (i = 0; i < num_default_words; ++i) {
        add_reserved_word_without_init (default_reserved_words[i].name,
                        NULL, 0);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE void initialize_word ( const char *  word, const size_t  size, struct reserved_word_list *const  reserved  )

static

Definition at line 2663 of file reserved.c.

References allocate_str_removing_asterisk(), and reserved_word_list::word.

Referenced by add_reserved_word_without_init().

{
    allocate_str_removing_asterisk (word, size, &reserved->word);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

static

Definition at line 2571 of file reserved.c.

References cob_strcasecmp(), and cb_intrinsic_table::name.

Referenced by lookup_intrinsic().

{
    return cob_strcasecmp (p1, ((struct cb_intrinsic_table *)p2)->name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct cb_intrinsic_table* lookup_intrinsic	(	const char *	name,
		const int	checkres,
		const int	checkimpl
	)

Definition at line 2976 of file reserved.c.

References cb_intrinsic_table::implemented, intrinsic_comp(), NULL, and NUM_INTRINSICS.

Referenced by cb_build_any_intrinsic(), cb_build_intrinsic(), cobc_deciph_funcs(), and yylex().

{
    struct cb_intrinsic_table   *cbp;

    cbp = bsearch (name, function_list, NUM_INTRINSICS,
            sizeof (struct cb_intrinsic_table), intrinsic_comp);
    if (cbp && (checkimpl || cbp->implemented)) {
        return cbp;
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

struct cobc_reserved* lookup_reserved_word

(

const char *

name

)

Definition at line 2910 of file reserved.c.

References _, CB_CS_PROGRAM_ID, cb_error(), cobc_cs_check, cobc_force_literal, cobc_in_procedure, cobc_in_repository, cobc_reserved::context_sens, cobc_reserved::context_set, cobc_reserved::context_test, create_dummy_reserved(), FUNCTION_ID, initialize_reserved_words_if_needed(), INTRINSIC, NULL, num_reserved_words, PROGRAM_ID, REPOSITORY, reserve_comp(), cobc_reserved::token, and unlikely.

Referenced by yylex().

{
    struct cobc_reserved        *p;
    struct cobc_reserved        to_find;

    initialize_reserved_words_if_needed ();

    to_find = create_dummy_reserved (name);
    p = bsearch (&to_find, reserved_words, num_reserved_words,
             sizeof (struct cobc_reserved), reserve_comp);
    if (!p) {
        return NULL;
    }

    /* Check word is implemented */
    if (unlikely(p->token <= 0)) {
        /* Not implemented - If context sensitive, no error */
        if (!p->context_sens) {
            cb_error (_("'%s' reserved word, but not supported"), name);
        }
        return NULL;
    }

    /* Special actions / Context sensitive */
    if (p->context_set) {
        if (unlikely(p->context_test)) {
            /* Dependent words */
            if (!(cobc_cs_check & p->context_test)) {
                return p;
            }
        }
        cobc_cs_check |= p->context_set;
        return p;
    }

    if (p->context_test) {
#if 0   /* RXWRXW - CS check */
        if (!(cobc_cs_check & p->context_test)) {
#endif
        if ((cobc_cs_check & p->context_test) != p->context_test) {
            return NULL;
        }
        if (!cobc_in_procedure) {
            cobc_cs_check = 0;
        }
        return p;
    }

    if (p->token == FUNCTION_ID) {
        cobc_cs_check = 0;
        cobc_force_literal = 1;
    } else if (p->token == INTRINSIC) {
        if (!cobc_in_repository) {
            return NULL;
        }
    } else if (p->token == PROGRAM_ID) {
        cobc_cs_check = CB_CS_PROGRAM_ID;
        cobc_force_literal = 1;
    } else if (p->token == REPOSITORY) {
        cobc_in_repository = 1;
    }

    return p;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cb_tree lookup_system_name

(

const char *

name

)

Definition at line 2860 of file reserved.c.

References cb_build_system_name(), cob_strcasecmp(), EXT_SYSTEM_TAB_SIZE, NULL, SYSTEM_TAB_SIZE, and cobc_reserved::token.

Referenced by cb_build_display_name(), cb_define_system_name(), cb_emit_accept_name(), and yyparse().

{
    size_t  i;

    for (i = 0; i < SYSTEM_TAB_SIZE; ++i) {
        if (cob_strcasecmp (name, system_table[i].name) == 0) {
            return cb_build_system_name (system_table[i].category,
                              system_table[i].token);
        }
    }
    if (cb_flag_syntax_extension) {
        for (i = 0; i < EXT_SYSTEM_TAB_SIZE; ++i) {
            if (cob_strcasecmp (name, ext_system_table[i].name) == 0) {
                return cb_build_system_name (ext_system_table[i].category,
                                  ext_system_table[i].token);
            }
        }
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static COB_INLINE COB_A_INLINE void pop_reserved_word ( const enum free_word_action  action )

static

Definition at line 2787 of file reserved.c.

References delete_reserved_word_from_list(), and NULL.

Referenced by get_reserved_words_from_user_list().

{
    delete_reserved_word_from_list (NULL, action, cobc_user_res_list);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void remove_reserved_word

(

const char *

word

)

Definition at line 2882 of file reserved.c.

References cob_strcasecmp(), delete_reserved_word_from_list(), FREE_WORD_STR, initialize_user_res_list_if_needed(), reserved_word_list::next, NULL, and reserved_word_list::word.

Referenced by cb_config_entry().

{
    struct reserved_word_list   *reserved;
    struct reserved_word_list   *prev = NULL;

    initialize_user_res_list_if_needed ();

    for (reserved = cobc_user_res_list; reserved; reserved = reserved->next) {
        /*
          We can only remove the word if it has already been specified.
        */
        if (cob_strcasecmp (reserved->word, word) == 0) {
                delete_reserved_word_from_list (prev, FREE_WORD_STR,
                            reserved);
            return;
        }
        prev = reserved;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static const char* res_get_feature ( const enum cb_system_name_category  category )

static

Definition at line 2577 of file reserved.c.

References _, CB_DEVICE_NAME, CB_FEATURE_NAME, and CB_SWITCH_NAME.

Referenced by cb_list_mnemonics().

{
    const char  *s;

    switch (category) {
    case CB_DEVICE_NAME:
        s = _("Device name");
        break;
    case CB_SWITCH_NAME:
        s = _("Switch name");
        break;
    case CB_FEATURE_NAME:
        s = _("Feature name");
        break;
    default:
        s = _("Unknown");
        break;
    }
    return s;
}

Here is the caller graph for this function:

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

static

Definition at line 2564 of file reserved.c.

References cob_strcasecmp(), and cb_intrinsic_table::name.

Referenced by find_default_reserved_word(), get_reserved_words_from_user_list(), and lookup_reserved_word().

{
    return cob_strcasecmp (((struct cobc_reserved *)p1)->name,
                   ((struct cobc_reserved *)p2)->name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

unsigned char cob_lower_tab[256]

static

Definition at line 2522 of file reserved.c.

Referenced by cob_strcasecmp(), and cobc_init_reserved().

struct reserved_word_list* cobc_user_res_list = ((void*)0)

Definition at line 36 of file reserved.c.

Referenced by add_reserved_word_without_init(), get_length_of_user_res_list(), and get_reserved_words_from_user_list().

struct cobc_reserved default_reserved_words[]

static

Definition at line 200 of file reserved.c.

Referenced by get_reserved_words_from_default_list().

const struct system_struct ext_system_table[]

static

Definition at line 116 of file reserved.c.

const struct cb_intrinsic_table function_list[]

static

Definition at line 1965 of file reserved.c.

size_t num_reserved_words

static

Definition at line 1953 of file reserved.c.

Referenced by cb_list_reserved(), get_reserved_words_from_default_list(), get_reserved_words_from_user_list(), and lookup_reserved_word().

const unsigned char pcob_lower_tab[] = "abcdefghijklmnopqrstuvwxyz"

static

Definition at line 2523 of file reserved.c.

Referenced by cobc_init_reserved().

const unsigned char pcob_lower_val[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

static

Definition at line 2524 of file reserved.c.

Referenced by cobc_init_reserved().

struct cobc_reserved* reserved_words

static

Definition at line 198 of file reserved.c.

const struct system_struct system_table[]

static

Definition at line 46 of file reserved.c.