/* @(#)gen_pr_add.c	    95/05/11 */

/******************************************************************************/
/* function    : gen_pr_add.c						      */
/*									      */
/* subsystem   : chgen							      */
/*									      */
/* input       : <none>							      */
/*									      */
/* output      : <none>	(writes	to pr_load.c output file)		      */
/*									      */
/* returns     : void							      */
/*									      */
/* author      : Steve Smith / Craig Smith				      */
/*									      */
/* created     : July, 1991						      */
/*									      */
/* revisions   : added comment at line 194 - RJL 91/1/16		      */
/*	       : inserted NEWVERSION flag for 0	 version problem -CEM 19/11/92*/
/*	       : added code at line 50 - 92s523GEN - 4/24/92		      */
/*									      */
/* description : This routine writes out the code for the pr_add routine      */
/*		 to the	pr_load.c output file.	For a description of output   */
/*		 code, see the output comments below.			      */
/*									      */
/******************************************************************************/
/******************************************************************************/
/* 95s523 (V10), chwang	modifies the file to generate the btree_initialized() */
/* routine and modify pr_link()	routine.			      5,11,95 */
/******************************************************************************/


#include <stdio.h>
#include <ctype.h>
#include "chgen_define.h"
#include "chgen_externs.h"

/* 93su523 PGEN	merge (BEGIN) */

void gen_pr_link();
/* 93su523 PGEN	merge (END) */

void gen_pr_add()    /*	 generating function pr_add() */
{
	int foundnum, i;
	char parent_pkey[NAMELENGTH];
	char unpad;
/* 93su523 PGEN	merge (BEGIN) */
	struct rr_type *tmp;

	gen_pr_link_macros();
	gen_pr_link();
	gen_pr_create();
	gen_pr_add_macros();
/* 93su523 PGEN	merge (END) */

/* 93su523 PGEN	merge -- pr_add	has been significantly changed */

	fprintf(prload_fp,
"\
/******************************************************************************/\n\
/* This	routine	is used	to add a single	row to a virtual database table.      */\n\
/* Validations for valid table-id, table is within view, and the version      */\n\
/* number is the right one for this table in this view.	 if all	this passes,  */\n\
/* the row is added to the database, and linked	in to its parents, etc...     */\n\
/******************************************************************************/\n\
void gen_pr_add	(viewname, tbl_abbrv, tbl_ptr)\n\
char viewname[];\n\
char tbl_abbrv[];\n\
hcg_ptr	tbl_ptr;\n\
{\n\
	char error_table[HCG_ABBR_SIZE+1];\n\
	char tempkey[HCG_KEY_SIZE+1];\n\
	int tbl_encoding;\n\
\n\
	/* skip	leading	spaces (if any)	from tbl_abbrv */ \n\
\n\
	while( *tbl_abbrv == ' ') ++tbl_abbrv;		\n\
\n\
	if (!hcg_initialized)\n\
	{\n\
		printf(\"Error: pr_add() called when database is not yet initialized.\\n\");\n\
		exit(1);\n\
	}\n\
\n\
	if (!find_view_idx(viewname))\n\
	{\n\
		printf(\"Error: view %%s passed to pr_load is not defined.\\n\",viewname);\n\
		exit(2);\n\
	}\n\
	if (!find_tbl_idx(tbl_abbrv))\n\
	{\n\
		strncpy_null(error_table, tbl_abbrv, HCG_ABBR_SIZE);\n\
		printf(\"Warning: unknown table (%%s) passed to pr_add, ignored.\\n\",error_table);\n\
		return;\n\
	}\n\
");

#ifndef	NEW_VERSION
	fprintf(prload_fp,
"\
	if (hcg_view_list.view_list[hcg_view_idx].version_list[hcg_tbl_idx] == '\\0')\n\
	  return;\n\
");
#endif

	fprintf(prload_fp,
"\
\n\
	hcg_version = hcg_view_list.view_list[hcg_view_idx].version_list[hcg_tbl_idx];	 \n\
	hcg_table_seq_list[hcg_tbl_idx].rcount++;\n\
	hcg_ts_list[hcg_tbl_idx].ts_list[hcg_version].rcount++;\n\
\n\
	tbl_encoding = encoding( hcg_table_seq_list[hcg_tbl_idx].ttabbrev );	\n\
	switch(	tbl_encoding )\n\
	{\n\
");


/*
 *	generating cases' branches
 */
	tt_curr	= tt;
	while (	tt_curr	!= NULL)
	{
		fprintf(prload_fp,"\t\tcase %d :\t/* encoding of %s */\n",encoding(tt_curr->TTabbr), tt_curr->TTabbr);

		fprintf(prload_fp,
		  "\t\t\t%selt = (struct %s *) tbl_ptr;\n", tt_curr->TTabbr, tt_curr->TTabbr);

		ta_curr	= tt_curr->ta_ptr;

		fprintf(prload_fp,
			"\t\t\tpr_gen_pkey(viewname,%s,%selt->%s);\n",
			tt_curr->TTabbr, tt_curr->TTabbr, ta_curr->FieldName);

		for(tmp= cp_table; tmp;	tmp = tmp->next_ptr )
		{
			struct rr_data rr_entry;
			if (! pr_get_cp_entry( tmp, tt_curr->TTabbr, & rr_entry	) )
				continue;

			fprintf( prload_fp,
			    "\t\t\tpr_check_fkey(%s,%selt,%s,%s,%s,%selt);\n",
				   rr_entry.child_abbrev, rr_entry.child_abbrev, rr_entry.parent,
				   rr_entry.prnt_abbrev,  rr_entry.parent_pkey,	 rr_entry.prnt_abbrev);
		}

		while (	ta_curr	!= NULL)
		{
		  if(ta_curr->IsKey)
		  {
		      /* field is the primary/foreign key which	is already done	*/
		      ta_curr =	ta_curr->next_ptr;
		      continue;
		  }
		  else switch (	ta_curr->FieldType[0] )
		  {
		      case 'i':
		      case 'f':
			break;
		      case 'd':
			fprintf( prload_fp, "\t\t\tpr_check_str (%s,%selt,%s,%d);\n",
					tt_curr->TTabbr, tt_curr->TTabbr, ta_curr->FieldName, 26);
			break;
		      default:
			fprintf( prload_fp, "\t\t\tpr_check_str (%s,%selt,%s,%d);\n",
					tt_curr->TTabbr, tt_curr->TTabbr,
					ta_curr->FieldName, atoi(ta_curr->FieldType+1));
		  }
		  ta_curr = ta_curr->next_ptr;
		}


		fprintf(prload_fp,
			"\t\t\tpr_link(tbl_encoding);\n" );
		fprintf(prload_fp,
			"\t\t\tbreak;\n\n" );

		tt_curr	= tt_curr->next_ptr;

	} /* while tt */

	fprintf(prload_fp,"\t}\n\n");
/* I don't know if this is valid! -- MM */
	fprintf(prload_fp,"\thcg_ts_list[hcg_tbl_idx].ts_list[hcg_version].maxrow++;\n");
	fprintf(prload_fp,"}\n\n");
}

/* 93su523 PGEN	merge (BEGIN) */
gen_pr_link_macros()
{
    char *sep =	(cli_ansi)? "##" : "/**/" ;

    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp,"/* This private macro will allocate a block of memory large enough to hold the*/\n");
    fprintf(prload_fp,"/* specified table type.  It also flushes the block to binary 0 (zero), so    */\n");
    fprintf(prload_fp,"/* that pointer fields are pre-nulled.                                        */\n");
    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp,"\n#define alloc_element(tbl) \\\n");
    fprintf(prload_fp,"\ttbl%selt = (struct tbl *)malloc( sizeof(struct tbl) ); \\\n",sep);
    fprintf(prload_fp,"\tclear_mem(tbl%selt,sizeof(struct tbl))\n\n",sep);

    if (!cli_noorder)
     {
    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp,"/* This private macro will insert a row into a table.  The pkey parameter is  */\n");
    fprintf(prload_fp,"/* the name of the primary key field for the table in question.  The row is   */\n");
    fprintf(prload_fp,"/* linked into the tables row chain at the alphabetically correct location,   */\n");
    fprintf(prload_fp,"/* sorted by primary key.                                                     */\n");
    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp, "#define insert_element(tbl,pkey) \\\n");
    fprintf(prload_fp, "if (tbl == NULL) \\\n");
    fprintf(prload_fp, "{ \\\n");
    fprintf(prload_fp, "        tbl = tbl%selt; \\\n",sep);
    fprintf(prload_fp, "        tbl%send = tbl%selt; \\\n",sep,sep);
    fprintf(prload_fp, "} \\\n");
    fprintf(prload_fp, "else \\\n");
    fprintf(prload_fp, "if (key_compare(&tbl%send->pkey,&tbl%selt->pkey) < 0) \\\n",sep,sep);
    fprintf(prload_fp, "{ \\\n");
    fprintf(prload_fp, "        tbl%send->next_ptr = tbl%selt; \\\n",sep,sep);
    fprintf(prload_fp, "        tbl%selt->prev_ptr = tbl%send; \\\n",sep,sep);
    fprintf(prload_fp, "        tbl%send = tbl%selt; \\\n",sep,sep);
    fprintf(prload_fp, "} \\\n");
    fprintf(prload_fp, "else \\\n");
    fprintf(prload_fp, "{ \\\n");
    fprintf(prload_fp, "        tbl%stemp = tbl; \\\n",sep);
    fprintf(prload_fp, "        tbl%scurr = tbl; \\\n",sep);
    fprintf(prload_fp, "        while ((tbl%scurr != NULL) && (key_compare(&tbl%scurr->pkey,&tbl%selt->pkey) < 0)) \\\n",sep,sep,sep);
    fprintf(prload_fp, "        { \\\n");
    fprintf(prload_fp, "                tbl%stemp = tbl%scurr; \\\n",sep,sep);
    fprintf(prload_fp, "                tbl%scurr = tbl%scurr->next_ptr; \\\n",sep,sep);
    fprintf(prload_fp, "        } \\\n");
    fprintf(prload_fp, "        if ((tbl%scurr != NULL) && (key_compare(&tbl%scurr->pkey,&tbl%selt->pkey) == 0)) \\\n",sep,sep,sep);
    fprintf(prload_fp, "        { \\\n");
    fprintf(prload_fp, "                dup_row_warning(tbl%selt->pkey); \\\n",sep);
    fprintf(prload_fp, "                free(tbl%selt); \\\n",sep);
    fprintf(prload_fp, "                break; \\\n");
    fprintf(prload_fp, "        } \\\n");
    fprintf(prload_fp, "        if (tbl%scurr == tbl) \\\n",sep);
    fprintf(prload_fp, "        { \\\n");
    fprintf(prload_fp, "                tbl%selt->next_ptr = tbl; \\\n",sep);
    fprintf(prload_fp, "                tbl->prev_ptr    = tbl%selt; \\\n",sep);
    fprintf(prload_fp, "                tbl = tbl%selt; \\\n",sep);
    fprintf(prload_fp, "        } \\\n");
    fprintf(prload_fp, "        else \\\n");
    fprintf(prload_fp, "        { \\\n");
    fprintf(prload_fp, "                tbl%selt->next_ptr     = tbl%scurr; \\\n",sep,sep);
    fprintf(prload_fp, "                tbl%selt->prev_ptr     = tbl%stemp; \\\n",sep,sep);
    fprintf(prload_fp, "                tbl%stemp->next_ptr    = tbl%selt; \\\n",sep,sep);
    fprintf(prload_fp, "                if (tbl%scurr != NULL) \\\n",sep);
    fprintf(prload_fp, "                        tbl%scurr->prev_ptr  = tbl%selt; \\\n",sep,sep);
    fprintf(prload_fp, "        } \\\n");
    fprintf(prload_fp, "} \\\n");
    fprintf(prload_fp, "tbl%scurr = tbl%selt\n\n",sep,sep);
     }
    else
     {
    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp,"/* This private macro will insert a row into a table.  Since the -order       */\n");
    fprintf(prload_fp,"/* command-line qualifier was used to generate this code, the element is NOT  */\n");
    fprintf(prload_fp,"/* inserted in primary-key sorted order, it is inserted at the end of the     */\n");
    fprintf(prload_fp,"/* table.                                                                     */\n");
    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp, "#define insert_element(tbl,pkey) \\\n");
    fprintf(prload_fp, "\ttbl%scurr = tbl%selt;\\\n",sep,sep);
    fprintf(prload_fp, "\tif (tbl) tbl%send->next_ptr = tbl%selt; else tbl = tbl%selt; \\\n",sep,sep,sep);
    fprintf(prload_fp, "\ttbl%selt->prev_ptr = tbl%send; \\\n",sep,sep);
    fprintf(prload_fp, "\ttbl%send = tbl%selt\n\n",sep,sep);
     }


    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp,"/* This private macro will loop over the specified child table, linking the   */\n");
    fprintf(prload_fp,"/* first child it finds for this parent row.  This is acceptable since it is  */\n");
    fprintf(prload_fp,"/* supposed to be a singleton relationship.                                   */\n");
    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp, "#define link_child_1(ca,pa,cf,pk,p,c) \\\n");
    fprintf(prload_fp, "pa%scurr = pa%selt; \\\n",sep,sep);
    fprintf(prload_fp, "ca%scurr2 = ca; \\\n",sep);
    fprintf(prload_fp, "while(ca%scurr2) \\\n",sep);
    fprintf(prload_fp, "{ \\\n");
    fprintf(prload_fp, "        if (key_compare(&ca%scurr2->cf,&pa%scurr->pk) == 0) \\\n",sep,sep);
    fprintf(prload_fp, "        { \\\n");
    fprintf(prload_fp, "                ca%scurr2->p%s_pp = pa%scurr; \\\n",sep,sep,sep);
    fprintf(prload_fp, "                pa%scurr->c%s_fcp = ca%scurr2; \\\n",sep,sep,sep);
    fprintf(prload_fp, "                break; \\\n");
    fprintf(prload_fp, "        } \\\n");
    fprintf(prload_fp, "        ca%scurr2 = ca%scurr2->next_ptr; \\\n",sep,sep);
    fprintf(prload_fp, "}\n\n");


    if (!cli_nobp)
     {
      if (!cli_noorder)
       {
	fprintf(prload_fp,"/******************************************************************************/\n");
	fprintf(prload_fp,"/* This private macro will loop over the specified child table, linking any   */\n");
	fprintf(prload_fp,"/* children of this parent row.  It is identical to link_child_nobp except    */\n");
	fprintf(prload_fp,"/* that back pointers are also filled in.                                     */\n");
	fprintf(prload_fp,"/******************************************************************************/\n");
	fprintf(prload_fp, "#define link_child_bp_m(ca,pa,cf,pk,p,c) \\\n");
	fprintf(prload_fp, "pa%scurr = pa%selt; \\\n",sep,sep);
	fprintf(prload_fp, "ca%scurr2 = ca; \\\n",sep);
	fprintf(prload_fp, "while(ca%scurr2) \\\n",sep);
	fprintf(prload_fp, "{ \\\n");
	fprintf(prload_fp, "    if (key_compare(&ca%scurr2->cf,&pa%scurr->pk) == 0) \\\n",sep,sep);
	fprintf(prload_fp, "    { \\\n");
	fprintf(prload_fp, "            ca%scurr2->p%s_pp = pa%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            ca%stemp2 = pa%scurr->c%s_bcp; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            pa%scurr->c%s_bcp = ca%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            (struct pa *) ca%scurr2->p%s_fpp = pa%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            if (pa%scurr->c%s_fcp == NULL) \\\n",sep,sep);
	fprintf(prload_fp, "            { \\\n");
	fprintf(prload_fp, "                    pa%scurr->c%s_fcp = ca%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "                    (struct pa *) ca%scurr2->p%s_bpp = pa%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            } \\\n");
	fprintf(prload_fp, "            else \\\n");
	fprintf(prload_fp, "            { \\\n");
	fprintf(prload_fp, "                    (struct ca *) ca%scurr2->p%s_bpp = ca%stemp2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "                    (struct ca *) ca%stemp2->p%s_fpp = ca%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            } \\\n");
	fprintf(prload_fp, "    } \\\n");
	fprintf(prload_fp, "    ca%scurr2 = ca%scurr2->next_ptr; \\\n",sep,sep);
	fprintf(prload_fp, "}\n\n");

       }
      else
       {
	fprintf(prload_fp,"/******************************************************************************/\n");
	fprintf(prload_fp,"/* This private macro will loop over the specified child table, linking any   */\n");
	fprintf(prload_fp,"/* children of this parent row.  It is identical to link_child_nobp except    */\n");
	fprintf(prload_fp,"/* that back pointers are also filled in.  Since the -noorder command-line    */\n");
	fprintf(prload_fp,"/* qualifier was used to generate this code, the child is inserted as the     */\n");
	fprintf(prload_fp,"/* FIRST child in the chain.  This requires considerably less code than       */\n");
	fprintf(prload_fp,"/* inserting at the end of the chain.                                         */\n");
	fprintf(prload_fp,"/******************************************************************************/\n");
	fprintf(prload_fp, "#define link_child_bp_m(ca,pa,cf,pk,p,c) \\\n");
	fprintf(prload_fp, "pa%scurr = pa%selt; \\\n",sep,sep);
	fprintf(prload_fp, "ca%scurr2 = ca; \\\n",sep);
	fprintf(prload_fp, "while(ca%scurr2) \\\n",sep);
	fprintf(prload_fp, "{ \\\n");
	fprintf(prload_fp, "    if (key_compare(&ca%scurr2->cf,&pa%scurr->pk) == 0) \\\n",sep,sep);
	fprintf(prload_fp, "    { \\\n");
	fprintf(prload_fp, "            ca%scurr2->p%s_pp = pa%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            (struct pa *) ca%scurr2->p%s_bpp = pa%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            (struct pa *) ca%scurr2->p%s_fpp = pa%scurr->c%s_fcp; \\\n",sep,sep,sep,sep);
	fprintf(prload_fp, "            ca%stemp2 = pa%scurr->c%s_fcp; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            pa%scurr->c%s_fcp = ca%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            if (ca%stemp2 != NULL) \\\n",sep);
	fprintf(prload_fp, "                    (struct ca *) ca%stemp2->p%s_bpp = ca%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "    } \\\n");
	fprintf(prload_fp, "    ca%scurr2 = ca%scurr2->next_ptr; \\\n",sep,sep);
	fprintf(prload_fp, "}\n\n");
       } /* if !cli_noorder */
     }

    if (!cli_noorder)
     {
      fprintf(prload_fp,"/******************************************************************************/\n");
      fprintf(prload_fp,"/* This private macro will loop over the specified child table, linking any   */\n");
      fprintf(prload_fp,"/* children of this parent row.  It is identical to link_child_bp except      */\n");
      fprintf(prload_fp,"/* that back pointers are not filled in.  Because there are no back-ptrs,     */\n");
      fprintf(prload_fp,"/* the last child in the chain must be found via a search loop over the       */\n");
      fprintf(prload_fp,"/* children.                                                                  */\n");
      fprintf(prload_fp,"/******************************************************************************/\n");
      fprintf(prload_fp, "#define link_child_nobp_m(ca,pa,cf,pk,p,c) \\\n");
      fprintf(prload_fp, "pa%scurr = pa%selt; \\\n",sep,sep);
      fprintf(prload_fp, "ca%scurr2 = ca; \\\n",sep);
      fprintf(prload_fp, "while(ca%scurr2) \\\n",sep);
      fprintf(prload_fp, "{ \\\n");
      fprintf(prload_fp, "      if (key_compare(&ca%scurr2->cf,&pa%scurr->pk) == 0) \\\n",sep,sep);
      fprintf(prload_fp, "      { \\\n");
      fprintf(prload_fp, "              ca%scurr2->p%s_pp = pa%scurr; \\\n",sep,sep,sep);
      fprintf(prload_fp, "              (struct pa *) ca%scurr2->p%s_fpp = pa%scurr; \\\n",sep,sep,sep);
      fprintf(prload_fp, "              if (pa%scurr->c%s_fcp == NULL) \\\n",sep,sep);
      fprintf(prload_fp, "              { \\\n");
      fprintf(prload_fp, "                      pa%scurr->c%s_fcp = ca%scurr2; \\\n",sep,sep,sep);
      fprintf(prload_fp, "              } \\\n");
      fprintf(prload_fp, "              else \\\n");
      fprintf(prload_fp, "              { \\\n");
      fprintf(prload_fp, "                  for (ca%stemp2 = pa%scurr->c%s_fcp; (struct pa *) ca%stemp2->p%s_fpp != pa%scurr; ca%stemp2 = (struct ca *)ca%stemp2->p%s_fpp); \\\n",sep,sep,sep,sep,sep,sep,sep,sep,sep);
      fprintf(prload_fp, "                      (struct ca *) ca%stemp2->p%s_fpp = ca%scurr2; \\\n",sep,sep,sep);
      fprintf(prload_fp, "              } \\\n");
      fprintf(prload_fp, "              ca%stemp2 = ca%scurr2; \\\n",sep,sep);
      fprintf(prload_fp, "      } \\\n");
      fprintf(prload_fp, "      ca%scurr2 = ca%scurr2->next_ptr; \\\n",sep,sep);
      fprintf(prload_fp, "}\n\n");
     }
    else
     {
      fprintf(prload_fp,"/******************************************************************************/\n");
      fprintf(prload_fp,"/* This private macro will loop over the specified child table, linking any   */\n");
      fprintf(prload_fp,"/* children of this parent row.  It is identical to link_child_bp except      */\n");
      fprintf(prload_fp,"/* that back pointers are not filled in.  Because there are no back-ptrs,     */\n");
      fprintf(prload_fp,"/* the last child in the chain must be found via a search loop over the       */\n");
      fprintf(prload_fp,"/* children.  Since the -noorder command-line was used to generate this code, */\n");
      fprintf(prload_fp,"/* the child is inserted as the FIRST child in the chain.  This requires      */\n");
      fprintf(prload_fp,"/* considerably less code than inserting at the end of the chain.             */\n");
      fprintf(prload_fp,"/******************************************************************************/\n");
      fprintf(prload_fp, "#define link_child_nobp_m(ca,pa,cf,pk,p,c) \\\n");
      fprintf(prload_fp, "pa%scurr = pa%selt; \\\n",sep,sep);
      fprintf(prload_fp, "ca%scurr2 = ca; \\\n",sep);
      fprintf(prload_fp, "while(ca%scurr2) \\\n",sep);
      fprintf(prload_fp, "{ \\\n");
      fprintf(prload_fp, "      if (key_compare(&ca%scurr2->cf,&pa%scurr->pk) == 0) \\\n",sep,sep);
      fprintf(prload_fp, "      { \\\n");
      fprintf(prload_fp, "              ca%scurr2->p%s_pp = pa%scurr; \\\n",sep,sep,sep);
      fprintf(prload_fp, "              (struct pa *) ca%scurr2->p%s_fpp = pa%scurr->c%s_fcp; \\\n",sep,sep,sep,sep);
      fprintf(prload_fp, "              pa%scurr->c%s_fcp = ca%scurr2; \\\n",sep,sep,sep);
      fprintf(prload_fp, "      } \\\n");
      fprintf(prload_fp, "      ca%scurr2 = ca%scurr2->next_ptr; \\\n",sep,sep);
      fprintf(prload_fp, "}\n\n");
     } /* if !cli_noorder */

   fprintf(prload_fp,"/******************************************************************************/\n");
   fprintf(prload_fp,"/* This private macro will loop over the specified parent table, linking any  */\n");
   fprintf(prload_fp,"/* parents of this child row.  It is identical to link_parent_nobp except     */\n");
   fprintf(prload_fp,"/* that it is assumed to be a singleton child.                                */\n");
   fprintf(prload_fp,"/******************************************************************************/\n");
   fprintf(prload_fp, "#define link_parent_1(ca,pa,cf,pk,p,c) \\\n");
   if (!cli_noorder)
     fprintf(prload_fp,	"       for (pa%scurr2 = pa; (pa%scurr2 != NULL) && (key_compare(&pa%scurr2->pk,&ca%scurr->cf) < 0); pa%scurr2 = pa%scurr2->next_ptr); \\\n",sep,sep,sep,sep,sep,sep);
   else
     fprintf(prload_fp,	"       for (pa%scurr2 = pa; (pa%scurr2 != NULL) && (key_compare(&pa%scurr2->pk,&ca%scurr->cf) != 0); pa%scurr2 = pa%scurr2->next_ptr); \\\n",sep,sep,sep,sep,sep,sep);
   fprintf(prload_fp, " if ((pa%scurr2 != NULL) && (key_compare(&ca%scurr->cf,&pa%scurr2->pk) == 0)) \\\n",sep,sep,sep);
   fprintf(prload_fp, " { \\\n");
   fprintf(prload_fp, "         ca%scurr->p%s_pp = pa%scurr2; \\\n",sep,sep,sep);
   fprintf(prload_fp, "         pa%scurr2->c%s_fcp = ca%scurr; \\\n",sep,sep,sep);
   fprintf(prload_fp, " }");
   if (cli_noforward)
    {
     fprintf(prload_fp,	"\\\nif (ca%scurr->p%s_pp == NULL) \\\n",sep,sep);
     fprintf(prload_fp,	"       forward_ref_warning(ca%scurr->ca%sid,ca%scurr->cf)",sep,sep,sep);
    }
   fprintf(prload_fp, "\n\n");

    if (!cli_nobp)
     {
      if (!cli_noorder)
       {
	fprintf(prload_fp,"/******************************************************************************/\n");
	fprintf(prload_fp,"/* This private macro will loop over the specified parent table, linking any  */\n");
	fprintf(prload_fp,"/* parents of this child row.  It is identical to link_parent_nobp except     */\n");
	fprintf(prload_fp,"/* that back pointers are also filled in.                                     */\n");
	fprintf(prload_fp,"/*                                                                            */\n");
       }
      else
       {
	fprintf(prload_fp,"/******************************************************************************/\n");
	fprintf(prload_fp,"/* This private macro will loop over the specified parent table, linking any  */\n");
	fprintf(prload_fp,"/* parents of this child row.  It is identical to link_parent_nobp except     */\n");
	fprintf(prload_fp,"/* that back pointers are also filled in.  Since the -noorder command-line    */\n");
	fprintf(prload_fp,"/* qualifier was used to generate this code,  the child is inserted as        */\n");
	fprintf(prload_fp,"/* the FIRST child in the chain.  This requires considerably less code than   */\n");
	fprintf(prload_fp,"/* inserting at the end of the chain.                                         */\n");
	fprintf(prload_fp,"/*                                                                            */\n");
       }
      if (cli_noforward)
       {
	fprintf(prload_fp,"/* NOTE: Since the -noforward command-line qualifier was used to generate this*/\n");
	fprintf(prload_fp,"/*       code, a check is included at the bottom of this macro.  The check    */\n");
	fprintf(prload_fp,"/*       ensures that the parent record was found.  If not, a warning is      */\n");
	fprintf(prload_fp,"/*       printed.  In addition, using this flag means that calls to link_     */\n");
	fprintf(prload_fp,"/*       child_{no}bp are not included in pr_add.  Link child is only needed  */\n");
	fprintf(prload_fp,"/*       when there is a risk of forward references in the data file.         */\n");
       }
      else
       {
	fprintf(prload_fp,"/* NOTE: Since the -noforward command-line qualifier was NOT used to generate */\n");
	fprintf(prload_fp,"/*       this code, no check is included to ensure that a parent row was      */\n");
	fprintf(prload_fp,"/*       actually found.  Performance and code size are sacrificed here, since*/\n");
	fprintf(prload_fp,"/*       calls to link_child_{no}bp are included in the caller (pr_add).      */\n");
	fprintf(prload_fp,"/*       Link child is only needed when there is a risk of forward references */\n");
	fprintf(prload_fp,"/*       in the data file.                                                    */\n");
       }

      fprintf(prload_fp,"/*                                                                            */\n");
      fprintf(prload_fp,"/******************************************************************************/\n");

      if (!cli_noorder)
       {
	fprintf(prload_fp, "#define link_parent_bp_m(ca,pa,cf,pk,p,c) \\\n");
	fprintf(prload_fp, "    for (pa%scurr2 = pa; (pa%scurr2 != NULL) && (key_compare(&pa%scurr2->pk,&ca%scurr->cf) < 0); pa%scurr2 = pa%scurr2->next_ptr); \\\n",sep,sep,sep,sep,sep,sep);
	fprintf(prload_fp, "    if ((pa%scurr2 != NULL) && (key_compare(&ca%scurr->cf,&pa%scurr2->pk) == 0)) \\\n",sep,sep,sep);

	fprintf(prload_fp, "    { \\\n");
	fprintf(prload_fp, "            ca%scurr->p%s_pp = pa%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            ca%stemp = pa%scurr2->c%s_bcp; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            pa%scurr2->c%s_bcp = ca%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            (struct pa *) ca%scurr->p%s_fpp = pa%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            if (pa%scurr2->c%s_fcp == NULL) \\\n",sep,sep);
	fprintf(prload_fp, "            { \\\n");
	fprintf(prload_fp, "                    pa%scurr2->c%s_fcp = ca%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "                    (struct pa *) ca%scurr->p%s_bpp = pa%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            } \\\n");
	fprintf(prload_fp, "            else \\\n");
	fprintf(prload_fp, "            { \\\n");
	fprintf(prload_fp, "                    (struct ca *) ca%scurr->p%s_bpp = ca%stemp; \\\n",sep,sep,sep);
	fprintf(prload_fp, "                    (struct ca *) ca%stemp->p%s_fpp = ca%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            } \\\n");
	fprintf(prload_fp, "    }");
	if (cli_noforward)
	 {
	  fprintf(prload_fp, "\\\nif (ca%scurr->p%s_pp == NULL) \\\n",sep,sep);
	  fprintf(prload_fp, "  forward_ref_warning(ca%scurr->ca%sid,ca%scurr->cf)",sep,sep,sep);
	 }
	fprintf(prload_fp, "\n\n");

       } /* if !cli_noorder */
      else
       {

	fprintf(prload_fp, "#define link_parent_bp_m(ca,pa,cf,pk,p,c) \\\n");
	fprintf(prload_fp, "    for (pa%scurr2 = pa; (pa%scurr2 != NULL) && (key_compare(&pa%scurr2->pk,&ca%scurr->cf) != 0); pa%scurr2 = pa%scurr2->next_ptr); \\\n",sep,sep,sep,sep,sep,sep);
	fprintf(prload_fp, "    if ((pa%scurr2 != NULL) && (key_compare(&ca%scurr->cf,&pa%scurr2->pk) == 0)) \\\n",sep,sep,sep);

	fprintf(prload_fp, "    { \\\n");
	fprintf(prload_fp, "            ca%scurr->p%s_pp = pa%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            (struct pa *) ca%scurr->p%s_bpp = pa%scurr2; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            (struct pa *) ca%scurr->p%s_fpp = pa%scurr2->c%s_fcp; \\\n",sep,sep,sep,sep);
	fprintf(prload_fp, "            ca%stemp = pa%scurr2->c%s_fcp; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            pa%scurr2->c%s_fcp = ca%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "            if (ca%stemp != NULL) \\\n",sep);
	fprintf(prload_fp, "                    (struct ca *) ca%stemp->p%s_bpp = ca%scurr; \\\n",sep,sep,sep);
	fprintf(prload_fp, "    }");
	if (cli_noforward)
	 {
	  fprintf(prload_fp, "\\\nif (ca%scurr->p%s_pp == NULL) \\\n",sep,sep);
	  fprintf(prload_fp, "  forward_ref_warning(ca%scurr->ca%sid,ca%scurr->cf)",sep,sep,sep);
	 }
	fprintf(prload_fp, "\n\n");

       } /* else of if !cli_noorder */

     } /* if !cli_nobp */

    fprintf(prload_fp,"/******************************************************************************/\n");
    fprintf(prload_fp,"/* This private macro will loop over the specified parent table, linking any  */\n");
    fprintf(prload_fp,"/* parents of this child row.  It is identical to link_parent_nobp except     */\n");
    fprintf(prload_fp,"/* that back pointers are not filled in.  Because there are no back-ptrs,     */\n");
    fprintf(prload_fp,"/* the last child in the chain must be found via a search loop over the       */\n");
    fprintf(prload_fp,"/* children.                                                                  */\n");
    fprintf(prload_fp,"/*                                                                            */\n");
    if (cli_noforward)
     {
      fprintf(prload_fp,"/* NOTE: Since the -noforward command-line qualifier was used to generate this*/\n");
      fprintf(prload_fp,"/*       code, a check is included at the bototom of this macro.  The check   */\n");
      fprintf(prload_fp,"/*       ensures that the parent record was found.  If not, a warning is      */\n");
      fprintf(prload_fp,"/*       printed.  In addition, using this flag means that calls to link_     */\n");
      fprintf(prload_fp,"/*       child_{no}bp are not included in pr_add.  Link child is only needed  */\n");
      fprintf(prload_fp,"/*       when there is a risk of forward references in the data file.         */\n");
     }
    else
     {
      fprintf(prload_fp,"/* NOTE: Since the -noforward command-line qualifier was NOT used to generate */\n");
      fprintf(prload_fp,"/*       this code, no check is included to ensure that a parent row was      */\n");
      fprintf(prload_fp,"/*       actually found.  Performance and code size are sacrificed here, since*/\n");
      fprintf(prload_fp,"/*       calls to link_child_{no}bp are included in the caller (pr_add).      */\n");
      fprintf(prload_fp,"/*       Link child is only needed when there is a risk of forward references */\n");
      fprintf(prload_fp,"/*       in the data file.                                                    */\n");
     }

    fprintf(prload_fp,"/*                                                                            */\n");
    fprintf(prload_fp,"/******************************************************************************/\n");

    if (!cli_noorder)
     {
      fprintf(prload_fp, "#define link_parent_nobp_m(ca,pa,cf,pk,p,c) \\\n");
      fprintf(prload_fp, "for (pa%scurr2 = pa; (pa%scurr2 != NULL) && (key_compare(&pa%scurr2->pk,&ca%scurr->cf) < 0); pa%scurr2 = pa%scurr2->next_ptr); \\\n",sep,sep,sep,sep,sep,sep);
      fprintf(prload_fp, "if ((pa%scurr2 != NULL) && (key_compare(&ca%scurr->cf,&pa%scurr2->pk) == 0)) \\\n",sep,sep,sep);

      fprintf(prload_fp, "{ \\\n");
      fprintf(prload_fp, "      ca%scurr->p%s_pp = pa%scurr2; \\\n",sep,sep,sep);
      fprintf(prload_fp, "      (struct pa *) ca%scurr->p%s_fpp = pa%scurr2; \\\n",sep,sep,sep);
      fprintf(prload_fp, "      if (pa%scurr2->c%s_fcp == NULL) \\\n",sep,sep);
      fprintf(prload_fp, "              pa%scurr2->c%s_fcp = ca%scurr; \\\n",sep,sep,sep);
      fprintf(prload_fp, "      else \\\n");
      fprintf(prload_fp, "      { \\\n");
      fprintf(prload_fp, "              for (ca%stemp2 = pa%scurr2->c%s_fcp; (struct pa *) ca%stemp2->p%s_fpp != pa%scurr2; ca%stemp2 = (struct ca *)ca%stemp2->p%s_fpp); \\\n",sep,sep,sep,sep,sep,sep,sep,sep,sep);
      fprintf(prload_fp, "              (struct ca *) ca%stemp2->p%s_fpp = ca%scurr; \\\n",sep,sep,sep);
      fprintf(prload_fp, "      } \\\n");
      fprintf(prload_fp, "}");
      if (cli_noforward)
       {
	fprintf(prload_fp, "\\\nif (ca%scurr->p%s_pp == NULL) \\\n",sep,sep);
	fprintf(prload_fp, "    forward_ref_warning(ca%scurr->ca%sid,ca%scurr->cf)",sep,sep,sep);
       }
      fprintf(prload_fp, "\n\n");
     } /* if !cli_noorder */
    else
     {
      fprintf(prload_fp, "#define link_parent_nobp_m(ca,pa,cf,pk,p,c) \\\n");
      fprintf(prload_fp, "for (pa%scurr2 = pa; (pa%scurr2 != NULL) && (key_compare(&pa%scurr2->pk,&ca%scurr->cf) != 0); pa%scurr2 = pa%scurr2->next_ptr); \\\n",sep,sep,sep,sep,sep,sep);
      fprintf(prload_fp, "if ((pa%scurr2 != NULL) && (key_compare(&ca%scurr->cf,&pa%scurr2->pk) == 0)) \\\n",sep,sep,sep);

      fprintf(prload_fp, "{ \\\n");
      fprintf(prload_fp, "      ca%scurr->p%s_pp = pa%scurr2; \\\n",sep,sep,sep);
      fprintf(prload_fp, "      (struct pa *) ca%scurr->p%s_fpp = pa%scurr2->c%s_fcp; \\\n",sep,sep,sep,sep);
      fprintf(prload_fp, "      pa%scurr2->c%s_fcp = ca%scurr; \\\n",sep,sep,sep);
      fprintf(prload_fp, "}");
      if (cli_noforward)
       {
	fprintf(prload_fp, "\\\nif (ca%scurr->p%s_pp == NULL) \\\n",sep,sep);
	fprintf(prload_fp, "    forward_ref_warning(ca%scurr->ca%sid,ca%scurr->cf)",sep,sep,sep);
       }
      fprintf(prload_fp, "\n\n");
     } /* if !cli_noorder */

}

void gen_pr_link()    /*  generating function pr_link()	*/
{
	struct rr_type *tmp;
	struct rr_data rr_entry;

	fprintf(prload_fp,
"\
/******************************************************************************/\n\
/* This	routine	is used	to link	a single row to	a virtual database table.     */\n\
/******************************************************************************/\n\
\n\
void pr_link (tbl_encoding)\n\
	int tbl_encoding;\n\
{\n\
\n\
	switch(	tbl_encoding )	\n\
	{\n\
");

/*
 *	generating cases' branches
 */
	tt_curr	= tt;
	while (	tt_curr	!= NULL)
	{
		fprintf(prload_fp,"\t\tcase %d :\t/* encoding of %s */\n",
				 encoding(tt_curr->TTabbr), tt_curr->TTabbr);

		fprintf(prload_fp, "\t\t\tinsert_element(%s,%s);\n", tt_curr->TTabbr, tt_curr->ta_ptr->FieldName);

/*** 95s523,chwang,5,11,95. Judge the comment in order to add the row into btree or not	***/
/*** ---lines begin--- ***/
		if( tt_curr->comment[0]	!= '\0')
		    if(	tt_curr->comment[2] == '1')
		       fprintf(prload_fp, "\t\t\tbtree_add_row(%s);\n",	tt_curr->TTabbr);
/*** ---lines end--- ***/

		if (!cli_noforward)
		{
			/* for each of the pc_table entries, generating	a while	loop linking
			all the	rings accordingly */

			for(tmp	= pc_table; tmp; tmp = tmp->next_ptr)
			{
				if ( ! pr_get_pc_entry(	tmp, tt_curr->TTabbr, &rr_entry) )
				   continue;

				fprintf(prload_fp,"\t\t\tlink_child_");

				if (tmp->Singleton)
					fprintf(prload_fp,"1");
				else
				{
					if ((!cli_nobp)	&& (tmp->HasBp))
						fprintf(prload_fp, "bp_m");
					else
						fprintf(prload_fp, "nobp_m");
				}

				fprintf(prload_fp,"(%s,%s,%s,%s,%s,%s);\n",
					rr_entry.child_abbrev, rr_entry.prnt_abbrev,
					rr_entry.parent, rr_entry.parent_pkey, rr_entry.parent,	rr_entry.child);

			}
		} /* if	cli_noforward */

		/* for each of the cp_table entries, generating	a while	loop linking
		all the	rings accordingly */

		for(tmp= cp_table; tmp;	tmp = tmp->next_ptr )
		{
			if( ! pr_get_cp_entry( tmp, tt_curr->TTabbr, &rr_entry ) )
				continue;

			fprintf(prload_fp,"\t\t\tlink_parent_");

			if (tmp->Singleton)
				fprintf(prload_fp,"1");
			else
			{
				if ((!cli_nobp)	&& (tmp->HasBp))
					fprintf(prload_fp,"bp_m");
				else
					fprintf(prload_fp,"nobp_m");
			}

			fprintf(prload_fp,"(%s,%s,%s,%s,%s,%s);\n",
				rr_entry.child_abbrev, rr_entry.prnt_abbrev,
				rr_entry.parent, rr_entry.parent_pkey, rr_entry.parent,	rr_entry.child);

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

		tt_curr	= tt_curr->next_ptr;

	} /* while tt */

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

pr_get_pc_entry( tmp, TTabbr, pc_entry)
	register struct	rr_type	*tmp;
	char *TTabbr;
	struct rr_data *pc_entry;
{
	int foundnum, i;

	if (strncmp(tmp->firstid, TTabbr, hcg_abbr_size) != 0)
	{
		return 0;
	}

	/* getting table type and abbreviates for parent and child */
	strncpy_null(	pc_entry->prnt_abbrev,	tmp->firstid, hcg_abbr_size);
	strcpy(		pc_entry->parent,	tmp->firstid);
	strncpy_null(	pc_entry->child_abbrev,	tmp->secondid, hcg_abbr_size);
	strcpy(		pc_entry->child,	tmp->secondid);

	strcpy(	pc_entry->parent_pkey, pc_entry->parent);
	foundnum = 0;
	i = 0 ;
	while (	(!foundnum) && (i < strlen(pc_entry->parent) ))
		if (isdigit( pc_entry->parent[i]) != 0)
			foundnum = 1;
		else
			i++ ;
	if (foundnum)
	   pc_entry->parent_pkey[i] = '\0';

	return 1;
}

pr_get_cp_entry( tmp, TTabbr, cp_entry )
	char *TTabbr;
	register struct	rr_type	*tmp;
	struct rr_data *cp_entry;
{
	int foundnum, i;

	if (strncmp(tmp->firstid, TTabbr, hcg_abbr_size) != 0 )
	{
		return 0;
	}

	/* getting table type and abbreviates for parent and child */
	strncpy_null(	cp_entry->child_abbrev,	tmp->firstid, hcg_abbr_size);
	strcpy(		cp_entry->child,	tmp->firstid);
	strncpy_null(	cp_entry->prnt_abbrev,	tmp->secondid, hcg_abbr_size);
	strcpy(		cp_entry->parent,	tmp->secondid);

	strcpy(		cp_entry->parent_pkey,	cp_entry->parent);
	foundnum = 0;
	i = 0 ;
	while (	(!foundnum) && (i < strlen(cp_entry->parent)))
		  if  (isdigit(cp_entry->parent[i]) != 0)
			foundnum = 1;
		  else
			i++ ;
	if (foundnum)
		cp_entry->parent_pkey[i] = '\0';

	return 1;
}

/*** 93s523  PGEN  ***/
gen_pr_create()
{
	fprintf(prload_fp,
"\n\
/******************************************************************************/\n\
/* This	routine	is used	to create a table element and initialize it.	      */\n\
/******************************************************************************/\n\
						\n\
hcg_ptr	pr_gen_create (	size )			\n\
   int size;					\n\
{						\n\
   hcg_ptr ptr = (hcg_ptr) malloc(size);	\n\
   bzero(ptr, size); /*	or memset(ptr, 0, size); */\n\
   /* This should also set all the keys	to null_key() but doesn't right now -- MM */\n\
   return ptr;					\n\
}						\n\
");

}

gen_pr_add_macros()
{

	char *sep, *bq,	*eq;

	if (cli_ansi)
		{
		bq = "#";
		eq = "";
		sep = "##";
		}
	else
		{
		sep = "/**/";
		bq = eq	= "\"";
		}


	fprintf(prload_fp,"\
/******************************************************************************/\n\
/* This	macro is used to generate the next available primary key value for the*/\n\
/* specified table, using the specified	view.				      */\n\
/******************************************************************************/\n\
										\n\
#define	pr_gen_key(key,tbl_abbrv,version_id,entry_id) \\\n\
    (key) = *null_key();\\\n\
    set_abbr(&(key), (tbl_abbrv));\\\n\
    set_version(&(key),	(version_id));\\\n\
    set_row(&(key), (entry_id))\\\n\
");

	fprintf(prload_fp,"\
\n\
#define	pr_gen_pkey(viewname,tbl,pkey) \\\n\
   if (find_view_idx(viewname))	\\\n\
	 pr_gen_key(pkey,hcg_table_seq_list[tbl%s_idx].ttabbrev, \\\n\
	 (char)	hcg_view_list.view_list[hcg_view_idx].version_list[tbl%s_idx], \\\n\
	 hcg_ts_list[tbl%s_idx].ts_list[hcg_view_list.view_list[hcg_view_idx].version_list[tbl%s_idx]].maxrow+1)\n\
\n\
\n\
#define	pr_check_fkey(ctbl_abbr,ctbl_ptr,ckey,ptbl_abbr,pkey,ptbl_ptr) \\\n\
   if (	is_null_key(&((ctbl_ptr)->ckey)) || (ctbl_ptr)->ckey ==	0 ) {\\\n\
      if (!hcg_default_fkey) {\\\n\
	 printf(\"Warning: foreign key %%s is not set for table %%s element 0x%%8.8x\\n\", \\\n\
		    %sckey%s, %sctbl_abbr%s, ctbl_ptr );\\\n\
	 pr_gen_key( (ctbl_ptr)->ckey,%sptbl_abbr%s, 0,	0);\\\n\
      }\\\n\
      else if (	(ptbl_ptr) && (	!is_null_key(&((ptbl_ptr)->pkey)) ) && ( (ptbl_ptr)->pkey != 0)	) {\\\n\
	 (ctbl_ptr)->ckey = (ptbl_ptr)->pkey;\\\n\
      }\\\n\
      else {\\\n\
	 pr_gen_key( (ctbl_ptr)->ckey, %sptbl_abbr%s, 0, 0);\\\n\
      }\\\n\
   }\n\
\n\
/******************************************************************************/\n\
/* This	macro is used set the default value of non-key fields of type cX or tX*/\n\
/******************************************************************************/\n\
\n\
#define	pr_check_str(tbl_abbr,tbl_ptr,fld,length) \\\n\
	if ( (tbl_ptr)->fld[0] == '\\0'	) \\\n\
	   {\\\n\
	   int i = sizeof((tbl_ptr)->fld) - 2;\\\n\
	   printf(\"Warning: string field %%s is not set for table %%s element 0x%%8.8x\\n\", \\\n\
		%sfld%s, %stbl_abbr%s, tbl_ptr);\\\n\
	   for((tbl_ptr)->fld[i] = '\\0'; i>=0;	(tbl_ptr)->fld[i--] = '?');\\\n\
	   }\n\
\n\
", sep, sep, sep, sep,
   bq, eq, bq, eq,
   bq, eq, bq, eq,
   bq, eq, bq, eq,
   bq, eq
);


}
/* 93su523 PGEN	merge (END) */