Usenet 1994 January/usenetsourcesnewsgroupsinfomagicjanuary1994.iso/sources/misc/volume19/dmake/part09

Text File | 1991-05-11 | 40.2 KB | 1,489 lines

Newsgroups: comp.sources.misc
From: Dennis Vadura <[e-mail]>
Subject:  v19i030:  dmake - dmake version 3.7, Part09/37
Message-ID: <[e-mail]>
Date: Fri, 10 May 1991 18:58:04 GMT
Approved: [e-mail]

Submitted-by: Dennis Vadura <[e-mail]>
Posting-number: Volume 19, Issue 30
Archive-name: dmake/part09
Supersedes: dmake-3.6: Volume 15, Issue 52-77

---- Cut Here and feed the following to sh ----
#!/bin/sh
# this is dmake.shar.09 (part 9 of a multipart archive)
# do not concatenate these parts, unpack them in order with /bin/sh
# file dmake/expand.c continued
#
if test ! -r _shar_seq_.tmp; then
    echo 'Please unpack part 1 first!'
    exit 1
fi
(read Scheck
 if test "$Scheck" != 9; then
    echo Please unpack part "$Scheck" next!
    exit 1
 else
    exit 0
 fi
) < _shar_seq_.tmp || exit 1
if test -f _shar_wnt_.tmp; then
sed 's/^X//' << 'SHAR_EOF' >> 'dmake/expand.c' &&
X   while( *(tok = Get_token( &tokens, "", FALSE )) != '\0' ) {
X      DB_PRINT( "exp", ("Tokenizing [%s]", tok) );
X
X      if( first ) {
X     FREE( res );
X     res   = _strdup( tok );
X     first = FALSE;
X      }
X      else {
X           char *x;
X     res = _strjoin(res, x =_strjoin(separator, tok, -1, FALSE), -1, TRUE);
X     FREE( x );
X      }
X   }
X
X   FREE( src );
X   DB_RETURN( res );
}
X
X
static char*
_scan_token( s, ps )/*
======================
X      This routine scans the token characters one at a time and identifies
X      macros starting with $( and ${ and calls _scan_macro to expand their
X      value.   the string1{ token_list }string2 expansion is also handled.
X      In this case a temporary result is maintained so that we can take it's
X      cross product with any other token_lists that may possibly appear. */
X
char *s;        /* pointer to start of src string */
char **ps;        /* pointer to start pointer      */
{
X   char *res;                 /* pointer to result          */
X   char *start;               /* pointer to start of prefix */
X   int  crossproduct = 0;     /* if 1 then computing X-prod */
X
X   start = s;
X   res   = _strdup( "" );
X   while( 1 )
X      switch( *s ) {
X         /* Termination, We halt at seeing a space or a tab or end of string.
X          * We return the value of the result with any new macro's we scanned
X          * or if we were computing cross_products then we return the new
X          * cross_product.
X          * NOTE:  Once we start computing cross products it is impossible to
X          *        stop.  ie. the semantics are such that once a {} pair is
X          *        seen we compute cross products until termination. */
X
X         case ' ':
X         case '\t':
X     case '\n':
X         case '\0':
X     {
X        char *tmp;
X
X        *ps = s;
X        if( !crossproduct )
X           tmp = _strjoin( res, start, (s-start), TRUE );
X        else
X        {
X           tmp = _substr( start, s );
X           tmp = _cross_prod( res, tmp );
X        }
X        return( tmp );
X     }
X
X         case '$':
X         case '{':
X     {
X        /* Handle if it's a macro or if it's a {} construct.
X         * The results of a macro expansion are handled differently based
X         * on whether we have seen a {} beforehand. */
X
X        char *tmp;
X        tmp = _substr( start, s );          /* save the prefix */
X
X        if( *s == '$' ) {
X           start = _scan_macro( s+1, &s );
X
X           if( crossproduct )
X          res = _cross_prod( res, _strjoin( tmp, start, -1, TRUE ) );
X           else {
X          res = _strjoin(res,tmp = _strjoin(tmp,start,-1,TRUE),-1,TRUE);
X          FREE( tmp );
X           }
X           FREE( start );
X        }
X        else if( strchr("{ \t",s[1]) == NIL(char) ){
X           int ok;
X           start = _scan_brace( s+1, &s, &ok );
X
X           if( ok ) {
X          res = _cross_prod( res, _cross_prod(tmp, start) );
X          crossproduct = TRUE;
X           }
X           else {
X          res =_strjoin(res,tmp=_strjoin(tmp,start,-1,TRUE),-1,TRUE);
X          FREE( start );
X          FREE( tmp   );
X           }
X        }
X        else {    /* handle the {{ case */
X           res = _strjoin( res, start, (s-start+1), TRUE );
X           s  += (s[1]=='{')?2:1;
X           FREE( tmp );
X        }
X
X        start = s;
X     }
X     break;
X
X     case '}':
X        if( s[1] != '}' ) {
X           /* error malformed macro expansion */
X           s++;
X        }
X        else {    /* handle the }} case */
X           res = _strjoin( res, start, (s-start+1), TRUE );
X           s += 2;
X           start = s;
X        }
X        break;
X
X         default: s++;
X      }
}
X
X
static char*
_scan_macro( s, ps )/*
======================
X    This routine scans a macro use and expands it to the value.  It
X    returns the macro's expanded value and modifies the pointer into the
X    src string to point at the first character after the macro use.
X    The types of uses recognized are:
X
X        $$        - expands to $
X        $(name)        - expands to value of name
X        ${name}        - same as above
X        $($(name))    - recurses on macro names (any level)
X    and
X        $(func[,args ...] [data])
X    and
X            $(name:modifier_list:modifier_list:...)
X
X    see comment for Expand for description of valid modifiers.
X
X    NOTE that once a macro name bounded by ( or { is found only
X    the appropriate terminator (ie. ( or } is searched for. */
X
char *s;        /* pointer to start of src string   */
char **ps;        /* pointer to start pointer        */
{
X   char sdelim;         /* start of macro delimiter         */
X   char edelim;         /* corresponding end macro delim    */
X   char *start;         /* start of prefix                  */
X   char *macro_name;    /* temporary macro name             */
X   char *recurse_name;  /* recursive macro name             */
X   char *result;    /* result for macro expansion        */
X   int  bflag = 0;      /* brace flag, ==0 => $A type macro */
X   int  done  = 0;      /* != 0 => done macro search        */
X   int  lev   = 0;      /* brace level                      */
X   int  mflag = 0;      /* != 0 => modifiers present in mac */
X   int  fflag = 0;    /* != 0 => GNU style function         */
X   HASHPTR hp;        /* hash table pointer for macros    */
X
X   DB_ENTER( "_scan_macro" );
X
X   /* Check for the simple $ at end of line case */
X   if( !*s ) {
X      *ps = s;
X      DB_RETURN( _strdup("") );
X   }
X
X   if( *s == '$' ) {    /* Take care of the simple $$ case. */
X      *ps = s+1;
X      DB_RETURN( _strdup("$") );
X   }
X
X   sdelim = *s;         /* set and remember start/end delim */
X   if( sdelim == '(' )
X      edelim = ')';
X   else
X      edelim = '}';
X
X   start = s;           /* build up macro name, find its end*/
X   while( !done ) {
X      switch( *s ) {
X         case '(':                /* open macro brace */
X         case '{':
X        if( *s == sdelim ) {
X           lev++;
X           bflag++;
X        }
X        break;
X
X         case ':':                              /* halt at modifier */
X            if( lev == 1 ) {
X               done = TRUE;
X               mflag = 1;
X            }
X            break;
X
X     case ' ':
X     case '\t':
X     case '\n':
X        fflag = 1;
X        break;
X
X     case '\0':                /* check for null */
X        *ps = s;
X        if( lev ) {
X           done  = TRUE;
X           bflag = 0;
X           s     = start;
X        }
X        break;
X
X         case ')':                /* close macro brace */
X         case '}':
X        if( *s == edelim && lev ) --lev;
X        /*FALLTHROUGH*/
X
X         default:
X        done = !lev;
X      }
X      s++;
X   }
X
X   /* Check if this is a $A type macro.  If so then we have to
X    * handle it a little differently. */
X   if( bflag )
X      macro_name = _substr( start+1, s-1 );
X   else
X      macro_name = _substr( start, s );
X
X   /* Check to see if the macro name contains spaces, if so then treat it
X    * as a GNU style function invocation and call the function mapper to
X    * deal with it. */
X   if( fflag )
X      result = Exec_function(macro_name);
X   else {
X      /* Check if the macro is a recursive macro name, if so then
X       * EXPAND the name before expanding the value */
X      if( strchr( macro_name, '$' ) != NIL(char) ) {
X     recurse_name = Expand( macro_name );
X     FREE( macro_name );
X     macro_name = recurse_name;
X      }
X
X      /* Code to do value expansion goes here, NOTE:  macros whose assign bit
X     is one have been evaluated and assigned, they contain no further
X     expansions and thus do not need their values expanded again. */
X
X      if( (hp = GET_MACRO( macro_name )) != NIL(HASH) ) {
X     if( hp->ht_flag & M_MARK )
X        Fatal( "Detected circular macro [%s]", hp->ht_name );
X
X     /* for M_MULTI macro variable assignments */
X     If_multi = hp->ht_flag & M_MULTI;
X
X     if( !(hp->ht_flag & M_EXPANDED) ) {
X        hp->ht_flag |= M_MARK;
X        result = Expand( hp->ht_value );
X        hp->ht_flag ^= M_MARK;
X     }
X     else if( hp->ht_value != NIL(char) )
X        result = _strdup( hp->ht_value );
X     else
X        result = _strdup( "" );
X
X     /*
X      * Mark macros as used only if we are not expanding them for
X      * the purpose of a .IF test, so we can warn about redef after use*/
X
X     if( !If_expand ) hp->ht_flag |= M_USED;
X      }
X      else
X     result = _strdup( "" );
X   }
X
X   if( mflag ) {
X      char separator;
X      int  modifier_list = 0;
X      int  aug_mod       = FALSE;
X      char *pat1;
X      char *pat2;
X      char *p;
X
X      /* Yet another brain damaged AUGMAKE kludge.  We should accept the
X       * AUGMAKE bullshit of $(f:pat=sub) form of macro expansion.  In
X       * order to do this we will forgo the normal processing if the
X       * AUGMAKE solution pans out, otherwise we will try to process the
X       * modifiers ala dmake.
X       *
X       * So we look for = in modifier string.
X       * If found we process it and not do the normal stuff */
X
X      for( p=s; *p && *p != '=' && *p != edelim; p++ );
X
X      if( *p == '=' ) {
X     pat1 = _substr( s, p );
X     for( s=p=p+1; (*p != edelim); p++ );
X
X     pat2   = _substr( s, p );
X     result = Apply_edit( result, pat1, pat2, TRUE, TRUE );
X     FREE( pat1 );
X     FREE( pat2 );
X     s = p;
X     aug_mod = TRUE;
X      }
X
X      if( !aug_mod )
X     while( *s && *s != edelim ) {        /* while not at end of macro */
X        switch( *s++ ) {
X           case 'b':
X           case 'B': modifier_list |= FILE_FLAG;            break;
X
X           case 'd':
X           case 'D': modifier_list |= DIRECTORY_FLAG;         break;
X
X           case 'f':
X           case 'F': modifier_list |= FILE_FLAG | SUFFIX_FLAG; break;
X
X           case 'S':
X           case 's':
X          if( modifier_list ) {
X             Warning( "Edit modifier must appear alone, ignored");
X             modifier_list = 0;
X          }
X          else {
X             separator = *s++;
X             for( p=s; *p != separator && *p != edelim; p++ );
X
X             if( *p == edelim )
X                Warning("Syntax error in edit pattern, ignored");
X             else {
X            char *t1, *t2;
X            pat1 = _substr( s, p );
X            for(s=p=p+1; (*p != separator) && (*p != edelim); p++ );
X            pat2 = _substr( s, p );
X            t1 = Expand(pat1); FREE(pat1);
X            t2 = Expand(pat2); FREE(pat2);
X            result = Apply_edit( result, t1, t2, TRUE, FALSE );
X            FREE( t1 );
X            FREE( t2 );
X             }
X             s = p;
X          }
X          /* find the end of the macro spec, or the start of a new
X           * modifier list for further processing of the result */
X
X          for( ; (*s != edelim) && (*s != ':'); s++ );
X          if( *s == ':' ) s++;
X          break;
X
X           case 'T':
X           case 't':
X          if( modifier_list ) {
X             Warning( "Tokenize modifier must appear alone, ignored");
X             modifier_list = 0;
X          }
X          else {
X             char *msg = "Separator string must be quoted";
X
X             separator = *s++;
X
X             if( separator != '\"' )
X            Warning( msg );
X             else {
X            /* we change the semantics to allow $(v:t")") */
X            for (p = s; *p && *p != separator; p++)
X               if (*p == '\\')
X                  if (p[1] == '\\' || p[1] == '"')
X                 p++;
X            if( *p == 0 )
X               Fatal( "Unterminated separator string" );
X            else {
X               pat1 = _substr( s, p );
X               result = Tokenize( result, pat1 );
X               FREE( pat1 );
X            }
X            s = p;
X             }
X
X             /* find the end of the macro spec, or the start of a new
X              * modifier list for further processing of the result */
X
X             for( ; (*s != edelim) && (*s != ':'); s++ );
X             if( *s == ':' ) s++;
X          }
X          break;
X
X           case ':':
X          if( modifier_list ) {
X             result = Apply_modifiers( modifier_list, result );
X             modifier_list = 0;
X          }
X          break;
X
X           default:
X          Warning( "Illegal modifier in macro, ignored" );
X          break;
X        }
X     }
X
X      if( modifier_list ) /* apply modifier */
X         result = Apply_modifiers( modifier_list, result );
X
X      s++;
X   }
X
X   *ps = s;
X   FREE( macro_name );
X   DB_RETURN( result );
}
X
X
static char*
_scan_brace( s, ps, flag )/*
============================
X      This routine scans for { token_list } pairs.  It expands the value of
X      token_list by calling Expand on it.  Token_list may be anything at all.
X      Note that the routine count's ballanced parentheses.  This means you
X      cannot have something like { fred { joe }, if that is what you really
X      need the write it as { fred {{ joe }, flag is set to 1 if all ok
X      and to 0 if the braces were unballanced. */
X
char *s;
char **ps;
int  *flag;
{
X   char *t;
X   char *start;
X   char *res;
X   int  lev  = 1;
X   int  done = 0;
X
X   DB_ENTER( "_scan_brace" );
X
X   start = s;
X   while( !done )
X      switch( *s++ ) {
X         case '{':
X            if( *s == '{' ) break;              /* ignore {{ */
X            lev++;
X            break;
X
X         case '}':
X            if( *s == '}' ) break;              /* ignore }} */
X        if( lev )
X           if( --lev == 0 ) done = TRUE;
X        break;
X
X     case '$':
X        if( *s == '{' || *s == '}' ) {
X          if( (t = strchr(s,'}')) != NIL(char) )
X             s = t;
X          s++;
X        }
X        break;
X
X         case '\0':
X        if( lev ) {
X           done = TRUE;
X           s--;
X           /* error malformed macro expansion */
X        }
X        break;
X      }
X
X   start = _substr( start, (lev) ? s : s-1 );
X
X   if( lev ) {
X      /* Braces were not ballanced so just return the string.
X       * Do not expand it. */
X
X      res   = _strjoin( "{", start, -1, FALSE );
X      *flag = 0;
X   }
X   else {
X      *flag = 1;
X      res   = Expand( start );
X
X      if( (t = _strspn( res, " \t" )) != res ) strcpy( res, t );
X   }
X
X   FREE( start );       /* this is ok! start is assigned a _substr above */
X   *ps = s;
X
X   DB_RETURN( res );
}
X
X
static char*
_cross_prod( x, y )/*
=====================
X      Given two strings x and y compute the cross-product of the tokens found
X      in each string.  ie. if x = "a b" and y = "c d" return "ac ad bc bd".
X
X         NOTE:  buf will continue to grow until it is big enough to handle
X                all cross product requests.  It is never freed!  (maybe I
X            will fix this someday) */
X
char *x;
char *y;
{
X   static char *buf;
X   static int  buf_siz = 0;
X   char *brkx;
X   char *brky;
X   char *cy;
X   char *cx;
X   char *res;
X   int  i;
X
X   if( *x && *y ) {
X      res = _strdup( "" ); cx = x;
X      while( *cx ) {
X     cy = y;
X         brkx = _strpbrk( cx, " \t\n" );
X     if( (brkx-cx == 2) && *cx == '\"' && *(cx+1) == '\"' ) cx = brkx;
X
X     while( *cy ) {
X        brky = _strpbrk( cy, " \t\n" );
X        if( (brky-cy == 2) && *cy == '\"' && *(cy+1) == '\"' ) cy = brky;
X        i    = brkx-cx + brky-cy + 2;
X
X        if( i > buf_siz ) {        /* grow buf to the correct size */
X           if( buf != NIL(char) ) FREE( buf );
X           if( (buf = MALLOC( i, char )) == NIL(char))  No_ram();
X           buf_siz = i;
X        }
X
X        strncpy( buf, cx, (i = brkx-cx) );
X        buf[i] = '\0';
X        if (brky-cy > 0) strncat( buf, cy, brky-cy );
X        buf[i+(brky-cy)] = '\0';
X        strcat( buf, " " );
X        res = _strjoin( res, buf, -1, TRUE );
X        cy = _strspn( brky, " \t\n" );
X     }
X     cx = _strspn( brkx, " \t\n" );
X      }
X
X      FREE( x );
X      res[ strlen(res)-1 ] = '\0';
X   }
X   else
X      res = _strjoin( x, y, -1, TRUE );
X
X   FREE( y );
X   return( res );
}
SHAR_EOF
chmod 0640 dmake/expand.c ||
echo 'restore of dmake/expand.c failed'
Wc_c="`wc -c < 'dmake/expand.c'`"
test 25368 -eq "$Wc_c" ||
    echo 'dmake/expand.c: original size 25368, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/extern.h ==============
if test -f 'dmake/extern.h' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/extern.h (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/extern.h' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/extern.h,v 1.1 91/05/06 15:23:13 dvadura Exp $
-- SYNOPSIS -- external declarations for dmake functions.
--
-- DESCRIPTION
--    ANSI is a macro that allows the proper handling of ANSI style
--    function declarations.
--
-- AUTHOR
--      Dennis Vadura, [e-mail]
--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
--
-- COPYRIGHT
--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
--
--      This program is free software; you can redistribute it and/or
--      modify it under the terms of the GNU General Public License
--      (version 1), as published by the Free Software Foundation, and
--      found in the file 'LICENSE' included with this distribution.
--
--      This program is distributed in the hope that it will be useful,
--      but WITHOUT ANY WARRANTY; without even the implied warrant of
--      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--      GNU General Public License for more details.
--
--      You should have received a copy of the GNU General Public License
--      along with this program;  if not, write to the Free Software
--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
--
-- LOG
--     $Log:    extern.h,v $
X * Revision 1.1  91/05/06  15:23:13  dvadura
X * dmake Release Version 3.7
X *
*/
X
#ifndef EXTERN_h
#define EXTERN_h
X
/* Define this for the RS/6000 if it breaks something then we have to put a
X * #ifdef around it. */
#if defined(rs6000)
#define _POSIX_SOURCE
#endif
X
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include "itypes.h"
#include "stdmacs.h"
#include "alloc.h"
#include "db.h"
#include "dmake.h"
#include "struct.h"
#include "vextern.h"
#include "public.h"
X
/* Include this last as it invalidates some functions that are defined
X * externally above and turns them into no-ops.  Have to do this after
X * the extern declarations however. */
#include "config.h"
X
#endif
X
SHAR_EOF
chmod 0640 dmake/extern.h ||
echo 'restore of dmake/extern.h failed'
Wc_c="`wc -c < 'dmake/extern.h'`"
test 2089 -eq "$Wc_c" ||
    echo 'dmake/extern.h: original size 2089, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/function.c ==============
if test -f 'dmake/function.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/function.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/function.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/function.c,v 1.1 91/05/06 15:23:14 dvadura Exp $
-- SYNOPSIS -- GNU style functions for dmake.
--
-- DESCRIPTION
--     All GNU stule functions understood by dmake are implemented in this
--    file.  Currently the only such function is $(mktmp ...) which is
--    not part of GNU-make is an extension provided by dmake.
--
-- AUTHOR
--      Dennis Vadura, [e-mail]
--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
--
-- COPYRIGHT
--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
--
--      This program is free software; you can redistribute it and/or
--      modify it under the terms of the GNU General Public License
--      (version 1), as published by the Free Software Foundation, and
--      found in the file 'LICENSE' included with this distribution.
--
--      This program is distributed in the hope that it will be useful,
--      but WITHOUT ANY WARRANTY; without even the implied warrant of
--      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--      GNU General Public License for more details.
--
--      You should have received a copy of the GNU General Public License
--      along with this program;  if not, write to the Free Software
--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
--
-- LOG
--     $Log:    function.c,v $
X * Revision 1.1  91/05/06  15:23:14  dvadura
X * dmake Release Version 3.7
X *
*/
X
#include "extern.h"
X
static char *_exec_mktmp  ANSI((char *, char *, char *));
static char *_exec_subst  ANSI((char *, char *, char *));
static char *_exec_iseq   ANSI((char *, char *, char *, int));
static char *_exec_sort   ANSI((char *));
static char *_exec_shell  ANSI((char *));
static int   _mystrcmp    ANSI((CONST void *, CONST void *));
X
X
PUBLIC char *
Exec_function(buf)/*
====================
X   Execute the function given by the value of args.
X
X   So far mktmp is the only valid function, anything else elicits and error
X   message.  It is my hope to support the GNU style functions in this portion
X   of the code at some time in the future. */
char *buf;
{
X   char *fname;
X   char *args;
X   char *mod1;
X   char *mod2 = NIL(char);
X   char *res  = NIL(char);
X
X   /* This must succeed since the presence of ' ', \t or \n is what
X    * determines if this functions is called in the first place. */
X   fname = _substr(buf, args=_strpbrk(buf," \t\n"));
X
X   if( (mod1 = strchr(fname,',')) != NIL(char) ){
X      *mod1 = '\0';
X      mod1++;
X
X      if( (mod2 = strchr(mod1,',')) != NIL(char) ){
X     *mod2 = '\0';
X     mod2++;
X      }
X   }
X
X   switch( *fname ) {
X      case 'e':
X     if(strncmp(fname,"eq",2) == 0) res = _exec_iseq(mod1,mod2,args,TRUE);
X     break;
X
X      case 'm':
X     if( strncmp(fname,"mktmp", 5) == 0 ) res = _exec_mktmp(mod1,mod2,args);
X     break;
X
X      case 'n':
X     if( strncmp(fname,"null", 4) == 0 )
X        res = _exec_iseq(mod1,NIL(char),args,TRUE);
X     break;
X
X      case '!':
X     if(strncmp(fname,"!null",5) == 0)
X        res = _exec_iseq(mod1,NIL(char),args,FALSE);
X     if(strncmp(fname,"!eq",3) == 0) res = _exec_iseq(mod1,mod2,args,FALSE);
X     break;
X
X      case 's':
X     if(strncmp(fname,"sort",4) == 0) res = _exec_sort(args);
X     else if(strncmp(fname,"shell",5)==0) res = _exec_shell(args);
X     else if(strncmp(fname,"strip",5)==0) res = Tokenize(Expand(args)," ");
X     else if(strncmp(fname,"subst",5)==0) res = _exec_subst(mod1,mod2,args);
X     break;
X
X      default:
X     Warning( "Function '%s' not implemented at this time", fname );
X   }
X
X   if( res == NIL(char) ) res = _strdup("");
X
X   FREE(fname);
X   return(res);
}
X
X
static char *
_exec_mktmp( file, text, data )
char *file;
char *text;
char *data;
{
X   register char *p;
X   char *tmpname;
X   char *name;
X   FILE *tmpfile = NIL(FILE);
X
X   /* This is only a test of the recipe line so prevent the tempfile side
X    * effects. */
X   if( Suppress_temp_file ) return(NIL(char));
X
X   name = Current_target ? Current_target->CE_NAME:"makefile text";
X
X   if( file && *file ) {
X      char *newtmp;
X
X      /* This call to Get_temp sets TMPFILE for subsequent expansion of file.
X       * DO NOT DELETE IT! */
X      Get_temp( &newtmp, "", FALSE ); FREE(newtmp);
X      tmpname = Expand(file);
X
X      if( *tmpname ) {
X     if( (tmpfile = fopen(tmpname, "w")) == NIL(FILE) )
X        Open_temp_error( tmpname, name );
X
X     Def_macro("TMPFILE", tmpname, M_EXPANDED|M_MULTI);
X     Link_temp( Current_target, tmpfile, tmpname );
X      }
X      else
X     FREE(tmpname);
X   }
X
X   if( !tmpfile )
X      tmpfile = Start_temp( "", Current_target, &tmpname );
X
X   if( !text || !*text ) text = tmpname;
X   data = Expand(_strspn(data, " \t\n"));
X
X   for(p=strchr(data,'\n'); p; p=strchr(p,'\n')) {
X      char *q = _strspn(++p," \t");
X      strcpy(p,q);
X   }
X
X   Append_line( data, FALSE, tmpfile, name, FALSE, TRUE );
X   Close_temp( Current_target, tmpfile );
X   FREE(data);
X
X   return( Expand(text) );
}
X
X
static char *
_exec_iseq( lhs, rhs, data, eq )
char *lhs;
char *rhs;
char *data;
int  eq;
{
X   char *l = Expand(lhs);
X   char *r = Expand(rhs);
X   char *i = _strspn(data, " \t\n");
X   char *e = strchr(i, ' ');
X   char *res = NIL(char);
X   int  val = strcmp(l,r);
X
X   if( (!val && eq) || (val && !eq) ) {
X      if( e != NIL(char) ) *e = '\0';
X      res = Expand(i);
X   }
X   else if( e != NIL(char) ) {
X      e = _strspn(e," \t\n");
X      if( *e ) res = Expand(e);
X   }
X
X   FREE(l);
X   FREE(r);
X   return(res);
}
X
X
static char *
_exec_sort( args )
char *args;
{
X   char *res  = NIL(char);
X   char *data = Expand(args);
X   char **tokens = NIL(char *);
X   char *p;
X   char *white = " \t\n";
X   int  j;
X   int  i = 0;
X
X   for( i=0,p=_strspn(data,white); *p; p=_strspn(_strpbrk(p,white),white),i++);
X
X   if( i != 0 ) {
X      TALLOC(tokens, i, char *);
X
X      for( i=0,p=_strspn(data,white); *p; p=_strspn(p,white),i++){
X     tokens[i] = p;
X     p = _strpbrk(p,white);
X     if( *p ) *p++ = '\0';
X      }
X
X      qsort( tokens, i-1, sizeof(char *), _mystrcmp );
X
X      for( j=0; j<i; j++ ) res = _strapp(res, tokens[j]);
X      FREE(data);
X      FREE(tokens);
X   }
X
X   return(res);
}
X
X
static int
_mystrcmp( p, q )
CONST void *p;
CONST void *q;
{
X   return(strcmp(*((CONST char **)p),*((CONST char **)q)));
}
X
X
static char *
_exec_subst( pat, subst, data )
char *pat;
char *subst;
char *data;
{
X   char *res;
X
X   pat = Expand(pat);
X   subst = Expand(subst);
X   res = Apply_edit( Expand(data), pat, subst, TRUE, FALSE );
X   FREE(pat);
X   FREE(subst);
X
X   return(res);
}
X
X
static char *
_exec_shell( data )
char *data;
{
X   extern char *tempnam();
X   int wait  = Wait_for_completion;
X   char *res = NIL(char);
X   int free_buf = FALSE;
X   char *buffer;
X   int out;
X   int err;
X   FILE *tmp;
X   char *tmpnm;
X   CELL cell;
X   STRING rcp;
X   HASH   cname;
X
X   if( Suppress_temp_file ) return(NIL(char));
X
X   /* Set the temp CELL used for building prerequisite candidates to
X    * all zero so that we don't have to keep initializing all the
X    * fields. */
X   {
X      register char *s = (char *) &cell;
X      register int   n = sizeof(CELL);
X      while( n ) { *s++ = '\0'; n--; }
X   }
X   rcp.st_string  = _strspn(data, " \t+-%@");
X   rcp.st_attr    = Rcp_attribute( data );
X   rcp.st_next    = NIL(STRING);
X   cname.ht_name  = "Shell escape";
X   cell.ce_name   = &cname;
X   cell.ce_fname  = cname.ht_name;
X   cell.ce_recipe = &rcp;
X   cell.ce_flag   = F_TARGET|F_RULES;
X   cell.ce_attr   = A_PHONY|A_SILENT;
X
X   tmpnm = tempnam(NIL(char),"mk");
X   out = dup( 1 );
X   if( (tmp = fopen(tmpnm, "w")) == NIL(FILE) )
X      Open_temp_error( tmpnm, cname.ht_name );
X
X   Wait_for_completion = TRUE;
X   close( 1 );
X   dup( fileno(tmp) );
X   fclose( tmp );
X   Exec_commands( &cell );
X   close(1);
X   dup(out);
X   close(out);
X
X   /* Now we have to read the temporary file, get the tokens and return them
X    * as a string. */
X   if( (tmp = fopen(tmpnm, "r")) == NIL(FILE) )
X      Open_temp_error( tmpnm, cname.ht_name );
X
X   if( Buffer == NIL(char) ) {
X      Buffer_size = BUFSIZ-2;
X      buffer = MALLOC(BUFSIZ-2,char);
X      free_buf = TRUE;
X   }
X   else
X      buffer = Buffer;
X
X   while( fgets(buffer, Buffer_size, tmp) ) {
X      char *p = strchr(buffer, '\n');
X
X      if( p == NIL(char) )
X     res = _strjoin(res,buffer,-1,TRUE);
X      else {
X     *p = '\0';
X         res = _strapp(res,buffer);
X      }
X   }
X
X   fclose(tmp);
X   unlink(tmpnm);
X   FREE(tmpnm);
X   if( free_buf ) FREE(buffer);
X
X   Wait_for_completion = wait;
X   return(res);
}
SHAR_EOF
chmod 0640 dmake/function.c ||
echo 'restore of dmake/function.c failed'
Wc_c="`wc -c < 'dmake/function.c'`"
test 8398 -eq "$Wc_c" ||
    echo 'dmake/function.c: original size 8398, current size' "$Wc_c"
rm -f _shar_wnt_.tmp
fi
# ============= dmake/getinp.c ==============
if test -f 'dmake/getinp.c' -a X"$1" != X"-c"; then
    echo 'x - skipping dmake/getinp.c (File already exists)'
    rm -f _shar_wnt_.tmp
else
> _shar_wnt_.tmp
sed 's/^X//' << 'SHAR_EOF' > 'dmake/getinp.c' &&
/* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/getinp.c,v 1.1 91/05/06 15:23:15 dvadura Exp $
-- SYNOPSIS -- handle reading of input.
--
-- DESCRIPTION
--    The code in this file reads the input from the specified stream
--    into the provided buffer of size Buffer_size.  In doing so it deletes
--    comments.  Comments are delimited by the #, and
--    <nl> character sequences.  An exception is \# which
--    is replaced by # in the input.  Line continuations are signalled
--    at the end of a line and are recognized inside comments.
--    The line continuation is always  <\><nl>.
--
--    If the file to read is NIL(FILE) then the Get_line routine returns the
--    next rule from the builtin rule table if there is one.
--
-- AUTHOR
--      Dennis Vadura, [e-mail]
--      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
--
-- COPYRIGHT
--      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
--
--      This program is free software; you can redistribute it and/or
--      modify it under the terms of the GNU General Public License
--      (version 1), as published by the Free Software Foundation, and
--      found in the file 'LICENSE' included with this distribution.
--
--      This program is distributed in the hope that it will be useful,
--      but WITHOUT ANY WARRANTY; without even the implied warrant of
--      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--      GNU General Public License for more details.
--
--      You should have received a copy of the GNU General Public License
--      along with this program;  if not, write to the Free Software
--      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
--
-- LOG
--     $Log:    getinp.c,v $
X * Revision 1.1  91/05/06  15:23:15  dvadura
X * dmake Release Version 3.7
X *
*/
X
#include "extern.h"
X
#define IS_WHITE(A)  ((A == ' ') || (A == '\t') || (A == '\n') || (A == '\r'))
#define SCAN_WHITE(A) \
X    while( IS_WHITE(*A) ) A++;
X
static    int    _is_conditional ANSI((char*));
static    int    _handle_conditional ANSI((int, TKSTRPTR));
X
static int  rule_ind = 0;    /* index of rule when reading Rule_tab     */
static int  skip = FALSE;    /* if true the skip input         */
X
X
PUBLIC int
Get_line( buf, fil )/*
======================
X        Read a line of input from the file stripping
X        off comments.  The routine returns TRUE if EOF */
char *buf;
FILE *fil;
{
X   extern   char **Rule_tab;
X   register char *p;
X   register char *c;
X   char      *q;
X   char             *buf_org;
X   static   int     ignore = FALSE;
X   int          cont   = FALSE;
X   int          pos    = 0;
X   int         res;
X
X   DB_ENTER( "Get_line" );
X
X   if( fil == NIL(FILE) ) {
X      /* Reading the internal rule table.  Set the rule_index to zero.
X       * This way ReadEnvironment works as expected every time. */
X
X      while( (p = Rule_tab[ rule_ind++ ]) != NIL(char) )
X     /* The last test in this if '*p != '~', handles the environment
X      * passing conventions used by MKS to pass arguments.  We want to
X      * skip those environment entries. */
X     if( !Readenv || (Readenv && (strchr(p,'=') != NIL(char)) && *p!='~')){
X        strcpy( buf, p );
X
X        DB_PRINT( "io", ("Returning [%s]", buf) );
X        DB_RETURN( FALSE );
X     }
X
X      rule_ind = 0;
X
X      DB_PRINT( "io", ("Done Ruletab") );
X      DB_RETURN( TRUE );
X   }
X
X   buf_org = buf;
X
do_again:
X   do {
X      p = buf+pos;
X      if(feof( fil ) || (fgets( p, Buffer_size-pos, fil ) == NIL(char)))
X     DB_RETURN( TRUE );
X
X      Line_number++;
X
X      /* ignore input if ignore flag set and line ends in a continuation
X     character. */
X
X      q = p+strlen(p)-2;
X      /* ignore each RETURN at the end of a line before any further
X       * processing */
X      if( q[0] == '\r' && q[1] == '\n' ) {
X     q[0] = '\n';
X     q[1] = '\0';
X     q--;
X      }
X      /* you also have to deal with END_OF_FILE chars to process raw
X       * DOS-Files. Normally they are the last chars in file, but after
X       * working on these file with vi, there is an additional NEWLINE
X       * after the last END_OF_FILE. So if the second last char in the
X       * actual line is END_OF_FILE, you can skip the last char. Then
X       * you can search the line back until you find no more END_OF_FILE
X       * and nuke each you found by string termination. */
X      if( q[0] == '\032' )
X     q--;
X      while( q[1] == '\032' ) {
X     q[1] = '\0';
X     q--;
X      }
X
X      if( ignore ) {
X     if( q[0] != CONTINUATION_CHAR || q[1] != '\n' )  ignore = FALSE;
X     *p = '\0';
X     continue;
X      }
X
X      c = Do_comment(p, &q, Group || (*buf == '\t'));
X
X      /* Does the end of the line end in a continuation sequence? */
X
X      if( (q[0] == CONTINUATION_CHAR) && (q[1] == '\n')) {
X     /* If the continuation was at the end of a comment then ignore the
X      * next input line, (or lines until we get one ending in just <nl>)
X      * else it's a continuation, so build the input line from several
X      * text lines on input.  The maximum size of this is governened by
X      * Buffer_size */
X     if( q != p && q[-1] == CONTINUATION_CHAR ) {
X        strcpy( q, q+1 );
X        q--;
X        cont = FALSE;
X     }
X     else if( c != NIL(char) )
X        ignore = TRUE;
X     else
X        cont   = TRUE;
X      }
X      else {
X     cont = FALSE;
X      }
X
X      q    = ( c == NIL(char) ) ? q+2 : c;
X      pos += q-p;
X   }
X   while( (cont || !*buf) && (pos <= Buffer_size) );
X
X   if( buf[ pos-1 ] == '\n' )
X      buf[ --pos ] = '\0';
X   else
X      if( pos == Buffer_size-1 )
X     Fatal( "Input line too long, increase MAXLINELENGTH" );
X
X
X   /* Now that we have the next line of input to make, we should check to
X    * see if it is a conditional expression.  If it is then process it,
X    * otherwise pass it on to the parser. */
X
X   if( *(p = _strspn(buf, " \t\r\n")) == CONDSTART ) {
X      TKSTR token;
X
X      SET_TOKEN( &token, p );
X
X      p = Get_token( &token, "", FALSE );
X
X      if( (res = _is_conditional( p )) )    /* ignore non control special */
X      {                        /* targets               */
X     res  = _handle_conditional( res, &token );
X     skip = TRUE;
X      }
X      else {
X     CLEAR_TOKEN( &token );
X     res  = TRUE;
X      }
X   }
X
X   if( skip ) {
X      buf  = buf_org;        /* ignore line just read in */
X      pos  = 0;
X      skip = res;
X      goto do_again;
X   }
X
X   DB_PRINT( "io", ("Returning [%s]", buf) );
X   DB_RETURN( FALSE );
}
X
X
PUBLIC char *
Do_comment(str, pend, keep)/*
=============================
X   Search the input string looking for comment chars.  If it contains
X   comment chars then NUKE the remainder of the line, if the comment
X   char is preceeded by \ then shift the remainder of the line left
X   by one char. */
char *str;
char **pend;
int  keep;
{
X   char *c = str;
X
X   while( (c = strchr(c, COMMENT_CHAR)) != NIL(char) ) {
X      if( Comment || State == NORMAL_SCAN )
X     if( c != str && c[-1] == ESCAPE_CHAR ) {
X        strcpy( c-1, c );        /* copy it left, due to \# */
X        if( pend ) (*pend)--;    /* shift tail pointer left */
X     }
X     else {
X        *c = '\0';               /* a true comment so break */
X        break;
X     }
X      else {
X         if( keep )
X        c = NIL(char);
X     else
X        *c = '\0';
X
X     break;
X      }
X   }
X
X   return(c);
}
X
X
PUBLIC char *
Get_token( string, brk, anchor )/*
==================================
X    Return the next token in string.
X    Returns empty string when no more tokens in string.
X    brk is a list of chars that also cause breaks in addition to space and
X    tab, but are themselves returned as tokens.  if brk is NULL then the
X    remainder of the line is returned as a single token.
X
X    anchor if TRUE, says break on chars in the brk list, but only if
X    the entire token begins with the first char of the brk list, if
X    FALSE then any char of brk will cause a break to occurr. */
X
TKSTRPTR  string;
char      *brk;
int      anchor;
{
X   register char *s;
X   register char *curp;
X   register char *t;
X   int           done = FALSE;
X   char          space[10];
X
X   DB_ENTER( "Get_token" );
X
X   s  = string->tk_str;              /* Get string parameters    */
X   *s = string->tk_cchar;          /* ... and strip leading w/s    */
X
X   SCAN_WHITE( s );
X
X   DB_PRINT( "tok", ("What's left [%s]", s) );
X
X   if( !*s ) {
X      DB_PRINT( "tok", ("Returning NULL token") );
X      DB_RETURN( "" );
X   }
X
X
X   /* Build the space list.  space contains all those chars that may possibly
X    * cause breaks.  This includes the brk list as well as white space. */
X
X   if( brk != NIL(char) ) {
X      strcpy( space, " \t\r\n" );
X      strcat( space, brk   );
X   }
X   else {
X      space[0] = 0xff;            /* a char we know will not show up      */
X      space[1] = 0;
X   }
X
X
X   /* Handle processing of quoted tokens.  Note that this is disabled if
X    * brk is equal to NIL */
X
X   while( *s == '\"' && ((brk != NIL(char)) || !string->tk_quote) ) {
X      s++;
X      if( string->tk_quote ) {
X     curp = s-1;
X     do { curp = strchr( curp+1, '\"' ); }
X     while( (curp != NIL(char)) && (*(curp+1) == '\"'));
X
X         if( curp == NIL(char) ) Fatal( "Unmatched quote in token" );
X     string->tk_quote = !string->tk_quote;
X
X     /* Check for "" case, and if found ignore it */
X     if( curp == s ) continue;
X     goto found_token;
X      }
X      else
X     SCAN_WHITE( s );
X
X      string->tk_quote = !string->tk_quote;
X   }
X
X
X   /* Check for a token break character at the beginning of the token.
X    * If found return the next set of break chars as a token. */
X
X   if( (brk != NIL(char)) && (strchr( brk, *s ) != NIL(char)) ) {
X      curp = _strspn( s, brk );
X      done = (anchor == 0) ? TRUE :
X         ((anchor == 1)?(*s == *brk) : (*brk == curp[-1]));
X   }
X
X
X   /* Scan for the next token in the list and return it less the break char
X    * that was used to terminate the token.  It will possibly be returned in
X    * the next call to Get_token */
X
X   if( !done ) {
X      SCAN_WHITE( s );
X
X      t = s;
X      do {
X     done = TRUE;
X     curp = _strpbrk(t, space);
X
X     if( anchor && *curp && !IS_WHITE( *curp ) )
X        if( ((anchor == 1)?*curp:_strspn(curp,brk)[-1]) != *brk ) {
X           t++;
X           done = FALSE;
X        }
X      }
X      while( !done );
X
X      if( (curp == s) && (strchr(brk, *curp) != NIL(char)) ) curp++;
X   }
X
found_token:
X   string->tk_str   = curp;
X   string->tk_cchar = *curp;
X   *curp = '\0';
X
X   DB_PRINT( "tok", ("Returning [%s]", s) );
X   DB_RETURN( s );
}
X
X
static int
_is_conditional( tg )/*
=======================
X    Look at tg and return it's value if it is a conditional identifier
X    otherwise return 0. */
char *tg;
{
X   DB_ENTER( "_is_conditional" );
X
X   tg++;
X   switch( *tg ) {
X      case 'I': if( !strcmp( tg, "IF" )) DB_RETURN( ST_IF   ); break;
X
X      case 'E':
X         if( !strcmp( tg, "END" ))     DB_RETURN( ST_END  );
X         else if( !strcmp( tg, "ENDIF")) DB_RETURN( ST_END  );
X         else if( !strcmp( tg, "ELSE" )) DB_RETURN( ST_ELSE );
X         else if( !strcmp( tg, "ELIF" )) DB_RETURN( ST_ELIF );
X     break;
X   }
X
X   DB_RETURN( 0 );
}
X
X
X
#define SEEN_END  0x00
#define SEEN_IF   0x01
#define SEEN_ELSE 0x02
X
static int
_handle_conditional( opcode, tg )/*
===================================
X    Perform the necessary processing for .IF conditinal targets.
X    Someday this should be modified to do bracketted expressions ala
X    CPP... sigh */
int      opcode;
TKSTRPTR tg;
{
X   static short    action[MAX_COND_DEPTH];
X   static char  ifcntl[MAX_COND_DEPTH];
X   char     *tok, *lhs, *rhs, *op, *expr;
X   int      result;
X
X   DB_ENTER( "_handle_conditional" );
X
X   switch( opcode ) {
X      case ST_ELIF:
X         if( !(ifcntl[Nest_level] & SEEN_IF) || (ifcntl[Nest_level]&SEEN_ELSE) )
X        Fatal(".ELIF without a preceeding .IF" );
X     /* FALLTHROUGH */
X
X      case ST_IF:
X     if( opcode == ST_IF && (Nest_level+1) == MAX_COND_DEPTH )
X        Fatal( ".IF .ELSE ... .END nesting too deep" );
X
X     If_expand = TRUE;
X     expr = Expand( Get_token( tg, NIL(char), FALSE ));
X     If_expand = FALSE;
X     lhs = _strspn( expr, " \t" );
X     if( !*lhs ) lhs = NIL(char);
X
X     if( (op = _strstr( lhs, "==" )) == NIL(char) )
X        op = _strstr( lhs, "!=" );
X
X     if( op == NIL(char) )
X        result = (lhs != NIL(char));
X     else {
X        op[1] = op[0];
X        if( lhs != op ) {
X           for( tok = op-1; (tok != lhs) && ((*tok == ' ')||(*tok == '\t'));
SHAR_EOF
true || echo 'restore of dmake/getinp.c failed'
fi
echo 'End of part 9, continue with part 10'
echo 10 > _shar_seq_.tmp
exit 0

exit 0 # Just in case...
--
Kent Landfield                   INTERNET: [e-mail]
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    [phone]         FAX:      [phone]
Please send comp.sources.misc-related mail to [e-mail].