libs/wpp/wpp.c

   1 /*
   2  * Exported functions of the Wine preprocessor
   3  *
   4  * Copyright 1998 Bertho A. Stultiens
   5  * Copyright 2002 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "config.h"
  23 #include "wine/port.h"
  24
  25 #include <time.h>
  26 #include <stdlib.h>
  27
  28 #include "wpp_private.h"
  29 #include "wine/wpp.h"
  30
  31 int ppy_debug, pp_flex_debug;
  32
  33 struct define
  34 {
  35     struct define *next;
  36     char          *name;
  37     char          *value;
  38 };
  39
  40 static struct define *cmdline_defines;
  41
  42 static void add_cmdline_defines(void)
  43 {
  44     struct define *def;
  45
  46     for (def = cmdline_defines; def; def = def->next)
  47     {
  48         if (def->value) pp_add_define( def->name, def->value );
  49     }
  50 }
  51
  52 static void del_cmdline_defines(void)
  53 {
  54     struct define *def;
  55
  56     for (def = cmdline_defines; def; def = def->next)
  57     {
  58         if (def->value) pp_del_define( def->name );
  59     }
  60 }
  61
  62 static void add_special_defines(void)
  63 {
  64     time_t now = time(NULL);
  65     pp_entry_t *ppp;
  66     char buf[32];
  67
  68     strftime(buf, sizeof(buf), "\"%b %d %Y\"", localtime(&now));
  69     pp_add_define( "__DATE__", buf );
  70
  71     strftime(buf, sizeof(buf), "\"%H:%M:%S\"", localtime(&now));
  72     pp_add_define( "__TIME__", buf );
  73
  74     ppp = pp_add_define( "__FILE__", "" );
  75     if(ppp)
  76         ppp->type = def_special;
  77
  78     ppp = pp_add_define( "__LINE__", "" );
  79     if(ppp)
  80         ppp->type = def_special;
  81 }
  82
  83 static void del_special_defines(void)
  84 {
  85     pp_del_define( "__DATE__" );
  86     pp_del_define( "__TIME__" );
  87     pp_del_define( "__FILE__" );
  88     pp_del_define( "__LINE__" );
  89 }
  90
  91
  92 /* add a define to the preprocessor list */
  93 int wpp_add_define( const char *name, const char *value )
  94 {
  95     struct define *def;
  96
  97     if (!value) value = "";
  98
  99     for (def = cmdline_defines; def; def = def->next)
 100     {
 101         if (!strcmp( def->name, name ))
 102         {
 103             char *new_value = pp_xstrdup(value);
 104             if(!new_value)
 105                 return 1;
 106             free( def->value );
 107             def->value = new_value;
 108
 109             return 0;
 110         }
 111     }
 112
 113     def = pp_xmalloc( sizeof(*def) );
 114     if(!def)
 115         return 1;
 116     def->next  = cmdline_defines;
 117     def->name  = pp_xstrdup(name);
 118     if(!def->name)
 119     {
 120         free(def);
 121         return 1;
 122     }
 123     def->value = pp_xstrdup(value);
 124     if(!def->value)
 125     {
 126         free(def->name);
 127         free(def);
 128         return 1;
 129     }
 130     cmdline_defines = def;
 131     return 0;
 132 }
 133
 134
 135 /* undefine a previously added definition */
 136 void wpp_del_define( const char *name )
 137 {
 138     struct define *def;
 139
 140     for (def = cmdline_defines; def; def = def->next)
 141     {
 142         if (!strcmp( def->name, name ))
 143         {
 144             free( def->value );
 145             def->value = NULL;
 146             return;
 147         }
 148     }
 149 }
 150
 151
 152 /* add a command-line define of the form NAME=VALUE */
 153 int wpp_add_cmdline_define( const char *value )
 154 {
 155     char *p;
 156     char *str = pp_xstrdup(value);
 157     if(!str)
 158         return 1;
 159     p = strchr( str, '=' );
 160     if (p) *p++ = 0;
 161     wpp_add_define( str, p );
 162     free( str );
 163     return 0;
 164 }
 165
 166
 167 /* set the various debug flags */
 168 void wpp_set_debug( int lex_debug, int parser_debug, int msg_debug )
 169 {
 170     pp_flex_debug   = lex_debug;
 171     ppy_debug       = parser_debug;
 172     pp_status.debug = msg_debug;
 173 }
 174
 175
 176 /* set the pedantic mode */
 177 void wpp_set_pedantic( int on )
 178 {
 179     pp_status.pedantic = on;
 180 }
 181
 182
 183 /* the main preprocessor parsing loop */
 184 int wpp_parse( const char *input, FILE *output )
 185 {
 186     int ret;
 187
 188     pp_status.input = NULL;
 189     pp_status.line_number = 1;
 190     pp_status.char_number = 1;
 191     pp_status.state = 0;
 192
 193     ret = pp_push_define_state();
 194     if(ret)
 195         return ret;
 196     add_cmdline_defines();
 197     add_special_defines();
 198
 199     if (!input) pp_status.file = stdin;
 200     else if (!(pp_status.file = wpp_callbacks->open(input, 1)))
 201     {
 202         ppy_error("Could not open %s\n", input);
 203         del_special_defines();
 204         del_cmdline_defines();
 205         pp_pop_define_state();
 206         return 2;
 207     }
 208
 209     pp_status.input = input ? pp_xstrdup(input) : NULL;
 210
 211     ppy_out = output;
 212     pp_writestring("# 1 \"%s\" 1\n", input ? input : "");
 213
 214     ret = ppy_parse();
 215     /* If there were errors during processing, return an error code */
 216     if (!ret && pp_status.state) ret = pp_status.state;
 217
 218     if (input)
 219     {
 220         wpp_callbacks->close(pp_status.file);
 221         free(pp_status.input);
 222     }
 223     /* Clean if_stack, it could remain dirty on errors */
 224     while (pp_get_if_depth()) pp_pop_if();
 225     del_special_defines();
 226     del_cmdline_defines();
 227     pp_pop_define_state();
 228     return ret;
 229 }
 230
 231
 232 void wpp_set_callbacks( const struct wpp_callbacks *callbacks )
 233 {
 234     wpp_callbacks = callbacks;
 235 }