/* $RCSfile: dag.c,v $
-- $Revision: 1.12 $
-- last change: $Author: kz $ $Date: 2008-03-05 18:27:48 $
--
-- SYNOPSIS
--      Routines to construct the internal dag.
--
-- DESCRIPTION
--  This file contains all the routines that are responsible for
--  defining and manipulating all objects used by the make facility.
--
-- 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 void
set_macro_value(hp)/*
=====================
  Set the macro according to its type. In addition to the string value
  in hp->ht_value a macro can stores a value casted with its type.
*/
HASHPTR hp;
{
   switch( hp->ht_flag & M_VAR_MASK )   /* only one var type per var */
   {
      case M_VAR_STRING:
     *hp->MV_SVAR = hp->ht_value;
     /* Add special treatment for PWD/MAKEDIR for .WINPATH. */
     if( hp->MV_SVAR == &Pwd_macval ) {
        if( Pwd )
           FREE(Pwd);
        Pwd = hp->ht_value;
        /* Use the "DOSified" path for the macro. */
        *hp->MV_SVAR = hp->ht_value = DmStrDup(DO_WINPATH(hp->ht_value));
        DB_PRINT( "smv", ("PWD: %s/%s", Pwd_macval, Pwd) );
     } else if( hp->MV_SVAR == &Makedir_macval ) {
        if( Makedir )
           FREE(Makedir);
        Makedir = hp->ht_value;
        /* Use the "DOSified" path for the macro. */
        *hp->MV_SVAR = hp->ht_value = DmStrDup(DO_WINPATH(hp->ht_value));
        DB_PRINT( "smv", ("MAKEDIR: %s/%s", Makedir_macval, Makedir) );
     }
     /* No special treatment for TMD needed. */
     break;

      case M_VAR_CHAR:
         *hp->MV_CVAR = (hp->ht_value == NIL(char)) ? '\0':*hp->ht_value;
         break;

      case M_VAR_INT: {
         int tvalue;
         if( hp->MV_IVAR == NIL(int) ) break;   /* first time */

         tvalue = atoi(hp->ht_value);
         if( hp->MV_IVAR == &Buffer_size ) {
        /* If Buffer_size (MAXLINELENGTH) is modified then make sure
         * you change the size of the real buffer as well. As the
         * value will at least be BUFSIZ this might lead to the
         * situation that the (string) value of MAXLINELENGTH is
         * smaller than the integer value. */
            tvalue = (tvalue < (BUFSIZ-2)) ? BUFSIZ : tvalue+2;
            if( Buffer_size == tvalue ) break;
            if( Buffer ) FREE(Buffer);
            if((Buffer=MALLOC(tvalue, char)) == NIL(char)) No_ram();
            *Buffer = '\0';
         }
         *hp->MV_IVAR = tvalue;

         if( hp->MV_IVAR == &Max_proc || hp->MV_IVAR == &Max_proclmt ) {
            if( tvalue < 1 )
               Fatal( "Process limit value must be > 1" );

#if defined(USE_CREATEPROCESS)
            if( Max_proclmt > MAXIMUM_WAIT_OBJECTS )
               Fatal( "Specified maximum # of processes (MAXPROCESSLIMIT)"
              " exceeds OS limit of [%d].", MAXIMUM_WAIT_OBJECTS );
#endif

            if( Max_proc > Max_proclmt )
               Fatal( "Specified # of processes exceeds limit of [%d]",
                      Max_proclmt );

        /* Don't change MAXPROCESS value if .SEQUENTIAL is set. */
        if( (Glob_attr & A_SEQ) && (Max_proc != 1) ) {
           Warning( "Macro MAXPROCESS set to 1 because .SEQUENTIAL is set." );
           Max_proc = 1;
           if( hp->ht_value != NIL(char) ) FREE(hp->ht_value);
           hp->ht_value = DmStrDup( "1" );
        }
         }
      } break;

      case M_VAR_BIT:
         /* Bit variables are set to 1 if ht_value is not NULL and 0
          * otherwise */

         if( hp->ht_value == NIL(char) )
            *hp->MV_BVAR &= ~hp->MV_MASK;
         else {
            *hp->MV_BVAR |= hp->MV_MASK;
        /* If we're setting .SEQUENTIAL set MAXPROCESS=1. */
        if( (hp->MV_MASK & A_SEQ) && (Max_proc != 1) )
           Def_macro( "MAXPROCESS", "1", M_MULTI|M_EXPANDED);
     }

#if defined(__CYGWIN__)
     /* Global .WINPATH change. Only needed for cygwin. */
     if(hp->MV_MASK & A_WINPATH) {
        UseWinpath = ((Glob_attr&A_WINPATH) != 0);
        /* Change MAKEDIR, PWD according to .WINPATH. During
         * makefile evaluation this cannot change TMD (it is "."
         * and later TMD is set in Make() according to the
         * .WINPATH attribute. */
        Def_macro( "MAKEDIR", Makedir, M_FORCE | M_EXPANDED );
        Def_macro( "PWD", Pwd, M_FORCE | M_EXPANDED );
     }
#endif
     break;
   }
}


PUBLIC HASHPTR
Get_name( name, tab, define )/*
===============================
    Look to see if the name is defined, if it is then return
    a pointer to its node, if not return NIL(HASH).
    If define is TRUE and the name is not found it will be added. */

char    *name;          /* name we are looking for   */
HASHPTR *tab;           /* the hash table to look in */
int define;         /* TRUE => add to table      */
{
   register HASHPTR hp;
   register char    *p;
   uint16           hv;
   uint32           hash_key;

   DB_ENTER( "Get_name" );
   DB_PRINT( "name", ("Looking for %s", name) );

   hp = Search_table( tab, name, &hv, &hash_key );

   if( hp == NIL(HASH) && define ) {
      /* Check to make sure that CELL name contains only printable chars */
      for( p=name; *p; p++ )
     if( !isprint(*p) && !iswhite(*p) && *p != '\n' )
        Fatal( "Name contains non-printable character [0x%02x]", *p );

      TALLOC( hp, 1, HASH );        /* allocate a cell and add it in */

      hp->ht_name  = DmStrDup( name );
      hp->ht_hash  = hash_key;
      hp->ht_next  = tab[ hv ];
      tab[ hv ]    = hp;

      DB_PRINT( "name", ("Adding %s", name) );
   }

   DB_PRINT( "name",("Returning: [%s,%lu]",
         (hp == NIL(HASH)) ? "":hp->ht_name, hv) );
   DB_RETURN( hp );
}


PUBLIC HASHPTR
Search_table( tab, name, phv, phkey )
HASHPTR *tab;
char    *name;
uint16  *phv;
uint32  *phkey;
{
   HASHPTR hp;

   *phv = Hash( name, phkey );

   for( hp = tab[ *phv ]; hp != NIL(HASH); hp = hp->ht_next )
      if(    hp->ht_hash == *phkey
      && !strcmp(hp->ht_name, name) )
         break;

   return( hp );
}


PUBLIC HASHPTR
Push_macro(hp)/*
================
  This function pushes hp into the hash of all macros. If a previous
  instance of the macro exists it is hidden by the new one. If one
  existed before the new instance inherits some values from the preexisting
  macro (see below for details).
*/
HASHPTR hp;
{
   HASHPTR cur,prev;
   uint16  hv;
   uint32  key;

   hv = Hash(hp->ht_name, &key);

   /* Search for an existing instance of hp->ht_name, if found cur will point
    * to it. */
   for(prev=NIL(HASH),cur=Macs[hv]; cur!=NIL(HASH); prev=cur,cur=cur->ht_next)
      if(    cur->ht_hash == key
      && !strcmp(cur->ht_name, hp->ht_name) )
         break;

   if (cur == NIL(HASH) || prev == NIL(HASH)) {
      /* If no match or was found or the first element of Macs[hv] was
       * the match insert hp at the beginning. */
      hp->ht_next  = Macs[hv];
      Macs[hv] = hp;
   }
   else {
      /* otherwise insert hp in the chain. */
      hp->ht_next = prev->ht_next;
      prev->ht_next = hp;
   }

   /* Inherit some parts of the former instance. Copying cur->var to hp->var
    * copies the old value. Keeping the M_VAR_MASK (variable type) makes sure
    * the type stays the same keeping M_PRECIOUS assures that the old values
    * cannot be overridden if it is/was set. */
   if (cur) {
      memcpy((void *)&hp->var, (void *)&cur->var, sizeof(hp->var));
      hp->ht_flag |= ((M_VAR_MASK|M_PRECIOUS) & cur->ht_flag);
   }

   return(hp);
}


PUBLIC HASHPTR
Pop_macro(hp)/*
================
  This function pops (removes) hp from the hash of all macros. If a previous
  instance of the macro existed it becomes accessible again.
*/

HASHPTR hp;
{
   HASHPTR cur,prev;
   uint16  hv;
   uint32  key;

   hv = Hash(hp->ht_name, &key);

   /* Try to find hp. */
   for(prev=NIL(HASH),cur=Macs[hv]; cur != NIL(HASH);prev=cur,cur=cur->ht_next)
      if (cur == hp)
     break;

   /* If cur == NIL macros was not found. */
   if (cur == NIL(HASH))
      return(NIL(HASH));

   /* Remove hp from the linked list. */
   if (prev)
      prev->ht_next = cur->ht_next;
   else
      Macs[hv] = cur->ht_next;

   /* Look for a previous (older) instance of hp->ht_name. */
   for(cur=cur->ht_next; cur != NIL(HASH); cur=cur->ht_next)
      if(    cur->ht_hash == key
      && !strcmp(cur->ht_name, hp->ht_name) )
         break;

   /* If one was found we restore the typecast values. */
   if (cur)
      set_macro_value(cur);

   hp->ht_next = NIL(HASH);
   return(hp);
}



PUBLIC HASHPTR
Def_macro( name, value, flags )/*
=================================
   This routine is used to define a macro, and it's value. A copy of
   the content of value is stored and not the pointer to the value.
   The flags indicates if it is a permanent macro or if it's value
   can be redefined.  A flags of M_PRECIOUS means it is a precious
   macro and cannot be further redefined unless M_FORCE is used.
   If the flags flag contains the M_MULTI bit it means that the macro
   can be redefined multiple times and no warning of the redefinitions
   should be issued.
   Once a macro's VAR flags are set they are preserved through all future
   macro definitions.

   Macro definitions that have one of the variable bits set are treated
   specially.  In each case the hash table entry var field points at the
   global variable that can be set by assigning to the macro.

   bit valued global vars must be computed when the macro value is changed.
   char valued global vars must have the first char of ht_value copied to
   them.  string valued global vars have the same value as ht_value and should
   just have the new value of ht_value copied to them.  */

char    *name;          /* macro name to define */
char    *value;         /* macro value to set   */
int     flags;          /* initial ht_flags */
{
   register HASHPTR   hp;
   register char      *p, *q;

   DB_ENTER( "Def_macro" );
   DB_PRINT( "mac", ("Defining macro %s = %s, %x", name, value, flags) );

   /* check to see if name is in the table, if so then just overwrite
      the previous definition.  Otherwise allocate a new node, and
      stuff it in the hash table, at the front of any linked list */

   if( Readenv ) flags |= M_LITERAL|M_EXPANDED;

   hp = Get_name( name, Macs, TRUE );

   if ((flags & M_PUSH) && hp->ht_name != NIL(char)) {
      HASHPTR thp=hp;
      TALLOC(hp,1,HASH);
      hp->ht_name  = DmStrDup(thp->ht_name);
      hp->ht_hash  = thp->ht_hash;
      Push_macro(hp);
      flags |= hp->ht_flag;
   }
   flags &= ~M_PUSH;

   if( (hp->ht_flag & M_PRECIOUS) && !(flags & M_FORCE) ) {
      if  (Verbose & V_WARNALL)
         Warning( "Macro `%s' cannot be redefined", name );
      DB_RETURN( hp );
   }

   /* Make sure we don't export macros whose names contain legal macro
    * assignment operators, since we can't do proper quoting in the
    * environment. */
   if( *DmStrPbrk(name, "*+:=") != '\0' ) flags |= M_NOEXPORT;

   if( hp->ht_value != NIL(char) ) FREE( hp->ht_value );

   if( (hp->ht_flag & M_USED) && !((flags | hp->ht_flag) & M_MULTI) )
      Warning( "Macro `%s' redefined after use", name );

   /* If an empty string ("") is given set ht_value to NIL(char) */
   if( (value != NIL(char)) && (*value) ) {

      if( !(flags & M_LITERAL) ) {
     q = DmStrDup(value);
     /* strip out any \<nl> combinations where \ is the current
      * CONTINUATION char */
     for(p=q; (p=strchr(p,CONTINUATION_CHAR))!=NIL(char); )
        if( p[1] == '\n' ) {
           size_t len = strlen(p+2)+1;
           memmove ( p, p+2, len );
        }
        else
           p++;

     p = DmStrSpn(q ," \t");    /* Strip white space before ... */
     if( p != q ) {
        size_t len = strlen(p)+1;
        memmove( q, p, len );
        p = q;
     }

     if( *p ) {         /* ... and after the value. */
        for(q=p+strlen(p)-1; ((*q == ' ')||(*q == '\t')); q--);
        *++q = '\0';
     }
     flags &= ~M_LITERAL;
      }
      else
     p = DmStrDup( value );         /* take string literally   */

      if( !*p ) {               /* check if result is ""   */
         FREE( p );
         p = NIL(char);
     flags |= M_EXPANDED;
      }
      else if( *DmStrPbrk( p, "${}" ) == '\0' )
     flags |= M_EXPANDED;

      hp->ht_value = p;
   }
   else {
      hp->ht_value = NIL(char);
      flags |= M_EXPANDED;
   }

   /* Assign the hash table flag less the M_MULTI flag, it is used only
    * to silence the warning.  But carry it over if it was previously
    * defined in ht_flag, as this is a permanent M_MULTI variable. Keep
    * the M_PRECIOUS flag and strip the M_INIT flag. */

   hp->ht_flag = ((flags & ~(M_MULTI|M_FORCE)) |
          (hp->ht_flag & (M_VAR_MASK|M_MULTI|M_PRECIOUS))) & ~M_INIT;

   /* Check for macro variables and make the necessary adjustment in the
    * corresponding global variables */

   if( hp->ht_flag & M_VAR_MASK ) {
      if( !(flags & M_EXPANDED) )
     Error( "Macro variable '%s' must be assigned with :=", name );
      else
         set_macro_value(hp);
   }

   DB_RETURN( hp );
}



PUBLIC CELLPTR
Def_cell( name )/*
==================
   Check if a cell for "name" already exists, if not create a new cell.
   The value of name is normalized before checking/creating the cell to
   avoid creating multiple cells for the same target file.
   The function returns a pointer to the cell. */
char    *name;
{
   register HASHPTR  hp;
   register CELLPTR  cp;
   register CELLPTR  lib;
   char          *member;
   char          *end;

   DB_ENTER( "Def_cell" );

   /* Check to see if the cell is a member of the form lib(member) or
    * lib((symbol)) and handle the cases appropriately.
    * What we do is we look at the target, if it is of the above two
    * forms we get the lib, and add the member/symbol to the list of
    * prerequisites for the library.  If this is a symbol name def'n
    * we additionally add the attribute A_SYMBOL, so that stat can
    * try to do the right thing.  */

   if( ((member = strchr(name, '('))     != NIL(char)) &&
       ((end    = strrchr(member,  ')')) != NIL(char)) &&
       (member > name) && (member[-1] != '$') &&
       (end > member+1)  && (end[1] == '\0') )
   {
      *member++ = *end = '\0';

      if( (*member == '(') && (member[strlen(member)-1] == ')') ) {
     member[ strlen(member)-1 ] = '\0';
     cp = Def_cell( member+1 );
     cp->ce_attr |= A_SYMBOL;
      }
      else
     cp = Def_cell( member );

      lib  = Def_cell( name );

      Add_prerequisite( lib, cp, FALSE, FALSE );
      lib->ce_attr |= A_LIBRARY | A_COMPOSITE;

      if( !Def_targets ) cp = lib;
   }
   else {
      /* Normalize the name. */
      DB_PRINT( "path", ("Normalizing [%s]", name) );

      /* The normalizing function returns a pointer to a static buffer. */
      name = normalize_path(name);

      hp = Get_name( name, Defs, TRUE );/* get the name from hash table */

      if( hp->CP_OWNR == NIL(CELL) )    /* was it previously defined    */
      {                 /* NO, so define a new cell */
     DB_PRINT( "cell", ("Defining cell [%s]", name) );

     TALLOC( cp, 1, CELL );
     hp->CP_OWNR = cp;
     cp->ce_name = hp;
     cp->ce_fname = hp->ht_name;
     cp->ce_all.cl_prq = cp;
      }
      else              /* YES, so return the old cell  */
      {
     DB_PRINT( "cell", ("Getting cell [%s]", hp->ht_name) );
     cp = hp->CP_OWNR;
      }
   }

   DB_RETURN( cp );
}




PUBLIC LINKPTR
Add_prerequisite( cell, prq, head, force )/*
============================================
    Add a dependency node to the dag.  It adds it to the prerequisites,
    if any, of the cell and makes certain they are in linear order.
    If head == 1, then add to head of the prerequisite list, else
    add to tail. */
CELLPTR cell;
CELLPTR prq;
int     head;
int     force;
{
   register LINKPTR lp, tlp;

   DB_ENTER( "Add_prerequisite" );
   DB_PRINT( "cell", ("Defining prerequisite %s", prq->CE_NAME) );

   if( (prq->ce_flag & (F_MAGIC | F_PERCENT)) && !force )
      Fatal( "Special target [%s] cannot be a prerequisite",
             prq->CE_NAME );

   if( cell->ce_prq == NIL(LINK) ) {    /* it's the first one   */
      TALLOC( lp, 1, LINK );
      lp->cl_prq   = prq;
      cell->ce_prq = lp;
   }
   else {   /* search the list, checking for duplicates */
      for( lp = cell->ce_prq;
       (lp->cl_next != NIL(LINK)) && (lp->cl_prq != prq);
       lp = lp->cl_next );

      /* If the prq is not found and we are at the last prq in the list,
       * allocate a new prq and place it into the list, insert it at the
       * head if head == 1, else we add it to the end. */

      if( lp->cl_prq != prq ) {
     TALLOC( tlp, 1, LINK );
     tlp->cl_prq = prq;

     if( head ) {
        tlp->cl_next = cell->ce_prq;
        cell->ce_prq = tlp;
     }
     else
        lp->cl_next  = tlp;

     lp = tlp;
      }
   }

   DB_RETURN( lp );
}



PUBLIC void
Clear_prerequisites( cell )/*
=============================
    Clear out the list of prerequisites, freeing all of the LINK nodes,
    and setting the list to NULL */
CELLPTR cell;
{
   LINKPTR lp, tlp;

   DB_ENTER( "Clear_prerequisites" );
   DB_PRINT( "cell", ("Nuking prerequisites") );

   if( cell == NIL(CELL) ) { DB_VOID_RETURN; }

   for( lp=cell->ce_prq; lp != NIL(LINK); lp=tlp ) {
      tlp=lp->cl_next;
      FREE( lp );
   }

   cell->ce_prq = NIL(LINK);

   DB_VOID_RETURN;
}


PUBLIC int
Test_circle( cp, fail )/*
=========================
    Actually run through the graph */
CELLPTR cp;
int     fail;
{
   register LINKPTR lp;
   int res = 0;

   DB_ENTER( "Test_circle" );
   DB_PRINT( "tc", ("checking [%s]", cp->CE_NAME) );

   if( cp->ce_flag & F_MARK ) {
      if( fail )
     Fatal("Detected circular dependency in graph at [%s]", cp->CE_NAME);
      else
     DB_RETURN( 1 );
   }

   cp->ce_flag |= F_MARK;
   for( lp = cp->ce_prq; !res && lp != NIL(LINK); lp = lp->cl_next )
      res = Test_circle( lp->cl_prq, fail );
   cp->ce_flag ^= F_MARK;

   DB_RETURN( res );
}



PUBLIC STRINGPTR
Def_recipe( rcp, sp, white_too, no_check )/*
=============================================
   Take the recipe (rcp) and add it to the list of recipes pointed to by
   sp (sp points to the last element).  If white_too == TRUE add the recipe
   even if it contains only white space or an empty string.
   Return a pointer to the new recipe (or sp if it was discarded).
   If no_check is true then don't look for -@ at the start of the recipe
   line. */
char      *rcp;
STRINGPTR sp;
int       white_too;
int       no_check;
{
   register STRINGPTR nsp;
   register char      *rp;

   DB_ENTER( "Def_recipe" );
   DB_PRINT( "rul", ("Defining recipe %s", rcp) );

   if( !white_too ) rcp = DmStrSpn( rcp, " \t" );
   if( (rcp == NIL(char)) || (*rcp == 0 && !white_too) )
      DB_RETURN( sp );       /* return last recipe when new recipe not added */

   rp = no_check ? rcp : DmStrSpn( rcp, " \t@-+%" );

   TALLOC(nsp, 1, STRING);
   nsp->st_string = DmStrDup( rp );

   if( sp != NIL(STRING) ) sp->st_next = nsp;
   nsp->st_next = NIL(STRING);

   if( !no_check ) nsp->st_attr |= Rcp_attribute( rcp );

   DB_RETURN( nsp );
}


PUBLIC t_attr
Rcp_attribute( rp )/*
======================
   Look at the recipe and return the set of attributes that it defines. */
char *rp;
{
   t_attr flag = A_DEFAULT;
   int    done = FALSE;
   int atcount = 0;

   while( !done )
      switch( *rp++ )
      {
     case '@' : ++atcount;        break;
     case '-' : flag |= A_IGNORE; break;
     case '+' : flag |= A_SHELL;  break;
     case '%' :
#if defined(MSDOS)
        /* Ignore % in the non-MSDOS case. */
        flag |= A_SWAP;
#endif
        break;

     case ' ' :
     case '\t': break;

     default: done = TRUE; break;
      }

   if( !(Verbose & V_FORCEECHO) && atcount-- ) {
      flag |= A_SILENT;
      /* hide output if more than one @ are encountered. */
      if( atcount )
     flag |= A_MUTE;
   }

   return(flag);
}
