home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / driver / util / parsef.c < prev    next >
C/C++ Source or Header  |  1993-06-06  |  11KB  |  467 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from parsef.c
  3. */
  4. /** parsef.c **/
  5. #include "defines.h"
  6.  
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  10. #include <stdarg.h>
  11. #include <ctype.h>
  12.  
  13. #ifndef TEST
  14. #include "globals.h"
  15. #include "prhelp.h"
  16. #include "globals.i"
  17. #endif
  18.  
  19. #include "parsef.h"
  20. #include "parsef.i"
  21.  
  22. int Parse_Control;
  23. int Parse_Linenr;
  24.  
  25. static union arg_align {
  26.     char buf[ARG_STRING_SIZE];
  27.     long value;
  28. };
  29.  
  30. static void parse_line(struct string_parse *parse, char *line);
  31.  
  32.  
  33. /*
  34.  * Fuer die locale-Library:
  35.  *
  36.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  37.  * Achtung:
  38.  * Es muss/sollte 'multiple-include' erlaubt sein!
  39.  */
  40. #include "local.i"
  41.  
  42. #undef  CATCOMP_ARRAY
  43. #undef  CATCOMP_BLOCK
  44. #undef  CATCOMP_STRINGS
  45. #define CATCOMP_NUMBERS
  46. #include "localstr.h"
  47.  
  48.  
  49.  
  50. #ifdef TEST
  51.  
  52. /* Beispieldatei:
  53. init        27,42,2,LOW,HIGH
  54. printer epson
  55. ; comment
  56. hallo!
  57. draft on
  58. resolution    91,100,120; ja dann!
  59. printer foo ; weiterer Kommentar
  60. draft off;naja
  61. */
  62.  
  63. char maxline[512];
  64.  
  65. void __stdargs Fatal(int ret, char *fmt,...);
  66. void __stdargs Warning(char *fmt,...);
  67. void __stdargs Message(char *fmt,...);
  68. void *xmalloc(unsigned);
  69.  
  70. void main(int argc, char *argv[]);
  71.  
  72. static void __stdargs kw_printer(struct string_parse *, char *line, char *arg1);
  73. static void __stdargs kw_draft  (struct string_parse *, char *line, int on);
  74. static void __stdargs kw_string (struct string_parse *, char *line);
  75. static void __stdargs kw_ints   (struct string_parse *, char *line);
  76.  
  77. static struct string_parse printer_defs[] = {
  78.     {
  79.     "printer",
  80.     "%s",
  81.     (string_parse_function) kw_printer,
  82.     PAF_1_ARG
  83.     },
  84.     {
  85.     "draft",
  86.     NULL,
  87.     (string_parse_function) kw_draft,
  88.     PAF_BOOL_ARG | PAF_1_ARG
  89.     },
  90.     {
  91.     "init",
  92.     NULL,
  93.     (string_parse_function) kw_string,
  94.     PAF_ARGS
  95.     },
  96.     {
  97.     "resolution",
  98.     NULL,
  99.     (string_parse_function) kw_ints,
  100.     PAF_ARGS
  101.     },
  102.     {
  103.     NULL
  104.     }
  105. };
  106.  
  107. #endif /* TEST */
  108.  
  109.  
  110. void parse_file(struct string_parse *parse, FILE *file, int parse_control)
  111. {
  112.   char line[ARG_MAXLINE];
  113.   line[ARG_MAXLINE-1] = '\0';
  114.   Parse_Linenr = 0;
  115.   Parse_Control = parse_control & ~(PAC_END|PAC_END_SEARCH);
  116.  
  117.   while(fgets(line,ARG_MAXLINE-1,file) != NULL && !(Parse_Control & PAC_END)) {
  118.     char *s;
  119.     s = strrchr(line,'\n');
  120.     if (s != NULL) *s = '\0';
  121.  
  122.     s = strchr(line,';');        /* skip comment, koennte auch    */
  123.     if (s != NULL) *s = '\0';        /* von Flags abhaengig sein.    */
  124.  
  125.     Parse_Linenr++;
  126.     parse_line(parse,line);
  127.   }
  128. }
  129.  
  130.  
  131. static void parse_line(struct string_parse *parse, char *line)
  132. {
  133.   while (*line == ' ' || *line == '\t') line++;
  134.   if (*line == '\0') {        /* empty line */
  135.     return;
  136.   }
  137.  
  138.   for (; parse->paf_function; parse++) {
  139.     if (parse->paf_flags & PAF_NOKEY) {
  140.       /* let the function do everything */
  141.       (*parse->paf_function) (parse, line);
  142.       if (Parse_Control & PAC_END_SEARCH) {
  143.     Parse_Control &= ~PAC_END_SEARCH;
  144.         return;        /* allows for local control    */
  145.       }
  146.       else continue;    /* continue keyword search    */
  147.     }
  148.     else {
  149.       union arg_align arg1, arg2, arg3;        /* stack ?!    */
  150.       char format[MAX_FORMAT_LEN];        /* Na ja...    */
  151.       char key[MAX_KEY_LEN];
  152.       int num_args;
  153.       strcpy(format,"%13s ");            /*    (MAX_KEY_LEN)    */
  154.       if (parse->paf_flags & PAF_BOOL_ARG || (    /* allow BOOL w/o paf_format */
  155. #ifndef USE_PAFARGS
  156.        PAF_ARGS != (parse->paf_flags & PAF_ARGS) &&
  157. #endif
  158.        parse->paf_format)) {
  159.     strcat(format, parse->paf_format ? parse->paf_format : "%s");
  160. #if defined(HARDDEB)
  161.     if (MAX_FORMAT_LEN <= strlen(format))
  162.       Fatal(20,"parse_file : format overflow!");
  163. #endif
  164.       }
  165.       num_args = sscanf(line,
  166.     format, key, (void *)&arg1, (void *)&arg2, (void *)&arg3);
  167.       if (0 == num_args) {/*    looks like an empty line    */
  168. #if defined(HARDDEB)
  169.     Message("Empty line");    /* how did we get this ? */
  170. #endif
  171.     return;
  172.       }
  173.       if (0 == stricmp(key,parse->paf_keyword)) {
  174.         if (parse->paf_flags & PAF_ARGS) {
  175.       if (PAF_ARGS == (parse->paf_flags & PAF_ARGS)) {
  176.         /* let the function deal with all arguments    */
  177.         (*parse->paf_function) (
  178.           parse,
  179.           line
  180. #ifdef USE_PAFARGS
  181.           , (void *)&arg1, (void *)&arg2, (void *)&arg3
  182. #endif
  183.           );
  184.       }
  185.       else if (num_args != (parse->paf_flags & PAF_ARGS)) {
  186.         Warning(MSG_PARSE_BAD_NR_ARGS,
  187.           Parse_Linenr, line);
  188.       }
  189.       else {
  190.         if (parse->paf_flags & PAF_BOOL_ARG) {
  191.           int true = -1;
  192.           /* on or off is needed here, you may change that behaviour */
  193.           if (0 == stricmp(arg1.buf,"on"))        true = 1;
  194.           else if (0 == stricmp(arg1.buf,"off"))    true = 0;
  195.           if (-1 != true) {
  196.         (*parse->paf_function) (parse, line, true);
  197.           }
  198.           else Fatal(5,MSG_PARSE_BAD_ON_OFF,
  199.         Parse_Linenr, arg1.buf);
  200.         }
  201.         else {
  202.           /* call the function    */
  203.           (*parse->paf_function) (
  204.         parse,
  205.         line,
  206.         (void *)&arg1, (void *)&arg2, (void *)&arg3);
  207.         }
  208.       }
  209.     }
  210. #if defined(HARDDEB) /* Waehrend Testphase benutzen */
  211.     else Fatal(20,"parse_file : illegal flags!");
  212. #endif
  213.     return;
  214.       }
  215.     }
  216.   }
  217.   if (Parse_Control & PAC_END_UNKNOWN) {
  218.     Warning(MSG_PARSE_CANT_PARSE,Parse_Linenr, line);
  219.     Parse_Control |= PAC_END;
  220.   }
  221.   else Logging(MSG_PARSE_CANT_PARSE_IGNORE, Parse_Linenr, line);
  222. }
  223.  
  224.  
  225. /* non destructively skips the first field, which is known to be the
  226.     keyword. */
  227. char *args_line(char *line)
  228. {
  229.   while (!isspace(*line)) line++;
  230.   while (isspace(*line))  line++;
  231.   return line;
  232. }
  233.  
  234. /*J:    strtok() benutzen?    */
  235. /*    zero out all separators, note that the buffer is modified    */
  236. char *split_line(char *line, char *separators)
  237. {
  238.   char *pos;
  239.   for (pos = line; *pos; pos++) {
  240.     char *stops;
  241.     for (stops = separators; *stops; stops++) {
  242.       if (*stops == *pos) {
  243.         *pos='\0';
  244.     break;
  245.       }
  246.     }
  247.   }
  248.   return pos;    /* future lastpos    */
  249. }
  250.  
  251. /*    start from a zero position    */
  252. char *nextpos_line(char *line, char *lastpos)
  253. {
  254.   while(line != lastpos && '\0' == *line) line++;
  255.   return line;
  256. }
  257.  
  258. /*    start from an argument        */
  259. char *endpos_line(char *line)
  260. {
  261.   while (*line) line++;
  262.   return line;
  263. }
  264.  
  265.  
  266. /*    count the arguments        */
  267. unsigned fields_line(char *line, char *lastpos)
  268. {
  269.   char *pos = line;
  270.   unsigned fields = 0;
  271.   do {        /*    this shows how to parse the arguments    */
  272.     pos = nextpos_line(pos, lastpos);
  273.     if (pos == lastpos) break;
  274.     fields++;
  275.     pos = endpos_line(pos);
  276.   } while (1);
  277.   return fields;
  278. }
  279.  
  280.  
  281. /*    this will parse a sequence of chars like printer commands    */
  282. char *parse_bytes(char *line)
  283. {
  284.   char *resarray, num;
  285.   unsigned size;
  286.   char *pos, *lastpos;
  287.  
  288.   lastpos = split_line(line," \t");
  289.   size = fields_line(line,lastpos);
  290.  
  291.   /* the first position (corresponding to the former keyword)
  292.     will held the number of arguments.    */
  293.   resarray = xmalloc(size * sizeof(char));
  294.   
  295.   /* first skip the keyword arg.    */
  296.   pos = nextpos_line(line,lastpos);
  297.   if (pos == line) pos = nextpos_line(endpos_line(pos),lastpos);
  298.  
  299.   for (num = 0;
  300.        pos != lastpos;
  301.        pos= nextpos_line(endpos_line(pos),lastpos)) {
  302.     int i;
  303.     unsigned char c;
  304.  
  305.     /* I hope that this sscanf() works this way on all systems: */
  306.     /* make sure there's no char left after the number. */
  307.     if (0==strnicmp(pos, "0x", 2) && 1==sscanf(pos,"%x%c",&i,&c)) resarray[++num] = (char)i;
  308.     else if (1==sscanf(pos,"%d%c",&i,&c))    resarray[++num] = (char)i;
  309.     else if (0==stricmp(pos,"LOW"))    resarray[++num] = PP_INS_LOW;
  310.     else if (0==stricmp(pos,"HIGH"))    resarray[++num] = PP_INS_HIGH;
  311.     else if (0==stricmp(pos,"NR100"))    resarray[++num] = PP_INS_NR100;
  312.     else if (0==stricmp(pos,"NR10"))    resarray[++num] = PP_INS_NR10;
  313.     else if (0==stricmp(pos,"NR1"))    resarray[++num] = PP_INS_NR1;
  314.     else if (0==stricmp(pos,"ESC"))    resarray[++num]    = ESC;
  315.     else if (0==stricmp(pos,"FS"))    resarray[++num]    = FS;
  316.     else if (sscanf(pos, "'%c'", &c) == 1) resarray[++num] = c; 
  317.     /*else if (*(pos+1) == '\0')    resarray[++num] = *pos;*/
  318.     else Message(MSG_PARSE_ILLEG_ARG,line, pos);
  319.   }
  320.   resarray[0] = num;
  321. #if defined(HARDDEB)    /*    needed ?    */
  322.   if (num != size-1) Message("Data missing for keyword : %s.",line);
  323. #endif
  324.   return resarray;
  325. }
  326.  
  327.  
  328. #if 0 || defined(TEST)    /* function is not used */
  329. /*    this will parse a sequence of integer values    */
  330. int *parse_ints(char *line)
  331. {
  332.   int *resarray, num;
  333.   unsigned size;
  334.   char *pos = line, *lastpos;
  335.  
  336.   lastpos = split_line(line," \t,");
  337.   size = fields_line(line,lastpos);
  338.  
  339.   /* the first position (corresponding to the former keyword)
  340.     will held the number of arguments.    */
  341.   resarray = xmalloc(size * sizeof(int));
  342.   
  343.   /* first skip the keyword arg.    */
  344.   pos = nextpos_line(line,lastpos);
  345.   if (pos == line) pos = nextpos_line(endpos_line(pos),lastpos);
  346.  
  347.   for (num = 0;
  348.        pos != lastpos;
  349.        pos= nextpos_line(endpos_line(pos),lastpos)) {
  350.     if (1 == sscanf(pos,"%d",&resarray[num+1])) num++;
  351.     else Message("Erroneous argument %s with keyword %s.",pos,line);
  352.   }
  353.   resarray[0] = num;
  354.   if (num < 1) Warning("At least one parameter required with keyword %s.",line);
  355. #if defined(HARDDEB)
  356.   if (num != size-1) Message("Data missing for keyword : %s.",line);
  357. #endif
  358.   return resarray;
  359. }
  360. #endif /* 0 || TEST */
  361.  
  362.  
  363.  
  364. #ifdef TEST
  365.  
  366. static void __stdargs kw_printer(struct string_parse *p, char *line, char *arg1)
  367. {
  368.   Message("Printer %s selected.",arg1);
  369. }
  370.  
  371.  
  372. static void __stdargs kw_draft(struct string_parse *p, char *line, int on)
  373. {
  374.   Message( on ? "draft selected." : "draft unselected.");
  375. }
  376.  
  377.  
  378. static void __stdargs kw_string(struct string_parse *p, char *line)
  379. {
  380.   char *stringarray = parse_bytes(line);
  381.   int num;
  382.   Message("Keyword %s: (%d printer chars)",line,stringarray[0]);
  383.   for (num=0; num < stringarray[0]; num++)
  384.     Message("\tchar %d=%x", num+1, stringarray[num+1]);
  385. }
  386.  
  387.  
  388. static void __stdargs kw_ints(struct string_parse *p, char *line)
  389. {
  390.   int *array = parse_ints(line);
  391.   int num;
  392.   Message("Keyword %s: (%d ints)",line,array[0]);
  393.   for (num=0; num < array[0]; num++)
  394.     Message("\tint %d=%d", num+1, array[num+1]);
  395. }
  396.  
  397.  
  398. void *xmalloc(unsigned size)
  399. {
  400.   void *here = malloc(size);
  401.   if (!here) Fatal(10,"Memory allocation failure (size %u)!",size);
  402.   return here;
  403. }
  404.  
  405.  
  406. void __stdargs Fatal(int ret, char *fmt,...)
  407. {
  408.   va_list argptr;
  409.  
  410.   va_start(argptr, fmt);
  411.   /* sprintf() should return the number of chars output */
  412.   vsprintf(&maxline[sprintf(maxline,"FATAL-- ")], fmt, argptr);
  413.   va_end(argptr);
  414.   puts(maxline);
  415.  
  416.   exit(ret);
  417. }
  418.  
  419. void __stdargs Warning(char *fmt,...)
  420. {
  421.   va_list argptr;
  422.  
  423.   va_start(argptr, fmt);
  424.   vsprintf(maxline, fmt, argptr);
  425.   va_end(argptr);
  426.   puts(maxline);
  427. }
  428.  
  429. void __stdargs Message(char *fmt,...)
  430. {
  431.   va_list argptr;
  432.  
  433.   va_start(argptr, fmt);
  434.   vsprintf(maxline, fmt, argptr);
  435.   va_end(argptr);
  436.   puts(maxline);
  437. }
  438.  
  439.  
  440. void main(int argc, char *argv[]) {
  441. #if 1
  442.   if (argc !=2) {
  443.     Fatal(20,"Usage : parsef <filename>.");
  444.   }
  445.   else {
  446.     FILE *file;
  447. #if defined(HARDDEB)
  448.     Message("File :\"%s\".",argv[1]);
  449. #endif
  450.     file = fopen(argv[1],"r");
  451.     if (!file) Fatal(10,"Can't not open file \"%s\"!",argv[1]);
  452.     else {
  453.       parse_file(printer_defs, file);
  454.       fclose(file);
  455.     }
  456.   }
  457. #else
  458.   int num, *array;
  459.   array = parse_numbers("printer 1 2 3 4 5 6",PARSE_INTS);
  460.   for (num = 0; num < array[0]; num++) {
  461.     Message("%d = %d",num+1, array[num+1]);
  462.   }
  463. #endif
  464. }
  465.  
  466. #endif /* TEST */
  467.