{/*
  AnaGram Syntax Analyzer.
  Copyright (c) Parsifal Software, 1993.
  All Rights Reserved.

  Configuration file module
*/
#include HEADERS

#include DATA
#include ASSERT
#include CTYPE
#include STDLIB
#include STRING
#include ARRAYS
#include MYALLOC
#include CF
#include PARAMS
#include PF

}
[
  auto resynch
  context type = cint
  grammar token = config file
 ~declare pcb
	diagnose errors
//	enum constant name = "cf_%_token"
  lines and columns
  line numbers
 ~allow macros
	line numbers
  error frame
  nest comments
 ~test range
  token names
  pointer input
  default token type = int
  near functions
]

any digit = digit + hex letter
backslash = '\\'
blank char = ' ' + '\t'
carriage return = '\r'
digit = '0-9'
double quote = '"'
eof = 0 + 26
eol chars = newline + carriage return
hex letter = 'a-f' + 'A-F'
letter = 'a-z' + 'A-Z' + '_'
newline = '\n'
nonoctal digit = any digit - octal digit
octal digit = '0-7'
simple string char = ~eof - (any digit + double quote + backslash + eol chars)
tab = '\t'
vertical space = '\f' + '\v'

equals
 -> '=', space?

minus
 -> '-', space?

plus
 -> '+', space?

tilde
 -> '~', space?
/*
left bracket
 -> '[', space?

right bracket
 -> ']', blank?...
*/
left parenthesis
 -> '(', space?

right parenthesis
 -> ')', blank?...


config file
 -> blank?..., [global parameter | end of line]/..., eof

(void) global parameter
 -> name                          =cf_gp4(1);
 -> tilde, name                   =cf_gp4(0);
 -> name, equals, data type       =cf_gp2();
 -> name, equals, keyword string  =cf_gp3();
 -> name, equals, number:n        =cf_gp5(n);
 -> "trial", blank..., "copy", blank..., "code", blank?..., equals,
    trial copy code:n             =trial_copy_code = n;

(unsigned long) trial copy code
 -> '0-9':d                       =d-'0';
 -> trial copy code:n, '0-9':d    =10*n + d-'0';

(void) data type
 -> name
 -> name, abstract declarator  =concat_string();

(void) abstract declarator
 -> indirect data type
 -> direct abstract declarator
 -> indirect data type, direct abstract declarator  =concat_string();


(void) direct abstract declarator
 -> {left parenthesis =scs('('),0;}, abstract declarator,
     right parenthesis =concat_string(), acs(')');
/*
 -> brackets
 -> direct abstract declarator, brackets =concat_string();

(void) brackets
 -> left bracket, right bracket =sss("[]");
 -> left parenthesis, right parenthesis     =sss("()");
*/

(void) pointer
 -> star
 -> star, name  =concat_string();

(void) star
 -> '*', blank?... =sss(" *");

(void) indirect data type
 -> pointer
 -> indirect data type, pointer  =concat_string();

(void) name string
 -> letter:a   =scs(a);
 -> name string, letter + digit :a =acs(a);
 -> name string, blank..., letter + digit :a =acs(' '), acs(a);

name
 -> name string, blank?...

blank
 -> blank char
 -> c comment

space
 -> blank...
 -> blank..., continuation
 -> continuation

continuation
 -> comment, next line
 -> next line

next line
 -> carriage return?, newline
 -> carriage return?, newline, blank...

white
 -> blank
 -> carriage return?, newline
 -> comment, carriage return?, newline

end of line
 -> comment, carriage return?, newline
 -> carriage return?, newline
 -> end of line, white
 -> end of line, vertical space //form feed

comment
 -> "//", ~eol chars & ~eof?...

decimal number
 -> '1-9':d                       =d - '0';
 -> decimal number:n, '0-9':d     =10*n + d - '0';

octal number
 -> '0'                          =0;
 -> octal number:n, '0-7':d      =8*n + d - '0';

hex number
 -> "0x"                       =0;
 -> "0X"                       =0;
 -> hex number:n, '0-9':d      =16*n + d - '0';
 -> hex number:n, 'A-F' + 'a-f':d      =16*n + (d&7) + 9;

simple number
 -> decimal number
 -> octal number
 -> hex number

number
 -> sign:s, simple number:n, blank?... =s*n;

sign
 -> plus?         =1;
 -> minus         =-1;

keyword string
 -> keyword string head, string,  double quote, blank?...

string
 -> string A | string B | string C

(void) keyword string head
 -> double quote =ics();

string char
 -> simple string char
 -> escape sequence

escape sequence
 -> "\\a" ='\a';
 -> "\\b" ='\b';
 -> "\\f" ='\f';
 -> "\\n" ='\n';
 -> "\\r" ='\r';
 -> "\\t" ='\t';
 -> "\\v" ='\v';
 -> "\\\\" ='\\';
 -> "\\?" = '\?';
 -> "\\'" ='\'';
 -> "\\\"" ='"';
 -> three octal:n =n==0?cf_error("Null character in string"),0 : n;

one octal
 -> backslash, '0-7':n                      =n&7;

two octal
 -> one octal:n, '0-7':d                    = n*8 + (d&7);

three octal
 -> two octal:n, '0-7':d                    = n*8 + (d&7);

octal escape
 -> {one octal | two octal}:n =
     n==0?cf_error("Null character in string"),0 : n;

hex escape
 -> "\\x", hex number:n   =n;

(void) string A
 -> string char:c               =acs(c);
 -> any digit:c                 =acs(c);
 -> string, string char:c       =acs(c);
 -> string A, any digit:c       =acs(c);
 -> string B, nonoctal digit:c  =acs(c);

(void) string B
 -> octal escape:n              =acs(n);
 -> string, octal escape:n      =acs(n);

(void) string C
 -> hex escape:n                =acs(n);
 -> string, hex escape:n        =acs(n);

(void) c comment
 -> c comment text, "*/"

(void) c comment text
 -> "/*"
 -> c comment text, ~eof

c comment, c comment text
 -> c comment text, c comment =
{if (nest_comments) PCB.reduction_token = cf_c_comment_text_token;}

[
  hidden {
    left parenthesis, right parenthesis,
    pointer, indirect data type, name string,
    space, next line, sign, one octal, two octal, three octal,
    string A, string B, string C, c comment text, escape sequence,
    octal escape, hex escape, name string
  }
]

{

#define PARSE_STACK_OVERFLOW\
  {fprintf(stderr,"Parse stack overflow\n");myabort();}
#define SYNTAX_ERROR cf_syn_error()
#define GET_CONTEXT CONTEXT.x = PCB.column, CONTEXT.y = PCB.line

#define N_PARAMS 80


static cf_pcb_type cfcb;
#define PCB cfcb

extern string_dict *param_dict;
extern unsigned char *input_base;
extern int precedence_level;
extern int int_token_type;

void reset_stack(void);
void log_error(void);

static void cf_gp2(void);
static void cf_gp3(void);
static void cf_gp4(int);
static void cf_gp5(int);

void acs(int);
void scs(int);

void init_params(void);

unsigned char *read_file(char *);

static char *config_file;

static void cf_error(char *);

static void cf_bad_param(int pn) {
	char *dm;
	if (pn) dm = "Inappropriate value";
	else dm = "No such parameter";
	cf_error(dm);
  rcs();
  return;
}

void xgp5(int, void bad(int), int);

static void cf_gp5(int tv) {
  xgp5(tv,cf_bad_param,0);
}

void xgp4(int, void bad(int), int);

static void cf_gp4(int tv) {
  xgp4(tv,cf_bad_param,0);
}

void xgp2(void bad(int), int);

static void cf_gp2(void) {
  xgp2(cf_bad_param,0);
}

void xgp3(void bad(int), int);

static void cf_gp3(void) {
  xgp3(cf_bad_param,0);
}

static int read_config_file(char *path) {
  char* file_name = allocate(strlen(path)+20,char);
  char *cp;

  strcpy(file_name, path);
  cp = strrchr(file_name,PATH_DELIMITER);
/*
  assert(cp != NULL);
  strcpy(cp+1,"AnaGram.cfg");
*/
  if (cp) cp++;
  else cp = file_name;
  strcpy(cp,"AnaGram.cfg");
  config_file = file_name;
  cfcb.pointer = input_base = read_file(file_name);
  return input_base != NULL;
}

static void get_config(char *path) {
  cfcb.pointer = input_base = read_file(path);
  if (input_base != NULL) {
    cf();
    free(input_base);
  }
  input_base = NULL;
}
int in_cur_dir(char *);

void read_config(char *path) {
  if (read_config_file(path)) {
    cf();
    free(input_base);
    free(config_file);
  }
  if (in_cur_dir(path)) return;
  config_file = "AnaGram.cfg";
  get_config("anagram.cfg");
}

static void cf_error(char *msg) {
  int eline = PCB.line, ecol = PCB.column;

  if (PCB.token_number == cf_eof_token) {
    eline = ERROR_CONTEXT.y;
    ecol = ERROR_CONTEXT.x;
  }
  ssprintf("%s, Line %d, Col %d: %s", config_file,
    eline, ecol, msg);
  log_error();
}

static void cf_syn_error(void) {
  reset_stk();
  cf_error(PCB.error_message);
}

param_number_map *map_param_number;

static void init_param_val_proc(int *pn, char *name, int v) {
  param_number_map *mpn;

  *pn = add_string_dict(name,param_dict);
  check_size(map_param_number,*pn,*pn);
  mpn = &map_param_number[*pn];
/*  mpn->value_name = 1; */
  mpn->value = v;
}


#define init_param_val(p,v) \
  init_param_val_proc(&p##_pn, #p,v)

static param_number_map *id_param(int *pn, void *p, char *name) {
  int k = add_string_dict(name,param_dict);
  param_number_map *mpn;

  check_size(map_param_number, k,3*k/2);
  *pn = k;
  mpn = &map_param_number[k];
  mpn->param = p;
  return mpn;
}

#define init_param(p, global, implicit)\
  {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
  mpn->global = 1;\
  mpn->implicit = 1;}

#define init_param_co(p, global, implicit)\
  {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
  mpn->global = mpn->config_only = 1;\
  mpn->implicit = 1;}

/*
#define init_verb(p,param)\
 {param_number_map *mpn =\
  &map_param_number[p##_pn = add_string_dict(#p, param_dict)];\
  mpn->verb = 1;\
  mpn->value = param##_pn;}
*/
/*
#define init_token_param(p,implicit)\
  {param_number_map *mpn =\
   &map_param_number[p##_pn = add_string_dict(#p, param_dict)];\
  mpn->token = 1;\
  mpn->implicit = 1;}
*/

#define init_dict_param(p,global,dict_name)\
  {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
  mpn->global = 1;\
  mpn->dict = dict_name;\
  mpn->value_id = 1;}
/*
#define init_literal_param(p,global,first_value)\
  {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
  mpn->value = first_value##_pn;\
  mpn->global = 1;\
  mpn->dict = param_dict;\
  mpn->literal = 1;}
*/

#define init_proc_param(p,global,proc_name)\
  {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
  mpn->global = 1;\
  mpn->proc = proc_name;\
  mpn->proc_call = 1;}

#define init_token_id_param(p,global)\
  {param_number_map *mpn = id_param(&p##_pn,&p, #p);\
  mpn->global = 1;\
  mpn->proc = name_token;\
  mpn->proc_call = 1;\
  mpn->token_id = 1;}

#define dp(p)\
static int p##_pn

dp(on);
dp(off);

extern int   allow_macros;                      dp(allow_macros);
       int   auto_init = 1;                     dp(auto_init);
       int   auto_resynch = 0;                  dp(auto_resynch);
extern int   backtrack;                         dp(backtrack);
       int   bottom_margin = 3;                 dp(bottom_margin);
       int   bright_background = 1;             dp(bright_background);

       int   case_sensitive = 1;                dp(case_sensitive);
			 char *compile_command = "";              dp(compile_command);
       char *context_type = NULL;               dp(context_type);
       char *coverage_file_name = "#.nrc";      dp(coverage_file_name);

       int   declare_pcb = 1;                   dp(declare_pcb);
extern int   default_input_type;                dp(default_input_type);
extern int   default_token_type;                dp(default_token_type);
extern int   default_reductions;                dp(default_reductions);
       int   diagnose_errors = 1;               dp(diagnose_errors);

extern char *edit_command;                      dp(edit_command);
			 char *enum_constant_name = "$_%_token";  dp(enum_constant_name);
       int   error_frame = 0;                   dp(error_frame);
       int   error_trace = 0;                   dp(error_trace);
       int   escape_backslashes = 0;            dp(escape_backslashes);
       int   event_driven = 0;                  dp(event_driven);

extern int   far_tables;                        dp(far_tables);

extern int   grammar_token;                     dp(grammar_token);
extern char *header_file_name;                  dp(header_file_name);
       int   input_values = 0;                  dp(input_values);

       int   line_length = 80;                  dp(line_length);
extern int   line_numbers;                      dp(line_numbers);
       char *line_numbers_path = NULL;          dp(line_numbers_path);
extern int   lines_and_columns;                 dp(lines_and_columns);

       int   main_program = 1;                  dp(main_program);
       int   max_conflicts = 50;                dp(max_conflicts);

       int   near_functions = 0;                dp(near_functions);
       int   nest_comments = 0;                 dp(nest_comments);

       int   old_style = 0;                     dp(old_style);

       int   page_length = 66;                  dp(page_length);
extern char *parser_file_name;                  dp(parser_file_name);
       char *parser_name = "#";                 dp(parser_name);
       int   parser_stack_alignment;            dp(parser_stack_alignment);
       int   parser_stack_size = 32;            dp(parser_stack_size);
       int   pointer_input = 0;                 dp(pointer_input);
       char *pointer_type = "unsigned char *";  dp(pointer_type);
       char *print_file_name = "LPT1";          dp(print_file_name);

       int   quick_reference = 1;               dp(quick_reference);

       int   reduction_choices =0;              dp(reduction_choices);
       int   rule_coverage = 0;                 dp(rule_coverage);

			 int   tab_spacing = 8;                   dp(tab_spacing);
       int   test_file_binary = 0;              dp(test_file_binary);
       char *test_file_mask = "*.*";            dp(test_file_mask);
extern int   test_range;                        dp(test_range);
extern int   token_names;                       dp(token_names);
       int   top_margin = 3;                    dp(top_margin);
extern int   traditional_engine;                dp(traditional_engine);

extern int   video_mode;                        dp(video_mode);

       unsigned long trial_copy_code = 0;


/* char *note_file_name = "$.nf";  dp(note_file_name); */

       char *input_type_name = "$_it_type"; /* dp(input_type_name); */


char *control_block_type = "$_pcb_type";
char *typedef_name       = "$_token_type";
char *value_stack_type   = "$_vs_type";


extern string_dict *cast_dict;
extern string_dict *proc_dict;


extern string_dict *tkn_dict;

extern int error_token; dp(error_token);
/* extern int noise_token; dp(noise_token); */
int eof_token = 0; dp(eof_token);

extern int active_color;        dp(active_color);
extern int active_bar_color;    dp(active_bar_color);
extern int inactive_color;      dp(inactive_color);
extern int inactive_bar_color;  dp(inactive_bar_color);
extern int backdrop_color;      dp(backdrop_color);
extern int backdrop_bar_color;  dp(backdrop_bar_color);


int id_token(int);

static int name_token(char *name){
  sss(name);
  free(name);
  ids(tkn_dict);
  return id_token(fis());
}

void init_params(void) {
  int n;
  map_param_number = init_array(N_PARAMS,sizeof(param_number_map));

  init_param_val(off, 0);
  init_param_val(on, 1);

/*

  N.B. The following list should be in alphabetical order. Make sure that
  when you enter a new parameter, you enter it in the right place!

*/
  init_param(allow_macros, global, implicit);
  init_param(auto_init, global, implicit);
  init_param(auto_resynch, global, implicit);

  init_param(backtrack, global, implicit);
  init_param(bottom_margin, global, int_value);
  init_param_co(bright_background, global, implicit);

  init_param(case_sensitive, global, implicit);
	init_param(compile_command, global, string_value);
  init_param(context_type, global, text_value);
  init_param(coverage_file_name, global, string_value);

  init_param(declare_pcb, global,implicit);
  init_dict_param(default_input_type, global, cast_dict);
  init_param(default_reductions, global, implicit);
  init_dict_param(default_token_type, global, cast_dict);
  init_param(diagnose_errors, global, implicit);

  init_param(edit_command, global, string_value);
	init_param(enum_constant_name, global, string_value);
  init_token_id_param(eof_token, global);
  init_param(error_frame, global, implicit);
  init_token_id_param(error_token, global);
  init_param(error_trace, global, implicit);
  init_param(escape_backslashes, global, implicit);
  init_param(event_driven, global, implicit);

  init_param(far_tables, global, implicit);

  init_token_id_param(grammar_token, global);

  init_param(header_file_name, global, string_value);

  init_param(input_values, global, implicit);

  init_param(line_length, global, int_value);
  init_param(line_numbers, global, implicit);
  init_param(line_numbers_path, global, string_value);
  init_param(lines_and_columns, global, implicit);

  init_param(main_program, global, implicit);
  init_param(max_conflicts, global, int_value);

  init_param(near_functions, global, implicit);
  init_param(nest_comments, global, implicit);

  init_param(old_style, global, implicit);

  init_param(page_length, global, int_value);
  init_param(parser_file_name, global, string_value);
  init_param(parser_name, global, text_value);
  init_dict_param(parser_stack_alignment, global, cast_dict);
  init_param(parser_stack_size, global, int_value);
  init_param(pointer_input, global, implicit);
  init_param(pointer_type, global, text_value);
  init_param(print_file_name, global, string_value);

  init_param(quick_reference, global, implicit);

  init_param(reduction_choices, global, implicit);
  init_param(rule_coverage, global, implicit);

	init_param(tab_spacing, global, int_value);
  init_param(test_file_binary, global, implicit);
  init_param(test_file_mask, global, string_value);
  init_param(test_range, global, implicit);
  init_param(token_names, global, implicit);
  init_param(top_margin, global, int_value);
  init_param(traditional_engine, global, implicit);
  init_param_co(video_mode, global, int_value);



  init_param_co(active_bar_color, global, color_value);
  init_param_co(active_color, global, color_value);
  init_param_co(backdrop_bar_color, global, color_value);
  init_param_co(backdrop_color, global, color_value);
  init_param_co(inactive_bar_color, global, color_value);
  init_param_co(inactive_color, global, color_value);


  n = param_dict->nsx;
  assert(n < N_PARAMS);
  map_param_number = set_array_size(map_param_number, n);
}
}