maininit.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "constype.h"
#include "filenames.h"
#include "init.h"
#include "collect.h"
#include "timelogic.h"
#include "passfail.h"
#include "vpassfail.h"
#include "result.h"

Include dependency graph for maininit.c:

Go to the source code of this file.

Macros
#define	DEBUG_PULSES   0

Functions
int	run_nominal ()
int	compute_nominal (int runall)
static int	read_command_line (int argc, char *argv[])
int	init_main (int argc, char *argv[])
int	main (int argc, char **argv)

Macro Definition Documentation

#define DEBUG_PULSES   0

Definition at line 15 of file maininit.c.

Function Documentation

int compute_nominal

(

int

runall

)

Definition at line 33 of file maininit.c.

{
 SIGNALS *sp;
 char inputfile[NAME_LENGTH], logicfile[NAME_LENGTH], sigfile[NAME_LENGTH];
 char checkfile[NAME_LENGTH];
 char passfailfile[NAME_LENGTH];
 FILE *fp;
      

 printf("\nRUNNING PULSE EXTRACTION FOR THE NOMINAL VALUES OF OPERATING PARAMETERS.\n\n\n");

 strcpy(inputfile, param.tmp_dir);
 strcat(inputfile, param.circuit_name);
 strcat(inputfile, param.nom_ext);

 strcpy(logicfile, param.output_dir);
 strcat(logicfile, param.circuit_name);
 strcat(logicfile, param.nom_ext);
 strcat(logicfile, param.logic_ext);

 strcpy(passfailfile, param.input_dir);
 strcat(passfailfile, param.circuit_name);
 strcat(passfailfile, param.passfail_ext);

 strcpy(checkfile, param.input_dir);
 strcat(checkfile, param.circuit_name);
 strcat(checkfile, param.check_ext);


#if DEBUG_PULSES
 strcpy(sigfile, param.output_dir);
 strcat(sigfile, param.circuit_name);
 strcat(sigfile, PULSE_EXT);
#endif

 switch(param.pulse_extraction_method)
  {
   case COLLECT_BY_PHASE:
        sp=collect_pulses_by_phase(inputfile);
        break;

   case COLLECT_BY_VOLTAGE:
        sp=collect_pulses_by_voltage(inputfile);
        break;

   case COLLECT_EDGES:
    sp=collect_edges(inputfile);
        break;
  }


 if(sp!=NULL)
  {
#if DEBUG_PULSES
   print_signals(sp, sigfile);
#endif

   if(param.pulse_extraction_method == COLLECT_EDGES) {
     print_edges(sp, logicfile);
     generate_latch_passfail_file(sp, passfailfile, runall);
     free_data(sp);
     return 1;
   }

   if(sp->clk_num>0)
     change_into_logic(sp);

   generate_passfail_file(sp, passfailfile, runall);

   if(param.input_options & C_SET)
     generate_check_file(sp, checkfile);

   if((fp=fopen(logicfile, "w"))==NULL)
    {
     printf("Cannot open file %s!\n\n", logicfile);
     return 0;
    }

   if(sp->clk_num>0)
     print_with_clk(sp, fp);
   else
     print_async_signals(sp, fp);

   free_data(sp);
  }
 else
  return 0;

 return 1;
}

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

Definition at line 162 of file maininit.c.

{
 FILE *fp;

 init_parameters();

 
 if(!read_command_line(argc, argv))
  {
   printf("SYNOPSIS:\n");
   printf("\tinit [-B|-c|-l|-lB] <circuit_name>\n");
   exit(255);
  }

 if(!read_config(INIT_CONFIG_FILE))
   exit(255);

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

/* prepare_included_files(); */

 generate_jspice_config();

 param.program = INIT_PROGRAM;
 if(param.input_options & LATCH_SET) {
   param.pulse_extraction_method = COLLECT_EDGES;
 }
  
 run_nominal();
 if(param.input_options & BATCH_SET)
   compute_nominal(1);
 else
   compute_nominal(0);
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 199 of file maininit.c.

{
    extern init_main(int, char**);
    extern opt_main(int, char**);
    extern marg_main(int, char**);
    const char *usage =
        "Usage:\n  malt -i (init args)\n"
        "  malt -o (opt args)\n"
        "  malt -m (marg args)\n";

    if (argc < 3) {
        puts(usage);
        return (255);
    }
    char *av1 = argv[1];
    argv[1] = argv[0];
    argc--;
    argv++;
    if (av1[0] == '-' && av1[1] == 'i')
        return (init_main(argc, argv));
    if (av1[0] == '-' && av1[1] == 'o')
        return (opt_main(argc, argv));
    if (av1[0] == '-' && av1[1] == 'm')
        return (marg_main(argc, argv));
    puts(usage);
    return (255);
}

static int read_command_line ( int  argc, char *  argv[]  )

static

Definition at line 125 of file maininit.c.

{
 if((argc<2) || (argc>3))
   return 0;

 if(argc==2)
  if(argv[1][0]!='-')
   return 1;
  else
   return 0;

 if(argc==3)
  if((strcmp(argv[1], "-c")==0) && (argv[2][0]!='-')) {
    param.input_options |= C_SET;
    return 1;
  }
  else if((strcmp(argv[1], "-B")==0) && (argv[2][0]!='-')) {
    param.input_options |= BATCH_SET;
    return 1;
  }
  else if((strcmp(argv[1], "-l")==0) && (argv[2][0]!='-')) {
    param.input_options |= LATCH_SET;
    return 1;
  }
  else if((strcmp(argv[1], "-lB")==0) && (argv[2][0]!='-')) {
    param.input_options |= LATCH_SET;
    param.input_options |= BATCH_SET;
    return 1;
  }
  else 
    return 0;
}

int run_nominal

(

)

Definition at line 18 of file maininit.c.

{
 char command_line[LINE_LENGTH];
 int is_ws = (strstr(param.spice_name, "wrspice") != NULL);

 printf("RUNNING %s FOR THE NOMINAL VALUES OF OPERATING PARAMETERS.\n\n\n",
     is_ws ? "WRSPICE" : "JSPICE");

 strcpy(command_line, param.spice_name);
 strcat(command_line, " nominal");

 return system(command_line);
}