/* RCS  $Id: macparse.c,v 1.1.1.1 2000/09/22 15:33:25 hr Exp $
--
-- SYNOPSIS
--      Parse a macro definition
-- 
-- DESCRIPTION
--	This file contains the code that parses a macro definition
--	stored in a buffer.  If the string in buffer is not a valid
--	macro definition the routie Parse_macro returns 0, otherwise it
--	returns 1 to indicate success.
-- 
-- 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"

PUBLIC int
Parse_macro( buffer, flag )/*
=============================
   Parse the string in buffer and define it as a macro if it is a valid macro.
   Note especially the string .SETDIR= since it is an attribute, but looks a
   lot like a macro definition.  This would not be a problem if make used
   white space as token separators, since this is not the case we must do
   something about it. */
char *buffer;
int  flag;
{
   char		 *result;	/* temporary pointer for strings   */
   TKSTR          input;        /* place to scan the buffer from   */
   HASHPTR	  hv;		/* pointer to hash table value	   */
   int		  operator;	/* what macro operator do we have  */
   char *tok1;			/* temporary place to keep a token */
   char *tok2;			/* temporary place to keep a token */

   DB_ENTER( "Parse_macro" );

   SET_TOKEN( &input, buffer );
   tok1 = Get_token( &input, "=+:*!?", 0 );

   operator=Macro_op(tok1);
   if( operator ) {
      Error( "No macro name" );
      CLEAR_TOKEN( &input );
      DB_RETURN( 1 );
   }

   tok1 = DmStrDup(tok1);
   tok2 = Get_token( &input, "=+:*!?", 2 );
   if( !(operator = Macro_op(tok2)) || !strcmp(tok1,".SETDIR") ) {
      CLEAR_TOKEN( &input );
      FREE(tok1);
      DB_RETURN(0);
   }

   tok2 = Expand(tok1); FREE(tok1); tok1 = tok2;
   tok2 = Get_token(&input, NIL( char ), FALSE);

   /* Make sure we can force the assignment. */
   if ( operator & M_OP_SI ) {
      flag |= M_FORCE|M_MULTI;
      operator &= ~M_OP_SI;
   }

   switch( operator ) {
      case M_OP_PLCL:
	  tok2 = Expand( tok2 );
	  /* Fall thru */

      case M_OP_PL:
	 /* Add to an existing macro, if it is not defined, though, then
	  * just define a new macro */

	 if( (hv = GET_MACRO(tok1)) == NIL(HASH) || hv->ht_value == NIL(char) )
	    Def_macro( tok1, tok2, flag );
	 else {
	    result = DmStrAdd( hv->ht_value, tok2, FALSE );
	    Def_macro( tok1, result, flag );
	    FREE( result );
	 }
	 if( operator == M_OP_PLCL ) FREE(tok2);
	 break;

      case M_OP_DF:
 	 if( (hv = GET_MACRO(tok1)) != NIL(HASH) && !(hv->ht_flag & M_INIT) )
	    break;
	 /* else FALLTHRU */

      case M_OP_EQ:
	 Def_macro( tok1, tok2, flag );
	 break;

      case M_OP_DFCL:
 	 if( (hv = GET_MACRO(tok1)) != NIL(HASH) && !(hv->ht_flag & M_INIT) )
	    break;
	 /* else FALLTHRU */

      case M_OP_CL:
	 tok2 = Expand( tok2 );
	 Def_macro( tok1, tok2, M_EXPANDED | flag );
	 FREE( tok2 );
	 break;

      case M_OP_CM:{
	 CELLPTR     cp;
	 STRINGPTR   sp;

	 if (flag & M_PUSH) {
	    Error("Nested conditional definition [%s ?= %s] ignored",
		  tok1, tok2);
	 }
	 else {
	    cp = Def_cell(tok1);
	    if (cp->ce_flag & F_MULTI) {
	       LINKPTR lp;
	       for(lp=cp->ce_prq; lp->cl_next; lp=lp->cl_next);
	       cp = lp->cl_prq;
	    }
	    TALLOC(sp,1,STRING);
	    sp->st_string = DmStrDup(tok2);
	    sp->st_next   = cp->ce_cond;
	    cp->ce_cond   = sp;

	    tok1 = NIL(char);
	 }
      }
      break;
   }

   if (tok1) {	    
      if ( LastMacName != NIL(char) )
	 FREE( LastMacName );

      LastMacName = tok1;
   }

   DB_RETURN( 1 );
}



PUBLIC int
Macro_op( op )/*
================
   Check the passed in op string and map it to one of the macro operators */
char *op;
{
   int ret = 0;
   DB_ENTER( "macro_op" );

   if ( *op == '!' ) {
      ret = M_OP_SI;
      op++;
   }

   switch( *op ) {
      case '=': ret |= M_OP_EQ; break;
      case ':': ret |= M_OP_CL; op++; break;

      case '+':
	 op++;
         if( *op == ':' ) {
	    ret |= M_OP_PLCL;
	    op++;
	 }
	 else {
	    ret |= M_OP_PL;
	 }
         break;

      case '*':
	 op++;
         if( *op == ':' ) {
	    ret |= M_OP_DFCL;
	    op++;
	 }
	 else {
	    ret |= M_OP_DF;
	 }
         break;

      case '?':
	 ret |= M_OP_CM;
	 op++;
	 break;
   }

   if( *op != '=' )
      ret = 0;
   else {
      op++;
      
      if( *op != '\0' )
	 ret = 0;
   }

   DB_RETURN( ret );
}
