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 (!strncmp(varname, "OPT_", 4))
  54         buffer[0] = '\0';
  55     else
  56     {
  57         if (!quiet)
  58             printf("[MMAKE] Variable %s doesn't exist\n", varname);
  59         sprintf (buffer, "?$(%s)", varname);
  60     }
  61     return buffer;
  62 }
  63
  64 char *
  65 substvars (struct List * varlist, const char * str)
  66 {
  67     static char buffer[4096];
  68     char varname[256];
  69     const char * src;
  70     char * dest, * vptr;
  71
  72     assert (str);
  73
  74     src = str;
  75     dest = buffer;
  76
  77     while (*src)
  78     {
  79         if (*src == '$')
  80         {
  81             src += 2;
  82             vptr = varname;
  83
  84             while (*src && *src != ')')
  85             {
  86                 *vptr ++ = *src ++;
  87             }
  88             if (*src)
  89                 src ++;
  90
  91             *vptr = 0;
  92
  93             strcpy (dest, getvar (varlist, varname));
  94             dest += strlen (dest);
  95         }
  96         else
  97             *dest ++ = *src ++;
  98
  99         assert (dest<buffer+sizeof(buffer));
 100     }
 101
 102     *dest = 0;
 103
 104     return buffer;
 105 }
 106
 107 void
 108 setvar (struct List * varlist, const char * name, const char * val)
 109 {
 110     struct Var * var;
 111
 112     assert (name);
 113
 114 #if 0
 115     printf ("assign %s=%s\n", name, val);
 116 #endif
 117
 118     var = addnodeoncesize (varlist, name, sizeof(struct Var));
 119     SETSTR (var->value, val);
 120
 121 #if 0
 122     printf ("vars=");
 123     printvarlist (varlist);
 124 #endif
 125 }
 126
 127 void
 128 printvarlist (struct List * l)
 129 {
 130     struct Var * n;
 131
 132     ForeachNode (l,n)
 133     {
 134         printf ("    %s=%s\n", n->node.name, n->value);
 135     }
 136 }
 137
 138 void
 139 freevarlist (struct List * l)
 140 {
 141     struct Var * node, * next;
 142
 143     ForeachNodeSafe(l,node,next)
 144     {
 145         Remove (node);
 146
 147         xfree (node->node.name);
 148         cfree (node->value);
 149         xfree (node);
 150     }
 151 }
 152
 153 char **
 154 getargs (const char * line, int * argc, struct List * vars)
 155 {
 156     static char * argv[256];
 157     static char * buffer = NULL;
 158     char * src;
 159     int arg;
 160
 161     cfree (buffer);
 162     buffer = NULL;
 163
 164     if (!line)
 165         return NULL;
 166
 167     if (vars)
 168         buffer = xstrdup (substvars (vars, line));
 169     else
 170         buffer = xstrdup (line);
 171
 172     assert (buffer);
 173
 174     src = buffer;
 175     arg = 0;
 176
 177     while (*src)
 178     {
 179         while (isspace (*src))
 180             src ++;
 181
 182         if (!*src)
 183             break;
 184
 185         assert (arg < 255);
 186         argv[arg++] = src;
 187
 188         if (*src == '"')
 189         {
 190             while (*src && *src != '"')
 191                 src ++;
 192         }
 193         else
 194         {
 195             while (*src && !isspace (*src))
 196                 src ++;
 197         }
 198
 199         if (*src)
 200             *src++ = 0;
 201     }
 202
 203     argv[arg] = NULL;
 204
 205     if (argc)
 206         *argc = arg;
 207
 208     return argv;
 209 }