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

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_RESERVED_WORDS sizeof (reserved_words) / sizeof (struct cobc_reserved)

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

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)

cb_tree	lookup_system_name (const char *name)

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
static struct system_struct	system_table []

static struct system_struct	ext_system_table []

static struct cobc_reserved	reserved_words []

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

Referenced by cb_list_mnemonics(), and lookup_system_name().

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

Referenced by cb_list_intrinsics(), and lookup_intrinsic().

#define NUM_RESERVED_WORDS sizeof (reserved_words) / sizeof (struct cobc_reserved)

Referenced by cb_list_reserved(), and lookup_reserved_word().

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

Referenced by cb_list_mnemonics(), and lookup_system_name().

Function Documentation

void cb_list_intrinsics ( void )

References _, and NUM_INTRINSICS.

Referenced by process_command_line().

 {
     const char  *s;
     const char  *t;
     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 < 0) {
             printf ("%s%s%s\t\tVariable\n", function_list[i].name,
                 s, t);
         } else {
             printf ("%s%s%s\t\t%d\n", function_list[i].name,
                 s, t, function_list[i].args);
         }
     }
 }

void cb_list_mnemonics ( void )

References _, 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);
     }
 }

void cb_list_reserved ( void )

References _, NUM_RESERVED_WORDS, and p.

Referenced by process_command_line().

 {
     const char  *s;
     const char  *p;
     size_t      i;
     size_t      n;
 
     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) {
             p = _("N (85 obsolete)");
         } else 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 ("'LENGTH OF' phrase\t\tUSAGE BINARY-LONG");
 }

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

static

References cob_lower_tab.

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

 {
     const unsigned char *p1;
     const unsigned char *p2;
     unsigned char       c1;
     unsigned char       c2;
 
     /* Note - second parameter is assumed already upper case */
 
     p1 = (const unsigned char *)s1;
     p2 = (const unsigned char *)s2;
 
     for (;;) {
         if (cob_lower_tab[*p1]) {
             c1 = cob_lower_tab[*p1++];
         } else {
             c1 = *p1++;
         }
         c2 = *p2++;
         if (c1 != c2) {
             return c1 < c2 ? -1 : 1;
         }
         if (!c1) {
             break;
         }
     }
     return 0;
 }

void cobc_init_reserved ( void )

References cob_lower_tab, p, 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;
     }
 }

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

static

References cob_strcasecmp(), and cb_intrinsic_table::name.

Referenced by lookup_intrinsic().

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

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

read

References cobc_nores_base, cb_intrinsic_table::implemented, intrinsic_comp(), noreserve::next, noreserve::noresword, NULL, NUM_INTRINSICS, and unlikely.

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

 {
     struct cb_intrinsic_table   *cbp;
     struct noreserve        *nr;
 
     if (unlikely(cobc_nores_base && checkres)) {
         for (nr = cobc_nores_base; nr; nr = nr->next) {
             if (strcasecmp (name, nr->noresword) == 0) {
                 return NULL;
             }
         }
     }
     cbp = bsearch (name, function_list, NUM_INTRINSICS,
             sizeof (struct cb_intrinsic_table), intrinsic_comp);
     if (cbp && (checkimpl || cbp->implemented)) {
         return cbp;
     }
     return NULL;
 }

struct cobc_reserved* lookup_reserved_word ( const char * name )

read

References _, CB_CS_PROGRAM_ID, cb_error(), cobc_cs_check, cobc_force_literal, cobc_in_procedure, cobc_in_repository, cobc_nores_base, cobc_reserved::context_sens, cobc_reserved::context_set, cobc_reserved::context_test, FUNCTION_ID, INTRINSIC, noreserve::next, noreserve::noresword, NULL, NUM_RESERVED_WORDS, p, PROGRAM_ID, REPOSITORY, reserve_comp(), cobc_reserved::token, and unlikely.

Referenced by while().

 {
     struct cobc_reserved    *p;
     struct noreserve    *nr;
 
     p = bsearch (name, reserved_words, NUM_RESERVED_WORDS,
              sizeof (struct cobc_reserved), reserve_comp);
     if (!p) {
         return NULL;
     }
 
     /* Allow obsolete/unimplemented 85 keywords as user names */
     if (!p->token && !cb_cobol85_reserved) {
         return NULL;
     }
 
     /* Check if the configuration has unreserved the word */
     for (nr = cobc_nores_base; nr; nr = nr->next) {
         if (strcasecmp (name, nr->noresword) == 0) {
             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;
 }

cb_tree lookup_system_name ( const char * name )

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

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

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

static const char* res_get_feature ( const enum cb_system_name_category category )

static

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

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

static

References cob_strcasecmp(), and cb_intrinsic_table::name.

Referenced by lookup_reserved_word().

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

Variable Documentation

unsigned char cob_lower_tab[256]

static

Referenced by cob_strcasecmp(), and cobc_init_reserved().

struct system_struct ext_system_table[]

static

Initial value:

= {
    {"SW0",         CB_SWITCH_NAME,  CB_SWITCH_0},
    {"SW1",         CB_SWITCH_NAME,  CB_SWITCH_1},
    {"SW2",         CB_SWITCH_NAME,  CB_SWITCH_2},
    {"SW3",         CB_SWITCH_NAME,  CB_SWITCH_3},
    {"SW4",         CB_SWITCH_NAME,  CB_SWITCH_4},
    {"SW5",         CB_SWITCH_NAME,  CB_SWITCH_5},
    {"SW6",         CB_SWITCH_NAME,  CB_SWITCH_6},
    {"SW7",         CB_SWITCH_NAME,  CB_SWITCH_7},
    {"SW8",         CB_SWITCH_NAME,  CB_SWITCH_8},
    {"SW9",         CB_SWITCH_NAME,  CB_SWITCH_9},
    {"SW10",        CB_SWITCH_NAME,  CB_SWITCH_10},
    {"SW11",        CB_SWITCH_NAME,  CB_SWITCH_11},
    {"SW12",        CB_SWITCH_NAME,  CB_SWITCH_12},
    {"SW13",        CB_SWITCH_NAME,  CB_SWITCH_13},
    {"SW14",        CB_SWITCH_NAME,  CB_SWITCH_14},
    {"SW15",        CB_SWITCH_NAME,  CB_SWITCH_15}
}

struct cb_intrinsic_table function_list[]

static

const unsigned char pcob_lower_tab[] = "abcdefghijklmnopqrstuvwxyz"

static

Referenced by cobc_init_reserved().

const unsigned char pcob_lower_val[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

static

Referenced by cobc_init_reserved().

struct cobc_reserved reserved_words[]

static

struct system_struct system_table[]

static

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

Function Documentation

Variable Documentation