/******************************************************************************/
/* function    : gen_pr_log.c                                                 */
/*                                                                            */
/* subsystem   : chgen                                                        */
/*                                                                            */
/* input       : TT and TA tables                                             */
/*                                                                            */
/* output      : <none> (writes to pr_log.c  output file)                     */
/*                                                                            */
/* returns     : void                                                         */
/*                                                                            */
/* author      : Sathyanarayan Jaganathan / Denise Nelson                     */
/*                 Bill Rideout / Mike Murphy                                 */
/*                                                                            */
/* created     : May, 1996                                                    */
/*                                                                            */
/* revisions   : Nov   2001: modified to fix warnings for BDE - sjaganat      */
/*                           (code change for 90 lines approx.)               */
/*                                                                            */
/*             : Added in rrassman's replay routines from 98f523 - JK/KS      */
/*               This included log_do_set_int, to set the value of an int     */
/*               field, log_do_set_flt, log_do_set_key, log_do_set_str, and   */
/*               updates to the gen_pr_log (offset by 12/12/98 comment).      */
/*               99s523 Added rcsid lines - JK/KS                             */
/*                                                                            */
/* description : This routine writes out the code for the pr_log routines     */
/*               to the pr_log.c  output file.  For a description of output   */
/*               code, see the output comments below.                         */
/*                                                                            */
/******************************************************************************/
				 					       
				 
#include <stdio.h>		 
#include <ctype.h>		 
#include "chgen_define.h"	 
#include "chgen_externs.h"	 

void
gen_globals()
{
	static char rcsid[] = "";
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/******************************************************************************/\n");
  fprintf(prlog_fp, "/*		Function prototypes                                                    */\n");
  fprintf(prlog_fp, "/******************************************************************************/\n");
  fprintf(prlog_fp, "#ifdef __STDC__\n"); /* Sathya */
  fprintf(prlog_fp, "   extern void mystrcpy(char *, const char *, int, int);\n"); /* Sathya */
  fprintf(prlog_fp, "   extern int lut_insert_element(lut_st *, char *);\n"); /* Sathya */
  fprintf(prlog_fp, "#else\n"); /* Sathya */
  fprintf(prlog_fp, "   strcpy();\n"); /* Sathya */
  fprintf(prlog_fp, "   extern int lut_insert_element();\n"); /* Sathya */
  fprintf(prlog_fp, "#endif\n"); /* Sathya */
  fprintf(prlog_fp, "/* in pr_load.c: */\n"); /* Sathya */
  fprintf(prlog_fp, "extern void hcg_parse(char*, char*, int*);\n"); /* Sathya */
  fprintf(prlog_fp, "extern int lut_insert_element(lut_st*, char*);\n"); /* Sathya */
  fprintf(prlog_fp, "extern int find_view_idx(char*);\n"); /* Sathya */
  fprintf(prlog_fp, "extern int find_tbl_idx(const char*); /* added const 2k20829 - RJL */\n"); /* Sathya */
  fprintf(prlog_fp, "extern void hcg_read_next(void);\n"); /* Sathya */
  fprintf(prlog_fp, "extern void pr_init (char*, char*);\n"); /* Sathya */
  fprintf(prlog_fp, "extern void pr_load (char*, char*);\n"); /* Sathya */
  fprintf(prlog_fp, "extern void pr_free(void);\n"); /* Sathya */
  fprintf(prlog_fp, "extern void do_pr_add( char *viewname, char *tbl_abbrv, hcg_ptr tbl_ptr);\n\n"); /* Sathya */
  fprintf(prlog_fp, "/* in pr_delete.c: macro pr_delete and pr_del() */\n"); /* Sathya */
  fprintf(prlog_fp, "extern void pr_del(int); /* REQUIRES XXcurr ptr */\n\n"); /* Sathya */
  fprintf(prlog_fp, "/* in pr_dump.c: */\n"); /* Sathya */
  fprintf(prlog_fp, "extern void pr_dump (char*, char*,  int, char*);\n\n"); /* Sathya */
  fprintf(prlog_fp, "/* from <unistd.h>: */\n"); /* Sathya */
  fprintf(prlog_fp, "int unlink(const char*);\n"); /* Sathya */
  fprintf(prlog_fp, "int close(int);\n\n"); /* Sathya */
  fprintf(prlog_fp, "/* fwd ref: */\n"); /* Sathya */
  fprintf(prlog_fp, "int mysleep(struct timeval *);\n"); /* Sathya */
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/******************************************************************************/\n");
  fprintf(prlog_fp, "/*	             Global variables                                              */\n");
  fprintf(prlog_fp, "/******************************************************************************/\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "static struct timeval timestamp;\n");
  fprintf(prlog_fp, "static int time_flag = -1;\n");


}

void
gen_sig_handler()
{

  fprintf(prlog_fp, "/****************************************************************************\n");
  fprintf(prlog_fp, " *                                                                          *\n");
  fprintf(prlog_fp, " *  trivial function for signal handler                                     *\n");
  fprintf(prlog_fp, " ***************************************************************************/\n");
  fprintf(prlog_fp, "static void\n");
  fprintf(prlog_fp, "func(int signo)\n");
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  return;\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_log_sleep()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_sleep                                      */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to pause the execution based on    */\n");
  fprintf(prlog_fp, "/* a parameter indicatings the number of milliseconds of    */\n");
  fprintf(prlog_fp, "/* the desired pause                                        */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: mseconds    - integer of the number of sleep  */\n");
  fprintf(prlog_fp, "/*                         milliseconds.                    */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "#ifdef __STDC__	 \n");
  fprintf(prlog_fp, "int		 \n");
  fprintf(prlog_fp, "log_sleep(int milliseconds)\n");
  fprintf(prlog_fp, "#else		 \n");
  fprintf(prlog_fp, "int		 \n");
  fprintf(prlog_fp, "log_sleep(milliseconds)\n");
  fprintf(prlog_fp, "int milliseconds;\n");
  fprintf(prlog_fp, "#endif /* __STDC__ */\n");
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  struct timeval t;\n");
  fprintf(prlog_fp, "  int status;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (milliseconds < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: log_sleep: milliseconds must be >= 0\\n\",\n");
  fprintf(prlog_fp, "	      __FILE__,__LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  t.tv_sec = milliseconds/1000;\n");
  fprintf(prlog_fp, "  t.tv_usec = (milliseconds %% 1000)*1000;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  status = mysleep(&t);\n");
  fprintf(prlog_fp, "  if (status < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: log_sleep: mysleep failed with status %%d\\n\",\n");
  fprintf(prlog_fp, "	      __FILE__,__LINE__,status);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "  return 0;\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");

}
void
gen_usleep()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/****************************************************************************\n");
  fprintf(prlog_fp, " * mysleep                                                                   *\n");
  fprintf(prlog_fp, " * This routine blocks until the amount of time specified in the timeval    *\n");
  fprintf(prlog_fp, " * referred to be t has elapsed.  The method used is to set an interval     *\n");
  fprintf(prlog_fp, " * timer and to wait until the signal is delivered with a sigpause.         *\n");
  fprintf(prlog_fp, " *  side effects:                                                           *\n");
  fprintf(prlog_fp, " *   The SIGALRM handler is reset for the duration of the call,             *\n");
  fprintf(prlog_fp, " *   When the interval timer expires, A SIGALRM is delivered to the process *\n");
  fprintf(prlog_fp, " *                                                                          *\n");
  fprintf(prlog_fp, " *  preconditions:                                                          *\n");
  fprintf(prlog_fp, " *    t is not null                                                         *\n");
  fprintf(prlog_fp, " *    t refers to a timeval struct                                          *\n");
  fprintf(prlog_fp, " *    t->tv_sec >= 0                                                        *\n");
  fprintf(prlog_fp, " *    t->tv_usec >= 0                                                       *\n");
  fprintf(prlog_fp, " *    t->tv_usec < 1*10^6                                                   *\n");
  fprintf(prlog_fp, " *                                                                          *\n");
  fprintf(prlog_fp, " *  postcondition:                                                          *\n");
  fprintf(prlog_fp, " *    if the return value of mysleep is 0, then                              *\n");
  fprintf(prlog_fp, " *        time = time' + t->tv_sec + t->tv_usec                             *\n");
  fprintf(prlog_fp, " *                                                                          *\n");
  fprintf(prlog_fp, " *  returns: 0 if no errors occurred, -1 otherwise                          *\n");
  fprintf(prlog_fp, " ***************************************************************************/\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "int\n");
  fprintf(prlog_fp, "mysleep(struct timeval *t)\n");
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  struct sigaction newact, oldact;\n");
  fprintf(prlog_fp, "  sigset_t newmask, oldmask, zeromask;\n");
  fprintf(prlog_fp, "  struct itimerval tv1, tv2;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "  /* validate arg */\n");
  fprintf(prlog_fp, "  if (t == NULL)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: bad argument\\n\", __FILE__,__LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* don't wait if no time specified */\n");
  fprintf(prlog_fp, "  if (t->tv_sec == 0 && t->tv_usec == 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      return 0;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "  /* block signals */\n");
  fprintf(prlog_fp, "  sigemptyset(&newmask);\n");
  fprintf(prlog_fp, "  sigemptyset(&zeromask);\n");
  fprintf(prlog_fp, "  sigaddset(&newmask, SIGALRM);\n");
  fprintf(prlog_fp, "  if (sigprocmask(SIG_BLOCK, &newmask, &oldmask) < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      perror(\"sigprocmask\");\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: sigprocmask failed\\n\", __FILE__,__LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* set handler */\n");
  fprintf(prlog_fp, "  newact.sa_handler = func;\n");
  fprintf(prlog_fp, "  sigemptyset(&newact.sa_mask);\n");
  fprintf(prlog_fp, "  newact.sa_flags = 0;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (sigaction(SIGALRM, &newact, &oldact) < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      perror(\"sigaction\");\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: sigaction failed\\n\", __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "        \n");
  fprintf(prlog_fp, "  /* set interval timer */\n");
  fprintf(prlog_fp, "  tv2.it_value.tv_sec = t->tv_sec;\n");
  fprintf(prlog_fp, "  tv2.it_value.tv_usec = t->tv_usec;\n");
  fprintf(prlog_fp, "  tv2.it_interval.tv_sec = 0;\n");
  fprintf(prlog_fp, "  tv2.it_interval.tv_usec = 0;\n");
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "  if (setitimer(ITIMER_REAL, &tv2, &tv1) < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: setitimer failed\\n\", __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (tv1.it_value.tv_sec > 0 || tv1.it_value.tv_usec > 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: interval timer is already set!\\n\",\n");
  fprintf(prlog_fp, "	      __FILE__,__LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* sleep until signal delivered */\n");
  fprintf(prlog_fp, "  if (sigsuspend(&zeromask) != -1)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: sigsuspend didn't return -1\\n\",\n");
  fprintf(prlog_fp, "	      __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* reset signal mask */\n");
  fprintf(prlog_fp, "  if (sigprocmask(SIG_SETMASK, &oldmask, NULL) < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      perror(\"sigprocmask\");\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: sigprocmask failed\\n\", __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* reset signal handler */\n");
  fprintf(prlog_fp, "  if (sigaction(SIGALRM, &oldact, NULL) < 0 )\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      perror(\"sigaction\");\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: mysleep: sigaction failed\\n\", __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "  return 0;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
}


void
gen_time_initialize()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/******************************************************************************/\n");
  fprintf(prlog_fp, "/* time_initialize                                                            */\n");
  fprintf(prlog_fp, "/* Sets the timestamp global with the current time and clear the time_flag    */\n");
  fprintf(prlog_fp, "/******************************************************************************/\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "void\n");
  fprintf(prlog_fp, "time_initialize()\n");
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  struct timezone t;\n");
  fprintf(prlog_fp, "  gettimeofday(&timestamp, &t);\n");
  fprintf(prlog_fp, "  time_flag = 0;\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");

}

void
gen_get_delta_tee()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "int\n");
  fprintf(prlog_fp, "get_delta_tee(struct timeval *t)\n");
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  struct timeval now, delta;\n");
  fprintf(prlog_fp, "  struct timezone tz;\n");
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "  if (!t)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: get_delta_tee: t is null\\n\",__FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (gettimeofday(&now, &tz) < 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      perror(\"gettimeofday\");\n");
  fprintf(prlog_fp, "      fprintf(stderr, \"%%s: %%d: gettimeofday failed\\n\", __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (time_flag != 0)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      /* the first time through report elapsed time of zero,\n");
  fprintf(prlog_fp, "	 and initialize */\n");
  fprintf(prlog_fp, "      t->tv_sec = 0;\n");
  fprintf(prlog_fp, "      t->tv_usec = 0;\n");
  fprintf(prlog_fp, "      time_initialize();\n");
  fprintf(prlog_fp, "      return 0;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (now.tv_usec < timestamp.tv_usec)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      if (now.tv_sec <= 0)\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "	  fprintf(stderr,\n");
  fprintf(prlog_fp, "		  \"%%s: %%d: get_delta_tee: bad tv_sec value\\n\",\n");
  fprintf(prlog_fp, "		  __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "	  return -1;\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "      delta.tv_sec = now.tv_sec - 1;\n");
  fprintf(prlog_fp, "      delta.tv_usec = now.tv_usec + 1000000;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "  else\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      delta.tv_sec = now.tv_sec;\n");
  fprintf(prlog_fp, "      delta.tv_usec = now.tv_usec;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  t->tv_sec = delta.tv_sec - timestamp.tv_sec;\n");
  fprintf(prlog_fp, "  t->tv_usec = delta.tv_usec - timestamp.tv_usec;\n");
  fprintf(prlog_fp, "  timestamp.tv_sec = now.tv_sec;\n");
  fprintf(prlog_fp, "  timestamp.tv_usec = now.tv_usec;\n");
  fprintf(prlog_fp, "  return 0;\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
}

void
gen_timeval2millisec()
{
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "/**********************************************************\n");
  fprintf(prlog_fp, " *  Function: timeval2millisec(int *, struct timeval *)   *\n");
  fprintf(prlog_fp, " *                                                        *\n");
  fprintf(prlog_fp, " *  This function converts the time in the timeval struct *\n");
  fprintf(prlog_fp, " *  into the equiv number of milliseconds, and places the *\n");
  fprintf(prlog_fp, " *  result in the first argument.                         *\n");
  fprintf(prlog_fp, " *  On success it returns 0, -1 otherwise                 *\n");
  fprintf(prlog_fp, " *********************************************************/\n");
  fprintf(prlog_fp, "static int\n");
  fprintf(prlog_fp, "timeval2millisec(int *millisec,\n");
  fprintf(prlog_fp, "		 const struct timeval *t)\n");
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  int temp;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (!millisec || !t)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "      fprintf(stderr,\n");
  fprintf(prlog_fp, "	      \"%%s: %%d: timeval2millisec: bad argument\\n\", __FILE__, __LINE__);\n");
  fprintf(prlog_fp, "      return -1;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  temp = t->tv_sec*1000;\n");
  fprintf(prlog_fp, "  temp = temp + t->tv_usec/1000;\n");
  fprintf(prlog_fp, "  *millisec = (int) temp;\n");
  fprintf(prlog_fp, "  return 0;\n"); /* Sathya */
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");

}

void
gen_logstr()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/**********************************************************/\n");
  fprintf(prlog_fp, "/*  Function: logstr()                                    */ \n");
  fprintf(prlog_fp, "/*  Arguments: text - contains the string to be printed   */  \n");
  fprintf(prlog_fp, "/*                    to the log file.                    */  \n");
  fprintf(prlog_fp, "/*                                                        */  \n");
  fprintf(prlog_fp, "/*  This function writes the text string to the logfile   */  \n");
  fprintf(prlog_fp, "/*  if logging is active                                  */  \n");
  fprintf(prlog_fp, "/*                                                        */  \n");
  fprintf(prlog_fp, "/**********************************************************/\n");
  fprintf(prlog_fp, "void logstr(char text[BUFSIZE])\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  if (hcg_log == 1)  \n");
  fprintf(prlog_fp, "    fprintf(hcg_logfileptr, \"%%s\", text);\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");
}

void
gen_logwait()
{
  fprintf(prlog_fp, "/**********************************************************/\n");
  fprintf(prlog_fp, "/*  Function: logwait()                                   */ \n");
  fprintf(prlog_fp, "/*  Arguments: none                                       */  \n");
  fprintf(prlog_fp, "/*                                                        */  \n");
  fprintf(prlog_fp, "/*  This function calculates the wait time based on the   */  \n");
  fprintf(prlog_fp, "/*  value of setitimer.                                   */  \n");
  fprintf(prlog_fp, "/*  waitTime = initial_val_of_itimer - cur_val_of_itimer  */  \n");
  fprintf(prlog_fp, "/*  Writes the waitTime to the log file and re-initializes*/  \n");
  fprintf(prlog_fp, "/*  the value of the itimer.                              */  \n");
  fprintf(prlog_fp, "/*                                                        */  \n");
  fprintf(prlog_fp, "/**********************************************************/\n");
  fprintf(prlog_fp, "void logwait(void)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  struct timeval tv;\n");
  fprintf(prlog_fp, "  char text[BUFSIZE];\n");
  fprintf(prlog_fp, "  int waitTime;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (hcg_log == 1) {\n");
  fprintf(prlog_fp, "    get_delta_tee(&tv);\n");
  fprintf(prlog_fp, "    if (timeval2millisec(&waitTime, &tv) < 0)\n");
  fprintf(prlog_fp, "      {\n");
  fprintf(prlog_fp, "	fprintf(stderr,\n");
  fprintf(prlog_fp, "		\"%%s: %%d: logwait: timeval2millisec failed\\n\",__FILE__,__LINE__);\n");  /* Sathya */
  fprintf(prlog_fp, "	return;\n");
  fprintf(prlog_fp, "      }\n");
  fprintf(prlog_fp, "    sprintf(text,\"WA %%d\\n\", waitTime);\n");
  fprintf(prlog_fp, "    logstr(text);    \n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_pr_startlog()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/********************************************************************************/\n");
  fprintf(prlog_fp, "/* Function :  pr_startlog                               			*/\n");
  fprintf(prlog_fp, "/*                                                                      	*/\n");
  fprintf(prlog_fp, "/* Abstract : This function is used to start a logging session.                 */\n");
  fprintf(prlog_fp, "/*            It opens a logfile and dumps a current copy of the database       */\n");
  fprintf(prlog_fp, "/*                                                                      	*/\n");
  fprintf(prlog_fp, "/* Created by : B. Rideout                                         		*/ \n");
  fprintf(prlog_fp, "/*                                                                      	*/\n");
  fprintf(prlog_fp, "/* Creation Date : 4/24/96                                            		*/ \n");
  fprintf(prlog_fp, "/*                                                                    		*/  \n");
  fprintf(prlog_fp, "/* Modified :                                                           	*/\n");
  fprintf(prlog_fp, "/*             									*/\n");
  fprintf(prlog_fp, "/********************************************************************************/\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "int pr_startlog (char* file_name, char* viewname)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "static char rcsid[] = \"\";\n");
  fprintf(prlog_fp, "char DB1string[10] = \"DB1.dat\";\n");
  fprintf(prlog_fp, "char logfileDB1_name[NAMELENGTH];\n");
  fprintf(prlog_fp, "char temp_file_name[NAMELENGTH]=\"\\0\";\n");
  fprintf(prlog_fp, "int i;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	/*   check that pr_init has been called	- if not, return without starting log*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	if (!hcg_initialized)	\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: pr_startlog() called when database is not yet initialized.\\n\");\n");
  fprintf(prlog_fp, "		return (-1);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* check that viewname is valid	- if not, return without starting log*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	if (!find_view_idx(viewname))	\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: view %%s passed to pr_startlog is not defined.\\n\",viewname);\n");
  fprintf(prlog_fp, "		return (-2);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* check that logging is off	- if not, return without starting log*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	if (hcg_log)	\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: pr_startlog called when logging was not off.\\n\");\n");
  fprintf(prlog_fp, "		return (-3);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	/* Check that file_name is not null */\n");
  fprintf(prlog_fp, "	if (!strcmp(file_name, \"\\0\"))\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: log file name null; logging not on.\\n\");\n");
  fprintf(prlog_fp, "		return (-4);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/*  set global hcg_logfile to file name of log file (w/out extention) */\n");
  fprintf(prlog_fp, "	for (i = strlen(file_name);\n");
  fprintf(prlog_fp, "		(i>=0) && (file_name[i]!= '.');\n");
  fprintf(prlog_fp, "		i--);\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	if (i<0) /* no extention */\n");
  fprintf(prlog_fp, "		strcpy (hcg_logfile, file_name);\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	else   /* remove extention */\n");
  fprintf(prlog_fp, "		strncpy (hcg_logfile, file_name, (i));\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	strcpy (temp_file_name, hcg_logfile);\n");
  fprintf(prlog_fp, "	strcat (temp_file_name, \".txt\");\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	/* check that logfile opened - if not, return without starting log*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	if ((hcg_logfileptr=fopen(temp_file_name, \"w\")) == NULL)	\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: pr_startlog() cannot open %%s\\n\", file_name);\n");
  fprintf(prlog_fp, "		return (-3);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/*  Call pr_dump to save a current version of the database  */\n");
  fprintf(prlog_fp, "	/*  Database saved to name of log file + \"DB1\"				*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	strcat (strcpy(logfileDB1_name, hcg_logfile), DB1string);\n");
  fprintf(prlog_fp, "	pr_dump (viewname, logfileDB1_name, FALSE, \"w\" );\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/*  Initiate logging by setting global hcg_log = 1	*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	hcg_log =1;\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/*  Log call to pr_startlog as first record	*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	logstr(\"SR\\n\");\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* Set timer info - to be done		*/\n");
  fprintf(prlog_fp, "	time_initialize();\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	return (0);\n");
  fprintf(prlog_fp, "}	/* End pr_startlog	*/\n");
  fprintf(prlog_fp, "\n");
}

void
gen_pr_stoplog()
{
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/********************************************************************************/\n");
  fprintf(prlog_fp, "/* Function :  pr_stoplog                                                       */\n");
  fprintf(prlog_fp, "/*                                                                              */\n");
  fprintf(prlog_fp, "/* Abstract : This function is used to stop a logging session.                  */\n");
  fprintf(prlog_fp, "/*            It optionally dumps a current copy of the database and closes     */\n");
  fprintf(prlog_fp, "/*            the logfile                                                       */\n");
  fprintf(prlog_fp, "/*                                                                              */\n");
  fprintf(prlog_fp, "/* Created by : B. Rideout                                                      */\n");
  fprintf(prlog_fp, "/*                                                                              */\n");
  fprintf(prlog_fp, "/* Creation Date : 4/26/96                                                      */\n");
  fprintf(prlog_fp, "/*                                                                    	         */\n");
  fprintf(prlog_fp, "/* Modified :                                                                   */\n");
  fprintf(prlog_fp, "/*                                                                              */\n");
  fprintf(prlog_fp, "/********************************************************************************/\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "int pr_stoplog (char* viewname, int dump_flag)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "char DB2string[10] = \"DB2.dat\";\n");
  fprintf(prlog_fp, "char logfileDB2_name[NAMELENGTH];\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	/*   check that logging is active	- if not, return without stopping log*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	if (!hcg_log)	\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: pr_stoplog() called when logging not active.\\n\");\n");
  fprintf(prlog_fp, "		return (-1);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* check that viewname is valid	- if not, return without starting log*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	if (!find_view_idx(viewname))	\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		printf(\"Error: view %%s passed to pr_startlog is not defined.\\n\",viewname);\n");
  fprintf(prlog_fp, "		return (-2);\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* 4/24/96 - other error checking functions to be added */\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* Generate Wait statement	*/\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "	logwait();\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/* Log pr_stoplog		*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	logstr(\"SP\\n\");\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/*  Terminate logging by setting global hcg_log = 0		*/\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	hcg_log =0;\n");
  fprintf(prlog_fp, "	\n");
  fprintf(prlog_fp, "	/*  Call pr_dump to save a current version of the database if dump_flag set */\n");
  fprintf(prlog_fp, "	/*  Database saved to name of log file + \"DB2\"				*/\n");
  fprintf(prlog_fp, "	if (dump_flag)\n");
  fprintf(prlog_fp, "	{\n");
  fprintf(prlog_fp, "		strcat (strcpy(logfileDB2_name, hcg_logfile), DB2string);\n");
  fprintf(prlog_fp, "		pr_dump (viewname, logfileDB2_name, FALSE, \"w\" );\n");
  fprintf(prlog_fp, "	}\n");
  fprintf(prlog_fp, "	fclose(hcg_logfileptr);\n");
  fprintf(prlog_fp, "	return (0);\n");
  fprintf(prlog_fp, "}	/* End pr_stoplog	*/\n");
  fprintf(prlog_fp, "\n");
}

void
gen_log_parselogdata()
{
  
  
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_parselogdata                               */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to parse the data file(logdata.txt)*/\n");
  fprintf(prlog_fp, "/* & create temporary files that contain the data of the    */\n");
  fprintf(prlog_fp, "/* original data files.  It returns a string list with      */\n");
  fprintf(prlog_fp, "/* the names of the new files.  The new file names are      */\n");
  fprintf(prlog_fp, "/* separated by spaces.  It returns a value to indicate     */\n");
  fprintf(prlog_fp, "/* success or failure.                                      */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: newlist - a list of files separated by commas */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Preconditions:                                           */\n");
  fprintf(prlog_fp, "/*   newlist must be a character string of size BUFSIZE     */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* returns:   0    - success                                */\n");
  fprintf(prlog_fp, "/*           <0    - failure                                */\n");
  fprintf(prlog_fp, "/*           -3    - open file failure                      */\n");
  fprintf(prlog_fp, "/*           -5    - invalid file format                    */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "int log_parselogdata(char * newlist)\n");  /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char datafile[NAMELENGTH],token[BUFSIZE],tempfname[NAMELENGTH],tempnewlist[BUFSIZE];\n");
  fprintf(prlog_fp, "  FILE *data_fp, *temp_fp;\n");
  fprintf(prlog_fp, "  int idx;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* open logdata.txt */\n");
  fprintf(prlog_fp, "  strcpy(datafile,\"logdata.txt\");\n");
  fprintf(prlog_fp, "  if ((data_fp = fopen(datafile, \"r\")) ==NULL) \n");
  fprintf(prlog_fp, "    return(-3);\n");
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "  hcg_ascii_fp = data_fp;\n");
  fprintf(prlog_fp, "  hcg_read_next();  /* read first line of data file */\n");
  fprintf(prlog_fp, "  idx = 0;\n");
  fprintf(prlog_fp, "  hcg_parse(hcg_buffer,token,&idx);\n");
  fprintf(prlog_fp, "  if (strcmp(token,\"LogDataFile\") != 0) { \n");
  fprintf(prlog_fp, "    /* invalid file format */\n");
  fprintf(prlog_fp, "    return(-5);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "  hcg_parse(hcg_buffer,token,&idx);  /* get filename */\n");
  fprintf(prlog_fp, "  tempnewlist[0] = \'\\0\';\n");
  fprintf(prlog_fp, "  while (!feof(data_fp)) {\n");
  fprintf(prlog_fp, "    /* open temp file */\n");
  fprintf(prlog_fp, "    sprintf(tempfname,\"temp%%s\",token);\n");  /* Sathya */
  fprintf(prlog_fp, "    if ((temp_fp = fopen(tempfname, \"w\")) ==NULL) \n");
  fprintf(prlog_fp, "      return(-3);\n");
  fprintf(prlog_fp, "    strcat(tempnewlist,tempfname);\n");
  fprintf(prlog_fp, "    strcat(tempnewlist,\" \\0\");\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    hcg_read_next(); /* read next line in data file */\n");
  fprintf(prlog_fp, "    idx = 0;\n");
  fprintf(prlog_fp, "    hcg_parse(hcg_buffer,token,&idx);\n");
  fprintf(prlog_fp, "    while (!feof(data_fp) && (strcmp(token,\"LogDataFile\") != 0)) {\n");
  fprintf(prlog_fp, "      /* write buffer in temp file */\n");
  fprintf(prlog_fp, "      fprintf(temp_fp,\"%%s\\n\",hcg_buffer);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      idx = 0;\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,token,&idx);\n");
  fprintf(prlog_fp, "    } /* end while !feof loop */\n");
  fprintf(prlog_fp, "    fclose(temp_fp);\n");
  fprintf(prlog_fp, "    hcg_parse(hcg_buffer,token,&idx);  /* get filename */\n");
  fprintf(prlog_fp, "  } \n");
  fprintf(prlog_fp, "  fclose(data_fp);\n");
  fprintf(prlog_fp, "  strcpy(newlist,tempnewlist); \n");
  fprintf(prlog_fp, "  return(0);\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_del_tempfiles()
{

  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: del_tempfiles                                  */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to delete the temporary files that */\n");
  fprintf(prlog_fp, "/* were created during the replay session.                  */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: filelist    - a list of files separated by    */\n");
  fprintf(prlog_fp, "/*                         commas.                          */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void del_tempfiles(char *filelist)\n");  /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  int idx = 0;\n");
  fprintf(prlog_fp, "  char token[BUFSIZE];\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  while (idx < strlen(filelist)) {\n");
  fprintf(prlog_fp, "    hcg_parse(filelist,token,&idx);\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Unlinked %%s.\\n\",token);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "    unlink(token);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");

}

void
gen_convert2temp()
{
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: convert2temp                                   */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to convert an inputted string of   */\n");
  fprintf(prlog_fp, "/* datfiles separated by spaces to the filenames with the   */\n");
  fprintf(prlog_fp, "/* prefix 'temp'.  Returns the string of altered names.     */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: instr       - string of size BUFSIZE that     */\n");
  fprintf(prlog_fp, "/*                         containts the string to add the  */\n");
  fprintf(prlog_fp, "/*                         temp infront of each word        */\n");
  fprintf(prlog_fp, "/*            out         - string that will place the      */\n");
  fprintf(prlog_fp, "/*                         altered string.                  */\n");
  fprintf(prlog_fp, "/* Preconditions:                                           */\n");
  fprintf(prlog_fp, "/*    instr must be a string of size BUFSIZE                */\n");
  fprintf(prlog_fp, "/*    out  must be a string of size BUFSIZE                 */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void convert2temp(char instr[BUFSIZE],char out[BUFSIZE])\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char token[BUFSIZE];\n");
  fprintf(prlog_fp, "  char outstr[BUFSIZE];\n");
  fprintf(prlog_fp, "  int idx = 0;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (strlen(instr)==0) {\n");
  fprintf(prlog_fp, "    strcpy(out,\"\\0\");\n");
  fprintf(prlog_fp, "    return;\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "  /* get first token in string instr */\n");
  fprintf(prlog_fp, "  hcg_parse(instr,token,&idx);\n");
  fprintf(prlog_fp, "  sprintf(outstr,\"temp%%s\",token);\n"); /* Sathya */
 
  fprintf(prlog_fp, "  /* get the rest of the tokens in the string instr */\n");
  fprintf(prlog_fp, "  hcg_parse(instr,token,&idx);\n");
  fprintf(prlog_fp, "  while (idx < strlen(instr)) {\n");
  fprintf(prlog_fp, "    char temp[BUFSIZE];\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    sprintf(temp,\" temp%%s\",token);\n");
  fprintf(prlog_fp, "    strcat(outstr,temp);\n");
  fprintf(prlog_fp, "    hcg_parse(instr,token,&idx);\n");
  fprintf(prlog_fp, "  } \n");
  fprintf(prlog_fp, "  strcpy(out,outstr);\n");
  fprintf(prlog_fp, "  return;\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  
}

void
gen_log_do_add()
{

  char unpad;

  fprintf(prlog_fp,"/************************************************************/\n");
  fprintf(prlog_fp,"/* Function: log_do_add                                     */\n");
  fprintf(prlog_fp,"/*                                                          */\n");
  fprintf(prlog_fp,"/* This function is used to do the add given the viewname   */\n");
  fprintf(prlog_fp,"/* the tablename and a string of the additional information */\n");
  fprintf(prlog_fp,"/*                                                          */\n");
  fprintf(prlog_fp,"/* Arguments: view        - the viewname                    */\n");
  fprintf(prlog_fp,"/*            tablename   - the tablename of the record to  */\n");
  fprintf(prlog_fp,"/*                         be added.                        */\n");
  fprintf(prlog_fp,"/*            theRest     - a string of the additional info */\n");
  fprintf(prlog_fp,"/*                         of the record to be added        */\n");
  fprintf(prlog_fp,"/* Returns:   0           - success                         */\n");
  fprintf(prlog_fp,"/*           <0           - error with the add              */\n");
  fprintf(prlog_fp,"/*                                                          */\n");
  fprintf(prlog_fp,"/* Genlog 96s523                                            */\n");
  fprintf(prlog_fp,"/************************************************************/\n");
  fprintf(prlog_fp,"int log_do_add(char *view, char *tablename, char *theRest)\n"); /* Sathya */
  fprintf(prlog_fp,"{\n");
  fprintf(prlog_fp,"  int status = 0;  /* the return status of the function */\n");
  fprintf(prlog_fp,"  int idx = 0;     /* parsing temp index                */\n");
  fprintf(prlog_fp,"  int tbl_encoding;\n");
  tt_curr = tt;
  while(tt_curr != NULL)
    {
      
      fprintf(prlog_fp, "  struct %s *%s_elt;\n", tt_curr->TTabbr , tt_curr->TTabbr);
      tt_curr = tt_curr->next_ptr;

    }

  /* generate row pointer variables for switch statement */
  fprintf(prlog_fp,"\n");
  fprintf(prlog_fp,"\n");
  fprintf(prlog_fp,"   if (!find_tbl_idx(tablename))\n");
  fprintf(prlog_fp,"   {\n");
  fprintf(prlog_fp,"    fprintf(stderr,\n");
  fprintf(prlog_fp,"\t\"%%s: %%d: log_do_add: unknown table (%%s) found in log\\n\",\n"); /* Sathya */
  fprintf(prlog_fp,"\t__FILE__, __LINE__, tablename);\n");
  fprintf(prlog_fp,"\treturn (status = -1);\n"); /* Sathya */
  fprintf(prlog_fp,"   }\n");
  fprintf(prlog_fp,"\n");
  fprintf(prlog_fp,"   tbl_encoding = encoding(hcg_table_seq_list[hcg_tbl_idx].ttabbrev); /* global hcg_tbl_idx is set by find_tbl_idx */\n");
  fprintf(prlog_fp,"\n");
  fprintf(prlog_fp,"/* the following switch statement is adapted from the one in pr_parse */\n");
  fprintf(prlog_fp,"\n\n\tswitch( tbl_encoding )\n\t{\n");

  /* generate the switch statement (one branch for each type) */
  tt_curr = tt;
  while ( tt_curr != NULL)
    {
      fprintf(prlog_fp, "\tcase %d:\t/* encoding of %s */\n", encoding(tt_curr->TTabbr), tt_curr->TTabbr);
      fprintf(prlog_fp, "\t\t%s_elt = pr_create(%s);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "\t\tif (!%s_elt)\n\t\t{\n\t\t\t  fprintf(stderr,", tt_curr->TTabbr);
      fprintf(prlog_fp, "\"%%s: %%d: log_do_add: pr_create failed\\n\","); /* Sathya */
      fprintf(prlog_fp, " __FILE__, __LINE__);\n"); /* Sathya */
	  fprintf(prlog_fp, "\t\t\treturn (status = -1);\n"); /* Sathya */
      fprintf(prlog_fp, "\t\t}\n"); /* Sathya */

      /* for each column, do appropriate field init */
      ta_curr = tt_curr->ta_ptr;
      while ( ta_curr != NULL )
	  {
	  if (ta_curr->IsKey)
	    {
	      if (ta_curr == tt_curr->ta_ptr) /* primary key - skip, since pr_add will determine this */
		{
		}
	      else
		{
		  fprintf(prlog_fp, "\t\thcg_parse(theRest, hcg_t, &idx);\n");
		  fprintf(prlog_fp, "\t\tencode(hcg_t, &hcg_k);\n");
		  fprintf(prlog_fp, "\t\t%s_elt->%s = hcg_k;\n", tt_curr->TTabbr, ta_curr->FieldName);
		}
	    }
	  else /* field is not a key */
	    {
	      switch ( ta_curr->FieldType[0] )
		{
		case 'i':
		  fprintf(prlog_fp, "\t\thcg_parse(theRest, hcg_t, &idx);\n");
		  fprintf(prlog_fp, "\t\tpr_set_int(%s_elt, %s, atoi(hcg_t));\n", tt_curr->TTabbr, ta_curr->FieldName);
		  break;

		case 'f':
		  fprintf(prlog_fp, "\t\thcg_parse(theRest, hcg_t, &idx);\n");
		  if ( ta_curr->FieldType[1] == '4')  /* is this a float or double ? */
		    fprintf(prlog_fp, "\t\t\tpr_set_flt(%s_elt, %s, (float) atof(hcg_t));\n", tt_curr->TTabbr,
			    ta_curr->FieldName);
		  else
		    fprintf(prlog_fp, "\t\tpr_set_flt(%s_elt, %s, atof(hcg_t));\n", tt_curr->TTabbr,
			    ta_curr->FieldName);
		  break;

		case 'd':
		  if (ta_curr->next_ptr != NULL) /* not first and not last field, so parse and mystrcpy */
		    {
		      fprintf(prlog_fp, "\t\thcg_parse(theRest, hcg_t, &idx);\n");
		      fprintf(prlog_fp, "\t\tmystrcpy(%s_elt->%s, hcg_t, 26, 1);\n", tt_curr->TTabbr,
			      ta_curr->FieldName);
		    }
		  else
		    /* last field of table is a date, so don't parse to let it have spaces within */
		    fprintf(prlog_fp, "\t\tmystrcpy(%s_elt->%s, theRest+idx, 26, 1);\n", tt_curr->TTabbr,
			    ta_curr->FieldName);
		  break;

		  /* the tactic of assuming that an unassigned type is a string is adapted from gen_pr_log.
		     Note that the switch statement here must be revised whenever new data types are added */
		  
		default:
		  if (ta_curr->FieldType[0] == 't')
		    unpad = '1';
		  else
		    unpad = '0';

		  if (ta_curr == tt_curr->ta_ptr) /* first field is pkey - skip it */
		    {
		    }
		  else if (ta_curr->next_ptr != NULL)
		    {
		      fprintf(prlog_fp, "\t\thcg_parse(theRest, hcg_t, &idx);\n");
		      fprintf(prlog_fp, "\t\tmystrcpy(%s_elt->%s, hcg_t, %d, %c);\n",
			      tt_curr->TTabbr, ta_curr->FieldName, atoi(&(ta_curr->FieldType[1])), unpad);
		    }
		  else /* last field of table is a string - don't parse, so it can have spaces */
		    {
		      fprintf(prlog_fp, "\t\tmystrcpy(%s_elt->%s, theRest+idx, %d, %c);\n",
			      tt_curr->TTabbr, ta_curr->FieldName, atoi(&(ta_curr->FieldType[1])), unpad);
		    }
		}
	    } /* switch */
	  ta_curr = ta_curr->next_ptr;
	  }

      fprintf(prlog_fp, "\t\tpr_add(view, %s, %s_elt);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "\t\tbreak;\n\n");
      tt_curr = tt_curr->next_ptr;

    }
  fprintf(prlog_fp, "\t}\n");
  fprintf(prlog_fp, "\treturn 0;\n"); /* Sathya */
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");

}

void
gen_log_do_delete(void) /* Sathya */
{

  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_do_delete                                  */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to delete a record given the pkey. */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: pkeychar    - char string of the primary key. */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void log_do_delete(const char pkeychar[HCG_KEY_SIZE+1])\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char pkey[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "  int tbl_encoding;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  strcpy(pkey,pkeychar);\n");
  fprintf(prlog_fp, "  find_tbl_idx(pkeychar);\n");
  fprintf(prlog_fp, "  if(encode(pkey,&hcg_k) ==1)\n");
  fprintf(prlog_fp, "  {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found DL with pkey %%s.\\n\",pkeychar);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "    tbl_encoding = encoding(hcg_table_seq_list[hcg_tbl_idx].ttabbrev);\n");
  fprintf(prlog_fp, "    switch(tbl_encoding) {\n");
  fprintf(prlog_fp, "\n");
  /* for each table type, emit an appropriate delete action in the switch */

  tt_curr = tt;
  while ( tt_curr != NULL )
    {
      fprintf(prlog_fp, "  case %d: /* %s table */\n", encoding(tt_curr->TTabbr), tt_curr->TTabbr);
      fprintf(prlog_fp, "    pr_find(%s, %sid, hcg_k);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "    if (%scurr == NULL)\n",tt_curr->TTabbr);
      fprintf(prlog_fp, "      printf(\"log_delete: %%s not found.\\n\", pkeychar);\n");
      fprintf(prlog_fp, "    else\n");
      fprintf(prlog_fp, "      pr_delete(%s);\n", tt_curr->TTabbr);
      fprintf(prlog_fp, "    break;\n");
      fprintf(prlog_fp, "\n");
      tt_curr = tt_curr->next_ptr;
    }
  fprintf(prlog_fp, "    } /* end switch */\n");
  fprintf(prlog_fp, "  } /* end if decode */\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");




}

void
gen_log_do_set_int()
{
  int elseflag;

  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_do_set_int                                 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to set the value of an int field.  */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Created by : Rob Rassmann                      		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Creation Date : 12/12/98	         		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: pkeychar    - char string of the primary key. */\n");
  fprintf(prlog_fp, "/*            fieldname   - char string of the changing field. */\n");
  fprintf(prlog_fp, "/*            newval      - int value to be set.            */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void log_do_set_int(const char pkeychar[HCG_KEY_SIZE+1],const char fieldname[NAMELENGTH+1],const int newval)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char pkey[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "  int tbl_encoding/*, fld_encoding*/;\n");  /* Sathya */
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  strcpy(pkey,pkeychar);\n");
  fprintf(prlog_fp, "  find_tbl_idx(pkeychar);\n");
  fprintf(prlog_fp, "  if(encode(pkey,&hcg_k) ==1)\n");
  fprintf(prlog_fp, "  {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found DL with pkey %%s.\\n\",pkeychar);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "    tbl_encoding = encoding(hcg_table_seq_list[hcg_tbl_idx].ttabbrev);\n");
  fprintf(prlog_fp, "    switch(tbl_encoding) {\n");
  fprintf(prlog_fp, "\n");
  /* for each table type, emit an appropriate delete action in the switch */

  tt_curr = tt;
  while ( tt_curr != NULL )
    {
      fprintf(prlog_fp, "  case %d: /* %s table */\n", encoding(tt_curr->TTabbr), tt_curr->TTabbr);

      fprintf(prlog_fp, "    pr_find(%s, %sid, hcg_k);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "    if (%scurr == NULL)\n",tt_curr->TTabbr);
      fprintf(prlog_fp, "      printf(\"log_do_set_int %%s not found.\\n\", pkeychar);\n");
      fprintf(prlog_fp, "    else{\n");

      ta_curr = tt_curr->ta_ptr;
      elseflag = 0;
      while (ta_curr != NULL)
      {
	if(*ta_curr->FieldType=='i')
	{
	  if(elseflag)
	    fprintf(prlog_fp, "      else\n");
	  else
	    elseflag = 1;
	  fprintf(prlog_fp, "      if(strcmp(fieldname,\"%s\")==0)\n",ta_curr->FieldName);
	  fprintf(prlog_fp, "        %scurr->%s = newval;\n",tt_curr->TTabbr,ta_curr->FieldName);
	}
	ta_curr = ta_curr->next_ptr;
      }

      fprintf(prlog_fp, "    }\n");
      fprintf(prlog_fp, "    break;\n");
      fprintf(prlog_fp, "\n");
      tt_curr = tt_curr->next_ptr;
    }
  fprintf(prlog_fp, "    } /* end switch */\n");
  fprintf(prlog_fp, "  } /* end if decode */\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_log_do_set_flt()
{
  int elseflag;

  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_do_set_flt                                 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to set the value of an float field.*/\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Created by : Rob Rassmann                      		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Creation Date : 12/12/98	         		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: pkeychar    - char string of the primary key. */\n");
  fprintf(prlog_fp, "/*            fieldname   - char string of the changing field. */\n");
  fprintf(prlog_fp, "/*            newval      - flt value to be set.            */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void log_do_set_flt(const char pkeychar[HCG_KEY_SIZE+1],const char fieldname[NAMELENGTH+1],const float newval)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char pkey[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "  int tbl_encoding/*, fld_encoding*/;\n"); /* Sathya */
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  strcpy(pkey,pkeychar);\n");
  fprintf(prlog_fp, "  find_tbl_idx(pkeychar);\n");
  fprintf(prlog_fp, "  if(encode(pkey,&hcg_k) ==1)\n");
  fprintf(prlog_fp, "  {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found DL with pkey %%s.\\n\",pkeychar);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "    tbl_encoding = encoding(hcg_table_seq_list[hcg_tbl_idx].ttabbrev);\n");
  fprintf(prlog_fp, "    switch(tbl_encoding) {\n");
  fprintf(prlog_fp, "\n");
  /* for each table type, emit an appropriate delete action in the switch */

  tt_curr = tt;
  while ( tt_curr != NULL )
    {
      fprintf(prlog_fp, "  case %d: /* %s table */\n", encoding(tt_curr->TTabbr), tt_curr->TTabbr);

      fprintf(prlog_fp, "    pr_find(%s, %sid, hcg_k);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "    if (%scurr == NULL)\n",tt_curr->TTabbr);
      fprintf(prlog_fp, "      printf(\"log_do_set_flt %%s not found.\\n\", pkeychar);\n");
      fprintf(prlog_fp, "    else{\n");

      ta_curr = tt_curr->ta_ptr;
      elseflag = 0;
      while (ta_curr != NULL)
      {
	if(*ta_curr->FieldType=='f')
	{
	  if(elseflag)
	    fprintf(prlog_fp, "      else\n");
	  else
	    elseflag = 1;
	  fprintf(prlog_fp, "      if(strcmp(fieldname,\"%s\")==0)\n",ta_curr->FieldName);
	  fprintf(prlog_fp, "        %scurr->%s = newval;\n",tt_curr->TTabbr,ta_curr->FieldName);
	}
	ta_curr = ta_curr->next_ptr;
      }

      fprintf(prlog_fp, "    }\n");
      fprintf(prlog_fp, "    break;\n");
      fprintf(prlog_fp, "\n");
      tt_curr = tt_curr->next_ptr;
    }
  fprintf(prlog_fp, "    } /* end switch */\n");
  fprintf(prlog_fp, "  } /* end if decode */\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_log_do_set_key()
{
  int elseflag;

  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_do_set_key                                 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to set the value of an key field.  */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Created by : Rob Rassmann                      		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Creation Date : 12/12/98	         		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: pkeychar    - char string of the primary key. */\n");
  fprintf(prlog_fp, "/*            fieldname   - char string of the changing field. */\n");
  fprintf(prlog_fp, "/*            newval      - char string key value to be set.*/\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void log_do_set_key(const char pkeychar[HCG_KEY_SIZE+1],const char fieldname[NAMELENGTH+1],const char newval[HCG_KEY_SIZE+1])\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char pkey[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "  int tbl_encoding/*, fld_encoding*/;\n"); /* Sathya */
  fprintf(prlog_fp, "  hcg_key new_key;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  strcpy(pkey,pkeychar);\n");
  fprintf(prlog_fp, "  find_tbl_idx(pkeychar);\n");
  fprintf(prlog_fp, "  if(encode(pkey,&hcg_k) ==1)\n");
  fprintf(prlog_fp, "  {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found DL with pkey %%s.\\n\",pkeychar);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "    if(encode(fieldname,&new_key) ==1)\n");
  fprintf(prlog_fp, "    {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found DL with key %%s.\\n\",fieldname);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      tbl_encoding = encoding(hcg_table_seq_list[hcg_tbl_idx].ttabbrev);\n");
  fprintf(prlog_fp, "      switch(tbl_encoding) {\n");
  fprintf(prlog_fp, "\n");
  /* for each table type, emit an appropriate delete action in the switch */

  tt_curr = tt;
  while ( tt_curr != NULL )
    {
      fprintf(prlog_fp, "      case %d: /* %s table */\n", encoding(tt_curr->TTabbr), tt_curr->TTabbr);

      fprintf(prlog_fp, "        pr_find(%s, %sid, hcg_k);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "        if (%scurr == NULL)\n",tt_curr->TTabbr);
      fprintf(prlog_fp, "          printf(\"log_do_set_key %%s not found.\\n\", pkeychar);\n");
      fprintf(prlog_fp, "        else{\n");

      ta_curr = tt_curr->ta_ptr;
      elseflag = 0;
      while (ta_curr != NULL)
      {
	if(ta_curr->IsKey==1)
	{
	  if(elseflag)
	    fprintf(prlog_fp, "          else\n");
	  else
	    elseflag = 1;
	  fprintf(prlog_fp, "          if(strcmp(fieldname,\"%s\")==0)\n",ta_curr->FieldName);
	  fprintf(prlog_fp, "            %scurr->%s = new_key;\n",tt_curr->TTabbr,ta_curr->FieldName);
	}
	ta_curr = ta_curr->next_ptr;
      }

      fprintf(prlog_fp, "        }\n");
      fprintf(prlog_fp, "        break;\n");
      fprintf(prlog_fp, "\n");
      tt_curr = tt_curr->next_ptr;
    }
  fprintf(prlog_fp, "      } /* end switch */\n");
  fprintf(prlog_fp, "    } /* end if decode of fieldname */\n");
  fprintf(prlog_fp, "  } /* end if decode of pkey */\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_log_do_set_str()
{
  int elseflag;

  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: log_do_set_str                                 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to set the value of an string field.*/\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Created by : Rob Rassmann                      		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Creation Date : 12/12/98	         		 */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: pkeychar    - char string of the primary key. */\n");
  fprintf(prlog_fp, "/*            fieldname   - char string of the changing field. */\n");
  fprintf(prlog_fp, "/*            newval      - char string value to be set.    */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "void log_do_set_str(const char pkeychar[HCG_KEY_SIZE+1],const char fieldname[NAMELENGTH+1],const char newval[BUFSIZE+1])\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  char pkey[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "  int tbl_encoding/*, fld_encoding*/;\n"); /* Sathya */
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  strcpy(pkey,pkeychar);\n");
  fprintf(prlog_fp, "  find_tbl_idx(pkeychar);\n");
  fprintf(prlog_fp, "  if(encode(pkey,&hcg_k) ==1)\n");
  fprintf(prlog_fp, "  {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found DL with pkey %%s.\\n\",pkeychar);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "    tbl_encoding = encoding(hcg_table_seq_list[hcg_tbl_idx].ttabbrev);\n");
  fprintf(prlog_fp, "    switch(tbl_encoding) {\n");
  fprintf(prlog_fp, "\n");
  /* for each table type, emit an appropriate delete action in the switch */

  tt_curr = tt;
  while ( tt_curr != NULL )
    {
      fprintf(prlog_fp, "  case %d: /* %s table */\n", encoding(tt_curr->TTabbr), tt_curr->TTabbr);

      fprintf(prlog_fp, "    pr_find(%s, %sid, hcg_k);\n", tt_curr->TTabbr, tt_curr->TTabbr);
      fprintf(prlog_fp, "    if (%scurr == NULL)\n",tt_curr->TTabbr);
      fprintf(prlog_fp, "      printf(\"log_do_set_str %%s not found.\\n\", pkeychar);\n");
      fprintf(prlog_fp, "    else{\n");

      ta_curr = tt_curr->ta_ptr;
      elseflag = 0;
      while (ta_curr != NULL)
      {
	if(*ta_curr->FieldType=='c' && ta_curr->IsKey==0)
	{
	  if(elseflag)
	    fprintf(prlog_fp, "      else\n");
	  else
	    elseflag = 1;
	  fprintf(prlog_fp, "      if(strcmp(fieldname,\"%s\")==0)\n",ta_curr->FieldName);
	  fprintf(prlog_fp, "        strcpy(%scurr->%s,newval);\n",tt_curr->TTabbr,ta_curr->FieldName);
	}
	ta_curr = ta_curr->next_ptr;
      }

      fprintf(prlog_fp, "    }\n");
      fprintf(prlog_fp, "    break;\n");
      fprintf(prlog_fp, "\n");
      tt_curr = tt_curr->next_ptr;
    }
  fprintf(prlog_fp, "    } /* end switch */\n");
  fprintf(prlog_fp, "  } /* end if decode */\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}


void
gen_replay_log()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function:replay_log                                      */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to parse the logfile and execute   */\n");
  fprintf(prlog_fp, "/* the action of the log entry.                             */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: logfile     - logfile to replay               */\n");
  fprintf(prlog_fp, "/*            near_realtime -         flag indicates to     */\n");
  fprintf(prlog_fp, "/*                           replay in near realtime        */\n");
  fprintf(prlog_fp, "/*                           0 = not real time              */\n");
  fprintf(prlog_fp, "/*                           1 = real time                  */\n");
  fprintf(prlog_fp, "/* Return values:                                           */\n");
  fprintf(prlog_fp, "/*        0 - success parsing and replay                    */\n");
  fprintf(prlog_fp, "/*       -3 - cannot open file                              */\n");
  fprintf(prlog_fp, "/*       -5 - incorrect logfile format                      */\n");
  fprintf(prlog_fp, "/* Effects:                                                 */\n"); /* Sathya */
  fprintf(prlog_fp, "/*   hcg_buffer   - altered                                 */\n"); /* Sathya */
  fprintf(prlog_fp, "/*   hcg_ascii_fp - altered                                 */\n"); /* Sathya */
  fprintf(prlog_fp, "/*   hcg_t        - altered                                 */\n"); /* Sathya */
  fprintf(prlog_fp, "/*   value of database may be altered based on the error in */\n");
  fprintf(prlog_fp, "/*       the format of the data file.  If no SP was found,  */\n");
  fprintf(prlog_fp, "/*       the replay will be done already.                   */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "int replay_log(char logfile[NAMELENGTH],int near_realtime)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  int idx;\n");
  fprintf(prlog_fp, "  char token[BUFSIZE];\n");
  fprintf(prlog_fp, "  FILE *logfile_fp;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* check variables */\n");
  fprintf(prlog_fp, "  if ((near_realtime != 1) && (near_realtime !=0)){\n");
  fprintf(prlog_fp, "    printf(\"replay_log: warning invalid value of near_realtime %%d.\\n\",near_realtime);\n");
  fprintf(prlog_fp, "    printf(\"\\tDefault = 0 (Ignore Wait Commands).\\n\");\n");
  fprintf(prlog_fp, "    near_realtime = 0;\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "  /* open the log file */\n");
  fprintf(prlog_fp, "  if ((logfile_fp = fopen(logfile, \"r\")) ==NULL) {\n");
  fprintf(prlog_fp, "    hcg_log = 0;\n");
  fprintf(prlog_fp, "    return(-3);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  hcg_ascii_fp = logfile_fp;\n");
  fprintf(prlog_fp, "  idx = 0;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  hcg_read_next();  /* read first line of log file */\n");
  fprintf(prlog_fp, " \n");
  fprintf(prlog_fp, "  /* check logfile header format */\n");
  fprintf(prlog_fp, "  hcg_parse(hcg_buffer,token,&idx);\n");
  fprintf(prlog_fp, "  if (strcmp(token, \"SR\")!=0)  {\n");
  fprintf(prlog_fp, "    fclose(logfile_fp);\n");
  fprintf(prlog_fp, "    return(-5);  /* log file is not opend with SR entry */\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found SR\\n\");\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, " \n");
  fprintf(prlog_fp, "  hcg_read_next();\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  while (!feof(hcg_ascii_fp)) {\n");
  fprintf(prlog_fp, "    idx = 0;\n");
  fprintf(prlog_fp, "    hcg_parse(hcg_buffer,token,&idx);\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"LD\") == 0) {\n");
  fprintf(prlog_fp, "      char logviewname[NAMELENGTH];\n");
  fprintf(prlog_fp, "      char datafile[NAMELENGTH];\n");
  fprintf(prlog_fp, "      char newdatafile[NAMELENGTH];\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,logviewname,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,datafile,&idx);\n");
  fprintf(prlog_fp, "      sprintf(newdatafile,\"temp%%s\",datafile);\n"); /* Sathya */
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found LD: viewname:%%s,datafile:%%s.\\n\",logviewname,newdatafile);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      pr_load(logviewname,newdatafile);  \n");
  fprintf(prlog_fp, "      hcg_ascii_fp = logfile_fp;  /* reset the file pointer */\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token, \"SP\") == 0) {\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found SP\\n\");\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      if (feof(hcg_ascii_fp)) {\n");
  fprintf(prlog_fp, "        fclose(logfile_fp);\n");
  fprintf(prlog_fp, "        return(0);  /* successful completion of log parsing */ \n");
  fprintf(prlog_fp, "      }\n");
  fprintf(prlog_fp, "      else {\n");
  fprintf(prlog_fp, "        fclose(logfile_fp);\n");
  fprintf(prlog_fp, "        return(-5);  /* log file has stuff after the SP entry */\n");
  fprintf(prlog_fp, "      }\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"WA\") == 0) {\n");
  fprintf(prlog_fp, "      char temp[BUFSIZE];\n");
  fprintf(prlog_fp, "      int totMsec;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "      /* get the wait times */\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp,&idx);\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "      /* convert seconds and milliseconds to milliseconds */\n");
  fprintf(prlog_fp, "      totMsec = atoi(temp);\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found WA with total milliseconds %%d.\\n\",totMsec);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      \n");
  fprintf(prlog_fp, "      /* must do the wait */\n");
  fprintf(prlog_fp, "      if ((near_realtime ==1)&& (totMsec > 0)) \n");
  fprintf(prlog_fp, "	log_sleep(totMsec);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"IN\") == 0) {\n");
  fprintf(prlog_fp, "      char viewname[NAMELENGTH],datalist[BUFSIZE],temp[BUFSIZE],tempdatalist[BUFSIZE];\n");
  fprintf(prlog_fp, "    \n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,viewname,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp,&idx);\n");
  fprintf(prlog_fp, "      strcpy(datalist,strstr(hcg_buffer, temp));\n");
  fprintf(prlog_fp, "     convert2temp(datalist,tempdatalist);\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found IN with viewname %%s, datalist=%%s.\\n\",viewname,temp);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      pr_init(viewname,tempdatalist);  \n");
  fprintf(prlog_fp, "      hcg_ascii_fp = logfile_fp;  /* reset the file pointer */\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"DL\") == 0) {\n");
  fprintf(prlog_fp, "      char temp[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp,&idx);\n");
  fprintf(prlog_fp, "      log_do_delete(temp);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");


  /*** New Code inserted 12/12/98 ***/
  fprintf(prlog_fp, "    if (strcmp(token,\"PR_SET_INT\") == 0) {\n");
  fprintf(prlog_fp, "      char temp_tbl[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "      char temp_field[NAMELENGTH+1];\n");
  fprintf(prlog_fp, "      char temp_newval[BUFSIZE+1];\n");
  fprintf(prlog_fp, "      int temp_newint;\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_tbl,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_field,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_newval,&idx);\n");
  fprintf(prlog_fp, "      temp_newint = atoi(temp_newval);\n");
  fprintf(prlog_fp, "      log_do_set_int(temp_tbl,temp_field,temp_newint);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"PR_SET_FLT\") == 0) {\n");
  fprintf(prlog_fp, "      char temp_tbl[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "      char temp_field[NAMELENGTH+1];\n");
  fprintf(prlog_fp, "      char temp_newval[BUFSIZE+1];\n");
  fprintf(prlog_fp, "      float temp_newflt;\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_tbl,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_field,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_newval,&idx);\n");
  fprintf(prlog_fp, "      temp_newflt = atof(temp_newval);\n");
  fprintf(prlog_fp, "      log_do_set_flt(temp_tbl,temp_field,temp_newflt);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"PR_SET_KEY\") == 0) {\n");
  fprintf(prlog_fp, "      char temp_tbl[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "      char temp_field[NAMELENGTH+1];\n");
  fprintf(prlog_fp, "      char temp_newkey[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_tbl,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_field,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_newkey,&idx);\n");
  fprintf(prlog_fp, "      log_do_set_key(temp_tbl,temp_field,temp_newkey);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"PR_SET_STR\") == 0) {\n");
  fprintf(prlog_fp, "      char temp_tbl[HCG_KEY_SIZE+1];\n");
  fprintf(prlog_fp, "      char temp_field[NAMELENGTH+1];\n");
  fprintf(prlog_fp, "      char temp_newstr[BUFSIZE+1];\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_tbl,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_field,&idx);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp_newstr,&idx);\n");
  fprintf(prlog_fp, "      log_do_set_str(temp_tbl,temp_field,temp_newstr);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  /*** End of New Code inserted 12/12/98 ***/

  fprintf(prlog_fp, "    if (strcmp(token,\"FR\") == 0) {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found FR.\\n\");\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      pr_free(); \n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "    if (strcmp(token,\"VN\") == 0) {\n");
  fprintf(prlog_fp, "      char viewname[NAMELENGTH];\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,viewname,&idx);\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Found VN with viewname %%s.\\n\",viewname);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      strcpy(hcg_viewname,viewname);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "    }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "   { \n");
  fprintf(prlog_fp, "      char temppkey[BUFSIZE],temp[BUFSIZE], *addlist;\n");
  fprintf(prlog_fp, "      /* unused: int tbl_encoding;*/\n"); /* Sathya */
  fprintf(prlog_fp, "      strcpy(temppkey,token);\n");
  fprintf(prlog_fp, "      hcg_parse(hcg_buffer,temp,&idx);\n");
  fprintf(prlog_fp, "      addlist = (char *)strstr(hcg_buffer, temp);\n");
  fprintf(prlog_fp, "      if (find_tbl_idx(temppkey)==0) {\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Unknown format: skipping %%s\\n\", temppkey);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "        hcg_read_next();\n");
  fprintf(prlog_fp, "        continue;\n");
  fprintf(prlog_fp, "      }\n");
  fprintf(prlog_fp, "#ifdef DEBUG\n");
  fprintf(prlog_fp, "  printf(\"Doing pr_add with pkey %%s, rest %%s.\\n\",temppkey,addlist);\n");
  fprintf(prlog_fp, "#endif\n");
  fprintf(prlog_fp, "      log_do_add(hcg_viewname,hcg_table_seq_list[hcg_tbl_idx].ttabbrev,addlist);\n");
  fprintf(prlog_fp, "      hcg_read_next();\n");
  fprintf(prlog_fp, "      continue;\n");
  fprintf(prlog_fp, "   }\n");
  fprintf(prlog_fp, "  }  /* end while !feof */\n");
  fprintf(prlog_fp, "  fclose(logfile_fp);\n");
  fprintf(prlog_fp, "  return(-5);  /* log file is not closed with SP entry */\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
}

void
gen_pr_replay()
{
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "/* Function: pr_replay                                      */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* This function is used to replay a logsession based on    */\n");
  fprintf(prlog_fp, "/* a log file.  It will destroy the current database,       */\n");
  fprintf(prlog_fp, "/* replace the DB from the start of the log session,        */\n");
  fprintf(prlog_fp, "/* reproduce the DB modifications based on the logfile.     */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/* Arguments: view      - the viewname of the log session   */\n");
  fprintf(prlog_fp, "/*     logfile          - the name of the logfile to replay */\n");
  fprintf(prlog_fp, "/*     near_realtime    - a boolean flag indicating if      */\n");
  fprintf(prlog_fp, "/*                      the replay should approx realtime   */\n");
  fprintf(prlog_fp, "/*                      0 - no near_realtime playback       */\n");
  fprintf(prlog_fp, "/*                      1 - playback in near-realtime       */\n");
  fprintf(prlog_fp, "/*     take_endsnapshot - a boolean flag indicating if the  */\n");
  fprintf(prlog_fp, "/*                      database should be dumped at the    */\n");
  fprintf(prlog_fp, "/*                      end of the replay.                  */\n");
  fprintf(prlog_fp, "/*                      0 - do not take the end DB snapshot */\n");
  fprintf(prlog_fp, "/*                      1 - take  the end DB snapshot       */\n");
  fprintf(prlog_fp, "/* Return values:                                           */\n");
  fprintf(prlog_fp, "/*     0 - success                                          */\n");
  fprintf(prlog_fp, "/*    -1 - Replay error - null view name                    */\n");
  fprintf(prlog_fp, "/*    -2 - Replay error - null log file                     */\n");
  fprintf(prlog_fp, "/*    -3 - Replay error - unable to open file               */\n");
  fprintf(prlog_fp, "/*    -4 - Replay error - log session in progress           */\n");
  fprintf(prlog_fp, "/*    -5 - Replay error - incorrect log file format         */\n");
  fprintf(prlog_fp, "/*                                                          */\n");
  fprintf(prlog_fp, "/************************************************************/\n");
  fprintf(prlog_fp, "int pr_replay(char *view,char logfile[NAMELENGTH],int near_realtime,int take_endsnapshot)\n"); /* Sathya */
  fprintf(prlog_fp, "{\n");
  fprintf(prlog_fp, "  /*unused: FILE *log_fp;*/\n"); /* Sathya */
  fprintf(prlog_fp, "  char filelist[BUFSIZE], tempfilelist[BUFSIZE],tempvar[BUFSIZE], logfiledb[NAMELENGTH];\n");
  fprintf(prlog_fp, "  int retval;\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  if (hcg_log ==1 ) {\n");
  fprintf(prlog_fp, "    printf(\"pr_replay error: logging in progress\\n\");\n");
  fprintf(prlog_fp, "    return(-4);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* set replay to be on & save logfilename*/\n");
  fprintf(prlog_fp, "  hcg_log = 2;\n");
  fprintf(prlog_fp, "  strcpy(hcg_logfile,logfile);\n");
  fprintf(prlog_fp, "  \n");
  fprintf(prlog_fp, "  /* validate the arguments */\n");
  fprintf(prlog_fp, "  if (view == NULL) {\n");
  fprintf(prlog_fp, "    printf(\"pr_replay error: null view name\\n\");\n");
  fprintf(prlog_fp, "    hcg_log = 0;\n");
  fprintf(prlog_fp, "    return(-1);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "  if (logfile == NULL) {\n");
  fprintf(prlog_fp, "    printf(\"pr_replay error: null log file\\n\");\n");
  fprintf(prlog_fp, "    hcg_log = 0;\n");
  fprintf(prlog_fp, "    return(-2);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* free the existing database */\n");
  fprintf(prlog_fp, "  if (hcg_initialized) {\n");
  fprintf(prlog_fp, "    pr_free();\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* generate the data files */\n");
  fprintf(prlog_fp, "  strtok(logfile,\".\");\n");
  fprintf(prlog_fp, "  sprintf(logfiledb,\"%%sDB1.dat\",logfile);\n");
  fprintf(prlog_fp, "  log_parselogdata(tempfilelist);\n");
  fprintf(prlog_fp, "  sprintf(filelist,\"%%s %%s\",tempfilelist, logfiledb); \n"); /* Sathya */
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* initialize & load the database */\n");
  fprintf(prlog_fp, "  pr_init(\"../lib/bdetest.viewdefs\",filelist);\n");
  fprintf(prlog_fp, "  pr_load(view,logfiledb);\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* replay the log  */\n");
  fprintf(prlog_fp, "  if ((retval = replay_log(hcg_logfile,near_realtime)) != 0) {\n");
  fprintf(prlog_fp, "    return(retval);\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* take final snapshot */\n");
  fprintf(prlog_fp, "  if (take_endsnapshot==1) {\n");
  fprintf(prlog_fp, "    sprintf(tempvar,\"%%sDB3.dat\",logfile); \n");
  fprintf(prlog_fp, "    pr_dump(view, tempvar,0,\"w\");\n");
  fprintf(prlog_fp, "  }\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  /* delete interim datafiles */\n");
  fprintf(prlog_fp, "  del_tempfiles(tempfilelist);\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "  hcg_log = 0;\n");
  fprintf(prlog_fp, "  return (0);\n");
  fprintf(prlog_fp, "}\n");
  fprintf(prlog_fp, "\n");
  fprintf(prlog_fp, "\n");

}

void
gen_pr_log()
{

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

	fprintf(prlog_fp,"#include <stdio.h>\n") ;
	fprintf(prlog_fp,"#include <string.h>\n") ;
    fprintf(prlog_fp,"#include <stdlib.h>\n") ;
	fprintf(prlog_fp,"#include <signal.h>\n") ;
	fprintf(prlog_fp,"#include <sys/time.h>\n");
	fprintf(prlog_fp,"#include <unistd.h>\n");  /* Sathya */
	fprintf(prlog_fp,"#include \"%s\"\n\n",sch_header_file_name) ;

	gen_globals();
	gen_sig_handler();
	gen_log_sleep();

	gen_usleep();
	gen_time_initialize();
	gen_get_delta_tee();
	gen_timeval2millisec();
	gen_logstr();
	gen_logwait();
	gen_pr_startlog();
	gen_pr_stoplog();
	gen_log_parselogdata();
	gen_del_tempfiles();
	gen_log_do_add();
	gen_convert2temp();
	gen_log_do_delete();

        /*** New Code inserted 12/12/98 ***/
        gen_log_do_set_int();
        gen_log_do_set_flt();
        gen_log_do_set_key();
        gen_log_do_set_str();
        /*** End of New Code inserted 12/12/98 ***/

	gen_replay_log();
	gen_pr_replay();



}