init.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "constype.h"
#include "config.h"
#include "filenames.h"
#include "param.h"

Include dependency graph for init.c:

Go to the source code of this file.

Functions
void	trademark ()
void	command_line_error (char *filename)
void	init_parameters ()
static int	check_config_item (char *item_type, char **item_list, int item_num)
static int	blank_line (char *line)
static void	unrecognized_value (char *line, char *filename)
static void	out_of_range (char *line, char *filename)
int	read_config (char *filename)
static int	check_option (char *option)
int	read_options (int argc, char *argv[])
int	generate_jspice_config ()
int	file_copy (char *infilename, char *outfilename)

Variables
PARAMETERS	param

Function Documentation

static int blank_line ( char *  line )

static

Definition at line 150 of file init.c.

{
 int i=0, n=strlen(line);

 while(i<n)
  {
   if(!isspace(line[i++]))
     return 0;
  }
 return 1;
}

static int check_config_item ( char *  item_type, char **  item_list, int  item_num  )

static

Definition at line 132 of file init.c.

{
 int i=0;
 int not_found = 1;
 
 do
  { 
   not_found = strcmp(item_type, item_list[i++]);
  }
 while(not_found && (i < item_num));

 if (!not_found)
  return(i-1);
 else
  return(item_num + 1);
}

static int check_option ( char *  option )

static

Definition at line 819 of file init.c.

{
 int k,n;
 int jset=0;
 int iset=0;

 if(option[0]!='-')
  {
   printf("Unrecognized option: %s\n", option);
   return 0;
  }

 n=strlen(option);
 for(k=1; k<n; k++)
  switch(option[k])
   {
    case 'm': 
         if(jset)
           param.input_options |= JM_SET;
     else
           param.input_options |= M_SET;
         break;

    case 'h':
         if(iset)
       param.input_options |= IH_SET;
         else {
       param.input_options |= H_SET;
           if(jset)
             param.input_options |= JH_SET;
     }
         break;

    case 'r':
         param.input_options |= R_SET;
         if(jset)
           param.input_options |= JR_SET;
         break;  

    case 's':
         if(iset)
       param.input_options |= IS_SET;
     else {
       param.input_options |= S_SET;
           if(jset)
             param.input_options |= JS_SET;
         }
         break;

    case 'j':
         jset=1;
         break;

    case 'i':
         iset=1;
         break;

    case 'q':
         param.input_options |= Q_SET;
     break;

    case 'p':
         param.input_options |= P_SET;
     break;

    case 'v':
         param.input_options |= V_SET;
     break;

    case 'w':
         param.input_options |= W_SET;
     break;


/*
    case 'x':
         if(jset)
          param.input_options |= JX_SET;
     else
          {
           printf("Unrecognized option: %s\n", option);
           return 0;
          }
         break;
*/

    case 'd':
         if(iset)
          param.input_options |= ID_SET;
     else
          {
           printf("Unrecognized option: %s\n", option);
           return 0;
          }
         break;

    case 'B':
         param.input_options |= BATCH_SET;
         break;

    default:
         printf("Unrecognized option: %s\n", option);
         return 0;
   }

 return 1;
}

void command_line_error

(

char *

filename

)

Definition at line 27 of file init.c.

{
 char help[NAME_LENGTH];

 /* set the line that will call display of the command line help */
 strcpy(help, "more ");
 strcat(help, filename);

 system(help);
}

int file_copy	(	char *	infilename,
		char *	outfilename
	)

Definition at line 1136 of file init.c.

{
 FILE *infp, *outfp;
 char line[LINE_LENGTH];

 infp=fopen(infilename,"r");
 if(infp==NULL)
   return 0;
 outfp=fopen(outfilename,"w");
 if(outfp==NULL)
   return 0;

 while(fgets(line, LINE_LENGTH, infp)!=NULL)
   fputs(line, outfp);
 fclose(infp);
 fclose(outfp);
 return 1;
}

int generate_jspice_config

(

)

Definition at line 967 of file init.c.

{
 FILE *fp;
 int is_ws = (strstr(param.spice_name, "wrspice") != NULL);

 fp=fopen(JSPICE_CONFIG,"w");
 if(fp == NULL)
  {
   printf("Cannot create %s configuration file %s.\n\n",
     is_ws ? "wrspice" : "jspice", JSPICE_CONFIG);
   return 0;
  }

 if (is_ws) {
   fprintf(fp, "set subc_catchar=\":\"\n");
   fprintf(fp, "set subc_catmode=\"spice3\"\n\n");
 }

 fprintf(fp, "set circuit = '%s'\n\n", param.circuit_name);

 fprintf(fp, "quiet = %d\n\n", ((param.input_options & Q_SET)?1:0));

 fprintf(fp, "set circext  = '%s'\n", param.circuit_ext);
 fprintf(fp, "set paramext = '%s'\n", param.param_ext);
 fprintf(fp, "set printext = '%s'\n", param.print_ext);
 fprintf(fp, "set passfailext = '%s'\n\n", param.passfail_ext);
 fprintf(fp, "set checkext = '%s'\n", param.check_ext);

#if 0
 fprintf(fp, "set stepext  = '%s'\n", param.step_ext);
#endif

 fprintf(fp, "set phasext  = '%s'\n", param.phase_ext);
 fprintf(fp, "set avrext   = '%s'\n", param.avr_ext);
 fprintf(fp, "set holdext  = '%s'\n", param.hold_ext);
 fprintf(fp, "set setupext = '%s'\n", param.setup_ext);
 fprintf(fp, "set sepext = '%s'\n",   param.separation_ext);
 fprintf(fp, "set goodext  = '%s'\n", param.good_ext);
 fprintf(fp, "set badext   = '%s'\n", param.bad_ext);
 fprintf(fp, "set tparext   = '%s'\n\n", TPARAM_EXT);
 fprintf(fp, "set nomext   = '%s'\n\n", param.nom_ext);

 fprintf(fp, "set reportext   = '%s'\n\n", param.report_ext);

 fprintf(fp, "set input_dir   = '%s'\n", param.input_dir);
 fprintf(fp, "set tmp_dir     = '%s'\n", param.tmp_dir);
 fprintf(fp, "set output_dir  = '%s'\n\n", param.output_dir);

 fprintf(fp, "failthres    = %.2f\n", param.min_fail_thresh);
 fprintf(fp, "accuracy     = %.5f\n", param.accuracy/100.0);
 fprintf(fp, "time_accuracy  = %.5f\n", param.time_accuracy);
 fprintf(fp, "delay_variation = %.2f\n", param.max_delay_var);
 fprintf(fp, "check_inputs = %d\n", param.inputs_checked);

 fclose(fp);

 return 1;
}

void init_parameters

(

)

Definition at line 39 of file init.c.

{
 param.input_options=0;

 param.maxplane = 50000;
 param.maxiter = 100;
 param.miniter = 10;
 param.pulse_extraction_method = COLLECT_BY_PHASE;
 param.nom_phase_thresh = PHASE_THRESHOLD;
 param.min_phase_thresh = MIN_PHASE_THRESHOLD;
 param.max_phase_thresh = MAX_PHASE_THRESHOLD;
 param.interpolate = INTERPOLATION;

 param.min_pulse_phase_diff = PHASE_THRESHOLD_MIN;
 param.volt_thresh = VOLTAGE_THRESHOLD;

 param.min_fail_thresh = PASS_FAIL_THRESHOLD;
 param.checkpoint_ratio = CHECKING_RATIO;
 param.accuracy = DEFAULT_ACCURACY;
 param.time_accuracy = DEFAULT_TIME_ACCURACY;
 param.max_delay_var = MAX_DELAY_VARIATION;
 param.min_time_step = MINIMUM_STEP;
 param.inputs_checked = 1;

 strcpy(param.spice_name, JSPICE_CALL);
 strcpy(param.input_dir, INPUT_DIR);
 strcpy(param.tmp_dir, TMP_DIR);
 strcpy(param.output_dir, OUTPUT_DIR);

 strcpy(param.circuit_ext,  CIRCUIT_EXT);
 strcpy(param.param_ext,    PARAM_EXT);
 strcpy(param.print_ext,    PRINT_EXT);
 strcpy(param.step_ext,     STEP_EXT);
 strcpy(param.check_ext,    CHECK_EXT);
 strcpy(param.avr_ext,      AVR_EXT);
 strcpy(param.hold_ext,     HOLD_EXT);
 strcpy(param.setup_ext,    SETUP_EXT);
 strcpy(param.separation_ext, SEPARATION_EXT);
 strcpy(param.good_ext,     GOOD_EXT);
 strcpy(param.bad_ext,      BAD_EXT);
 strcpy(param.logic_ext,    LOGIC_EXT);
 strcpy(param.hose_ext,     HOLDSETUP_EXT);
 strcpy(param.report_ext,   REPORT_EXT);
 strcpy(param.period_ext,   INTERPOLATE_EXT);
 strcpy(param.comp_ext,     VALUE_COMP_EXT);
 strcpy(param.phase_ext,    PHASE_EXT);
 strcpy(param.nom_ext,      NOMINAL_EXT);
 strcpy(param.init_ext,     INIT_EXT);
 strcpy(param.passfail_ext, PASSFAIL_EXT);
 strcpy(param.marg_ext,     MARGIN_EXT);
 strcpy(param.bound_ext,    BOUNDARY_EXT);
 strcpy(param.opt_ext,      OPT_EXT);
 strcpy(param.region_ext,   REGION_EXT);
 strcpy(param.timeinit_ext, TIMEINIT_EXT);
 strcpy(param.signal_ext,   SIGNAL_EXT);

 param.avr_one_volt=LATCH_ONE_VOLT;
 param.nom_edge_thresh = LATCH_THRESHOLD;
 param.min_edge_sep = LATCH_MIN_EDGE_INT;
 param.max_zero_volt = LATCH_MAX_ZERO;
 param.min_one_volt = LATCH_MIN_ONE;
 param.min_checks_interval = LATCH_CHECK_INT;
 param.min_interval_to_riseedge = LATCH_EDGE_INT;
 param.min_interval_to_falledge = LATCH_EDGE_INT;
 param.clk_chktime_ratio = LATCH_CHECKRATIO;
}

static void out_of_range ( char *  line, char *  filename  )

static

Definition at line 170 of file init.c.

{
 printf("Parameter out of range in %s:\n%s\n\n",
                 filename, line);
}

int read_config

(

char *

filename

)

Definition at line 189 of file init.c.

{
 char config_item[NAME_LENGTH], eq[NAME_LENGTH], item[NAME_LENGTH];
 char in_buffer[LINE_LENGTH];
 FILE *fp;
 float fvalue;
 int ivalue;
 int no_error=1;


 if((fp = fopen(filename, "r"))==NULL)
  {
   printf("Warning !!!\nCannot open configuration file %s.\n\n", filename);
   return 0;
  }

 while(fgets(in_buffer, LINE_LENGTH, fp)!=NULL)
  {
   if(in_buffer[0]=='*')
    continue;

   if(blank_line(in_buffer))
     continue;

{
/* SRW ** Here's an alternate tokenizer that allows interior white space
          in the right side.  It alsl makes space arount '=' optional.
          This makes it possible to pass arguments to spice_name.
*/

    char *b = in_buffer;
    char *s = config_item;
    while (isspace(*b))
        b++;
    while (*b && !isspace(*b) && *b != '=')
        *s++ = *b++;
    *s = 0;
    while (isspace(*b) || *b == '=')
        b++;
    if (!*b || !*config_item) {
        printf("Unrecognized line in %s:\n%s\n\n", filename, in_buffer);
        no_error = 0;
        continue;
    }
    strncpy(item, b, NAME_LENGTH);
    item[NAME_LENGTH-1] = 0;
    s = item + strlen(item) - 1;
    while (s >= item && isspace(*s))
        *s-- = 0;
}
/*
   if(sscanf(in_buffer, "%s%s%s", config_item, eq, item)!=3)
    {
     printf("Unrecognized line in %s:\n%s\n\n", filename, in_buffer);
     no_error = 0;
     continue;
    }

   if(strcmp(eq, "=") != 0)
    {
     printf("Unrecognized line in %s:\n%s\n\n", filename, in_buffer);
     no_error = 0;
     continue;
    }
*/

     switch(check_config_item(config_item, config_item_list, CONFIG_ITEM_NUM))
       {
        case PLS_EXTR_MTHD_CONFIG:
         if(strcmp(item, "PT")==0)
              param.pulse_extraction_method = COLLECT_BY_PHASE;
             else
             if(strcmp(item, "VP")==0)
              param.pulse_extraction_method = COLLECT_BY_VOLTAGE;
             else
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             break;

        case PH_THR_NOM_CONFIG:   
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);  
               no_error = 0;
              }   
             else
             if((fvalue<0.0) || (fvalue>2.0))
              {
               out_of_range(in_buffer, filename);
               no_error = 0;
              }
             else
               param.nom_phase_thresh=fvalue*M_PI;
             break;

        case PH_THR_MIN_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);  
               no_error = 0;
              }   
             else
             if((fvalue<0.0) || (fvalue>2.0))
              {
               out_of_range(in_buffer, filename);
               no_error = 0;
              }
             else
               param.min_phase_thresh=fvalue*M_PI;
             break;

        case PH_THR_MAX_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);    
               no_error = 0;
              } 
             else
             if((fvalue<0.0) || (fvalue>2.0))
              {
               out_of_range(in_buffer, filename);
               no_error = 0;
              }
             else
               param.max_phase_thresh=fvalue*M_PI;  
             break;

        case INTERPOL_CONFIG:
         if(strcmp(item, "YES")==0)
              param.interpolate = 1;
             else
             if(strcmp(item, "NO")==0)
              param.interpolate = 0;
             else
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             break;

        case VOLT_THR_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.volt_thresh=fvalue*1e-6;
             break;

        case MAXPLANE_CONFIG:
             if(sscanf(item, "%d", &ivalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.maxplane=ivalue;
             break;

        case MAXITER_CONFIG:
             if(sscanf(item, "%d", &ivalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.maxiter=ivalue;
             break;

        case MINITER_CONFIG:
             if(sscanf(item, "%d", &ivalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.miniter=ivalue;
             break;

        case MIN_PH_DIFF_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);  
               no_error = 0;
              }
             else
             if((fvalue<0.0) || (fvalue>2.0))
              {
               out_of_range(in_buffer, filename);
               no_error = 0;
              }
             else
               param.min_pulse_phase_diff=fvalue*M_PI;  
             break;

    case ACCURACY_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.accuracy=fvalue;
             break;

    case TIME_ACCURACY_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.time_accuracy=fvalue;
             break;

    case MAX_DEL_VAR_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.max_delay_var=fvalue;
             break;

    case MIN_TIME_STEP_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
               param.min_time_step=fvalue;
             break;

        case CHECK_RATIO_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
             if((fvalue<0.0) || (fvalue>1.0))
              {
               out_of_range(in_buffer, filename);
               no_error = 0;
              }
             else
           param.checkpoint_ratio=fvalue;
             break;

        case FAIL_THR_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             else
             if((fvalue<0.0) || (fvalue>2*M_PI))
              {
               out_of_range(in_buffer, filename);
               no_error = 0;
              }
             else
               param.min_fail_thresh=fvalue;
             break;

        case IN_CHECK_CONFIG:
         if(strcmp(item, "YES")==0)
              param.inputs_checked = 1;
             else
             if(strcmp(item, "NO")==0)
              param.inputs_checked = 0;
             else
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             break;

    case IN_CONFIG:
         strcpy(param.input_dir, item);
             if(item[strlen(item)-1]!='/')
        strcat(param.input_dir, "/");
             break;

    case TMP_CONFIG:
         strcpy(param.tmp_dir, item);
             if(item[strlen(item)-1]!='/')
        strcat(param.tmp_dir, "/");
             break;

    case OUT_CONFIG:
         strcpy(param.output_dir, item);
             if(item[strlen(item)-1]!='/')
        strcat(param.output_dir, "/");
             break;

    case SPICE_CONFIG:
         strcpy(param.spice_name, item);
             break;

    case CIRC_CONFIG:
         strcpy(param.circuit_ext, item);
             break;

    case PARAM_CONFIG:
         strcpy(param.param_ext, item);
             break;

    case CHECK_CONFIG:
         strcpy(param.check_ext, item);
             break;

    case STEP_CONFIG:
         strcpy(param.step_ext, item);
             break;

    case PRINT_CONFIG:
         strcpy(param.print_ext, item);
             break;

    case MID_CONFIG:
         strcpy(param.avr_ext, item);
             break;

    case PHASE_CONFIG:
         strcpy(param.phase_ext, item);
             break;

    case SETUP_CONFIG:
         strcpy(param.setup_ext, item);
             break;

    case HOLD_CONFIG:
         strcpy(param.hold_ext, item);
             break;

    case SEPARATION_CONFIG:
         strcpy(param.separation_ext, item);
             break;

    case GOOD_CONFIG:
         strcpy(param.good_ext, item);
             break;

    case BAD_CONFIG:
         strcpy(param.bad_ext, item);
             break;

    case LOGIC_CONFIG:
         strcpy(param.logic_ext, item);
             break;

    case HOSE_CONFIG:
         strcpy(param.hose_ext, item);
             break;

    case REPORT_CONFIG:
         strcpy(param.report_ext, item);
             break;

    case NOMINAL_CONFIG:
         strcpy(param.nom_ext, item);
             break;

    case INIT_CONFIG:
         strcpy(param.init_ext, item);
             break;

    case PASSFAIL_CONFIG:
         strcpy(param.passfail_ext, item);
             break;

    case MARGINS_CONFIG:
         strcpy(param.marg_ext, item);
             break;

    case BOUNDARY_CONFIG:
         strcpy(param.bound_ext, item);
             break;

    case OPTIMIZE_CONFIG:
         strcpy(param.opt_ext, item);
             break;

    case REGION_CONFIG:
         strcpy(param.region_ext, item);
             break;

    case SIGNAL_CONFIG:
         strcpy(param.signal_ext, item);
             break;

        case ONE_VOLTAGE_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.avr_one_volt=fvalue*1.0e-3;
             break;


        case THRESHOLD_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.nom_edge_thresh=fvalue;
             break;


        case MAX_ZERO_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.max_zero_volt=fvalue;
             break;

        case MIN_ONE_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.min_one_volt=fvalue;
             break;

        case CHECK_INT_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.min_checks_interval=fvalue*1.0e-12;
             break;

        case RISEEDGE_CHECK_INT_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.min_interval_to_riseedge=fvalue*1.0e-12;
             break;

        case FALLEDGE_CHECK_INT_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.min_interval_to_falledge=fvalue*1.0e-12;
             break;

        case INTEREDGE_INT_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.min_edge_sep=fvalue*1.0e-12;
             break;

        case CLK_CHECKTIME_CONFIG:
             if(sscanf(item, "%f", &fvalue)!=1)
              {
               unrecognized_value(in_buffer, filename);
               no_error = 0;
              }
             param.clk_chktime_ratio=fvalue;
             break;


        default:
             printf("Unknown option in %s:\n%s\n\n", filename, in_buffer);
             no_error = 0;
             break;
       }
  }

 fclose(fp);

 param.nom_edge_thresh*=param.avr_one_volt;
 param.min_one_volt*=param.avr_one_volt;
 param.max_zero_volt*=param.avr_one_volt;

 return no_error;
}

int read_options	(	int	argc,
		char *	argv[]
	)

Definition at line 929 of file init.c.

{ 
 int i, ret_val=1;
 int iset=0;

 if(argc < 2)
  return 0;

 for(i=1; i<argc-1; i++)
  {
   if(!check_option(argv[i]))
     ret_val=0;
   if((param.input_options & I_SET) && (!iset))
     {
      strcpy(param.circuit_name, argv[argc-2]);
      strcpy(param.opt_num,      argv[argc-1]);
      iset=1;
      argc--;
     }
  }

 if(!iset)
   strcpy(param.circuit_name, argv[argc-1]);

 if(!((param.input_options & V_SET) && (param.input_options & P_SET)))
  {
   if(param.input_options & V_SET)
     param.pulse_extraction_method = COLLECT_BY_VOLTAGE;

   if(param.input_options & P_SET)
     param.pulse_extraction_method = COLLECT_BY_PHASE;
  }

 return ret_val;
}

void trademark

(

)

Definition at line 12 of file init.c.

{
 printf("  TAN -  Timing Analyzer,   v1.0\n");
 printf("Kris & Quentin    -  April 1, 1995\n\n");
}

static void unrecognized_value ( char *  line, char *  filename  )

static

Definition at line 163 of file init.c.

{
 printf("Unrecognized value of parameter in %s:\n%s\n\n",
                 filename, line);
}

Variable Documentation

PARAMETERS param

Definition at line 10 of file init.c.