home *** CD-ROM | disk | FTP | other *** search
/ gdead.berkeley.edu / gdead.berkeley.edu.tar / gdead.berkeley.edu / pub / cad-tools / ciftomann.tar / driver_dir / driver.c < prev    next >
C/C++ Source or Header  |  1988-01-28  |  8KB  |  398 lines
  1. #include "fd.h"
  2. #include <stdio.h>
  3. #include <signal.h>
  4.  
  5. #define FILE_SIZE 15
  6. #define PATH_SIZE 101
  7. #define NUM_SIZE 20
  8. #define FLAG_SIZE 3
  9. #define BB_SIZE 4*NUM_SIZE
  10. #define PG_SIZE 6*NUM_SIZE
  11.  
  12. #define NIL(type) ( (type *) 0)
  13.  
  14. typedef struct cmd_tag {
  15.     char inlayer[5];
  16.     int invert_flag;
  17.     int mod_factor;
  18.     char *outlayer[5];
  19.     struct cmd_tag *next;
  20. } cmd_type;
  21.  
  22.     /* the path names of all the sub processes */
  23. extern char flatten[];
  24. extern char edger[];
  25. extern char sort[];
  26. extern char merge[];
  27. extern char resort[];
  28. extern char boxer[];
  29. extern char smash[];
  30.  
  31. cmd_type *get_cmd();
  32.  
  33. char bb_tmp_name[FILE_SIZE],
  34.      out_tmp_name[FILE_SIZE],
  35.      in_tmp_name[FILE_SIZE],
  36.      log_tmp_name[FILE_SIZE];
  37.  
  38. char cif_file_name[PATH_SIZE];
  39.  
  40.     /* the elements of the per-layer pipelines */
  41. char *layer_cmdv[] = { merge, resort, boxer, smash, NIL(char) };
  42.     
  43.     /* the elements of the initial flatten and edging pipeline */
  44.  
  45. char *flat_cmdv[] = { flatten, edger, NIL(char) };
  46.  
  47. char tmp_dir[101];
  48.  
  49. char basename[FILE_SIZE];
  50.      
  51. char mod_string[NUM_SIZE], invert_string[FLAG_SIZE],
  52.      bb_string[BB_SIZE], pg_string[PG_SIZE], round_string[2*NUM_SIZE];
  53.  
  54.     /* the individual arguments for the per-layer processes */
  55.  
  56. char *merge_argv[] = { "merge", invert_string, bb_string, mod_string,
  57.              NIL(char) },
  58.      *resort_argv[] = { "resort", mod_string, NIL(char) },
  59.      *boxer_argv[] = { "boxer", NIL(char) },
  60.      *smash_argv[] = { "smash", pg_string, NIL(char) };
  61.  
  62. char **layer_argvv[] = {
  63.     merge_argv,
  64.     resort_argv,
  65.     boxer_argv,
  66.     smash_argv,
  67.     NIL(char *)
  68. };
  69.  
  70.     /* the individual arguements for the flatten/edger pipeline */
  71.  
  72. char *flatten_argv[] = { "flatten", cif_file_name, NIL(char) },
  73.      *edger_argv[] = { "edger", basename, round_string, bb_tmp_name, tmp_dir, NIL(char) };
  74.  
  75. char **flat_argvv[] = {
  76.     flatten_argv,
  77.     edger_argv,
  78.     NIL(char *)
  79. };
  80.  
  81. char *user;
  82. FILE *fopen();
  83.  
  84.     /*
  85.      *    Driver constructs the pipeline elements and their arguments
  86.      *    from the command file and starts the pipelines going.
  87.      */
  88.  
  89. main(argc,argv)
  90. int argc;
  91. char **argv;
  92. {
  93.     FILE *log_file,*bb_file,*out_file,*in_file;
  94.  
  95.     int lower_left_x, lower_left_y, upper_right_x, upper_right_y;
  96.     int stage_min, stage_max, aperture_min, aperture_max, grid_size;
  97.     int num_masks, mask;
  98.     int already_flat = 0;
  99.     int silent = 0;
  100.     int status;
  101.     int mod_factor, invert_flag;
  102.     char inlayer[5], outlayer[5];
  103.     float scale_factor;
  104.  
  105.     cmd_type *cmd_list, *last;
  106.         
  107.     set_names();
  108.  
  109.     catch_signals();
  110.  
  111.     if ( argv[1][1] == 's' ) {
  112.     silent = 1;
  113.     }
  114.  
  115.     if (argv[1][2] == 'a') {
  116.     already_flat = 1;
  117.     }
  118.  
  119.     user = argv[2];
  120.     strcpy(cif_file_name,argv[3]);
  121.  
  122. /*
  123.  *    read the various parameters for the job
  124.  */
  125.  
  126.  
  127.     if ( (scanf("%s %s %d %d %d %d %d %f",tmp_dir,basename,&stage_min,
  128.         &stage_max,&aperture_min, &aperture_max, &grid_size,
  129.         &scale_factor) != 8) 
  130.     || (scanf("%d ",&num_masks) != 1) ) {
  131.  
  132.     fprintf(stderr,"Panic : internal commands to the driver have been hashed\n");
  133.     exit(1);
  134.     }
  135.  
  136.     /* build the pattern generator descriptor */
  137.  
  138.     sprintf(pg_string,"%d %d %d %d %d %f", stage_min, stage_max,
  139.         aperture_min, aperture_max, grid_size, scale_factor);
  140.  
  141.     sprintf(round_string,"%g %d", scale_factor, grid_size);
  142.  
  143.  
  144.     /* build a linked list of the commands */
  145.  
  146.     last = cmd_list = get_cmd();
  147.     for ( mask = 2; mask <= num_masks; mask++) {
  148.     last->next = get_cmd();
  149.     last = last->next;
  150.     }
  151.  
  152. /*
  153.  *    Change to the temporary directory and start up the various
  154.  *    files needed
  155.  */
  156.  
  157.     chdir(tmp_dir);
  158.  
  159.     sprintf(log_tmp_name,"%s_log",basename);
  160.     sprintf(out_tmp_name,"%s_out",basename);
  161.     sprintf(bb_tmp_name,"%s_bb",basename);
  162.  
  163.     if ( (out_file = fopen(out_tmp_name,"w")) == NULL) {
  164.     fprintf(stderr,"Could not open the output file %s .\n",
  165.         out_tmp_name);
  166.     fprintf(stderr,"Job was not started\n");
  167.     terminate();
  168.     }
  169.  
  170.     dup2(fileno(out_file),STDOUT);    /* connect out_file to stdout */
  171.     fclose(out_file);
  172.  
  173. /* 
  174.  *        Flatten the cif and then edge and sort the flattened cif
  175.  *        producing a seperate "basename.layername" file for each
  176.  *        layer. ( edger popens the sorter itself, since it does
  177.  *        the layer file manipulation )
  178.  */
  179.  
  180.     if ( !silent ) {
  181.     fprintf(stderr,"\nFlattening and translating the cif.\n");
  182.     }
  183.  
  184. #ifdef DEBUG
  185.     print_pipe(flat_cmdv,flat_argvv);
  186. #endif
  187.  
  188.     if (!already_flat) {
  189.     status = pipeline(stdin,stderr,flat_cmdv,flat_argvv,stdout);
  190.     }
  191.  
  192.     if ( status != 0 ) {
  193.     fprintf(stderr,"Job terminated\n");
  194.     terminate();
  195.     }
  196.  
  197. /*
  198.  *    Read the bounding box information produced by flatten
  199.  *    in "basename_bb" file
  200.  */
  201.  
  202.     if ( (bb_file = fopen(bb_tmp_name,"r")) == NULL) {
  203.     fprintf(stderr,"Panic : could not open the temp file %s .\n",
  204.         bb_tmp_name);
  205.     fprintf(stderr,"Job terminated\n");
  206.     terminate();
  207.     }
  208.  
  209.     if ( fscanf(bb_file,"%d %d %d %d", &lower_left_x, &lower_left_y,
  210.         &upper_right_x, &upper_right_y) != 4 ) {
  211.         
  212.     fprintf(stderr,"Panic : temp file %s has been trashed\n",
  213.         bb_tmp_name);
  214.     fprintf(stderr,"Job terminated\n");
  215.     terminate();
  216.     }
  217.  
  218.     fclose(bb_file);
  219.  
  220.     sprintf(bb_string,"%d %d %d %d",lower_left_x,lower_left_y,
  221.         upper_right_x, upper_right_y);
  222.  
  223. /*
  224.  *    The main loop :  Process each layer according to the 
  225.  *    information in the command file and append the result
  226.  *    to the output file
  227.  */
  228.  
  229.     for ( mask = 1; mask <= num_masks; mask++) {
  230.  
  231.     sprintf(in_tmp_name,"%s.%s",basename,cmd_list->inlayer);
  232.  
  233.     if ( (in_file = fopen(in_tmp_name,"r")) == NULL) {
  234.         fprintf(stderr,"Panic : either temp layer file %s has been trashed\n",
  235.             in_tmp_name);
  236.         fprintf(stderr,"or layer %s was never used in your chip\n",
  237.             cmd_list->inlayer);
  238.         fprintf(stderr,"Job terminated\n");
  239.         terminate();
  240.     }
  241.  
  242.     printf("L %s;\n",cmd_list->outlayer);
  243.     fflush(stdout);
  244.  
  245.     if ( !silent ) {
  246.         fprintf(stderr,"Processing layer %s.\n",cmd_list->outlayer);
  247.     }
  248.  
  249.     sprintf(mod_string,"%d",cmd_list->mod_factor);
  250.     sprintf(invert_string,"-%c",(cmd_list->invert_flag ? 'i' : 'n'));
  251.  
  252. #ifdef DEBUG
  253.     print_pipe(layer_cmdv,layer_argvv);
  254. #endif
  255.         /* start the pipeline */
  256.  
  257.     status = pipeline(in_file,stderr,layer_cmdv,layer_argvv,stdout);
  258.  
  259.     if ( status != 0) {
  260.         fprintf(stderr,"Job terminated\n");
  261.         terminate();
  262.     }
  263.  
  264.     fclose(in_file);
  265.  
  266.     cmd_list = cmd_list->next;
  267.     }
  268.  
  269.     printf("E\n");
  270.  
  271.     if ( !silent ) {
  272.     fprintf(stderr,"\nTranslation was successful.\n");
  273.     }
  274.  
  275.     clean_up();
  276.     exit(0);
  277. }
  278.         
  279. clean_up()
  280. {
  281.     char cmd_string[101];
  282.     int cmd_stat;
  283.  
  284.     fclose(stdout);
  285.  
  286.     unlink(bb_tmp_name);
  287.  
  288.     delete_layer_temps(basename);
  289. }
  290.  
  291. terminate()
  292. {
  293.     kill_pipe();
  294.     clean_up();
  295.     exit(1);
  296. }
  297.  
  298. delete_layer_temps(basename)
  299. char *basename;
  300. {
  301.     char string[101];
  302.  
  303.     sprintf(string,"rm %s.*",basename);
  304.  
  305.     if ( vfork() == 0) {
  306.  
  307.     execl("/bin/csh","csh","-f","-c",string,0);
  308.     }
  309. }
  310.  
  311. #include <sys/types.h>
  312. #include <sys/stat.h>
  313.  
  314. exists(file_name)
  315. char *file_name;
  316. {
  317.     
  318.     struct stat buf;
  319.  
  320.     if ( stat(file_name,&buf) != 0) {
  321.     return(0);
  322.     }
  323.  
  324.     return(1);
  325. }
  326.  
  327. non_empty(file_name)
  328. char *file_name;
  329. {
  330.     
  331.     struct stat buf;
  332.  
  333.     if ( stat(file_name,&buf) != 0) {
  334.     return(0);
  335.     }
  336.  
  337.     if (buf.st_size <= 0) {
  338.     return(0);
  339.     }
  340.  
  341.     return(1);
  342. }
  343.  
  344. #ifdef DEBUG
  345. print_pipe(cmdv,argvv)
  346. char **cmdv;
  347. char ***argvv;
  348. {
  349.     char *cmd,**argv,*arg;
  350.  
  351.     while ( (cmd = *(cmdv++)) != NIL(char) ) {
  352.     argv = *(argvv++);
  353.     fprintf(stderr,"%s ",cmd);
  354.     while ( (arg = *(argv++)) != NIL(char) ) {
  355.         fprintf(stderr,"%s ",arg);
  356.     }
  357.     putc('\n',stderr);
  358.     }
  359.     
  360. }
  361. #endif
  362.  
  363.     /*
  364.      *    read the commands being sent by ciftomann
  365.      */
  366.  
  367. cmd_type *get_cmd()
  368. {
  369.     cmd_type *new;
  370.  
  371.     new = (cmd_type *) malloc( sizeof(cmd_type));
  372.  
  373.     if (scanf("%s %d %d %s", new->inlayer, &new->mod_factor,
  374.         &new->invert_flag, new->outlayer) != 4) {
  375.     fprintf(stderr,"Panic : internal commands have been trashed\n");
  376.     fprintf(stderr,"Job terminated\n");
  377.     terminate();
  378.     }
  379.  
  380.     return(new);
  381. }
  382.  
  383. catch_signals()
  384. {
  385.  
  386.     if (signal(SIGHUP, SIG_IGN) != SIG_IGN) {
  387.     signal(SIGHUP, terminate);
  388.     }
  389.  
  390.     if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
  391.     signal(SIGINT, terminate);
  392.     }
  393.  
  394.     signal(SIGPIPE, terminate);
  395.  
  396.     signal(SIGTERM, terminate);
  397. }
  398.