tools/wrc/newstruc.c

   1 /*
   2  * Create dynamic new structures of various types
   3  * and some utils in that trend.
   4  *
   5  * Copyright 1998 Bertho A. Stultiens
   6  *
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <assert.h>
  13
  14 #include <config.h>
  15 #include "wrc.h"
  16 #include "newstruc.h"
  17 #include "utils.h"
  18 #include "parser.h"
  19
  20 /* Generate new_* functions that have no parameters (NOTE: no ';') */
  21 __NEW_STRUCT_FUNC(dialog)
  22 __NEW_STRUCT_FUNC(dialogex)
  23 __NEW_STRUCT_FUNC(name_id)
  24 __NEW_STRUCT_FUNC(menu)
  25 __NEW_STRUCT_FUNC(menuex)
  26 __NEW_STRUCT_FUNC(menu_item)
  27 __NEW_STRUCT_FUNC(menuex_item)
  28 __NEW_STRUCT_FUNC(control)
  29 __NEW_STRUCT_FUNC(icon)
  30 __NEW_STRUCT_FUNC(cursor)
  31 __NEW_STRUCT_FUNC(versioninfo)
  32 __NEW_STRUCT_FUNC(ver_value)
  33 __NEW_STRUCT_FUNC(ver_block)
  34 __NEW_STRUCT_FUNC(stt_entry)
  35 __NEW_STRUCT_FUNC(accelerator)
  36 __NEW_STRUCT_FUNC(event)
  37 __NEW_STRUCT_FUNC(raw_data)
  38 __NEW_STRUCT_FUNC(lvc)
  39 __NEW_STRUCT_FUNC(res_count)
  40 __NEW_STRUCT_FUNC(string)
  41 __NEW_STRUCT_FUNC(toolbar_item)
  42
  43 /* New instances for all types of structures */
  44 /* Very inefficient (in size), but very functional :-]
  45  * Especially for type-checking.
  46  */
  47 resource_t *new_resource(enum res_e t, void *res, int memopt, language_t *lan)
  48 {
  49         resource_t *r = (resource_t *)xmalloc(sizeof(resource_t));
  50         r->type = t;
  51         r->res.overlay = res;
  52         r->memopt = memopt;
  53         r->lan = lan;
  54         return r;
  55 }
  56
  57 version_t *new_version(DWORD v)
  58 {
  59         version_t *vp = (version_t *)xmalloc(sizeof(version_t));
  60         *vp = v;
  61         return vp;
  62 }
  63
  64 characts_t *new_characts(DWORD c)
  65 {
  66         characts_t *cp = (characts_t *)xmalloc(sizeof(characts_t));
  67         *cp = c;
  68         return cp;
  69 }
  70
  71 language_t *new_language(int id, int sub)
  72 {
  73         language_t *lan = (language_t *)xmalloc(sizeof(language_t));
  74         lan->id = id;
  75         lan->sub = sub;
  76         return lan;
  77 }
  78
  79 language_t *dup_language(language_t *l)
  80 {
  81         if(!l) return NULL;
  82         return new_language(l->id, l->sub);
  83 }
  84
  85 version_t *dup_version(version_t *v)
  86 {
  87         if(!v) return NULL;
  88         return new_version(*v);
  89 }
  90
  91 characts_t *dup_characts(characts_t *c)
  92 {
  93         if(!c) return NULL;
  94         return new_characts(*c);
  95 }
  96
  97 rcdata_t *new_rcdata(raw_data_t *rd, int *memopt)
  98 {
  99         rcdata_t *rc = (rcdata_t *)xmalloc(sizeof(rcdata_t));
 100         rc->data = rd;
 101         if(memopt)
 102         {
 103                 rc->memopt = *memopt;
 104                 free(memopt);
 105         }
 106         else
 107                 rc->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 108         return rc;
 109 }
 110
 111 font_id_t *new_font_id(int size, string_t *face, int weight, int italic)
 112 {
 113         font_id_t *fid = (font_id_t *)xmalloc(sizeof(font_id_t));
 114         fid->name = face;
 115         fid->size = size;
 116         fid->weight = weight;
 117         fid->italic = italic;
 118         return fid;
 119 }
 120
 121 user_t *new_user(name_id_t *type, raw_data_t *rd, int *memopt)
 122 {
 123         user_t *usr = (user_t *)xmalloc(sizeof(user_t));
 124         usr->data = rd;
 125         if(memopt)
 126         {
 127                 usr->memopt = *memopt;
 128                 free(memopt);
 129         }
 130         else
 131                 usr->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 132         usr->type = type;
 133         return usr;
 134 }
 135
 136 font_t *new_font(raw_data_t *rd, int *memopt)
 137 {
 138         font_t *fnt = (font_t *)xmalloc(sizeof(font_t));
 139         fnt->data = rd;
 140         if(memopt)
 141         {
 142                 fnt->memopt = *memopt;
 143                 free(memopt);
 144         }
 145         else
 146                 fnt->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 147         return fnt;
 148 }
 149
 150 icon_group_t *new_icon_group(raw_data_t *rd, int *memopt)
 151 {
 152         icon_group_t *icog = (icon_group_t *)xmalloc(sizeof(icon_group_t));
 153         if(memopt)
 154         {
 155                 icog->memopt = *memopt;
 156                 free(memopt);
 157         }
 158         else
 159                 icog->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
 160         icog->lvc.language = dup_language(currentlanguage);
 161         split_icons(rd, icog, &(icog->nicon));
 162         free(rd->data);
 163         free(rd);
 164         return icog;
 165 }
 166
 167 cursor_group_t *new_cursor_group(raw_data_t *rd, int *memopt)
 168 {
 169         cursor_group_t *curg = (cursor_group_t *)xmalloc(sizeof(cursor_group_t));
 170         if(memopt)
 171         {
 172                 curg->memopt = *memopt;
 173                 free(memopt);
 174         }
 175         else
 176                 curg->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE | WRC_MO_DISCARDABLE;
 177         curg->lvc.language = dup_language(currentlanguage);
 178         split_cursors(rd, curg, &(curg->ncursor));
 179         free(rd->data);
 180         free(rd);
 181         return curg;
 182 }
 183
 184 bitmap_t *new_bitmap(raw_data_t *rd, int *memopt)
 185 {
 186         bitmap_t *bmp = (bitmap_t *)xmalloc(sizeof(bitmap_t));
 187         bmp->data = rd;
 188         if(memopt)
 189         {
 190                 bmp->memopt = *memopt;
 191                 free(memopt);
 192         }
 193         else
 194                 bmp->memopt = WRC_MO_MOVEABLE | WRC_MO_PURE;
 195         return bmp;
 196 }
 197
 198 ver_words_t *new_ver_words(int i)
 199 {
 200         ver_words_t *w = (ver_words_t *)xmalloc(sizeof(ver_words_t));
 201         w->words = (WORD *)xmalloc(sizeof(WORD));
 202         w->words[0] = (WORD)i;
 203         w->nwords = 1;
 204         return w;
 205 }
 206
 207 ver_words_t *add_ver_words(ver_words_t *w, int i)
 208 {
 209         w->words = (WORD *)xrealloc(w->words, (w->nwords+1) * sizeof(WORD));
 210         w->words[w->nwords] = (WORD)i;
 211         w->nwords++;
 212         return w;
 213 }
 214
 215 messagetable_t *new_messagetable(raw_data_t *rd)
 216 {
 217         messagetable_t *msg = (messagetable_t *)xmalloc(sizeof(messagetable_t));
 218         msg->data = rd;
 219         return msg;
 220 }
 221
 222 void copy_raw_data(raw_data_t *dst, raw_data_t *src, int offs, int len)
 223 {
 224         assert(offs <= src->size);
 225         assert(offs + len <= src->size);
 226         if(!dst->data)
 227         {
 228                 dst->data = (char *)xmalloc(len);
 229                 dst->size = 0;
 230         }
 231         else
 232                 dst->data = (char *)xrealloc(dst->data, dst->size + len);
 233         /* dst->size holds the offset to copy to */
 234         memcpy(dst->data + dst->size, src->data + offs, len);
 235         dst->size += len;
 236 }
 237
 238 int *new_int(int i)
 239 {
 240         int *ip = (int *)xmalloc(sizeof(int));
 241         *ip = i;
 242         return ip;
 243 }
 244
 245 stringtable_t *new_stringtable(lvc_t *lvc)
 246 {
 247         stringtable_t *stt = (stringtable_t *)xmalloc(sizeof(stringtable_t));
 248
 249         if(lvc)
 250                 stt->lvc = *lvc;
 251
 252         return stt;
 253 }
 254
 255 toolbar_t *new_toolbar(int button_width, int button_height, toolbar_item_t *items, int nitems)
 256 {
 257         toolbar_t *tb = (toolbar_t *)xmalloc(sizeof(toolbar_t));
 258         tb->button_width = button_width;
 259         tb->button_height = button_height;
 260         tb->nitems = nitems;
 261         tb->items = items;
 262         return tb;
 263 }