home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 529b.lha / BMake_v1.1 / macro.c < prev    next >
C/C++ Source or Header  |  1991-07-02  |  4KB  |  158 lines
  1. /*    macro.c
  2.  *    (c) Copyright 1991 by Ben Eng, All Rights Reserved
  3.  *
  4.  *    USER DEFINABLE variables
  5.  *
  6.  *    $x        = the variable x
  7.  *    $(var)    = the variable var
  8.  *    ${var}    = the same variable var
  9.  *
  10.  *    INTERNAL AUTOMATIC variables (not for user definitions)
  11.  *
  12.  *    $$ = $
  13.  *    $@ = target filename
  14.  *    $* = basename of target
  15.  *    $< = dependent filename
  16.  *    $^ = all dependents of target newer than target
  17.  *    $% = dependent member of the target archive (not-imp)
  18.  *    $? = all dependents of the target archive (not-imp)
  19.  */
  20.  
  21. #include <clib/exec_protos.h>
  22.  
  23. #include "make.h"
  24. #include "depend.h"
  25.  
  26. /*    internal function used to find an existing variable */
  27. struct target *
  28. find_macro( char *macroname )
  29. {
  30.     struct macro *mac = NULL;
  31.  
  32.     for( struct macro *ln = Global.macrolist.lh_Head; ln->node.ln_Succ;
  33.         ln = ln->node.ln_Succ ) {
  34.         if( !strcmp( macroname, ln->name )) {
  35.             mac = ln;
  36.             break;
  37.         }
  38.     }
  39.  
  40.     return( mac );
  41. }
  42.  
  43. /*    internal allocation function */
  44. struct macro *
  45. new_macro( char *name, char *expansion )
  46. {
  47.     long size = sizeof(struct macro);
  48.     struct macro *new = (struct macro *)calloc( size, 1 );
  49.     if( new ) {
  50.         if( name )
  51.             if( !(new->name = strdup( name ))) goto death;
  52.         if( expansion )
  53.             if( !(new->expansion = strdup( expansion ))) goto death;
  54.         new->flags = 0;
  55.     }
  56.     return( new );
  57. death:
  58.     if( new ) {
  59.         if( new->name ) free( new->name );
  60.         if( new->expansion ) free( new->expansion );
  61.         free( new );
  62.     }
  63.     return( NULL );
  64. }
  65.  
  66. /*    internal deallocation function */
  67. int
  68. delete_macro( struct macro *mac )
  69. {
  70.     if( mac->name ) free( mac->name );
  71.     if( mac->expansion ) free( mac->expansion );
  72.     free( mac );
  73.     return( 0 );
  74. }
  75.  
  76. /*    perform a variable assignment
  77.  *    this is the entry point from outside
  78.  *    a NULL or null string will delete the variable
  79.  */
  80. struct macro *
  81. set_macro( char *name, char *expansion )
  82. {
  83.     struct macro *mac = NULL;
  84.     int create_flag = (expansion && !isemptyline( expansion ));
  85.  
  86.     if( mac = find_macro( name )) {
  87.         if( create_flag ) {
  88.             if( mac->expansion ) free( mac->expansion );
  89.             mac->expansion = strdup( expansion );
  90.         }
  91.         else {
  92.             Remove( &mac->node );
  93.             delete_macro( mac );
  94.             mac = NULL;
  95.         }
  96.     }
  97.     else
  98.         if( create_flag ) mac = new_macro( name, expansion );
  99.  
  100.     if( mac && !(mac->flags & MF_ADDED )) {
  101.         mac->flags |= MF_ADDED;
  102.         AddTail( &Global.macrolist, &mac->node );
  103.     }
  104.     return( mac );
  105. }
  106.  
  107. /*    Set's the automatic variables $@ $* and $<  */
  108. void
  109. set_target_macros( char *tarname, char *depname )
  110. {
  111.     struct macro *mac;
  112.  
  113.     if( tarname && *tarname ) {
  114.         char *dupname = strdup( tarname );
  115.         char *next;
  116.         if( dupname ) { /* try the more efficient way first */
  117.             next = strrchr( dupname, '.' );
  118.             if( next ) *next = (char)0; /* remove the extension */
  119.             mac    = set_macro( "*", dupname );
  120.             free( dupname );
  121.         }
  122.         else {
  123.             mac = set_macro( "*", tarname );
  124.             next = strrchr( mac->name, '.' );
  125.             if( next ) *next = (char)0; /* remove the extension */
  126.         }
  127.     }
  128.     else mac = set_macro( "*", NULL );
  129.     mac = set_macro( "@", tarname );
  130.     mac = set_macro( "<", depname );
  131. }
  132.  
  133. void
  134. delete_macrolist( struct List *list )
  135. {
  136.     for_list( list, delete_macro );
  137.     NewList( list );
  138. }
  139.  
  140. /* set a variable by expanding all macros in its value */
  141. struct macro *
  142. set_simplemacro( char *name, char *value )
  143. {
  144.     char *expansion = NULL;
  145.     struct macro *mac = NULL;
  146.  
  147.     expansion = (char *)malloc( Param.MaxLine );
  148.     if( !expansion ) goto death;
  149.  
  150.     if( expand_macros( expansion, value, Param.MaxLine )) goto death;
  151.     if( mac = set_macro( name, expansion )) {
  152.         mac->flags |= MF_SIMPLE;
  153.     }
  154. death:
  155.     if( expansion ) free( expansion );
  156.     return( mac );
  157. }
  158.