home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / DMAKE37S.ZIP / DMAKE / GETINP.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-06  |  13.0 KB  |  491 lines
  1. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/getinp.c,v 1.1 91/05/06 15:23:15 dvadura Exp $
  2. -- SYNOPSIS -- handle reading of input.
  3. -- 
  4. -- DESCRIPTION
  5. --    The code in this file reads the input from the specified stream
  6. --    into the provided buffer of size Buffer_size.  In doing so it deletes
  7. --    comments.  Comments are delimited by the #, and
  8. --    <nl> character sequences.  An exception is \# which
  9. --    is replaced by # in the input.  Line continuations are signalled
  10. --    at the end of a line and are recognized inside comments.
  11. --    The line continuation is always  <\><nl>.
  12. --
  13. --    If the file to read is NIL(FILE) then the Get_line routine returns the
  14. --    next rule from the builtin rule table if there is one.
  15. --
  16. -- AUTHOR
  17. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  18. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  19. --
  20. -- COPYRIGHT
  21. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  22. -- 
  23. --      This program is free software; you can redistribute it and/or
  24. --      modify it under the terms of the GNU General Public License
  25. --      (version 1), as published by the Free Software Foundation, and
  26. --      found in the file 'LICENSE' included with this distribution.
  27. -- 
  28. --      This program is distributed in the hope that it will be useful,
  29. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  30. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31. --      GNU General Public License for more details.
  32. -- 
  33. --      You should have received a copy of the GNU General Public License
  34. --      along with this program;  if not, write to the Free Software
  35. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  36. --
  37. -- LOG
  38. --     $Log:    getinp.c,v $
  39.  * Revision 1.1  91/05/06  15:23:15  dvadura
  40.  * dmake Release Version 3.7
  41.  * 
  42. */
  43.  
  44. #include "extern.h"
  45.  
  46. #define IS_WHITE(A)  ((A == ' ') || (A == '\t') || (A == '\n') || (A == '\r'))
  47. #define SCAN_WHITE(A) \
  48.     while( IS_WHITE(*A) ) A++;
  49.  
  50. static    int    _is_conditional ANSI((char*));
  51. static    int    _handle_conditional ANSI((int, TKSTRPTR));
  52.  
  53. static int  rule_ind = 0;    /* index of rule when reading Rule_tab     */
  54. static int  skip = FALSE;    /* if true the skip input         */
  55.  
  56.  
  57. PUBLIC int
  58. Get_line( buf, fil )/*
  59. ======================
  60.         Read a line of input from the file stripping
  61.         off comments.  The routine returns TRUE if EOF */
  62. char *buf;
  63. FILE *fil;
  64. {
  65.    extern   char **Rule_tab;
  66.    register char *p;
  67.    register char *c;
  68.    char      *q;
  69.    char             *buf_org;
  70.    static   int     ignore = FALSE;
  71.    int          cont   = FALSE;
  72.    int          pos    = 0;
  73.    int         res;
  74.  
  75.    DB_ENTER( "Get_line" );
  76.  
  77.    if( fil == NIL(FILE) ) {
  78.       /* Reading the internal rule table.  Set the rule_index to zero.
  79.        * This way ReadEnvironment works as expected every time. */
  80.  
  81.       while( (p = Rule_tab[ rule_ind++ ]) != NIL(char) )
  82.      /* The last test in this if '*p != '~', handles the environment
  83.       * passing conventions used by MKS to pass arguments.  We want to
  84.       * skip those environment entries. */
  85.      if( !Readenv || (Readenv && (strchr(p,'=') != NIL(char)) && *p!='~')){
  86.         strcpy( buf, p );
  87.  
  88.         DB_PRINT( "io", ("Returning [%s]", buf) );
  89.         DB_RETURN( FALSE );
  90.      }
  91.  
  92.       rule_ind = 0;
  93.  
  94.       DB_PRINT( "io", ("Done Ruletab") );
  95.       DB_RETURN( TRUE );
  96.    }
  97.  
  98.    buf_org = buf;
  99.  
  100. do_again:
  101.    do {
  102.       p = buf+pos;
  103.       if(feof( fil ) || (fgets( p, Buffer_size-pos, fil ) == NIL(char)))
  104.      DB_RETURN( TRUE );
  105.  
  106.       Line_number++;
  107.  
  108.       /* ignore input if ignore flag set and line ends in a continuation
  109.      character. */
  110.  
  111.       q = p+strlen(p)-2;
  112.       /* ignore each RETURN at the end of a line before any further
  113.        * processing */
  114.       if( q[0] == '\r' && q[1] == '\n' ) {
  115.      q[0] = '\n';
  116.      q[1] = '\0';
  117.      q--;
  118.       }
  119.       /* you also have to deal with END_OF_FILE chars to process raw
  120.        * DOS-Files. Normally they are the last chars in file, but after
  121.        * working on these file with vi, there is an additional NEWLINE
  122.        * after the last END_OF_FILE. So if the second last char in the
  123.        * actual line is END_OF_FILE, you can skip the last char. Then
  124.        * you can search the line back until you find no more END_OF_FILE
  125.        * and nuke each you found by string termination. */
  126.       if( q[0] == '\032' )
  127.      q--;
  128.       while( q[1] == '\032' ) {
  129.      q[1] = '\0';
  130.      q--;
  131.       }
  132.  
  133.       if( ignore ) {
  134.      if( q[0] != CONTINUATION_CHAR || q[1] != '\n' )  ignore = FALSE;
  135.      *p = '\0';
  136.      continue;
  137.       }
  138.  
  139.       c = Do_comment(p, &q, Group || (*buf == '\t'));
  140.       
  141.       /* Does the end of the line end in a continuation sequence? */
  142.       
  143.       if( (q[0] == CONTINUATION_CHAR) && (q[1] == '\n')) {
  144.      /* If the continuation was at the end of a comment then ignore the
  145.       * next input line, (or lines until we get one ending in just <nl>)
  146.       * else it's a continuation, so build the input line from several
  147.       * text lines on input.  The maximum size of this is governened by
  148.       * Buffer_size */
  149.      if( q != p && q[-1] == CONTINUATION_CHAR ) {
  150.         strcpy( q, q+1 );
  151.         q--;
  152.         cont = FALSE;
  153.      }
  154.      else if( c != NIL(char) )
  155.         ignore = TRUE;
  156.      else
  157.         cont   = TRUE;
  158.       }
  159.       else {
  160.      cont = FALSE;
  161.       }
  162.  
  163.       q    = ( c == NIL(char) ) ? q+2 : c;
  164.       pos += q-p;
  165.    }
  166.    while( (cont || !*buf) && (pos <= Buffer_size) );
  167.  
  168.    if( buf[ pos-1 ] == '\n' )
  169.       buf[ --pos ] = '\0';
  170.    else
  171.       if( pos == Buffer_size-1 )
  172.      Fatal( "Input line too long, increase MAXLINELENGTH" );
  173.  
  174.  
  175.    /* Now that we have the next line of input to make, we should check to
  176.     * see if it is a conditional expression.  If it is then process it,
  177.     * otherwise pass it on to the parser. */
  178.  
  179.    if( *(p = _strspn(buf, " \t\r\n")) == CONDSTART ) {
  180.       TKSTR token;
  181.  
  182.       SET_TOKEN( &token, p );
  183.  
  184.       p = Get_token( &token, "", FALSE );
  185.  
  186.       if( (res = _is_conditional( p )) )    /* ignore non control special */
  187.       {                        /* targets               */
  188.      res  = _handle_conditional( res, &token );
  189.      skip = TRUE;
  190.       }
  191.       else {
  192.      CLEAR_TOKEN( &token );
  193.      res  = TRUE;
  194.       }
  195.    }
  196.  
  197.    if( skip ) {
  198.       buf  = buf_org;        /* ignore line just read in */
  199.       pos  = 0;
  200.       skip = res;
  201.       goto do_again;
  202.    }
  203.  
  204.    DB_PRINT( "io", ("Returning [%s]", buf) );
  205.    DB_RETURN( FALSE );
  206. }
  207.  
  208.  
  209. PUBLIC char *
  210. Do_comment(str, pend, keep)/*
  211. =============================
  212.    Search the input string looking for comment chars.  If it contains
  213.    comment chars then NUKE the remainder of the line, if the comment
  214.    char is preceeded by \ then shift the remainder of the line left
  215.    by one char. */
  216. char *str;
  217. char **pend;
  218. int  keep;
  219. {
  220.    char *c = str;
  221.  
  222.    while( (c = strchr(c, COMMENT_CHAR)) != NIL(char) ) {
  223.       if( Comment || State == NORMAL_SCAN )
  224.      if( c != str && c[-1] == ESCAPE_CHAR ) {
  225.         strcpy( c-1, c );        /* copy it left, due to \# */
  226.         if( pend ) (*pend)--;    /* shift tail pointer left */
  227.      }
  228.      else {
  229.         *c = '\0';               /* a true comment so break */
  230.         break;
  231.      }
  232.       else {
  233.          if( keep )
  234.         c = NIL(char);
  235.      else
  236.         *c = '\0';
  237.  
  238.      break;
  239.       }
  240.    }
  241.  
  242.    return(c);
  243. }
  244.       
  245.  
  246. PUBLIC char *
  247. Get_token( string, brk, anchor )/*
  248. ==================================
  249.     Return the next token in string.
  250.     Returns empty string when no more tokens in string.
  251.     brk is a list of chars that also cause breaks in addition to space and
  252.     tab, but are themselves returned as tokens.  if brk is NULL then the
  253.     remainder of the line is returned as a single token.
  254.     
  255.     anchor if TRUE, says break on chars in the brk list, but only if
  256.     the entire token begins with the first char of the brk list, if
  257.     FALSE then any char of brk will cause a break to occurr. */
  258.  
  259. TKSTRPTR  string;
  260. char      *brk;
  261. int      anchor;
  262. {
  263.    register char *s;
  264.    register char *curp;
  265.    register char *t;
  266.    int           done = FALSE;
  267.    char          space[10];
  268.  
  269.    DB_ENTER( "Get_token" );
  270.  
  271.    s  = string->tk_str;              /* Get string parameters    */
  272.    *s = string->tk_cchar;          /* ... and strip leading w/s    */
  273.  
  274.    SCAN_WHITE( s );
  275.  
  276.    DB_PRINT( "tok", ("What's left [%s]", s) );
  277.  
  278.    if( !*s ) {
  279.       DB_PRINT( "tok", ("Returning NULL token") );
  280.       DB_RETURN( "" );
  281.    }
  282.  
  283.  
  284.    /* Build the space list.  space contains all those chars that may possibly
  285.     * cause breaks.  This includes the brk list as well as white space. */
  286.  
  287.    if( brk != NIL(char) ) {
  288.       strcpy( space, " \t\r\n" );
  289.       strcat( space, brk   );
  290.    }
  291.    else {
  292.       space[0] = 0xff;            /* a char we know will not show up      */
  293.       space[1] = 0;
  294.    }
  295.  
  296.  
  297.    /* Handle processing of quoted tokens.  Note that this is disabled if
  298.     * brk is equal to NIL */
  299.  
  300.    while( *s == '\"' && ((brk != NIL(char)) || !string->tk_quote) ) {
  301.       s++;
  302.       if( string->tk_quote ) {
  303.      curp = s-1;
  304.      do { curp = strchr( curp+1, '\"' ); }
  305.      while( (curp != NIL(char)) && (*(curp+1) == '\"'));
  306.  
  307.          if( curp == NIL(char) ) Fatal( "Unmatched quote in token" );
  308.      string->tk_quote = !string->tk_quote;
  309.  
  310.      /* Check for "" case, and if found ignore it */
  311.      if( curp == s ) continue;
  312.      goto found_token;
  313.       }
  314.       else
  315.      SCAN_WHITE( s );
  316.  
  317.       string->tk_quote = !string->tk_quote;
  318.    }
  319.    
  320.  
  321.    /* Check for a token break character at the beginning of the token.
  322.     * If found return the next set of break chars as a token. */
  323.  
  324.    if( (brk != NIL(char)) && (strchr( brk, *s ) != NIL(char)) ) {
  325.       curp = _strspn( s, brk );
  326.       done = (anchor == 0) ? TRUE :
  327.          ((anchor == 1)?(*s == *brk) : (*brk == curp[-1]));
  328.    }
  329.  
  330.  
  331.    /* Scan for the next token in the list and return it less the break char
  332.     * that was used to terminate the token.  It will possibly be returned in
  333.     * the next call to Get_token */
  334.  
  335.    if( !done ) {
  336.       SCAN_WHITE( s );
  337.  
  338.       t = s;
  339.       do {
  340.      done = TRUE;
  341.      curp = _strpbrk(t, space);
  342.      
  343.      if( anchor && *curp && !IS_WHITE( *curp ) )
  344.         if( ((anchor == 1)?*curp:_strspn(curp,brk)[-1]) != *brk ) {
  345.            t++;
  346.            done = FALSE;
  347.         }
  348.       }
  349.       while( !done );
  350.  
  351.       if( (curp == s) && (strchr(brk, *curp) != NIL(char)) ) curp++;
  352.    }
  353.  
  354. found_token:
  355.    string->tk_str   = curp;
  356.    string->tk_cchar = *curp;
  357.    *curp = '\0';
  358.  
  359.    DB_PRINT( "tok", ("Returning [%s]", s) );
  360.    DB_RETURN( s );
  361. }
  362.  
  363.  
  364. static int
  365. _is_conditional( tg )/*
  366. =======================
  367.     Look at tg and return it's value if it is a conditional identifier
  368.     otherwise return 0. */
  369. char *tg;
  370. {
  371.    DB_ENTER( "_is_conditional" );
  372.    
  373.    tg++;
  374.    switch( *tg ) {
  375.       case 'I': if( !strcmp( tg, "IF" )) DB_RETURN( ST_IF   ); break;
  376.       
  377.       case 'E':
  378.          if( !strcmp( tg, "END" ))     DB_RETURN( ST_END  );
  379.          else if( !strcmp( tg, "ENDIF")) DB_RETURN( ST_END  );
  380.          else if( !strcmp( tg, "ELSE" )) DB_RETURN( ST_ELSE );
  381.          else if( !strcmp( tg, "ELIF" )) DB_RETURN( ST_ELIF );
  382.      break;
  383.    }
  384.    
  385.    DB_RETURN( 0 );
  386. }
  387.  
  388.  
  389.  
  390. #define SEEN_END  0x00
  391. #define SEEN_IF   0x01
  392. #define SEEN_ELSE 0x02
  393.  
  394. static int
  395. _handle_conditional( opcode, tg )/*
  396. ===================================
  397.     Perform the necessary processing for .IF conditinal targets.
  398.     Someday this should be modified to do bracketted expressions ala
  399.     CPP... sigh */
  400. int      opcode;
  401. TKSTRPTR tg;
  402. {
  403.    static short    action[MAX_COND_DEPTH];
  404.    static char  ifcntl[MAX_COND_DEPTH];
  405.    char     *tok, *lhs, *rhs, *op, *expr;
  406.    int      result;
  407.  
  408.    DB_ENTER( "_handle_conditional" );
  409.  
  410.    switch( opcode ) {
  411.       case ST_ELIF:
  412.          if( !(ifcntl[Nest_level] & SEEN_IF) || (ifcntl[Nest_level]&SEEN_ELSE) )
  413.         Fatal(".ELIF without a preceeding .IF" );
  414.      /* FALLTHROUGH */
  415.  
  416.       case ST_IF:
  417.      if( opcode == ST_IF && (Nest_level+1) == MAX_COND_DEPTH )
  418.         Fatal( ".IF .ELSE ... .END nesting too deep" );
  419.  
  420.      If_expand = TRUE;
  421.      expr = Expand( Get_token( tg, NIL(char), FALSE ));
  422.      If_expand = FALSE;
  423.      lhs = _strspn( expr, " \t" );
  424.      if( !*lhs ) lhs = NIL(char);
  425.  
  426.      if( (op = _strstr( lhs, "==" )) == NIL(char) )
  427.         op = _strstr( lhs, "!=" );
  428.  
  429.      if( op == NIL(char) )
  430.         result = (lhs != NIL(char));
  431.      else {
  432.         op[1] = op[0];
  433.         if( lhs != op ) {
  434.            for( tok = op-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t'));
  435.                 tok-- );
  436.            tok[1] = '\0';
  437.         }
  438.         else
  439.            lhs = NIL(char);
  440.  
  441.         op++;
  442.         rhs = _strspn( op+1, " \t" );
  443.         if( !*rhs ) rhs = NIL(char);
  444.  
  445.         if( (rhs == NIL(char)) || (lhs == NIL(char)) )
  446.            result = (rhs == lhs) ? TRUE : FALSE;
  447.         else {
  448.            tok = rhs + strlen( rhs );
  449.            for( tok=tok-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t'));
  450.             tok--);
  451.            tok[1] = '\0';
  452.  
  453.            result = (strcmp( lhs, rhs ) == 0) ? TRUE : FALSE;
  454.         }
  455.  
  456.         if( *op == '!' ) result = !result;
  457.      }
  458.  
  459.      if( expr != NIL(char) ) FREE( expr );
  460.  
  461.      if( opcode == ST_IF ) {
  462.         Nest_level++;
  463.         ifcntl[Nest_level] |= SEEN_IF;
  464.      }
  465.  
  466.      if( result )
  467.         action[ Nest_level ] = action[ Nest_level-1 ];
  468.      else
  469.         action[ Nest_level ] = 1;
  470.      break;
  471.  
  472.       case ST_ELSE:
  473.      if( Nest_level <= 0 ) Fatal( ".ELSE without .IF" );
  474.      if( ifcntl[Nest_level] & SEEN_ELSE )
  475.         Fatal( "Missing .IF or .ELIF before .ELSE" );
  476.  
  477.      if( action[ Nest_level-1 ] != 1 )
  478.         action[ Nest_level ] ^= 0x1;    /* flip between 0 and 1    */
  479.      ifcntl[Nest_level] |= SEEN_ELSE;
  480.      break;
  481.  
  482.       case ST_END:
  483.      ifcntl[Nest_level] = SEEN_END;
  484.      Nest_level--;
  485.      if( Nest_level < 0 ) Fatal( "Unmatched .END" );
  486.      break;
  487.    }
  488.  
  489.    DB_RETURN( action[ Nest_level ] );
  490. }
  491.