/* @(#)gen_pr_utils.c	2.1 93/05/19 */
 
/******************************************************************************/
/* function    : gen_pr_utils                                                 */
/*                                                                            */
/* subsystem   : chgen                                                        */
/*                                                                            */
/* input       : <none>                                                       */
/*                                                                            */
/* output      : <none>                                                       */
/*                                                                            */
/* returns     : void                                                         */
/*                                                                            */
/* author      : Sathyanarayan Jaganathan / Steve Smith / Craig Smith         */
/*                                                                            */
/* created     : July, 1991                                                   */
/*                                                                            */
/* revisions   : Nov   2001: modified to fix warnings for BDE - sjaganat      */
/*                           (code change for 100 lines approx.)               */
/*                                                                            */
/*             : 93s523:  modified several functions to incorporate int pkeys */
/*                        added key and lut handling functions	              */
/*             : 96s523:  replaced generation of fixed ..btidx declares with  */
/*                        code to loop through tt_type structures             */
/*                                                                            */
/* description : This routine generates the set of small utility routines     */
/*               needed by the pr_ routines.  They represent the beginning of */
/*               the pr_load.c file.                                          */
/*                                                                            */
/******************************************************************************/


#include <stdio.h>
#include <ctype.h>
#include "chgen_define.h"
#include "chgen_externs.h"
#include "lut_c_file.h"
#include "btree_c_file.h"
#include "prototypes.h"


void gen_pr_utils()	/* generates pr utilities, into the pr_load.c file */
{
	static char rcsid[] = "";

        fprintf(prload_fp,"/******************************************************************************/\n");
        fprintf(prload_fp,"/* File          : pr_load.c                                                  */\n");
        fprintf(prload_fp,"/* Schema        : %-58s */\n",sch_text_file_name);
        fprintf(prload_fp,"/* Chgen Version : %-58s */\n",CHGEN_VERSION);
        fprintf(prload_fp,"/******************************************************************************/\n\n");

        /*** 93su523 PGEN merge***/
        fprintf(prload_fp, "#include <stdio.h>\n") ;
        fprintf(prload_fp, "#include <math.h>\n") ;
        fprintf(prload_fp, "#ifdef __STDC__\n");
        fprintf(prload_fp, "#include <stdlib.h>\n") ;
        fprintf(prload_fp, "#include <strings.h>\n") ;
        fprintf(prload_fp, "#endif\n");
        fprintf(prload_fp, "#include \"%s\"\n\n",sch_header_file_name) ;

        fprintf(prload_fp, "char outkey[3][HCG_KEY_SIZE+1]; /* used in  log_pr_add() */\n"); /* Sathya */
        fprintf(prload_fp, "/* A distinct outkey is local to pr_dump.c;              */\n"); /* Sathya */
        fprintf(prload_fp, "/* forward declaration                                   */\n"); /* Sathya */
        fprintf(prload_fp, "int btree_insert_node(btree_node_st**, char*, int);\n"); /* Sathya */
        fprintf(prload_fp, "int lut_does_node_exist(lut_st*, char*);\n"); /* Sathya */
        fprintf(prload_fp, "int btree_does_node_exist(btree_node_st*, char*);\n"); /* Sathya */
        fprintf(prload_fp, "int btree_destroy(btree_node_st*, btree_node_st*);\n"); /* Sathya */
        fprintf(prload_fp, "int btree_create(lut_st*);\n"); /* Sathya */
        fprintf(prload_fp, "int btree_wt(btree_node_st*);\n"); /* Sathya */
        fprintf(prload_fp, "void btree_initialized(void);\n"); /* Sathya */
        fprintf(prload_fp, "#ifdef GENLOG\n"); /* Sathya */
        fprintf(prload_fp, "extern void logwait(void);\n"); /* Sathya */
        fprintf(prload_fp, "extern void logstr(char*);\n"); /* Sathya */
        fprintf(prload_fp, "#else\n"); /* Sathya */
        fprintf(prload_fp, "void logwait(void){};\n"); /* Sathya */
        fprintf(prload_fp, "void logstr(char* dummy_strptr){};\n"); /*
Sathya */
        fprintf(prload_fp, "#endif\n"); /* Sathya */
        fprintf(prload_fp, "\n"); /* Sathya */
        fprintf(prload_fp, "/* moved here from schema.h - no other user in bde/{src pr_util} */\n"); /* Sathya */
        fprintf(prload_fp, "/* this was inside #ifndef SCHEMA_LOADED...#endif there */\n"); /* Sathya */
        
	/************************************************ bdesym ***/
	tt_curr=tt;
	while(tt_curr != NULL)
	{
	 fprintf(prload_fp,"int %sbtidx;\n",tt_curr->TTabbr);
	 tt_curr=tt_curr->next_ptr;
	}
	/************************************************ bdesym ***/
	fprintf(prload_fp, "int open_file;\n"); 

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine is similar to strcpy, except that it pads the result string   */\n");
	fprintf(prload_fp, "/* with blanks (if the unpad flag is 0) out to the length specified by n.     */\n");
	fprintf(prload_fp, "/* If the unpad flag is 1, then trailing blanks are removed (even any that    */\n");
	fprintf(prload_fp, "/* were in the original string).                                              */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
    fprintf(prload_fp,"static char rcsid[] = \"\";\n");
	fprintf(prload_fp, "void mystrcpy(char *s,char *t,int n,int unpad)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "int   i;\n");
	fprintf(prload_fp, "char *s2;\n");
	fprintf(prload_fp, "\ts2 = s;\n");
	fprintf(prload_fp, "\twhile ((*t != '\\0') && (n>0))\n\t{\n\t\t*s++ = *t++;\n\t\tn--;\n\t}\n");
	fprintf(prload_fp, "\t\twhile (n>0)\n"); /* Sathya */
    fprintf(prload_fp, "\t\t{\n"); /* Sathya */
    fprintf(prload_fp, "\t\t\t*s++ = ' ';\n"); /* Sathya */
    fprintf(prload_fp, "\t\t\tn--;\n"); /* Sathya */
    fprintf(prload_fp, "\t\t}\n"); /* Sathya */
    fprintf(prload_fp, "\t\t*s = '\\0';\n"); /* Sathya */
    fprintf(prload_fp, "\t\ts = s2; /* restore s */\n"); /* Sathya */
    fprintf(prload_fp, "\t\tif (unpad)\n"); /* Sathya */
    fprintf(prload_fp, "\t\t\tfor ( i=strlen(s)-1;( i>=0 ) && ( (s[i] == ' ') || (s[i] == '\\t') );i-- )\n"); /* Sathya */
    fprintf(prload_fp, "\t\t\t\ts[i] = '\\0';\n"); /* Sathya */
    fprintf(prload_fp, "}\n"); /* Sathya */

	fprintf(prload_fp, "/*********************************************************/\n");
	fprintf(prload_fp, "/** This function is identical to the system routine   **/\n");
	fprintf(prload_fp, "/** strncpy, except that it null terminates the string **/\n");
	fprintf(prload_fp, "/*********************************************************/\n\n");
	fprintf(prload_fp, "void strncpy_null(char *a,char *b,int n)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "   strncpy(a,b,n);\n");
	fprintf(prload_fp, "   a[n] = '\\0';\n");
	fprintf(prload_fp, "   return;\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine sets a region of memory to 0 (zero).  The 'standard' routine  */\n");
	fprintf(prload_fp, "/* memset() could be used, but apparently, it is not supplied with some       */\n");
	fprintf(prload_fp, "/* UNIX systems.                                                              */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "void clear_mem(char *s,int n)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "\tfor (; n>0; n--)\n");
	fprintf(prload_fp, "\t\t*s++ = '\\0';\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This function searches the hcg_table_seq_list for the specified table      */\n");
	fprintf(prload_fp, "/* abbrev (which is assumed to be the first 2 chars of the pkey param).       */\n");
	fprintf(prload_fp, "/* If successful, the global hcg_tbl_idx is set to its idx, and 1 is          */\n");
	fprintf(prload_fp, "/* returned.  Otherwise, the hcg_tbl_idx is set to 0, and 0 is returned.      */\n");
	fprintf(prload_fp, "/* This search is optimized using a form of caching.  If the hcg_tbl_idx      */\n");
	fprintf(prload_fp, "/* already points to the correct table, the search is avoided.                */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
/*** 93s523: changed code to incorporate key-size for this schema ***/
	fprintf(prload_fp, "int find_tbl_idx(const char *pkey)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "\tif (strncmp(pkey,hcg_table_seq_list[hcg_tbl_idx].ttabbrev,HCG_ABBR_SIZE) == 0)\n");
	fprintf(prload_fp, "\t\treturn(1);\n");
	fprintf(prload_fp, "\tfor (hcg_tbl_idx=0; hcg_tbl_idx < HCG_NUM_TABLES; hcg_tbl_idx++)\n");
	fprintf(prload_fp, "\t\tif (strncmp(pkey,hcg_table_seq_list[hcg_tbl_idx].ttabbrev,HCG_ABBR_SIZE) == 0)\n");
	fprintf(prload_fp, "\t\t\treturn(1);\n");
	fprintf(prload_fp, "\thcg_tbl_idx = 0;\n");
	fprintf(prload_fp, "\treturn(0);\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This function is almost identical to find_tbl_idx, except that it searches */\n");
	fprintf(prload_fp, "/* the hcg_view_list for the specified view-name, and the hcg_view_idx is     */\n");
	fprintf(prload_fp, "/* used.  In this case, viewnames are not restricted to any fixed length,     */\n");
	fprintf(prload_fp, "/* so a regular strcmp() is used.                                             */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "int find_view_idx(char *viewname)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "\tif (strcmp(viewname,hcg_view_list.view_list[hcg_view_idx].view_name) == 0)\n");
	fprintf(prload_fp, "\t\treturn(1);\n");
	fprintf(prload_fp, "\tfor (hcg_view_idx=0; hcg_view_idx < hcg_view_list.num_views; hcg_view_idx++)\n");
	fprintf(prload_fp, "\t\tif (strcmp(viewname,hcg_view_list.view_list[hcg_view_idx].view_name) == 0)\n");
	fprintf(prload_fp, "\t\t\treturn(1);\n");
	fprintf(prload_fp, "\thcg_view_idx = 0;\n");
	fprintf(prload_fp, "\treturn(0);\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine will extract a version number and row_number out of the       */\n");
	fprintf(prload_fp, "/* specified key value.  The results are stored in the globals hcg_version    */\n");
	fprintf(prload_fp, "/* and hcg_row.                                                               */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This function will determine if the specified key value meets the          */\n");
	fprintf(prload_fp, "/* proper version for that table in the specified view idx.                   */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
  /**** 93s523 ****/
	fprintf(prload_fp, "int meets_view(int tbl_idx, int view_idx, hcg_key pkey)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
#ifndef NEW_VERSION
        fprintf(prload_fp,"  return(hcg_view_list.view_list[view_idx].version_list[tbl_idx] == (get_version(&pkey)));\n");
#else
        fprintf(prload_fp,"  return(1);\n");
#endif
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine simply prints a warning when a duplicate row is added to      */\n");
	fprintf(prload_fp, "/* a table.  While it may seem this would be better as a macro, it is used    */\n");
	fprintf(prload_fp, "/* as a routine instead, to help minimize macro expansion.                    */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
   /*** 93s523 ***/
	fprintf(prload_fp, "void dup_row_warning(hcg_key pkey)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "   char temp_key[HCG_KEY_SIZE+1];\n\n");
	fprintf(prload_fp, "   if(decode(temp_key, &pkey) != 1)\n");
	fprintf(prload_fp, "      printf(\"Error: pkey %%8x is an ivalid key!\\n\",(unsigned int)pkey);\n"); /* Sathya */
	fprintf(prload_fp, "   else\n");
    fprintf(prload_fp, "    printf(\"Warning: duplicate row (%%s) encountered in pr_add, ignored.\\n\",temp_key);\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* Same as dup_row_warning, but a different error concept.                    */\n");
    fprintf(prload_fp, "/* only if -nobp (no back pointers) was a chgen qualifier                     */\n"); /* Sathya */
	fprintf(prload_fp, "/******************************************************************************/\n");
   /*** 93s523 ***/
	fprintf(prload_fp, "void forward_ref_warning(hcg_key pkey,hcg_key fkey)\n");  /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "   char temp_pkey[HCG_KEY_SIZE+1], temp_fkey[HCG_KEY_SIZE+1];\n\n");
	fprintf(prload_fp, "   if(decode(temp_pkey, &pkey) != 1)\n");
	fprintf(prload_fp, "     printf(\"Error: Invalid pkey %%8x !\\n\",(unsigned int)pkey);\n"); /* Sathya */
	fprintf(prload_fp, "   if(decode(temp_fkey, &fkey) != 1)\n");
	fprintf(prload_fp, "     printf(\"Error: Invalid fkey %%8x !\\n\",(unsigned int)fkey);\n"); /* Sathya */
    fprintf(prload_fp, "   printf(\"Warning: Record %%s references a parent record %%s that is not yet loaded (ie, forward reference)\\n\",temp_pkey,temp_fkey);\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine is used by the various file read routines.  It flushes the    */\n");
	fprintf(prload_fp, "/* read buffer, reads the next line of the file, and then converts any        */\n");
	fprintf(prload_fp, "/* control characters in the buffer into spaces (for example, newline).       */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "void hcg_read_next(void)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "  int i;\n");
	fprintf(prload_fp, "    clear_mem(hcg_buffer,BUFSIZE);\n");
	fprintf(prload_fp, "    fgets(hcg_buffer,BUFSIZE,hcg_ascii_fp);\n");
	fprintf(prload_fp, "    for (i = 0; hcg_buffer[i] != '\\0'; i++)\n");
	fprintf(prload_fp, "      if (hcg_buffer[i] < ' ') hcg_buffer[i] = ' ';\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine is used to parse the next word (w) out of the specified string*/\n");
	fprintf(prload_fp, "/* buffer(s).  The parameter idx serves two purposes.  On the way in, it      */\n");
	fprintf(prload_fp, "/* marks the starting point in the string for the parse.  From here, white-   */\n");
	fprintf(prload_fp, "/* space is skipped.  Once a word has begun, it is considered finished when   */\n");
	fprintf(prload_fp, "/* more whitespace is encountered, or end of string.  Finally, idx is moved   */\n");
	fprintf(prload_fp, "/* along to the start of the next word.  It is up to the caller to initially  */\n");
	fprintf(prload_fp, "/* set idx = 0.  This routine is also useful for any parsing project.         */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "void hcg_parse(char *s,char *w,int *idx)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, " int i;\n\n");
	fprintf(prload_fp, " i = 0;\n");
	fprintf(prload_fp, " while ( (s[*idx] == ' ') || (s[*idx] == '\\t') || (s[*idx] == '\\n'))\n");
	fprintf(prload_fp, "   (*idx)++;\n\n");

	fprintf(prload_fp, " while ( (s[*idx] != ' ') && (s[*idx] != '\\t') && (s[*idx] != '\\0') && (s[*idx] != '\\n'))\n");
	fprintf(prload_fp, "  {\n");
	fprintf(prload_fp, "   w[i++] = s[*idx];\n");
	fprintf(prload_fp, "   (*idx)++;\n");
	fprintf(prload_fp, "  }\n\n");

	fprintf(prload_fp, " w[i] = '\\0';\n\n");

	fprintf(prload_fp, " while ( (s[*idx] == ' ') || (s[*idx] == '\\t') || (s[*idx] == '\\n'))\n");
	fprintf(prload_fp, "   (*idx)++;\n\n");

	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/******************************************************************************/\n");
	fprintf(prload_fp, "/* This routine is used to update the embedded version number of a key field. */\n");
	fprintf(prload_fp, "/* If the new version flag indicates a new version should be generated, and   */\n");
	fprintf(prload_fp, "/* the mode of the view is 'w' (write), and the table corresponding to the    */\n");
	fprintf(prload_fp, "/* key in question (since it may be a foreign key) is in the view, then a     */\n");
	fprintf(prload_fp, "/* version update will actually occur.  The version is updated to 'one higher'*/\n");
	fprintf(prload_fp, "/* than the highest version found for the base table in question (specified   */\n");
	fprintf(prload_fp, "/* by tbl_idx). Arg3 locally renamed as is_new_version                        */\n");
	fprintf(prload_fp, "/******************************************************************************/\n");
   /*** 93s523 ***/
	fprintf(prload_fp, "void hcg_update_version(hcg_key *p_key,int tbl_idx,int is_new_version)\n");/* Sathya */
	fprintf(prload_fp, "{\n");
#ifndef NEW_VERSION
	fprintf(prload_fp, "   if ((is_new_version) &&\n"); /* Sathya */
	fprintf(prload_fp, "       (hcg_view_list.view_list[hcg_view_idx].mode == 'w') &&\n");
	fprintf(prload_fp, "       (hcg_view_list.view_list[hcg_view_idx].version_list[tbl_idx] != '\\0'))\n");
#else
	fprintf(prload_fp, "   if ((is_new_version) &&\n");  /* Sathya */
	fprintf(prload_fp, "       (hcg_view_list.view_list[hcg_view_idx].mode == 'w') )\n");
#endif
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "	   if(set_version(p_key, hcg_table_seq_list[tbl_idx].maxver +1) != 1)\n"); /* Sathya */
	fprintf(prload_fp, "           printf(\"Error: Can not set version# at p_key %%lu to %%d\\n\", (unsigned long) p_key, hcg_table_seq_list[tbl_idx].maxver + 1);\n"); /* Sathya */
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");



/********************************************************************************/
/* The next 2 fprintf statements are used to output the functions used in the   */
/* look up table and binary tree functions...  There are 3 header files that    */
/* contain static strings that are the actual source code for these functions...*/
/********************************************************************************/

	fprintf(prload_fp, "%s", p_lut_c);
	fprintf(prload_fp, "%s", p_btree_c);


/********************************************************************************/



/*
*	The next several functions are created to manipulate the new (spr '93)
*   32 bit integer keys.
*/

	fprintf(prload_fp, "/*  private functions used by the key servicing (not exported for general use)  */\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Internally used values of character field lengths\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "#define		OLD_KEY_LEN			8						/* for backward compatibility  */\n\n");
	fprintf(prload_fp, "#define		OLD_ABB_LEN			2\n");
	fprintf(prload_fp, "#define		OLD_VER_LEN			2\n");
	fprintf(prload_fp, "#define		OLD_ROW_LEN			4\n");

	fprintf(prload_fp, "#define		NEW_KEY_LEN			12\n");
	fprintf(prload_fp, "#define		NEW_ABB_LEN			4\n");
	fprintf(prload_fp, "#define		NEW_VER_LEN			3\n");
	fprintf(prload_fp, "#define		NEW_ROW_LEN			5\n");

	fprintf(prload_fp, "#define		MAX_ROW				65535\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      The following are masks defining bit lengths of the key field\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "static unsigned long abmask = 0x000000FF;				/* masks 8 bit abbreviation field from 32 bit key */\n");
	fprintf(prload_fp, "static unsigned long vrmask = 0x000000FF;				/* masks 8 bit version field from 32 bit key */\n");
	fprintf(prload_fp, "static unsigned long rwmask = 0x0000FFFF;				/* masks 16 bit row # field from 32 bit key */\n\n");

	fprintf(prload_fp, "static int key_len = HCG_KEY_SIZE;\n");
	fprintf(prload_fp, "static int max_row = MAX_ROW;\n");
	fprintf(prload_fp, "static int max_ver = MAXVERSIONS;\n");

	fprintf(prload_fp, "static int abshift = 24;		/* these are the amounts to shift the 32 bit key to use the above masks */\n");
	fprintf(prload_fp, "static int vrshift = 16;\n");
	fprintf(prload_fp, "static int rwshift = 0;\n\n");


	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      This is the value used to generate the NULL key.\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "static hcg_key null_key_p = (hcg_key)0x0;\n\n"); /* Sathya */

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      The following key function sets the static key length\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int\n");
	fprintf(prload_fp, "set_external_key_length( int klen )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	if( (klen == OLD_KEY_LEN) || (klen == NEW_KEY_LEN) )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		key_len = klen;\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Decode abbrev. encoded in key k, return in string abb\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int	abb_decode( hcg_key *k,char *abb )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	char* tmp;\n");
	fprintf(prload_fp, "	unsigned int abi;\n");

	fprintf(prload_fp, "	abi = (*(unsigned long*)k >> abshift) & abmask;\n");
	fprintf(prload_fp, "	if( (tmp = (char *)lut_get_name(&hcg_table_abbrev_lut, abi)) != NULL )\n");  /* Sathya */
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		strcpy( abb, tmp );\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		abb[0] = '\\0';\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");
	
	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Decode the version field of key k; return string representation in ver\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int ver_decode( hcg_key *k, char *ver )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	unsigned int vri = 0;\n");
	fprintf(prload_fp, "	vri = (*(unsigned long*)k >> vrshift) & vrmask;\n");
	fprintf(prload_fp, "	if( key_len == OLD_KEY_LEN )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		sprintf(ver,\"%%02d\",vri);\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else if( key_len == NEW_KEY_LEN )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "	        sprintf(ver,\"%%03d\",vri);\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		ver[0] = '\\0';\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Decode (convert to string) the row field of k, return in row\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int	row_decode( hcg_key *k, char *row )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	int rwi;\n");

	fprintf(prload_fp, "	rwi = (int) ((*(unsigned long*)k >> rwshift) & rwmask);\n");
	fprintf(prload_fp, "	if( key_len == OLD_KEY_LEN )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		sprintf(row, \"%%04d\", rwi);\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else if( key_len == NEW_KEY_LEN )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		sprintf(row, \"%%05d\", rwi);\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	return 1;\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Encode the table abbrev field of key k; with abbr in string t\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int	abb_encode( hcg_key *k, char *t )\n"); /* Sathya */
	fprintf(prload_fp, "{	\n");
	fprintf(prload_fp, "	int ab;\n");
	fprintf(prload_fp, "	if( (ab = lut_insert_element( &hcg_table_abbrev_lut, t )) < 0 )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		printf(\"ERROR: failure to encode table abbrev: %%s\\n\",t);\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		*(unsigned long*)k &= ~(abmask << abshift);\n");
	fprintf(prload_fp, "		*(unsigned long*)k |= ((unsigned long)ab & abmask) << abshift;\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Encode version field in key k to (legal) value contained in string t\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int	ver_encode( hcg_key *k, char *t )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	unsigned long vr;\n");
	fprintf(prload_fp, "	char* unconv_stuff = NULL;\n");
	fprintf(prload_fp, "	if( (vr = strtoul(t, &unconv_stuff, 10)) > max_ver )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		printf(\"ERROR: failure to encode table version: %%s;  MAX allowed version: %%d\\n\",t,max_ver);\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		*(unsigned long*)k &= ~(vrmask << vrshift);						/* clear field */\n");
	fprintf(prload_fp, "		*(unsigned long*)k |= (vr & vrmask) << vrshift;\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Encode the row field of key k to (legal) value denoted in string t\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int	row_encode( hcg_key *k, char *t )\n");  /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	unsigned long rw;\n");
	fprintf(prload_fp, "	char* unconv_suff = NULL;\n");

	fprintf(prload_fp, "	if( (rw = strtoul(t, &unconv_suff, 10)) > max_row )\n");
	fprintf(prload_fp, "	  {\n");
	fprintf(prload_fp, "		printf(\"ERROR: failure to encode row value: %%s;  MAX allowed row: %%d\\n\",t,max_row);\n");
	fprintf(prload_fp, "	    return -1;\n");
	fprintf(prload_fp, "	  }\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		*(unsigned long*)k |= (rw & rwmask);\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");

	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Encode the string in external_key; return key in k\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int encode( char *external_key, hcg_key *k )\n");  /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	int		ncp;						/* no. of chars in field (in external key) */\n");
	fprintf(prload_fp, "	int		fstrt;						/* start of field index in external key */\n");
	fprintf(prload_fp, "	int		i;\n");
	fprintf(prload_fp, "	int klen;\n");
	fprintf(prload_fp, "	char t[NEW_KEY_LEN + 1];\n");
	fprintf(prload_fp, "	char field_buf[NEW_KEY_LEN + 1];\n");

	fprintf(prload_fp, "	if( (lut_st*) &hcg_table_abbrev_lut == (lut_st*)NULL ) 	/* ensure necessary tables have been initialized */\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "	  return -1;\n");
	fprintf(prload_fp, "	}\n");

	fprintf(prload_fp, "	if( (klen = strlen(external_key)) != key_len)\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		printf(\"Key encode: invalid character key length: %%d; key: %%s\\n\",klen,external_key);\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		for( i=0; i < klen; i++ )\n");
/*	fprintf(prload_fp, "		     t[i] = (isupper(external_key[i]) ? external_key[i] : toupper(external_key[i]));\n");*/
	fprintf(prload_fp, "		     t[i] = toupper((int)external_key[i]);\n"); /* Sathya */
	fprintf(prload_fp, "		*k = 0;\n");
	fprintf(prload_fp, "		ncp = (klen == OLD_KEY_LEN) ? 2 : 4;\n");
	fprintf(prload_fp, "		strncpy(field_buf,t,ncp);\n");
	fprintf(prload_fp, "		field_buf[ncp] = '\\0';\n");
	fprintf(prload_fp, "		if( abb_encode(k,field_buf) < 0 )\n");
	fprintf(prload_fp, "		{\n");
	fprintf(prload_fp, "			return -1;\n");
	fprintf(prload_fp, "		}\n");
	fprintf(prload_fp, "		else\n");
	fprintf(prload_fp, "		{\n");
	fprintf(prload_fp, "			fstrt = ncp;\n");
	fprintf(prload_fp, "			if( klen == OLD_KEY_LEN )\n");
	fprintf(prload_fp, "			{\n");
	fprintf(prload_fp, "				ncp = OLD_VER_LEN;\n");
	fprintf(prload_fp, "				field_buf[0] = '0';\n");
	fprintf(prload_fp, "				strncpy( &field_buf[1], &t[fstrt], ncp );\n");
	fprintf(prload_fp, "				field_buf[ncp+1] = '\\0';\n");
	fprintf(prload_fp, "			}\n");
	fprintf(prload_fp, "			else\n");
	fprintf(prload_fp, "			{\n");
	fprintf(prload_fp, "				ncp = NEW_VER_LEN;\n");
	fprintf(prload_fp, "				strncpy( field_buf, &t[fstrt], ncp );\n");
	fprintf(prload_fp, "				field_buf[ncp] = '\\0';\n");
	fprintf(prload_fp, "			}\n");
			
	fprintf(prload_fp, "			if( ver_encode(k, field_buf) < 0 )\n");
	fprintf(prload_fp, "			{\n");
	fprintf(prload_fp, "				return -1;\n");
	fprintf(prload_fp, "			}\n");
	fprintf(prload_fp, "			else\n");
	fprintf(prload_fp, "			{\n");
	fprintf(prload_fp, "				fstrt += ncp;\n");
	fprintf(prload_fp, "				ncp = (klen == OLD_KEY_LEN) ? OLD_ROW_LEN : NEW_ROW_LEN;\n");
	fprintf(prload_fp, "				strncpy(field_buf, &t[fstrt], ncp);\n");
	fprintf(prload_fp, "				field_buf[ncp] = '\\0';\n");

	fprintf(prload_fp, "				return ( row_encode(k, field_buf) >= 0 ) ? 1 : -1;\n");
	fprintf(prload_fp, "			}\n");
	fprintf(prload_fp, "		}\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Decode key k, return pointer to static buffer containing string\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "char* decode_retstr( hcg_key *k )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	static char external_key[NEW_KEY_LEN + 1];\n");
	fprintf(prload_fp, "	int status;\n");

	fprintf(prload_fp, "	return ( (status = decode(external_key,k)) == 1 ) ? external_key : NULL;\n");
	fprintf(prload_fp, "}\n\n");
	
	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Decode the encoded key k, return string in external_key\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int decode( char *external_key, hcg_key *k )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	char t[10];\n");
	fprintf(prload_fp, "	int klen;\n");

	fprintf(prload_fp, "	external_key[0] = '\\0';\n");

	fprintf(prload_fp, "	if( abb_decode(k,t) < 0 )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		klen = strlen(t);\n");
	fprintf(prload_fp, "		if( ((klen = strlen(t)) != OLD_ABB_LEN) && (klen != NEW_ABB_LEN) )\n");
	fprintf(prload_fp, "		{\n");
	fprintf(prload_fp, "			printf(\"ERROR: invalid key returned in decoding; key: %%s\\n\", t);\n");
	fprintf(prload_fp, "			return -1;\n");
	fprintf(prload_fp, "		}\n");
	fprintf(prload_fp, "		else\n");
	fprintf(prload_fp, "		{\n");
	fprintf(prload_fp, "			strcat( external_key, t );\n");
	fprintf(prload_fp, "			if( ver_decode(k,t) < 0 )\n");
	fprintf(prload_fp, "			{\n");
	fprintf(prload_fp, "				return -1;\n");
	fprintf(prload_fp, "			}\n");
	fprintf(prload_fp, "			else\n");
	fprintf(prload_fp, "			{\n");
	fprintf(prload_fp, "				strcat( external_key, t );\n");
	fprintf(prload_fp, "				if( row_decode(k,t) < 0 )\n");
	fprintf(prload_fp, "				{\n");
	fprintf(prload_fp, "					return -1;\n");
	fprintf(prload_fp, "				}\n");
	fprintf(prload_fp, "				else\n");
	fprintf(prload_fp, "				{\n");
	fprintf(prload_fp, "					strcat( external_key, t );\n");
	fprintf(prload_fp, "					return 1;\n");
	fprintf(prload_fp, "				}	/* row decode ok */\n");
	fprintf(prload_fp, "			}		/* ver decode ok */\n");
	fprintf(prload_fp, "		}	/* abbr of valid length */\n");
	fprintf(prload_fp, "	}	/* abb decode ok */\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Compare two keys; return value as strcmp (-1,0,1)\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int key_compare( hcg_key *k1, hcg_key *k2 )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	if( *(unsigned long*)k1 < *(unsigned long*)k2 ) return -1;\n");
	fprintf(prload_fp, "	if( *(unsigned long*)k1 == *(unsigned long*)k2 ) return 0;\n");
	fprintf(prload_fp, "	else return 1;\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Return the character abbr of the encoded key\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "char* get_abbr( hcg_key *k, char *ret )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	return (abb_decode(k,ret) >= 0) ? ret : NULL;\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Return the version no. encoded in this key\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int	  	get_version( hcg_key *k )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	return (int) (*(unsigned long*)k >> vrshift) & vrmask;\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Return the row value of the encoded key\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int  	get_row( hcg_key *k )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	return (int) (*(unsigned long*)k & rwmask );\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Set the abbr field of an encoded key to a desired value\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int 	set_abbr( hcg_key *k, char *ret )\n");  /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	return abb_encode(k,ret);\n");
    fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Set the version field of an encoded key to a desired (legal) value\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int  	set_version( hcg_key *k, int r )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	char vbuf[NEW_KEY_LEN];\n");
	fprintf(prload_fp, "	if( r > max_ver )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		sprintf(vbuf,\"%%03d\",r);\n");
	fprintf(prload_fp, "		vbuf[NEW_VER_LEN] = '\\0';\n");
	fprintf(prload_fp, "		ver_encode( k, vbuf );\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Set the row field of an encoded key to the desired legal value\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int  	set_row( hcg_key *k, int r )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	unsigned int rwi;\n");

	fprintf(prload_fp, "	rwi = (unsigned int) r;\n");

	fprintf(prload_fp, "	if( r > max_row )\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		return -1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "	else\n");
	fprintf(prload_fp, "	{\n");
	fprintf(prload_fp, "		*(unsigned long*)k &= ~(rwmask << rwshift);\n");
	fprintf(prload_fp, "		*(unsigned long*)k |= (rwi & rwmask) << rwshift;\n");
	fprintf(prload_fp, "		return 1;\n");
	fprintf(prload_fp, "	}\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      This (nkey) is used as a NULL key\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "static hcg_key nkey;\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      Return a pointer to a NULL key\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "hcg_key*\n");
	fprintf(prload_fp, "null_key(void)\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	nkey = null_key_p;\n");
	fprintf(prload_fp, "	return &nkey;\n");
	fprintf(prload_fp, "}\n\n");

	fprintf(prload_fp, "/*******************************************************************\n");
	fprintf(prload_fp, "*      The following tests a key to see if it is NULL\n");
	fprintf(prload_fp, "*******************************************************************/\n");
	fprintf(prload_fp, "int\n");
	fprintf(prload_fp, "is_null_key( hcg_key *k )\n"); /* Sathya */
	fprintf(prload_fp, "{\n");
	fprintf(prload_fp, "	return (*k == null_key_p);\n");
	fprintf(prload_fp, "}\n\n");
}