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