home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 449a.lha / ListPlot / Csrc / get_args.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-08  |  14.5 KB  |  774 lines
  1. /*
  2.  * get_args.c
  3.  *
  4.  *    command line argument parser
  5.  */
  6. #include <stdio.h>
  7. #include <errno.h>
  8. extern int    errno;
  9. #include <assert.h>
  10. #include <ctype.h>
  11. #include <string.h>
  12. #include "datatypes.h"
  13.  
  14. /*
  15. #define    min(A,B)    A<B? A : B
  16. #define    max(A,B)    A>B? A : B
  17. */
  18.  
  19. void
  20. get_args(argc, argv, Symbols, Usage, Function)
  21. int    argc;
  22. char    **argv;
  23. ARGDEF    *Symbols[];
  24. char    *Usage[], *Function[];
  25. {
  26.     register int    i;
  27.     bool    helped;
  28.     bool    Help(), ParseHelp();
  29.  
  30.     /* set default values */
  31.     SetDefaults(Symbols);
  32.  
  33.     helped = FALSE;
  34.     for (i=1; i<argc; i++)
  35.         if (argv[i][0] == '?' || argv[i][0] == '-') {
  36.             Help(Usage, Function, Symbols, "All");
  37.             helped = TRUE;
  38.         } else if (strncmp(argv[i], "Help",4)==0 || strncmp(argv[i],"help",4)==0) {
  39.             ParseHelp(Usage, Function, Symbols, argv[i]);
  40.             helped = TRUE;
  41.         } else if (ParseArg(Symbols, argv[i])) {
  42.             continue;
  43.         } else {
  44.             errno = EINVAL;
  45.             perror(argv[i]);
  46.             goto error_exit;
  47.         }
  48.     if (helped == TRUE)
  49.         exit(0);
  50.     else
  51.         return;
  52.  
  53. error_exit:
  54.     PrintUsage(stderr, Usage, Function, Symbols);
  55.     exit(errno);
  56. }
  57.  
  58.  
  59. void
  60. SetDefaults(Symbols)
  61. ARGDEF    *Symbols[];
  62. {
  63.     register int    i;
  64.  
  65.     for (i=0; Symbols[i]; i++)
  66.         if (SetValue(
  67.             Symbols[i]->ad_value,
  68.             Symbols[i]->ad_default,
  69.             Symbols[i]->ad_defaultType
  70.         ) != TRUE) {
  71.             /* error */
  72.             fprintf(stderr,"Internal error: (SetDefaults) Unable to set ");
  73.             PrintArgDef(stderr,Symbols[i]);
  74.             errno = EINVAL;
  75.             exit(errno);
  76.         }
  77.     return;
  78. }
  79.  
  80.  
  81. bool
  82. SetValue(Val, ValStr, ValType)
  83. VALUE    *Val;
  84. char    *ValStr;
  85. char    *ValType;
  86. {
  87.     register int    WidType;
  88.  
  89.     WidType = strlen(ValType);
  90.     if (strncmp(ValType, "string", WidType) == 0) {
  91.         return(SetString(Val, ValStr));
  92.     } else if (strncmp(ValType, "dbl", WidType) == 0) {
  93.         return(SetDbl(Val, ValStr));
  94.     } else if (strncmp(ValType, "float", WidType) == 0) {
  95.         return(SetFloat(Val, ValStr));
  96.     } else if (strncmp(ValType, "int", WidType) == 0) {
  97.         return(SetInt(Val, ValStr));
  98.     } else if (strncmp(ValType, "boolean", WidType) == 0) {
  99.         return(SetBool(Val, ValStr));
  100.     } else if (strncmp(ValType, "byte", WidType) == 0) {
  101.         return(SetByte(Val, ValStr));
  102.     } else if (strncmp(ValType, "interval", WidType) == 0) {
  103.         return(SetInterval(Val, ValStr));
  104.     } else if (strncmp(ValType, "set", min(WidType,3)) == 0) {
  105.         return(SetSet(Val, ValStr, ValType, WidType));
  106.     } else if (strncmp(ValType, "rect", WidType) == 0) {
  107.         return(SetRect(Val, ValStr));
  108.     } else {
  109.         return(FALSE);
  110.     }
  111. }
  112.  
  113.  
  114. bool
  115. SetString(Val, ValStr)
  116. VALUE    *Val;
  117. char    *ValStr;
  118. {
  119.     Val->val_type = string;
  120.     Val->val_u.udt_string = StrDup(ValStr);
  121.     return(TRUE);
  122. }
  123.  
  124.  
  125. bool
  126. SetDbl(Val, ValStr)
  127. VALUE    *Val;
  128. char    *ValStr;
  129. {
  130.     double    D;
  131.  
  132.     if (sscanf(ValStr, "%lf", &D) == 1) {
  133.         Val->val_type = dbl;
  134.         Val->val_u.udt_dbl = D;
  135.         return(TRUE);
  136.     } else {
  137.         return(FALSE);
  138.     }
  139. }
  140.  
  141.  
  142. bool
  143. SetFloat(Val, ValStr)
  144. VALUE    *Val;
  145. char    *ValStr;
  146. {
  147.     float    F;
  148.  
  149.     if (sscanf(ValStr, "%f", &F) == 1) {
  150.         Val->val_type = flt;
  151.         Val->val_u.udt_flt = F;
  152.         return(TRUE);
  153.     } else {
  154.         return(FALSE);
  155.     }
  156. }
  157.  
  158.  
  159. bool
  160. SetInt(Val, ValStr)
  161. VALUE    *Val;
  162. char    *ValStr;
  163. {
  164.     int    I;
  165.  
  166.     if (sscanf(ValStr, "%d", &I) == 1) {
  167.         Val->val_type = integer;
  168.         Val->val_u.udt_int = I;
  169.         return(TRUE);
  170.     } else {
  171.         return(FALSE);
  172.     }
  173. }
  174.  
  175.  
  176. bool
  177. SetBool(Val, ValStr)
  178. VALUE    *Val;
  179. char    *ValStr;
  180. {
  181.     register int i, n;
  182.     char    s[32];
  183.  
  184.     n = min(strlen(ValStr),sizeof(s)-1);
  185.     for (i=0; i<n; i++)
  186.         s[i] = isupper(ValStr[i])? tolower(ValStr[i]) : ValStr[i];
  187.     s[i] = (char)NULL;
  188.     n = i - 1;
  189.  
  190.     if (
  191.         strncmp(s, "true", n) == 0 ||
  192.         strncmp(s, "on", n) == 0 ||
  193.         strncmp(s, "yes", n) == 0 ||
  194.         strncmp(s, "1", n) == 0)
  195.     {
  196.         Val->val_type = boolean;
  197.         Val->val_u.udt_bool = TRUE;
  198.         return(TRUE);
  199.     } else if (
  200.         strncmp(s, "false", n) == 0 ||
  201.         strncmp(s, "off", n) == 0 ||
  202.         strncmp(s, "no", n) == 0 ||
  203.         strncmp(s, "0", n) == 0)
  204.     {
  205.         Val->val_type = boolean;
  206.         Val->val_u.udt_bool = FALSE;
  207.         return(TRUE);
  208.     } else {
  209.         return(FALSE);
  210.     }
  211. }
  212.  
  213.  
  214. bool
  215. SetByte(Val, ValStr)
  216. VALUE    *Val;
  217. char    *ValStr;
  218. {
  219.     char    C;
  220.     Val->val_type = byte;
  221.     if (sscanf(ValStr, "%c", &C) == 1) {
  222.         Val->val_u.udt_byte = (char)C;
  223.         return(TRUE);
  224.     } else {
  225.         return(FALSE);
  226.     }
  227. }
  228.  
  229.  
  230. bool
  231. SetInterval(Val, ValStr)
  232. VALUE    *Val;
  233. char    *ValStr;
  234. {
  235.     double    lo, hi;
  236.     Val->val_type = interval;
  237.     if (sscanf(ValStr, "%lf,%lf", &lo,&hi) == 2) {
  238.         Val->val_u.udt_interval.int_lo = lo;
  239.         Val->val_u.udt_interval.int_hi = hi;
  240.         return(TRUE);
  241.     } else {
  242.         return(FALSE);
  243.     }
  244. }
  245.  
  246.  
  247. bool
  248. SetSet(Val, ValStr, ValType, WidType)
  249. VALUE    *Val;
  250. char    *ValStr;
  251. char    *ValType;
  252. int    WidType;
  253. {
  254.     int    i;
  255.     SET    *S;
  256.     char    *LeftBrace, *RightBrace;
  257.     char    *Start;
  258.     char    *sp;
  259.     bool    Escape;
  260.     int    WidStr;
  261.     char    s[128];
  262.     char    *SkipBlanks(char *);
  263.  
  264.     Val->val_type = set;
  265.     S = &Val->val_u.udt_set;
  266.     S->list_n = 0;
  267.     S->list_head = (LATOM *)NULL;
  268.     S->list_tail = (LATOM *)NULL;
  269.  
  270.     if ((LeftBrace = strchr(ValStr, '{')) == (char *)NULL) {
  271.         /*error*/
  272.         fprintf(stderr,"(SetSet) Invalid set specification:  \"%s\" (missing left brace).\n", ValStr);
  273.         exit(0);
  274.     }
  275.     Start = LeftBrace+1;
  276.     if ((RightBrace = strchr(ValStr, '}')) == (char *)NULL) {
  277.         /*error*/
  278.         fprintf(stderr,"(SetSet) Invalid set specification: \"%s\" (missing right brace).\n", ValStr);
  279.         exit(0);
  280.     }
  281.     WidStr = RightBrace - Start;
  282.  
  283.     for (sp=Start; *sp && *sp != '}'; ) {
  284. /*         sp = SkipBlanks(sp); */
  285.         for ( Escape=FALSE,i=0; *sp && (Escape==TRUE || (Escape==FALSE && *sp != ',' && *sp != '}')); sp++) {
  286.             if (Escape == TRUE) {
  287.                 s[i++] = *sp;
  288.                 Escape = !Escape;
  289.             } else if (*sp == '\\' && Escape == FALSE) {
  290.                 Escape = !Escape;
  291.             } else {
  292.                 assert(*sp != '\\' && Escape == FALSE);
  293.                 s[i++] = *sp;
  294.             }
  295.         }
  296.         s[i] = (char)NULL;
  297.         Append(S, (generic *)StrDup(s));
  298.         if (*sp == ',')
  299.             ++sp;
  300.     }
  301.  
  302.     return(TRUE);
  303. }
  304.  
  305.  
  306. bool
  307. SetRect(Val, ValStr)
  308. VALUE    *Val;
  309. char    *ValStr;
  310. {
  311.     register char    *sp;
  312.     register int    i;
  313.     FLOAT    *R;
  314.     char    *LeftBrace, *RightBrace;
  315.     char    *Start;
  316.     char    s[128];
  317.     char    *SkipBlanks(char *);
  318.     double    atof();
  319.  
  320.     Val->val_type = rect;
  321.     R = Val->val_u.udt_rect.r_diag;
  322.  
  323.     if ((LeftBrace = strchr(ValStr, '{')) == (char *)NULL) {
  324.         /*error*/
  325.         fprintf(stderr,"(SetRect) Invalid rect specification:  \"%s\" (missing left brace).\n", ValStr);
  326.         exit(0);
  327.     }
  328.     Start = LeftBrace+1;
  329.     if ((RightBrace = strchr(ValStr, '}')) == (char *)NULL) {
  330.         /*error*/
  331.         fprintf(stderr,"(SetRect) Invalid rect specification: \"%s\" (missing right brace).\n", ValStr);
  332.         exit(0);
  333.     }
  334.  
  335.     for (sp=Start; *sp && *sp != '}'; ) {
  336.         sp = SkipBlanks(sp);
  337.         for ( i=0; *sp && *sp != ',' && *sp != '}'; sp++) {
  338.             s[i++] = *sp;
  339.         }
  340.         s[i] = (char)NULL;
  341.         *R++ = atof(s);
  342.         if (*sp == ',')
  343.             ++sp;
  344.     }
  345.  
  346.     return(TRUE);
  347. }
  348.  
  349.  
  350. char *
  351. SkipBlanks(s)
  352. register char    *s;
  353. {
  354.     while(isspace(*s))
  355.         ++s;
  356.     return(s);
  357. }
  358.  
  359.  
  360. void
  361. PrintUsage(Fp, Usage, Function, Symbols)
  362. FILE    *Fp;
  363. char    *Usage[];
  364. char    *Function[];
  365. ARGDEF    *Symbols[];
  366. {
  367.     register int    i;
  368.  
  369.     for (i=0; Usage[i]; i++)
  370.         fputs(Usage[i], Fp);
  371.     for (i=0; Function[i]; i++)
  372.         fputs(Function[i], Fp);
  373.     fprintf(Fp, "Options:\n");
  374.     for (i=0; Symbols[i]; i++) {
  375.         fputc('\t', Fp);
  376.         PrintArgDef(Fp, Symbols[i]);
  377.     }
  378. }
  379.  
  380.  
  381. bool
  382. ParseHelp(Usage, Function, Symbols, arg)
  383. char    *Usage;
  384. char    *Function;
  385. ARGDEF    *Symbols[];
  386. char    *arg;
  387. {
  388.     bool    Help(); 
  389.     char    *EqualSign;
  390.  
  391.     if (strncmp(arg, "Help", 4)==0 || strncmp(arg, "help", 4)==0) {
  392.         if ((EqualSign = strchr(arg,'=')) == (char *)NULL)
  393.             return(Help(Usage, Function, Symbols, "All"));
  394.         else
  395.             return(Help(Usage, Function, Symbols, EqualSign+1));
  396.     }
  397.     return(FALSE);
  398. }
  399.  
  400.  
  401. bool
  402. Help(Usage, Function, Symbols, arg)
  403. char    *Usage[];
  404. char    *Function[];
  405. ARGDEF    *Symbols[];
  406. char    *arg;
  407. {
  408.     register int    i, j;
  409.     extern    VALUE    V_Verbose;
  410.  
  411.     if (strcmp(arg, "All")==0 || strcmp(arg,"all")==0) {
  412.         if (VtoBoolean(V_Verbose)) {
  413.             for (i=0; Usage[i]; i++)
  414.                 fputs(Usage[i], stdout);
  415.             for (i=0; Function[i]; i++)
  416.                 fputs(Function[i], stdout);
  417.             fprintf(stdout, "Options:\n");
  418.             for (i=0; Symbols[i]; i++) {
  419.                 fputc('\t', stdout);
  420.                 PrintArgDef(stdout, Symbols[i]);
  421.                 if ( Symbols[i]->ad_helptext != (char **)NULL) {
  422.                     for (j=0; Symbols[i]->ad_helptext[j]; j++)
  423.                         fputs(Symbols[i]->ad_helptext[j], stdout);
  424.                 }
  425.                 fputc('\n', stdout);
  426.             }
  427.         } else {
  428.             fputs(Usage[0], stdout);
  429.             fputs(Function[0], stdout);
  430.             fprintf(stderr, "Options:\n");
  431.             for (i=0; Symbols[i]; i++) {
  432.                 fputc('\t', stdout);
  433.                 PrintArgDef(stdout, Symbols[i]);
  434.             }
  435.         }
  436.         return(TRUE);
  437.     } else {
  438.         /* find entry in symbol table    */
  439.         for (i=0; Symbols[i]; i++) {
  440.             if (strcmp(arg,Symbols[i]->ad_id) == 0) {
  441.                 /* found */
  442.                 fputc('\t', stdout);
  443.                 PrintArgDef(stdout, Symbols[i]);
  444.                 if (VtoBoolean(V_Verbose) && Symbols[i]->ad_helptext != (char **)NULL) {
  445.                     for (j=0; Symbols[i]->ad_helptext[j]; j++)
  446.                         fputs(Symbols[i]->ad_helptext[j], stdout);
  447.                     fputc('\n', stdout);
  448.                 }
  449.                 return(TRUE);
  450.             }
  451.         }
  452.     }
  453.     return(FALSE);
  454. }
  455.  
  456.  
  457.  
  458.  
  459. bool
  460. ParseArg(Symbols, arg)
  461. ARGDEF    *Symbols[];
  462. char    *arg;
  463. {
  464.     register int    i;
  465.     char        *EqualSign;
  466.     char        *ValueStr;
  467.     int        wid;
  468.  
  469.     if ((EqualSign = strchr(arg,'=')) == (char *)NULL) {
  470.         ValueStr = arg;
  471.         wid = strlen(ValueStr);
  472.     } else {
  473.         ValueStr = EqualSign + 1;
  474.         wid = EqualSign - arg;
  475.     }
  476.  
  477.     /* find entry in symbol table    */
  478.     for (i=0; Symbols[i]; i++) {
  479.         if (strncmp(arg,Symbols[i]->ad_id, wid) == 0) {
  480.             /* found */
  481.             return(ParseEntry(Symbols[i], ValueStr));
  482.         }
  483.     }
  484.     
  485.     return(FALSE);
  486. }
  487.  
  488.  
  489. bool
  490. ParseEntry(Entry, arg)
  491. ARGDEF    *Entry;
  492. char    *arg;
  493. {
  494.     char    *StartOpt, *StartType;
  495.     char    *BarOpt;
  496.     char    *BarType;
  497.     int    WidOpt, WidType;
  498.  
  499.     StartOpt = Entry->ad_options;
  500.     StartType = Entry->ad_opttype;
  501.     do {
  502.         if ((BarOpt = strchr(StartOpt,'|')) == (char *)NULL) {
  503.             WidOpt = strlen(StartOpt);
  504.         } else {
  505.             WidOpt = BarOpt - StartOpt;
  506.         }
  507.         if ((BarType = strchr(StartType,'|')) == (char *)NULL) {
  508.             WidType = strlen(StartType);
  509.         } else {
  510.             WidType = BarType - StartType;
  511.         }
  512.  
  513.         if (strncmp(StartType, "string", WidType) == 0) {
  514.             if (ParseString(Entry, StartOpt, WidOpt, arg) == TRUE)
  515.                 return(TRUE);
  516.             else {
  517.                 StartOpt = ++BarOpt;
  518.                 StartType = ++BarType;
  519.                 continue;
  520.             }
  521.         } else  if (strncmp(StartType, "dbl", WidType) == 0) {
  522.             if (ParseDbl(Entry, arg) == TRUE)
  523.                 return(TRUE);
  524.             else {
  525.                 StartOpt = ++BarOpt;
  526.                 StartType = ++BarType;
  527.                 continue;
  528.             }
  529.         } else if (strncmp(StartType, "float", WidType) == 0) {
  530.             if (ParseFloat(Entry, arg) == TRUE)
  531.                 return(TRUE);
  532.             else {
  533.                 StartOpt = ++BarOpt;
  534.                 StartType = ++BarType;
  535.                 continue;
  536.             }
  537.         } else if (strncmp(StartType, "int", WidType) == 0) {
  538.             if (ParseInt(Entry, arg) == TRUE)
  539.                 return(TRUE);
  540.             else {
  541.                 StartOpt = ++BarOpt;
  542.                 StartType = ++BarType;
  543.                 continue;
  544.             }
  545.         } else if (strncmp(StartType, "boolean", WidType) == 0) {
  546.             if (ParseBool(Entry, arg) == TRUE)
  547.                 return(TRUE);
  548.             else {
  549.                 StartOpt = ++BarOpt;
  550.                 StartType = ++BarType;
  551.                 continue;
  552.             }
  553.         } else if (strncmp(StartType, "byte", WidType) == 0) {
  554.             if (ParseByte(Entry, arg) == TRUE)
  555.                 return(TRUE);
  556.             else {
  557.                 StartOpt = ++BarOpt;
  558.                 StartType = ++BarType;
  559.                 continue;
  560.             }
  561.         } else if (strncmp(StartType, "interval", WidType) == 0) {
  562.             if (ParseInterval(Entry, arg) == TRUE)
  563.                 return(TRUE);
  564.             else {
  565.                 StartOpt = ++BarOpt;
  566.                 StartType = ++BarType;
  567.                 continue;
  568.             }
  569.         } else if (strncmp(StartType, "set", min(WidType,3)) == 0) {
  570.             if (ParseSet(Entry, arg, StartType,WidType) == TRUE) {
  571.                 return(TRUE);
  572.             } else {
  573.                 StartOpt = ++BarOpt;
  574.                 StartType = ++BarType;
  575.                 continue;
  576.             }
  577.         } else if (strncmp(StartType, "rect", WidType) == 0) {
  578.             if (ParseRect(Entry, arg) == TRUE) {
  579.                 return(TRUE);
  580.             } else {
  581.                 StartOpt = ++BarOpt;
  582.                 StartType = ++BarType;
  583.                 continue;
  584.             }
  585.         } else {
  586.             fprintf(stderr, "Internal Error: invalid option type string: \"%s\"\n", StartType);
  587.             PrintArgDef(stderr,Entry);
  588.             errno = EINVAL;
  589.             exit(errno);
  590.         }
  591.     } while(StartOpt != (char)NULL && StartType != (char)NULL);
  592.     return(TRUE);
  593. }
  594.  
  595.  
  596. bool
  597. ParseString(Entry, Option, n, arg)
  598. ARGDEF    *Entry;
  599. char    *Option;
  600. int    n;
  601. char    *arg;
  602. {
  603.     if (*Option == '*') {
  604.          /* Match any string    */
  605.         Entry->ad_value->val_type = string;
  606.         Entry->ad_value->val_u.udt_string = StrDup(arg);
  607.         return(TRUE);
  608.     } else if (arg!=(char *)NULL && strncmp(arg,Option,strlen(arg)) == 0) {
  609.         /* Matches option    */
  610.         Entry->ad_value->val_type = string;
  611.         Entry->ad_value->val_u.udt_string = StrDup(arg);
  612.         return(TRUE);
  613.     } else {
  614.         return(FALSE);
  615.     }
  616. }
  617.  
  618. char    *
  619. StrDup(Str)
  620. char    *Str;
  621. {
  622.     register int    n;
  623.     register char    *Dup;
  624.  
  625.     if (Str == (char *)NULL)
  626.         return((char *)NULL);
  627.  
  628.     n = strlen(Str);
  629.     if ((Dup = malloc(n+1)) == (char *)NULL) {
  630.         perror("(StrDup) ");
  631.         assert(Dup != (char *)NULL);
  632.         exit(errno);
  633.     }
  634.     memcpy(Dup, Str, n+1);
  635.     return(Dup);
  636. }
  637.  
  638.  
  639. bool
  640. ParseDbl(Entry, arg)
  641. ARGDEF    *Entry;
  642. char    *arg;
  643. {
  644.     return(SetDbl(Entry->ad_value, arg));
  645. }
  646.  
  647. bool
  648. ParseFloat(Entry, arg)
  649. ARGDEF    *Entry;
  650. char    *arg;
  651. {
  652.     return(SetFloat(Entry->ad_value, arg));
  653. }
  654.  
  655. bool
  656. ParseInt(Entry, arg)
  657. ARGDEF    *Entry;
  658. char    *arg;
  659. {
  660.     return(SetInt(Entry->ad_value, arg));
  661. }
  662.  
  663. bool
  664. ParseBool(Entry, arg)
  665. ARGDEF    *Entry;
  666. char    *arg;
  667. {
  668.     return(SetBool(Entry->ad_value, arg));
  669. }
  670.  
  671. bool
  672. ParseByte(Entry, arg)
  673. ARGDEF    *Entry;
  674. char    *arg;
  675. {
  676.     return(SetByte(Entry->ad_value, arg));
  677. }
  678.  
  679. bool
  680. ParseInterval(Entry, arg)
  681. ARGDEF    *Entry;
  682. char    *arg;
  683. {
  684.     return(SetInterval(Entry->ad_value, arg));
  685. }
  686.  
  687. bool
  688. ParseSet(Entry, arg, Type, WidType)
  689. ARGDEF    *Entry;
  690. char    *arg;
  691. char    *Type;
  692. int    WidType;
  693. {
  694.     return(SetSet(Entry->ad_value, arg, Type, WidType));
  695. }
  696.  
  697. bool
  698. ParseRect(Entry, arg)
  699. ARGDEF    *Entry;
  700. char    *arg;
  701. {
  702.     return(SetRect(Entry->ad_value, arg));
  703. }
  704.  
  705.  
  706. void
  707. PrintArgDef(Fp, Def)
  708. FILE    *Fp;
  709. ARGDEF    *Def;
  710. {
  711.     fprintf(Fp, "%s=", Def->ad_id);
  712.     fprintf(Fp, "[%s]", Def->ad_options);
  713.     fprintf(Fp, " default: %s\n", Def->ad_default);
  714.     fflush(Fp);
  715. }
  716.  
  717.  
  718. void
  719. PrintArg(Fp, Def)
  720. FILE    *Fp;
  721. ARGDEF    *Def;
  722. {
  723.     LATOM    *A;
  724.  
  725.     switch(Def->ad_value->val_type) {
  726.     default:
  727.         fprintf(Fp,"%s=<Invalid datatype>!\n", Def->ad_id);
  728.         break;
  729.     case boolean:
  730.         fprintf(Fp,"%s=%s\n",
  731.             Def->ad_id,
  732.             Def->ad_value->val_u.udt_bool? "TRUE":"FALSE");
  733.         break;
  734.     case integer:
  735.         fprintf(Fp,"%s=%d\n",Def->ad_id,Def->ad_value->val_u.udt_int);
  736.         break;
  737.     case dbl:
  738.         fprintf(Fp,"%s=%lg\n",Def->ad_id,Def->ad_value->val_u.udt_dbl);
  739.         break;
  740.     case flt:
  741.         fprintf(Fp,"%s=%g\n",Def->ad_id,Def->ad_value->val_u.udt_flt);
  742.         break;
  743.     case byte:
  744.         fprintf(Fp,"%s=%c\n",Def->ad_id,Def->ad_value->val_u.udt_byte);
  745.         break;
  746.     case string:
  747.         fprintf(Fp,"%s=\"%s\"\n",Def->ad_id,Def->ad_value->val_u.udt_string);
  748.         break;
  749.     case interval:
  750.         fprintf(Fp,"%s=%g,%g\n",Def->ad_id,Def->ad_value->val_u.udt_interval);
  751.         break;
  752.     case set:
  753.         fprintf(Fp,"%s={\n",Def->ad_id);
  754.         for (A=Def->ad_value->val_u.udt_set.list_head; A; A=A->la_next)
  755.             if (A->la_next)
  756.                 fprintf(Fp,"\t\t<%s>,\n",(char *)A->la_p);
  757.             else
  758.                 fprintf(Fp,"\t\t<%s>\n",(char *)A->la_p);
  759.         fprintf(Fp, "\t}\n");
  760.         break;
  761.     case rect:
  762.         fprintf(
  763.             Fp,
  764.             "%s={%g,%g, %g,%g}\n",
  765.             Def->ad_id,
  766.             Def->ad_value->val_u.udt_rect.r_diag[0],
  767.             Def->ad_value->val_u.udt_rect.r_diag[1],
  768.             Def->ad_value->val_u.udt_rect.r_diag[2],
  769.             Def->ad_value->val_u.udt_rect.r_diag[3]
  770.         );
  771.         break;
  772.     }
  773. }
  774.