malt-wr
init.c
Go to the documentation of this file.
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 
5 #include "constype.h"
6 #include "config.h"
7 #include "filenames.h"
8 #include "param.h"
9 
11 
12 void trademark()
13 {
14  printf(" TAN - Timing Analyzer, v1.0\n");
15  printf("Kris & Quentin - April 1, 1995\n\n");
16 }
17 
18  /*** COMMAND_LINE_ERROR ***/
19 /*
20  GOAL:
21  printing the information about an error in the command line
22  and and displaying a help file with the description of the
23  command line;
24 
25 */
26 
28 {
29  char help[NAME_LENGTH];
30 
31  /* set the line that will call display of the command line help */
32  strcpy(help, "more ");
33  strcat(help, filename);
34 
35  system(help);
36 }
37 
38 
40 {
41  param.input_options=0;
42 
43  param.maxplane = 50000;
44  param.maxiter = 100;
45  param.miniter = 10;
50  param.interpolate = INTERPOLATION;
51 
54 
57  param.accuracy = DEFAULT_ACCURACY;
61  param.inputs_checked = 1;
62 
63  strcpy(param.spice_name, JSPICE_CALL);
64  strcpy(param.input_dir, INPUT_DIR);
65  strcpy(param.tmp_dir, TMP_DIR);
66  strcpy(param.output_dir, OUTPUT_DIR);
67 
68  strcpy(param.circuit_ext, CIRCUIT_EXT);
69  strcpy(param.param_ext, PARAM_EXT);
70  strcpy(param.print_ext, PRINT_EXT);
71  strcpy(param.step_ext, STEP_EXT);
72  strcpy(param.check_ext, CHECK_EXT);
73  strcpy(param.avr_ext, AVR_EXT);
74  strcpy(param.hold_ext, HOLD_EXT);
75  strcpy(param.setup_ext, SETUP_EXT);
76  strcpy(param.separation_ext, SEPARATION_EXT);
77  strcpy(param.good_ext, GOOD_EXT);
78  strcpy(param.bad_ext, BAD_EXT);
79  strcpy(param.logic_ext, LOGIC_EXT);
80  strcpy(param.hose_ext, HOLDSETUP_EXT);
81  strcpy(param.report_ext, REPORT_EXT);
82  strcpy(param.period_ext, INTERPOLATE_EXT);
83  strcpy(param.comp_ext, VALUE_COMP_EXT);
84  strcpy(param.phase_ext, PHASE_EXT);
85  strcpy(param.nom_ext, NOMINAL_EXT);
86  strcpy(param.init_ext, INIT_EXT);
87  strcpy(param.passfail_ext, PASSFAIL_EXT);
88  strcpy(param.marg_ext, MARGIN_EXT);
89  strcpy(param.bound_ext, BOUNDARY_EXT);
90  strcpy(param.opt_ext, OPT_EXT);
91  strcpy(param.region_ext, REGION_EXT);
92  strcpy(param.timeinit_ext, TIMEINIT_EXT);
93  strcpy(param.signal_ext, SIGNAL_EXT);
94 
104 }
105 
106 
107 
108  /*** CHECK_CONFIG_ITEM ***/
109 /*
110  GOAL:
111  verifying, if an item identifier in the configuration
112  file is a valid item type;
113 
114  INPUT:
115  item_type - item identifier being checked;
116 
117  OUTPUT:
118  item code number (i.e., position on the config_item_list)
119  - if the item is on the item list, or
120  CONFIG_ITEM_NUM + 1 (item list size plus one) - if it is invalid;
121 
122  OPERATION:
123  looking for the config_item_type on the config_item_list;
124 
125  USED IN:
126  read_config();
127 
128  USES:
129  strcmp();
130 */
131 
132 static int check_config_item(char *item_type, char **item_list, int item_num)
133 {
134  int i=0;
135  int not_found = 1;
136 
137  do
138  {
139  not_found = strcmp(item_type, item_list[i++]);
140  }
141  while(not_found && (i < item_num));
142 
143  if (!not_found)
144  return(i-1);
145  else
146  return(item_num + 1);
147 }
148 
149 
150 static int blank_line(char *line)
151 {
152  int i=0, n=strlen(line);
153 
154  while(i<n)
155  {
156  if(!isspace(line[i++]))
157  return 0;
158  }
159  return 1;
160 }
161 
162 
163 static void unrecognized_value(char *line, char *filename)
164 {
165  printf("Unrecognized value of parameter in %s:\n%s\n\n",
166  filename, line);
167 }
168 
169 
170 static void out_of_range(char *line, char *filename)
171 {
172  printf("Parameter out of range in %s:\n%s\n\n",
173  filename, line);
174 }
175 
176 
177  /*** READ_CONFIG ***/
178 /*
179  GOAL:
180  reading information about the environment from the
181  file CONFIG_FILE (="hs.config");
182 
183  OUTPUT:
184  TRUE - if operation succesful;
185  FALSE - otherwise;
186 */
187 
188 
190 {
191  char config_item[NAME_LENGTH], eq[NAME_LENGTH], item[NAME_LENGTH];
192  char in_buffer[LINE_LENGTH];
193  FILE *fp;
194  float fvalue;
195  int ivalue;
196  int no_error=1;
197 
198 
199  if((fp = fopen(filename, "r"))==NULL)
200  {
201  printf("Warning !!!\nCannot open configuration file %s.\n\n", filename);
202  return 0;
203  }
204 
205  while(fgets(in_buffer, LINE_LENGTH, fp)!=NULL)
206  {
207  if(in_buffer[0]=='*')
208  continue;
209 
210  if(blank_line(in_buffer))
211  continue;
212 
213 {
214 /* SRW ** Here's an alternate tokenizer that allows interior white space
215  in the right side. It alsl makes space arount '=' optional.
216  This makes it possible to pass arguments to spice_name.
217 */
218 
219  char *b = in_buffer;
220  char *s = config_item;
221  while (isspace(*b))
222  b++;
223  while (*b && !isspace(*b) && *b != '=')
224  *s++ = *b++;
225  *s = 0;
226  while (isspace(*b) || *b == '=')
227  b++;
228  if (!*b || !*config_item) {
229  printf("Unrecognized line in %s:\n%s\n\n", filename, in_buffer);
230  no_error = 0;
231  continue;
232  }
233  strncpy(item, b, NAME_LENGTH);
234  item[NAME_LENGTH-1] = 0;
235  s = item + strlen(item) - 1;
236  while (s >= item && isspace(*s))
237  *s-- = 0;
238 }
239 /*
240  if(sscanf(in_buffer, "%s%s%s", config_item, eq, item)!=3)
241  {
242  printf("Unrecognized line in %s:\n%s\n\n", filename, in_buffer);
243  no_error = 0;
244  continue;
245  }
246 
247  if(strcmp(eq, "=") != 0)
248  {
249  printf("Unrecognized line in %s:\n%s\n\n", filename, in_buffer);
250  no_error = 0;
251  continue;
252  }
253 */
254 
255  switch(check_config_item(config_item, config_item_list, CONFIG_ITEM_NUM))
256  {
258  if(strcmp(item, "PT")==0)
260  else
261  if(strcmp(item, "VP")==0)
263  else
264  {
265  unrecognized_value(in_buffer, filename);
266  no_error = 0;
267  }
268  break;
269 
270  case PH_THR_NOM_CONFIG:
271  if(sscanf(item, "%f", &fvalue)!=1)
272  {
273  unrecognized_value(in_buffer, filename);
274  no_error = 0;
275  }
276  else
277  if((fvalue<0.0) || (fvalue>2.0))
278  {
279  out_of_range(in_buffer, filename);
280  no_error = 0;
281  }
282  else
283  param.nom_phase_thresh=fvalue*M_PI;
284  break;
285 
286  case PH_THR_MIN_CONFIG:
287  if(sscanf(item, "%f", &fvalue)!=1)
288  {
289  unrecognized_value(in_buffer, filename);
290  no_error = 0;
291  }
292  else
293  if((fvalue<0.0) || (fvalue>2.0))
294  {
295  out_of_range(in_buffer, filename);
296  no_error = 0;
297  }
298  else
299  param.min_phase_thresh=fvalue*M_PI;
300  break;
301 
302  case PH_THR_MAX_CONFIG:
303  if(sscanf(item, "%f", &fvalue)!=1)
304  {
305  unrecognized_value(in_buffer, filename);
306  no_error = 0;
307  }
308  else
309  if((fvalue<0.0) || (fvalue>2.0))
310  {
311  out_of_range(in_buffer, filename);
312  no_error = 0;
313  }
314  else
315  param.max_phase_thresh=fvalue*M_PI;
316  break;
317 
318  case INTERPOL_CONFIG:
319  if(strcmp(item, "YES")==0)
320  param.interpolate = 1;
321  else
322  if(strcmp(item, "NO")==0)
323  param.interpolate = 0;
324  else
325  {
326  unrecognized_value(in_buffer, filename);
327  no_error = 0;
328  }
329  break;
330 
331  case VOLT_THR_CONFIG:
332  if(sscanf(item, "%f", &fvalue)!=1)
333  {
334  unrecognized_value(in_buffer, filename);
335  no_error = 0;
336  }
337  else
338  param.volt_thresh=fvalue*1e-6;
339  break;
340 
341  case MAXPLANE_CONFIG:
342  if(sscanf(item, "%d", &ivalue)!=1)
343  {
344  unrecognized_value(in_buffer, filename);
345  no_error = 0;
346  }
347  else
348  param.maxplane=ivalue;
349  break;
350 
351  case MAXITER_CONFIG:
352  if(sscanf(item, "%d", &ivalue)!=1)
353  {
354  unrecognized_value(in_buffer, filename);
355  no_error = 0;
356  }
357  else
358  param.maxiter=ivalue;
359  break;
360 
361  case MINITER_CONFIG:
362  if(sscanf(item, "%d", &ivalue)!=1)
363  {
364  unrecognized_value(in_buffer, filename);
365  no_error = 0;
366  }
367  else
368  param.miniter=ivalue;
369  break;
370 
371  case MIN_PH_DIFF_CONFIG:
372  if(sscanf(item, "%f", &fvalue)!=1)
373  {
374  unrecognized_value(in_buffer, filename);
375  no_error = 0;
376  }
377  else
378  if((fvalue<0.0) || (fvalue>2.0))
379  {
380  out_of_range(in_buffer, filename);
381  no_error = 0;
382  }
383  else
384  param.min_pulse_phase_diff=fvalue*M_PI;
385  break;
386 
387  case ACCURACY_CONFIG:
388  if(sscanf(item, "%f", &fvalue)!=1)
389  {
390  unrecognized_value(in_buffer, filename);
391  no_error = 0;
392  }
393  else
394  param.accuracy=fvalue;
395  break;
396 
398  if(sscanf(item, "%f", &fvalue)!=1)
399  {
400  unrecognized_value(in_buffer, filename);
401  no_error = 0;
402  }
403  else
404  param.time_accuracy=fvalue;
405  break;
406 
407  case MAX_DEL_VAR_CONFIG:
408  if(sscanf(item, "%f", &fvalue)!=1)
409  {
410  unrecognized_value(in_buffer, filename);
411  no_error = 0;
412  }
413  else
414  param.max_delay_var=fvalue;
415  break;
416 
418  if(sscanf(item, "%f", &fvalue)!=1)
419  {
420  unrecognized_value(in_buffer, filename);
421  no_error = 0;
422  }
423  else
424  param.min_time_step=fvalue;
425  break;
426 
427  case CHECK_RATIO_CONFIG:
428  if(sscanf(item, "%f", &fvalue)!=1)
429  {
430  unrecognized_value(in_buffer, filename);
431  no_error = 0;
432  }
433  else
434  if((fvalue<0.0) || (fvalue>1.0))
435  {
436  out_of_range(in_buffer, filename);
437  no_error = 0;
438  }
439  else
440  param.checkpoint_ratio=fvalue;
441  break;
442 
443  case FAIL_THR_CONFIG:
444  if(sscanf(item, "%f", &fvalue)!=1)
445  {
446  unrecognized_value(in_buffer, filename);
447  no_error = 0;
448  }
449  else
450  if((fvalue<0.0) || (fvalue>2*M_PI))
451  {
452  out_of_range(in_buffer, filename);
453  no_error = 0;
454  }
455  else
456  param.min_fail_thresh=fvalue;
457  break;
458 
459  case IN_CHECK_CONFIG:
460  if(strcmp(item, "YES")==0)
461  param.inputs_checked = 1;
462  else
463  if(strcmp(item, "NO")==0)
464  param.inputs_checked = 0;
465  else
466  {
467  unrecognized_value(in_buffer, filename);
468  no_error = 0;
469  }
470  break;
471 
472  case IN_CONFIG:
473  strcpy(param.input_dir, item);
474  if(item[strlen(item)-1]!='/')
475  strcat(param.input_dir, "/");
476  break;
477 
478  case TMP_CONFIG:
479  strcpy(param.tmp_dir, item);
480  if(item[strlen(item)-1]!='/')
481  strcat(param.tmp_dir, "/");
482  break;
483 
484  case OUT_CONFIG:
485  strcpy(param.output_dir, item);
486  if(item[strlen(item)-1]!='/')
487  strcat(param.output_dir, "/");
488  break;
489 
490  case SPICE_CONFIG:
491  strcpy(param.spice_name, item);
492  break;
493 
494  case CIRC_CONFIG:
495  strcpy(param.circuit_ext, item);
496  break;
497 
498  case PARAM_CONFIG:
499  strcpy(param.param_ext, item);
500  break;
501 
502  case CHECK_CONFIG:
503  strcpy(param.check_ext, item);
504  break;
505 
506  case STEP_CONFIG:
507  strcpy(param.step_ext, item);
508  break;
509 
510  case PRINT_CONFIG:
511  strcpy(param.print_ext, item);
512  break;
513 
514  case MID_CONFIG:
515  strcpy(param.avr_ext, item);
516  break;
517 
518  case PHASE_CONFIG:
519  strcpy(param.phase_ext, item);
520  break;
521 
522  case SETUP_CONFIG:
523  strcpy(param.setup_ext, item);
524  break;
525 
526  case HOLD_CONFIG:
527  strcpy(param.hold_ext, item);
528  break;
529 
530  case SEPARATION_CONFIG:
531  strcpy(param.separation_ext, item);
532  break;
533 
534  case GOOD_CONFIG:
535  strcpy(param.good_ext, item);
536  break;
537 
538  case BAD_CONFIG:
539  strcpy(param.bad_ext, item);
540  break;
541 
542  case LOGIC_CONFIG:
543  strcpy(param.logic_ext, item);
544  break;
545 
546  case HOSE_CONFIG:
547  strcpy(param.hose_ext, item);
548  break;
549 
550  case REPORT_CONFIG:
551  strcpy(param.report_ext, item);
552  break;
553 
554  case NOMINAL_CONFIG:
555  strcpy(param.nom_ext, item);
556  break;
557 
558  case INIT_CONFIG:
559  strcpy(param.init_ext, item);
560  break;
561 
562  case PASSFAIL_CONFIG:
563  strcpy(param.passfail_ext, item);
564  break;
565 
566  case MARGINS_CONFIG:
567  strcpy(param.marg_ext, item);
568  break;
569 
570  case BOUNDARY_CONFIG:
571  strcpy(param.bound_ext, item);
572  break;
573 
574  case OPTIMIZE_CONFIG:
575  strcpy(param.opt_ext, item);
576  break;
577 
578  case REGION_CONFIG:
579  strcpy(param.region_ext, item);
580  break;
581 
582  case SIGNAL_CONFIG:
583  strcpy(param.signal_ext, item);
584  break;
585 
586  case ONE_VOLTAGE_CONFIG:
587  if(sscanf(item, "%f", &fvalue)!=1)
588  {
589  unrecognized_value(in_buffer, filename);
590  no_error = 0;
591  }
592  param.avr_one_volt=fvalue*1.0e-3;
593  break;
594 
595 
596  case THRESHOLD_CONFIG:
597  if(sscanf(item, "%f", &fvalue)!=1)
598  {
599  unrecognized_value(in_buffer, filename);
600  no_error = 0;
601  }
602  param.nom_edge_thresh=fvalue;
603  break;
604 
605 
606  case MAX_ZERO_CONFIG:
607  if(sscanf(item, "%f", &fvalue)!=1)
608  {
609  unrecognized_value(in_buffer, filename);
610  no_error = 0;
611  }
612  param.max_zero_volt=fvalue;
613  break;
614 
615  case MIN_ONE_CONFIG:
616  if(sscanf(item, "%f", &fvalue)!=1)
617  {
618  unrecognized_value(in_buffer, filename);
619  no_error = 0;
620  }
621  param.min_one_volt=fvalue;
622  break;
623 
624  case CHECK_INT_CONFIG:
625  if(sscanf(item, "%f", &fvalue)!=1)
626  {
627  unrecognized_value(in_buffer, filename);
628  no_error = 0;
629  }
630  param.min_checks_interval=fvalue*1.0e-12;
631  break;
632 
634  if(sscanf(item, "%f", &fvalue)!=1)
635  {
636  unrecognized_value(in_buffer, filename);
637  no_error = 0;
638  }
639  param.min_interval_to_riseedge=fvalue*1.0e-12;
640  break;
641 
643  if(sscanf(item, "%f", &fvalue)!=1)
644  {
645  unrecognized_value(in_buffer, filename);
646  no_error = 0;
647  }
648  param.min_interval_to_falledge=fvalue*1.0e-12;
649  break;
650 
652  if(sscanf(item, "%f", &fvalue)!=1)
653  {
654  unrecognized_value(in_buffer, filename);
655  no_error = 0;
656  }
657  param.min_edge_sep=fvalue*1.0e-12;
658  break;
659 
661  if(sscanf(item, "%f", &fvalue)!=1)
662  {
663  unrecognized_value(in_buffer, filename);
664  no_error = 0;
665  }
666  param.clk_chktime_ratio=fvalue;
667  break;
668 
669 
670  default:
671  printf("Unknown option in %s:\n%s\n\n", filename, in_buffer);
672  no_error = 0;
673  break;
674  }
675  }
676 
677  fclose(fp);
678 
679  param.nom_edge_thresh*=param.avr_one_volt;
680  param.min_one_volt*=param.avr_one_volt;
681  param.max_zero_volt*=param.avr_one_volt;
682 
683  return no_error;
684 }
685 
686 #if 0
687 int read_xy_config(XY_PARAMETERS *xy_param, char* circuit_name)
688 {
689  char config_item[NAME_LENGTH], eq[NAME_LENGTH], item[NAME_LENGTH];
690  char in_buffer[LINE_LENGTH];
691  char jxfile[LINE_LENGTH];
692  FILE *fp;
693  int no_error=1;
694  float fvalue;
695  int ivalue;
696 
697  xy_param->xmin = 0;
698  xy_param->xmax = 0;
699  xy_param->step = 1;
700  xy_param->input_nr = -1;
701  xy_param->in_clk_cycle = -1;
702  xy_param->out_clk_cycle = -1;
703 
704  strcpy(jxfile, param.input_dir);
705  strcat(jxfile, circuit_name);
706  strcat(jxfile, XY_CONFIG_FILE_EXT);
707 
708  if((fp = fopen(jxfile, "r"))==NULL)
709  {
710  printf("Warning !!!\nCannot open configuration file %s.\n\n", jxfile);
711  return 0;
712  }
713 
714  while(fgets(in_buffer, LINE_LENGTH, fp)!=NULL)
715  {
716  if(in_buffer[0]=='*')
717  continue;
718 
719  if(blank_line(in_buffer))
720  continue;
721 
722  if(sscanf(in_buffer, "%s%s%s", config_item, eq, item)!=3)
723  {
724  printf("Unrecognized line in %s:\n%s\n\n", jxfile, in_buffer);
725  no_error=0;
726  continue;
727  }
728 
729  if(strcmp(eq, "=") != 0)
730  {
731  printf("Unrecognized line in %s:\n%s\n\n", jxfile, in_buffer);
732  no_error=0;
733  continue;
734  }
735 
736 
738  {
739  case XMIN_XY_CONFIG:
740  if(sscanf(item, "%f", &fvalue)!=1)
741  {
742  unrecognized_value(in_buffer, jxfile);
743  no_error=0;
744  }
745  else
746  xy_param->xmin = fvalue;
747  break;
748 
749  case XMAX_XY_CONFIG:
750  if(sscanf(item, "%f", &fvalue)!=1)
751  {
752  unrecognized_value(in_buffer, jxfile);
753  no_error=0;
754  }
755  else
756  xy_param->xmax = fvalue;
757  break;
758 
759  case XSTEP_XY_CONFIG:
760  if(sscanf(item, "%f", &fvalue)!=1)
761  {
762  unrecognized_value(in_buffer, jxfile);
763  no_error=0;
764  }
765  else
766  xy_param->step = fvalue;
767  break;
768 
769  case INPUT_NR_XY_CONFIG:
770  if(sscanf(item, "%d", &ivalue)!=1)
771  {
772  unrecognized_value(in_buffer, jxfile);
773  no_error=0;
774  }
775  else
776  if(ivalue<1)
777  {
778  out_of_range(in_buffer, jxfile);
779  no_error=0;
780  }
781  else
782  xy_param->input_nr = ivalue;
783  break;
784 
786  if(sscanf(item, "%d", &ivalue)!=1)
787  {
788  unrecognized_value(in_buffer, jxfile);
789  no_error=0;
790  }
791  else
792  xy_param->in_clk_cycle = ivalue;
793  break;
794 
796  if(sscanf(item, "%d", &ivalue)!=1)
797  {
798  unrecognized_value(in_buffer, jxfile);
799  no_error=0;
800  }
801  else
802  xy_param->out_clk_cycle = ivalue;
803  break;
804 
805  default:
806  printf("Unknown option in %s:\n%s\n\n", jxfile, in_buffer);
807  no_error=0;
808  break;
809 
810  }
811  }
812  fclose(fp);
813 
814  return no_error;
815 }
816 #endif
817 
818 
819 static int check_option(char *option)
820 {
821  int k,n;
822  int jset=0;
823  int iset=0;
824 
825  if(option[0]!='-')
826  {
827  printf("Unrecognized option: %s\n", option);
828  return 0;
829  }
830 
831  n=strlen(option);
832  for(k=1; k<n; k++)
833  switch(option[k])
834  {
835  case 'm':
836  if(jset)
837  param.input_options |= JM_SET;
838  else
839  param.input_options |= M_SET;
840  break;
841 
842  case 'h':
843  if(iset)
844  param.input_options |= IH_SET;
845  else {
846  param.input_options |= H_SET;
847  if(jset)
848  param.input_options |= JH_SET;
849  }
850  break;
851 
852  case 'r':
853  param.input_options |= R_SET;
854  if(jset)
855  param.input_options |= JR_SET;
856  break;
857 
858  case 's':
859  if(iset)
860  param.input_options |= IS_SET;
861  else {
862  param.input_options |= S_SET;
863  if(jset)
864  param.input_options |= JS_SET;
865  }
866  break;
867 
868  case 'j':
869  jset=1;
870  break;
871 
872  case 'i':
873  iset=1;
874  break;
875 
876  case 'q':
877  param.input_options |= Q_SET;
878  break;
879 
880  case 'p':
881  param.input_options |= P_SET;
882  break;
883 
884  case 'v':
885  param.input_options |= V_SET;
886  break;
887 
888  case 'w':
889  param.input_options |= W_SET;
890  break;
891 
892 
893 /*
894  case 'x':
895  if(jset)
896  param.input_options |= JX_SET;
897  else
898  {
899  printf("Unrecognized option: %s\n", option);
900  return 0;
901  }
902  break;
903 */
904 
905  case 'd':
906  if(iset)
907  param.input_options |= ID_SET;
908  else
909  {
910  printf("Unrecognized option: %s\n", option);
911  return 0;
912  }
913  break;
914 
915  case 'B':
916  param.input_options |= BATCH_SET;
917  break;
918 
919  default:
920  printf("Unrecognized option: %s\n", option);
921  return 0;
922  }
923 
924  return 1;
925 }
926 
927 
928 
929 int read_options(int argc, char*argv[])
930 {
931  int i, ret_val=1;
932  int iset=0;
933 
934  if(argc < 2)
935  return 0;
936 
937  for(i=1; i<argc-1; i++)
938  {
939  if(!check_option(argv[i]))
940  ret_val=0;
941  if((param.input_options & I_SET) && (!iset))
942  {
943  strcpy(param.circuit_name, argv[argc-2]);
944  strcpy(param.opt_num, argv[argc-1]);
945  iset=1;
946  argc--;
947  }
948  }
949 
950  if(!iset)
951  strcpy(param.circuit_name, argv[argc-1]);
952 
953  if(!((param.input_options & V_SET) && (param.input_options & P_SET)))
954  {
955  if(param.input_options & V_SET)
957 
958  if(param.input_options & P_SET)
960  }
961 
962  return ret_val;
963 }
964 
965 
966 
968 {
969  FILE *fp;
970  int is_ws = (strstr(param.spice_name, "wrspice") != NULL);
971 
972  fp=fopen(JSPICE_CONFIG,"w");
973  if(fp == NULL)
974  {
975  printf("Cannot create %s configuration file %s.\n\n",
976  is_ws ? "wrspice" : "jspice", JSPICE_CONFIG);
977  return 0;
978  }
979 
980  if (is_ws) {
981  fprintf(fp, "set subc_catchar=\":\"\n");
982  fprintf(fp, "set subc_catmode=\"spice3\"\n\n");
983  }
984 
985  fprintf(fp, "set circuit = '%s'\n\n", param.circuit_name);
986 
987  fprintf(fp, "quiet = %d\n\n", ((param.input_options & Q_SET)?1:0));
988 
989  fprintf(fp, "set circext = '%s'\n", param.circuit_ext);
990  fprintf(fp, "set paramext = '%s'\n", param.param_ext);
991  fprintf(fp, "set printext = '%s'\n", param.print_ext);
992  fprintf(fp, "set passfailext = '%s'\n\n", param.passfail_ext);
993  fprintf(fp, "set checkext = '%s'\n", param.check_ext);
994 
995 #if 0
996  fprintf(fp, "set stepext = '%s'\n", param.step_ext);
997 #endif
998 
999  fprintf(fp, "set phasext = '%s'\n", param.phase_ext);
1000  fprintf(fp, "set avrext = '%s'\n", param.avr_ext);
1001  fprintf(fp, "set holdext = '%s'\n", param.hold_ext);
1002  fprintf(fp, "set setupext = '%s'\n", param.setup_ext);
1003  fprintf(fp, "set sepext = '%s'\n", param.separation_ext);
1004  fprintf(fp, "set goodext = '%s'\n", param.good_ext);
1005  fprintf(fp, "set badext = '%s'\n", param.bad_ext);
1006  fprintf(fp, "set tparext = '%s'\n\n", TPARAM_EXT);
1007  fprintf(fp, "set nomext = '%s'\n\n", param.nom_ext);
1008 
1009  fprintf(fp, "set reportext = '%s'\n\n", param.report_ext);
1010 
1011  fprintf(fp, "set input_dir = '%s'\n", param.input_dir);
1012  fprintf(fp, "set tmp_dir = '%s'\n", param.tmp_dir);
1013  fprintf(fp, "set output_dir = '%s'\n\n", param.output_dir);
1014 
1015  fprintf(fp, "failthres = %.2f\n", param.min_fail_thresh);
1016  fprintf(fp, "accuracy = %.5f\n", param.accuracy/100.0);
1017  fprintf(fp, "time_accuracy = %.5f\n", param.time_accuracy);
1018  fprintf(fp, "delay_variation = %.2f\n", param.max_delay_var);
1019  fprintf(fp, "check_inputs = %d\n", param.inputs_checked);
1020 
1021  fclose(fp);
1022 
1023  return 1;
1024 }
1025 
1026 
1027 #if 0
1028 int prepare_timegen_files(char *circuit_name)
1029 {
1030  char command_line[LINE_LENGTH], filename[LINE_LENGTH];
1031  FILE *fp;
1032 
1033  if(param.input_options & J_SET)
1034  {
1035  fp=fopen(TIMEGEN_CONST_FILE, "r");
1036  if(fp!=NULL)
1037  {
1038  fclose(fp);
1039  strcpy(command_line, "mv -f ");
1040  strcat(command_line, TIMEGEN_CONST_FILE);
1041  strcat(command_line, " ");
1042  strcat(command_line, ".");
1043  strcat(command_line, TIMEGEN_CONST_FILE);
1044  system(command_line);
1045  }
1046 
1047  fp=fopen(TIMEGEN_FILE, "r");
1048  if(fp!=NULL)
1049  {
1050  fclose(fp);
1051  strcpy(command_line, "mv -f ");
1052  strcat(command_line, TIMEGEN_FILE);
1053  strcat(command_line, " ");
1054  strcat(command_line, ".");
1055  strcat(command_line, TIMEGEN_FILE);
1056  system(command_line);
1057  }
1058 
1059  strcpy(filename, param.input_dir);
1060  strcat(filename, circuit_name);
1061  strcat(filename, ".");
1062  strcat(filename, TIMEGEN_FILE);
1063  fp=fopen(filename,"r");
1064  if(fp==NULL)
1065  {
1066  printf("Cannot find file %s.\n", filename);
1067  return 0;
1068  }
1069 
1070  strcpy(command_line, "cp ");
1071  strcat(command_line, filename);
1072  strcat(command_line, " ");
1073  strcat(command_line, TIMEGEN_FILE);
1074  system(command_line);
1075 
1076 
1077  if(!(param.input_options & JX_SET))
1078  {
1079  strcpy(filename, param.input_dir);
1080  strcat(filename, circuit_name);
1081  strcat(filename, ".");
1082  strcat(filename, TIMEGEN_CONST_FILE);
1083  fp=fopen(filename,"r");
1084  if(fp==NULL)
1085  {
1086  printf("Cannot find file %s.\n", filename);
1087  return 0;
1088  }
1089 
1090  strcpy(command_line, "cp ");
1091  strcat(command_line, filename);
1092  strcat(command_line, " ");
1093  strcat(command_line, TIMEGEN_CONST_FILE);
1094  system(command_line);
1095  }
1096  }
1097  return 1;
1098 }
1099 
1100 
1102 {
1103  char infilename[NAME_LENGTH], outfilename[NAME_LENGTH];
1104 
1105  strcpy(infilename, param.input_dir);
1106  strcat(infilename, param.circuit_name);
1107  strcat(infilename, TIMEGEN_FILE);
1108 
1109  strcat(outfilename, TIMEGEN_FILE);
1110 
1111  file_copy(infilename, outfilename);
1112 
1113  strcpy(infilename, param.input_dir);
1114  strcat(infilename, param.circuit_name);
1115  strcat(infilename, TIMEGEN_CONST_FILE);
1116 
1117  strcat(outfilename, TIMEGEN_CONST_FILE);
1118 
1119  file_copy(infilename, outfilename);
1120 
1121 /*
1122  strcpy(infilename, param.input_dir);
1123  strcat(infilename, circuit_name);
1124  strcat(infilename, ".");
1125  strcat(infilename, PARAMETERS_FILE);
1126 
1127  strcpy(outfilename, ".");
1128  strcat(outfilename, PARAMETERS_FILE);
1129 
1130  file_copy(infilename, outfilename);
1131 */
1132 }
1133 #endif
1134 
1135 
1136 int file_copy(char *infilename, char *outfilename)
1137 {
1138  FILE *infp, *outfp;
1139  char line[LINE_LENGTH];
1140 
1141  infp=fopen(infilename,"r");
1142  if(infp==NULL)
1143  return 0;
1144  outfp=fopen(outfilename,"w");
1145  if(outfp==NULL)
1146  return 0;
1147 
1148  while(fgets(line, LINE_LENGTH, infp)!=NULL)
1149  fputs(line, outfp);
1150  fclose(infp);
1151  fclose(outfp);
1152  return 1;
1153 }
1154 
1155 
1156 
1157 
1158 
1159 
#define JSPICE_CONFIG
Definition: filenames.h:5
#define H_SET
Definition: constype.h:12
#define BAD_CONFIG
Definition: config.h:108
char logic_ext[NAME_LENGTH]
Definition: constype.h:168
#define XY_CONFIG_ITEM_NUM
Definition: config.h:151
double avr_one_volt
Definition: constype.h:204
#define REPORT_CONFIG
Definition: config.h:111
#define SETUP_EXT
Definition: param.h:35
#define INIT_EXT
Definition: param.h:28
#define JR_SET
Definition: constype.h:17
char good_ext[NAME_LENGTH]
Definition: constype.h:166
#define JS_SET
Definition: constype.h:15
#define HOSE_CONFIG
Definition: config.h:110
#define ACCURACY_CONFIG
Definition: config.h:113
void prepare_included_files()
char hose_ext[NAME_LENGTH]
Definition: constype.h:170
#define BOUNDARY_EXT
Definition: param.h:42
#define PASS_FAIL_THRESHOLD
Definition: param.h:11
char circuit_name[NAME_LENGTH]
Definition: constype.h:184
#define CHECKING_RATIO
Definition: param.h:12
#define IS_SET
Definition: constype.h:31
#define XMIN_XY_CONFIG
Definition: config.h:154
#define TMP_DIR
Definition: param.h:19
#define CHECK_EXT
Definition: param.h:32
#define BATCH_SET
Definition: constype.h:35
int read_options(int argc, char *argv[])
Definition: init.c:929
#define VOLTAGE_THRESHOLD
Definition: param.h:7
#define HOLD_CONFIG
Definition: config.h:106
double max_zero_volt
Definition: constype.h:211
#define ID_SET
Definition: constype.h:29
#define PLS_EXTR_MTHD_CONFIG
Definition: config.h:86
char setup_ext[NAME_LENGTH]
Definition: constype.h:164
#define OUT_CLK_CYCLE_XY_CONFIG
Definition: config.h:159
int file_copy(char *infilename, char *outfilename)
Definition: init.c:1136
char output_dir[NAME_LENGTH]
Definition: constype.h:149
int input_options
Definition: constype.h:199
#define LATCH_CHECK_INT
Definition: param.h:64
#define PH_THR_NOM_CONFIG
Definition: config.h:87
#define ONE_VOLTAGE_CONFIG
Definition: config.h:138
#define LATCH_CHECKRATIO
Definition: param.h:67
float checkpoint_ratio
Definition: constype.h:115
#define R_SET
Definition: constype.h:16
int interpolate
Definition: constype.h:99
#define SETUP_CONFIG
Definition: config.h:105
int read_config(char *filename)
Definition: init.c:189
#define MAX_DELAY_VARIATION
Definition: param.h:15
#define PHASE_THRESHOLD
Definition: param.h:1
char param_ext[NAME_LENGTH]
Definition: constype.h:156
#define PH_THR_MAX_CONFIG
Definition: config.h:89
#define PRINT_EXT
Definition: param.h:27
void command_line_error(char *filename)
Definition: init.c:27
#define TIMEINIT_EXT
Definition: param.h:56
char bad_ext[NAME_LENGTH]
Definition: constype.h:167
#define AVR_EXT
Definition: param.h:34
static int check_config_item(char *item_type, char **item_list, int item_num)
Definition: init.c:132
char signal_ext[NAME_LENGTH]
Definition: constype.h:181
#define PHASE_THRESHOLD_MIN
Definition: param.h:9
char timeinit_ext[NAME_LENGTH]
Definition: constype.h:180
#define INPUT_NR_XY_CONFIG
Definition: config.h:157
#define XY_CONFIG_FILE_EXT
Definition: filenames.h:15
TIME accuracy
Definition: constype.h:122
#define CHECK_INT_CONFIG
Definition: config.h:133
#define INTEREDGE_INT_CONFIG
Definition: config.h:136
#define COLLECT_BY_PHASE
Definition: constype.h:44
int miniter
Definition: constype.h:71
static void out_of_range(char *line, char *filename)
Definition: init.c:170
PHASE min_pulse_phase_diff
Definition: constype.h:111
PHASE min_phase_thresh
Definition: constype.h:86
#define P_SET
Definition: constype.h:23
TIME min_checks_interval
Definition: constype.h:221
char report_ext[NAME_LENGTH]
Definition: constype.h:171
#define Q_SET
Definition: constype.h:20
#define CIRC_CONFIG
Definition: config.h:99
PHASE min_fail_thresh
Definition: constype.h:119
#define MIN_PHASE_THRESHOLD
Definition: param.h:3
#define PHASE_CONFIG
Definition: config.h:104
#define VOLT_THR_CONFIG
Definition: config.h:91
#define COLLECT_BY_VOLTAGE
Definition: constype.h:45
#define JH_SET
Definition: constype.h:13
#define IN_CHECK_CONFIG
Definition: config.h:114
#define M_SET
Definition: constype.h:10
#define CIRCUIT_EXT
Definition: param.h:24
char print_ext[NAME_LENGTH]
Definition: constype.h:157
static int blank_line(char *line)
Definition: init.c:150
#define GOOD_EXT
Definition: param.h:37
PHASE nom_phase_thresh
Definition: constype.h:82
#define CHECK_RATIO_CONFIG
Definition: config.h:93
int out_clk_cycle
Definition: constype.h:274
#define LATCH_ONE_VOLT
Definition: param.h:60
#define PASSFAIL_EXT
Definition: param.h:29
#define NAME_LENGTH
Definition: constype.h:3
#define INTERPOL_CONFIG
Definition: config.h:90
TIME min_interval_to_falledge
Definition: constype.h:229
void trademark()
Definition: init.c:12
#define SPICE_CONFIG
Definition: config.h:98
int read_xy_config(XY_PARAMETERS *xy_param, char *circuit_name)
double min_one_volt
Definition: constype.h:214
#define MINIMUM_STEP
Definition: param.h:16
char init_ext[NAME_LENGTH]
Definition: constype.h:175
#define MAX_ZERO_CONFIG
Definition: config.h:131
char spice_name[NAME_LENGTH]
Definition: constype.h:152
char hold_ext[NAME_LENGTH]
Definition: constype.h:163
char opt_num[NAME_LENGTH]
Definition: constype.h:196
#define DEFAULT_TIME_ACCURACY
Definition: param.h:14
#define I_SET
Definition: constype.h:36
#define MAX_PHASE_THRESHOLD
Definition: param.h:4
#define LATCH_EDGE_INT
Definition: param.h:65
#define REGION_CONFIG
Definition: config.h:123
#define LATCH_MIN_EDGE_INT
Definition: param.h:66
#define IN_CONFIG
Definition: config.h:95
int min_time_step
Definition: constype.h:136
#define FAIL_THR_CONFIG
Definition: config.h:94
TIME min_interval_to_riseedge
Definition: constype.h:225
#define INTERPOLATE_EXT
Definition: param.h:55
#define OUT_CONFIG
Definition: config.h:97
char phase_ext[NAME_LENGTH]
Definition: constype.h:159
#define MARGINS_CONFIG
Definition: config.h:120
TIME time_accuracy
Definition: constype.h:125
char avr_ext[NAME_LENGTH]
Definition: constype.h:162
#define GOOD_CONFIG
Definition: config.h:107
char input_dir[NAME_LENGTH]
Definition: constype.h:143
char comp_ext[NAME_LENGTH]
Definition: constype.h:173
#define NOMINAL_EXT
Definition: param.h:40
#define TIME_ACCURACY_CONFIG
Definition: config.h:128
#define MINITER_CONFIG
Definition: config.h:127
PARAMETERS param
Definition: init.c:10
#define REPORT_EXT
Definition: param.h:51
#define PRINT_CONFIG
Definition: config.h:101
char marg_ext[NAME_LENGTH]
Definition: constype.h:176
static char line[LONG_LINE_LENGTH]
Definition: collect.c:7
int generate_jspice_config()
Definition: init.c:967
#define BAD_EXT
Definition: param.h:39
#define MAXPLANE_CONFIG
Definition: config.h:125
static char * xy_config_item_list[]
Definition: config.h:141
#define LINE_LENGTH
Definition: constype.h:4
#define PHASE_EXT
Definition: param.h:33
#define TPARAM_EXT
Definition: param.h:26
#define IH_SET
Definition: constype.h:30
#define STEP_EXT
Definition: param.h:31
int pulse_extraction_method
Definition: constype.h:78
VOLTAGE volt_thresh
Definition: constype.h:103
#define V_SET
Definition: constype.h:21
char step_ext[NAME_LENGTH]
Definition: constype.h:160
#define MID_CONFIG
Definition: config.h:112
char check_ext[NAME_LENGTH]
Definition: constype.h:161
char period_ext[NAME_LENGTH]
Definition: constype.h:172
double nom_edge_thresh
Definition: constype.h:208
TIME max_delay_var
Definition: constype.h:129
char separation_ext[NAME_LENGTH]
Definition: constype.h:165
#define INPUT_DIR
Definition: param.h:18
#define PARAM_EXT
Definition: param.h:25
char circuit_ext[NAME_LENGTH]
Definition: constype.h:155
#define TMP_CONFIG
Definition: config.h:96
#define CONFIG_ITEM_NUM
Definition: config.h:78
#define SIGNAL_CONFIG
Definition: config.h:129
#define HOLDSETUP_EXT
Definition: param.h:50
#define MAX_DEL_VAR_CONFIG
Definition: config.h:115
char tmp_dir[NAME_LENGTH]
Definition: constype.h:146
#define PH_THR_MIN_CONFIG
Definition: config.h:88
int maxiter
Definition: constype.h:68
#define STEP_CONFIG
Definition: config.h:102
#define MAXITER_CONFIG
Definition: config.h:126
#define SEPARATION_EXT
Definition: param.h:38
double clk_chktime_ratio
Definition: constype.h:234
#define RISEEDGE_CHECK_INT_CONFIG
Definition: config.h:134
#define SIGNAL_EXT
Definition: param.h:46
#define LATCH_MIN_ONE
Definition: param.h:62
#define MIN_PH_DIFF_CONFIG
Definition: config.h:92
char bound_ext[NAME_LENGTH]
Definition: constype.h:178
#define W_SET
Definition: constype.h:33
static char * config_item_list[]
Definition: config.h:21
PHASE max_phase_thresh
Definition: constype.h:90
#define INIT_CONFIG
Definition: config.h:118
#define XSTEP_XY_CONFIG
Definition: config.h:156
TIME min_edge_sep
Definition: constype.h:218
#define XMAX_XY_CONFIG
Definition: config.h:155
#define IN_CLK_CYCLE_XY_CONFIG
Definition: config.h:158
#define JSPICE_CALL
Definition: param.h:22
char region_ext[NAME_LENGTH]
Definition: constype.h:179
#define OUTPUT_DIR
Definition: param.h:20
#define SEPARATION_CONFIG
Definition: config.h:124
int inputs_checked
Definition: constype.h:139
int in_clk_cycle
Definition: constype.h:270
#define PARAM_CONFIG
Definition: config.h:100
#define BOUNDARY_CONFIG
Definition: config.h:121
#define DEFAULT_ACCURACY
Definition: param.h:13
#define J_SET
Definition: constype.h:18
#define MIN_ONE_CONFIG
Definition: config.h:132
#define OPT_EXT
Definition: param.h:43
#define REGION_EXT
Definition: param.h:44
#define OPTIMIZE_CONFIG
Definition: config.h:122
char opt_ext[NAME_LENGTH]
Definition: constype.h:177
int maxplane
Definition: constype.h:65
#define INTERPOLATION
Definition: param.h:5
#define LATCH_MAX_ZERO
Definition: param.h:63
static void unrecognized_value(char *line, char *filename)
Definition: init.c:163
#define CLK_CHECKTIME_CONFIG
Definition: config.h:137
#define MARGIN_EXT
Definition: param.h:41
#define JM_SET
Definition: constype.h:11
#define FALLEDGE_CHECK_INT_CONFIG
Definition: config.h:135
#define THRESHOLD_CONFIG
Definition: config.h:130
static char filename[LINE_LENGTH]
Definition: optimize.c:35
#define NOMINAL_CONFIG
Definition: config.h:117
#define VALUE_COMP_EXT
Definition: param.h:54
char passfail_ext[NAME_LENGTH]
Definition: constype.h:158
static int check_option(char *option)
Definition: init.c:819
#define LOGIC_EXT
Definition: param.h:48
#define LATCH_THRESHOLD
Definition: param.h:61
void init_parameters()
Definition: init.c:39
#define PASSFAIL_CONFIG
Definition: config.h:119
#define MIN_TIME_STEP_CONFIG
Definition: config.h:116
char nom_ext[NAME_LENGTH]
Definition: constype.h:174
#define LOGIC_CONFIG
Definition: config.h:109
#define S_SET
Definition: constype.h:14
#define CHECK_CONFIG
Definition: config.h:103
#define HOLD_EXT
Definition: param.h:36