/*************************************************************************
 *
 *  $RCSfile: function.c,v $
 *
 *  $Revision: 1.4.20.2 $
 *
 *  last change: $Author: hr $ $Date: 2004/01/09 16:59:00 $
 *
 *  The Contents of this file are made available subject to the terms of
 *  either of the following licenses
 *
 *         - GNU Lesser General Public License Version 2.1
 *         - Sun Industry Standards Source License Version 1.1
 *
 *  Sun Microsystems Inc., October, 2000
 *
 *  GNU Lesser General Public License Version 2.1
 *  =============================================
 *  Copyright 2000 by Sun Microsystems, Inc.
 *  901 San Antonio Road, Palo Alto, CA 94303, USA
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License version 2.1, as published by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *  MA  02111-1307  USA
 *
 *
 *  Sun Industry Standards Source License Version 1.1
 *  =================================================
 *  The contents of this file are subject to the Sun Industry Standards
 *  Source License Version 1.1 (the "License"); You may not use this file
 *  except in compliance with the License. You may obtain a copy of the
 *  License at http://www.openoffice.org/license.html.
 *
 *  Software provided under this License is provided on an "AS IS" basis,
 *  WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
 *  WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
 *  MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
 *  See the License for the specific provisions governing your rights and
 *  obligations concerning the Software.
 *
 *  The Initial Developer of the Original Code is: Sun Microsystems, Inc.
 *
 *  Copyright: 2000 by Sun Microsystems, Inc.
 *
 *  All Rights Reserved.
 *
 *  Contributor(s): _______________________________________
 *
 *
 ************************************************************************/
/*
-- SYNOPSIS
--      GNU style functions for dmake.
--
-- DESCRIPTION
-- 	All GNU style 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, 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 *));
static int   _mystrcmp    ANSI((const PVOID, const PVOID));


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.
	   * 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); */
      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 ); */
   Append_line( data, TRUE, tmpfile, name, FALSE, FALSE );
   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 )
const PVOID p;
const PVOID q;
{
   return(strcmp(*((const char **)p),*((const char **)q)));
}


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);

      if( (tmp = Get_temp(&tmpnm, "", "w+")) == NIL(FILE) )
	 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(""));
}
