开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 人工智能/神经网络 > 查看源码
scan.c
资源名称：apriori(c).zip　[点击查看]
上传用户：lengbin
上传日期：2010-03-31
资源大小：121k
文件大小：38k
源码类别：

人工智能/神经网络

开发平台：

C/C++

scan.c：源码内容
  1. /*----------------------------------------------------------------------
  2.   File    : scan.c
  3.   Contents: scanner (lexical analysis of a character stream)
  4.   Author  : Christian Borgelt
  5.   History : 16.01.1996 file created
  6.             21.02.1996 identifier recognition made more flexible
  7.             17.03.1996 keyword tokens removed
  8.             15.04.1996 duplicate state removed from sc_next
  9.             29.07.1997 < and > declared active (for decision trees)
  10.             08.09.1997 escape sequences in strings made possible
  11.             11.09.1997 single characters stored also in scn->value
  12.             08.02.1998 recover and error message functions added
  13.             09.02.1998 bug in state S_NUMPT concerning "-." removed
  14.             13.02.1998 token T_RGT ('->') added
  15.             04.03.1998 returned tokens changed for some states
  16.             17.04.1998 token T_LFT ('<-') added
  17.             27.05.1998 token T_CMP (two char comparison operator) added
  18.             31.05.1998 token conversion to number removed
  19.             08.02.1999 reading from standard input made possible
  20.             29.04.1999 quoted string parsing improved
  21.             13.11.1999 token string length stored in scn->len
  22.             23.11.2000 functions sc_fmtlen and sc_format added
  23.             15.07.2001 scanner made an object, state definitions added
  24.             16.07.2001 characters with code > 127 made printable
  25.                        look ahead functionality added (sc_back)
  26. ----------------------------------------------------------------------*/
  27. #include <stdio.h>
  28. #include <stdlib.h>
  29. #include <string.h>
  30. #include <stdarg.h>
  31. #include <assert.h>
  32. #include "scan.h"
  33. #ifdef STORAGE
  34. #include "storage.h"
  35. #endif
  37. /*----------------------------------------------------------------------
  38.   Preprocessor Definitions
  39. ----------------------------------------------------------------------*/
  40. #ifdef SC_SCAN
  41. /* --- character classes --- */
  42. #define C_ILLEGAL    0          /* illegal character */
  43. #define C_SPACE      1          /* white space, e.g. ' ' 't' 'n' */
  44. #define C_LETTER     2          /* letter or underscore '_' */
  45. #define C_DIGIT      3          /* digit */
  46. #define C_POINT      4          /* point, '.' */
  47. #define C_SIGN       5          /* sign,  '+' or '-' */
  48. #define C_SLASH      6          /* slash, '/' */
  49. #define C_QUOTE      7          /* quote, e.g. '"' '`' */
  50. #define C_CMPOP      8          /* comparison operator, e.g. '<' */
  51. #define C_ACTIVE     9          /* active characters, e.g. ',' '(' */
  53. /* --- scanner states --- */
  54. #define S_SPACE      0          /* skipping white space */
  55. #define S_ID         1          /* reading identifier */
  56. #define S_NUMDIG     2          /* reading number, digit */
  57. #define S_NUMPT      3          /* reading number, decimal point */
  58. #define S_FRAC       4          /* reading number, digit and point */
  59. #define S_EXPIND     5          /* reading exponent, indicator */
  60. #define S_EXPSGN     6          /* reading exponent, sign */
  61. #define S_EXPDIG     7          /* reading exponent, digit */
  62. #define S_SIGN       8          /* sign read */
  63. #define S_CMPOP      9          /* reading comparison operator */
  64. #define S_STRING    10          /* reading quoted string */
  65. #define S_ESC       11          /* reading escaped character */
  66. #define S_OCT1      12          /* reading octal  number, 1 digit */
  67. #define S_OCT2      13          /* reading octal  number, 2 digits */
  68. #define S_HEX1      14          /* reading hexad. number, 1 digit */
  69. #define S_HEX2      15          /* reading hexad. number, 2 digits */
  70. #define S_SLASH     16          /* slash read */
  71. #define S_CPPCOM    17          /* reading C++ comment */
  72. #define S_CCOM1     18          /* reading C comment */
  73. #define S_CCOM2     19          /* reading C comment, possible end */
  74. #define S_CCOM3     20          /* reading C comment, possible start */
  76. /* --- functions --- */
  77. #define UNGETC(s,c)  do { if ((c) ==  EOF) break; 
  78.                           if ((c) == 'n') (s)->line--; 
  79.                           ungetc(c, (s)->file); } while (0)
  81. /* --- additional error codes --- */
  82. #define E_UNKNOWN   (-11)       /* unknown error */
  83. #define MSGOFFSET   (-16)       /* offset for add. error messages */
  85. /* --- texts --- */
  86. #ifdef GERMAN                   /* deutsche Texte */
  87. #define FILETXT     "Datei"
  88. #define LINETXT     "Zeile"
  89. #else                           /* English texts */
  90. #define FILETXT     "file"
  91. #define LINETXT     "line"
  92. #endif  /* #ifdef GERMAN .. #else .. */
  93. #endif  /* #ifdef SC_SCAN */
  95. /*----------------------------------------------------------------------
  96.   Constants
  97. ----------------------------------------------------------------------*/
  98. static const char _scftab[256] = {  /* scanable form classes */
  99.         /* NUL  SOH  STX  ETX  EOT  ENQ  ACK  BEL */
  100. /* 00 */    2,   2,   2,   2,   2,   2,   2,  'a',
  101.         /*  BS   HT   LF   VT   FF   CR   SO   SI */
  102.            'b', 't', 'n', 'v', 'f', 'r',  2,   2,
  103.         /* DLE  DC1  DC2  DC3  DC4  NAK  SYN  ETB */
  104. /* 10 */    2,   2,   2,   2,   2,   2,   2,   2,
  105.         /* CAN   EM  SUB  ESC   FS   GS   RS   US */
  106.             2,   2,   2,   2,   2,   2,   2,   2,
  107.         /* ' '  '!'  '"'  '#'  '$'  '%'  '&'  ''' */
  108. /* 20 */    1,   1,  '"',  1,   1,   1,   1,   1,
  109.         /* '('  ')'  '*'  '+'  ','  '-'  '.'  '/' */
  110.             1,   1,   1,   0,   1,   0,   0,   1,
  111.         /* '0'  '1'  '2'  '3'  '4'  '5'  '6'  '7' */
  112. /* 30 */    0,   0,   0,   0,   0,   0,   0,   0,
  113.         /* '8'  '9'  ':'  ';'  '<'  '='  '>'  '?' */
  114.             0,   0,   1,   1,   1,   1,   1,   1,
  115.         /* '@'  'A'  'B'  'C'  'D'  'E'  'F'  'G' */
  116. /* 40 */    1,   0,   0,   0,   0,   0,   0,   0,
  117.         /* 'H'  'I'  'J'  'K'  'L'  'M'  'N'  'O' */
  118.             0,   0,   0,   0,   0,   0,   0,   0,
  119.         /* 'P'  'Q'  'R'  'S'  'T'  'U'  'V'  'W' */
  120. /* 50 */    0,   0,   0,   0,   0,   0,   0,   0,
  121.         /* 'X'  'Y'  'Z'  '['  ''  ']'  '^'  '_' */
  122.             0,   0,   0,   1, '\',  1,   1,   0,
  123.         /* '`'  'a'  'b'  'c'  'd'  'e'  'f'  'g' */
  124. /* 60 */    1,   0,   0,   0,   0,   0,   0,   0,
  125.         /* 'h'  'i'  'j'  'k'  'l'  'm'  'n'  'o' */
  126.             0,   0,   0,   0,   0,   0,   0,   0,
  127.         /* 'p'  'q'  'r'  's'  't'  'u'  'v'  'w' */
  128. /* 70 */    0,   0,   0,   0,   0,   0,   0,   0,
  129.         /* 'x'  'y'  'z'  '{'  '|'  '}'  '~'  DEL */
  130.             0,   0,   0,   1,   1,   1,   1,   2,
  131. /* 80 */    1,   1,   1,   1,   1,   1,   1,   1,
  132.             1,   1,   1,   1,   1,   1,   1,   1,
  133. /* 90 */    1,   1,   1,   1,   1,   1,   1,   1,
  134.             1,   1,   1,   1,   1,   1,   1,   1,
  135. /* a0 */    1,   1,   1,   1,   1,   1,   1,   1,
  136.             1,   1,   1,   1,   1,   1,   1,   1,
  137. /* b0 */    1,   1,   1,   1,   1,   1,   1,   1,
  138.             1,   1,   1,   1,   1,   1,   1,   1,
  139. /* c0 */    1,   1,   1,   1,   1,   1,   1,   1,
  140.             1,   1,   1,   1,   1,   1,   1,   1,
  141. /* d0 */    1,   1,   1,   1,   1,   1,   1,   1,
  142.             1,   1,   1,   1,   1,   1,   1,   1,
  143. /* e0 */    1,   1,   1,   1,   1,   1,   1,   1,
  144.             1,   1,   1,   1,   1,   1,   1,   1,
  145. /* f0 */    1,   1,   1,   1,   1,   1,   1,   1,
  146.             1,   1,   1,   1,   1,   1,   1,   1 };
  148. #ifdef SC_SCAN
  149. static const char _ccltab[256] = {  /* character classes */
  150.         /* NUL  SOH  STX  ETX  EOT  ENQ  ACK  BEL */
  151. /* 00 */    0,   0,   0,   0,   0,   0,   0,   0,
  152.         /*  BS   HT   LF   VT   FF   CR   SO   SI */
  153.             0,   1,   1,   1,   1,   1,   0,   0,
  154.         /* DLE  DC1  DC2  DC3  DC4  NAK  SYN  ETB */
  155. /* 10 */    0,   0,   0,   0,   0,   0,   0,   0,
  156.         /* CAN   EM  SUB  ESC   FS   GS   RS   US */
  157.             0,   0,   0,   0,   0,   0,   0,   0,
  158.         /* ' '  '!'  '"'  '#'  '$'  '%'  '&'  ''' */
  159. /* 20 */    1,   8,   7,   9,   9,   9,   9,   7,
  160.         /* '('  ')'  '*'  '+'  ','  '-'  '.'  '/' */
  161.             9,   9,   9,   5,   9,   5,   4,   6,
  162.         /* '0'  '1'  '2'  '3'  '4'  '5'  '6'  '7' */
  163. /* 30 */    3,   3,   3,   3,   3,   3,   3,   3,
  164.         /* '8'  '9'  ':'  ';'  '<'  '='  '>'  '?' */
  165.             3,   3,   9,   9,   8,   8,   8,   9,
  166.         /* '@'  'A'  'B'  'C'  'D'  'E'  'F'  'G' */
  167. /* 40 */    0,   2,   2,   2,   2,   2,   2,   2,
  168.         /* 'H'  'I'  'J'  'K'  'L'  'M'  'N'  'O' */
  169.             2,   2,   2,   2,   2,   2,   2,   2,
  170.         /* 'P'  'Q'  'R'  'S'  'T'  'U'  'V'  'W' */
  171. /* 50 */    2,   2,   2,   2,   2,   2,   2,   2,
  172.         /* 'X'  'Y'  'Z'  '['  ''  ']'  '^'  '_' */
  173.             2,   2,   2,   9,   9,   9,   9,   2,
  174.         /* '`'  'a'  'b'  'c'  'd'  'e'  'f'  'g' */
  175. /* 60 */    7,   2,   2,   2,   2,   2,   2,   2,
  176.         /* 'h'  'i'  'j'  'k'  'l'  'm'  'n'  'o' */
  177.             2,   2,   2,   2,   2,   2,   2,   2,
  178.         /* 'p'  'q'  'r'  's'  't'  'u'  'v'  'w' */
  179. /* 70 */    2,   2,   2,   2,   2,   2,   2,   2,
  180.         /* 'x'  'y'  'z'  '{'  '|'  '}'  '~'  DEL */
  181.             2,   2,   2,   9,   9,   9,   9,   0,
  182. /* 80 */    0,   0,   0,   0,   0,   0,   0,   0,
  183.             0,   0,   0,   0,   0,   0,   0,   0,
  184. /* 90 */    0,   0,   0,   0,   0,   0,   0,   0,
  185.             0,   0,   0,   0,   0,   0,   0,   0,
  186. /* a0 */    0,   0,   0,   0,   0,   0,   0,   0,
  187.             0,   0,   0,   0,   0,   0,   0,   0,
  188. /* b0 */    0,   0,   0,   0,   0,   0,   0,   0,
  189.             0,   0,   0,   0,   0,   0,   0,   0,
  190. /* c0 */    0,   0,   0,   0,   0,   0,   0,   0,
  191.             0,   0,   0,   0,   0,   0,   0,   0,
  192. /* d0 */    0,   0,   0,   0,   0,   0,   0,   0,
  193.             0,   0,   0,   0,   0,   0,   0,   0,
  194. /* e0 */    0,   0,   0,   0,   0,   0,   0,   0,
  195.             0,   0,   0,   0,   0,   0,   0,   0,
  196. /* f0 */    0,   0,   0,   0,   0,   0,   0,   0,
  197.             0,   0,   0,   0,   0,   0,   0,   0 };
  199. #ifdef GERMAN                      /* deutsche Texte */
  200. static const char *_errmsgs[] = {  /* error messages */
  201.   /* E_NONE      0 */  "kein Fehler",
  202.   /* E_NOMEM    -1 */  "nicht genug Speicher",
  203.   /* E_FOPEN    -2 */  "謋fnen fehlgeschlagen",
  204.   /* E_FREAD    -3 */  "Lesefehler",
  205.   /* E_FWRITE   -4 */  "Schreibfehler",
  206.   /* E_ILLCHR   -5 */  "ung黮tiges Zeichen '%c' (0x%02x)",
  207.   /* E_BUFOVF   -6 */  "Puffer黚erlauf",
  208.   /* E_UNTSTR   -7 */  "unbeendete Zeichenkette",
  209.   /* E_UNTCOM   -8 */  "unerwartetes Dateiende in Kommentar "
  210.                        "(Anfang in Zeile %d)",
  211.   /* E_STATE    -9 */  "ung黮tiger Scannerzustand",
  212.   /* E_GARBAGE -10 */  "ung黮tiger Text am Dateiende",
  213.   /* E_UNKNOWN -11 */  "unbekannter Fehler"
  214. };
  215. #else                              /* English texts */
  216. static const char *_errmsgs[] = {  /* error messages */
  217.   /* E_NONE      0 */  "no error",
  218.   /* E_NOMEM    -1 */  "not enough memory",
  219.   /* E_FOPEN    -2 */  "file open failed",
  220.   /* E_FREAD    -3 */  "file read failed",
  221.   /* E_FWRITE   -4 */  "file write failed",
  222.   /* E_ILLCHR   -5 */  "illegal character '%c' (0x%02x)",
  223.   /* E_BUFOVF   -6 */  "scan buffer overflow",
  224.   /* E_UNTSTR   -7 */  "unterminated string",
  225.   /* E_UNTCOM   -8 */  "unexpected end of file in comment "
  226.                        "started on line %d",
  227.   /* E_STATE    -9 */  "illegal scanner state",
  228.   /* E_GARBAGE -10 */  "garbage at end of file",
  229.   /* E_UNKNOWN -11 */  "unknown error"
  230. };
  231. #endif  /* #ifdef GERMAN .. #else .. */
  232. #endif  /* #ifdef SC_SCAN */
  234. /*----------------------------------------------------------------------
  235.   Auxiliary Functions
  236. ----------------------------------------------------------------------*/
  237. #ifdef SC_SCAN
  239. static int _swap (SCAN *scan)
  240. {                               /* --- swap token information */
  241.   int t;                        /* swap buffer */
  243.   if (scan->value == scan->buf[0]) scan->value = scan->buf[1];
  244.   else                             scan->value = scan->buf[0];
  245.   t = scan->plen;   scan->plen   = scan->len;   scan->len   = t;
  246.   t = scan->pline;  scan->pline  = scan->line;  scan->line  = t;
  247.   t = scan->ptoken; scan->ptoken = scan->token; scan->token = t;
  248.   return t;                     /* return the new token */
  249. }  /* _swap() */
  251. #endif
  252. /*----------------------------------------------------------------------
  253.   Main Functions
  254. ----------------------------------------------------------------------*/
  256. int sc_fmtlen (const char *s, int *len)
  257. {                               /* --- length of a formatted name */
  258.   int n = 0, k = 0;             /* number of (additional) characters */
  259.   int q = 0;                    /* quote flag (default: no quotes) */
  261.   assert(s);                    /* check the function arguments */
  262.   while (*s) {                  /* while not at end of name */
  263.     n++;                        /* count character */
  264.     switch (_scftab[(unsigned char)*s++]) {
  265.       case  0:                break;
  266.       case  1:         q = 2; break;
  267.       case  2: k += 3; q = 2; break;
  268.       default: k += 1; q = 2; break;
  269.     }                           /* sum additional characters and */
  270.   }                             /* set quote flag (if necessary) */
  271.   if (len) *len = n;            /* store normal length and */
  272.   return n +k +q;               /* return length of scanable form */
  273. }  /* sc_fmtlen() */
  275. /*--------------------------------------------------------------------*/
  277. int sc_format (char *dst, const char *src, int quotes)
  278. {                               /* --- format name in scanable form */
  279.   char *d; const char *s;       /* to traverse buffer and name */
  280.   int  c, cls;                  /* character and character class */
  281.   int  t;                       /* temporary buffer */
  283.   assert(dst && src);           /* check the function arguments */
  284.   if (!*src) quotes = 1;        /* an empty name needs quotes */
  285.   if (!quotes) {                /* if quotes are not mandatory, */
  286.     for (s = src; *s; )         /* traverse the string to convert */
  287.       if (_scftab[(unsigned char)*s++] != 0) {
  288.         quotes = 1; break; }    /* if a character needs quotes, */
  289.   }                             /* set the quotes flag and abort */
  290.   d = dst;                      /* get the destination and */
  291.   if (quotes) *d++ = '"';       /* store a quote if necessary */
  292.   while (*src) {                /* traverse the characters */
  293.     c   = (unsigned char)*src++;/* get the next character */
  294.     cls = _scftab[c];           /* and its character class */
  295.     if      (cls < 2)           /* if it is a normal character, */
  296.       *d++ = c;                 /* just store it */
  297.     else if (cls > 2) {         /* if it is an ANSI escape character, */
  298.       *d++ = '\'; *d++ = cls;} /* store it as 'c' */
  299.     else {                      /* if it is any other character */
  300.       *d++ = '\'; *d++ = 'x';
  301.       t = c >> 4;  *d++ = (t > 9) ? (t -10 +'a') : (t +'0');
  302.       t = c & 0xf; *d++ = (t > 9) ? (t -10 +'a') : (t +'0');
  303.     }                           /* store the character code */
  304.   }                             /* as a hexadecimal number */
  305.   if (quotes) *d++ = '"';       /* store the closing quote */
  306.   *d = '';                    /* and terminate the string */
  307.   return (int)(d -dst);         /* return the length of the result */
  308. }  /* sc_format() */
  310. /*--------------------------------------------------------------------*/
  311. #ifdef SC_SCAN
  313. SCAN* sc_create (const char *fname)
  314. {                               /* --- create a scanner */
  315.   const char *fn = fname;       /* buffer for filename */
  316.   SCAN       *scan;             /* created scanner */
  318.   if (!fn || !*fn) fname = "<stdin>";
  319.   scan = (SCAN*)malloc(sizeof(SCAN) +strlen(fname));
  320.   if (!scan) return NULL;       /* allocate memory for a scanner */
  321.   strcpy(scan->fname, fname);   /* and note the file name */
  322.   if (!fn || !*fn)              /* if no file name is given, */
  323.     scan->file = stdin;         /* read from standard input */
  324.   else {                        /* if a  file name is given, */
  325.     scan->file = fopen(fn,"r"); /* open the file for reading */
  326.     if (!scan->file) { free(scan); return NULL; }
  327.   }
  328.   scan->line    = 1;            /* initialize the fields */
  329.   scan->token   = scan->len   = scan->start = 0;
  330.   scan->value   = scan->buf[0]; scan->buf[0][0] = '';
  331.   scan->back    = 0;
  332.   scan->errfile = stderr;
  333.   scan->msgcnt  = scan->lncnt = 0;
  334.   scan->msgs    = NULL;
  335.   return scan;                  /* return created scanner */
  336. }  /* sc_create() */
  338. /*--------------------------------------------------------------------*/
  340. void sc_delete (SCAN *scan)
  341. {                               /* --- delete a scanner */
  342.   if (scan->file != stdin) fclose(scan->file);
  343.   free(scan);                   /* close the input file and */
  344. }  /* sc_delete() */            /* delete the scanner structure */
  346. /*--------------------------------------------------------------------*/
  348. int sc_next (SCAN *scan)
  349. {                               /* --- get next token */
  350.   int  c, ccl;                  /* character and character class */
  351.   int  quote = 0;               /* quote at the start of a string */
  352.   int  ec    = 0;               /* escaped character */
  353.   int  state = 0;               /* state of automaton */
  354.   int  level = 0;               /* comment nesting level */
  355.   char *p;                      /* to traverse the scan buffer */
  356.   char *end;                    /* end of the scan buffer */
  358.   if (scan->back) {             /* if a step backwards has been made, */
  359.     scan->back = 0;             /* clear the corresponding flag, */
  360.     return _swap(scan);         /* swap back the token information, */
  361.   }                             /* and return the current token */
  362.   scan->pline  = scan->line;    /* note the relevant information */
  363.   scan->ptoken = scan->token;   /* of the current token */
  364.   scan->plen   = scan->len;     /* and swap scan buffers */
  365.   if (scan->value == scan->buf[0]) scan->value = p = scan->buf[1];
  366.   else                             scan->value = p = scan->buf[0];
  367.   end = p +SC_BUFSIZE -1;       /* get the end of the scan buffer */
  369.   while (1) {                   /* read loop */
  370.     c   = getc(scan->file);     /* get character and character class */
  371.     ccl = (c < 0) ? EOF : _ccltab[c];
  372.     if (c == 'n') scan->line++; /* count the line */
  374.     switch (state) {            /* evaluate state of automaton */
  376.       case S_SPACE:             /* --- skip white space */
  377.         switch (ccl) {          /* evaluate character category */
  378.           case C_SPACE : /* do nothing */             break;
  379.           case C_LETTER: *p++  = c; state = S_ID;     break;
  380.           case C_DIGIT : *p++  = c; state = S_NUMDIG; break;
  381.           case C_POINT : *p++  = c; state = S_NUMPT;  break;
  382.           case C_SIGN  : *p++  = c; state = S_SIGN;   break;
  383.           case C_CMPOP : *p++  = c; state = S_CMPOP;  break;
  384.           case C_QUOTE : quote = c; state = S_STRING; break;
  385.           case C_SLASH :            state = S_SLASH;  break;
  386.           case C_ACTIVE: *p++  = c; *p = ''; scan->len = 1;
  387.                          return scan->token = c;
  388.           case EOF     : strcpy(p, "<eof>");   scan->len = 4;
  389.                          return scan->token = (ferror(scan->file))
  390.                                            ? E_FREAD : T_EOF;
  391.           default      : *p++  = c; *p = ''; scan->len = 1;
  392.                          return scan->token = E_ILLCHR;
  393.         } break;
  395.       case S_ID:                /* --- identifier (letter read) */
  396.         if ((ccl == C_LETTER)   /* if another letter */
  397.         ||  (ccl == C_DIGIT)    /* or a digit */
  398.         ||  (ccl == C_POINT)    /* or a decimal point */
  399.         ||  (ccl == C_SIGN)) {  /* or a sign follows */
  400.           if (p >= end) return scan->token = E_BUFOVF;
  401.           *p++ = c; break;      /* buffer character */
  402.         }                       /* otherwise */
  403.         UNGETC(scan, c);        /* put back last character, */
  404.         *p = '';              /* terminate string in buffer */
  405.         scan->len = (int)(p -scan->value); /* set string length */
  406.         return scan->token = T_ID;   /* and return 'identifier' */
  408.       case S_NUMDIG:            /* --- number (digit read) */
  409.         if (p < end) *p++ = c;  /* buffer character */
  410.         else return scan->token = E_BUFOVF;
  411.         if  (ccl == C_DIGIT)    /* if another digit follows, */
  412.           break;                /* do nothing */
  413.         if  (ccl == C_POINT) {  /* if a decimal point follows, */
  414.           state = S_FRAC;   break; } /* go to 'fraction' state */
  415.         if ((c == 'e')          /* if an exponent indicator follows */
  416.         ||  (c == 'E')) {       /* (lower- or uppercase), */
  417.           state = S_EXPIND; break; } /* go to 'exponent' state */
  418.         if ((ccl == C_LETTER)   /* if a letter */
  419.         ||  (ccl == C_SIGN)) {  /* or a sign follows, */
  420.           state = S_ID; break;  /* go to 'identifier' state */
  421.         }                       /* otherwise */
  422.         UNGETC(scan, c);        /* put back last character, */
  423.         *--p = '';            /* terminate string in buffer */
  424.         scan->len = (int)(p -scan->value); /* set string length */
  425.         return scan->token = T_NUM;      /* and return 'number' */
  427.       case S_NUMPT:             /* --- number (point read) */
  428.         if (p < end) *p++ = c;  /* buffer character */
  429.         else return scan->token = E_BUFOVF;
  430.         if  (ccl == C_DIGIT) {       /* if a digit follows, */
  431.           state = S_FRAC; break; }   /* go to 'fraction' state */
  432.         if ((ccl == C_LETTER)   /* if a letter */
  433.         ||  (ccl == C_POINT)    /* or a decimal point */
  434.         ||  (ccl == C_SIGN)) {  /* or a sign follows */
  435.           state = S_ID; break;  /* go to 'identifier' state */
  436.         }                       /* otherwise */
  437.         UNGETC(scan, c);        /* put back last character, */
  438.         *--p = '';            /* terminate string in buffer */
  439.         scan->len = (int)(p -scan->value); /* set string length */
  440.         return scan->token = T_ID;   /* and return 'identifier' */
  442.       case S_FRAC:              /* --- number (digit & point read) */
  443.         if (p < end) *p++ = c;  /* buffer character */
  444.         else return scan->token = E_BUFOVF;
  445.         if  (ccl == C_DIGIT)    /* if another digit follows, */
  446.           break;                /* do nothing else */
  447.         if ((c == 'e')          /* if an exponent indicator follows, */
  448.         ||  (c == 'E')) {       /* (lower- or uppercase), */
  449.           state = S_EXPIND; break; } /* go to exponent state */
  450.         if ((ccl == C_LETTER)   /* if a letter */
  451.         ||  (ccl == C_POINT)    /* or a decimal point */
  452.         ||  (ccl == C_SIGN)) {  /* or a sign follows, */
  453.           state = S_ID; break;  /* go to 'identifier' state */
  454.         }                       /* otherwise */
  455.         UNGETC(scan, c);        /* put back last character, */
  456.         *--p = '';            /* terminate string in buffer */
  457.         scan->len = (int)(p -scan->value); /* set string length */
  458.         return scan->token = T_NUM;      /* and return 'number' */
  460.       case S_EXPIND:            /* --- exponent (indicator read) */
  461.         if (p < end) *p++ = c;  /* buffer character */
  462.         else return scan->token = E_BUFOVF;
  463.         if  (ccl == C_SIGN) {        /* if a sign follows, */
  464.           state = S_EXPSGN; break; } /* go to 2nd 'exponent' state */
  465.         if  (ccl == C_DIGIT) {       /* if a digit follows, */
  466.           state = S_EXPDIG; break; } /* go to 3rd 'exponent' state */
  467.         if ((ccl == C_LETTER)   /* if a letter */
  468.         ||  (ccl == C_POINT)) { /* or a decimal point follows */
  469.           state = S_ID; break;  /* go to 'identifier' state */
  470.         }                       /* otherwise */
  471.         UNGETC(scan, c);        /* put back last character, */
  472.         *--p = '';            /* terminate string in buffer */
  473.         scan->len = (int)(p -scan->value); /* set string length */
  474.         return scan->token = T_ID;   /* and return 'identifier' */
  476.       case S_EXPSGN:            /* --- exponent (sign read) */
  477.         if (p < end) *p++ = c;  /* buffer character */
  478.         else return scan->token = E_BUFOVF;
  479.         if  (ccl == C_DIGIT) {      /* if a digit follows, */
  480.           state = S_EXPDIG; break;} /* do nothing else */
  481.         if ((ccl == C_LETTER)   /* if a letter */
  482.         ||  (ccl == C_POINT)    /* or a decimal point */
  483.         ||  (ccl == C_SIGN)) {  /* or a sign follows */
  484.           state = S_ID; break;  /* go to 'identifier' state */
  485.         }                       /* otherwise */
  486.         UNGETC(scan, c);        /* put back last character, */
  487.         *--p = '';            /* terminate string in buffer */
  488.         scan->len = (int)(p -scan->value); /* set string length */
  489.         return scan->token = T_ID;   /* and return 'identifier' */
  491.       case S_EXPDIG:            /* --- exponent (digit read) */
  492.         if (p < end) *p++ = c;  /* buffer character */
  493.         else return scan->token = E_BUFOVF;
  494.         if  (ccl == C_DIGIT)    /* if another digit follows, */
  495.           break;                /* do nothing else */
  496.         if ((ccl == C_LETTER)   /* if a letter */
  497.         ||  (ccl == C_POINT)    /* or a decimal point */
  498.         ||  (ccl == C_SIGN)) {  /* or a sign follows, */
  499.           state = S_ID; break;  /* go to 'identifier' state */
  500.         }                       /* otherwise */
  501.         UNGETC(scan, c);        /* put back last character, */
  502.         *--p = '';            /* terminate string in buffer */
  503.         scan->len = (int)(p -scan->value); /* set string length */
  504.         return scan->token = T_NUM;      /* and return 'number' */
  506.       case S_SIGN:              /* --- number (sign read) */
  507.         *p++ = c;               /* buffer character */
  508.         if  (ccl == C_DIGIT) {       /* if a digit follows, */
  509.           state = S_NUMDIG; break; } /* go to 'number' state */
  510.         if  (ccl == C_POINT) {       /* if a decimal point follows, */
  511.           state = S_NUMPT; break; }  /* go to fraction state */
  512.         if ((ccl == C_LETTER)        /* if a letter */
  513.         ||  (ccl == C_SIGN)) {       /* or a sign follows, */
  514.           state = S_ID; break; }     /* go to 'identifier' state */
  515.         if ((c == '>')          /* if a '>' follows and previous */
  516.         &&  (scan->value[0] == '-')) {   /* char was a minus sign */
  517.           *p = ''; scan->len = 2; return scan->token = T_RGT; }
  518.         UNGETC(scan, c);        /* otherwise put back last character, */
  519.         *--p = '';            /* terminate string in buffer */
  520.         scan->len = (int)(p -scan->value); /* set string length */
  521.         return scan->token = T_ID;   /* and return 'identifier' */
  523.       case S_CMPOP:             /* --- comparison operator read */
  524.         if ((c == '-')          /* if a minus sign follows and */
  525.         &&  (scan->value[0] == '<')) {  /* prev. char was a '<' */
  526.           *p++ = '-';       scan->token = T_LFT; }
  527.         else if (c == '=') {    /* if an equal sign follows */
  528.           *p++ = '=';       scan->token = T_CMP; }
  529.         else {                  /* if anything else follows */
  530.           UNGETC(scan, c);  scan->token = scan->value[0]; }
  531.         *p = '';              /* terminate string in buffer */
  532.         scan->len = (int)(p -scan->value); /* set string length */
  533.         return scan->token;        /* and return the token read */
  535.       case S_STRING:            /* --- quoted string */
  536.         if ((c == 'n') || (c == EOF))  /* if end of line or file, */
  537.           return scan->token = E_UNTSTR;   /* string is unterminated */
  538.         if (c != quote) {       /* if not at end of string */
  539.           if (p >= end) return scan->token = E_BUFOVF;
  540.           if (c == '\') {      /* if escaped character follows, */
  541.             state = S_ESC; break; }  /* go to escaped char state */
  542.           *p++ = c; break;      /* otherwise buffer character */
  543.         }                       /* if at end of string, */
  544.         *p = '';              /* terminate string in buffer */
  545.         scan->len = (int)(p -scan->value); /* set string length */
  546.         return scan->token = T_ID;   /* and return 'identifier' */
  548.       case S_ESC:               /* --- after '' in quoted string */
  549.         if ((c >= '0') && (c <= '7')) {        /* if octal digit, */
  550.           ec = c -'0'; state = S_OCT1; break; }/* evaluate digit  */
  551.         if (c == 'x') {         /* if hexadecimal character code, */
  552.           state = S_HEX1; break;} /* go to hexadecimal evaluation */
  553.         switch (c) {            /* evaluate character after '' */
  554.           case  'a': c = 'a'; break;
  555.           case  'b': c = 'b'; break;
  556.           case  'f': c = 'f'; break;
  557.           case  'n': c = 'n'; break;
  558.           case  'r': c = 'r'; break;
  559.           case  't': c = 't'; break;
  560.           case  'v': c = 'v'; break;
  561.           case 'n': c = -1;   break;
  562.           default  :           break;
  563.         }                       /* get escaped character */
  564.         if (c >= 0) *p++ = c;   /* and store it, then */
  565.         state = S_STRING; break;/* return to quoted string state */
  567.       case S_OCT1:              /* --- escaped octal number 1 */
  568.         if ((c >= '0')          /* if an octal digit follows, */
  569.         &&  (c <= '7')) {       /* evaluate it */
  570.           ec = ec *8 +c -'0'; state = S_OCT2; break; }
  571.         UNGETC(scan, c);        /* otherwise put back last character */
  572.         *p++  = ec;             /* store escaped character and */
  573.         state = S_STRING; break;/* return to quoted string state */
  575.       case S_OCT2:              /* --- escaped octal number 2 */
  576.         if ((c >= '0') || (c <= '7'))
  577.           ec = ec *8 +c -'0';   /* if octal digit, evaluate it */
  578.         else UNGETC(scan, c);   /* otherwise put back last character */
  579.         *p++  = ec;             /* store escaped character and */
  580.         state = S_STRING; break;/* return to quoted string state */
  582.       case S_HEX1:              /* --- escaped hexadecimal number 1 */
  583.         if (ccl == C_DIGIT) {   /* if hexadecimal digit, evaluate it */
  584.           ec = c -'0';     state = S_HEX2; break; }
  585.         if ((c >= 'a') && (c <= 'f')) {
  586.           ec = c -'a' +10; state = S_HEX2; break; }
  587.         if ((c >= 'A') && (c <= 'F')) {
  588.           ec = c -'A' +10; state = S_HEX2; break; }
  589.         UNGETC(scan, c);        /* otherwise put back last character */
  590.         *p++  = 'x';            /* store escaped character ('x') and */
  591.         state = S_STRING; break;/* return to quoted string state */
  593.       case S_HEX2:              /* --- escaped hexadecimal number 2 */
  594.         if (ccl == C_DIGIT)     /* if hexadecimal digit, evaluate it */
  595.           ec = ec*16 +c -'0';
  596.         else if ((c >= 'a') && (c <= 'f'))
  597.           ec = ec*16 +c -'a' +10;
  598.         else if ((c >= 'A') && (c <= 'F'))
  599.           ec = ec*16 +c -'A' +10;
  600.         else UNGETC(scan, c);   /* otherwise put back last character */
  601.         *p++  = ec;             /* store escaped character and */
  602.         state = S_STRING; break;/* return to quoted string state */
  604.       case S_SLASH:             /* --- slash '/' */
  605.         if (c == '/') {         /* if C++ style comment, then */
  606.           state = S_CPPCOM; break; }   /* skip to end of line */
  607.         if (c == '*') {         /* if C style comment */
  608.           scan->start = scan->line; level = 1;
  609.           state = S_CCOM1; break;    /* note start line, init. level */
  610.         }                       /* and go to first 'comment' state */
  611.         UNGETC(scan, c);        /* otherwise put back last character */
  612.         *p++ = '/'; *p = '';  /* store character in buffer */
  613.         scan->len = 1;          /* set string length and */
  614.         return scan->token = '/';  /* return `character' */
  616.       case S_CPPCOM:            /* --- C++ style comment */
  617.         if ((c == 'n')         /* if at end of line */
  618.         ||  (c == EOF))         /* or at end of file */
  619.           state = S_SPACE;      /* return to white space skipping */
  620.         break;                  /* (skip to end of line) */
  622.       case S_CCOM1:             /* --- C style comment 1 */
  623.         if      (c == EOF)      /* if end of file, abort */
  624.           return scan->token = E_UNTCOM;
  625.         if      (c == '*')      /* if possibly 'end of comment', */
  626.           state = S_CCOM2;      /* go to 2nd 'comment' state */
  627.         else if (c == '/')      /* if possibly 'start of comment', */
  628.           state = S_CCOM3;      /* go to 3rd 'comment' state */
  629.         break;
  631.       case S_CCOM2:             /* --- C style comment 2 */
  632.         if      (c == EOF)      /* if end of file, abort */
  633.           return scan->token = E_UNTCOM;
  634.         if      (c == '/') {    /* if end of comment found */
  635.           if (--level <= 0) state = S_SPACE;
  636.           else              state = S_CCOM1; }
  637.         else if (c != '*')      /* if end of comment impossible */
  638.           state = S_CCOM1;      /* return to comment skipping */
  639.         break;                  /* (possible start of comment) */
  641.       case S_CCOM3:             /* --- C style comment 3 */
  642.         if      (c == EOF)      /* if end of file, abort */
  643.           return scan->token = E_UNTCOM;
  644.         if      (c == '*') {    /* if start of comment found */
  645.           level++; state = S_CCOM1; }
  646.         else if (c != '/')      /* if start of comment impossible */
  647.           state = S_CCOM1;      /* return to comment skipping */
  648.         break;                  /* (possible end of comment) */
  650.       default:                  /* if state is illegal, abort */
  651.         return scan->token = E_STATE;
  653.     }  /* switch() */
  654.   }  /* while(1) */
  655. }  /* sc_next() */
  657. /*--------------------------------------------------------------------*/
  659. int sc_nexter (SCAN *scan)
  660. {                               /* --- get next token error reporting */
  661.   if (sc_next(scan) < 0) return sc_error(scan, scan->token);
  662.   return scan->token;           /* get next token, report error, */
  663. }  /* sc_nexter() */            /* and return next token */
  665. /*--------------------------------------------------------------------*/
  667. int sc_back (SCAN *scan)
  668. {                               /* --- go back one token */
  669.   if (scan->back)               /* a second step backwards */
  670.     return scan->token;         /* is impossible, so do nothing */
  671.   scan->back = -1;              /* set the step backward flag */
  672.   return _swap(scan);           /* swap the token information */
  673. }  /* sc_back() */              /* and return the previous token */
  675. /*--------------------------------------------------------------------*/
  677. int sc_eof (SCAN *scan)
  678. {                               /* --- check for end of file */
  679.   if (scan->token == T_EOF) return 1;
  680.   sc_error(scan, E_GARBAGE);    /* check for end of file */
  681.   return 0;                     /* and report an error */
  682. }  /* sc_eof() */               /* if it is not reached */
  684. /*--------------------------------------------------------------------*/
  686. int sc_recover (SCAN *scan, int stop, int beg, int end, int level)
  687. {                               /* --- recover from an error */
  688.   while ((scan->token != stop)     /* while at stop token */
  689.   &&     (scan->token != T_EOF)) { /* and not at end of file */
  690.     if       (scan->token == beg)  /* if begin level token found, */
  691.       level++;                     /* increment level counter */
  692.     else if ((scan->token == end)  /* if end level token found */
  693.     &&       (--level    <= 0))    /* and on level to return to, */
  694.       break;                       /* abort loop */
  695.     if (sc_next(scan) < 0) return scan->token;
  696.   }                             /* consume token */
  697.   if (scan->token != T_EOF)     /* if not at end of file, */
  698.     sc_next(scan);              /* consume token (stop or end) */
  699.   return scan->token;           /* return the next token */
  700. }  /* sc_recover() */
  702. /*--------------------------------------------------------------------*/
  704. void sc_errfile (SCAN *scan, FILE *file, int lncnt)
  705. {                               /* --- set file for error output */
  706.   assert(scan);                 /* check the function arguments */
  707.   scan->errfile = (file) ? file : stderr;
  708.   scan->lncnt   = lncnt;        /* set file and line count */
  709. }  /* sc_errfile() */
  711. /*--------------------------------------------------------------------*/
  713. void sc_errmsgs (SCAN *scan, const char *msgs[], int cnt)
  714. {                                /* --- set additonal error messages */
  715.   assert(scan);                  /* check the function arguments */
  716.   scan->msgs   = msgs;           /* note error message vector */
  717.   scan->msgcnt = cnt;            /* and number of error messages */
  718. }  /* sc_errmsgs() */
  720. /*--------------------------------------------------------------------*/
  722. int sc_error (SCAN *scan, int code, ...)
  723. {                               /* --- print an error message */
  724.   va_list    args;              /* variable argument list */
  725.   const char *msg;              /* error message */
  726.   int        c, pc;             /* the illegal character */
  727.   int        tmp;               /* temporary buffer */
  729.   assert(scan);                  /* check the function arguments */
  730.   if (scan->lncnt <= 0)         /* if line count is zero or negative, */
  731.     putc('n', scan->errfile);  /* start a new output line */
  732.   fprintf(scan->errfile, FILETXT" %s", scan->fname);
  733.                                 /* print the file name */
  734.   if ((code != E_NONE)          /* if an error occurred, */
  735.   &&  (code != E_FOPEN)         /* but not 'file open failed' */
  736.   &&  (code != E_UNTCOM)) {     /* and not 'unterminated comment' */
  737.     fputs((scan->lncnt > 2) ? ",n" : ", ", scan->errfile);
  738.     fprintf(scan->errfile, LINETXT" %d", scan->line);
  739.   }                             /* print line number */
  740.   fputs((scan->lncnt > 1) ? ":n" : ": ", scan->errfile);
  742.   if (code >= 0) code = E_NONE; /* check error code and */
  743.   tmp = MSGOFFSET -code;        /* get error message text */
  744.   if      (code > E_UNKNOWN)    msg = _errmsgs[-code];
  745.   else if (tmp  < scan->msgcnt) msg = scan->msgs[tmp];
  746.   else                          msg = NULL;
  747.   if (!msg) msg = _errmsgs[-(code = E_UNKNOWN)];
  749.   switch (code) {               /* special error handling */
  750.     case E_ILLCHR: c = pc = (unsigned char)scan->value[0];
  751.                    if (c < ' ') pc = ' ';
  752.                    fprintf (scan->errfile, msg, pc, c);       break;
  753.     case E_UNTCOM: fprintf (scan->errfile, msg, scan->start); break;
  754.     default      : va_start(args, code); /* get variable arguments */
  755.                    vfprintf(scan->errfile, msg, args);
  756.                    va_end(args); break;  /* print error message and */
  757.   }                             /* end variable argument evaluation */
  758.   if (scan->lncnt > 0)          /* if line count is positive, */
  759.     putc('n', scan->errfile);  /* terminate output line */
  760.   return code;                  /* return error code */
  761. }  /* sc_error() */
  763. #endif