home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume14 / shellforms / part02 / load.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-05-09  |  8.6 KB  |  350 lines
  1. /* Last update: 01/26/88  10:53 PM  (Edition: 63) */
  2. #include    <stdio.h>
  3. #include    <strings.h>
  4. #include    "form.h"
  5. #include    "field.h"
  6. #include    "basic.h"
  7.  
  8. #define    TOKENSIZE    256
  9.  
  10. char    Varname [MAXVNAME];        /* variable name string pool */
  11. char    *Varwp = Varname;        /* next write position */
  12.  
  13. extern    char        Screen[SCRLINE][SCRCOL+1];
  14. extern    char        Form_name[];
  15. extern    unsigned char    Fhead[];    /* 1st field index on each line */
  16. extern    unsigned char    Flcount[];    /* number of fields on this line */
  17. extern    unsigned char    Lastdata;
  18. extern    struct    field    Field[];    /* field nodes */
  19. extern    int        Fno;        /* next field to use (or count) */
  20.  
  21. /*----------------------------------------------------------------------+
  22. |                                    |
  23. |        load_form : load a form from disk file            |
  24. |                                    |
  25. +----------------------------------------------------------------------*/
  26. load_form (fname)
  27. char    *fname;
  28.     {
  29.     FILE            *fp;
  30.     register unsigned char    i;
  31.  
  32.     ENTER (load_form);
  33.     if (fname == NULL) fp = stdin;
  34.     else if ((fp = fopen (fname, "r")) == 0) {
  35.         fprintf (stderr, "Can not open form file %s\r\n", fname);
  36.         RETURN (0);
  37.         }
  38.     for (i=0; i<SCRLINE; i++) Screen[i][0] = '\0';
  39.     init_field ();
  40.     for (i=0; i<SCRLINE; i++) {
  41.         if (fgets (Screen[i], SCRCOL+1, fp) == 0) break;
  42.         if (Screen[i][0] == CTRL('L')) {
  43.             Screen[i][0] = EOS;
  44.             field_attr (fp);
  45.             break;
  46.             }
  47.         make_field (i+1, Screen[i]);
  48.         }
  49.     init_sno ();        /* fill data for field with selections */
  50.     Lastdata = i;
  51.     if (fname != NULL) {
  52.         strcpy (Form_name, fname);
  53.         }
  54.     RETURN (1);
  55.     }
  56.  
  57. /*----------------------------------------------------------------------+
  58. |                                    |
  59. |    bcopy : copy len byte from src to dest (extra fill with blanks)    |
  60. |                                    |
  61. +----------------------------------------------------------------------*/
  62. bcopy (dest, src, len)
  63. char        *dest;
  64. char        *src;
  65. unsigned    len;
  66.     {
  67.     char        c = ' ';
  68.  
  69.     ENTER (bcopy);
  70.     while (len-- != 0) {
  71.         if (c == EOS) *dest++ = ' ';    /* fill blanks to end */
  72.         else if ((c = *src++) != EOS)
  73.             *dest++ = c;
  74.         else    *dest++ = ' ';
  75.         }
  76.     EXIT;
  77.     }
  78.  
  79. /*-------------------------------------------------------------05/08/86-+
  80. |                                    |
  81. |       add_var : add a variable name to field structure        |
  82. |                                    |
  83. +----------------------------------------------------------------------*/
  84. add_var (fno, name)
  85. int    fno;
  86. char    *name;
  87.     {
  88.     int        len = strlen (name) + 1;
  89.  
  90.     ENTER (add_var);
  91.     if (Varwp + len >= &Varname[MAXVNAME]) {
  92.         fprintf (stderr, "add_var: no more space for variable name\r\n");
  93.         exit (1);
  94.         }
  95.     Field[fno].f_var = Varwp;
  96.     strcpy (Varwp, name);
  97.     Varwp += len;
  98.     EXIT;
  99.     }
  100.  
  101. /*-------------------------------------------------------------05/08/86-+
  102. |                                    |
  103. |      field_attr : read in field attribute of the form        |
  104. |                                    |
  105. +----------------------------------------------------------------------*/
  106. field_attr (fd)
  107. FILE    *fd;
  108.     {
  109.     int        field = -1;
  110.     char        tokbuf [TOKENSIZE];    /* token value */
  111.     char        token;            /* token specifier */
  112.     int        i, n;
  113.     unsigned    len, size;
  114.     struct    field    *f;
  115.     char        *p;
  116.  
  117.     ENTER (field_attr);
  118.     while (token = get_token (fd, tokbuf)) {
  119.         switch (token) {
  120.             when 'v': if (++field >= Fno) RETURN (0);
  121.                   add_var (field, tokbuf);
  122.             when 's': n = (field < 0) ? 0 : field;
  123.                   f = &Field[n];
  124.                   size = strlen(tokbuf);
  125.                   build_selection (f, tokbuf, size);
  126.             when 'h': n = (field < 0) ? 0 : field;
  127.                   f = &Field[n];
  128.                   build_help_msg (f, tokbuf);
  129.             when 'd': n = (field < 0) ? 0 : field;
  130.                   f = &Field[n];
  131.                   size = strlen(tokbuf);
  132.                   len = (size > f-> f_len) ? f-> f_len : size;
  133.                   for (p=tokbuf, i=0; i<len; i++) {
  134.                       Screen[f-> f_line - 1][f-> f_off + i] = *p++;
  135.                       }
  136.             when 'a': n = (field < 0) ? 0 : field;
  137.                   f = &Field[n];
  138.                   set_field_attr (f, tokbuf);
  139.             otherwise:fprintf (stderr, "unknown token %c (field %d)\r\n",
  140.                        token, field);    
  141.             }
  142.         }
  143.     RETURN (1);
  144.     }
  145.  
  146. /*-------------------------------------------------------------05/08/86-+
  147. |                                    |
  148. |     get_token : return next token in field description section    |
  149. |                                    |
  150. +----------------------------------------------------------------------*/
  151. get_token (fd, tokbuf)
  152. FILE    *fd;
  153. char    *tokbuf;
  154.     {
  155.     static    char    buf[TOKENSIZE];
  156.     static    char    *p;
  157.     static    int    len = 0;
  158.     static    char    dchar;
  159.     register char    *tp;        /* temp pointer */
  160.     char        token;
  161.  
  162.     ENTER (get_token);
  163.     if (len == 0) {
  164.         do    {
  165.             if (!fgets (buf, sizeof (buf), fd)) RETURN ((char)0);
  166.             len = strlen (buf) - 1;        /* no NL */
  167.             } while (len == 0);
  168.         dchar = buf[0];        /* delimiter char */
  169.         p = buf + 1;        /* 1st char */
  170.         }
  171.  
  172.     for (tp=p; tp < &buf[len]; ) {
  173.         if (*tp++ == dchar) break;
  174.         }
  175.  
  176.     token = *p++;            /* return token char */
  177.     p++;                /* skip =, actually ignore it */
  178.     while (p < tp-1)
  179.         *tokbuf++ = *p++;
  180.     *tokbuf = EOS;
  181.  
  182.     if ((p = tp) == &buf[len]) len = 0;
  183.     RETURN (token);
  184.     }
  185.  
  186. /*----------------------------------------------------------------------+
  187. |                                    |
  188. |    make_field : extract input fields to make field structure    |
  189. |                                    |
  190. +----------------------------------------------------------------------*/
  191. make_field (lno, line)
  192. unsigned    lno;        /* line number of this line */
  193. char        *line;
  194.     {
  195.     char        *p;
  196.     unsigned    col = 1;    /* current column position */
  197.     unsigned    in_field = 0;    /* number of input field char */
  198.     unsigned    cno;
  199.  
  200.     ENTER (make_field);
  201.     for (p=line; *p != EOS; p++) {
  202.         switch (*p) {
  203.             case '~':     /* input field */
  204.                 *p = ' ';
  205.                 if (in_field++ == 0) cno = col;
  206.                 col++;
  207.                 break;
  208.             case '\t':
  209.                 col = ((col-1)/8 + 1) * 8 + 1;
  210.                 goto lab;
  211.             default:
  212.                 col++;
  213. lab:                if (in_field)
  214.                     add_field (lno, cno, p-line-in_field,
  215.                            in_field);
  216.                 in_field = 0;
  217.             }
  218.         }
  219.     EXIT;
  220.     }
  221.  
  222. /*----------------------------------------------------------------------+
  223. |                                    |
  224. |    init_field : initialize all field control related data        |
  225. |                                    |
  226. +----------------------------------------------------------------------*/
  227. init_field ()
  228.     {
  229.     int        i;
  230.  
  231.     ENTER (init_field);
  232.     Fno = 0;
  233.     for (i=0; i<SCRLINE; i++) {
  234.         Fhead[i] = 0;
  235.         Flcount[i] = 0;
  236.         }
  237.     EXIT;
  238.     }
  239.  
  240. /*----------------------------------------------------------------------+
  241. |                                    |
  242. |        add_field : add a given field to field structure        |
  243. |                                    |
  244. +----------------------------------------------------------------------*/
  245. add_field (line, column, offset, len)
  246. unsigned    line;        /* line of the field */
  247. unsigned    column;        /* column of the field */
  248. unsigned    offset;        /* char offset from beginning of the line */
  249. unsigned    len;        /* field size */
  250.     {
  251.     struct    field    *fp;
  252.  
  253.     ENTER (add_field);
  254.     if (Fno >= MAXFIELD) {
  255.         fprintf (stderr, "Too many fields in a screen max=%d\r\n",
  256.              MAXFIELD);
  257.         exit (1);
  258.         }
  259.     fp = &Field[Fno];
  260.     fp-> f_line = line;
  261.     fp-> f_col = column;
  262.     fp-> f_off = offset;
  263.     fp-> f_len = len;
  264.     fp-> f_attr = 0;        /* 'a' -- attribute */
  265.     fp-> f_sel = NULL;        /* 's' -- selection */
  266.     fp-> f_help = NULL;        /* 'h' -- help message */
  267.     fp-> f_sno = 0;
  268.     fp-> f_var = NULL;
  269.  
  270.     if (Flcount[line-1]++ == 0) {
  271.         Fhead[line-1] = Fno;
  272.         }
  273.     Fno++;
  274.     EXIT;
  275.     }
  276.  
  277. #define    STRNEQ(x,y,n)    ((*(x) == *(y)) && strncmp (x,y,n) == 0)
  278. #define    BADINIT    "Field %d, Init value: [%.*s] no in selection list, ignored\n"
  279. /*-------------------------------------------------------------01/11/88-+
  280. |                                    |
  281. |       init_sno : initialize selection number for preloaded fields    |
  282. |                                    |
  283. +----------------------------------------------------------------------*/
  284. init_sno ()
  285.     {
  286.     register int    idx, j;
  287.     int        field_count;
  288.     int        init_size;    /* initial default data size */
  289.     struct    field    *f;
  290.     char        *p;
  291.  
  292.     ENTER (init_sno);
  293.     for (idx=0; idx<Fno; idx++) {
  294.  
  295.         f = &Field[idx];
  296.         p = &Screen[f-> f_line - 1][f-> f_off];
  297.         init_size = fldlen (p, f-> f_len);
  298.  
  299.         if (f-> f_sel != NULL) {
  300.         if (init_size) {
  301.             field_count = sel_num (f);
  302.             /* check if default data is in the selection list */
  303.             for (j=0; j<field_count; j++) {
  304.                 register char    *selp;
  305.                 selp = f-> f_sel[j];
  306.                 if (STRNEQ (p, selp, strlen(selp))) {
  307.                     f-> f_sno = j;
  308.                     break;
  309.                     }
  310.                 }
  311.             if (j >= field_count) {
  312.                 fprintf (stderr, BADINIT, idx, init_size, p);
  313.                 j = 0;  goto mv_1st;
  314.                 }
  315.             }
  316.         else    {
  317.             /* move the first selection into the field */
  318.             j = 0;
  319. mv_1st:            strncpy (p, f-> f_sel[j], strlen(f-> f_sel[j]));
  320.             }
  321.         }
  322.         }
  323.     EXIT;
  324.     }
  325.  
  326. /*-------------------------------------------------------------01/26/88-+
  327. |                                    |
  328. |        set_field_attr : set attributes for a given field        |
  329. |                                    |
  330. +----------------------------------------------------------------------*/
  331. set_field_attr (fieldp, buf)
  332. struct    field    *fieldp;
  333. char        *buf;
  334.     {
  335.     char    c;
  336.  
  337.     ENTER (set_field_attr);
  338.     while ((c = *buf++) != EOS) {
  339.         switch (c) {
  340.             when 'd':    fieldp-> f_attr |= FA_NUMERIC;
  341.             when 'a':    fieldp-> f_attr |= FA_AUTOTAB;
  342.             when 'b':    fieldp-> f_attr |= FA_BLOCK;
  343.             otherwise:    fprintf (stderr,
  344.                      "unknown field attribute: %c\r\n", c);
  345.                 exit (1);
  346.             }
  347.         }
  348.     EXIT;
  349.     }
  350.