home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 3 / TheARMClub_PDCD3.iso / hensa / misc / b186_1 / Source / c / template < prev    next >
Text File  |  1987-09-27  |  13KB  |  551 lines
  1. /*
  2.  
  3.        This file is part of the PDP software package.
  4.          
  5.        Copyright 1987 by James L. McClelland and David E. Rumelhart.
  6.        
  7.        Please refer to licensing information in the file license.txt,
  8.        which is in the same directory with this source file and is
  9.        included here by reference.
  10. */
  11.  
  12.  
  13. /* template.c
  14.  
  15.     File for reading and scanning screen templates.
  16.  
  17.     First version implemented by Elliot Jaffe.
  18.     
  19.     Date of last revision:  8-12-87/JLM.
  20. */
  21.  
  22. #include "general.h"
  23. #include "command.h"
  24. #include "variable.h"
  25. #include "display.h"
  26. #include "template.h"
  27.  
  28. struct Template *tlist = 0;    /* template list: linked list */
  29. struct Template **torder;    /* list of pointers to templates */
  30. int ntemplates = 0;        /* number of templates */
  31.  
  32. boolean    layout_defined = 0;
  33.  
  34. char    **background;
  35. int    num_slots = 0;
  36.  
  37. struct slot_locations {
  38.     int    xloc;
  39.     int    yloc;
  40. };
  41.  
  42. struct slot_locations *slot_loc;
  43. int    maxslots = MAXSLOTS;
  44.  
  45. int template_level;
  46. int template_x;
  47. int template_y;
  48.  
  49. /* install a template with the given name, at the given position (x,y)
  50.    Defaulting the display to be on/off, with the variable var. */
  51.    
  52. struct Template *
  53. install_template (s, type, display_level, varname, 
  54.             x, y, orient,min_x,min_y,max_x, max_y, digits, precision,spacing)
  55. char   *s;            /* this is the users name for the displays */
  56. int     type;            /* the type of display */
  57. int     display_level;
  58. char    *varname;
  59. int     x, y;            /* starting (x,y) position on the screen */
  60. boolean orient;            /* on for horizonal off for vertical */
  61. int     min_x, min_y, max_x, max_y, digits;
  62. float   precision;
  63. int     spacing;
  64. {
  65.     struct Template *sp;
  66.     char   *emalloc (), *strcpy ();
  67.     struct Variable *var, *lookup_var ();
  68.     
  69.     sp = (struct Template  *) emalloc (sizeof (struct Template));
  70.     sp->name = emalloc((unsigned)(strlen(s) + 1));
  71.     (void) strcpy(sp->name, s);
  72.  
  73.     if (type != LABEL) {
  74.       if (varname != (char *) NULL) {
  75.     var = lookup_var(varname);
  76.       }
  77.       if (var == NULL) {
  78.     sp->defined = 0;
  79.     sp->var = (struct Variable *) 
  80.             emalloc ((unsigned)(strlen (varname) + 1));
  81.     (void) strcpy((char *) sp->var, varname);
  82.       }
  83.       else {
  84.     sp->defined = 1;
  85.     sp->var = var;
  86.       }
  87.       (void) install_command(sp->name, change_display, DISPLAYOPTIONS,
  88.                                     (int *) sp);
  89.       (void) install_command(sp->name, do_update_template, DISPLAYMENU,
  90.                                     (int *) sp);
  91.     }
  92.     else {
  93.         sp->var = NULL;
  94.     sp->defined = -1;
  95.     }
  96.     
  97.     sp->type = type;
  98.     sp->display_level = display_level;
  99.     sp->x = x;
  100.     sp->y = y;
  101.     sp->orientation = orient;
  102.     sp->min_x = min_x;
  103.     sp->min_y = min_y;
  104.     sp->max_x = max_x;
  105.     sp->max_y = max_y;
  106.     sp->digits = digits;
  107.     sp->precision = precision;
  108.     sp->spacing = spacing;
  109.     sp->look = NULL;
  110.     sp->next = tlist;
  111.     tlist = sp;
  112.     return sp;
  113. }
  114.  
  115. read_template() {
  116.     char    name[40];
  117.     char    type[40];
  118.  
  119.     while (fscanf(in_stream, "%s %s", name, type) != EOF) {
  120.     if(strcmp("layout", type) == 0) {
  121.         read_background();
  122.     }
  123.     else
  124.         if (strcmp("vector", type) == 0) {
  125.         read_vector(name);
  126.         }
  127.     else
  128.         if (strcmp("matrix", type) == 0) {
  129.         read_matrix(name);
  130.         }
  131.     else
  132.         if (strcmp("label", type) == 0) {
  133.         read_label(name);
  134.         }
  135.     else
  136.         if (strcmp("label_array", type) == 0) {
  137.         read_label_array(name);
  138.         }
  139.     else
  140.         if (strcmp("variable", type) == 0) {
  141.         read_variable(name);
  142.         }
  143.     else
  144.         if (strcmp("look", type) == 0) {
  145.         read_look(name);
  146.         }
  147.     else
  148.         if (strcmp("label_look", type) == 0) {
  149.         read_label_look(name);
  150.         }
  151.     else
  152.         if (strcmp("floatvar", type) == 0) {
  153.         read_float_variable(name);
  154.         }
  155.     else 
  156.         return(put_error("Undefined template type encountered."));
  157.     }
  158.     make_torder();
  159.     return(CONTINUE);
  160. }
  161.  
  162.  
  163. read_vector(name)
  164. char   *name;
  165. {
  166.     char    Varname[40];
  167.     int     digits;
  168.     float   precision;
  169.     char    Orient[2];
  170.     boolean orientation;
  171.     int     start,stop,level;
  172.  
  173.     get_template_xy();
  174.  
  175.     (void) fscanf(in_stream, "%s%s%d%f%d%d",
  176.           Varname,Orient, &digits, &precision,&start, &stop);
  177.     
  178.     if (strcmp(Orient, "h") == 0) {
  179.     orientation = TRUE;
  180.     }
  181.     else {
  182.     orientation = FALSE;
  183.     }
  184.  
  185.     (void) install_template(name, VECTOR, template_level, Varname, template_x,
  186.         template_y,orientation,start,0,stop, 0, digits, precision,0);
  187.  
  188. }
  189.  
  190. read_matrix(name)
  191. char   *name;
  192. {
  193.     char    Varname[40];
  194.     int     digits;
  195.     float   precision;
  196.     char    Orient[2];
  197.     int        orientation;
  198.     int     first_row,num_rows,first_col,num_cols;
  199.  
  200.     get_template_xy();
  201.     
  202.     (void) fscanf(in_stream, "%s%s%d%f%d%d%d%d",
  203.         Varname, Orient, &digits, &precision,&first_row,&num_rows,
  204.             &first_col, &num_cols);
  205.  
  206.     if (strcmp(Orient, "h") == 0) {
  207.     orientation = TRUE;
  208.     }
  209.     else {
  210.     orientation = FALSE;
  211.     }
  212.  
  213.     (void) install_template(name, MATRIX, template_level, Varname, template_x,
  214.         template_y,orientation,
  215.         first_row,first_col,num_rows,num_cols,digits, precision,0);
  216. }
  217.  
  218. read_label(name)
  219. char   *name;
  220. {
  221.     int     digits;
  222.     char    Orient[2];
  223.     char    str[40];
  224.     boolean orientation;
  225.  
  226.     get_template_xy();
  227.     
  228.     (void) fscanf(in_stream, "%s%d", Orient, &digits);
  229.  
  230.     if (strcmp(Orient, "h") == 0) {
  231.     orientation = TRUE;
  232.     }
  233.     else {
  234.     orientation = FALSE;
  235.     }
  236.  
  237.     (void) install_template(name, LABEL, NULL, template_level, 
  238.         template_x, template_y, orientation,0,0,0, 0, digits, 0.0,0);
  239. }
  240.  
  241. read_label_array(name)
  242. char   *name;
  243. {
  244.     int     digits;
  245.     char    varname[40];
  246.     char    Orient[2];
  247.     boolean orientation;
  248.     int        start,stop;
  249.  
  250.     get_template_xy();
  251.     
  252.     (void) fscanf(in_stream, "%s%s%d%d%d", 
  253.             varname, Orient, &digits,&start, &stop);
  254.  
  255.     if (strcmp(Orient, "h") == 0) {
  256.     orientation = TRUE;
  257.     }
  258.     else {
  259.     orientation = FALSE;
  260.     }
  261.  
  262.     (void) install_template(name, LABEL_ARRAY, template_level, varname, 
  263.      template_x, template_y, orientation,start,0,stop, 0, digits, 0.0,0);
  264.  
  265. }
  266.  
  267. read_variable(name)
  268. char   *name;
  269. {
  270.     char    varname[40];
  271.     char    str[40];
  272.     int     dig;
  273.     float   scale;
  274.  
  275.     get_template_xy();
  276.     
  277.     (void) fscanf(in_stream, "%s%d%f",varname, &dig, &scale);
  278.  
  279.     (void) install_template(name, VARIABLE, template_level, varname, 
  280.         template_x, template_y, TRUE,0,0, 0, 0, dig, scale,0);
  281. }
  282.  
  283. read_float_variable(name)
  284. char   *name;
  285. {
  286.     char    varname[40];
  287.     int     dig;
  288.     float   scale;
  289.  
  290.     get_template_xy();
  291.     
  292.     (void) fscanf(in_stream, "%s%d%f", varname, &dig, &scale);
  293.  
  294.     (void) install_template(name, FLOATVAR, template_level, varname, 
  295.         template_x, template_y, TRUE, 0,0,0, 0, dig, scale,0);
  296. }
  297.  
  298.  
  299. read_look(name)
  300. char   *name;
  301. {
  302.     char    varname[40];
  303.     char    filename[40];
  304.     int     dig;
  305.     float   scale;
  306.     int     spacing;
  307.     struct Template *look_temp;
  308.  
  309.     get_template_xy();
  310.     
  311.     (void) fscanf(in_stream, "%s%d%f%d%s",
  312.         varname, &dig, &scale, &spacing, filename);
  313.  
  314.     look_temp = install_template(name, LOOK, template_level, varname, 
  315.         template_x, template_y,TRUE, 0,0,0, 0, dig, scale, spacing);
  316.  
  317.     get_look(look_temp, filename);
  318. }
  319.  
  320.  
  321. read_label_look(name)
  322. char   *name;
  323. {
  324.     char    varname[40];
  325.     char    filename[40];
  326.     int     dig;
  327.     char    orient[2];
  328.     int     spacing;
  329.     boolean orientation;
  330.  
  331.     struct Template *look_temp;
  332.  
  333.     get_template_xy();
  334.     
  335.     (void) fscanf(in_stream, "%s%s%d%d%s",
  336.         varname, orient, &dig, &spacing, filename);
  337.     
  338.     if (strcmp(orient, "h") == 0) {
  339.     orientation = HORIZONTAL;
  340.     }
  341.     else {
  342.     orientation = VERTICAL;
  343.     }
  344.  
  345.     look_temp = install_template(name, LABEL_LOOK, template_level, varname, 
  346.         template_x, template_y,orientation, 0,0,0, 0, dig, 0.0, spacing);
  347.  
  348.     get_look(look_temp, filename);
  349. }
  350.  
  351.  
  352. dump_template() {
  353.     struct Template *tp;
  354.     char    Type_Name[40];
  355.  
  356.     printf("TEMPLATES\n");
  357.     printf("name    type    Lev  varname  x   y   orient  max_x   max_y  dig  scale\n");
  358.     for (tp = tlist; tp != (struct Template *) NULL; tp = tp->next) {
  359.     switch (tp->type) {
  360.         case COMMAND: 
  361.         (void) strcpy(Type_Name, "command");
  362.         break;
  363.         case VECTOR: 
  364.         (void) strcpy(Type_Name, "vector");
  365.         break;
  366.         case MATRIX: 
  367.         (void) strcpy(Type_Name, "matrix");
  368.         break;
  369.         case VARIABLE: 
  370.         (void) strcpy(Type_Name, "variable");
  371.         break;
  372.         case LABEL: 
  373.         (void) strcpy(Type_Name, "label");
  374.         break;
  375.         case LABEL_ARRAY: 
  376.         (void) strcpy(Type_Name, "label_array");
  377.         break;
  378.         case LOOK: 
  379.         (void) strcpy(Type_Name, "look");
  380.         break;
  381.         case LABEL_LOOK: 
  382.         (void) strcpy(Type_Name, "label_look");
  383.         break;
  384.         case FLOATVAR: 
  385.         (void) strcpy(Type_Name, "floatvar");
  386.         break;
  387.         default: 
  388.         (void) strcpy(Type_Name, "unknown");
  389.         break;
  390.     }
  391.  
  392.     if (tp->defined == 1) {
  393.       printf("%-8.7s%-8.7s%-5d%-9.8s%-4d%-4d%-8d%-8d%-7d%-5d%-7.2f%-5d\n", 
  394.            tp->name, Type_Name, tp->display_level, tp->var->name, 
  395.            tp->x, tp->y, tp->orientation, tp->max_x, tp->max_y, 
  396.            tp->digits, tp->precision,tp->spacing);
  397.     }
  398.     else {
  399.       printf("%-8.7s%-8.7s%-5d%-9.8s%-4d%-4d%-8d%-8d%-7d%-5d%-7.2f%-5d\n", 
  400.          tp->name, Type_Name, tp->display_level, tp->name, 
  401.          tp->x, tp->y, tp->orientation, tp->max_x, tp->max_y, 
  402.          tp->digits, tp->precision,tp->spacing);
  403.     }
  404.     }
  405. }
  406.  
  407. get_look(template, filename)
  408. struct Template *template;
  409. char   *filename;
  410. {
  411.     FILE * fp = NULL;
  412.     char    string[BUFSIZ];
  413.     struct Look *look;
  414.     char     **look_table;
  415.  
  416.     if ((fp = fopen(filename, "r")) == NULL) {
  417.         sprintf(string,"Cannot open look file %s.",filename);
  418.     return(put_error(string));
  419.     }
  420.  
  421.     look = (struct Look *) emalloc (sizeof (struct Look));
  422.     template->look = look;
  423.  
  424.  /* read in the maximum y and x coordinates of the look table */
  425.     (void) fscanf(fp, "%d%d", &look->look_y, &look->look_x);
  426.  
  427.     look->look_template = ((char **) emalloc((unsigned)(sizeof(char *)
  428.         * look->look_x * look->look_y)));
  429.     look_table = look->look_template;
  430.  
  431.     while (fscanf(fp, "%s", string) != EOF) {
  432.     if (*string == '.') {
  433.         *look_table = NOCELL;
  434.         look_table++;
  435.     }
  436.     else {
  437.         *look_table = ((char *) emalloc((unsigned)strlen(string)+1));
  438.         strcpy(*look_table,string);
  439.         look_table++;
  440.     }
  441.     }
  442.     fclose(fp);
  443. }
  444.  
  445. read_background()
  446. {
  447.     int x,y,i,back_lines;
  448.     char string[BUFSIZ];
  449.     fgets(string,BUFSIZ,in_stream);
  450.     sscanf(string,"%d%d",&num_lines,&num_cols);
  451.     if (num_lines > 5) back_lines = num_lines -5;
  452.     else back_lines = 0;
  453.     
  454.     if (!back_lines) {
  455.         fgets(string,BUFSIZ,in_stream);
  456.         if(startsame("end",string)) 
  457.           return(CONTINUE);
  458.         else 
  459.           return(put_error("No lines available for background."));
  460.     }
  461.     slot_loc = ((struct slot_locations *) 
  462.             emalloc((unsigned)maxslots*sizeof(struct slot_locations)));
  463.     background = ((char **) 
  464.                  emalloc((unsigned)((back_lines+1)*sizeof(char *))));
  465.  
  466.     for(y = 0; y <= back_lines; y++) {
  467.        background[y] = 
  468.         ( (char *) emalloc ((unsigned)((num_cols+1)*sizeof(char))));
  469.        for(x = 0; x <= num_cols;x++) {
  470.           background[y][x] = '\0';
  471.        }
  472.     }
  473.  
  474.     layout_defined++;
  475.     num_slots = 0;
  476.     y = 0;
  477.  
  478.     while(fgets(string,BUFSIZ,in_stream) != NULL) {
  479.        if(startsame("end",string))
  480.           break;
  481.        if(y == back_lines) {
  482.         return(put_error(
  483.                "Background specification has too many lines."));
  484.        }
  485.        for(i = 0; i < num_cols; i++) {
  486.           if(string[i] == '\0') break;
  487.           if( (string[i] == ' ') || (string[i] == '\n') ) continue;
  488.           if( string[i] == '    ') {
  489.          return(put_error(
  490.             "no tabs allowed in background specification"));
  491.           }
  492.           if(string[i] == '$') {
  493.             if (num_slots >= maxslots) {
  494.             maxslots += 20;
  495.             slot_loc = ((struct slot_locations *) 
  496.                erealloc((char *)slot_loc, 
  497.                 (unsigned)((maxslots-20)*sizeof(struct slot_locations)),
  498.             (unsigned)maxslots*sizeof(struct slot_locations)));
  499.         }
  500.         slot_loc[num_slots].xloc = i;
  501.         slot_loc[num_slots++].yloc = y+5;
  502.           }
  503.           else
  504.          background[y][i] = string[i];
  505.        }
  506.        y++;
  507.     }
  508.     return(CONTINUE);
  509. }
  510.  
  511. make_torder() {
  512.     struct Template *tp;
  513.     
  514.     ntemplates = 0;
  515.     
  516.     for (tp = tlist; tp != NULL; tp = tp->next) {
  517.     ntemplates++;
  518.     }
  519.     torder = ( (struct Template **) emalloc 
  520.     ((unsigned) ntemplates * sizeof (struct Template *)));
  521.     
  522.     ntemplates = 0;
  523.     for (tp = tlist; tp != NULL; tp = tp->next) {
  524.         torder[ntemplates++] = tp;
  525.     }
  526. }
  527.  
  528. int prev_slot = -1;
  529.  
  530. get_template_xy() {
  531.     int slot;
  532.     char ty_str[40], tx_str[40];
  533.     
  534.     fscanf(in_stream, "%d%s%s", &template_level, ty_str, tx_str);   
  535.     
  536.     if( ty_str[0] == '$') {
  537.        if( tx_str[0] == 'n' ) slot = ++prev_slot;
  538.        else prev_slot = slot = atoi(tx_str);
  539.        if( slot >= num_slots) {
  540.      return(put_error("not enough dollar signs in background"));
  541.        }
  542.        template_y = slot_loc[slot].yloc;
  543.        template_x = slot_loc[slot].xloc;
  544.     }
  545.     else {
  546.       template_y = atoi(ty_str);
  547.       template_x = atoi(tx_str);
  548.     }
  549.     return(CONTINUE);
  550. }
  551.