2004-09-08 10:06:20 -05:00
|
|
|
/* $RCSfile: function.c,v $
|
|
|
|
-- $Revision: 1.7 $
|
|
|
|
-- last change: $Author: rt $ $Date: 2004-09-08 16:06:20 $
|
|
|
|
--
|
2000-09-22 09:33:37 -05:00
|
|
|
-- SYNOPSIS
|
|
|
|
-- GNU style functions for dmake.
|
|
|
|
--
|
|
|
|
-- DESCRIPTION
|
2002-10-11 07:42:49 -05:00
|
|
|
-- All GNU style functions understood by dmake are implemented in this
|
2000-09-22 09:33:37 -05:00
|
|
|
-- file. Currently the only such function is $(mktmp ...) which is
|
|
|
|
-- not part of GNU-make is an extension provided by dmake.
|
|
|
|
--
|
|
|
|
-- AUTHOR
|
|
|
|
-- Dennis Vadura, dvadura@dmake.wticorp.com
|
|
|
|
--
|
|
|
|
-- WWW
|
|
|
|
-- http://dmake.wticorp.com/
|
|
|
|
--
|
|
|
|
-- COPYRIGHT
|
|
|
|
-- Copyright (c) 1996,1997 by WTI Corp. All rights reserved.
|
|
|
|
--
|
|
|
|
-- This program is NOT free software; you can redistribute it and/or
|
|
|
|
-- modify it under the terms of the Software License Agreement Provided
|
|
|
|
-- in the file <distribution-root>/readme/license.txt.
|
|
|
|
--
|
|
|
|
-- LOG
|
|
|
|
-- Use cvs log to obtain detailed change logs.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "extern.h"
|
|
|
|
|
|
|
|
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_echo ANSI((char *));
|
|
|
|
static char *_exec_uniq ANSI((char *));
|
|
|
|
static char *_exec_shell ANSI((char *, char *));
|
|
|
|
static char *_exec_call ANSI((char *, char *));
|
|
|
|
static char *_exec_assign ANSI((char *));
|
|
|
|
static char *_exec_foreach ANSI((char *, char *, char *));
|
|
|
|
static char *_exec_andor ANSI((char *, int));
|
|
|
|
static char *_exec_not ANSI((char *));
|
2002-10-04 07:31:37 -05:00
|
|
|
static int _mystrcmp ANSI((const PVOID, const PVOID));
|
2000-09-22 09:33:37 -05:00
|
|
|
|
|
|
|
|
|
|
|
PUBLIC char *
|
|
|
|
Exec_function(buf)/*
|
|
|
|
====================
|
|
|
|
Execute the function given by the value of args.
|
|
|
|
|
|
|
|
So far mktmp is the only valid function, anything else elicits and error
|
|
|
|
message. It is my hope to support the GNU style functions in this portion
|
|
|
|
of the code at some time in the future. */
|
|
|
|
char *buf;
|
|
|
|
{
|
|
|
|
char *fname;
|
|
|
|
char *args;
|
|
|
|
char *mod1;
|
|
|
|
char *mod2 = NIL(char);
|
|
|
|
char *res = NIL(char);
|
|
|
|
|
|
|
|
/* This must succeed since the presence of ' ', \t or \n is what
|
|
|
|
* determines if this function is called in the first place. */
|
|
|
|
FREE(ScanToken(buf, &args, FALSE));
|
|
|
|
fname = DmSubStr(buf, args);
|
|
|
|
|
|
|
|
if( (mod1 = strchr(fname,',')) != NIL(char) ){
|
|
|
|
*mod1 = '\0';
|
|
|
|
mod1++;
|
|
|
|
|
|
|
|
if( (mod2 = strchr(mod1,',')) != NIL(char) ){
|
|
|
|
*mod2 = '\0';
|
|
|
|
mod2++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
switch( *fname ) {
|
|
|
|
case 'a':
|
|
|
|
if(strncmp(fname,"assign",6) == 0)
|
|
|
|
res = _exec_assign(args);
|
|
|
|
else if(strncmp(fname,"and",3) == 0)
|
|
|
|
res = _exec_andor(args, TRUE);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'e':
|
|
|
|
if(strncmp(fname,"eq",2) == 0)
|
|
|
|
res = _exec_iseq(mod1,mod2,args,TRUE);
|
|
|
|
else if (strncmp(fname,"echo",4) == 0)
|
|
|
|
res = _exec_echo(args);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'f':
|
|
|
|
if(strncmp(fname,"foreach",7) == 0)
|
|
|
|
res = _exec_foreach(mod1,mod2,args);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'm':
|
|
|
|
if(strncmp(fname,"mktmp",5) == 0)
|
|
|
|
res = _exec_mktmp(mod1,mod2,args);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'n':
|
|
|
|
if( strncmp(fname,"null", 4) == 0 )
|
|
|
|
res = _exec_iseq(mod1,NIL(char),args,TRUE);
|
|
|
|
else if (strncmp(fname,"nil",3) == 0 )
|
|
|
|
res = DmStrDup("");
|
|
|
|
else if (strncmp(fname,"not",3) == 0 )
|
|
|
|
res = _exec_not(args);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case '!':
|
|
|
|
if(strncmp(fname,"!null",5) == 0)
|
|
|
|
res = _exec_iseq(mod1,NIL(char),args,FALSE);
|
|
|
|
else if(strncmp(fname,"!eq",3) ==0)
|
|
|
|
res = _exec_iseq(mod1,mod2,args,FALSE);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'o':
|
|
|
|
if(strncmp(fname,"or",2) == 0)
|
|
|
|
res = _exec_andor(args, FALSE);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 's':
|
|
|
|
if(strncmp(fname,"sort",4) == 0)
|
|
|
|
res = _exec_sort(args);
|
|
|
|
else if(strncmp(fname,"shell",5)==0)
|
|
|
|
res = _exec_shell(args,mod1);
|
|
|
|
else if(strncmp(fname,"strip",5)==0)
|
|
|
|
res = Tokenize(Expand(args)," ",'t',TRUE);
|
|
|
|
else if(strncmp(fname,"subst",5)==0)
|
|
|
|
res = _exec_subst(mod1,mod2,args);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case 'u':
|
|
|
|
if(strncmp(fname,"uniq",4) == 0)
|
|
|
|
res = _exec_uniq(args);
|
|
|
|
else
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
res = _exec_call(fname,args);
|
|
|
|
}
|
|
|
|
|
|
|
|
if( res == NIL(char) ) res = DmStrDup("");
|
|
|
|
|
|
|
|
FREE(fname);
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_assign( macrostring )
|
|
|
|
char *macrostring;
|
|
|
|
{
|
|
|
|
if ( !Parse_macro(macrostring, M_MULTI|M_FORCE) ) {
|
|
|
|
Error( "Dynamic macro assignment failed, while making [%s]\n",
|
|
|
|
Current_target ? Current_target->CE_NAME : "NIL");
|
|
|
|
return(DmStrDup(""));
|
|
|
|
}
|
|
|
|
|
|
|
|
return(DmStrDup(LastMacName));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_echo(data)
|
|
|
|
char *data;
|
|
|
|
{
|
|
|
|
return(DmStrDup(DmStrSpn(data," \t")));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_call( var, list )
|
|
|
|
char *var;
|
|
|
|
char *list;
|
|
|
|
{
|
|
|
|
char *res = NIL(char);
|
|
|
|
char *s;
|
|
|
|
TKSTR tk;
|
|
|
|
int i=0;
|
|
|
|
|
|
|
|
list = Expand(list);
|
|
|
|
|
|
|
|
SET_TOKEN(&tk,list);
|
|
|
|
while( *(s=Get_token(&tk, "", FALSE)) != '\0' ) {
|
|
|
|
char buf[40];
|
|
|
|
|
|
|
|
sprintf(buf, "%d", i++);
|
|
|
|
Def_macro(buf,s,M_MULTI|M_NOEXPORT|M_FORCE|M_PUSH);
|
|
|
|
}
|
|
|
|
CLEAR_TOKEN(&tk);
|
|
|
|
|
|
|
|
var = DmStrJoin(DmStrJoin("$(",var,-1,FALSE),")",-1,TRUE);
|
|
|
|
res = Expand(var);
|
|
|
|
|
|
|
|
i=0;
|
|
|
|
SET_TOKEN(&tk,list);
|
|
|
|
while( *(s=Get_token(&tk, "", FALSE)) != '\0' ) {
|
|
|
|
HASHPTR hp;
|
|
|
|
char buf[40];
|
|
|
|
|
|
|
|
sprintf(buf, "%d", i++);
|
|
|
|
hp = GET_MACRO(buf);
|
|
|
|
Pop_macro(hp);
|
|
|
|
FREE(hp->ht_name);
|
|
|
|
if(hp->ht_value) FREE(hp->ht_value);
|
|
|
|
FREE(hp);
|
|
|
|
}
|
|
|
|
CLEAR_TOKEN(&tk);
|
|
|
|
|
|
|
|
FREE(var);
|
|
|
|
FREE(list);
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_foreach( var, list, data )
|
|
|
|
char *var;
|
|
|
|
char *list;
|
|
|
|
char *data;
|
|
|
|
{
|
|
|
|
char *res = NIL(char);
|
|
|
|
char *s;
|
|
|
|
TKSTR tk;
|
|
|
|
HASHPTR hp;
|
|
|
|
|
|
|
|
var = Expand(var);
|
|
|
|
list = Expand(list);
|
|
|
|
|
|
|
|
data = DmStrSpn(data," \t\n");
|
|
|
|
SET_TOKEN(&tk,list);
|
|
|
|
hp = Def_macro(var,"",M_MULTI|M_NOEXPORT|M_FORCE|M_PUSH);
|
|
|
|
|
|
|
|
while( *(s=Get_token(&tk, "", FALSE)) != '\0' ) {
|
|
|
|
Def_macro(var,s,M_MULTI|M_NOEXPORT|M_FORCE);
|
|
|
|
res = DmStrAdd(res,Expand(data),TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
CLEAR_TOKEN(&tk);
|
|
|
|
Pop_macro(hp);
|
|
|
|
FREE(hp->ht_name);
|
|
|
|
if(hp->ht_value) FREE(hp->ht_value);
|
|
|
|
FREE(hp);
|
|
|
|
FREE(var);
|
|
|
|
FREE(list);
|
|
|
|
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_mktmp( file, text, data )
|
|
|
|
char *file;
|
|
|
|
char *text;
|
|
|
|
char *data;
|
|
|
|
{
|
|
|
|
register char *p;
|
|
|
|
char *tmpname;
|
|
|
|
char *name;
|
|
|
|
FILE *tmpfile = NIL(FILE);
|
|
|
|
|
|
|
|
/* This is only a test of the recipe line so prevent the tempfile side
|
|
|
|
* effects. */
|
|
|
|
if( Suppress_temp_file ) return(NIL(char));
|
|
|
|
|
|
|
|
name = Current_target ? Current_target->CE_NAME:"makefile text";
|
|
|
|
|
|
|
|
if( file && *file ) {
|
|
|
|
char *newtmp;
|
|
|
|
|
|
|
|
/* This call to Get_temp sets TMPFILE for subsequent expansion of file.
|
2003-12-17 09:01:08 -06:00
|
|
|
* The contents file variable passed may include TMPFILE to be expanded. */
|
|
|
|
/* Using TMPFILE as an argument to mktmp is no longer supported because it is not
|
|
|
|
* safe to create a random filename and assume the file does not exist. Howver,
|
|
|
|
* we still allow Expand() to do its job for fixed filenames */
|
|
|
|
/* Get_temp( &newtmp, "", FALSE ); FREE(newtmp); */
|
2000-09-22 09:33:37 -05:00
|
|
|
tmpname = Expand(file);
|
|
|
|
|
|
|
|
if( *tmpname ) {
|
|
|
|
if( (tmpfile = fopen(tmpname, "w")) == NIL(FILE) )
|
|
|
|
Open_temp_error( tmpname, name );
|
|
|
|
|
|
|
|
Def_macro("TMPFILE", tmpname, M_EXPANDED|M_MULTI);
|
|
|
|
Link_temp( Current_target, tmpfile, tmpname );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
FREE(tmpname);
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !tmpfile )
|
|
|
|
tmpfile = Start_temp( "", Current_target, &tmpname );
|
|
|
|
|
|
|
|
if( !text || !*text ) text = tmpname;
|
|
|
|
data = Expand(DmStrSpn(data, " \t\n"));
|
|
|
|
|
|
|
|
for(p=strchr(data,'\n'); p; p=strchr(p,'\n')) {
|
|
|
|
char *q = DmStrSpn(++p," \t");
|
|
|
|
strcpy(p,q);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* do not map escape sequences while writing a tmpfile */
|
|
|
|
/* Append_line( data, FALSE, tmpfile, name, FALSE, TRUE ); */
|
2003-08-18 09:04:15 -05:00
|
|
|
Append_line( data, TRUE, tmpfile, name, FALSE, FALSE );
|
2000-09-22 09:33:37 -05:00
|
|
|
Close_temp( Current_target, tmpfile );
|
|
|
|
FREE(data);
|
|
|
|
|
|
|
|
return( Expand(text) );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_iseq( lhs, rhs, data, eq )
|
|
|
|
char *lhs;
|
|
|
|
char *rhs;
|
|
|
|
char *data;
|
|
|
|
int eq;
|
|
|
|
{
|
|
|
|
char *l = Expand(lhs);
|
|
|
|
char *r = Expand(rhs);
|
|
|
|
char *i = DmStrSpn(data, " \t\n");
|
|
|
|
char *e = strchr(i, ' ');
|
|
|
|
char *res = NIL(char);
|
|
|
|
int val = strcmp(l,r);
|
|
|
|
|
|
|
|
if( (!val && eq) || (val && !eq) ) {
|
|
|
|
if( e != NIL(char) ) *e = '\0';
|
|
|
|
res = Expand(i);
|
|
|
|
}
|
|
|
|
else if( e != NIL(char) ) {
|
|
|
|
e = DmStrSpn(e," \t\n");
|
|
|
|
if( *e ) res = Expand(e);
|
|
|
|
}
|
|
|
|
|
|
|
|
FREE(l);
|
|
|
|
FREE(r);
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_sort( args )
|
|
|
|
char *args;
|
|
|
|
{
|
|
|
|
char *res = NIL(char);
|
|
|
|
char *data = Expand(args);
|
|
|
|
char **tokens;
|
|
|
|
char *p;
|
|
|
|
char *white = " \t\n";
|
|
|
|
int j;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i=0,p=DmStrSpn(data,white);*p;p=DmStrSpn(DmStrPbrk(p,white),white),i++);
|
|
|
|
|
|
|
|
if( i != 0 ) {
|
|
|
|
TALLOC(tokens, i, char *);
|
|
|
|
|
|
|
|
for( i=0,p=DmStrSpn(data,white); *p; p=DmStrSpn(p,white),i++){
|
|
|
|
tokens[i] = p;
|
|
|
|
p = DmStrPbrk(p,white);
|
|
|
|
if( *p ) *p++ = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
qsort( tokens, i, sizeof(char *), _mystrcmp );
|
|
|
|
|
|
|
|
for( j=0; j<i; j++ ) res = DmStrApp(res, tokens[j]);
|
|
|
|
FREE(data);
|
|
|
|
FREE(tokens);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_uniq( args )
|
|
|
|
char *args;
|
|
|
|
{
|
|
|
|
char *res = NIL(char);
|
|
|
|
char *data = Expand(args);
|
|
|
|
char **tokens;
|
|
|
|
char **tokens_after;
|
|
|
|
char *p;
|
|
|
|
char *white = " \t\n";
|
|
|
|
int j;
|
|
|
|
int i;
|
|
|
|
char *last = "";
|
|
|
|
int k = 0;
|
|
|
|
|
|
|
|
for(i=0,p=DmStrSpn(data,white);*p;p=DmStrSpn(DmStrPbrk(p,white),white),i++);
|
|
|
|
|
|
|
|
if( i != 0 ) {
|
|
|
|
TALLOC(tokens, i, char *);
|
|
|
|
TALLOC(tokens_after, i, char *);
|
|
|
|
|
|
|
|
for( i=0,p=DmStrSpn(data,white); *p; p=DmStrSpn(p,white),i++){
|
|
|
|
tokens[i] = p;
|
|
|
|
p = DmStrPbrk(p,white);
|
|
|
|
if( *p ) *p++ = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
qsort( tokens, i, sizeof(char *), _mystrcmp );
|
|
|
|
|
|
|
|
for( j=0; j<i; j++ ) {
|
|
|
|
if (strcmp(tokens[j], last) != 0) {
|
|
|
|
tokens_after[k++] = tokens[j];
|
|
|
|
last = tokens[j];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for( j=0; j<k; j++ ) res = DmStrApp(res, tokens_after[j]);
|
|
|
|
FREE(data);
|
|
|
|
FREE(tokens);
|
|
|
|
FREE(tokens_after);
|
|
|
|
}
|
|
|
|
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
_mystrcmp( p, q )
|
2002-10-04 07:31:37 -05:00
|
|
|
const PVOID p;
|
|
|
|
const PVOID q;
|
2000-09-22 09:33:37 -05:00
|
|
|
{
|
2002-10-04 07:31:37 -05:00
|
|
|
return(strcmp(*((const char **)p),*((const char **)q)));
|
2000-09-22 09:33:37 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_subst( pat, subst, data )
|
|
|
|
char *pat;
|
|
|
|
char *subst;
|
|
|
|
char *data;
|
|
|
|
{
|
|
|
|
char *res;
|
|
|
|
|
|
|
|
pat = Expand(pat);
|
|
|
|
subst = Expand(subst);
|
|
|
|
res = Apply_edit( Expand(data), pat, subst, TRUE, FALSE );
|
|
|
|
FREE(pat);
|
|
|
|
FREE(subst);
|
|
|
|
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_shell( data, mod1 )
|
|
|
|
char *data;
|
|
|
|
char *mod1;
|
|
|
|
{
|
|
|
|
extern char *tempnam();
|
|
|
|
static int nestlevel = 0;
|
|
|
|
static int org_out;
|
|
|
|
static int bsize;
|
|
|
|
static char *buffer;
|
|
|
|
static char *tmpnm;
|
|
|
|
static FILE *tmp;
|
|
|
|
|
|
|
|
int wait = Wait_for_completion;
|
|
|
|
uint16 vflag = Verbose;
|
|
|
|
int tflag = Trace;
|
|
|
|
char *res = NIL(char);
|
|
|
|
CELL cell;
|
|
|
|
STRING rcp;
|
|
|
|
HASH cname;
|
|
|
|
|
|
|
|
if( Suppress_temp_file ) return(NIL(char));
|
|
|
|
|
|
|
|
/* Set the temp CELL used for building prerequisite candidates to
|
|
|
|
* all zero so that we don't have to keep initializing all the
|
|
|
|
* fields. */
|
|
|
|
{
|
|
|
|
register char *s = (char *) &cell;
|
|
|
|
register int n = sizeof(CELL);
|
|
|
|
while( n ) { *s++ = '\0'; n--; }
|
|
|
|
}
|
|
|
|
rcp.st_string = DmStrSpn(data, " \t+-%@");
|
|
|
|
rcp.st_attr = Rcp_attribute( data );
|
|
|
|
rcp.st_next = NIL(STRING);
|
|
|
|
cname.ht_name = "Shell escape";
|
|
|
|
cell.ce_name = &cname;
|
|
|
|
cell.ce_all.cl_prq = &cell;
|
|
|
|
cell.ce_all.cl_next = NIL(LINK);
|
|
|
|
cell.ce_all.cl_flag = 0;
|
|
|
|
cell.ce_fname = cname.ht_name;
|
|
|
|
cell.ce_recipe = &rcp;
|
|
|
|
cell.ce_flag = F_TARGET|F_RULES;
|
|
|
|
cell.ce_attr = A_PHONY|A_SILENT;
|
|
|
|
|
|
|
|
if( nestlevel == 0 ) {
|
|
|
|
org_out = dup(1);
|
|
|
|
|
2003-12-17 09:01:08 -06:00
|
|
|
if( (tmp = Get_temp(&tmpnm, "", "w+")) == NIL(FILE) )
|
2000-09-22 09:33:37 -05:00
|
|
|
Open_temp_error( tmpnm, cname.ht_name );
|
|
|
|
|
|
|
|
close(1);
|
|
|
|
dup( fileno(tmp) );
|
|
|
|
|
|
|
|
bsize = (Buffer_size < BUFSIZ)?BUFSIZ:Buffer_size;
|
|
|
|
buffer = MALLOC(bsize,char);
|
|
|
|
}
|
|
|
|
|
|
|
|
Wait_for_completion = TRUE;
|
|
|
|
Verbose &= V_LEAVE_TMP;
|
|
|
|
Trace = FALSE;
|
|
|
|
nestlevel++;
|
|
|
|
Exec_commands( &cell );
|
|
|
|
Unlink_temp_files( &cell );
|
|
|
|
nestlevel--;
|
|
|
|
Trace = tflag;
|
|
|
|
Verbose = vflag;
|
|
|
|
Wait_for_completion = wait;
|
|
|
|
|
|
|
|
/* Now we have to read the temporary file, get the tokens and return them
|
|
|
|
* as a string. */
|
|
|
|
rewind(tmp);
|
|
|
|
while( fgets(buffer, bsize, tmp) ) {
|
|
|
|
char *p = strchr(buffer, '\n');
|
|
|
|
|
|
|
|
if( p == NIL(char) )
|
|
|
|
res = DmStrJoin(res,buffer,-1,TRUE);
|
|
|
|
else {
|
|
|
|
*p = '\0';
|
|
|
|
res = DmStrApp(res,buffer);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fclose(tmp);
|
|
|
|
if( nestlevel == 0 ) {
|
|
|
|
close(1);
|
|
|
|
dup(org_out);
|
|
|
|
close(org_out);
|
|
|
|
Remove_file(tmpnm);
|
|
|
|
FREE(tmpnm);
|
|
|
|
FREE(buffer);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if( (tmp = fopen(tmpnm, "w+")) == NIL(FILE) )
|
|
|
|
Open_temp_error( tmpnm, cname.ht_name );
|
|
|
|
|
|
|
|
close(1);
|
|
|
|
dup( fileno(tmp) );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( mod1 ) {
|
|
|
|
mod1 = Expand(res);
|
|
|
|
FREE(res);
|
|
|
|
res = mod1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_andor( args, doand )
|
|
|
|
char *args;
|
|
|
|
int doand;
|
|
|
|
{
|
|
|
|
char *next;
|
|
|
|
char *p;
|
|
|
|
char *white = " \t\n";
|
|
|
|
int res=doand;
|
|
|
|
|
|
|
|
args = DmStrSpn(args,white);
|
|
|
|
do {
|
|
|
|
p=ScanToken(args, &next, TRUE);
|
|
|
|
|
|
|
|
if (doand ? !*p : *p) {
|
|
|
|
res = !doand;
|
|
|
|
FREE(p);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
FREE(p);
|
|
|
|
}
|
|
|
|
while (*(args=DmStrSpn(next,white)));
|
|
|
|
|
|
|
|
return(res ? DmStrDup("t") : DmStrDup(""));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
_exec_not( args )
|
|
|
|
char *args;
|
|
|
|
{
|
|
|
|
char *white = " \t\n";
|
|
|
|
char *p=Expand(args);
|
|
|
|
int res = (*DmStrSpn(p,white) == '\0');
|
|
|
|
|
|
|
|
FREE(p);
|
|
|
|
return(res ? DmStrDup("t") : DmStrDup(""));
|
|
|
|
}
|