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