/* 
    Copyright (C) 1999-2004 David Essex, Rildo Pragana
   
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2, or (at your option)
    any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this software; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
    Boston, MA 02111-1307 USA

    TinyCOBOL Pre-Processor program used as a front end to the main compiler.

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <assert.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <getopt.h>

#include "cobpp.h"
#include "htconfig.h"
#include "tcppversion.h"
#include "tcpphelp.h"
#include "mwindows.h"


extern FILE *pp_yyin;
extern FILE *pp_yyout;
FILE *yylist;

extern int pp_yyparse(void);
extern char *filename;

char HTG_COPYDIR[PATHMAX3 + 2] = "";
char HTG_FNAME_SUFFIX[PATHMAX1] = "";
char fpath[PATHMAX3 + 2] = ""; 
char fsuffix[PATHMAX] = ""; 

char *prg_name;

/* #define DEBUG_COBPP_PP            1 */

#ifdef DEBUG_COBPP_PP

char errppbuf[1024*8];

void debug_pp_rtn (const char *s1, const char *s2, const char *s3, int w1, int cw);

#define DEBUG_PPRTN_STR1(msg1) debug_pp_rtn (msg1, NULL, NULL, 0, 1);
#define DEBUG_PPRTN_STR3(msg1, msg2) debug_pp_rtn (msg1, msg2, NULL, 0, 3);
#define DEBUG_PPRTN_STR7(msg1, i1) debug_pp_rtn (msg1, NULL, NULL, i1, 7);
#define DEBUG_PPRTN_STR15(msg1, msg2, msg3) debug_pp_rtn (msg1, msg2, msg3, 0, 15);
#define DEBUG_PPRTN_STR21(msg1, msg2, i1) debug_pp_rtn (msg1, msg2, NULL, i1, 21);
#define DEBUG_PPRTN_STR105(msg1, msg2, msg3, i1) debug_pp_rtn (msg1, msg2, msg3, i1, 105);

#else

#define DEBUG_PPRTN_STR1(msg1) 
#define DEBUG_PPRTN_STR3(msg1, msg2) 
#define DEBUG_PPRTN_STR7(msg1, i1) 
#define DEBUG_PPRTN_STR15(msg1, msg2, msg3) 
#define DEBUG_PPRTN_STR21(msg1, msg2, i1)
#define DEBUG_PPRTN_STR105(msg1, msg2, msg3, i1)

#endif

/* Global Env struct due to yywrap, yylex */

int main( int argc , char** argv ) {

	int rc = 0;

        prg_name = argv[0];
	
	globalEnvPtr = &globalEnv;

	setDefaults();

	/* error, or help/version printed */
	rc = setOptions(&globalEnv, argc, argv);
	if (rc != 0) {
	   if ((rc > 0) && (rc < 100)) {
	       printHelp();
               CleanUp();
	   }
           return rc;
	}
		
	/* If everything is OK parse file */

	filename = strdup (globalEnv.ifname);
        pp_yyin = fopen(globalEnv.ifname, "r");
        if ( pp_yyin == NULL ) {
	    fprintf(stderr, "Error opening input file: %s\n", globalEnv.ifname);
	    rc = 3;
	    return rc;
	}
                
        if (globalEnv.ofname != NULL) {
           pp_yyout = fopen(globalEnv.ofname, "w");
           if ( pp_yyout == NULL ) {
		fprintf(stderr,
			"Error opening output file: %s\n"
			,globalEnv.ofname
		);
                fclose(pp_yyin);
	        rc = 9;
		return rc;
	   }
        }
	else {
	    pp_yyout = stdout;
	}

        if (globalEnv.lfname != NULL) { 
           yylist = fopen(globalEnv.lfname, "w");
           if ( yylist == NULL ) {
		fprintf(stderr,
			"Error opening listing file: %s\n"
			,globalEnv.lfname
		);
                fclose(pp_yyin);
                if ( pp_yyout != stdout ) {
                   fclose(pp_yyout);
                }
	        rc = 11;
		return rc;
	   }
        }
 
	setup_scanner_state();
/*	pp_yylex(); */
/*	rc = pp_yyparse(); */
	(void) pp_yyparse();

        rc = globalEnv.errFlag;

        DEBUG_PPRTN_STR7("Program return code=%d\n", rc)

        return rc;
}


/* 
 *  Initalize the Env struct passed to this function 
 */
void setDefaults(void) {
    
    Env *gEnv = globalEnvPtr;

    gEnv->codeFormat    = -1;   /* 1 is free , 0 is fixed */

    gEnv->debugFlag     = 0;    /* debug flag */

    gEnv->IncDebugLines = 0;
    gEnv->verboseFlag   = 0;    /* set verbose flag off */
    gEnv->errFlag       = 0;    /* no error state by default */
    gEnv->tab2space     = 0;    /* expand tabs to 0 spaces */
    gEnv->progName      = NULL;
    gEnv->ofname        = NULL;
    gEnv->ifname        = NULL;
    gEnv->lfname        = NULL;

}

/*
 *  Function to clean up memory allocated in program.
 * 
 */
void CleanUp(void) {
	
	Env *gEnv = globalEnvPtr;

	globalEnvPtr = NULL;
	if (gEnv->progName != NULL)
	       free(gEnv->progName);

	if (gEnv->ifname != NULL)
	       free(gEnv->ifname);

	if (gEnv->ofname != NULL)
		free(gEnv->ofname);

	if (gEnv->lfname != NULL)
		free(gEnv->lfname);
	
}

/*
 * Read in command line options and set up the Env struct passed in
 * Alloc memory for program name string in Env struct.
 * 
 */
int setOptions(Env* gEnv, int argc, char** argv) {
	
	/*  Read in args for option settings. */

    int r = 0, len, sw, i;
    char tbuf[PATHMAX1] = "";

    
    len = strlen(argv[0]);
    gEnv->progName = malloc(len + 1);
    if (gEnv->progName == NULL) {
       gEnv->errFlag++;
       r = 2;
       return r;
    }
    strncpy(gEnv->progName, argv[0], len);

    /*
     * Check argc for number of args  
     */
/*    if (( argc < 2 ) || (argc > 5 )){ */
    if ( argc < 2 ){
       /* printHelp(); */
       gEnv->errFlag++;
       r = 1;
       return r;
    }
    
/*    opterr = 0;    */
    while ((sw = getopt(argc, argv, option_list)) != EOF) {

      switch (sw) {

        /* Include debug lines from sources */
        case TCOBPP_CMDOPT_INC_DEBUG:
          gEnv->IncDebugLines = 1;
	break;
        
        /* Not currently used */
        case TCOBPP_CMDOPT_DEBUG:
          gEnv->debugFlag = 1;
	break;

        /* Set input file format to FIXED */
        case TCOBPP_CMDOPT_FRM_FIXED:
           if (gEnv->ifname != NULL) {
              fprintf(stderr, "error: duplicate input file name '%s' ... aborting\n", optarg);
              gEnv->errFlag++;
              r = 20;
              return r;
           }
           len = strlen(optarg);
/* 	   fprintf(stderr, "cobpp debug: optarg=%s: len=%d\n", optarg, len); */
           gEnv->ifname = (char*)malloc(len + 2);
           if (gEnv->ifname == NULL) {
              gEnv->errFlag++;
              r = 21;
              return r;
           }
	   strncpy(gEnv->ifname, optarg, len+1);
/* 	   fprintf(stderr, "cobpp debug: input file name :%s:, len=%d\n", gEnv->ifname, len); */
	   gEnv->codeFormat = 0; /* 1 is free, 0 is fixed */
	break;

        /* Add path to copybooks search path */
        case TCOBPP_CMDOPT_INC_PATH:
           append_include_path(optarg);
	break;

        /* Set output file name */
        case TCOBPP_CMDOPT_OUTFILE:
           if (gEnv->ofname != NULL) {
              fprintf(stderr, "error: duplicate output file name '%s' ... aborting\n", optarg);
              gEnv->errFlag++;
              r = 40;
              return r;
           }
           len = strlen(optarg);
           gEnv->ofname = (char*)malloc(len + 2);
           if (gEnv->ofname == NULL) {
              gEnv->errFlag++;
              r = 41;
              return r;
           }
	   strncpy(gEnv->ofname, optarg, len+1);
/* 	   fprintf(stderr, "cobpp debug: output file name '%s', len=%d\n", gEnv->ofname, len); */
	break;

        /* Set output listinf file name */
        case TCOBPP_CMDOPT_LIST:
           if (gEnv->lfname != NULL) {
              fprintf(stderr, "error: duplicate listing file name '%s' ... aborting\n", optarg);
              gEnv->errFlag++;
              r = 50;
              return r;
           }
           len = strlen(optarg);
           gEnv->lfname = (char*)malloc(len + 2);
           if (gEnv->lfname == NULL) {
              gEnv->errFlag++;
              r = 51;
              return r;
           }
	   strncpy(gEnv->lfname, optarg, len+1);
/* 	   fprintf(stderr, "cobpp debug: print file name '%s', len=%d\n", gEnv->lfname, len); */
	break;

        /* Set tab to space conversion length */
        case TCOBPP_CMDOPT_TAB_LEN:
           if (gEnv->tab2space != 0) {
              fprintf(stderr, "error: duplicate tabs2space argument '%s' specified ... aborting\n", optarg);
              gEnv->errFlag++;
              r = 60;
              return r;
           }
           strcpy(tbuf, optarg);
/*           len = strlen(optarg); */
           len = strlen(tbuf);
           for (i=0; i<len; i++) {
/*               if (!isdigit(optarg[i])) { */
               if (!isdigit(tbuf[i])) {
/*                  fprintf(stderr, "error: invalid tabs2space argument '%s' specified ... aborting\n", optarg); */
                  fprintf(stderr, "error: invalid tabs2space argument '%s' specified ... aborting\n", tbuf);
                  gEnv->errFlag++;
                  r = 61;
                  return r;
               }
           }
/*           sscanf(optarg, "%d", &gEnv->tab2space); */
           sscanf(tbuf, "%d", &gEnv->tab2space);
           if ((gEnv->tab2space < 1) || (gEnv->tab2space > 99)) {
                  fprintf(stderr, "error: invalid tabs2space argument '%s' specified, max=99 min=1 ... aborting\n", optarg);
                  gEnv->errFlag++;
                  r = 62;
                  return r;
           }
/*
 	   fprintf(stderr, "cobpp debug: input tab string :%s:, gEnv->tab2space=%d\n", optarg, gEnv->tab2space);
 	   fprintf(stderr, "cobpp debug: input tab string :%s:, gEnv->tab2space=%d\n", tbuf, gEnv->tab2space);
*/
	break;

        /* Set input file format to FREE */
        case TCOBPP_CMDOPT_FRM_FREE:
           if (gEnv->ifname != NULL) {
              fprintf(stderr, "error: duplicate input file name '%s' ... aborting\n", optarg);
              gEnv->errFlag++;
              r = 70;
              return r;
           }
           len = strlen(optarg);
/* 	   fprintf(stderr, "cobpp debug: optarg=%s: len=%d\n", optarg, len); */
           gEnv->ifname = (char*)malloc(len + 2);
/*           gEnv->ifname = malloc(len + 2); */
           if (gEnv->ifname == NULL) {
              gEnv->errFlag++;
              r = 71;
              return r;
           }
	   strncpy(gEnv->ifname, optarg, len+1);
/*	   strcpy(gEnv->ifname, optarg); */
/* 	   fprintf(stderr, "cobpp debug: input file name=%s:, len=%d\n", gEnv->ifname, len); */
	   gEnv->codeFormat = 1; /* 1 is free, 0 is fixed */
	break;

        /* Display version number */
        case TCOBPP_CMDOPT_VERSION:
           printVersion();
           r = 197;
	break;

        /* Set verbose option on  */
        case TCOBPP_CMDOPT_VERBOSE:
           gEnv->verboseFlag = 1;
	break;

        /* Display command line help  */
        case TCOBPP_CMDOPT_HELP1:
        case TCOBPP_CMDOPT_HELP:
        default:
           r = 5;
/*        printHelp(); */
	break;
   
      }
    }

   if (r == 0) {
      if (gEnv->ifname == NULL) {
         fprintf(stderr, "error: no input file name selected ... aborting\n");
         gEnv->errFlag++;
         r = 80;
      }
   }

   /* If tabs not set default to 8 spaces */
   if (gEnv->tab2space == 0)
       gEnv->tab2space = 8;

   return r;

}


/*
   Print out extended help 
*/
void printHelp(void){

/*     fprintf (stdout, */
     fprintf (stderr, 
              "Usage: %s %s%s",
              globalEnvPtr->progName,
              usage_list0,
              usage_list1
              );
}

/*  
 * Print pre-processor version and copyright
*/
void printVersion(void) {

	fprintf(stdout, "%s - %s\n%s\n", 
	                TCOBPP_TITLE, 
	                TCOBPP_PGM_VERSION, 
	                TCOBPP_COPYWR
	                );  
}

int find_copybook_file (char *fname, char *lname)
{
  int r = 1, len, sw = 0;  
  char *pt, 
       tpath[PATHMAX1], 
       fname1[PATHMAX], 
       lname1[PATHMAX1];
       
  if (lname == NULL) {
     if ((*fname == CHR_SQUOTE) || (*fname == CHR_DQUOTE)) {
        sw = STATE_FLIT_LNONE;
        strcpy(fname1, fname+1);
        len = strlen(fname1);
        fname1[len - 1] = CHR_EOS;
        r = find_filename_literal(fname1, HTG_COPYDIR);

     }
     else {
        sw = STATE_FNAME_LNONE;
        strcpy(fname1, fname);
        strcpy(HTG_FNAME_SUFFIX, STR_SEARCH_SUFFIXES);
        r = find_filename_text(fname1, HTG_COPYDIR, HTG_FNAME_SUFFIX);
     }
  }
  else {
     if ((*lname == CHR_SQUOTE) || (*lname == CHR_DQUOTE)) {
        strcpy(lname1, lname+1);
        len = strlen(lname1);
        lname1[len - 1] = CHR_EOS;
        strcpy(tpath, lname1);
	len = strlen(tpath);
	if (len > 0) {
	  if (tpath[len - 1] != CHR_COLEN) {
	     strcat(tpath, STR_COLEN);
	  }
	}
        if ((*fname == CHR_SQUOTE) || (*fname == CHR_DQUOTE)) {
            sw = STATE_FLIT_LLIT;
            strcpy(fname1, fname+1);
            len = strlen(fname1);
            fname1[len - 1] = CHR_EOS;
            r = find_filename_literal(fname1, tpath);
         }
         else {
            sw = STATE_FNAME_LLIT;
            strcpy(fname1, fname);
            strcpy(HTG_FNAME_SUFFIX, STR_SEARCH_SUFFIXES);
            r = find_filename_text(fname1, tpath, HTG_FNAME_SUFFIX);
         }
     }
     else {
        if ((*fname == CHR_SQUOTE) || (*fname == CHR_DQUOTE)) {
            sw = STATE_FLIT_LNAME;
            strcpy(fname1, fname+1);
            len = strlen(fname1);
            fname1[len - 1] = CHR_EOS;
            strcpy(lname1, lname);
            pt = find_env_variable(lname1);
            if (pt != NULL) {
               strcpy(tpath, pt);
            }
            else {
               strcpy(tpath, "");
            }
	    len = strlen(tpath);
	    if (len > 0) {
	      if (tpath[len - 1] != CHR_COLEN) {
		 strcat(tpath, STR_COLEN);
	      }
	    }
            r = find_filename_literal(fname1, tpath);
         }
         else {
            sw = STATE_FNAME_LNAME;
            strcpy(fname1, fname);
            strcpy(lname1, lname);
            strcpy(HTG_FNAME_SUFFIX, STR_SEARCH_SUFFIXES);
            pt = find_env_variable(lname1);
            if (pt != NULL) {
               strcpy(tpath, pt);
            }
            else {
               strcpy(tpath, "");
            }
	    len = strlen(tpath);
	    if (len > 0) {
	      if (tpath[len - 1] != CHR_COLEN) {
		 strcat(tpath, STR_COLEN);
	      }
	    }
            r = find_filename_text(fname1, tpath, HTG_FNAME_SUFFIX);
         }
     }     
  }
  
  return r;
}

int find_filename_literal (char *fname, char *fp)
{
  int r = 1, len, sw1=0;
  char *pt1;
  struct stat sbuf;
        
  strcpy(fpath, fp);

  len = strlen(fpath);
  if (len == 0) {
     sprintf(include_full_filename, "%s", fname);
     if (stat(include_full_filename, &sbuf) == 0) {
     	 if (S_ISREG(sbuf.st_mode) && 
     	    ((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
     	    r = 0;
     	    if (globalEnvPtr->verboseFlag == 1) {
     	       printf("found copybook name \'%s\'\n", include_full_filename);
     	    }
     	 }
         else {
            if (globalEnvPtr->verboseFlag == 1) {
               printf("copybook file \'%s\' not readable\n", include_full_filename);
            }
         }
     }
     else {
     	if (globalEnvPtr->verboseFlag == 1) {
     	   printf("copybook file \'%s\' not found\n", include_full_filename);
     	}
     }
  }
  else {
     // If filename is an absolute path ignore library path 
     if (*fname == CHR_SLASH) {
         if (globalEnvPtr->verboseFlag == 1) {
            printf("warning: ignoring other search path(s) in absolute path copybook name \'%s\'\n", fname);
         }
         sprintf(include_full_filename, "%s", fname);
         if (stat(include_full_filename, &sbuf) == 0) {
             if (S_ISREG(sbuf.st_mode) && 
         	((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
         	r = 0;
         	if (globalEnvPtr->verboseFlag == 1) {
         	   printf("found copybook name \'%s\'\n", include_full_filename);
         	}
             }
             else {
         	if (globalEnvPtr->verboseFlag == 1) {
         	   printf("copybook file \'%s\' not readable\n", include_full_filename);
         	}
             }
         }
         else {
            if (globalEnvPtr->verboseFlag == 1) {
               printf("copybook file \'%s\' not found\n", include_full_filename);
            }
         }
     }
     else {
         sw1 = 0;
         strcpy(fpath, fp);
         pt1 = find_token(fpath, STR_COLEN, 0);
         if (pt1 == NULL) {
            pt1 = fpath;
         }
         while (sw1 == 0) {
            sprintf(include_full_filename, "%s", pt1);
            if (stat(include_full_filename, &sbuf) == 0) {
               if (S_ISDIR(sbuf.st_mode) && 
                  ((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
                   if (globalEnvPtr->verboseFlag == 1) {
            	      printf("searching directory path \'%s\'\n", include_full_filename);
                   }
                   sprintf(include_full_filename, "%s/%s", pt1, fname);
                   if (stat(include_full_filename, &sbuf) == 0) {
                       if (S_ISREG(sbuf.st_mode) && 
                   	  ((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
                   	  r = 0;
                   	  if (globalEnvPtr->verboseFlag == 1) {
                   	     printf("found copybook name \'%s\'\n", include_full_filename);
                   	  }
                   	  sw1 = 1;
                       }
                       else {
                   	  if (globalEnvPtr->verboseFlag == 1) {
                   	     printf("copybook file \'%s\' not readable\n", include_full_filename);
                   	  }
                       }
                   }
                   else {
                      if (globalEnvPtr->verboseFlag == 1) {
             	   	 printf("copybook file \'%s\' not found\n", include_full_filename);
                      }
                   }
               }
               else {
                   if (globalEnvPtr->verboseFlag == 1) {
            	       printf("directory path \'%s\' not readable\n", include_full_filename);
                   }
               }
            }
            else {
                 if (globalEnvPtr->verboseFlag == 1) {
                    printf("directory path \'%s\' not found\n", include_full_filename);
                 }
            }
            pt1 = find_token(pt1, STR_COLEN, 1);
            if (pt1 == NULL) {
                sw1 = 1;
            }
         }
     }
  }

  return r;
}

int find_filename_text (char *fname, char *fp, char *fs)
{
  int r = 1, len, sw1, sw2;
  char *pt1, *pt2;
  struct stat sbuf;
        
  strcpy(fpath, fp);
  strcpy(fsuffix, fs);

  len = strlen(fpath);
  if (len == 0) {
     sw1 = 0;
     pt1 = find_token(fsuffix, STR_COLEN, 0);
     if (pt1 == NULL) {
         pt1 = fsuffix;
     }
     while (sw1 == 0) {
           sprintf(include_full_filename, "%s%s", fname, pt1);
           if (stat(include_full_filename, &sbuf) == 0) {
               if (S_ISREG(sbuf.st_mode) && 
                  ((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
                  r = 0;
                  if (globalEnvPtr->verboseFlag == 1) {
                     printf("found copybook name \'%s\'\n", include_full_filename);
                  }
                  sw1 = 1;
               }
               else {
                  if (globalEnvPtr->verboseFlag == 1) {
                     printf("copybook file \'%s\' not readable\n", include_full_filename);
                  }
               }
               sw1 = 1;
           }
           else {
              if (globalEnvPtr->verboseFlag == 1) {
             	 printf("copybook file \'%s\' not found\n", include_full_filename);
              }
           }
           pt1 = find_token(pt1, STR_COLEN, 1);
           if (pt1 == NULL) {
               sw1 = 1;
           }
     }
  }
  else {
     sw1 = 0;
     sw2 = 0;
     strcpy(fpath, fp);
     strcpy(fsuffix, fs);
     pt1 = find_token(fpath, STR_COLEN, 0);
     if (pt1 == NULL) {
     	 pt1 = fpath;
     }
     while (sw1 == 0) {
        sprintf(include_full_filename, "%s", pt1);
        if (stat(include_full_filename, &sbuf) == 0) {
           if (S_ISDIR(sbuf.st_mode) && 
              ((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
               if (globalEnvPtr->verboseFlag == 1) {
            	  printf("searching directory path \'%s\'\n", include_full_filename);
               }
               strcpy(fsuffix, fs);
               sw2 = 0;
               pt2 = find_token(fsuffix, STR_COLEN, 0);
               while (sw2 == 0) {
                     sprintf(include_full_filename, "%s/%s%s", pt1, fname, pt2);
                     if (stat(include_full_filename, &sbuf) == 0) {
                         if (S_ISREG(sbuf.st_mode) && 
                            ((S_IRUSR & sbuf.st_mode) || (S_IRGRP & sbuf.st_mode) || (S_IROTH & sbuf.st_mode))) {
                            r = 0;
                            if (globalEnvPtr->verboseFlag == 1) {
                               printf("found copybook name \'%s\'\n", include_full_filename);
                            }
                   	    sw1 = 1;
                   	    sw2 = 1;
                         }
                         else {
                            if (globalEnvPtr->verboseFlag == 1) {
                               printf("copybook file \'%s\' not readable\n", include_full_filename);
                            }
                         }
                         sw2 = 1;
                     }
                     else {
                        if (globalEnvPtr->verboseFlag == 1) {
             	           printf("copybook file \'%s\' not found\n", include_full_filename);
                        }
                     }
                     pt2 = find_token(pt2, STR_COLEN, 1);
                     if (pt2 == NULL) {
                        sw2 = 1;
                     }
               }
           }
           else {
               if (globalEnvPtr->verboseFlag == 1) {
            	  printf("directory path \'%s\' not readable\n", include_full_filename);
               }
           }
        }
        else {
             if (globalEnvPtr->verboseFlag == 1) {
                printf("directory path \'%s\' not found\n", include_full_filename);
             }
        }
        pt1 = find_token(pt1, STR_COLEN, 1);
        if (pt1 == NULL) {
            sw1 = 1;
        }
     }
  }

  return r;
}

char *find_env_variable (char *ev)
{
  char *pt, ev1[PATHMAX]; 
  int i, len;
  
  len = strlen(ev);  
  for (i=0; i<len; i++) {
      if (*(ev+i) == STR_DASH) {
         *(ev1+i) = STR_UNDERSCORE;
      }
      else {
         *(ev1+i) = *(ev+i);
      }
  }
  *(ev1+len) = CHR_EOS;
  
  pt = getenv(ev1);
  if (pt != NULL) {
     if (globalEnvPtr->verboseFlag == 1) {
  	 printf("envoromental variable \'%s\' found, setting search path(s) to \'%s\'\n", ev1, pt);
     }
     return pt;
  }
  
  if (globalEnvPtr->verboseFlag == 1) {
      printf("warning: envoromental variable \'%s\' not found\n", ev1);
  }

  return NULL;
}

char *find_token(char *p, const char *d, int sw)
{
 int i, len;
   
 DEBUG_PPRTN_STR105("find_token trace(1): p=%s; d=%s, sw=%d\n", p, d, sw)

 if (sw == 0) {
    
    len = strlen(p);
    *(p+len+1) = CHR_EOS;
    for (i=0; i<len; i++) {
        if (*(p+i) == *d) {
           *(p+i) = CHR_EOS;
            
           DEBUG_PPRTN_STR105("find_token trace(2): p=%s; d=%s, sw=%d\n", p, d, sw)

           return p;
        }
    }
     
    DEBUG_PPRTN_STR21("find_token trace(3): p=NULL; d=%s, sw=%d\n", d, sw)
    
    return NULL;

 }
 else {

    len = strlen(p);
    p = p + len + 1;
    if (*p != CHR_EOS) {
       len = strlen(p);
       for (i=0; i<len; i++) {
           if (*(p+i) == *d) {
              *(p+i) = CHR_EOS;
               
              DEBUG_PPRTN_STR105("find_token trace(4): p=%s; d=%s, sw=%d\n", p, d, sw)
              
              return p;
           }
       }
    }
    
    DEBUG_PPRTN_STR21("find_token trace(5): p=NULL; d=%s, sw=%d\n", d, sw)
    
    return NULL;
    
 }
 
}

void append_include_path(char *ap)
{
 int len1, len2, len3, rc=0;
 
 len1 = strlen(HTG_COPYDIR);
 len2 = strlen(ap);
 len3 = len1 + len2;

 if (len1 == 0)  {
    if (len2 < (PATHMAX3 + 1)) {  
       strcpy (HTG_COPYDIR, ap);
       strcat (HTG_COPYDIR, STR_COLEN);
    }
    else {
       rc = 16;
    }
 }
 else {
    if (len3 < PATHMAX3) {  
       strcat (HTG_COPYDIR, ap);
       strcat (HTG_COPYDIR, STR_COLEN);
    }
    else {
       rc = 16;
    }
 }

 if (globalEnvPtr->verboseFlag == 1) { 
    fprintf (stdout, "Appending '%s' to include (copybooks) search path\n", ap);
 }

 if (rc != 0) { 
    fprintf (stderr, "%s: *** Buffer overflow error while appending '%s' to include (copybooks) search path. Abort.\n", prg_name, ap);
    exit(rc);
 }

}

#ifdef DEBUG_COBPP_PP

void debug_pp_rtn (const char *s1, const char *s2, const char *s3, int w1, int cw)
{
   switch (cw)
   {
     case 3:
       sprintf(errppbuf, s1, s2);
       break;
     
     case 5:
       sprintf(errppbuf, s1, s3);
       break;
     
     case 7:
       sprintf(errppbuf, s1, w1);
       break;
     
     case 15:
       sprintf(errppbuf, s1, s2, s3);
       break;
     
     case 21:
       sprintf(errppbuf, s1, s2, w1);
       break;
     
     case 35:
       sprintf(errppbuf, s1, s3, w1);
       break;
     
     case 105:
       sprintf(errppbuf, s1, s2, s3, w1);
       break;
     
     default:
       sprintf(errppbuf, "%s", s1);
       break;
   }
   
   fprintf(stderr, "%s", errppbuf);
}

#endif