libyasm/valparam.c

   1 /*
   2  * Value/Parameter type functions
   3  *
   4  *  Copyright (C) 2001-2007  Peter Johnson
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include "util.h"
  28
  29 #include "libyasm-stdint.h"
  30 #include "coretype.h"
  31 #include "valparam.h"
  32
  33 #include "errwarn.h"
  34 #include "intnum.h"
  35 #include "expr.h"
  36 #include "symrec.h"
  37
  38 #include "section.h"
  39
  40 void
  41 yasm_call_directive(const yasm_directive *directive, yasm_object *object,
  42                     yasm_valparamhead *valparams,
  43                     yasm_valparamhead *objext_valparams, unsigned long line)
  44 {
  45     yasm_valparam *vp;
  46
  47     if ((directive->flags & (YASM_DIR_ARG_REQUIRED|YASM_DIR_ID_REQUIRED)) &&
  48         (!valparams || !yasm_vps_first(valparams))) {
  49         yasm_error_set(YASM_ERROR_SYNTAX,
  50                        N_("directive `%s' requires an argument"),
  51                        directive->name);
  52         return;
  53     }
  54     if (valparams) {
  55         vp = yasm_vps_first(valparams);
  56         if ((directive->flags & YASM_DIR_ID_REQUIRED) &&
  57             vp->type != YASM_PARAM_ID) {
  58             yasm_error_set(YASM_ERROR_SYNTAX,
  59                 N_("directive `%s' requires an identifier parameter"),
  60                 directive->name);
  61             return;
  62         }
  63     }
  64     directive->handler(object, valparams, objext_valparams, line);
  65 }
  66
  67 yasm_valparam *
  68 yasm_vp_create_id(/*@keep@*/ char *v, /*@keep@*/ char *p, int id_prefix)
  69 {
  70     yasm_valparam *r = yasm_xmalloc(sizeof(yasm_valparam));
  71     r->val = v;
  72     r->type = YASM_PARAM_ID;
  73     r->param.id = p;
  74     r->id_prefix = (char)id_prefix;
  75     return r;
  76 }
  77
  78 yasm_valparam *
  79 yasm_vp_create_string(/*@keep@*/ char *v, /*@keep@*/ char *p)
  80 {
  81     yasm_valparam *r = yasm_xmalloc(sizeof(yasm_valparam));
  82     r->val = v;
  83     r->type = YASM_PARAM_STRING;
  84     r->param.str = p;
  85     r->id_prefix = '\0';
  86     return r;
  87 }
  88
  89 yasm_valparam *
  90 yasm_vp_create_expr(/*@keep@*/ char *v, /*@keep@*/ yasm_expr *p)
  91 {
  92     yasm_valparam *r = yasm_xmalloc(sizeof(yasm_valparam));
  93     r->val = v;
  94     r->type = YASM_PARAM_EXPR;
  95     r->param.e = p;
  96     r->id_prefix = '\0';
  97     return r;
  98 }
  99
 100 /*@null@*/ /*@only@*/ yasm_expr *
 101 yasm_vp_expr(const yasm_valparam *vp, yasm_symtab *symtab, unsigned long line)
 102 {
 103     if (!vp)
 104         return NULL;
 105     switch (vp->type) {
 106         case YASM_PARAM_ID:
 107             return yasm_expr_create_ident(yasm_expr_sym(
 108                 yasm_symtab_use(symtab, yasm_vp_id(vp), line)), line);
 109         case YASM_PARAM_EXPR:
 110             return yasm_expr_copy(vp->param.e);
 111         default:
 112             return NULL;
 113     }
 114 }
 115
 116 /*@null@*/ /*@dependent@*/ const char *
 117 yasm_vp_string(const yasm_valparam *vp)
 118 {
 119     if (!vp)
 120         return NULL;
 121     switch (vp->type) {
 122         case YASM_PARAM_ID:
 123             return vp->param.id;
 124         case YASM_PARAM_STRING:
 125             return vp->param.str;
 126         default:
 127             return NULL;
 128     }
 129 }
 130
 131 /*@null@*/ /*@dependent@*/ const char *
 132 yasm_vp_id(const yasm_valparam *vp)
 133 {
 134     if (!vp)
 135         return NULL;
 136     if (vp->type == YASM_PARAM_ID) {
 137         if (vp->param.id[0] == vp->id_prefix)
 138             return &vp->param.id[1];
 139         else
 140             return vp->param.id;
 141     }
 142     return NULL;
 143 }
 144
 145 void
 146 yasm_vps_delete(yasm_valparamhead *headp)
 147 {
 148     yasm_valparam *cur, *next;
 149
 150     cur = STAILQ_FIRST(headp);
 151     while (cur) {
 152         next = STAILQ_NEXT(cur, link);
 153         if (cur->val)
 154             yasm_xfree(cur->val);
 155         switch (cur->type) {
 156             case YASM_PARAM_ID:
 157                 yasm_xfree(cur->param.id);
 158                 break;
 159             case YASM_PARAM_STRING:
 160                 yasm_xfree(cur->param.str);
 161                 break;
 162             case YASM_PARAM_EXPR:
 163                 yasm_expr_destroy(cur->param.e);
 164                 break;
 165         }
 166         yasm_xfree(cur);
 167         cur = next;
 168     }
 169     STAILQ_INIT(headp);
 170 }
 171
 172 void
 173 yasm_vps_print(const yasm_valparamhead *headp, FILE *f)
 174 {
 175     const yasm_valparam *vp;
 176
 177     if(!headp) {
 178         fprintf(f, "(none)");
 179         return;
 180     }
 181
 182     yasm_vps_foreach(vp, headp) {
 183         if (vp->val)
 184             fprintf(f, "(\"%s\",", vp->val);
 185         else
 186             fprintf(f, "((nil),");
 187         switch (vp->type) {
 188             case YASM_PARAM_ID:
 189                 fprintf(f, "%s", vp->param.id);
 190                 break;
 191             case YASM_PARAM_STRING:
 192                 fprintf(f, "\"%s\"", vp->param.str);
 193                 break;
 194             case YASM_PARAM_EXPR:
 195                 yasm_expr_print(vp->param.e, f);
 196                 break;
 197         }
 198         fprintf(f, ")");
 199         if (yasm_vps_next(vp))
 200             fprintf(f, ",");
 201     }
 202 }
 203
 204 yasm_valparamhead *
 205 yasm_vps_create(void)
 206 {
 207     yasm_valparamhead *headp = yasm_xmalloc(sizeof(yasm_valparamhead));
 208     yasm_vps_initialize(headp);
 209     return headp;
 210 }
 211
 212 void
 213 yasm_vps_destroy(yasm_valparamhead *headp)
 214 {
 215     yasm_vps_delete(headp);
 216     yasm_xfree(headp);
 217 }
 218
 219 int
 220 yasm_dir_helper(void *obj, yasm_valparam *vp_first, unsigned long line,
 221                 const yasm_dir_help *help, size_t nhelp, void *data,
 222                 int (*helper_valparam) (void *obj, yasm_valparam *vp,
 223                                         unsigned long line, void *data))
 224 {
 225     yasm_valparam *vp = vp_first;
 226     int anymatched = 0;
 227     int matched;
 228
 229     if (!vp)
 230         return 0;
 231
 232     do {
 233         const char *s;
 234         size_t i;
 235
 236         matched = 0;
 237         if (!vp->val && (s = yasm_vp_id(vp))) {
 238             for (i=0; i<nhelp; i++) {
 239                 if (help[i].needsparam == 0 &&
 240                     yasm__strcasecmp(s, help[i].name) == 0) {
 241                     if (help[i].helper(obj, vp, line,
 242                                        ((char *)data)+help[i].off,
 243                                        help[i].arg) != 0)
 244                         return -1;
 245                     matched = 1;
 246                     anymatched = 1;
 247                     break;
 248                 }
 249             }
 250         } else if (vp->val) {
 251             for (i=0; i<nhelp; i++) {
 252                 if (help[i].needsparam == 1 &&
 253                     yasm__strcasecmp(vp->val, help[i].name) == 0) {
 254                     if (help[i].helper(obj, vp, line,
 255                                        ((char *)data)+help[i].off,
 256                                        help[i].arg) != 0)
 257                         return -1;
 258                     matched = 1;
 259                     anymatched = 1;
 260                     break;
 261                 }
 262             }
 263         }
 264
 265         if (!matched) {
 266             int final = helper_valparam(obj, vp, line, data);
 267             if (final < 0)
 268                 return -1;
 269             if (final > 0)
 270                 anymatched = 1;
 271         }
 272     } while((vp = yasm_vps_next(vp)));
 273
 274     return anymatched;
 275 }
 276
 277 int
 278 yasm_dir_helper_flag_or(void *obj, yasm_valparam *vp, unsigned long line,
 279                         void *d, uintptr_t flag)
 280 {
 281     unsigned long *flags = (unsigned long *)d;
 282     *flags |= flag;
 283     return 0;
 284 }
 285
 286 int
 287 yasm_dir_helper_flag_and(void *obj, yasm_valparam *vp, unsigned long line,
 288                          void *d, uintptr_t flag)
 289 {
 290     unsigned long *flags = (unsigned long *)d;
 291     *flags &= ~flag;
 292     return 0;
 293 }
 294
 295 int
 296 yasm_dir_helper_flag_set(void *obj, yasm_valparam *vp, unsigned long line,
 297                          void *d, uintptr_t flag)
 298 {
 299     unsigned long *flags = (unsigned long *)d;
 300     *flags = flag;
 301     return 0;
 302 }
 303
 304 int
 305 yasm_dir_helper_expr(void *obj, yasm_valparam *vp, unsigned long line,
 306                      void *data, uintptr_t arg)
 307 {
 308     yasm_object *object = (yasm_object *)obj;
 309     yasm_expr **expr = (yasm_expr **)data;
 310
 311     if (*expr)
 312         yasm_expr_destroy(*expr);
 313     if (!(*expr = yasm_vp_expr(vp, object->symtab, line))) {
 314         yasm_error_set(YASM_ERROR_VALUE, N_("argument to `%s' is not an expression"),
 315                        vp->val);
 316         return -1;
 317     }
 318     return 0;
 319 }
 320
 321 int
 322 yasm_dir_helper_intn(void *obj, yasm_valparam *vp, unsigned long line,
 323                      void *data, uintptr_t arg)
 324 {
 325     yasm_object *object = (yasm_object *)obj;
 326     /*@only@*/ /*@null@*/ yasm_expr *e;
 327     /*@dependent@*/ /*@null@*/ yasm_intnum *local;
 328     yasm_intnum **intn = (yasm_intnum **)data;
 329
 330     if (*intn)
 331         yasm_intnum_destroy(*intn);
 332     if (!(e = yasm_vp_expr(vp, object->symtab, line)) ||
 333         !(local = yasm_expr_get_intnum(&e, 0))) {
 334         yasm_error_set(YASM_ERROR_NOT_CONSTANT,
 335                        N_("argument to `%s' is not an integer"),
 336                        vp->val);
 337         if (e)
 338             yasm_expr_destroy(e);
 339         return -1;
 340     }
 341     *intn = yasm_intnum_copy(local);
 342     yasm_expr_destroy(e);
 343     return 0;
 344 }
 345
 346 int
 347 yasm_dir_helper_string(void *obj, yasm_valparam *vp, unsigned long line,
 348                        void *data, uintptr_t arg)
 349 {
 350     /*@dependent@*/ /*@null@*/ const char *local;
 351     char **s = (char **)data;
 352
 353     if (*s)
 354         yasm_xfree(*s);
 355     if (!(local = yasm_vp_string(vp))) {
 356         yasm_error_set(YASM_ERROR_VALUE,
 357                        N_("argument to `%s' is not a string or identifier"),
 358                        vp->val);
 359         return -1;
 360     }
 361     *s = yasm__xstrdup(local);
 362     return 0;
 363 }
 364
 365 int
 366 yasm_dir_helper_valparam_warn(void *obj, yasm_valparam *vp,
 367                               unsigned long line, void *data)
 368 {
 369     const char *s;
 370
 371     if (vp->val) {
 372         yasm_warn_set(YASM_WARN_GENERAL, N_("Unrecognized qualifier `%s'"),
 373                       vp->val);
 374         return 0;
 375     }
 376
 377     if ((s = yasm_vp_id(vp)))
 378         yasm_warn_set(YASM_WARN_GENERAL, N_("Unrecognized qualifier `%s'"), s);
 379     else if (vp->type == YASM_PARAM_STRING)
 380         yasm_warn_set(YASM_WARN_GENERAL, N_("Unrecognized string qualifier"));
 381     else
 382         yasm_warn_set(YASM_WARN_GENERAL, N_("Unrecognized numeric qualifier"));
 383
 384     return 0;
 385 }