/* @(#)gen_pr_add.c 95/05/11 */ /******************************************************************************/ /* function : gen_pr_add.c */ /* */ /* subsystem : chgen */ /* */ /* input : */ /* */ /* output : (writes to pr_load.c output file) */ /* */ /* returns : void */ /* */ /* author : Sathyanarayan Jaganathan */ /* */ /* created : July, 1991 */ /* */ /* revisions : Nov 2001: modified to fix warnings for BDE - sjaganat */ /* (code change for 50 lines approx.) */ /* */ /* : 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 */ /* : included #include and added assert macro */ /* : to link_child_1 macro -RJL 94/12/6 */ /* : inserted logging code throughout - GENLOG 96s523 -DN */ /* */ /* 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 #include #include "chgen_define.h" #include "chgen_externs.h" #include /* 93su523 PGEN merge (BEGIN) */ /* // GENMERGE: structure definition of rr_data moved tp chgen_externs.h by GENLOG */ void gen_pr_link(); /* 93su523 PGEN merge (END) */ void gen_pr_add() /* generating function pr_add() */ { static char rcsid[] = ""; 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) */ if (cli_log == 1) /* GENLOG 96s523 - DN */ gen_pr_add_log(); /* 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 do_pr_add (char *viewname, char *tbl_abbrv, 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"); if (cli_log == 1) fprintf(prload_fp,"\ char VNstring[NAMELENGTH] = \"VN \"; \n"); fprintf(prload_fp,"\ \n\ /* skip leading spaces (if any) from tbl_abbrv */ \n\ \n\ while( *tbl_abbrv == ' ') ++tbl_abbrv; \n\ \n"); /* added for GENLOG logging 96s523 */ if (cli_log == 1) { fprintf(prload_fp,"\ if (hcg_log == 1)\n\ {\n\ /* Add Wait line to log */\n\ logwait();\n\n\ /* Write out viewname, if changed */\n\ if (strcmp(viewname, hcg_viewname))\n\ {\n\ logstr(strcat (strcat (VNstring, viewname), \"\\n\"));\n\ strcpy (hcg_viewname, viewname);\n\ };\n\ };\n\n"); } /* (END) GENLOG 96s523 */ fprintf(prload_fp, "\n\ if (!hcg_initialized)\n\ {\n\ printf(\"Error: [do_]pr_add ignored - database not initialized.\\n\");\n"); /* added for GENLOG logging 96s523 */ if (cli_log == 1) { fprintf(prload_fp,"\ /*log_pr_add (tbl_abbrv, viewname, tbl_ptr); */\n"); } /* (END) GENLOG 96s523 */ /* GENMERGE: AS: Noticed that genlog project replaced "exit(1)" statement // with a "return" statement below. No explanation given // for this change. This could be a bug, since origianl // GEN v10 code uses "exit" for errors and "return" for warnings" */ fprintf(prload_fp,"\ return;\n\ }\n\ \n\ if (!find_view_idx(viewname))\n\ {\n\ printf(\"[do_]pr_add ignored; view %%s not found.\\n\",viewname);\n"); /* added for GENLOG logging 96s523 */ if (cli_log == 1) { fprintf(prload_fp,"\ /*log_pr_add (tbl_abbrv, viewname, tbl_ptr); */\n"); } /* (END) GENLOG 96s523 */ /* GENMERGE: AS: Noticed that genlog project replaced "exit(2)" statement // with a "return" statement below. No explanation given // for this change. This could be a bug, since origianl // GEN v10 code uses "exit" for errors and "return" for warnings" */ fprintf(prload_fp,"\ return; \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"); /* added for GENLOG logging 96s523 */ if (cli_log == 1) { fprintf(prload_fp,"\ /*log_pr_add (tbl_abbrv, viewname, tbl_ptr); */\n"); } /* (END) GENLOG 96s523 */ fprintf(prload_fp,"\ 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': if (strcmp(tt_curr->TTabbr, "FO") == 0) { fprintf( prload_fp, "\t\t\t assert(strlen( %selt->%s)>0);",tt_curr->TTabbr, ta_curr->FieldName); } 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: if (strcmp(tt_curr->TTabbr, "FO") == 0) { fprintf( prload_fp, "\t\t\t assert(strlen( %selt->%s)>0);",tt_curr->TTabbr, ta_curr->FieldName); } 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; } /* added for GENLOG logging 96s523 */ if (cli_log == 1) { if (strcmp(tt_curr->TTabbr, "FO") == 0) fprintf(prload_fp,"\t\t\tassert(strlen(viewname)>0);\n"); fprintf(prload_fp,"\t\t\tlog_pr_add (\"%s\", viewname, %selt);\n",tt_curr->TTabbr, tt_curr->TTabbr); } 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,"/* The assert macro aborts if more than one child is linked in - RJL 94/12/6 */\n"); fprintf(prload_fp,"/* assert (loosely) allows NULL or self-pointer in the current parent */\n"); fprintf(prload_fp,"/******************************************************************************/\n"); fprintf(prload_fp, "#define link_child_1(ca,pa,cf,pk,p,c) \\\n"); fprintf(prload_fp, "assert(pa%scurr->c%s_fcp == NULL || pa%scurr->c%s_fcp == pa%scurr);\\\n",sep,sep,sep,sep,sep); 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 ( unsigned long 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_no,next_row_no) \\\n\ do{\\\n\ (key) = *null_key();\\\n\ set_abbr(&(key), (tbl_abbrv));\\\n\ set_version(&(key), (version_no));\\\n\ set_row(&(key), (next_row_no));\\\n\ } while(0)\n"); /* Sathya */ fprintf(prload_fp,"\ /******************************************************************************/\n\ /* Macro pr_gen_pkey calls find_view_idx to validate current viewname, */\n\ /* gets args from hcg_* structs and calls pr_gen_key to update pkey; */\n\ /* if validation fails, *pkey is initialized to 0; */\n\ /* pkey is target ptr; tt is unquoted ttype, tbl_abbrv is char * */\n\ /******************************************************************************/\n\ #define pr_gen_pkey(viewname, tt, pkey) \\\n\ do {\\\n\ if (find_view_idx(viewname)){\\\n\ int version_no, next_row_no, tt%sidx;\\\n\ char *tbl_abbrv;\\\n\ tt%sidx = (int) hcg_tbl_idx;\\\n\ tbl_abbrv = hcg_table_seq_list[tt%sidx].ttabbrev;\\\n\ assert(strcmp(tbl_abbrv, %stt) == 0);\\\n\ version_no = (hcg_view_list.view_list[hcg_view_idx].version_list[tt%sidx]);\\\n\ next_row_no = (hcg_ts_list[tt%sidx].ts_list[(int)hcg_view_list.view_list[hcg_view_idx].version_list[tt%sidx]].maxrow+1);\\\n\ pr_gen_key(pkey, tbl_abbrv, version_no, next_row_no ); \\\n\ } \\\n\ else pkey = *null_key(); \\\n\ } while (0);\n\ \n\ \n",sep,sep,sep,bq,sep,sep,sep); fprintf(prload_fp,"\ /* pr_check_fkey modified: print 32bit unsigned fkey as hex */ \\\n\ #define pr_check_fkey(ctbl_abbr,ctbl_ptr,ckey,ptbl_abbr,pkey,ptbl_ptr) \\\n\ do { \\\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, tbltype %%s row at %%lx;\\n\", \\\n\ %sckey%s, %sctbl_abbr%s, (unsigned long)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\ } while(0);\n\ \n", bq, eq, bq, eq, bq, eq, bq, eq); fprintf(prload_fp,"\ /******************************************************************************/\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,fldname,length) \\\n\ do {\\\n\ int i = (int)strlen(tbl_ptr->fldname);\\\n\ if ( i == 0 ) { \\\n\ printf(\\\n\ \" Warning: null %%s.%%s : expanded to at most '???' for pkey %%ux\\n\", \\\n\ %stbl_abbr%s, %sfldname%s, (unsigned int) tbl_ptr->tbl_abbr%sid);\\\n\ i = ((i > 3)?3:i);\\\n\ tbl_ptr->fldname[i--] = (char)'\\0';\\\n\ for( ; i>=0; i--)\\\n\ (tbl_ptr)->fldname[i--] = (char)'?';\\\n\ };\\\n\ }while (0); \n\ \n",bq, eq, bq, eq, sep); } /* 93su523 PGEN merge (END) */ /**************************************************************/ /* FUNCTION: gen_pr_add_log() */ /* This function is used to add the logging function to handle*/ /* pr_add. */ /* Created by: D.Nelson 96s532 GENLOG */ /**************************************************************/ gen_pr_add_log() { int i, k, line_len ; fprintf(prload_fp,"\n/********************************************************************************/\n"); fprintf(prload_fp,"/* Function : log_pr_add */\n"); fprintf(prload_fp,"/* */\n"); fprintf(prload_fp,"/* Abstract : This function is used to log a call to pr_add to hcg_logfile */\n"); fprintf(prload_fp,"/* The tbl indicates which table is having a row added. */\n"); fprintf(prload_fp,"/* tbl_ptr points to the record to be added. */\n"); fprintf(prload_fp,"/* */\n"); fprintf(prload_fp,"/********************************************************************************/\n\n"); fprintf(prload_fp,"void log_pr_add (char *tbl, char *viewname, hcg_ptr tbl_ptr)\n"); fprintf(prload_fp,"{\n"); fprintf(prload_fp,"\tchar outkey[3][HCG_KEY_SIZE+1];\n"); fprintf(prload_fp,"\tint idx;\n\n"); fprintf(prload_fp,"\t/* Return if logging not on */\n"); fprintf(prload_fp,"\tif (hcg_log != 1)\n"); fprintf(prload_fp,"\t\treturn;\n\n"); fprintf(prload_fp,"\tfind_tbl_idx(tbl);\n"); fprintf(prload_fp,"\tidx=hcg_tbl_idx;\n\n"); fprintf(prload_fp,"\t/* Write to hcg_logfile based on idx */\n\n"); /* generate the if statements */ tt_curr = tt; while (tt_curr != NULL) { fprintf(prload_fp,"\tif (idx==%d)\n",encoding(tt_curr->TTabbr) ); fprintf(prload_fp,"\t\t{\n"); fprintf(prload_fp,"\t\t\t%scurr=(struct %s *) tbl_ptr;\n",tt_curr->TTabbr,tt_curr->TTabbr); ta_curr = tt_curr->ta_ptr; i=0; while (ta_curr != NULL) { if (ta_curr->IsKey) { char temp_string[BUFSIZE]; strncpy_null(temp_string,ta_curr->FieldName, hcg_abbr_size); fprintf(prload_fp,"\t\t\thcg_update_version(&%scurr->%s,%s_idx,0);\n", tt_curr->TTabbr,ta_curr->FieldName,temp_string); fprintf(prload_fp,"\t\t\tdecode(outkey[%d], &%scurr->%s);\n", i, tt_curr->TTabbr, ta_curr->FieldName); i++; } ta_curr = ta_curr->next_ptr; } /* generate the PrintCheck statement */ fprintf(prload_fp,"\t\t\tPrintCheck(fprintf(hcg_logfileptr, \""); ta_curr = tt_curr->ta_ptr; k = 1; while ( ta_curr != NULL) { switch (ta_curr->FieldType[0] ) { case 'i': fprintf(prload_fp," %%%dd", MAXINTLENGTH); break; case 'f': fprintf(prload_fp," %%%d.%df", MAXFLOATLENGTH, FRACLENGTH); break; default: fprintf(prload_fp," %%-%ds", atoi(ta_curr->FieldType+1) ); } ta_curr = ta_curr->next_ptr; k++; } fprintf(prload_fp,"\\n\"\n\t\t\t"); ta_curr = tt_curr->ta_ptr; k = 1; line_len = 5; i = 0; while (ta_curr != NULL) { if (ta_curr->IsKey) { fprintf(prload_fp,", outkey[%d]", i); i++; } else fprintf(prload_fp,", %scurr->%s", tt_curr->TTabbr, ta_curr->FieldName ); /* include comma, space, & XXcurr-> */ line_len += (strlen(ta_curr->FieldName) + 8 * hcg_abbr_size); ta_curr = ta_curr->next_ptr; k++; if ((ta_curr != NULL) && (line_len >= 128)) { line_len = 0; fprintf(prload_fp,"\n\t\t\t\t"); } } /* end the PrintCheck statement */ fprintf(prload_fp,"));\n"); fprintf(prload_fp, "\t\t}\n"); tt_curr = tt_curr->next_ptr; } fprintf(prload_fp,"}\n\n\n"); } /* 96s523 GENLOG (END) - DN */