home *** CD-ROM | disk | FTP | other *** search
/ Amiga Elysian Archive / AmigaElysianArchive.iso / prog / c / cpp.lha / defmacio.c < prev    next >
C/C++ Source or Header  |  1991-04-15  |  12KB  |  483 lines
  1. /*
  2.  
  3.  
  4.  Copyright (C) 1990 Texas Instruments Incorporated.
  5.  
  6.  Permission is granted to any individual or institution to use, copy, modify,
  7.  and distribute this software, provided that this complete copyright and
  8.  permission notice is maintained, intact, in all copies and supporting
  9.  documentation.
  10.  
  11.  Texas Instruments Incorporated provides this software "as is" without
  12.  express or implied warranty.
  13.  
  14.  
  15.  *  
  16.  * Utility functions used by defmacros.
  17.  *
  18.  * Edit history
  19.  * Created: LGO 30-Mar-89 -- Initial design and implementation.
  20.  *
  21.  */
  22.  
  23. #include "defmacio.h"
  24.  
  25. /*
  26.  * Put a string in the input buffer used by getchar
  27.  * This lets us use scan_next for arbitrary strings.
  28.  */
  29. void set_inbuffer(instring)
  30.     char* instring;
  31. {
  32.   static FILEINFO inbuf = {0, 0, 0, 0, 0, 0, 0, 0};
  33.   inbuf.bptr = inbuf.buffer = instring;
  34.   MacInFile = &inbuf;
  35. }
  36.  
  37. /*
  38. // Skip whitespace characters and comments, returning the next character
  39. */
  40. char
  41. skip_blanks()
  42. {
  43.   register char c;
  44.  again:
  45.   while ((c = getchar()) != EOF && isspace(c));
  46.   if (c == '/') {
  47.     char nc = getchar();
  48.     if (nc == '/') {        /* If // comment, skip to end of line */
  49.       while ((c = getchar()) != EOF && c != '\n');
  50.       goto again;
  51.     } else if (nc == '*') {    /* If / * comment, skip to */
  52.       char p = getchar();
  53.       while ((c = getchar()) != EOF) {
  54.     if (c == '/' && p == '*') break;
  55.     p = c;
  56.       }
  57.       goto again;
  58.     } else            /* Else putback character after / */
  59.       unget();
  60.   } else if (c == '\\') {
  61.     char nc = getchar();
  62.     if (nc == '\n') goto again;          /* If \\\n, ignore */
  63.     unget();
  64.   }
  65.   return(c);
  66. }
  67.  
  68. /*
  69.  * Skip to next newline
  70.  */
  71. char
  72. skip_line()
  73. {
  74.   char c;
  75.   while ((c = getchar()) != EOF)
  76.     if (c == '\n') break;
  77.   return(c);
  78. }
  79.  
  80. /*
  81.  * Copy the next alphanumeric token
  82.  * the argument, str is a pointer to a string where the token is to be copied.
  83.  * Returns a pointer to the END of the token, which contains the NEXT character.
  84.  */
  85. char*
  86. copytoken(str)
  87.   char* str;
  88. {
  89.   int is_bad = TRUE;
  90.   char c = skip_blanks();
  91.   while (isalnum(c) ||
  92.      (c == '$') ||
  93.      (c == '_')) {
  94.     *str++ = c;
  95.     c = getchar();
  96.     is_bad = FALSE;
  97.   }
  98.   if(is_bad) {
  99.     if (c == EOF)
  100.       fprintf(stderr, "End of file while scanning for token\n");
  101.     else
  102.       fprintf(stderr, "Illegal character in token: '%c'\n", c);
  103.     return NULL;
  104.   }
  105.   unget();
  106.   *str = EOS;
  107.   return(str);
  108. }
  109.  
  110. STRING work_string = NULL;
  111.  
  112. static char*
  113. scan_next_string(delim)
  114.   char delim;                     /* Current delimiter */
  115. {
  116.   char c;                     /* Current character */
  117.   char p;                /* Previous character */
  118.   char* workp = work_string->buffp;    /* result buffer */
  119.   char* workend = work_string->buffend; /* end of result buffer */
  120.  
  121.   for (p = EOS; (c = getchar()) != EOF; p = c) {
  122.     if (workp >= workend-1) {
  123.       work_string->buffp = workp;
  124.       grow_STRING(work_string, 0);
  125.       workp = work_string->buffp;
  126.       workend = work_string->buffend;
  127.     }
  128.     *workp++ = c;
  129.     if (delim == c &&            /* Quit when delimeter found */
  130.     p != '\\' &&            /* and it's not quoted */
  131.     (delim != '/' || p == '*')) {     /* Special test for end of comment */
  132.       *workp = EOS;
  133.       work_string->buffp = workp;
  134.       return workp;
  135.     }
  136.   }
  137.   /* end of file when we get here */
  138.   *workp = EOS;
  139.   work_string->buffp = workp;
  140.   return workp;
  141. }
  142.  
  143.  
  144. char*
  145. scan_next_internal(delim, is_top_level)
  146.   char delim;                     /* Current delimiter */
  147.   int is_top_level;            /* flag */
  148. {
  149.   char newdelim;            /* New delimiter to look for */
  150.   int is_string = FALSE;        /* New is_string flag */
  151.   register char c;            /* Current character */
  152.   register char* workp = work_string->buffp;     /* result buffer */
  153.   register char* workend = work_string->buffend; /* end of result buffer */
  154.  
  155.   while ((c = getchar()) != EOF) {
  156.     if (workp >= workend-1) {
  157.       work_string->buffp = workp;
  158.       grow_STRING(work_string, 0);
  159.       workp = work_string->buffp;
  160.       workend = work_string->buffend;
  161.     }
  162.     *workp++ = c;
  163.     if (delim == c) {            /* Quit when delimeter found */
  164.       *workp = EOS;
  165.       work_string->buffp = workp;
  166.       return workp;
  167.     }
  168.     switch (c) {           /* Look for new delimeters when not is_string */
  169.     case '{':  newdelim = '}'; break;
  170.     case '[':  newdelim = ']'; break;
  171.     case '(':  newdelim = ')'; break;
  172.     case '<':
  173.       if (delim != '>')
  174.     continue;
  175.       newdelim = '>'; break;
  176.     case '\'':  newdelim = '\''; is_string = TRUE; break;
  177.     case '\"':  newdelim = '\"'; is_string = TRUE; break;
  178.     case '/':                  /* start of comment? */
  179.       c = getchar();
  180.       unget();
  181.       if (c == '/') {              /* standard comment */
  182.     newdelim = '\n';
  183.     is_string = TRUE;
  184.     break;
  185.       } else if (c == '*') {          /* c++ comment */
  186.     newdelim = '/';
  187.     is_string = TRUE;
  188.     break;
  189.       }
  190.       continue;
  191.     default:                  /* comma grabs args */
  192.       continue;
  193.     }                      /* end switch */
  194.     if (is_top_level && newdelim == delim) {
  195.       is_top_level = FALSE;
  196.       continue;        /* at top_level, with left side of delimiter */
  197.     }
  198.     work_string->buffp = workp;
  199.     if (is_string)
  200.       workp = scan_next_string(newdelim);
  201.     else
  202.       workp = scan_next_internal(newdelim, FALSE);
  203.     workend = work_string->buffend;
  204.     is_string = FALSE;
  205.   } /* end while */
  206.   /* end of file when we get here */
  207.   *workp = EOS;
  208.   work_string->buffp = workp;
  209.   return workp;
  210. } 
  211.  
  212. void scan_start() {
  213.   if(work_string == NULL)          /* Setup buffer */
  214.     work_string = make_STRING(4096);
  215.   work_string->buffp = work_string->buff;
  216. }
  217.  
  218. /*
  219.  * Get the next token, stopping at delim
  220.  */
  221. char* scan_next(delim)
  222.   char delim;                  /* delimiter */
  223. {
  224.   scan_start();
  225.   skip_blanks();            /* skip leading whitespace */
  226.   unget();
  227.   if (delim == ' ') {              /* ' ' means grab token */
  228.     work_string->buffp = copytoken(work_string->buffp);
  229.     if ((delim = getchar()) != '<') {      /* Grab <...> */
  230.       unget();
  231.     } else {
  232.       *work_string->buffp++ = delim;
  233.       scan_next_internal('>', FALSE);
  234.     }
  235.   } else {
  236.     scan_next_internal(delim, TRUE);
  237.   }
  238.   work_string->buffp++;
  239.   return work_string->buff;
  240. }
  241. /*
  242.  * Get the next token, stopping at delim
  243.  * Call scan_start before using this function
  244.  * The string returned is inside work_string, and
  245.  * will be clobbered on the next call to scan_start.
  246.  */
  247. char* scan_list(delim)
  248.   char delim;                  /* delimiter */
  249. {
  250.   unsigned int start = work_string->buffp - work_string->buff;
  251.   skip_blanks();            /* skip leading whitespace */
  252.   unget();
  253.   if (delim == ' ') {              /* ' ' means grab token */
  254.     if (work_string->buffend - work_string->buffp <= 128)
  255.       grow_STRING(work_string, 128);      /* Ensure at least 128 chars */
  256.     work_string->buffp = copytoken(work_string->buffp);
  257.   }
  258.   else
  259.     scan_next_internal(delim, TRUE);
  260.   work_string->buffp++;
  261.   return (work_string->buff+start);
  262. }
  263.  
  264. char*
  265. scan_token(delims)
  266.   char* delims;                  /* delimiters */
  267. {
  268.   register char* workp;
  269.   char* work;
  270.   register char c;
  271.   if(work_string == NULL)          /* Setup buffer */
  272.     work_string = make_STRING(3000);
  273.   workp = work_string->buff;
  274.   c = skip_blanks();            /* skip leading whitespace */
  275.   while(c != EOF) {
  276.     register char* p;
  277.     for(p=delims; *p!=EOS; p++)
  278.       if (*p == c) goto done;
  279.     *workp++ = c;
  280.     if (ispunct(c))            /* If {([<'" Use scan_next_internal */
  281.       for(p="{}()[]<>\'\'\"\""; *p!=EOS; p++)
  282.     if (*p++ == c) {
  283.       work_string->buffp = workp;
  284.       if (*p == '\'' || *p == '\"')
  285.         workp = scan_next_string(*p);
  286.       else
  287.         workp = scan_next_internal(*p, FALSE);
  288.       break;
  289.     }
  290.     c = getchar();
  291.   }
  292.  done:
  293.   unget();
  294.   work = work_string->buff;
  295.   while(workp>work && isspace(*(workp-1))) workp--;
  296.   *workp = EOS;                  /* trim trailing blanks */
  297.   return savestring(work);
  298. }
  299.  
  300. void
  301. put_string(string)
  302.   char* string;
  303. {
  304.   char c;
  305.   putchar('\"');
  306.   while ((c=*string++) != EOS)
  307.     switch (c) {
  308.       case '\"': putchar('\\');
  309.       default:  putchar(c);
  310.     }
  311.   putchar('\"');
  312. }
  313.  
  314. /* c_upcase -- Convert all alphabetical characters to uppercase
  315.  * Input:      Character string 
  316.  * Output:     Updated string
  317.  */
  318. char*
  319. c_upcase (s)
  320.   char* s;
  321. {
  322.   char* p = s;            /* Point to beginning of string */
  323.   while (*p != EOS) {        /* While there are still valid characters */
  324.     if (islower (*p))        /* if this is lower case */
  325.       *p = toupper (*p);    /* convert to uppercase */
  326.     p++;            /* Advance pointer */
  327.   }
  328.   return s;            /* Return reference to modified string */
  329. }
  330.  
  331.  
  332. /* c_downcase -- Convert all alphabetical characters to lowercase
  333.  * Input:        Character string
  334.  * Output:       Updated string
  335.  */
  336.  
  337. char*
  338. c_downcase (s)
  339.   char* s;
  340. {
  341.   char* p = s;            /* Point to beginning of string */
  342.   while (*p != EOS) {        /* While there are still valid characters */
  343.     if (isupper (*p))        /* if this is upper case */
  344.       *p = tolower (*p);    /* convert to lowercase  */
  345.     p++;            /* Advance pointer */
  346.   }
  347.   return s;            /* Return reference to modified string */
  348. }
  349.  
  350. /* c_capitalize -- Capitalize all words in a string. A word is defined as
  351.  *                 a sequence of characters separated by white space
  352.  * Input:          Character string
  353.  * Output:         Updated string
  354.  */
  355.  
  356. char*
  357. c_capitalize (s)
  358.   char* s;
  359. {
  360.   char* p = s;                /* Point to beginning of string */
  361.   while (TRUE) {            /* Infinite loop */
  362.     for ( ; *p && isspace(*p); p++);    /* Skip white space */
  363.     if (*p == EOS)                 /* If end of string */
  364.       return s;                /* Return string */
  365.     if (islower (*p))            /* If lower case */
  366.       *p = toupper (*p);        /* Convert character */
  367.     for ( ; *p && !isspace (*p); p++);    /* Search for white space */
  368.   }
  369. }
  370.  
  371. /*
  372.  * c_trim_all -- Removes any occurrence of the character(s) in "c" from "s"
  373.  * Input:    Source string and token string
  374.  * Output:   Modified string "s"
  375.  */
  376. char* c_trim_all (s, c)
  377.   char* s;
  378.   char* c;
  379. {
  380.   char* t0;
  381.   int old_length = strlen (s);          /* Old string "s" length */
  382.   int new_length = 0;              /* Counts characters in result */
  383.   char* p = getmem(old_length+1);      /* Temporary holding array */
  384.   int i;
  385.   for (i = 0; i < old_length; i++) {  /* For each character in string */
  386.     for (t0 = c; *t0 && s[i] != *t0; t0++); /* Scan for match */
  387.     if (*t0 == EOS)              /* If no match found */
  388.       p[new_length++] = s[i];          /* Copy character */
  389.   }
  390.   p[new_length] = EOS;              /* NULL terminate string */
  391.   strcpy (s, p);              /* Copy new string */
  392.   free(p);                  /* Deallocate temporary memory */
  393.   return s;                  /* Return pointer to new string */
  394. }
  395.  
  396. /*
  397.  * Primitive dynamic string support
  398.  */
  399.  
  400. STRING make_STRING(size)
  401.   int size;
  402. { STRING result = (STRING) getmem(sizeof(struct buf_string));
  403.   char* buff = getmem(size);
  404.   *buff = EOS;
  405.   result->buff = buff;
  406.   result->buffp = buff;
  407.   result->buffend = buff+size;
  408.   return result;
  409. }
  410.  
  411. void destroy_STRING(string)
  412.   STRING string;
  413. {
  414.   free(string->buff);
  415.   free(string);
  416. }
  417.  
  418. void grow_STRING(string, len)
  419.   STRING string;
  420.   unsigned int len;
  421. {
  422.   extern char* realloc(/* char*, int */);
  423.   char* old = string->buff;
  424.   unsigned int size = len + ((string->buffend - old) * 2);
  425.   char* new;
  426.   new = realloc(old, size);
  427.   if (new == NULL) cfatal("Heap exausted while growing string", "");
  428.   string->buffp = new + (string->buffp - old);
  429.   string->buff = new;
  430.   string->buffend = new + size;
  431. }
  432.  
  433. void append_STRING(string, chars)
  434.   STRING string;
  435.   char* chars;
  436. {  unsigned int len = strlen(chars);
  437.    if (string->buffend - string->buffp <= len)
  438.      grow_STRING(string, len);
  439.    strcpy(string->buffp, chars);
  440.    string->buffp += len;
  441. }
  442.  
  443. /*
  444. // Copy whitespace and comments into a string, returning the next character
  445. */
  446. char
  447. append_blanks(string)
  448.   STRING string;
  449. {
  450.   register char c;
  451.  again:
  452.   while ((c = getchar()) != EOF && isspace(c))
  453.     append_char(string, c);
  454.   if (c == '/') {
  455.     char nc = getchar();
  456.     if (nc == '/') {        /* If // comment, skip to end of line */
  457.       append_STRING(string, "//");
  458.       while ((c = getchar()) != EOF) {
  459.     append_char(string, c);
  460.     if (c == '\n') break;
  461.       }
  462.       goto again;
  463.     } else if (nc == '*') {    /* If / * comment, skip to */
  464.       char p = getchar();
  465.       append_STRING(string, "/*");
  466.       append_char(string, p);
  467.       while ((c = getchar()) != EOF) {
  468.     append_char(string, c);
  469.     if (c == '/' && p == '*') break;
  470.     p = c;
  471.       }
  472.       goto again;
  473.     } else            /* Else putback character after / */
  474.       unget();
  475.   } else if (c == '\\') {
  476.     char nc = getchar();
  477.     if (nc == '\n') goto again;          /* If \\\n, ignore */
  478.     unget();
  479.   }
  480.   *(string->buffp) = EOS;
  481.   return(c);
  482. }
  483.