tools/MetaMake/var.c

   1 /* MetaMake - A Make extension
   2    Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3
   4 This file is part of MetaMake.
   5
   6 MetaMake is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 MetaMake is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22
  23 #include <assert.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #ifdef HAVE_STRING_H
  27 #   include <string.h>
  28 #else
  29 #   include <strings.h>
  30 #endif
  31
  32 #include "var.h"
  33 #include "mem.h"
  34 #include "mmake.h"
  35
  36
  37 /* Functions */
  38 char *
  39 getvar (struct List * varlist, const char * varname)
  40 {
  41     static char buffer[256];
  42     char *env_val;
  43     struct Var * var = FindNode (varlist, varname);
  44
  45     if (var)
  46         return var->value;
  47
  48     env_val = getenv(varname);
  49     if(env_val)
  50     {
  51         return env_val;
  52     }
  53     if (verbose)
  54         printf("[MMAKE] Variable %s doesn't exist\n", varname);
  55     sprintf (buffer, "?$(%s)", varname);
  56
  57     return buffer;
  58 }
  59
  60 char *
  61 substvars (struct List * varlist, const char * str)
  62 {
  63     static char buffer[4096];
  64     char varname[256];
  65     const char * src;
  66     char * dest, * vptr;
  67
  68     assert (str);
  69
  70     src = str;
  71     dest = buffer;
  72
  73     while (*src)
  74     {
  75         if (*src == '$')
  76         {
  77             src += 2;
  78             vptr = varname;
  79
  80             while (*src && *src != ')')
  81             {
  82                 *vptr ++ = *src ++;
  83             }
  84             if (*src)
  85                 src ++;
  86
  87             *vptr = 0;
  88
  89             strcpy (dest, getvar (varlist, varname));
  90             dest += strlen (dest);
  91         }
  92         else
  93             *dest ++ = *src ++;
  94
  95         assert (dest<buffer+sizeof(buffer));
  96     }
  97
  98     *dest = 0;
  99
 100     return buffer;
 101 }
 102
 103 void
 104 setvar (struct List * varlist, const char * name, const char * val)
 105 {
 106     struct Var * var;
 107
 108     assert (name);
 109
 110 #if 0
 111     printf ("assign %s=%s\n", name, val);
 112 #endif
 113
 114     var = addnodeoncesize (varlist, name, sizeof(struct Var));
 115     SETSTR (var->value, val);
 116
 117 #if 0
 118     printf ("vars=");
 119     printvarlist (varlist);
 120 #endif
 121 }
 122
 123 void
 124 printvarlist (struct List * l)
 125 {
 126     struct Var * n;
 127
 128     ForeachNode (l,n)
 129     {
 130         printf ("    %s=%s\n", n->node.name, n->value);
 131     }
 132 }
 133
 134 void
 135 freevarlist (struct List * l)
 136 {
 137     struct Var * node, * next;
 138
 139     ForeachNodeSafe(l,node,next)
 140     {
 141         Remove (node);
 142
 143         xfree (node->node.name);
 144         cfree (node->value);
 145         xfree (node);
 146     }
 147 }
 148
 149 char **
 150 getargs (const char * line, int * argc, struct List * vars)
 151 {
 152     static char * argv[256];
 153     static char * buffer = NULL;
 154     char * src;
 155     int arg;
 156
 157     cfree (buffer);
 158     buffer = NULL;
 159
 160     if (!line)
 161         return NULL;
 162
 163     if (vars)
 164         buffer = xstrdup (substvars (vars, line));
 165     else
 166         buffer = xstrdup (line);
 167
 168     assert (buffer);
 169
 170     src = buffer;
 171     arg = 0;
 172
 173     while (*src)
 174     {
 175         while (isspace (*src))
 176             src ++;
 177
 178         if (!*src)
 179             break;
 180
 181         assert (arg < 255);
 182         argv[arg++] = src;
 183
 184         if (*src == '"')
 185         {
 186             while (*src && *src != '"')
 187                 src ++;
 188         }
 189         else
 190         {
 191             while (*src && !isspace (*src))
 192                 src ++;
 193         }
 194
 195         if (*src)
 196             *src++ = 0;
 197     }
 198
 199     argv[arg] = NULL;
 200
 201     if (argc)
 202         *argc = arg;
 203
 204     return argv;
 205 }