src/treefuncs.c

   1 /* Generated by generate_treefuncs.pl from treefuncs.def!
   2  * Do not edit by hand! */
   3
   4 #include <glib.h>
   5 #include "treefuncs.h"
   6
   7 #define COPY_LIST_VALS(list,func) { GList *li; for(li=(list);li;li=li->next) { li->data=func(li->data); } }
   8
   9 Node * new_argument (char * gtktype, Type * atype, GList * flags, char * name, char * get, int get_line, char * set, int set_line, int line_no)
  10 {
  11         Argument * self = g_new0(Argument, 1);
  12         self->type = ARGUMENT_NODE;
  13         self->gtktype = gtktype;
  14         self->atype = atype;
  15         self->flags = flags;
  16         self->name = name;
  17         self->get = get;
  18         self->get_line = get_line;
  19         self->set = set;
  20         self->set_line = set_line;
  21         self->line_no = line_no;
  22         return (Node *)self;
  23 }
  24
  25 Node * new_ccode (int cctype, char * cbuf, int line_no)
  26 {
  27         CCode * self = g_new0(CCode, 1);
  28         self->type = CCODE_NODE;
  29         self->cctype = cctype;
  30         self->cbuf = cbuf;
  31         self->line_no = line_no;
  32         return (Node *)self;
  33 }
  34
  35 Node * new_check (int chtype, char * number)
  36 {
  37         Check * self = g_new0(Check, 1);
  38         self->type = CHECK_NODE;
  39         self->chtype = chtype;
  40         self->number = number;
  41         return (Node *)self;
  42 }
  43
  44 Node * new_class (char * otype, char * ptype, char * bonobo_x_class, char * chunk_size, GList * nodes)
  45 {
  46         Class * self = g_new0(Class, 1);
  47         self->type = CLASS_NODE;
  48         self->otype = otype;
  49         self->ptype = ptype;
  50         self->bonobo_x_class = bonobo_x_class;
  51         self->chunk_size = chunk_size;
  52         self->nodes = nodes;
  53         return (Node *)self;
  54 }
  55
  56 Node * new_funcarg (Type * atype, char * name, GList * checks)
  57 {
  58         FuncArg * self = g_new0(FuncArg, 1);
  59         self->type = FUNCARG_NODE;
  60         self->atype = atype;
  61         self->name = name;
  62         self->checks = checks;
  63         return (Node *)self;
  64 }
  65
  66 Node * new_method (int scope, int method, Type * mtype, char * otype, GList * gtktypes, GList * flags, char * id, GList * args, char * onerror, char * defreturn, char * cbuf, int line_no, int ccode_line, gboolean vararg, int unique_id, gboolean bonobo_x_func)
  67 {
  68         Method * self = g_new0(Method, 1);
  69         self->type = METHOD_NODE;
  70         self->scope = scope;
  71         self->method = method;
  72         self->mtype = mtype;
  73         self->otype = otype;
  74         self->gtktypes = gtktypes;
  75         self->flags = flags;
  76         self->id = id;
  77         self->args = args;
  78         self->onerror = onerror;
  79         self->defreturn = defreturn;
  80         self->cbuf = cbuf;
  81         self->line_no = line_no;
  82         self->ccode_line = ccode_line;
  83         self->vararg = vararg;
  84         self->unique_id = unique_id;
  85         self->bonobo_x_func = bonobo_x_func;
  86         return (Node *)self;
  87 }
  88
  89 Node * new_type (char * name, char * pointer, char * postfix)
  90 {
  91         Type * self = g_new0(Type, 1);
  92         self->type = TYPE_NODE;
  93         self->name = name;
  94         self->pointer = pointer;
  95         self->postfix = postfix;
  96         return (Node *)self;
  97 }
  98
  99 Node * new_variable (int scope, Type * vtype, char * id, int line_no, char * destructor, int destructor_line, gboolean destructor_simple, char * initializer, int initializer_line)
 100 {
 101         Variable * self = g_new0(Variable, 1);
 102         self->type = VARIABLE_NODE;
 103         self->scope = scope;
 104         self->vtype = vtype;
 105         self->id = id;
 106         self->line_no = line_no;
 107         self->destructor = destructor;
 108         self->destructor_line = destructor_line;
 109         self->destructor_simple = destructor_simple;
 110         self->initializer = initializer;
 111         self->initializer_line = initializer_line;
 112         return (Node *)self;
 113 }
 114
 115 Argument * copy_argument (Argument * self)
 116 {
 117         Argument * new;
 118         g_return_val_if_fail(self != NULL, NULL);
 119         g_return_val_if_fail(self->type == ARGUMENT_NODE, NULL);
 120         new = g_new0(Argument, 1);
 121         new->type = ARGUMENT_NODE;
 122         new->gtktype = g_strdup(self->gtktype);
 123         new->atype = copy_type(self->atype);
 124         new->flags = g_list_copy(self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 125         new->name = g_strdup(self->name);
 126         new->get = g_strdup(self->get);
 127         new->get_line = self->get_line;
 128         new->set = g_strdup(self->set);
 129         new->set_line = self->set_line;
 130         new->line_no = self->line_no;
 131         return new;
 132 }
 133
 134 CCode * copy_ccode (CCode * self)
 135 {
 136         CCode * new;
 137         g_return_val_if_fail(self != NULL, NULL);
 138         g_return_val_if_fail(self->type == CCODE_NODE, NULL);
 139         new = g_new0(CCode, 1);
 140         new->type = CCODE_NODE;
 141         new->cctype = self->cctype;
 142         new->cbuf = g_strdup(self->cbuf);
 143         new->line_no = self->line_no;
 144         return new;
 145 }
 146
 147 Check * copy_check (Check * self)
 148 {
 149         Check * new;
 150         g_return_val_if_fail(self != NULL, NULL);
 151         g_return_val_if_fail(self->type == CHECK_NODE, NULL);
 152         new = g_new0(Check, 1);
 153         new->type = CHECK_NODE;
 154         new->chtype = self->chtype;
 155         new->number = g_strdup(self->number);
 156         return new;
 157 }
 158
 159 Class * copy_class (Class * self)
 160 {
 161         Class * new;
 162         g_return_val_if_fail(self != NULL, NULL);
 163         g_return_val_if_fail(self->type == CLASS_NODE, NULL);
 164         new = g_new0(Class, 1);
 165         new->type = CLASS_NODE;
 166         new->otype = g_strdup(self->otype);
 167         new->ptype = g_strdup(self->ptype);
 168         new->bonobo_x_class = g_strdup(self->bonobo_x_class);
 169         new->chunk_size = g_strdup(self->chunk_size);
 170         new->nodes = copy_node_list(self->nodes);
 171         return new;
 172 }
 173
 174 FuncArg * copy_funcarg (FuncArg * self)
 175 {
 176         FuncArg * new;
 177         g_return_val_if_fail(self != NULL, NULL);
 178         g_return_val_if_fail(self->type == FUNCARG_NODE, NULL);
 179         new = g_new0(FuncArg, 1);
 180         new->type = FUNCARG_NODE;
 181         new->atype = copy_type(self->atype);
 182         new->name = g_strdup(self->name);
 183         new->checks = copy_node_list(self->checks);
 184         return new;
 185 }
 186
 187 Method * copy_method (Method * self)
 188 {
 189         Method * new;
 190         g_return_val_if_fail(self != NULL, NULL);
 191         g_return_val_if_fail(self->type == METHOD_NODE, NULL);
 192         new = g_new0(Method, 1);
 193         new->type = METHOD_NODE;
 194         new->scope = self->scope;
 195         new->method = self->method;
 196         new->mtype = copy_type(self->mtype);
 197         new->otype = g_strdup(self->otype);
 198         new->gtktypes = g_list_copy(self->gtktypes); COPY_LIST_VALS(new->gtktypes, g_strdup);
 199         new->flags = g_list_copy(self->flags); COPY_LIST_VALS(new->flags, g_strdup);
 200         new->id = g_strdup(self->id);
 201         new->args = copy_node_list(self->args);
 202         new->onerror = g_strdup(self->onerror);
 203         new->defreturn = g_strdup(self->defreturn);
 204         new->cbuf = g_strdup(self->cbuf);
 205         new->line_no = self->line_no;
 206         new->ccode_line = self->ccode_line;
 207         new->vararg = self->vararg;
 208         new->unique_id = self->unique_id;
 209         new->bonobo_x_func = self->bonobo_x_func;
 210         return new;
 211 }
 212
 213 Type * copy_type (Type * self)
 214 {
 215         Type * new;
 216         g_return_val_if_fail(self != NULL, NULL);
 217         g_return_val_if_fail(self->type == TYPE_NODE, NULL);
 218         new = g_new0(Type, 1);
 219         new->type = TYPE_NODE;
 220         new->name = g_strdup(self->name);
 221         new->pointer = g_strdup(self->pointer);
 222         new->postfix = g_strdup(self->postfix);
 223         return new;
 224 }
 225
 226 Variable * copy_variable (Variable * self)
 227 {
 228         Variable * new;
 229         g_return_val_if_fail(self != NULL, NULL);
 230         g_return_val_if_fail(self->type == VARIABLE_NODE, NULL);
 231         new = g_new0(Variable, 1);
 232         new->type = VARIABLE_NODE;
 233         new->scope = self->scope;
 234         new->vtype = copy_type(self->vtype);
 235         new->id = g_strdup(self->id);
 236         new->line_no = self->line_no;
 237         new->destructor = g_strdup(self->destructor);
 238         new->destructor_line = self->destructor_line;
 239         new->destructor_simple = self->destructor_simple;
 240         new->initializer = g_strdup(self->initializer);
 241         new->initializer_line = self->initializer_line;
 242         return new;
 243 }
 244
 245 void free_argument (Argument * self)
 246 {
 247         g_return_if_fail(self != NULL);
 248         g_return_if_fail(self->type == ARGUMENT_NODE);
 249         g_free(self->gtktype);
 250         free_type(self->atype);
 251         g_list_foreach(self->flags, (GFunc)g_free, NULL); g_list_free(self->flags);
 252         g_free(self->name);
 253         g_free(self->get);
 254         g_free(self->set);
 255         g_free(self);
 256 }
 257
 258 void free_ccode (CCode * self)
 259 {
 260         g_return_if_fail(self != NULL);
 261         g_return_if_fail(self->type == CCODE_NODE);
 262         g_free(self->cbuf);
 263         g_free(self);
 264 }
 265
 266 void free_check (Check * self)
 267 {
 268         g_return_if_fail(self != NULL);
 269         g_return_if_fail(self->type == CHECK_NODE);
 270         g_free(self->number);
 271         g_free(self);
 272 }
 273
 274 void free_class (Class * self)
 275 {
 276         g_return_if_fail(self != NULL);
 277         g_return_if_fail(self->type == CLASS_NODE);
 278         g_free(self->otype);
 279         g_free(self->ptype);
 280         g_free(self->bonobo_x_class);
 281         g_free(self->chunk_size);
 282         free_node_list(self->nodes);
 283         g_free(self);
 284 }
 285
 286 void free_funcarg (FuncArg * self)
 287 {
 288         g_return_if_fail(self != NULL);
 289         g_return_if_fail(self->type == FUNCARG_NODE);
 290         free_type(self->atype);
 291         g_free(self->name);
 292         free_node_list(self->checks);
 293         g_free(self);
 294 }
 295
 296 void free_method (Method * self)
 297 {
 298         g_return_if_fail(self != NULL);
 299         g_return_if_fail(self->type == METHOD_NODE);
 300         free_type(self->mtype);
 301         g_free(self->otype);
 302         g_list_foreach(self->gtktypes, (GFunc)g_free, NULL); g_list_free(self->gtktypes);
 303         g_list_foreach(self->flags, (GFunc)g_free, NULL); g_list_free(self->flags);
 304         g_free(self->id);
 305         free_node_list(self->args);
 306         g_free(self->onerror);
 307         g_free(self->defreturn);
 308         g_free(self->cbuf);
 309         g_free(self);
 310 }
 311
 312 void free_type (Type * self)
 313 {
 314         g_return_if_fail(self != NULL);
 315         g_return_if_fail(self->type == TYPE_NODE);
 316         g_free(self->name);
 317         g_free(self->pointer);
 318         g_free(self->postfix);
 319         g_free(self);
 320 }
 321
 322 void free_variable (Variable * self)
 323 {
 324         g_return_if_fail(self != NULL);
 325         g_return_if_fail(self->type == VARIABLE_NODE);
 326         free_type(self->vtype);
 327         g_free(self->id);
 328         g_free(self->destructor);
 329         g_free(self->initializer);
 330         g_free(self);
 331 }
 332
 333 Node * copy_node(Node *node)
 334 {
 335         g_return_val_if_fail(node != NULL, NULL);
 336         g_return_val_if_fail(node->type >= 0 && node->type < LAST_NODE_TYPE, NULL);
 337         switch(node->type) {
 338         case ARGUMENT_NODE: return (Node *)copy_argument ((Argument *)node);
 339         case CCODE_NODE: return (Node *)copy_ccode ((CCode *)node);
 340         case CHECK_NODE: return (Node *)copy_check ((Check *)node);
 341         case CLASS_NODE: return (Node *)copy_class ((Class *)node);
 342         case FUNCARG_NODE: return (Node *)copy_funcarg ((FuncArg *)node);
 343         case METHOD_NODE: return (Node *)copy_method ((Method *)node);
 344         case TYPE_NODE: return (Node *)copy_type ((Type *)node);
 345         case VARIABLE_NODE: return (Node *)copy_variable ((Variable *)node);
 346         default: return NULL;
 347         }
 348 }
 349
 350 void free_node(Node *node)
 351 {
 352         g_return_if_fail(node != NULL);
 353         g_return_if_fail(node->type >= 0 && node->type < LAST_NODE_TYPE);
 354         switch(node->type) {
 355         case ARGUMENT_NODE: free_argument ((Argument *)node); return;
 356         case CCODE_NODE: free_ccode ((CCode *)node); return;
 357         case CHECK_NODE: free_check ((Check *)node); return;
 358         case CLASS_NODE: free_class ((Class *)node); return;
 359         case FUNCARG_NODE: free_funcarg ((FuncArg *)node); return;
 360         case METHOD_NODE: free_method ((Method *)node); return;
 361         case TYPE_NODE: free_type ((Type *)node); return;
 362         case VARIABLE_NODE: free_variable ((Variable *)node); return;
 363         default: return;
 364         }
 365 }
 366
 367 GList * copy_node_list(GList *nodes)
 368 {
 369         GList *li;
 370         nodes = g_list_copy(nodes);
 371         for(li = nodes; li != NULL; li = li->next) {
 372                 li->data = copy_node(li->data);
 373         }
 374         return nodes;
 375 }
 376
 377 void free_node_list(GList *nodes)
 378 {
 379         GList *li;
 380         for(li = nodes; li != NULL; li = li->next) {
 381                 free_node(li->data);
 382         }
 383         g_list_free(nodes);
 384 }
 385