home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / dos / math / pac / pactok.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-05  |  5.8 KB  |  225 lines
  1. /* pactok.c */
  2. /**********************************************************************
  3. *    File Name     : pactok.c
  4. *    Function      : pac calculator token recognizer
  5. *    Author        : Istvan Mohos, 1987
  6. ***********************************************************************/
  7.  
  8. #include "defs.h"
  9. #define PACTOK
  10. #include "toktab.h"
  11. #undef PACTOK
  12.  
  13. fill_spreadbuf(buffer)
  14. char *buffer;
  15. {
  16.     register char *bp = buffer;
  17.     register char *spr = Spreadbuf;
  18.     register char prev_c = '\0';
  19.     int first = 0;
  20.     static char *fid = "fill_spreadbuf";
  21.  
  22.     _TR
  23.     if (*bp == 42 || *bp == 43 || *bp == 45 || *bp == 47 || *bp == 94) {
  24.         *spr++ = '\\';
  25.         *spr++ = ' ';
  26.     }
  27.     while(*bp) {
  28.         if ((ispunct(*bp)    && *bp != '.'    && *bp != '_')   ||
  29.             (ispunct(prev_c) && prev_c != '.' && prev_c != '_'))
  30.             *spr++ = ' ';   /* insert an extra space for pactok */
  31.  
  32.         if (*bp == ';')
  33.             first = 1;
  34.         else if (first) {
  35.             if (*bp == 42 || *bp == 43 || *bp == 45 ||
  36.                 *bp == 47 || *bp == 94) {
  37.                 *spr++ = '\\';
  38.                 *spr++ = ' ';
  39.                 first = 0;
  40.             }
  41.             else if (!isspace(*bp))
  42.                 first = 0;
  43.         }
  44.  
  45.         *spr++ = *bp;
  46.         prev_c = *bp++;
  47.     }
  48.     *spr = '\0';
  49.     if (Hc != -1) {
  50.         *Tmpbuf = '\0';
  51.         if (Hf == FVER) {
  52.             strcpy(Tmpbuf,
  53. "--------------------------------------------");
  54.             spr = Tmpbuf + strlen(Tmpbuf);
  55.             if (Ibase != 10) {
  56.                 sprintf(spr, " [ibase: %d]", Ibase);
  57.                 spr = Tmpbuf + strlen(Tmpbuf);
  58.             }
  59.             if (Obase != 10) {
  60.                 sprintf(spr, " [obase: %d]", Obase);
  61.                 spr = Tmpbuf + strlen(Tmpbuf);
  62.             }
  63.             strcat(Tmpbuf, "\n");
  64.         }
  65.         else if (Hf == FTER)
  66.             strcpy(Tmpbuf, "===\n");
  67.     }
  68.     TR_
  69. }
  70.  
  71. place_pointers()
  72. {
  73.     register int ri, rj;
  74.     register char *cp;
  75.     int thisnum;
  76.     int prevnum;
  77.     static char *fid = "place_pointers";
  78.  
  79.     _TR
  80.     Tokp[0] = Mainbuf;
  81.     /* take space and comma, unrecognized tokens (digits) will be
  82.        automatically concatenated in Ubuf.
  83.        This permits user formatted input. */
  84.  
  85.     if ((Tokp[1] = pactok(Spreadbuf, " ,")) == ZERO)
  86.         strcpy(Spreadbuf, "\\");
  87.     else {
  88.         for (cp=Tokp[1], prevnum=1; *cp; cp++) {
  89.             if (! (isdigit(*cp) || (*cp == '.') ||
  90.                    (*cp >= 'a' && *cp <= 'f') ||
  91.                    (*cp >= 'A' && *cp <= 'F'))  ) {
  92.                 prevnum = 0;
  93.                 break;
  94.             }
  95.         }
  96.         ri = 1;
  97.         while ((Tokp[++ri] = pactok(ZERO, " ,")) != ZERO) {
  98.             for (cp=Tokp[ri], thisnum=1; *cp; cp++) {
  99.                 if (! (isdigit(*cp) || (*cp == '.') ||
  100.                        (*cp >= 'a' && *cp <= 'f') ||
  101.                        (*cp >= 'A' && *cp <= 'F'))  ) {
  102.                     thisnum = prevnum = 0;
  103.                     break;
  104.                 }
  105.             }
  106.             if (thisnum && prevnum) {
  107.                 strcat(Tokp[ri-1], Tokp[ri]);
  108.                 --ri;
  109.             }
  110.             if (thisnum)
  111.                 prevnum = 1;
  112.         }
  113.         Last = Tokp[ri];       /*  == ZERO */
  114.     }
  115.  
  116.     if (Hc != -1) {
  117.         if (Hf != FXTER) {
  118.             for (rj = 1; rj < ri;) {
  119.                 strcat(Tmpbuf, Tokp[rj++]);
  120.                 strcat(Tmpbuf, " ");
  121.             }
  122.             strcat(Tmpbuf, "\n");
  123.             rj = strlen(Tmpbuf);
  124.             if (write(Hc, Tmpbuf, rj) != rj)
  125.                 fatal("hardcopy format write");
  126.         }
  127.     }
  128.     TR_
  129.     return(ri); /* # of non-ZERO tokens, including Tokp[0] = Mainbuf */
  130. }
  131.  
  132. lookup(c_ptr)
  133. char *c_ptr;
  134. {
  135.     int inlist_val;
  136.     static char *fid = "lookup";
  137.  
  138.     _TR
  139.         if ((inlist_val = spacefill(c_ptr, WORDSIZE)) != -1)
  140.             inlist_val = mybsearch(Tokbuf, toklist, LISTSIZE);
  141.     TR_
  142.     return(inlist_val);
  143. }
  144.  
  145. char *
  146. pactok(s1, s2)
  147. char *s1, *s2;
  148. {
  149.     register i;
  150.     char *separator[128];
  151.     int sepcount, tok_flag;
  152.     static char *tokenp = ZERO, *parser = ZERO;
  153.     static char *fid = "pactok";
  154.  
  155.     _TR
  156.     if ((sepcount = strlen(s2)) == 0) {
  157.         TR_
  158.         return(ZERO);
  159.     }
  160.     if (s1 != ZERO)
  161.         tokenp = parser = s1;
  162.     for (i = sepcount; --i >= 0; separator[i] = s2 + i);
  163.  
  164.     /* move parser, tokenp to first non-separator character */
  165.     while (*parser != '\0') {
  166.         int sep_flag = 0;
  167.         for (i = sepcount; --i >= 0;)
  168.             if (*separator[i] == *parser) {
  169.                 ++parser;
  170.                 sep_flag = 1;
  171.                 break;
  172.             }
  173.         if (!sep_flag)
  174.             break;
  175.     }
  176.     tokenp = parser;
  177.     tok_flag = 0;
  178.  
  179.     /* move parser to first separator after token, replace value with '\0' */
  180.     while (*parser != '\0') {
  181.         int sep_flag = 0;
  182.         for (i = sepcount; --i >= 0;)
  183.             if (*separator[i] == *parser) {
  184.                 *parser++ = '\0';
  185.                 sep_flag = 1;
  186.                 break;
  187.             }
  188.         if (sep_flag)
  189.             break;
  190.         ++parser;
  191.         tok_flag = 1;
  192.     }
  193.  
  194.     if (tok_flag) {
  195.         TR_
  196.         return(tokenp);
  197.     }
  198.     TR_
  199.     return(ZERO);
  200. }
  201.  
  202. mybsearch (comparee, wordlist, listsize)
  203. char *comparee;
  204. char *wordlist[];
  205. {
  206.     register    m, mid, lo, hi;
  207.     static char *fid = "mybsearch";
  208.  
  209.     _TR
  210.     lo = 0, hi = listsize -1;
  211.     while (lo <= hi) {
  212.         mid = (lo + hi) >> 1;
  213.         if ((m = strcmp(comparee, wordlist[mid])) < 0)
  214.             hi = mid -1;
  215.         else if (m > 0)
  216.             lo = mid +1;
  217.         else {
  218.             TR_
  219.             return(mid);
  220.         }
  221.     }
  222.     TR_
  223.     return (-1);
  224. }
  225.