c_src/parser_nodes.sep.2.c

   1 #include "parser_nodes.sep.0.h"
   2 /* method parser_nodes#ACallFormExpr#n_args= for (self: Object, AExprs) */
   3 void VIRTUAL_parser_nodes__ACallFormExpr__n_args_61d(val* self, val* p0) {
   4 parser_nodes__ACallFormExpr__n_args_61d(self, p0);
   5 RET_LABEL:;
   6 }
   7 /* method parser_nodes#ACallFormExpr#init for (self: ACallFormExpr) */
   8 void parser_nodes__ACallFormExpr__init(val* self) {
   9 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__init]))(self) /* init on <self:ACallFormExpr>*/;
  10 RET_LABEL:;
  11 }
  12 /* method parser_nodes#ACallFormExpr#init for (self: Object) */
  13 void VIRTUAL_parser_nodes__ACallFormExpr__init(val* self) {
  14 parser_nodes__ACallFormExpr__init(self);
  15 RET_LABEL:;
  16 }
  17 /* method parser_nodes#ASendReassignFormExpr#init for (self: ASendReassignFormExpr) */
  18 void parser_nodes__ASendReassignFormExpr__init(val* self) {
  19 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__init]))(self) /* init on <self:ASendReassignFormExpr>*/;
  20 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AReassignFormExpr__init]))(self) /* init on <self:ASendReassignFormExpr>*/;
  21 RET_LABEL:;
  22 }
  23 /* method parser_nodes#ASendReassignFormExpr#init for (self: Object) */
  24 void VIRTUAL_parser_nodes__ASendReassignFormExpr__init(val* self) {
  25 parser_nodes__ASendReassignFormExpr__init(self);
  26 RET_LABEL:;
  27 }
  28 /* method parser_nodes#AAttrReassignExpr#init for (self: AAttrReassignExpr) */
  29 void parser_nodes__AAttrReassignExpr__init(val* self) {
  30 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAttrFormExpr__init]))(self) /* init on <self:AAttrReassignExpr>*/;
  31 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AReassignFormExpr__init]))(self) /* init on <self:AAttrReassignExpr>*/;
  32 RET_LABEL:;
  33 }
  34 /* method parser_nodes#AAttrReassignExpr#init for (self: Object) */
  35 void VIRTUAL_parser_nodes__AAttrReassignExpr__init(val* self) {
  36 parser_nodes__AAttrReassignExpr__init(self);
  37 RET_LABEL:;
  38 }
  39 /* method parser_nodes#ACallExpr#init for (self: ACallExpr) */
  40 void parser_nodes__ACallExpr__init(val* self) {
  41 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ACallFormExpr__init]))(self) /* init on <self:ACallExpr>*/;
  42 RET_LABEL:;
  43 }
  44 /* method parser_nodes#ACallExpr#init for (self: Object) */
  45 void VIRTUAL_parser_nodes__ACallExpr__init(val* self) {
  46 parser_nodes__ACallExpr__init(self);
  47 RET_LABEL:;
  48 }
  49 /* method parser_nodes#ACallAssignExpr#init for (self: ACallAssignExpr) */
  50 void parser_nodes__ACallAssignExpr__init(val* self) {
  51 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ACallFormExpr__init]))(self) /* init on <self:ACallAssignExpr>*/;
  52 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignFormExpr__init]))(self) /* init on <self:ACallAssignExpr>*/;
  53 RET_LABEL:;
  54 }
  55 /* method parser_nodes#ACallAssignExpr#init for (self: Object) */
  56 void VIRTUAL_parser_nodes__ACallAssignExpr__init(val* self) {
  57 parser_nodes__ACallAssignExpr__init(self);
  58 RET_LABEL:;
  59 }
  60 /* method parser_nodes#ACallReassignExpr#init for (self: ACallReassignExpr) */
  61 void parser_nodes__ACallReassignExpr__init(val* self) {
  62 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ACallFormExpr__init]))(self) /* init on <self:ACallReassignExpr>*/;
  63 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendReassignFormExpr__init]))(self) /* init on <self:ACallReassignExpr>*/;
  64 RET_LABEL:;
  65 }
  66 /* method parser_nodes#ACallReassignExpr#init for (self: Object) */
  67 void VIRTUAL_parser_nodes__ACallReassignExpr__init(val* self) {
  68 parser_nodes__ACallReassignExpr__init(self);
  69 RET_LABEL:;
  70 }
  71 /* method parser_nodes#ASuperExpr#n_qualified for (self: ASuperExpr): nullable AQualified */
  72 val* parser_nodes__ASuperExpr__n_qualified(val* self) {
  73 val* var /* : nullable AQualified */;
  74 val* var1 /* : nullable AQualified */;
  75 var1 = self->attrs[COLOR_parser_nodes__ASuperExpr___n_qualified].val; /* _n_qualified on <self:ASuperExpr> */
  76 var = var1;
  77 RET_LABEL:;
  78 return var;
  79 }
  80 /* method parser_nodes#ASuperExpr#n_qualified for (self: Object): nullable AQualified */
  81 val* VIRTUAL_parser_nodes__ASuperExpr__n_qualified(val* self) {
  82 val* var /* : nullable AQualified */;
  83 val* var1 /* : nullable AQualified */;
  84 var1 = parser_nodes__ASuperExpr__n_qualified(self);
  85 var = var1;
  86 RET_LABEL:;
  87 return var;
  88 }
  89 /* method parser_nodes#ASuperExpr#n_qualified= for (self: ASuperExpr, nullable AQualified) */
  90 void parser_nodes__ASuperExpr__n_qualified_61d(val* self, val* p0) {
  91 self->attrs[COLOR_parser_nodes__ASuperExpr___n_qualified].val = p0; /* _n_qualified on <self:ASuperExpr> */
  92 RET_LABEL:;
  93 }
  94 /* method parser_nodes#ASuperExpr#n_qualified= for (self: Object, nullable AQualified) */
  95 void VIRTUAL_parser_nodes__ASuperExpr__n_qualified_61d(val* self, val* p0) {
  96 parser_nodes__ASuperExpr__n_qualified_61d(self, p0);
  97 RET_LABEL:;
  98 }
  99 /* method parser_nodes#ASuperExpr#n_kwsuper for (self: ASuperExpr): TKwsuper */
 100 val* parser_nodes__ASuperExpr__n_kwsuper(val* self) {
 101 val* var /* : TKwsuper */;
 102 val* var1 /* : TKwsuper */;
 103 var1 = self->attrs[COLOR_parser_nodes__ASuperExpr___n_kwsuper].val; /* _n_kwsuper on <self:ASuperExpr> */
 104 if (var1 == NULL) {
 105 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwsuper");
 106 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1391);
 107 show_backtrace(1);
 108 }
 109 var = var1;
 110 RET_LABEL:;
 111 return var;
 112 }
 113 /* method parser_nodes#ASuperExpr#n_kwsuper for (self: Object): TKwsuper */
 114 val* VIRTUAL_parser_nodes__ASuperExpr__n_kwsuper(val* self) {
 115 val* var /* : TKwsuper */;
 116 val* var1 /* : TKwsuper */;
 117 var1 = parser_nodes__ASuperExpr__n_kwsuper(self);
 118 var = var1;
 119 RET_LABEL:;
 120 return var;
 121 }
 122 /* method parser_nodes#ASuperExpr#n_kwsuper= for (self: ASuperExpr, TKwsuper) */
 123 void parser_nodes__ASuperExpr__n_kwsuper_61d(val* self, val* p0) {
 124 self->attrs[COLOR_parser_nodes__ASuperExpr___n_kwsuper].val = p0; /* _n_kwsuper on <self:ASuperExpr> */
 125 RET_LABEL:;
 126 }
 127 /* method parser_nodes#ASuperExpr#n_kwsuper= for (self: Object, TKwsuper) */
 128 void VIRTUAL_parser_nodes__ASuperExpr__n_kwsuper_61d(val* self, val* p0) {
 129 parser_nodes__ASuperExpr__n_kwsuper_61d(self, p0);
 130 RET_LABEL:;
 131 }
 132 /* method parser_nodes#ASuperExpr#n_args for (self: ASuperExpr): AExprs */
 133 val* parser_nodes__ASuperExpr__n_args(val* self) {
 134 val* var /* : AExprs */;
 135 val* var1 /* : AExprs */;
 136 var1 = self->attrs[COLOR_parser_nodes__ASuperExpr___n_args].val; /* _n_args on <self:ASuperExpr> */
 137 if (var1 == NULL) {
 138 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_args");
 139 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1392);
 140 show_backtrace(1);
 141 }
 142 var = var1;
 143 RET_LABEL:;
 144 return var;
 145 }
 146 /* method parser_nodes#ASuperExpr#n_args for (self: Object): AExprs */
 147 val* VIRTUAL_parser_nodes__ASuperExpr__n_args(val* self) {
 148 val* var /* : AExprs */;
 149 val* var1 /* : AExprs */;
 150 var1 = parser_nodes__ASuperExpr__n_args(self);
 151 var = var1;
 152 RET_LABEL:;
 153 return var;
 154 }
 155 /* method parser_nodes#ASuperExpr#n_args= for (self: ASuperExpr, AExprs) */
 156 void parser_nodes__ASuperExpr__n_args_61d(val* self, val* p0) {
 157 self->attrs[COLOR_parser_nodes__ASuperExpr___n_args].val = p0; /* _n_args on <self:ASuperExpr> */
 158 RET_LABEL:;
 159 }
 160 /* method parser_nodes#ASuperExpr#n_args= for (self: Object, AExprs) */
 161 void VIRTUAL_parser_nodes__ASuperExpr__n_args_61d(val* self, val* p0) {
 162 parser_nodes__ASuperExpr__n_args_61d(self, p0);
 163 RET_LABEL:;
 164 }
 165 /* method parser_nodes#ASuperExpr#init for (self: ASuperExpr) */
 166 void parser_nodes__ASuperExpr__init(val* self) {
 167 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ASuperExpr>*/;
 168 RET_LABEL:;
 169 }
 170 /* method parser_nodes#ASuperExpr#init for (self: Object) */
 171 void VIRTUAL_parser_nodes__ASuperExpr__init(val* self) {
 172 parser_nodes__ASuperExpr__init(self);
 173 RET_LABEL:;
 174 }
 175 /* method parser_nodes#AInitExpr#n_kwinit for (self: AInitExpr): TKwinit */
 176 val* parser_nodes__AInitExpr__n_kwinit(val* self) {
 177 val* var /* : TKwinit */;
 178 val* var1 /* : TKwinit */;
 179 var1 = self->attrs[COLOR_parser_nodes__AInitExpr___n_kwinit].val; /* _n_kwinit on <self:AInitExpr> */
 180 if (var1 == NULL) {
 181 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwinit");
 182 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1399);
 183 show_backtrace(1);
 184 }
 185 var = var1;
 186 RET_LABEL:;
 187 return var;
 188 }
 189 /* method parser_nodes#AInitExpr#n_kwinit for (self: Object): TKwinit */
 190 val* VIRTUAL_parser_nodes__AInitExpr__n_kwinit(val* self) {
 191 val* var /* : TKwinit */;
 192 val* var1 /* : TKwinit */;
 193 var1 = parser_nodes__AInitExpr__n_kwinit(self);
 194 var = var1;
 195 RET_LABEL:;
 196 return var;
 197 }
 198 /* method parser_nodes#AInitExpr#n_kwinit= for (self: AInitExpr, TKwinit) */
 199 void parser_nodes__AInitExpr__n_kwinit_61d(val* self, val* p0) {
 200 self->attrs[COLOR_parser_nodes__AInitExpr___n_kwinit].val = p0; /* _n_kwinit on <self:AInitExpr> */
 201 RET_LABEL:;
 202 }
 203 /* method parser_nodes#AInitExpr#n_kwinit= for (self: Object, TKwinit) */
 204 void VIRTUAL_parser_nodes__AInitExpr__n_kwinit_61d(val* self, val* p0) {
 205 parser_nodes__AInitExpr__n_kwinit_61d(self, p0);
 206 RET_LABEL:;
 207 }
 208 /* method parser_nodes#AInitExpr#n_args for (self: AInitExpr): AExprs */
 209 val* parser_nodes__AInitExpr__n_args(val* self) {
 210 val* var /* : AExprs */;
 211 val* var1 /* : AExprs */;
 212 var1 = self->attrs[COLOR_parser_nodes__AInitExpr___n_args].val; /* _n_args on <self:AInitExpr> */
 213 if (var1 == NULL) {
 214 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_args");
 215 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1400);
 216 show_backtrace(1);
 217 }
 218 var = var1;
 219 RET_LABEL:;
 220 return var;
 221 }
 222 /* method parser_nodes#AInitExpr#n_args for (self: Object): AExprs */
 223 val* VIRTUAL_parser_nodes__AInitExpr__n_args(val* self) {
 224 val* var /* : AExprs */;
 225 val* var1 /* : AExprs */;
 226 var1 = parser_nodes__AInitExpr__n_args(self);
 227 var = var1;
 228 RET_LABEL:;
 229 return var;
 230 }
 231 /* method parser_nodes#AInitExpr#n_args= for (self: AInitExpr, AExprs) */
 232 void parser_nodes__AInitExpr__n_args_61d(val* self, val* p0) {
 233 self->attrs[COLOR_parser_nodes__AInitExpr___n_args].val = p0; /* _n_args on <self:AInitExpr> */
 234 RET_LABEL:;
 235 }
 236 /* method parser_nodes#AInitExpr#n_args= for (self: Object, AExprs) */
 237 void VIRTUAL_parser_nodes__AInitExpr__n_args_61d(val* self, val* p0) {
 238 parser_nodes__AInitExpr__n_args_61d(self, p0);
 239 RET_LABEL:;
 240 }
 241 /* method parser_nodes#AInitExpr#init for (self: AInitExpr) */
 242 void parser_nodes__AInitExpr__init(val* self) {
 243 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__init]))(self) /* init on <self:AInitExpr>*/;
 244 RET_LABEL:;
 245 }
 246 /* method parser_nodes#AInitExpr#init for (self: Object) */
 247 void VIRTUAL_parser_nodes__AInitExpr__init(val* self) {
 248 parser_nodes__AInitExpr__init(self);
 249 RET_LABEL:;
 250 }
 251 /* method parser_nodes#ABraFormExpr#n_args for (self: ABraFormExpr): AExprs */
 252 val* parser_nodes__ABraFormExpr__n_args(val* self) {
 253 val* var /* : AExprs */;
 254 val* var1 /* : AExprs */;
 255 var1 = self->attrs[COLOR_parser_nodes__ABraFormExpr___n_args].val; /* _n_args on <self:ABraFormExpr> */
 256 if (var1 == NULL) {
 257 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_args");
 258 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1406);
 259 show_backtrace(1);
 260 }
 261 var = var1;
 262 RET_LABEL:;
 263 return var;
 264 }
 265 /* method parser_nodes#ABraFormExpr#n_args for (self: Object): AExprs */
 266 val* VIRTUAL_parser_nodes__ABraFormExpr__n_args(val* self) {
 267 val* var /* : AExprs */;
 268 val* var1 /* : AExprs */;
 269 var1 = parser_nodes__ABraFormExpr__n_args(self);
 270 var = var1;
 271 RET_LABEL:;
 272 return var;
 273 }
 274 /* method parser_nodes#ABraFormExpr#n_args= for (self: ABraFormExpr, AExprs) */
 275 void parser_nodes__ABraFormExpr__n_args_61d(val* self, val* p0) {
 276 self->attrs[COLOR_parser_nodes__ABraFormExpr___n_args].val = p0; /* _n_args on <self:ABraFormExpr> */
 277 RET_LABEL:;
 278 }
 279 /* method parser_nodes#ABraFormExpr#n_args= for (self: Object, AExprs) */
 280 void VIRTUAL_parser_nodes__ABraFormExpr__n_args_61d(val* self, val* p0) {
 281 parser_nodes__ABraFormExpr__n_args_61d(self, p0);
 282 RET_LABEL:;
 283 }
 284 /* method parser_nodes#ABraFormExpr#init for (self: ABraFormExpr) */
 285 void parser_nodes__ABraFormExpr__init(val* self) {
 286 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendExpr__init]))(self) /* init on <self:ABraFormExpr>*/;
 287 RET_LABEL:;
 288 }
 289 /* method parser_nodes#ABraFormExpr#init for (self: Object) */
 290 void VIRTUAL_parser_nodes__ABraFormExpr__init(val* self) {
 291 parser_nodes__ABraFormExpr__init(self);
 292 RET_LABEL:;
 293 }
 294 /* method parser_nodes#ABraExpr#init for (self: ABraExpr) */
 295 void parser_nodes__ABraExpr__init(val* self) {
 296 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ABraFormExpr__init]))(self) /* init on <self:ABraExpr>*/;
 297 RET_LABEL:;
 298 }
 299 /* method parser_nodes#ABraExpr#init for (self: Object) */
 300 void VIRTUAL_parser_nodes__ABraExpr__init(val* self) {
 301 parser_nodes__ABraExpr__init(self);
 302 RET_LABEL:;
 303 }
 304 /* method parser_nodes#ABraAssignExpr#init for (self: ABraAssignExpr) */
 305 void parser_nodes__ABraAssignExpr__init(val* self) {
 306 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ABraFormExpr__init]))(self) /* init on <self:ABraAssignExpr>*/;
 307 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignFormExpr__init]))(self) /* init on <self:ABraAssignExpr>*/;
 308 RET_LABEL:;
 309 }
 310 /* method parser_nodes#ABraAssignExpr#init for (self: Object) */
 311 void VIRTUAL_parser_nodes__ABraAssignExpr__init(val* self) {
 312 parser_nodes__ABraAssignExpr__init(self);
 313 RET_LABEL:;
 314 }
 315 /* method parser_nodes#AVarFormExpr#n_id for (self: AVarFormExpr): TId */
 316 val* parser_nodes__AVarFormExpr__n_id(val* self) {
 317 val* var /* : TId */;
 318 val* var1 /* : TId */;
 319 var1 = self->attrs[COLOR_parser_nodes__AVarFormExpr___n_id].val; /* _n_id on <self:AVarFormExpr> */
 320 if (var1 == NULL) {
 321 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_id");
 322 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1423);
 323 show_backtrace(1);
 324 }
 325 var = var1;
 326 RET_LABEL:;
 327 return var;
 328 }
 329 /* method parser_nodes#AVarFormExpr#n_id for (self: Object): TId */
 330 val* VIRTUAL_parser_nodes__AVarFormExpr__n_id(val* self) {
 331 val* var /* : TId */;
 332 val* var1 /* : TId */;
 333 var1 = parser_nodes__AVarFormExpr__n_id(self);
 334 var = var1;
 335 RET_LABEL:;
 336 return var;
 337 }
 338 /* method parser_nodes#AVarFormExpr#n_id= for (self: AVarFormExpr, TId) */
 339 void parser_nodes__AVarFormExpr__n_id_61d(val* self, val* p0) {
 340 self->attrs[COLOR_parser_nodes__AVarFormExpr___n_id].val = p0; /* _n_id on <self:AVarFormExpr> */
 341 RET_LABEL:;
 342 }
 343 /* method parser_nodes#AVarFormExpr#n_id= for (self: Object, TId) */
 344 void VIRTUAL_parser_nodes__AVarFormExpr__n_id_61d(val* self, val* p0) {
 345 parser_nodes__AVarFormExpr__n_id_61d(self, p0);
 346 RET_LABEL:;
 347 }
 348 /* method parser_nodes#AVarFormExpr#init for (self: AVarFormExpr) */
 349 void parser_nodes__AVarFormExpr__init(val* self) {
 350 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AVarFormExpr>*/;
 351 RET_LABEL:;
 352 }
 353 /* method parser_nodes#AVarFormExpr#init for (self: Object) */
 354 void VIRTUAL_parser_nodes__AVarFormExpr__init(val* self) {
 355 parser_nodes__AVarFormExpr__init(self);
 356 RET_LABEL:;
 357 }
 358 /* method parser_nodes#ABraReassignExpr#init for (self: ABraReassignExpr) */
 359 void parser_nodes__ABraReassignExpr__init(val* self) {
 360 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ABraFormExpr__init]))(self) /* init on <self:ABraReassignExpr>*/;
 361 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASendReassignFormExpr__init]))(self) /* init on <self:ABraReassignExpr>*/;
 362 RET_LABEL:;
 363 }
 364 /* method parser_nodes#ABraReassignExpr#init for (self: Object) */
 365 void VIRTUAL_parser_nodes__ABraReassignExpr__init(val* self) {
 366 parser_nodes__ABraReassignExpr__init(self);
 367 RET_LABEL:;
 368 }
 369 /* method parser_nodes#AVarExpr#init for (self: AVarExpr) */
 370 void parser_nodes__AVarExpr__init(val* self) {
 371 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AVarFormExpr__init]))(self) /* init on <self:AVarExpr>*/;
 372 RET_LABEL:;
 373 }
 374 /* method parser_nodes#AVarExpr#init for (self: Object) */
 375 void VIRTUAL_parser_nodes__AVarExpr__init(val* self) {
 376 parser_nodes__AVarExpr__init(self);
 377 RET_LABEL:;
 378 }
 379 /* method parser_nodes#AVarAssignExpr#init for (self: AVarAssignExpr) */
 380 void parser_nodes__AVarAssignExpr__init(val* self) {
 381 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AVarFormExpr__init]))(self) /* init on <self:AVarAssignExpr>*/;
 382 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignFormExpr__init]))(self) /* init on <self:AVarAssignExpr>*/;
 383 RET_LABEL:;
 384 }
 385 /* method parser_nodes#AVarAssignExpr#init for (self: Object) */
 386 void VIRTUAL_parser_nodes__AVarAssignExpr__init(val* self) {
 387 parser_nodes__AVarAssignExpr__init(self);
 388 RET_LABEL:;
 389 }
 390 /* method parser_nodes#AVarReassignExpr#init for (self: AVarReassignExpr) */
 391 void parser_nodes__AVarReassignExpr__init(val* self) {
 392 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AVarFormExpr__init]))(self) /* init on <self:AVarReassignExpr>*/;
 393 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AReassignFormExpr__init]))(self) /* init on <self:AVarReassignExpr>*/;
 394 RET_LABEL:;
 395 }
 396 /* method parser_nodes#AVarReassignExpr#init for (self: Object) */
 397 void VIRTUAL_parser_nodes__AVarReassignExpr__init(val* self) {
 398 parser_nodes__AVarReassignExpr__init(self);
 399 RET_LABEL:;
 400 }
 401 /* method parser_nodes#ARangeExpr#n_expr for (self: ARangeExpr): AExpr */
 402 val* parser_nodes__ARangeExpr__n_expr(val* self) {
 403 val* var /* : AExpr */;
 404 val* var1 /* : AExpr */;
 405 var1 = self->attrs[COLOR_parser_nodes__ARangeExpr___n_expr].val; /* _n_expr on <self:ARangeExpr> */
 406 if (var1 == NULL) {
 407 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr");
 408 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1455);
 409 show_backtrace(1);
 410 }
 411 var = var1;
 412 RET_LABEL:;
 413 return var;
 414 }
 415 /* method parser_nodes#ARangeExpr#n_expr for (self: Object): AExpr */
 416 val* VIRTUAL_parser_nodes__ARangeExpr__n_expr(val* self) {
 417 val* var /* : AExpr */;
 418 val* var1 /* : AExpr */;
 419 var1 = parser_nodes__ARangeExpr__n_expr(self);
 420 var = var1;
 421 RET_LABEL:;
 422 return var;
 423 }
 424 /* method parser_nodes#ARangeExpr#n_expr= for (self: ARangeExpr, AExpr) */
 425 void parser_nodes__ARangeExpr__n_expr_61d(val* self, val* p0) {
 426 self->attrs[COLOR_parser_nodes__ARangeExpr___n_expr].val = p0; /* _n_expr on <self:ARangeExpr> */
 427 RET_LABEL:;
 428 }
 429 /* method parser_nodes#ARangeExpr#n_expr= for (self: Object, AExpr) */
 430 void VIRTUAL_parser_nodes__ARangeExpr__n_expr_61d(val* self, val* p0) {
 431 parser_nodes__ARangeExpr__n_expr_61d(self, p0);
 432 RET_LABEL:;
 433 }
 434 /* method parser_nodes#ARangeExpr#n_expr2 for (self: ARangeExpr): AExpr */
 435 val* parser_nodes__ARangeExpr__n_expr2(val* self) {
 436 val* var /* : AExpr */;
 437 val* var1 /* : AExpr */;
 438 var1 = self->attrs[COLOR_parser_nodes__ARangeExpr___n_expr2].val; /* _n_expr2 on <self:ARangeExpr> */
 439 if (var1 == NULL) {
 440 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr2");
 441 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1456);
 442 show_backtrace(1);
 443 }
 444 var = var1;
 445 RET_LABEL:;
 446 return var;
 447 }
 448 /* method parser_nodes#ARangeExpr#n_expr2 for (self: Object): AExpr */
 449 val* VIRTUAL_parser_nodes__ARangeExpr__n_expr2(val* self) {
 450 val* var /* : AExpr */;
 451 val* var1 /* : AExpr */;
 452 var1 = parser_nodes__ARangeExpr__n_expr2(self);
 453 var = var1;
 454 RET_LABEL:;
 455 return var;
 456 }
 457 /* method parser_nodes#ARangeExpr#n_expr2= for (self: ARangeExpr, AExpr) */
 458 void parser_nodes__ARangeExpr__n_expr2_61d(val* self, val* p0) {
 459 self->attrs[COLOR_parser_nodes__ARangeExpr___n_expr2].val = p0; /* _n_expr2 on <self:ARangeExpr> */
 460 RET_LABEL:;
 461 }
 462 /* method parser_nodes#ARangeExpr#n_expr2= for (self: Object, AExpr) */
 463 void VIRTUAL_parser_nodes__ARangeExpr__n_expr2_61d(val* self, val* p0) {
 464 parser_nodes__ARangeExpr__n_expr2_61d(self, p0);
 465 RET_LABEL:;
 466 }
 467 /* method parser_nodes#ARangeExpr#init for (self: ARangeExpr) */
 468 void parser_nodes__ARangeExpr__init(val* self) {
 469 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ARangeExpr>*/;
 470 RET_LABEL:;
 471 }
 472 /* method parser_nodes#ARangeExpr#init for (self: Object) */
 473 void VIRTUAL_parser_nodes__ARangeExpr__init(val* self) {
 474 parser_nodes__ARangeExpr__init(self);
 475 RET_LABEL:;
 476 }
 477 /* method parser_nodes#ACrangeExpr#n_obra for (self: ACrangeExpr): TObra */
 478 val* parser_nodes__ACrangeExpr__n_obra(val* self) {
 479 val* var /* : TObra */;
 480 val* var1 /* : TObra */;
 481 var1 = self->attrs[COLOR_parser_nodes__ACrangeExpr___n_obra].val; /* _n_obra on <self:ACrangeExpr> */
 482 if (var1 == NULL) {
 483 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_obra");
 484 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1462);
 485 show_backtrace(1);
 486 }
 487 var = var1;
 488 RET_LABEL:;
 489 return var;
 490 }
 491 /* method parser_nodes#ACrangeExpr#n_obra for (self: Object): TObra */
 492 val* VIRTUAL_parser_nodes__ACrangeExpr__n_obra(val* self) {
 493 val* var /* : TObra */;
 494 val* var1 /* : TObra */;
 495 var1 = parser_nodes__ACrangeExpr__n_obra(self);
 496 var = var1;
 497 RET_LABEL:;
 498 return var;
 499 }
 500 /* method parser_nodes#ACrangeExpr#n_obra= for (self: ACrangeExpr, TObra) */
 501 void parser_nodes__ACrangeExpr__n_obra_61d(val* self, val* p0) {
 502 self->attrs[COLOR_parser_nodes__ACrangeExpr___n_obra].val = p0; /* _n_obra on <self:ACrangeExpr> */
 503 RET_LABEL:;
 504 }
 505 /* method parser_nodes#ACrangeExpr#n_obra= for (self: Object, TObra) */
 506 void VIRTUAL_parser_nodes__ACrangeExpr__n_obra_61d(val* self, val* p0) {
 507 parser_nodes__ACrangeExpr__n_obra_61d(self, p0);
 508 RET_LABEL:;
 509 }
 510 /* method parser_nodes#ACrangeExpr#n_cbra for (self: ACrangeExpr): TCbra */
 511 val* parser_nodes__ACrangeExpr__n_cbra(val* self) {
 512 val* var /* : TCbra */;
 513 val* var1 /* : TCbra */;
 514 var1 = self->attrs[COLOR_parser_nodes__ACrangeExpr___n_cbra].val; /* _n_cbra on <self:ACrangeExpr> */
 515 if (var1 == NULL) {
 516 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cbra");
 517 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1463);
 518 show_backtrace(1);
 519 }
 520 var = var1;
 521 RET_LABEL:;
 522 return var;
 523 }
 524 /* method parser_nodes#ACrangeExpr#n_cbra for (self: Object): TCbra */
 525 val* VIRTUAL_parser_nodes__ACrangeExpr__n_cbra(val* self) {
 526 val* var /* : TCbra */;
 527 val* var1 /* : TCbra */;
 528 var1 = parser_nodes__ACrangeExpr__n_cbra(self);
 529 var = var1;
 530 RET_LABEL:;
 531 return var;
 532 }
 533 /* method parser_nodes#ACrangeExpr#n_cbra= for (self: ACrangeExpr, TCbra) */
 534 void parser_nodes__ACrangeExpr__n_cbra_61d(val* self, val* p0) {
 535 self->attrs[COLOR_parser_nodes__ACrangeExpr___n_cbra].val = p0; /* _n_cbra on <self:ACrangeExpr> */
 536 RET_LABEL:;
 537 }
 538 /* method parser_nodes#ACrangeExpr#n_cbra= for (self: Object, TCbra) */
 539 void VIRTUAL_parser_nodes__ACrangeExpr__n_cbra_61d(val* self, val* p0) {
 540 parser_nodes__ACrangeExpr__n_cbra_61d(self, p0);
 541 RET_LABEL:;
 542 }
 543 /* method parser_nodes#ACrangeExpr#init for (self: ACrangeExpr) */
 544 void parser_nodes__ACrangeExpr__init(val* self) {
 545 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ARangeExpr__init]))(self) /* init on <self:ACrangeExpr>*/;
 546 RET_LABEL:;
 547 }
 548 /* method parser_nodes#ACrangeExpr#init for (self: Object) */
 549 void VIRTUAL_parser_nodes__ACrangeExpr__init(val* self) {
 550 parser_nodes__ACrangeExpr__init(self);
 551 RET_LABEL:;
 552 }
 553 /* method parser_nodes#AOrangeExpr#n_obra for (self: AOrangeExpr): TObra */
 554 val* parser_nodes__AOrangeExpr__n_obra(val* self) {
 555 val* var /* : TObra */;
 556 val* var1 /* : TObra */;
 557 var1 = self->attrs[COLOR_parser_nodes__AOrangeExpr___n_obra].val; /* _n_obra on <self:AOrangeExpr> */
 558 if (var1 == NULL) {
 559 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_obra");
 560 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1469);
 561 show_backtrace(1);
 562 }
 563 var = var1;
 564 RET_LABEL:;
 565 return var;
 566 }
 567 /* method parser_nodes#AOrangeExpr#n_obra for (self: Object): TObra */
 568 val* VIRTUAL_parser_nodes__AOrangeExpr__n_obra(val* self) {
 569 val* var /* : TObra */;
 570 val* var1 /* : TObra */;
 571 var1 = parser_nodes__AOrangeExpr__n_obra(self);
 572 var = var1;
 573 RET_LABEL:;
 574 return var;
 575 }
 576 /* method parser_nodes#AOrangeExpr#n_obra= for (self: AOrangeExpr, TObra) */
 577 void parser_nodes__AOrangeExpr__n_obra_61d(val* self, val* p0) {
 578 self->attrs[COLOR_parser_nodes__AOrangeExpr___n_obra].val = p0; /* _n_obra on <self:AOrangeExpr> */
 579 RET_LABEL:;
 580 }
 581 /* method parser_nodes#AOrangeExpr#n_obra= for (self: Object, TObra) */
 582 void VIRTUAL_parser_nodes__AOrangeExpr__n_obra_61d(val* self, val* p0) {
 583 parser_nodes__AOrangeExpr__n_obra_61d(self, p0);
 584 RET_LABEL:;
 585 }
 586 /* method parser_nodes#AOrangeExpr#n_cbra for (self: AOrangeExpr): TObra */
 587 val* parser_nodes__AOrangeExpr__n_cbra(val* self) {
 588 val* var /* : TObra */;
 589 val* var1 /* : TObra */;
 590 var1 = self->attrs[COLOR_parser_nodes__AOrangeExpr___n_cbra].val; /* _n_cbra on <self:AOrangeExpr> */
 591 if (var1 == NULL) {
 592 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cbra");
 593 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1470);
 594 show_backtrace(1);
 595 }
 596 var = var1;
 597 RET_LABEL:;
 598 return var;
 599 }
 600 /* method parser_nodes#AOrangeExpr#n_cbra for (self: Object): TObra */
 601 val* VIRTUAL_parser_nodes__AOrangeExpr__n_cbra(val* self) {
 602 val* var /* : TObra */;
 603 val* var1 /* : TObra */;
 604 var1 = parser_nodes__AOrangeExpr__n_cbra(self);
 605 var = var1;
 606 RET_LABEL:;
 607 return var;
 608 }
 609 /* method parser_nodes#AOrangeExpr#n_cbra= for (self: AOrangeExpr, TObra) */
 610 void parser_nodes__AOrangeExpr__n_cbra_61d(val* self, val* p0) {
 611 self->attrs[COLOR_parser_nodes__AOrangeExpr___n_cbra].val = p0; /* _n_cbra on <self:AOrangeExpr> */
 612 RET_LABEL:;
 613 }
 614 /* method parser_nodes#AOrangeExpr#n_cbra= for (self: Object, TObra) */
 615 void VIRTUAL_parser_nodes__AOrangeExpr__n_cbra_61d(val* self, val* p0) {
 616 parser_nodes__AOrangeExpr__n_cbra_61d(self, p0);
 617 RET_LABEL:;
 618 }
 619 /* method parser_nodes#AOrangeExpr#init for (self: AOrangeExpr) */
 620 void parser_nodes__AOrangeExpr__init(val* self) {
 621 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ARangeExpr__init]))(self) /* init on <self:AOrangeExpr>*/;
 622 RET_LABEL:;
 623 }
 624 /* method parser_nodes#AOrangeExpr#init for (self: Object) */
 625 void VIRTUAL_parser_nodes__AOrangeExpr__init(val* self) {
 626 parser_nodes__AOrangeExpr__init(self);
 627 RET_LABEL:;
 628 }
 629 /* method parser_nodes#AArrayExpr#n_exprs for (self: AArrayExpr): AExprs */
 630 val* parser_nodes__AArrayExpr__n_exprs(val* self) {
 631 val* var /* : AExprs */;
 632 val* var1 /* : AExprs */;
 633 var1 = self->attrs[COLOR_parser_nodes__AArrayExpr___n_exprs].val; /* _n_exprs on <self:AArrayExpr> */
 634 if (var1 == NULL) {
 635 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_exprs");
 636 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1476);
 637 show_backtrace(1);
 638 }
 639 var = var1;
 640 RET_LABEL:;
 641 return var;
 642 }
 643 /* method parser_nodes#AArrayExpr#n_exprs for (self: Object): AExprs */
 644 val* VIRTUAL_parser_nodes__AArrayExpr__n_exprs(val* self) {
 645 val* var /* : AExprs */;
 646 val* var1 /* : AExprs */;
 647 var1 = parser_nodes__AArrayExpr__n_exprs(self);
 648 var = var1;
 649 RET_LABEL:;
 650 return var;
 651 }
 652 /* method parser_nodes#AArrayExpr#n_exprs= for (self: AArrayExpr, AExprs) */
 653 void parser_nodes__AArrayExpr__n_exprs_61d(val* self, val* p0) {
 654 self->attrs[COLOR_parser_nodes__AArrayExpr___n_exprs].val = p0; /* _n_exprs on <self:AArrayExpr> */
 655 RET_LABEL:;
 656 }
 657 /* method parser_nodes#AArrayExpr#n_exprs= for (self: Object, AExprs) */
 658 void VIRTUAL_parser_nodes__AArrayExpr__n_exprs_61d(val* self, val* p0) {
 659 parser_nodes__AArrayExpr__n_exprs_61d(self, p0);
 660 RET_LABEL:;
 661 }
 662 /* method parser_nodes#AArrayExpr#init for (self: AArrayExpr) */
 663 void parser_nodes__AArrayExpr__init(val* self) {
 664 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AArrayExpr>*/;
 665 RET_LABEL:;
 666 }
 667 /* method parser_nodes#AArrayExpr#init for (self: Object) */
 668 void VIRTUAL_parser_nodes__AArrayExpr__init(val* self) {
 669 parser_nodes__AArrayExpr__init(self);
 670 RET_LABEL:;
 671 }
 672 /* method parser_nodes#ASelfExpr#n_kwself for (self: ASelfExpr): nullable TKwself */
 673 val* parser_nodes__ASelfExpr__n_kwself(val* self) {
 674 val* var /* : nullable TKwself */;
 675 val* var1 /* : nullable TKwself */;
 676 var1 = self->attrs[COLOR_parser_nodes__ASelfExpr___n_kwself].val; /* _n_kwself on <self:ASelfExpr> */
 677 var = var1;
 678 RET_LABEL:;
 679 return var;
 680 }
 681 /* method parser_nodes#ASelfExpr#n_kwself for (self: Object): nullable TKwself */
 682 val* VIRTUAL_parser_nodes__ASelfExpr__n_kwself(val* self) {
 683 val* var /* : nullable TKwself */;
 684 val* var1 /* : nullable TKwself */;
 685 var1 = parser_nodes__ASelfExpr__n_kwself(self);
 686 var = var1;
 687 RET_LABEL:;
 688 return var;
 689 }
 690 /* method parser_nodes#ASelfExpr#n_kwself= for (self: ASelfExpr, nullable TKwself) */
 691 void parser_nodes__ASelfExpr__n_kwself_61d(val* self, val* p0) {
 692 self->attrs[COLOR_parser_nodes__ASelfExpr___n_kwself].val = p0; /* _n_kwself on <self:ASelfExpr> */
 693 RET_LABEL:;
 694 }
 695 /* method parser_nodes#ASelfExpr#n_kwself= for (self: Object, nullable TKwself) */
 696 void VIRTUAL_parser_nodes__ASelfExpr__n_kwself_61d(val* self, val* p0) {
 697 parser_nodes__ASelfExpr__n_kwself_61d(self, p0);
 698 RET_LABEL:;
 699 }
 700 /* method parser_nodes#ASelfExpr#init for (self: ASelfExpr) */
 701 void parser_nodes__ASelfExpr__init(val* self) {
 702 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ASelfExpr>*/;
 703 RET_LABEL:;
 704 }
 705 /* method parser_nodes#ASelfExpr#init for (self: Object) */
 706 void VIRTUAL_parser_nodes__ASelfExpr__init(val* self) {
 707 parser_nodes__ASelfExpr__init(self);
 708 RET_LABEL:;
 709 }
 710 /* method parser_nodes#AImplicitSelfExpr#init for (self: AImplicitSelfExpr) */
 711 void parser_nodes__AImplicitSelfExpr__init(val* self) {
 712 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ASelfExpr__init]))(self) /* init on <self:AImplicitSelfExpr>*/;
 713 RET_LABEL:;
 714 }
 715 /* method parser_nodes#AImplicitSelfExpr#init for (self: Object) */
 716 void VIRTUAL_parser_nodes__AImplicitSelfExpr__init(val* self) {
 717 parser_nodes__AImplicitSelfExpr__init(self);
 718 RET_LABEL:;
 719 }
 720 /* method parser_nodes#ATrueExpr#n_kwtrue for (self: ATrueExpr): TKwtrue */
 721 val* parser_nodes__ATrueExpr__n_kwtrue(val* self) {
 722 val* var /* : TKwtrue */;
 723 val* var1 /* : TKwtrue */;
 724 var1 = self->attrs[COLOR_parser_nodes__ATrueExpr___n_kwtrue].val; /* _n_kwtrue on <self:ATrueExpr> */
 725 if (var1 == NULL) {
 726 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwtrue");
 727 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1493);
 728 show_backtrace(1);
 729 }
 730 var = var1;
 731 RET_LABEL:;
 732 return var;
 733 }
 734 /* method parser_nodes#ATrueExpr#n_kwtrue for (self: Object): TKwtrue */
 735 val* VIRTUAL_parser_nodes__ATrueExpr__n_kwtrue(val* self) {
 736 val* var /* : TKwtrue */;
 737 val* var1 /* : TKwtrue */;
 738 var1 = parser_nodes__ATrueExpr__n_kwtrue(self);
 739 var = var1;
 740 RET_LABEL:;
 741 return var;
 742 }
 743 /* method parser_nodes#ATrueExpr#n_kwtrue= for (self: ATrueExpr, TKwtrue) */
 744 void parser_nodes__ATrueExpr__n_kwtrue_61d(val* self, val* p0) {
 745 self->attrs[COLOR_parser_nodes__ATrueExpr___n_kwtrue].val = p0; /* _n_kwtrue on <self:ATrueExpr> */
 746 RET_LABEL:;
 747 }
 748 /* method parser_nodes#ATrueExpr#n_kwtrue= for (self: Object, TKwtrue) */
 749 void VIRTUAL_parser_nodes__ATrueExpr__n_kwtrue_61d(val* self, val* p0) {
 750 parser_nodes__ATrueExpr__n_kwtrue_61d(self, p0);
 751 RET_LABEL:;
 752 }
 753 /* method parser_nodes#ATrueExpr#init for (self: ATrueExpr) */
 754 void parser_nodes__ATrueExpr__init(val* self) {
 755 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ABoolExpr__init]))(self) /* init on <self:ATrueExpr>*/;
 756 RET_LABEL:;
 757 }
 758 /* method parser_nodes#ATrueExpr#init for (self: Object) */
 759 void VIRTUAL_parser_nodes__ATrueExpr__init(val* self) {
 760 parser_nodes__ATrueExpr__init(self);
 761 RET_LABEL:;
 762 }
 763 /* method parser_nodes#AFalseExpr#n_kwfalse for (self: AFalseExpr): TKwfalse */
 764 val* parser_nodes__AFalseExpr__n_kwfalse(val* self) {
 765 val* var /* : TKwfalse */;
 766 val* var1 /* : TKwfalse */;
 767 var1 = self->attrs[COLOR_parser_nodes__AFalseExpr___n_kwfalse].val; /* _n_kwfalse on <self:AFalseExpr> */
 768 if (var1 == NULL) {
 769 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwfalse");
 770 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1498);
 771 show_backtrace(1);
 772 }
 773 var = var1;
 774 RET_LABEL:;
 775 return var;
 776 }
 777 /* method parser_nodes#AFalseExpr#n_kwfalse for (self: Object): TKwfalse */
 778 val* VIRTUAL_parser_nodes__AFalseExpr__n_kwfalse(val* self) {
 779 val* var /* : TKwfalse */;
 780 val* var1 /* : TKwfalse */;
 781 var1 = parser_nodes__AFalseExpr__n_kwfalse(self);
 782 var = var1;
 783 RET_LABEL:;
 784 return var;
 785 }
 786 /* method parser_nodes#AFalseExpr#n_kwfalse= for (self: AFalseExpr, TKwfalse) */
 787 void parser_nodes__AFalseExpr__n_kwfalse_61d(val* self, val* p0) {
 788 self->attrs[COLOR_parser_nodes__AFalseExpr___n_kwfalse].val = p0; /* _n_kwfalse on <self:AFalseExpr> */
 789 RET_LABEL:;
 790 }
 791 /* method parser_nodes#AFalseExpr#n_kwfalse= for (self: Object, TKwfalse) */
 792 void VIRTUAL_parser_nodes__AFalseExpr__n_kwfalse_61d(val* self, val* p0) {
 793 parser_nodes__AFalseExpr__n_kwfalse_61d(self, p0);
 794 RET_LABEL:;
 795 }
 796 /* method parser_nodes#AFalseExpr#init for (self: AFalseExpr) */
 797 void parser_nodes__AFalseExpr__init(val* self) {
 798 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__ABoolExpr__init]))(self) /* init on <self:AFalseExpr>*/;
 799 RET_LABEL:;
 800 }
 801 /* method parser_nodes#AFalseExpr#init for (self: Object) */
 802 void VIRTUAL_parser_nodes__AFalseExpr__init(val* self) {
 803 parser_nodes__AFalseExpr__init(self);
 804 RET_LABEL:;
 805 }
 806 /* method parser_nodes#ANullExpr#n_kwnull for (self: ANullExpr): TKwnull */
 807 val* parser_nodes__ANullExpr__n_kwnull(val* self) {
 808 val* var /* : TKwnull */;
 809 val* var1 /* : TKwnull */;
 810 var1 = self->attrs[COLOR_parser_nodes__ANullExpr___n_kwnull].val; /* _n_kwnull on <self:ANullExpr> */
 811 if (var1 == NULL) {
 812 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwnull");
 813 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1503);
 814 show_backtrace(1);
 815 }
 816 var = var1;
 817 RET_LABEL:;
 818 return var;
 819 }
 820 /* method parser_nodes#ANullExpr#n_kwnull for (self: Object): TKwnull */
 821 val* VIRTUAL_parser_nodes__ANullExpr__n_kwnull(val* self) {
 822 val* var /* : TKwnull */;
 823 val* var1 /* : TKwnull */;
 824 var1 = parser_nodes__ANullExpr__n_kwnull(self);
 825 var = var1;
 826 RET_LABEL:;
 827 return var;
 828 }
 829 /* method parser_nodes#ANullExpr#n_kwnull= for (self: ANullExpr, TKwnull) */
 830 void parser_nodes__ANullExpr__n_kwnull_61d(val* self, val* p0) {
 831 self->attrs[COLOR_parser_nodes__ANullExpr___n_kwnull].val = p0; /* _n_kwnull on <self:ANullExpr> */
 832 RET_LABEL:;
 833 }
 834 /* method parser_nodes#ANullExpr#n_kwnull= for (self: Object, TKwnull) */
 835 void VIRTUAL_parser_nodes__ANullExpr__n_kwnull_61d(val* self, val* p0) {
 836 parser_nodes__ANullExpr__n_kwnull_61d(self, p0);
 837 RET_LABEL:;
 838 }
 839 /* method parser_nodes#ANullExpr#init for (self: ANullExpr) */
 840 void parser_nodes__ANullExpr__init(val* self) {
 841 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ANullExpr>*/;
 842 RET_LABEL:;
 843 }
 844 /* method parser_nodes#ANullExpr#init for (self: Object) */
 845 void VIRTUAL_parser_nodes__ANullExpr__init(val* self) {
 846 parser_nodes__ANullExpr__init(self);
 847 RET_LABEL:;
 848 }
 849 /* method parser_nodes#AIntExpr#n_number for (self: AIntExpr): TNumber */
 850 val* parser_nodes__AIntExpr__n_number(val* self) {
 851 val* var /* : TNumber */;
 852 val* var1 /* : TNumber */;
 853 var1 = self->attrs[COLOR_parser_nodes__AIntExpr___n_number].val; /* _n_number on <self:AIntExpr> */
 854 if (var1 == NULL) {
 855 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_number");
 856 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1508);
 857 show_backtrace(1);
 858 }
 859 var = var1;
 860 RET_LABEL:;
 861 return var;
 862 }
 863 /* method parser_nodes#AIntExpr#n_number for (self: Object): TNumber */
 864 val* VIRTUAL_parser_nodes__AIntExpr__n_number(val* self) {
 865 val* var /* : TNumber */;
 866 val* var1 /* : TNumber */;
 867 var1 = parser_nodes__AIntExpr__n_number(self);
 868 var = var1;
 869 RET_LABEL:;
 870 return var;
 871 }
 872 /* method parser_nodes#AIntExpr#n_number= for (self: AIntExpr, TNumber) */
 873 void parser_nodes__AIntExpr__n_number_61d(val* self, val* p0) {
 874 self->attrs[COLOR_parser_nodes__AIntExpr___n_number].val = p0; /* _n_number on <self:AIntExpr> */
 875 RET_LABEL:;
 876 }
 877 /* method parser_nodes#AIntExpr#n_number= for (self: Object, TNumber) */
 878 void VIRTUAL_parser_nodes__AIntExpr__n_number_61d(val* self, val* p0) {
 879 parser_nodes__AIntExpr__n_number_61d(self, p0);
 880 RET_LABEL:;
 881 }
 882 /* method parser_nodes#AIntExpr#init for (self: AIntExpr) */
 883 void parser_nodes__AIntExpr__init(val* self) {
 884 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AIntExpr>*/;
 885 RET_LABEL:;
 886 }
 887 /* method parser_nodes#AIntExpr#init for (self: Object) */
 888 void VIRTUAL_parser_nodes__AIntExpr__init(val* self) {
 889 parser_nodes__AIntExpr__init(self);
 890 RET_LABEL:;
 891 }
 892 /* method parser_nodes#AFloatExpr#n_float for (self: AFloatExpr): TFloat */
 893 val* parser_nodes__AFloatExpr__n_float(val* self) {
 894 val* var /* : TFloat */;
 895 val* var1 /* : TFloat */;
 896 var1 = self->attrs[COLOR_parser_nodes__AFloatExpr___n_float].val; /* _n_float on <self:AFloatExpr> */
 897 if (var1 == NULL) {
 898 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_float");
 899 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1513);
 900 show_backtrace(1);
 901 }
 902 var = var1;
 903 RET_LABEL:;
 904 return var;
 905 }
 906 /* method parser_nodes#AFloatExpr#n_float for (self: Object): TFloat */
 907 val* VIRTUAL_parser_nodes__AFloatExpr__n_float(val* self) {
 908 val* var /* : TFloat */;
 909 val* var1 /* : TFloat */;
 910 var1 = parser_nodes__AFloatExpr__n_float(self);
 911 var = var1;
 912 RET_LABEL:;
 913 return var;
 914 }
 915 /* method parser_nodes#AFloatExpr#n_float= for (self: AFloatExpr, TFloat) */
 916 void parser_nodes__AFloatExpr__n_float_61d(val* self, val* p0) {
 917 self->attrs[COLOR_parser_nodes__AFloatExpr___n_float].val = p0; /* _n_float on <self:AFloatExpr> */
 918 RET_LABEL:;
 919 }
 920 /* method parser_nodes#AFloatExpr#n_float= for (self: Object, TFloat) */
 921 void VIRTUAL_parser_nodes__AFloatExpr__n_float_61d(val* self, val* p0) {
 922 parser_nodes__AFloatExpr__n_float_61d(self, p0);
 923 RET_LABEL:;
 924 }
 925 /* method parser_nodes#AFloatExpr#init for (self: AFloatExpr) */
 926 void parser_nodes__AFloatExpr__init(val* self) {
 927 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AFloatExpr>*/;
 928 RET_LABEL:;
 929 }
 930 /* method parser_nodes#AFloatExpr#init for (self: Object) */
 931 void VIRTUAL_parser_nodes__AFloatExpr__init(val* self) {
 932 parser_nodes__AFloatExpr__init(self);
 933 RET_LABEL:;
 934 }
 935 /* method parser_nodes#ACharExpr#n_char for (self: ACharExpr): TChar */
 936 val* parser_nodes__ACharExpr__n_char(val* self) {
 937 val* var /* : TChar */;
 938 val* var1 /* : TChar */;
 939 var1 = self->attrs[COLOR_parser_nodes__ACharExpr___n_char].val; /* _n_char on <self:ACharExpr> */
 940 if (var1 == NULL) {
 941 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_char");
 942 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1518);
 943 show_backtrace(1);
 944 }
 945 var = var1;
 946 RET_LABEL:;
 947 return var;
 948 }
 949 /* method parser_nodes#ACharExpr#n_char for (self: Object): TChar */
 950 val* VIRTUAL_parser_nodes__ACharExpr__n_char(val* self) {
 951 val* var /* : TChar */;
 952 val* var1 /* : TChar */;
 953 var1 = parser_nodes__ACharExpr__n_char(self);
 954 var = var1;
 955 RET_LABEL:;
 956 return var;
 957 }
 958 /* method parser_nodes#ACharExpr#n_char= for (self: ACharExpr, TChar) */
 959 void parser_nodes__ACharExpr__n_char_61d(val* self, val* p0) {
 960 self->attrs[COLOR_parser_nodes__ACharExpr___n_char].val = p0; /* _n_char on <self:ACharExpr> */
 961 RET_LABEL:;
 962 }
 963 /* method parser_nodes#ACharExpr#n_char= for (self: Object, TChar) */
 964 void VIRTUAL_parser_nodes__ACharExpr__n_char_61d(val* self, val* p0) {
 965 parser_nodes__ACharExpr__n_char_61d(self, p0);
 966 RET_LABEL:;
 967 }
 968 /* method parser_nodes#ACharExpr#init for (self: ACharExpr) */
 969 void parser_nodes__ACharExpr__init(val* self) {
 970 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ACharExpr>*/;
 971 RET_LABEL:;
 972 }
 973 /* method parser_nodes#ACharExpr#init for (self: Object) */
 974 void VIRTUAL_parser_nodes__ACharExpr__init(val* self) {
 975 parser_nodes__ACharExpr__init(self);
 976 RET_LABEL:;
 977 }
 978 /* method parser_nodes#AStringFormExpr#n_string for (self: AStringFormExpr): Token */
 979 val* parser_nodes__AStringFormExpr__n_string(val* self) {
 980 val* var /* : Token */;
 981 val* var1 /* : Token */;
 982 var1 = self->attrs[COLOR_parser_nodes__AStringFormExpr___n_string].val; /* _n_string on <self:AStringFormExpr> */
 983 if (var1 == NULL) {
 984 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_string");
 985 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1523);
 986 show_backtrace(1);
 987 }
 988 var = var1;
 989 RET_LABEL:;
 990 return var;
 991 }
 992 /* method parser_nodes#AStringFormExpr#n_string for (self: Object): Token */
 993 val* VIRTUAL_parser_nodes__AStringFormExpr__n_string(val* self) {
 994 val* var /* : Token */;
 995 val* var1 /* : Token */;
 996 var1 = parser_nodes__AStringFormExpr__n_string(self);
 997 var = var1;
 998 RET_LABEL:;
 999 return var;
1000 }
1001 /* method parser_nodes#AStringFormExpr#n_string= for (self: AStringFormExpr, Token) */
1002 void parser_nodes__AStringFormExpr__n_string_61d(val* self, val* p0) {
1003 self->attrs[COLOR_parser_nodes__AStringFormExpr___n_string].val = p0; /* _n_string on <self:AStringFormExpr> */
1004 RET_LABEL:;
1005 }
1006 /* method parser_nodes#AStringFormExpr#n_string= for (self: Object, Token) */
1007 void VIRTUAL_parser_nodes__AStringFormExpr__n_string_61d(val* self, val* p0) {
1008 parser_nodes__AStringFormExpr__n_string_61d(self, p0);
1009 RET_LABEL:;
1010 }
1011 /* method parser_nodes#AStringFormExpr#init for (self: AStringFormExpr) */
1012 void parser_nodes__AStringFormExpr__init(val* self) {
1013 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AStringFormExpr>*/;
1014 RET_LABEL:;
1015 }
1016 /* method parser_nodes#AStringFormExpr#init for (self: Object) */
1017 void VIRTUAL_parser_nodes__AStringFormExpr__init(val* self) {
1018 parser_nodes__AStringFormExpr__init(self);
1019 RET_LABEL:;
1020 }
1021 /* method parser_nodes#AStringExpr#init for (self: AStringExpr) */
1022 void parser_nodes__AStringExpr__init(val* self) {
1023 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AStringFormExpr__init]))(self) /* init on <self:AStringExpr>*/;
1024 RET_LABEL:;
1025 }
1026 /* method parser_nodes#AStringExpr#init for (self: Object) */
1027 void VIRTUAL_parser_nodes__AStringExpr__init(val* self) {
1028 parser_nodes__AStringExpr__init(self);
1029 RET_LABEL:;
1030 }
1031 /* method parser_nodes#AStartStringExpr#init for (self: AStartStringExpr) */
1032 void parser_nodes__AStartStringExpr__init(val* self) {
1033 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AStringFormExpr__init]))(self) /* init on <self:AStartStringExpr>*/;
1034 RET_LABEL:;
1035 }
1036 /* method parser_nodes#AStartStringExpr#init for (self: Object) */
1037 void VIRTUAL_parser_nodes__AStartStringExpr__init(val* self) {
1038 parser_nodes__AStartStringExpr__init(self);
1039 RET_LABEL:;
1040 }
1041 /* method parser_nodes#AMidStringExpr#init for (self: AMidStringExpr) */
1042 void parser_nodes__AMidStringExpr__init(val* self) {
1043 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AStringFormExpr__init]))(self) /* init on <self:AMidStringExpr>*/;
1044 RET_LABEL:;
1045 }
1046 /* method parser_nodes#AMidStringExpr#init for (self: Object) */
1047 void VIRTUAL_parser_nodes__AMidStringExpr__init(val* self) {
1048 parser_nodes__AMidStringExpr__init(self);
1049 RET_LABEL:;
1050 }
1051 /* method parser_nodes#AEndStringExpr#init for (self: AEndStringExpr) */
1052 void parser_nodes__AEndStringExpr__init(val* self) {
1053 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AStringFormExpr__init]))(self) /* init on <self:AEndStringExpr>*/;
1054 RET_LABEL:;
1055 }
1056 /* method parser_nodes#AEndStringExpr#init for (self: Object) */
1057 void VIRTUAL_parser_nodes__AEndStringExpr__init(val* self) {
1058 parser_nodes__AEndStringExpr__init(self);
1059 RET_LABEL:;
1060 }
1061 /* method parser_nodes#ASuperstringExpr#n_exprs for (self: ASuperstringExpr): ANodes[AExpr] */
1062 val* parser_nodes__ASuperstringExpr__n_exprs(val* self) {
1063 val* var /* : ANodes[AExpr] */;
1064 val* var1 /* : ANodes[AExpr] */;
1065 var1 = self->attrs[COLOR_parser_nodes__ASuperstringExpr___n_exprs].val; /* _n_exprs on <self:ASuperstringExpr> */
1066 if (var1 == NULL) {
1067 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_exprs");
1068 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1550);
1069 show_backtrace(1);
1070 }
1071 var = var1;
1072 RET_LABEL:;
1073 return var;
1074 }
1075 /* method parser_nodes#ASuperstringExpr#n_exprs for (self: Object): ANodes[AExpr] */
1076 val* VIRTUAL_parser_nodes__ASuperstringExpr__n_exprs(val* self) {
1077 val* var /* : ANodes[AExpr] */;
1078 val* var1 /* : ANodes[AExpr] */;
1079 var1 = parser_nodes__ASuperstringExpr__n_exprs(self);
1080 var = var1;
1081 RET_LABEL:;
1082 return var;
1083 }
1084 /* method parser_nodes#ASuperstringExpr#init for (self: ASuperstringExpr) */
1085 void parser_nodes__ASuperstringExpr__init(val* self) {
1086 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ASuperstringExpr>*/;
1087 RET_LABEL:;
1088 }
1089 /* method parser_nodes#ASuperstringExpr#init for (self: Object) */
1090 void VIRTUAL_parser_nodes__ASuperstringExpr__init(val* self) {
1091 parser_nodes__ASuperstringExpr__init(self);
1092 RET_LABEL:;
1093 }
1094 /* method parser_nodes#AParExpr#n_opar for (self: AParExpr): TOpar */
1095 val* parser_nodes__AParExpr__n_opar(val* self) {
1096 val* var /* : TOpar */;
1097 val* var1 /* : TOpar */;
1098 var1 = self->attrs[COLOR_parser_nodes__AParExpr___n_opar].val; /* _n_opar on <self:AParExpr> */
1099 if (var1 == NULL) {
1100 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_opar");
1101 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1556);
1102 show_backtrace(1);
1103 }
1104 var = var1;
1105 RET_LABEL:;
1106 return var;
1107 }
1108 /* method parser_nodes#AParExpr#n_opar for (self: Object): TOpar */
1109 val* VIRTUAL_parser_nodes__AParExpr__n_opar(val* self) {
1110 val* var /* : TOpar */;
1111 val* var1 /* : TOpar */;
1112 var1 = parser_nodes__AParExpr__n_opar(self);
1113 var = var1;
1114 RET_LABEL:;
1115 return var;
1116 }
1117 /* method parser_nodes#AParExpr#n_opar= for (self: AParExpr, TOpar) */
1118 void parser_nodes__AParExpr__n_opar_61d(val* self, val* p0) {
1119 self->attrs[COLOR_parser_nodes__AParExpr___n_opar].val = p0; /* _n_opar on <self:AParExpr> */
1120 RET_LABEL:;
1121 }
1122 /* method parser_nodes#AParExpr#n_opar= for (self: Object, TOpar) */
1123 void VIRTUAL_parser_nodes__AParExpr__n_opar_61d(val* self, val* p0) {
1124 parser_nodes__AParExpr__n_opar_61d(self, p0);
1125 RET_LABEL:;
1126 }
1127 /* method parser_nodes#AParExpr#n_cpar for (self: AParExpr): TCpar */
1128 val* parser_nodes__AParExpr__n_cpar(val* self) {
1129 val* var /* : TCpar */;
1130 val* var1 /* : TCpar */;
1131 var1 = self->attrs[COLOR_parser_nodes__AParExpr___n_cpar].val; /* _n_cpar on <self:AParExpr> */
1132 if (var1 == NULL) {
1133 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cpar");
1134 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1557);
1135 show_backtrace(1);
1136 }
1137 var = var1;
1138 RET_LABEL:;
1139 return var;
1140 }
1141 /* method parser_nodes#AParExpr#n_cpar for (self: Object): TCpar */
1142 val* VIRTUAL_parser_nodes__AParExpr__n_cpar(val* self) {
1143 val* var /* : TCpar */;
1144 val* var1 /* : TCpar */;
1145 var1 = parser_nodes__AParExpr__n_cpar(self);
1146 var = var1;
1147 RET_LABEL:;
1148 return var;
1149 }
1150 /* method parser_nodes#AParExpr#n_cpar= for (self: AParExpr, TCpar) */
1151 void parser_nodes__AParExpr__n_cpar_61d(val* self, val* p0) {
1152 self->attrs[COLOR_parser_nodes__AParExpr___n_cpar].val = p0; /* _n_cpar on <self:AParExpr> */
1153 RET_LABEL:;
1154 }
1155 /* method parser_nodes#AParExpr#n_cpar= for (self: Object, TCpar) */
1156 void VIRTUAL_parser_nodes__AParExpr__n_cpar_61d(val* self, val* p0) {
1157 parser_nodes__AParExpr__n_cpar_61d(self, p0);
1158 RET_LABEL:;
1159 }
1160 /* method parser_nodes#AParExpr#init for (self: AParExpr) */
1161 void parser_nodes__AParExpr__init(val* self) {
1162 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AProxyExpr__init]))(self) /* init on <self:AParExpr>*/;
1163 RET_LABEL:;
1164 }
1165 /* method parser_nodes#AParExpr#init for (self: Object) */
1166 void VIRTUAL_parser_nodes__AParExpr__init(val* self) {
1167 parser_nodes__AParExpr__init(self);
1168 RET_LABEL:;
1169 }
1170 /* method parser_nodes#AProxyExpr#n_expr for (self: AProxyExpr): AExpr */
1171 val* parser_nodes__AProxyExpr__n_expr(val* self) {
1172 val* var /* : AExpr */;
1173 val* var1 /* : AExpr */;
1174 var1 = self->attrs[COLOR_parser_nodes__AProxyExpr___n_expr].val; /* _n_expr on <self:AProxyExpr> */
1175 if (var1 == NULL) {
1176 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr");
1177 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1563);
1178 show_backtrace(1);
1179 }
1180 var = var1;
1181 RET_LABEL:;
1182 return var;
1183 }
1184 /* method parser_nodes#AProxyExpr#n_expr for (self: Object): AExpr */
1185 val* VIRTUAL_parser_nodes__AProxyExpr__n_expr(val* self) {
1186 val* var /* : AExpr */;
1187 val* var1 /* : AExpr */;
1188 var1 = parser_nodes__AProxyExpr__n_expr(self);
1189 var = var1;
1190 RET_LABEL:;
1191 return var;
1192 }
1193 /* method parser_nodes#AProxyExpr#n_expr= for (self: AProxyExpr, AExpr) */
1194 void parser_nodes__AProxyExpr__n_expr_61d(val* self, val* p0) {
1195 self->attrs[COLOR_parser_nodes__AProxyExpr___n_expr].val = p0; /* _n_expr on <self:AProxyExpr> */
1196 RET_LABEL:;
1197 }
1198 /* method parser_nodes#AProxyExpr#n_expr= for (self: Object, AExpr) */
1199 void VIRTUAL_parser_nodes__AProxyExpr__n_expr_61d(val* self, val* p0) {
1200 parser_nodes__AProxyExpr__n_expr_61d(self, p0);
1201 RET_LABEL:;
1202 }
1203 /* method parser_nodes#AProxyExpr#init for (self: AProxyExpr) */
1204 void parser_nodes__AProxyExpr__init(val* self) {
1205 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AProxyExpr>*/;
1206 RET_LABEL:;
1207 }
1208 /* method parser_nodes#AProxyExpr#init for (self: Object) */
1209 void VIRTUAL_parser_nodes__AProxyExpr__init(val* self) {
1210 parser_nodes__AProxyExpr__init(self);
1211 RET_LABEL:;
1212 }
1213 /* method parser_nodes#AAsCastExpr#n_expr for (self: AAsCastExpr): AExpr */
1214 val* parser_nodes__AAsCastExpr__n_expr(val* self) {
1215 val* var /* : AExpr */;
1216 val* var1 /* : AExpr */;
1217 var1 = self->attrs[COLOR_parser_nodes__AAsCastExpr___n_expr].val; /* _n_expr on <self:AAsCastExpr> */
1218 if (var1 == NULL) {
1219 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr");
1220 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1569);
1221 show_backtrace(1);
1222 }
1223 var = var1;
1224 RET_LABEL:;
1225 return var;
1226 }
1227 /* method parser_nodes#AAsCastExpr#n_expr for (self: Object): AExpr */
1228 val* VIRTUAL_parser_nodes__AAsCastExpr__n_expr(val* self) {
1229 val* var /* : AExpr */;
1230 val* var1 /* : AExpr */;
1231 var1 = parser_nodes__AAsCastExpr__n_expr(self);
1232 var = var1;
1233 RET_LABEL:;
1234 return var;
1235 }
1236 /* method parser_nodes#AAsCastExpr#n_expr= for (self: AAsCastExpr, AExpr) */
1237 void parser_nodes__AAsCastExpr__n_expr_61d(val* self, val* p0) {
1238 self->attrs[COLOR_parser_nodes__AAsCastExpr___n_expr].val = p0; /* _n_expr on <self:AAsCastExpr> */
1239 RET_LABEL:;
1240 }
1241 /* method parser_nodes#AAsCastExpr#n_expr= for (self: Object, AExpr) */
1242 void VIRTUAL_parser_nodes__AAsCastExpr__n_expr_61d(val* self, val* p0) {
1243 parser_nodes__AAsCastExpr__n_expr_61d(self, p0);
1244 RET_LABEL:;
1245 }
1246 /* method parser_nodes#AAsCastExpr#n_kwas for (self: AAsCastExpr): TKwas */
1247 val* parser_nodes__AAsCastExpr__n_kwas(val* self) {
1248 val* var /* : TKwas */;
1249 val* var1 /* : TKwas */;
1250 var1 = self->attrs[COLOR_parser_nodes__AAsCastExpr___n_kwas].val; /* _n_kwas on <self:AAsCastExpr> */
1251 if (var1 == NULL) {
1252 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwas");
1253 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1570);
1254 show_backtrace(1);
1255 }
1256 var = var1;
1257 RET_LABEL:;
1258 return var;
1259 }
1260 /* method parser_nodes#AAsCastExpr#n_kwas for (self: Object): TKwas */
1261 val* VIRTUAL_parser_nodes__AAsCastExpr__n_kwas(val* self) {
1262 val* var /* : TKwas */;
1263 val* var1 /* : TKwas */;
1264 var1 = parser_nodes__AAsCastExpr__n_kwas(self);
1265 var = var1;
1266 RET_LABEL:;
1267 return var;
1268 }
1269 /* method parser_nodes#AAsCastExpr#n_kwas= for (self: AAsCastExpr, TKwas) */
1270 void parser_nodes__AAsCastExpr__n_kwas_61d(val* self, val* p0) {
1271 self->attrs[COLOR_parser_nodes__AAsCastExpr___n_kwas].val = p0; /* _n_kwas on <self:AAsCastExpr> */
1272 RET_LABEL:;
1273 }
1274 /* method parser_nodes#AAsCastExpr#n_kwas= for (self: Object, TKwas) */
1275 void VIRTUAL_parser_nodes__AAsCastExpr__n_kwas_61d(val* self, val* p0) {
1276 parser_nodes__AAsCastExpr__n_kwas_61d(self, p0);
1277 RET_LABEL:;
1278 }
1279 /* method parser_nodes#AAsCastExpr#n_opar for (self: AAsCastExpr): TOpar */
1280 val* parser_nodes__AAsCastExpr__n_opar(val* self) {
1281 val* var /* : TOpar */;
1282 val* var1 /* : TOpar */;
1283 var1 = self->attrs[COLOR_parser_nodes__AAsCastExpr___n_opar].val; /* _n_opar on <self:AAsCastExpr> */
1284 if (var1 == NULL) {
1285 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_opar");
1286 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1571);
1287 show_backtrace(1);
1288 }
1289 var = var1;
1290 RET_LABEL:;
1291 return var;
1292 }
1293 /* method parser_nodes#AAsCastExpr#n_opar for (self: Object): TOpar */
1294 val* VIRTUAL_parser_nodes__AAsCastExpr__n_opar(val* self) {
1295 val* var /* : TOpar */;
1296 val* var1 /* : TOpar */;
1297 var1 = parser_nodes__AAsCastExpr__n_opar(self);
1298 var = var1;
1299 RET_LABEL:;
1300 return var;
1301 }
1302 /* method parser_nodes#AAsCastExpr#n_opar= for (self: AAsCastExpr, TOpar) */
1303 void parser_nodes__AAsCastExpr__n_opar_61d(val* self, val* p0) {
1304 self->attrs[COLOR_parser_nodes__AAsCastExpr___n_opar].val = p0; /* _n_opar on <self:AAsCastExpr> */
1305 RET_LABEL:;
1306 }
1307 /* method parser_nodes#AAsCastExpr#n_opar= for (self: Object, TOpar) */
1308 void VIRTUAL_parser_nodes__AAsCastExpr__n_opar_61d(val* self, val* p0) {
1309 parser_nodes__AAsCastExpr__n_opar_61d(self, p0);
1310 RET_LABEL:;
1311 }
1312 /* method parser_nodes#AAsCastExpr#n_type for (self: AAsCastExpr): AType */
1313 val* parser_nodes__AAsCastExpr__n_type(val* self) {
1314 val* var /* : AType */;
1315 val* var1 /* : AType */;
1316 var1 = self->attrs[COLOR_parser_nodes__AAsCastExpr___n_type].val; /* _n_type on <self:AAsCastExpr> */
1317 if (var1 == NULL) {
1318 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_type");
1319 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1572);
1320 show_backtrace(1);
1321 }
1322 var = var1;
1323 RET_LABEL:;
1324 return var;
1325 }
1326 /* method parser_nodes#AAsCastExpr#n_type for (self: Object): AType */
1327 val* VIRTUAL_parser_nodes__AAsCastExpr__n_type(val* self) {
1328 val* var /* : AType */;
1329 val* var1 /* : AType */;
1330 var1 = parser_nodes__AAsCastExpr__n_type(self);
1331 var = var1;
1332 RET_LABEL:;
1333 return var;
1334 }
1335 /* method parser_nodes#AAsCastExpr#n_type= for (self: AAsCastExpr, AType) */
1336 void parser_nodes__AAsCastExpr__n_type_61d(val* self, val* p0) {
1337 self->attrs[COLOR_parser_nodes__AAsCastExpr___n_type].val = p0; /* _n_type on <self:AAsCastExpr> */
1338 RET_LABEL:;
1339 }
1340 /* method parser_nodes#AAsCastExpr#n_type= for (self: Object, AType) */
1341 void VIRTUAL_parser_nodes__AAsCastExpr__n_type_61d(val* self, val* p0) {
1342 parser_nodes__AAsCastExpr__n_type_61d(self, p0);
1343 RET_LABEL:;
1344 }
1345 /* method parser_nodes#AAsCastExpr#n_cpar for (self: AAsCastExpr): TCpar */
1346 val* parser_nodes__AAsCastExpr__n_cpar(val* self) {
1347 val* var /* : TCpar */;
1348 val* var1 /* : TCpar */;
1349 var1 = self->attrs[COLOR_parser_nodes__AAsCastExpr___n_cpar].val; /* _n_cpar on <self:AAsCastExpr> */
1350 if (var1 == NULL) {
1351 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cpar");
1352 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1573);
1353 show_backtrace(1);
1354 }
1355 var = var1;
1356 RET_LABEL:;
1357 return var;
1358 }
1359 /* method parser_nodes#AAsCastExpr#n_cpar for (self: Object): TCpar */
1360 val* VIRTUAL_parser_nodes__AAsCastExpr__n_cpar(val* self) {
1361 val* var /* : TCpar */;
1362 val* var1 /* : TCpar */;
1363 var1 = parser_nodes__AAsCastExpr__n_cpar(self);
1364 var = var1;
1365 RET_LABEL:;
1366 return var;
1367 }
1368 /* method parser_nodes#AAsCastExpr#n_cpar= for (self: AAsCastExpr, TCpar) */
1369 void parser_nodes__AAsCastExpr__n_cpar_61d(val* self, val* p0) {
1370 self->attrs[COLOR_parser_nodes__AAsCastExpr___n_cpar].val = p0; /* _n_cpar on <self:AAsCastExpr> */
1371 RET_LABEL:;
1372 }
1373 /* method parser_nodes#AAsCastExpr#n_cpar= for (self: Object, TCpar) */
1374 void VIRTUAL_parser_nodes__AAsCastExpr__n_cpar_61d(val* self, val* p0) {
1375 parser_nodes__AAsCastExpr__n_cpar_61d(self, p0);
1376 RET_LABEL:;
1377 }
1378 /* method parser_nodes#AAsCastExpr#init for (self: AAsCastExpr) */
1379 void parser_nodes__AAsCastExpr__init(val* self) {
1380 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AAsCastExpr>*/;
1381 RET_LABEL:;
1382 }
1383 /* method parser_nodes#AAsCastExpr#init for (self: Object) */
1384 void VIRTUAL_parser_nodes__AAsCastExpr__init(val* self) {
1385 parser_nodes__AAsCastExpr__init(self);
1386 RET_LABEL:;
1387 }
1388 /* method parser_nodes#AAsNotnullExpr#n_expr for (self: AAsNotnullExpr): AExpr */
1389 val* parser_nodes__AAsNotnullExpr__n_expr(val* self) {
1390 val* var /* : AExpr */;
1391 val* var1 /* : AExpr */;
1392 var1 = self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_expr].val; /* _n_expr on <self:AAsNotnullExpr> */
1393 if (var1 == NULL) {
1394 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr");
1395 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1579);
1396 show_backtrace(1);
1397 }
1398 var = var1;
1399 RET_LABEL:;
1400 return var;
1401 }
1402 /* method parser_nodes#AAsNotnullExpr#n_expr for (self: Object): AExpr */
1403 val* VIRTUAL_parser_nodes__AAsNotnullExpr__n_expr(val* self) {
1404 val* var /* : AExpr */;
1405 val* var1 /* : AExpr */;
1406 var1 = parser_nodes__AAsNotnullExpr__n_expr(self);
1407 var = var1;
1408 RET_LABEL:;
1409 return var;
1410 }
1411 /* method parser_nodes#AAsNotnullExpr#n_expr= for (self: AAsNotnullExpr, AExpr) */
1412 void parser_nodes__AAsNotnullExpr__n_expr_61d(val* self, val* p0) {
1413 self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_expr].val = p0; /* _n_expr on <self:AAsNotnullExpr> */
1414 RET_LABEL:;
1415 }
1416 /* method parser_nodes#AAsNotnullExpr#n_expr= for (self: Object, AExpr) */
1417 void VIRTUAL_parser_nodes__AAsNotnullExpr__n_expr_61d(val* self, val* p0) {
1418 parser_nodes__AAsNotnullExpr__n_expr_61d(self, p0);
1419 RET_LABEL:;
1420 }
1421 /* method parser_nodes#AAsNotnullExpr#n_kwas for (self: AAsNotnullExpr): TKwas */
1422 val* parser_nodes__AAsNotnullExpr__n_kwas(val* self) {
1423 val* var /* : TKwas */;
1424 val* var1 /* : TKwas */;
1425 var1 = self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_kwas].val; /* _n_kwas on <self:AAsNotnullExpr> */
1426 if (var1 == NULL) {
1427 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwas");
1428 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1580);
1429 show_backtrace(1);
1430 }
1431 var = var1;
1432 RET_LABEL:;
1433 return var;
1434 }
1435 /* method parser_nodes#AAsNotnullExpr#n_kwas for (self: Object): TKwas */
1436 val* VIRTUAL_parser_nodes__AAsNotnullExpr__n_kwas(val* self) {
1437 val* var /* : TKwas */;
1438 val* var1 /* : TKwas */;
1439 var1 = parser_nodes__AAsNotnullExpr__n_kwas(self);
1440 var = var1;
1441 RET_LABEL:;
1442 return var;
1443 }
1444 /* method parser_nodes#AAsNotnullExpr#n_kwas= for (self: AAsNotnullExpr, TKwas) */
1445 void parser_nodes__AAsNotnullExpr__n_kwas_61d(val* self, val* p0) {
1446 self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_kwas].val = p0; /* _n_kwas on <self:AAsNotnullExpr> */
1447 RET_LABEL:;
1448 }
1449 /* method parser_nodes#AAsNotnullExpr#n_kwas= for (self: Object, TKwas) */
1450 void VIRTUAL_parser_nodes__AAsNotnullExpr__n_kwas_61d(val* self, val* p0) {
1451 parser_nodes__AAsNotnullExpr__n_kwas_61d(self, p0);
1452 RET_LABEL:;
1453 }
1454 /* method parser_nodes#AAsNotnullExpr#n_opar for (self: AAsNotnullExpr): TOpar */
1455 val* parser_nodes__AAsNotnullExpr__n_opar(val* self) {
1456 val* var /* : TOpar */;
1457 val* var1 /* : TOpar */;
1458 var1 = self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_opar].val; /* _n_opar on <self:AAsNotnullExpr> */
1459 if (var1 == NULL) {
1460 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_opar");
1461 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1581);
1462 show_backtrace(1);
1463 }
1464 var = var1;
1465 RET_LABEL:;
1466 return var;
1467 }
1468 /* method parser_nodes#AAsNotnullExpr#n_opar for (self: Object): TOpar */
1469 val* VIRTUAL_parser_nodes__AAsNotnullExpr__n_opar(val* self) {
1470 val* var /* : TOpar */;
1471 val* var1 /* : TOpar */;
1472 var1 = parser_nodes__AAsNotnullExpr__n_opar(self);
1473 var = var1;
1474 RET_LABEL:;
1475 return var;
1476 }
1477 /* method parser_nodes#AAsNotnullExpr#n_opar= for (self: AAsNotnullExpr, TOpar) */
1478 void parser_nodes__AAsNotnullExpr__n_opar_61d(val* self, val* p0) {
1479 self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_opar].val = p0; /* _n_opar on <self:AAsNotnullExpr> */
1480 RET_LABEL:;
1481 }
1482 /* method parser_nodes#AAsNotnullExpr#n_opar= for (self: Object, TOpar) */
1483 void VIRTUAL_parser_nodes__AAsNotnullExpr__n_opar_61d(val* self, val* p0) {
1484 parser_nodes__AAsNotnullExpr__n_opar_61d(self, p0);
1485 RET_LABEL:;
1486 }
1487 /* method parser_nodes#AAsNotnullExpr#n_kwnot for (self: AAsNotnullExpr): TKwnot */
1488 val* parser_nodes__AAsNotnullExpr__n_kwnot(val* self) {
1489 val* var /* : TKwnot */;
1490 val* var1 /* : TKwnot */;
1491 var1 = self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_kwnot].val; /* _n_kwnot on <self:AAsNotnullExpr> */
1492 if (var1 == NULL) {
1493 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwnot");
1494 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1582);
1495 show_backtrace(1);
1496 }
1497 var = var1;
1498 RET_LABEL:;
1499 return var;
1500 }
1501 /* method parser_nodes#AAsNotnullExpr#n_kwnot for (self: Object): TKwnot */
1502 val* VIRTUAL_parser_nodes__AAsNotnullExpr__n_kwnot(val* self) {
1503 val* var /* : TKwnot */;
1504 val* var1 /* : TKwnot */;
1505 var1 = parser_nodes__AAsNotnullExpr__n_kwnot(self);
1506 var = var1;
1507 RET_LABEL:;
1508 return var;
1509 }
1510 /* method parser_nodes#AAsNotnullExpr#n_kwnot= for (self: AAsNotnullExpr, TKwnot) */
1511 void parser_nodes__AAsNotnullExpr__n_kwnot_61d(val* self, val* p0) {
1512 self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_kwnot].val = p0; /* _n_kwnot on <self:AAsNotnullExpr> */
1513 RET_LABEL:;
1514 }
1515 /* method parser_nodes#AAsNotnullExpr#n_kwnot= for (self: Object, TKwnot) */
1516 void VIRTUAL_parser_nodes__AAsNotnullExpr__n_kwnot_61d(val* self, val* p0) {
1517 parser_nodes__AAsNotnullExpr__n_kwnot_61d(self, p0);
1518 RET_LABEL:;
1519 }
1520 /* method parser_nodes#AAsNotnullExpr#n_kwnull for (self: AAsNotnullExpr): TKwnull */
1521 val* parser_nodes__AAsNotnullExpr__n_kwnull(val* self) {
1522 val* var /* : TKwnull */;
1523 val* var1 /* : TKwnull */;
1524 var1 = self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_kwnull].val; /* _n_kwnull on <self:AAsNotnullExpr> */
1525 if (var1 == NULL) {
1526 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwnull");
1527 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1583);
1528 show_backtrace(1);
1529 }
1530 var = var1;
1531 RET_LABEL:;
1532 return var;
1533 }
1534 /* method parser_nodes#AAsNotnullExpr#n_kwnull for (self: Object): TKwnull */
1535 val* VIRTUAL_parser_nodes__AAsNotnullExpr__n_kwnull(val* self) {
1536 val* var /* : TKwnull */;
1537 val* var1 /* : TKwnull */;
1538 var1 = parser_nodes__AAsNotnullExpr__n_kwnull(self);
1539 var = var1;
1540 RET_LABEL:;
1541 return var;
1542 }
1543 /* method parser_nodes#AAsNotnullExpr#n_kwnull= for (self: AAsNotnullExpr, TKwnull) */
1544 void parser_nodes__AAsNotnullExpr__n_kwnull_61d(val* self, val* p0) {
1545 self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_kwnull].val = p0; /* _n_kwnull on <self:AAsNotnullExpr> */
1546 RET_LABEL:;
1547 }
1548 /* method parser_nodes#AAsNotnullExpr#n_kwnull= for (self: Object, TKwnull) */
1549 void VIRTUAL_parser_nodes__AAsNotnullExpr__n_kwnull_61d(val* self, val* p0) {
1550 parser_nodes__AAsNotnullExpr__n_kwnull_61d(self, p0);
1551 RET_LABEL:;
1552 }
1553 /* method parser_nodes#AAsNotnullExpr#n_cpar for (self: AAsNotnullExpr): TCpar */
1554 val* parser_nodes__AAsNotnullExpr__n_cpar(val* self) {
1555 val* var /* : TCpar */;
1556 val* var1 /* : TCpar */;
1557 var1 = self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_cpar].val; /* _n_cpar on <self:AAsNotnullExpr> */
1558 if (var1 == NULL) {
1559 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cpar");
1560 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1584);
1561 show_backtrace(1);
1562 }
1563 var = var1;
1564 RET_LABEL:;
1565 return var;
1566 }
1567 /* method parser_nodes#AAsNotnullExpr#n_cpar for (self: Object): TCpar */
1568 val* VIRTUAL_parser_nodes__AAsNotnullExpr__n_cpar(val* self) {
1569 val* var /* : TCpar */;
1570 val* var1 /* : TCpar */;
1571 var1 = parser_nodes__AAsNotnullExpr__n_cpar(self);
1572 var = var1;
1573 RET_LABEL:;
1574 return var;
1575 }
1576 /* method parser_nodes#AAsNotnullExpr#n_cpar= for (self: AAsNotnullExpr, TCpar) */
1577 void parser_nodes__AAsNotnullExpr__n_cpar_61d(val* self, val* p0) {
1578 self->attrs[COLOR_parser_nodes__AAsNotnullExpr___n_cpar].val = p0; /* _n_cpar on <self:AAsNotnullExpr> */
1579 RET_LABEL:;
1580 }
1581 /* method parser_nodes#AAsNotnullExpr#n_cpar= for (self: Object, TCpar) */
1582 void VIRTUAL_parser_nodes__AAsNotnullExpr__n_cpar_61d(val* self, val* p0) {
1583 parser_nodes__AAsNotnullExpr__n_cpar_61d(self, p0);
1584 RET_LABEL:;
1585 }
1586 /* method parser_nodes#AAsNotnullExpr#init for (self: AAsNotnullExpr) */
1587 void parser_nodes__AAsNotnullExpr__init(val* self) {
1588 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:AAsNotnullExpr>*/;
1589 RET_LABEL:;
1590 }
1591 /* method parser_nodes#AAsNotnullExpr#init for (self: Object) */
1592 void VIRTUAL_parser_nodes__AAsNotnullExpr__init(val* self) {
1593 parser_nodes__AAsNotnullExpr__init(self);
1594 RET_LABEL:;
1595 }
1596 /* method parser_nodes#AIssetAttrExpr#n_kwisset for (self: AIssetAttrExpr): TKwisset */
1597 val* parser_nodes__AIssetAttrExpr__n_kwisset(val* self) {
1598 val* var /* : TKwisset */;
1599 val* var1 /* : TKwisset */;
1600 var1 = self->attrs[COLOR_parser_nodes__AIssetAttrExpr___n_kwisset].val; /* _n_kwisset on <self:AIssetAttrExpr> */
1601 if (var1 == NULL) {
1602 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwisset");
1603 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1590);
1604 show_backtrace(1);
1605 }
1606 var = var1;
1607 RET_LABEL:;
1608 return var;
1609 }
1610 /* method parser_nodes#AIssetAttrExpr#n_kwisset for (self: Object): TKwisset */
1611 val* VIRTUAL_parser_nodes__AIssetAttrExpr__n_kwisset(val* self) {
1612 val* var /* : TKwisset */;
1613 val* var1 /* : TKwisset */;
1614 var1 = parser_nodes__AIssetAttrExpr__n_kwisset(self);
1615 var = var1;
1616 RET_LABEL:;
1617 return var;
1618 }
1619 /* method parser_nodes#AIssetAttrExpr#n_kwisset= for (self: AIssetAttrExpr, TKwisset) */
1620 void parser_nodes__AIssetAttrExpr__n_kwisset_61d(val* self, val* p0) {
1621 self->attrs[COLOR_parser_nodes__AIssetAttrExpr___n_kwisset].val = p0; /* _n_kwisset on <self:AIssetAttrExpr> */
1622 RET_LABEL:;
1623 }
1624 /* method parser_nodes#AIssetAttrExpr#n_kwisset= for (self: Object, TKwisset) */
1625 void VIRTUAL_parser_nodes__AIssetAttrExpr__n_kwisset_61d(val* self, val* p0) {
1626 parser_nodes__AIssetAttrExpr__n_kwisset_61d(self, p0);
1627 RET_LABEL:;
1628 }
1629 /* method parser_nodes#AIssetAttrExpr#init for (self: AIssetAttrExpr) */
1630 void parser_nodes__AIssetAttrExpr__init(val* self) {
1631 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAttrFormExpr__init]))(self) /* init on <self:AIssetAttrExpr>*/;
1632 RET_LABEL:;
1633 }
1634 /* method parser_nodes#AIssetAttrExpr#init for (self: Object) */
1635 void VIRTUAL_parser_nodes__AIssetAttrExpr__init(val* self) {
1636 parser_nodes__AIssetAttrExpr__init(self);
1637 RET_LABEL:;
1638 }
1639 /* method parser_nodes#AExprs#n_exprs for (self: AExprs): ANodes[AExpr] */
1640 val* parser_nodes__AExprs__n_exprs(val* self) {
1641 val* var /* : ANodes[AExpr] */;
1642 val* var1 /* : ANodes[AExpr] */;
1643 var1 = self->attrs[COLOR_parser_nodes__AExprs___n_exprs].val; /* _n_exprs on <self:AExprs> */
1644 if (var1 == NULL) {
1645 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_exprs");
1646 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1596);
1647 show_backtrace(1);
1648 }
1649 var = var1;
1650 RET_LABEL:;
1651 return var;
1652 }
1653 /* method parser_nodes#AExprs#n_exprs for (self: Object): ANodes[AExpr] */
1654 val* VIRTUAL_parser_nodes__AExprs__n_exprs(val* self) {
1655 val* var /* : ANodes[AExpr] */;
1656 val* var1 /* : ANodes[AExpr] */;
1657 var1 = parser_nodes__AExprs__n_exprs(self);
1658 var = var1;
1659 RET_LABEL:;
1660 return var;
1661 }
1662 /* method parser_nodes#AExprs#init for (self: AExprs) */
1663 void parser_nodes__AExprs__init(val* self) {
1664 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AExprs>*/;
1665 RET_LABEL:;
1666 }
1667 /* method parser_nodes#AExprs#init for (self: Object) */
1668 void VIRTUAL_parser_nodes__AExprs__init(val* self) {
1669 parser_nodes__AExprs__init(self);
1670 RET_LABEL:;
1671 }
1672 /* method parser_nodes#ADebugTypeExpr#n_kwdebug for (self: ADebugTypeExpr): TKwdebug */
1673 val* parser_nodes__ADebugTypeExpr__n_kwdebug(val* self) {
1674 val* var /* : TKwdebug */;
1675 val* var1 /* : TKwdebug */;
1676 var1 = self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_kwdebug].val; /* _n_kwdebug on <self:ADebugTypeExpr> */
1677 if (var1 == NULL) {
1678 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwdebug");
1679 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1601);
1680 show_backtrace(1);
1681 }
1682 var = var1;
1683 RET_LABEL:;
1684 return var;
1685 }
1686 /* method parser_nodes#ADebugTypeExpr#n_kwdebug for (self: Object): TKwdebug */
1687 val* VIRTUAL_parser_nodes__ADebugTypeExpr__n_kwdebug(val* self) {
1688 val* var /* : TKwdebug */;
1689 val* var1 /* : TKwdebug */;
1690 var1 = parser_nodes__ADebugTypeExpr__n_kwdebug(self);
1691 var = var1;
1692 RET_LABEL:;
1693 return var;
1694 }
1695 /* method parser_nodes#ADebugTypeExpr#n_kwdebug= for (self: ADebugTypeExpr, TKwdebug) */
1696 void parser_nodes__ADebugTypeExpr__n_kwdebug_61d(val* self, val* p0) {
1697 self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_kwdebug].val = p0; /* _n_kwdebug on <self:ADebugTypeExpr> */
1698 RET_LABEL:;
1699 }
1700 /* method parser_nodes#ADebugTypeExpr#n_kwdebug= for (self: Object, TKwdebug) */
1701 void VIRTUAL_parser_nodes__ADebugTypeExpr__n_kwdebug_61d(val* self, val* p0) {
1702 parser_nodes__ADebugTypeExpr__n_kwdebug_61d(self, p0);
1703 RET_LABEL:;
1704 }
1705 /* method parser_nodes#ADebugTypeExpr#n_kwtype for (self: ADebugTypeExpr): TKwtype */
1706 val* parser_nodes__ADebugTypeExpr__n_kwtype(val* self) {
1707 val* var /* : TKwtype */;
1708 val* var1 /* : TKwtype */;
1709 var1 = self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_kwtype].val; /* _n_kwtype on <self:ADebugTypeExpr> */
1710 if (var1 == NULL) {
1711 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwtype");
1712 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1602);
1713 show_backtrace(1);
1714 }
1715 var = var1;
1716 RET_LABEL:;
1717 return var;
1718 }
1719 /* method parser_nodes#ADebugTypeExpr#n_kwtype for (self: Object): TKwtype */
1720 val* VIRTUAL_parser_nodes__ADebugTypeExpr__n_kwtype(val* self) {
1721 val* var /* : TKwtype */;
1722 val* var1 /* : TKwtype */;
1723 var1 = parser_nodes__ADebugTypeExpr__n_kwtype(self);
1724 var = var1;
1725 RET_LABEL:;
1726 return var;
1727 }
1728 /* method parser_nodes#ADebugTypeExpr#n_kwtype= for (self: ADebugTypeExpr, TKwtype) */
1729 void parser_nodes__ADebugTypeExpr__n_kwtype_61d(val* self, val* p0) {
1730 self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_kwtype].val = p0; /* _n_kwtype on <self:ADebugTypeExpr> */
1731 RET_LABEL:;
1732 }
1733 /* method parser_nodes#ADebugTypeExpr#n_kwtype= for (self: Object, TKwtype) */
1734 void VIRTUAL_parser_nodes__ADebugTypeExpr__n_kwtype_61d(val* self, val* p0) {
1735 parser_nodes__ADebugTypeExpr__n_kwtype_61d(self, p0);
1736 RET_LABEL:;
1737 }
1738 /* method parser_nodes#ADebugTypeExpr#n_expr for (self: ADebugTypeExpr): AExpr */
1739 val* parser_nodes__ADebugTypeExpr__n_expr(val* self) {
1740 val* var /* : AExpr */;
1741 val* var1 /* : AExpr */;
1742 var1 = self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_expr].val; /* _n_expr on <self:ADebugTypeExpr> */
1743 if (var1 == NULL) {
1744 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr");
1745 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1603);
1746 show_backtrace(1);
1747 }
1748 var = var1;
1749 RET_LABEL:;
1750 return var;
1751 }
1752 /* method parser_nodes#ADebugTypeExpr#n_expr for (self: Object): AExpr */
1753 val* VIRTUAL_parser_nodes__ADebugTypeExpr__n_expr(val* self) {
1754 val* var /* : AExpr */;
1755 val* var1 /* : AExpr */;
1756 var1 = parser_nodes__ADebugTypeExpr__n_expr(self);
1757 var = var1;
1758 RET_LABEL:;
1759 return var;
1760 }
1761 /* method parser_nodes#ADebugTypeExpr#n_expr= for (self: ADebugTypeExpr, AExpr) */
1762 void parser_nodes__ADebugTypeExpr__n_expr_61d(val* self, val* p0) {
1763 self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_expr].val = p0; /* _n_expr on <self:ADebugTypeExpr> */
1764 RET_LABEL:;
1765 }
1766 /* method parser_nodes#ADebugTypeExpr#n_expr= for (self: Object, AExpr) */
1767 void VIRTUAL_parser_nodes__ADebugTypeExpr__n_expr_61d(val* self, val* p0) {
1768 parser_nodes__ADebugTypeExpr__n_expr_61d(self, p0);
1769 RET_LABEL:;
1770 }
1771 /* method parser_nodes#ADebugTypeExpr#n_type for (self: ADebugTypeExpr): AType */
1772 val* parser_nodes__ADebugTypeExpr__n_type(val* self) {
1773 val* var /* : AType */;
1774 val* var1 /* : AType */;
1775 var1 = self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_type].val; /* _n_type on <self:ADebugTypeExpr> */
1776 if (var1 == NULL) {
1777 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_type");
1778 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1604);
1779 show_backtrace(1);
1780 }
1781 var = var1;
1782 RET_LABEL:;
1783 return var;
1784 }
1785 /* method parser_nodes#ADebugTypeExpr#n_type for (self: Object): AType */
1786 val* VIRTUAL_parser_nodes__ADebugTypeExpr__n_type(val* self) {
1787 val* var /* : AType */;
1788 val* var1 /* : AType */;
1789 var1 = parser_nodes__ADebugTypeExpr__n_type(self);
1790 var = var1;
1791 RET_LABEL:;
1792 return var;
1793 }
1794 /* method parser_nodes#ADebugTypeExpr#n_type= for (self: ADebugTypeExpr, AType) */
1795 void parser_nodes__ADebugTypeExpr__n_type_61d(val* self, val* p0) {
1796 self->attrs[COLOR_parser_nodes__ADebugTypeExpr___n_type].val = p0; /* _n_type on <self:ADebugTypeExpr> */
1797 RET_LABEL:;
1798 }
1799 /* method parser_nodes#ADebugTypeExpr#n_type= for (self: Object, AType) */
1800 void VIRTUAL_parser_nodes__ADebugTypeExpr__n_type_61d(val* self, val* p0) {
1801 parser_nodes__ADebugTypeExpr__n_type_61d(self, p0);
1802 RET_LABEL:;
1803 }
1804 /* method parser_nodes#ADebugTypeExpr#init for (self: ADebugTypeExpr) */
1805 void parser_nodes__ADebugTypeExpr__init(val* self) {
1806 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExpr__init]))(self) /* init on <self:ADebugTypeExpr>*/;
1807 RET_LABEL:;
1808 }
1809 /* method parser_nodes#ADebugTypeExpr#init for (self: Object) */
1810 void VIRTUAL_parser_nodes__ADebugTypeExpr__init(val* self) {
1811 parser_nodes__ADebugTypeExpr__init(self);
1812 RET_LABEL:;
1813 }
1814 /* method parser_nodes#AListExprs#init for (self: AListExprs) */
1815 void parser_nodes__AListExprs__init(val* self) {
1816 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExprs__init]))(self) /* init on <self:AListExprs>*/;
1817 RET_LABEL:;
1818 }
1819 /* method parser_nodes#AListExprs#init for (self: Object) */
1820 void VIRTUAL_parser_nodes__AListExprs__init(val* self) {
1821 parser_nodes__AListExprs__init(self);
1822 RET_LABEL:;
1823 }
1824 /* method parser_nodes#AParExprs#n_opar for (self: AParExprs): TOpar */
1825 val* parser_nodes__AParExprs__n_opar(val* self) {
1826 val* var /* : TOpar */;
1827 val* var1 /* : TOpar */;
1828 var1 = self->attrs[COLOR_parser_nodes__AParExprs___n_opar].val; /* _n_opar on <self:AParExprs> */
1829 if (var1 == NULL) {
1830 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_opar");
1831 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1615);
1832 show_backtrace(1);
1833 }
1834 var = var1;
1835 RET_LABEL:;
1836 return var;
1837 }
1838 /* method parser_nodes#AParExprs#n_opar for (self: Object): TOpar */
1839 val* VIRTUAL_parser_nodes__AParExprs__n_opar(val* self) {
1840 val* var /* : TOpar */;
1841 val* var1 /* : TOpar */;
1842 var1 = parser_nodes__AParExprs__n_opar(self);
1843 var = var1;
1844 RET_LABEL:;
1845 return var;
1846 }
1847 /* method parser_nodes#AParExprs#n_opar= for (self: AParExprs, TOpar) */
1848 void parser_nodes__AParExprs__n_opar_61d(val* self, val* p0) {
1849 self->attrs[COLOR_parser_nodes__AParExprs___n_opar].val = p0; /* _n_opar on <self:AParExprs> */
1850 RET_LABEL:;
1851 }
1852 /* method parser_nodes#AParExprs#n_opar= for (self: Object, TOpar) */
1853 void VIRTUAL_parser_nodes__AParExprs__n_opar_61d(val* self, val* p0) {
1854 parser_nodes__AParExprs__n_opar_61d(self, p0);
1855 RET_LABEL:;
1856 }
1857 /* method parser_nodes#AParExprs#n_cpar for (self: AParExprs): TCpar */
1858 val* parser_nodes__AParExprs__n_cpar(val* self) {
1859 val* var /* : TCpar */;
1860 val* var1 /* : TCpar */;
1861 var1 = self->attrs[COLOR_parser_nodes__AParExprs___n_cpar].val; /* _n_cpar on <self:AParExprs> */
1862 if (var1 == NULL) {
1863 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cpar");
1864 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1616);
1865 show_backtrace(1);
1866 }
1867 var = var1;
1868 RET_LABEL:;
1869 return var;
1870 }
1871 /* method parser_nodes#AParExprs#n_cpar for (self: Object): TCpar */
1872 val* VIRTUAL_parser_nodes__AParExprs__n_cpar(val* self) {
1873 val* var /* : TCpar */;
1874 val* var1 /* : TCpar */;
1875 var1 = parser_nodes__AParExprs__n_cpar(self);
1876 var = var1;
1877 RET_LABEL:;
1878 return var;
1879 }
1880 /* method parser_nodes#AParExprs#n_cpar= for (self: AParExprs, TCpar) */
1881 void parser_nodes__AParExprs__n_cpar_61d(val* self, val* p0) {
1882 self->attrs[COLOR_parser_nodes__AParExprs___n_cpar].val = p0; /* _n_cpar on <self:AParExprs> */
1883 RET_LABEL:;
1884 }
1885 /* method parser_nodes#AParExprs#n_cpar= for (self: Object, TCpar) */
1886 void VIRTUAL_parser_nodes__AParExprs__n_cpar_61d(val* self, val* p0) {
1887 parser_nodes__AParExprs__n_cpar_61d(self, p0);
1888 RET_LABEL:;
1889 }
1890 /* method parser_nodes#AParExprs#init for (self: AParExprs) */
1891 void parser_nodes__AParExprs__init(val* self) {
1892 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExprs__init]))(self) /* init on <self:AParExprs>*/;
1893 RET_LABEL:;
1894 }
1895 /* method parser_nodes#AParExprs#init for (self: Object) */
1896 void VIRTUAL_parser_nodes__AParExprs__init(val* self) {
1897 parser_nodes__AParExprs__init(self);
1898 RET_LABEL:;
1899 }
1900 /* method parser_nodes#ABraExprs#n_obra for (self: ABraExprs): TObra */
1901 val* parser_nodes__ABraExprs__n_obra(val* self) {
1902 val* var /* : TObra */;
1903 val* var1 /* : TObra */;
1904 var1 = self->attrs[COLOR_parser_nodes__ABraExprs___n_obra].val; /* _n_obra on <self:ABraExprs> */
1905 if (var1 == NULL) {
1906 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_obra");
1907 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1622);
1908 show_backtrace(1);
1909 }
1910 var = var1;
1911 RET_LABEL:;
1912 return var;
1913 }
1914 /* method parser_nodes#ABraExprs#n_obra for (self: Object): TObra */
1915 val* VIRTUAL_parser_nodes__ABraExprs__n_obra(val* self) {
1916 val* var /* : TObra */;
1917 val* var1 /* : TObra */;
1918 var1 = parser_nodes__ABraExprs__n_obra(self);
1919 var = var1;
1920 RET_LABEL:;
1921 return var;
1922 }
1923 /* method parser_nodes#ABraExprs#n_obra= for (self: ABraExprs, TObra) */
1924 void parser_nodes__ABraExprs__n_obra_61d(val* self, val* p0) {
1925 self->attrs[COLOR_parser_nodes__ABraExprs___n_obra].val = p0; /* _n_obra on <self:ABraExprs> */
1926 RET_LABEL:;
1927 }
1928 /* method parser_nodes#ABraExprs#n_obra= for (self: Object, TObra) */
1929 void VIRTUAL_parser_nodes__ABraExprs__n_obra_61d(val* self, val* p0) {
1930 parser_nodes__ABraExprs__n_obra_61d(self, p0);
1931 RET_LABEL:;
1932 }
1933 /* method parser_nodes#ABraExprs#n_cbra for (self: ABraExprs): TCbra */
1934 val* parser_nodes__ABraExprs__n_cbra(val* self) {
1935 val* var /* : TCbra */;
1936 val* var1 /* : TCbra */;
1937 var1 = self->attrs[COLOR_parser_nodes__ABraExprs___n_cbra].val; /* _n_cbra on <self:ABraExprs> */
1938 if (var1 == NULL) {
1939 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_cbra");
1940 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1623);
1941 show_backtrace(1);
1942 }
1943 var = var1;
1944 RET_LABEL:;
1945 return var;
1946 }
1947 /* method parser_nodes#ABraExprs#n_cbra for (self: Object): TCbra */
1948 val* VIRTUAL_parser_nodes__ABraExprs__n_cbra(val* self) {
1949 val* var /* : TCbra */;
1950 val* var1 /* : TCbra */;
1951 var1 = parser_nodes__ABraExprs__n_cbra(self);
1952 var = var1;
1953 RET_LABEL:;
1954 return var;
1955 }
1956 /* method parser_nodes#ABraExprs#n_cbra= for (self: ABraExprs, TCbra) */
1957 void parser_nodes__ABraExprs__n_cbra_61d(val* self, val* p0) {
1958 self->attrs[COLOR_parser_nodes__ABraExprs___n_cbra].val = p0; /* _n_cbra on <self:ABraExprs> */
1959 RET_LABEL:;
1960 }
1961 /* method parser_nodes#ABraExprs#n_cbra= for (self: Object, TCbra) */
1962 void VIRTUAL_parser_nodes__ABraExprs__n_cbra_61d(val* self, val* p0) {
1963 parser_nodes__ABraExprs__n_cbra_61d(self, p0);
1964 RET_LABEL:;
1965 }
1966 /* method parser_nodes#ABraExprs#init for (self: ABraExprs) */
1967 void parser_nodes__ABraExprs__init(val* self) {
1968 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AExprs__init]))(self) /* init on <self:ABraExprs>*/;
1969 RET_LABEL:;
1970 }
1971 /* method parser_nodes#ABraExprs#init for (self: Object) */
1972 void VIRTUAL_parser_nodes__ABraExprs__init(val* self) {
1973 parser_nodes__ABraExprs__init(self);
1974 RET_LABEL:;
1975 }
1976 /* method parser_nodes#AAssignOp#init for (self: AAssignOp) */
1977 void parser_nodes__AAssignOp__init(val* self) {
1978 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AAssignOp>*/;
1979 RET_LABEL:;
1980 }
1981 /* method parser_nodes#AAssignOp#init for (self: Object) */
1982 void VIRTUAL_parser_nodes__AAssignOp__init(val* self) {
1983 parser_nodes__AAssignOp__init(self);
1984 RET_LABEL:;
1985 }
1986 /* method parser_nodes#APlusAssignOp#n_pluseq for (self: APlusAssignOp): TPluseq */
1987 val* parser_nodes__APlusAssignOp__n_pluseq(val* self) {
1988 val* var /* : TPluseq */;
1989 val* var1 /* : TPluseq */;
1990 var1 = self->attrs[COLOR_parser_nodes__APlusAssignOp___n_pluseq].val; /* _n_pluseq on <self:APlusAssignOp> */
1991 if (var1 == NULL) {
1992 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_pluseq");
1993 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1632);
1994 show_backtrace(1);
1995 }
1996 var = var1;
1997 RET_LABEL:;
1998 return var;
1999 }
2000 /* method parser_nodes#APlusAssignOp#n_pluseq for (self: Object): TPluseq */
2001 val* VIRTUAL_parser_nodes__APlusAssignOp__n_pluseq(val* self) {
2002 val* var /* : TPluseq */;
2003 val* var1 /* : TPluseq */;
2004 var1 = parser_nodes__APlusAssignOp__n_pluseq(self);
2005 var = var1;
2006 RET_LABEL:;
2007 return var;
2008 }
2009 /* method parser_nodes#APlusAssignOp#n_pluseq= for (self: APlusAssignOp, TPluseq) */
2010 void parser_nodes__APlusAssignOp__n_pluseq_61d(val* self, val* p0) {
2011 self->attrs[COLOR_parser_nodes__APlusAssignOp___n_pluseq].val = p0; /* _n_pluseq on <self:APlusAssignOp> */
2012 RET_LABEL:;
2013 }
2014 /* method parser_nodes#APlusAssignOp#n_pluseq= for (self: Object, TPluseq) */
2015 void VIRTUAL_parser_nodes__APlusAssignOp__n_pluseq_61d(val* self, val* p0) {
2016 parser_nodes__APlusAssignOp__n_pluseq_61d(self, p0);
2017 RET_LABEL:;
2018 }
2019 /* method parser_nodes#APlusAssignOp#init for (self: APlusAssignOp) */
2020 void parser_nodes__APlusAssignOp__init(val* self) {
2021 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignOp__init]))(self) /* init on <self:APlusAssignOp>*/;
2022 RET_LABEL:;
2023 }
2024 /* method parser_nodes#APlusAssignOp#init for (self: Object) */
2025 void VIRTUAL_parser_nodes__APlusAssignOp__init(val* self) {
2026 parser_nodes__APlusAssignOp__init(self);
2027 RET_LABEL:;
2028 }
2029 /* method parser_nodes#AMinusAssignOp#n_minuseq for (self: AMinusAssignOp): TMinuseq */
2030 val* parser_nodes__AMinusAssignOp__n_minuseq(val* self) {
2031 val* var /* : TMinuseq */;
2032 val* var1 /* : TMinuseq */;
2033 var1 = self->attrs[COLOR_parser_nodes__AMinusAssignOp___n_minuseq].val; /* _n_minuseq on <self:AMinusAssignOp> */
2034 if (var1 == NULL) {
2035 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_minuseq");
2036 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1636);
2037 show_backtrace(1);
2038 }
2039 var = var1;
2040 RET_LABEL:;
2041 return var;
2042 }
2043 /* method parser_nodes#AMinusAssignOp#n_minuseq for (self: Object): TMinuseq */
2044 val* VIRTUAL_parser_nodes__AMinusAssignOp__n_minuseq(val* self) {
2045 val* var /* : TMinuseq */;
2046 val* var1 /* : TMinuseq */;
2047 var1 = parser_nodes__AMinusAssignOp__n_minuseq(self);
2048 var = var1;
2049 RET_LABEL:;
2050 return var;
2051 }
2052 /* method parser_nodes#AMinusAssignOp#n_minuseq= for (self: AMinusAssignOp, TMinuseq) */
2053 void parser_nodes__AMinusAssignOp__n_minuseq_61d(val* self, val* p0) {
2054 self->attrs[COLOR_parser_nodes__AMinusAssignOp___n_minuseq].val = p0; /* _n_minuseq on <self:AMinusAssignOp> */
2055 RET_LABEL:;
2056 }
2057 /* method parser_nodes#AMinusAssignOp#n_minuseq= for (self: Object, TMinuseq) */
2058 void VIRTUAL_parser_nodes__AMinusAssignOp__n_minuseq_61d(val* self, val* p0) {
2059 parser_nodes__AMinusAssignOp__n_minuseq_61d(self, p0);
2060 RET_LABEL:;
2061 }
2062 /* method parser_nodes#AMinusAssignOp#init for (self: AMinusAssignOp) */
2063 void parser_nodes__AMinusAssignOp__init(val* self) {
2064 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAssignOp__init]))(self) /* init on <self:AMinusAssignOp>*/;
2065 RET_LABEL:;
2066 }
2067 /* method parser_nodes#AMinusAssignOp#init for (self: Object) */
2068 void VIRTUAL_parser_nodes__AMinusAssignOp__init(val* self) {
2069 parser_nodes__AMinusAssignOp__init(self);
2070 RET_LABEL:;
2071 }
2072 /* method parser_nodes#AModuleName#n_quad for (self: AModuleName): nullable TQuad */
2073 val* parser_nodes__AModuleName__n_quad(val* self) {
2074 val* var /* : nullable TQuad */;
2075 val* var1 /* : nullable TQuad */;
2076 var1 = self->attrs[COLOR_parser_nodes__AModuleName___n_quad].val; /* _n_quad on <self:AModuleName> */
2077 var = var1;
2078 RET_LABEL:;
2079 return var;
2080 }
2081 /* method parser_nodes#AModuleName#n_quad for (self: Object): nullable TQuad */
2082 val* VIRTUAL_parser_nodes__AModuleName__n_quad(val* self) {
2083 val* var /* : nullable TQuad */;
2084 val* var1 /* : nullable TQuad */;
2085 var1 = parser_nodes__AModuleName__n_quad(self);
2086 var = var1;
2087 RET_LABEL:;
2088 return var;
2089 }
2090 /* method parser_nodes#AModuleName#n_quad= for (self: AModuleName, nullable TQuad) */
2091 void parser_nodes__AModuleName__n_quad_61d(val* self, val* p0) {
2092 self->attrs[COLOR_parser_nodes__AModuleName___n_quad].val = p0; /* _n_quad on <self:AModuleName> */
2093 RET_LABEL:;
2094 }
2095 /* method parser_nodes#AModuleName#n_quad= for (self: Object, nullable TQuad) */
2096 void VIRTUAL_parser_nodes__AModuleName__n_quad_61d(val* self, val* p0) {
2097 parser_nodes__AModuleName__n_quad_61d(self, p0);
2098 RET_LABEL:;
2099 }
2100 /* method parser_nodes#AModuleName#n_path for (self: AModuleName): ANodes[TId] */
2101 val* parser_nodes__AModuleName__n_path(val* self) {
2102 val* var /* : ANodes[TId] */;
2103 val* var1 /* : ANodes[TId] */;
2104 var1 = self->attrs[COLOR_parser_nodes__AModuleName___n_path].val; /* _n_path on <self:AModuleName> */
2105 if (var1 == NULL) {
2106 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_path");
2107 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1642);
2108 show_backtrace(1);
2109 }
2110 var = var1;
2111 RET_LABEL:;
2112 return var;
2113 }
2114 /* method parser_nodes#AModuleName#n_path for (self: Object): ANodes[TId] */
2115 val* VIRTUAL_parser_nodes__AModuleName__n_path(val* self) {
2116 val* var /* : ANodes[TId] */;
2117 val* var1 /* : ANodes[TId] */;
2118 var1 = parser_nodes__AModuleName__n_path(self);
2119 var = var1;
2120 RET_LABEL:;
2121 return var;
2122 }
2123 /* method parser_nodes#AModuleName#n_id for (self: AModuleName): TId */
2124 val* parser_nodes__AModuleName__n_id(val* self) {
2125 val* var /* : TId */;
2126 val* var1 /* : TId */;
2127 var1 = self->attrs[COLOR_parser_nodes__AModuleName___n_id].val; /* _n_id on <self:AModuleName> */
2128 if (var1 == NULL) {
2129 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_id");
2130 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1643);
2131 show_backtrace(1);
2132 }
2133 var = var1;
2134 RET_LABEL:;
2135 return var;
2136 }
2137 /* method parser_nodes#AModuleName#n_id for (self: Object): TId */
2138 val* VIRTUAL_parser_nodes__AModuleName__n_id(val* self) {
2139 val* var /* : TId */;
2140 val* var1 /* : TId */;
2141 var1 = parser_nodes__AModuleName__n_id(self);
2142 var = var1;
2143 RET_LABEL:;
2144 return var;
2145 }
2146 /* method parser_nodes#AModuleName#n_id= for (self: AModuleName, TId) */
2147 void parser_nodes__AModuleName__n_id_61d(val* self, val* p0) {
2148 self->attrs[COLOR_parser_nodes__AModuleName___n_id].val = p0; /* _n_id on <self:AModuleName> */
2149 RET_LABEL:;
2150 }
2151 /* method parser_nodes#AModuleName#n_id= for (self: Object, TId) */
2152 void VIRTUAL_parser_nodes__AModuleName__n_id_61d(val* self, val* p0) {
2153 parser_nodes__AModuleName__n_id_61d(self, p0);
2154 RET_LABEL:;
2155 }
2156 /* method parser_nodes#AModuleName#init for (self: AModuleName) */
2157 void parser_nodes__AModuleName__init(val* self) {
2158 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AModuleName>*/;
2159 RET_LABEL:;
2160 }
2161 /* method parser_nodes#AModuleName#init for (self: Object) */
2162 void VIRTUAL_parser_nodes__AModuleName__init(val* self) {
2163 parser_nodes__AModuleName__init(self);
2164 RET_LABEL:;
2165 }
2166 /* method parser_nodes#AInLanguage#n_kwin for (self: AInLanguage): TKwin */
2167 val* parser_nodes__AInLanguage__n_kwin(val* self) {
2168 val* var /* : TKwin */;
2169 val* var1 /* : TKwin */;
2170 var1 = self->attrs[COLOR_parser_nodes__AInLanguage___n_kwin].val; /* _n_kwin on <self:AInLanguage> */
2171 if (var1 == NULL) {
2172 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_kwin");
2173 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1647);
2174 show_backtrace(1);
2175 }
2176 var = var1;
2177 RET_LABEL:;
2178 return var;
2179 }
2180 /* method parser_nodes#AInLanguage#n_kwin for (self: Object): TKwin */
2181 val* VIRTUAL_parser_nodes__AInLanguage__n_kwin(val* self) {
2182 val* var /* : TKwin */;
2183 val* var1 /* : TKwin */;
2184 var1 = parser_nodes__AInLanguage__n_kwin(self);
2185 var = var1;
2186 RET_LABEL:;
2187 return var;
2188 }
2189 /* method parser_nodes#AInLanguage#n_kwin= for (self: AInLanguage, TKwin) */
2190 void parser_nodes__AInLanguage__n_kwin_61d(val* self, val* p0) {
2191 self->attrs[COLOR_parser_nodes__AInLanguage___n_kwin].val = p0; /* _n_kwin on <self:AInLanguage> */
2192 RET_LABEL:;
2193 }
2194 /* method parser_nodes#AInLanguage#n_kwin= for (self: Object, TKwin) */
2195 void VIRTUAL_parser_nodes__AInLanguage__n_kwin_61d(val* self, val* p0) {
2196 parser_nodes__AInLanguage__n_kwin_61d(self, p0);
2197 RET_LABEL:;
2198 }
2199 /* method parser_nodes#AInLanguage#n_string for (self: AInLanguage): TString */
2200 val* parser_nodes__AInLanguage__n_string(val* self) {
2201 val* var /* : TString */;
2202 val* var1 /* : TString */;
2203 var1 = self->attrs[COLOR_parser_nodes__AInLanguage___n_string].val; /* _n_string on <self:AInLanguage> */
2204 if (var1 == NULL) {
2205 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_string");
2206 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1648);
2207 show_backtrace(1);
2208 }
2209 var = var1;
2210 RET_LABEL:;
2211 return var;
2212 }
2213 /* method parser_nodes#AInLanguage#n_string for (self: Object): TString */
2214 val* VIRTUAL_parser_nodes__AInLanguage__n_string(val* self) {
2215 val* var /* : TString */;
2216 val* var1 /* : TString */;
2217 var1 = parser_nodes__AInLanguage__n_string(self);
2218 var = var1;
2219 RET_LABEL:;
2220 return var;
2221 }
2222 /* method parser_nodes#AInLanguage#n_string= for (self: AInLanguage, TString) */
2223 void parser_nodes__AInLanguage__n_string_61d(val* self, val* p0) {
2224 self->attrs[COLOR_parser_nodes__AInLanguage___n_string].val = p0; /* _n_string on <self:AInLanguage> */
2225 RET_LABEL:;
2226 }
2227 /* method parser_nodes#AInLanguage#n_string= for (self: Object, TString) */
2228 void VIRTUAL_parser_nodes__AInLanguage__n_string_61d(val* self, val* p0) {
2229 parser_nodes__AInLanguage__n_string_61d(self, p0);
2230 RET_LABEL:;
2231 }
2232 /* method parser_nodes#AInLanguage#init for (self: AInLanguage) */
2233 void parser_nodes__AInLanguage__init(val* self) {
2234 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AInLanguage>*/;
2235 RET_LABEL:;
2236 }
2237 /* method parser_nodes#AInLanguage#init for (self: Object) */
2238 void VIRTUAL_parser_nodes__AInLanguage__init(val* self) {
2239 parser_nodes__AInLanguage__init(self);
2240 RET_LABEL:;
2241 }
2242 /* method parser_nodes#AExternCodeBlock#n_in_language for (self: AExternCodeBlock): nullable AInLanguage */
2243 val* parser_nodes__AExternCodeBlock__n_in_language(val* self) {
2244 val* var /* : nullable AInLanguage */;
2245 val* var1 /* : nullable AInLanguage */;
2246 var1 = self->attrs[COLOR_parser_nodes__AExternCodeBlock___n_in_language].val; /* _n_in_language on <self:AExternCodeBlock> */
2247 var = var1;
2248 RET_LABEL:;
2249 return var;
2250 }
2251 /* method parser_nodes#AExternCodeBlock#n_in_language for (self: Object): nullable AInLanguage */
2252 val* VIRTUAL_parser_nodes__AExternCodeBlock__n_in_language(val* self) {
2253 val* var /* : nullable AInLanguage */;
2254 val* var1 /* : nullable AInLanguage */;
2255 var1 = parser_nodes__AExternCodeBlock__n_in_language(self);
2256 var = var1;
2257 RET_LABEL:;
2258 return var;
2259 }
2260 /* method parser_nodes#AExternCodeBlock#n_in_language= for (self: AExternCodeBlock, nullable AInLanguage) */
2261 void parser_nodes__AExternCodeBlock__n_in_language_61d(val* self, val* p0) {
2262 self->attrs[COLOR_parser_nodes__AExternCodeBlock___n_in_language].val = p0; /* _n_in_language on <self:AExternCodeBlock> */
2263 RET_LABEL:;
2264 }
2265 /* method parser_nodes#AExternCodeBlock#n_in_language= for (self: Object, nullable AInLanguage) */
2266 void VIRTUAL_parser_nodes__AExternCodeBlock__n_in_language_61d(val* self, val* p0) {
2267 parser_nodes__AExternCodeBlock__n_in_language_61d(self, p0);
2268 RET_LABEL:;
2269 }
2270 /* method parser_nodes#AExternCodeBlock#n_extern_code_segment for (self: AExternCodeBlock): TExternCodeSegment */
2271 val* parser_nodes__AExternCodeBlock__n_extern_code_segment(val* self) {
2272 val* var /* : TExternCodeSegment */;
2273 val* var1 /* : TExternCodeSegment */;
2274 var1 = self->attrs[COLOR_parser_nodes__AExternCodeBlock___n_extern_code_segment].val; /* _n_extern_code_segment on <self:AExternCodeBlock> */
2275 if (var1 == NULL) {
2276 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_extern_code_segment");
2277 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1653);
2278 show_backtrace(1);
2279 }
2280 var = var1;
2281 RET_LABEL:;
2282 return var;
2283 }
2284 /* method parser_nodes#AExternCodeBlock#n_extern_code_segment for (self: Object): TExternCodeSegment */
2285 val* VIRTUAL_parser_nodes__AExternCodeBlock__n_extern_code_segment(val* self) {
2286 val* var /* : TExternCodeSegment */;
2287 val* var1 /* : TExternCodeSegment */;
2288 var1 = parser_nodes__AExternCodeBlock__n_extern_code_segment(self);
2289 var = var1;
2290 RET_LABEL:;
2291 return var;
2292 }
2293 /* method parser_nodes#AExternCodeBlock#n_extern_code_segment= for (self: AExternCodeBlock, TExternCodeSegment) */
2294 void parser_nodes__AExternCodeBlock__n_extern_code_segment_61d(val* self, val* p0) {
2295 self->attrs[COLOR_parser_nodes__AExternCodeBlock___n_extern_code_segment].val = p0; /* _n_extern_code_segment on <self:AExternCodeBlock> */
2296 RET_LABEL:;
2297 }
2298 /* method parser_nodes#AExternCodeBlock#n_extern_code_segment= for (self: Object, TExternCodeSegment) */
2299 void VIRTUAL_parser_nodes__AExternCodeBlock__n_extern_code_segment_61d(val* self, val* p0) {
2300 parser_nodes__AExternCodeBlock__n_extern_code_segment_61d(self, p0);
2301 RET_LABEL:;
2302 }
2303 /* method parser_nodes#AExternCodeBlock#init for (self: AExternCodeBlock) */
2304 void parser_nodes__AExternCodeBlock__init(val* self) {
2305 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AExternCodeBlock>*/;
2306 RET_LABEL:;
2307 }
2308 /* method parser_nodes#AExternCodeBlock#init for (self: Object) */
2309 void VIRTUAL_parser_nodes__AExternCodeBlock__init(val* self) {
2310 parser_nodes__AExternCodeBlock__init(self);
2311 RET_LABEL:;
2312 }
2313 /* method parser_nodes#AQualified#n_quad for (self: AQualified): nullable TQuad */
2314 val* parser_nodes__AQualified__n_quad(val* self) {
2315 val* var /* : nullable TQuad */;
2316 val* var1 /* : nullable TQuad */;
2317 var1 = self->attrs[COLOR_parser_nodes__AQualified___n_quad].val; /* _n_quad on <self:AQualified> */
2318 var = var1;
2319 RET_LABEL:;
2320 return var;
2321 }
2322 /* method parser_nodes#AQualified#n_quad for (self: Object): nullable TQuad */
2323 val* VIRTUAL_parser_nodes__AQualified__n_quad(val* self) {
2324 val* var /* : nullable TQuad */;
2325 val* var1 /* : nullable TQuad */;
2326 var1 = parser_nodes__AQualified__n_quad(self);
2327 var = var1;
2328 RET_LABEL:;
2329 return var;
2330 }
2331 /* method parser_nodes#AQualified#n_quad= for (self: AQualified, nullable TQuad) */
2332 void parser_nodes__AQualified__n_quad_61d(val* self, val* p0) {
2333 self->attrs[COLOR_parser_nodes__AQualified___n_quad].val = p0; /* _n_quad on <self:AQualified> */
2334 RET_LABEL:;
2335 }
2336 /* method parser_nodes#AQualified#n_quad= for (self: Object, nullable TQuad) */
2337 void VIRTUAL_parser_nodes__AQualified__n_quad_61d(val* self, val* p0) {
2338 parser_nodes__AQualified__n_quad_61d(self, p0);
2339 RET_LABEL:;
2340 }
2341 /* method parser_nodes#AQualified#n_id for (self: AQualified): ANodes[TId] */
2342 val* parser_nodes__AQualified__n_id(val* self) {
2343 val* var /* : ANodes[TId] */;
2344 val* var1 /* : ANodes[TId] */;
2345 var1 = self->attrs[COLOR_parser_nodes__AQualified___n_id].val; /* _n_id on <self:AQualified> */
2346 if (var1 == NULL) {
2347 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_id");
2348 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1658);
2349 show_backtrace(1);
2350 }
2351 var = var1;
2352 RET_LABEL:;
2353 return var;
2354 }
2355 /* method parser_nodes#AQualified#n_id for (self: Object): ANodes[TId] */
2356 val* VIRTUAL_parser_nodes__AQualified__n_id(val* self) {
2357 val* var /* : ANodes[TId] */;
2358 val* var1 /* : ANodes[TId] */;
2359 var1 = parser_nodes__AQualified__n_id(self);
2360 var = var1;
2361 RET_LABEL:;
2362 return var;
2363 }
2364 /* method parser_nodes#AQualified#n_classid for (self: AQualified): nullable TClassid */
2365 val* parser_nodes__AQualified__n_classid(val* self) {
2366 val* var /* : nullable TClassid */;
2367 val* var1 /* : nullable TClassid */;
2368 var1 = self->attrs[COLOR_parser_nodes__AQualified___n_classid].val; /* _n_classid on <self:AQualified> */
2369 var = var1;
2370 RET_LABEL:;
2371 return var;
2372 }
2373 /* method parser_nodes#AQualified#n_classid for (self: Object): nullable TClassid */
2374 val* VIRTUAL_parser_nodes__AQualified__n_classid(val* self) {
2375 val* var /* : nullable TClassid */;
2376 val* var1 /* : nullable TClassid */;
2377 var1 = parser_nodes__AQualified__n_classid(self);
2378 var = var1;
2379 RET_LABEL:;
2380 return var;
2381 }
2382 /* method parser_nodes#AQualified#n_classid= for (self: AQualified, nullable TClassid) */
2383 void parser_nodes__AQualified__n_classid_61d(val* self, val* p0) {
2384 self->attrs[COLOR_parser_nodes__AQualified___n_classid].val = p0; /* _n_classid on <self:AQualified> */
2385 RET_LABEL:;
2386 }
2387 /* method parser_nodes#AQualified#n_classid= for (self: Object, nullable TClassid) */
2388 void VIRTUAL_parser_nodes__AQualified__n_classid_61d(val* self, val* p0) {
2389 parser_nodes__AQualified__n_classid_61d(self, p0);
2390 RET_LABEL:;
2391 }
2392 /* method parser_nodes#AQualified#init for (self: AQualified) */
2393 void parser_nodes__AQualified__init(val* self) {
2394 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AQualified>*/;
2395 RET_LABEL:;
2396 }
2397 /* method parser_nodes#AQualified#init for (self: Object) */
2398 void VIRTUAL_parser_nodes__AQualified__init(val* self) {
2399 parser_nodes__AQualified__init(self);
2400 RET_LABEL:;
2401 }
2402 /* method parser_nodes#ADoc#n_comment for (self: ADoc): ANodes[TComment] */
2403 val* parser_nodes__ADoc__n_comment(val* self) {
2404 val* var /* : ANodes[TComment] */;
2405 val* var1 /* : ANodes[TComment] */;
2406 var1 = self->attrs[COLOR_parser_nodes__ADoc___n_comment].val; /* _n_comment on <self:ADoc> */
2407 if (var1 == NULL) {
2408 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_comment");
2409 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1666);
2410 show_backtrace(1);
2411 }
2412 var = var1;
2413 RET_LABEL:;
2414 return var;
2415 }
2416 /* method parser_nodes#ADoc#n_comment for (self: Object): ANodes[TComment] */
2417 val* VIRTUAL_parser_nodes__ADoc__n_comment(val* self) {
2418 val* var /* : ANodes[TComment] */;
2419 val* var1 /* : ANodes[TComment] */;
2420 var1 = parser_nodes__ADoc__n_comment(self);
2421 var = var1;
2422 RET_LABEL:;
2423 return var;
2424 }
2425 /* method parser_nodes#ADoc#init for (self: ADoc) */
2426 void parser_nodes__ADoc__init(val* self) {
2427 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:ADoc>*/;
2428 RET_LABEL:;
2429 }
2430 /* method parser_nodes#ADoc#init for (self: Object) */
2431 void VIRTUAL_parser_nodes__ADoc__init(val* self) {
2432 parser_nodes__ADoc__init(self);
2433 RET_LABEL:;
2434 }
2435 /* method parser_nodes#AAnnotations#n_at for (self: AAnnotations): nullable TAt */
2436 val* parser_nodes__AAnnotations__n_at(val* self) {
2437 val* var /* : nullable TAt */;
2438 val* var1 /* : nullable TAt */;
2439 var1 = self->attrs[COLOR_parser_nodes__AAnnotations___n_at].val; /* _n_at on <self:AAnnotations> */
2440 var = var1;
2441 RET_LABEL:;
2442 return var;
2443 }
2444 /* method parser_nodes#AAnnotations#n_at for (self: Object): nullable TAt */
2445 val* VIRTUAL_parser_nodes__AAnnotations__n_at(val* self) {
2446 val* var /* : nullable TAt */;
2447 val* var1 /* : nullable TAt */;
2448 var1 = parser_nodes__AAnnotations__n_at(self);
2449 var = var1;
2450 RET_LABEL:;
2451 return var;
2452 }
2453 /* method parser_nodes#AAnnotations#n_at= for (self: AAnnotations, nullable TAt) */
2454 void parser_nodes__AAnnotations__n_at_61d(val* self, val* p0) {
2455 self->attrs[COLOR_parser_nodes__AAnnotations___n_at].val = p0; /* _n_at on <self:AAnnotations> */
2456 RET_LABEL:;
2457 }
2458 /* method parser_nodes#AAnnotations#n_at= for (self: Object, nullable TAt) */
2459 void VIRTUAL_parser_nodes__AAnnotations__n_at_61d(val* self, val* p0) {
2460 parser_nodes__AAnnotations__n_at_61d(self, p0);
2461 RET_LABEL:;
2462 }
2463 /* method parser_nodes#AAnnotations#n_opar for (self: AAnnotations): nullable TOpar */
2464 val* parser_nodes__AAnnotations__n_opar(val* self) {
2465 val* var /* : nullable TOpar */;
2466 val* var1 /* : nullable TOpar */;
2467 var1 = self->attrs[COLOR_parser_nodes__AAnnotations___n_opar].val; /* _n_opar on <self:AAnnotations> */
2468 var = var1;
2469 RET_LABEL:;
2470 return var;
2471 }
2472 /* method parser_nodes#AAnnotations#n_opar for (self: Object): nullable TOpar */
2473 val* VIRTUAL_parser_nodes__AAnnotations__n_opar(val* self) {
2474 val* var /* : nullable TOpar */;
2475 val* var1 /* : nullable TOpar */;
2476 var1 = parser_nodes__AAnnotations__n_opar(self);
2477 var = var1;
2478 RET_LABEL:;
2479 return var;
2480 }
2481 /* method parser_nodes#AAnnotations#n_opar= for (self: AAnnotations, nullable TOpar) */
2482 void parser_nodes__AAnnotations__n_opar_61d(val* self, val* p0) {
2483 self->attrs[COLOR_parser_nodes__AAnnotations___n_opar].val = p0; /* _n_opar on <self:AAnnotations> */
2484 RET_LABEL:;
2485 }
2486 /* method parser_nodes#AAnnotations#n_opar= for (self: Object, nullable TOpar) */
2487 void VIRTUAL_parser_nodes__AAnnotations__n_opar_61d(val* self, val* p0) {
2488 parser_nodes__AAnnotations__n_opar_61d(self, p0);
2489 RET_LABEL:;
2490 }
2491 /* method parser_nodes#AAnnotations#n_items for (self: AAnnotations): ANodes[AAnnotation] */
2492 val* parser_nodes__AAnnotations__n_items(val* self) {
2493 val* var /* : ANodes[AAnnotation] */;
2494 val* var1 /* : ANodes[AAnnotation] */;
2495 var1 = self->attrs[COLOR_parser_nodes__AAnnotations___n_items].val; /* _n_items on <self:AAnnotations> */
2496 if (var1 == NULL) {
2497 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_items");
2498 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1673);
2499 show_backtrace(1);
2500 }
2501 var = var1;
2502 RET_LABEL:;
2503 return var;
2504 }
2505 /* method parser_nodes#AAnnotations#n_items for (self: Object): ANodes[AAnnotation] */
2506 val* VIRTUAL_parser_nodes__AAnnotations__n_items(val* self) {
2507 val* var /* : ANodes[AAnnotation] */;
2508 val* var1 /* : ANodes[AAnnotation] */;
2509 var1 = parser_nodes__AAnnotations__n_items(self);
2510 var = var1;
2511 RET_LABEL:;
2512 return var;
2513 }
2514 /* method parser_nodes#AAnnotations#n_cpar for (self: AAnnotations): nullable TCpar */
2515 val* parser_nodes__AAnnotations__n_cpar(val* self) {
2516 val* var /* : nullable TCpar */;
2517 val* var1 /* : nullable TCpar */;
2518 var1 = self->attrs[COLOR_parser_nodes__AAnnotations___n_cpar].val; /* _n_cpar on <self:AAnnotations> */
2519 var = var1;
2520 RET_LABEL:;
2521 return var;
2522 }
2523 /* method parser_nodes#AAnnotations#n_cpar for (self: Object): nullable TCpar */
2524 val* VIRTUAL_parser_nodes__AAnnotations__n_cpar(val* self) {
2525 val* var /* : nullable TCpar */;
2526 val* var1 /* : nullable TCpar */;
2527 var1 = parser_nodes__AAnnotations__n_cpar(self);
2528 var = var1;
2529 RET_LABEL:;
2530 return var;
2531 }
2532 /* method parser_nodes#AAnnotations#n_cpar= for (self: AAnnotations, nullable TCpar) */
2533 void parser_nodes__AAnnotations__n_cpar_61d(val* self, val* p0) {
2534 self->attrs[COLOR_parser_nodes__AAnnotations___n_cpar].val = p0; /* _n_cpar on <self:AAnnotations> */
2535 RET_LABEL:;
2536 }
2537 /* method parser_nodes#AAnnotations#n_cpar= for (self: Object, nullable TCpar) */
2538 void VIRTUAL_parser_nodes__AAnnotations__n_cpar_61d(val* self, val* p0) {
2539 parser_nodes__AAnnotations__n_cpar_61d(self, p0);
2540 RET_LABEL:;
2541 }
2542 /* method parser_nodes#AAnnotations#init for (self: AAnnotations) */
2543 void parser_nodes__AAnnotations__init(val* self) {
2544 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AAnnotations>*/;
2545 RET_LABEL:;
2546 }
2547 /* method parser_nodes#AAnnotations#init for (self: Object) */
2548 void VIRTUAL_parser_nodes__AAnnotations__init(val* self) {
2549 parser_nodes__AAnnotations__init(self);
2550 RET_LABEL:;
2551 }
2552 /* method parser_nodes#AAnnotation#n_atid for (self: AAnnotation): AAtid */
2553 val* parser_nodes__AAnnotation__n_atid(val* self) {
2554 val* var /* : AAtid */;
2555 val* var1 /* : AAtid */;
2556 var1 = self->attrs[COLOR_parser_nodes__AAnnotation___n_atid].val; /* _n_atid on <self:AAnnotation> */
2557 if (var1 == NULL) {
2558 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_atid");
2559 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1678);
2560 show_backtrace(1);
2561 }
2562 var = var1;
2563 RET_LABEL:;
2564 return var;
2565 }
2566 /* method parser_nodes#AAnnotation#n_atid for (self: Object): AAtid */
2567 val* VIRTUAL_parser_nodes__AAnnotation__n_atid(val* self) {
2568 val* var /* : AAtid */;
2569 val* var1 /* : AAtid */;
2570 var1 = parser_nodes__AAnnotation__n_atid(self);
2571 var = var1;
2572 RET_LABEL:;
2573 return var;
2574 }
2575 /* method parser_nodes#AAnnotation#n_atid= for (self: AAnnotation, AAtid) */
2576 void parser_nodes__AAnnotation__n_atid_61d(val* self, val* p0) {
2577 self->attrs[COLOR_parser_nodes__AAnnotation___n_atid].val = p0; /* _n_atid on <self:AAnnotation> */
2578 RET_LABEL:;
2579 }
2580 /* method parser_nodes#AAnnotation#n_atid= for (self: Object, AAtid) */
2581 void VIRTUAL_parser_nodes__AAnnotation__n_atid_61d(val* self, val* p0) {
2582 parser_nodes__AAnnotation__n_atid_61d(self, p0);
2583 RET_LABEL:;
2584 }
2585 /* method parser_nodes#AAnnotation#n_opar for (self: AAnnotation): nullable TOpar */
2586 val* parser_nodes__AAnnotation__n_opar(val* self) {
2587 val* var /* : nullable TOpar */;
2588 val* var1 /* : nullable TOpar */;
2589 var1 = self->attrs[COLOR_parser_nodes__AAnnotation___n_opar].val; /* _n_opar on <self:AAnnotation> */
2590 var = var1;
2591 RET_LABEL:;
2592 return var;
2593 }
2594 /* method parser_nodes#AAnnotation#n_opar for (self: Object): nullable TOpar */
2595 val* VIRTUAL_parser_nodes__AAnnotation__n_opar(val* self) {
2596 val* var /* : nullable TOpar */;
2597 val* var1 /* : nullable TOpar */;
2598 var1 = parser_nodes__AAnnotation__n_opar(self);
2599 var = var1;
2600 RET_LABEL:;
2601 return var;
2602 }
2603 /* method parser_nodes#AAnnotation#n_opar= for (self: AAnnotation, nullable TOpar) */
2604 void parser_nodes__AAnnotation__n_opar_61d(val* self, val* p0) {
2605 self->attrs[COLOR_parser_nodes__AAnnotation___n_opar].val = p0; /* _n_opar on <self:AAnnotation> */
2606 RET_LABEL:;
2607 }
2608 /* method parser_nodes#AAnnotation#n_opar= for (self: Object, nullable TOpar) */
2609 void VIRTUAL_parser_nodes__AAnnotation__n_opar_61d(val* self, val* p0) {
2610 parser_nodes__AAnnotation__n_opar_61d(self, p0);
2611 RET_LABEL:;
2612 }
2613 /* method parser_nodes#AAnnotation#n_args for (self: AAnnotation): ANodes[AAtArg] */
2614 val* parser_nodes__AAnnotation__n_args(val* self) {
2615 val* var /* : ANodes[AAtArg] */;
2616 val* var1 /* : ANodes[AAtArg] */;
2617 var1 = self->attrs[COLOR_parser_nodes__AAnnotation___n_args].val; /* _n_args on <self:AAnnotation> */
2618 if (var1 == NULL) {
2619 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_args");
2620 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1680);
2621 show_backtrace(1);
2622 }
2623 var = var1;
2624 RET_LABEL:;
2625 return var;
2626 }
2627 /* method parser_nodes#AAnnotation#n_args for (self: Object): ANodes[AAtArg] */
2628 val* VIRTUAL_parser_nodes__AAnnotation__n_args(val* self) {
2629 val* var /* : ANodes[AAtArg] */;
2630 val* var1 /* : ANodes[AAtArg] */;
2631 var1 = parser_nodes__AAnnotation__n_args(self);
2632 var = var1;
2633 RET_LABEL:;
2634 return var;
2635 }
2636 /* method parser_nodes#AAnnotation#n_cpar for (self: AAnnotation): nullable TCpar */
2637 val* parser_nodes__AAnnotation__n_cpar(val* self) {
2638 val* var /* : nullable TCpar */;
2639 val* var1 /* : nullable TCpar */;
2640 var1 = self->attrs[COLOR_parser_nodes__AAnnotation___n_cpar].val; /* _n_cpar on <self:AAnnotation> */
2641 var = var1;
2642 RET_LABEL:;
2643 return var;
2644 }
2645 /* method parser_nodes#AAnnotation#n_cpar for (self: Object): nullable TCpar */
2646 val* VIRTUAL_parser_nodes__AAnnotation__n_cpar(val* self) {
2647 val* var /* : nullable TCpar */;
2648 val* var1 /* : nullable TCpar */;
2649 var1 = parser_nodes__AAnnotation__n_cpar(self);
2650 var = var1;
2651 RET_LABEL:;
2652 return var;
2653 }
2654 /* method parser_nodes#AAnnotation#n_cpar= for (self: AAnnotation, nullable TCpar) */
2655 void parser_nodes__AAnnotation__n_cpar_61d(val* self, val* p0) {
2656 self->attrs[COLOR_parser_nodes__AAnnotation___n_cpar].val = p0; /* _n_cpar on <self:AAnnotation> */
2657 RET_LABEL:;
2658 }
2659 /* method parser_nodes#AAnnotation#n_cpar= for (self: Object, nullable TCpar) */
2660 void VIRTUAL_parser_nodes__AAnnotation__n_cpar_61d(val* self, val* p0) {
2661 parser_nodes__AAnnotation__n_cpar_61d(self, p0);
2662 RET_LABEL:;
2663 }
2664 /* method parser_nodes#AAnnotation#init for (self: AAnnotation) */
2665 void parser_nodes__AAnnotation__init(val* self) {
2666 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AAnnotation>*/;
2667 RET_LABEL:;
2668 }
2669 /* method parser_nodes#AAnnotation#init for (self: Object) */
2670 void VIRTUAL_parser_nodes__AAnnotation__init(val* self) {
2671 parser_nodes__AAnnotation__init(self);
2672 RET_LABEL:;
2673 }
2674 /* method parser_nodes#AAtArg#init for (self: AAtArg) */
2675 void parser_nodes__AAtArg__init(val* self) {
2676 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AAtArg>*/;
2677 RET_LABEL:;
2678 }
2679 /* method parser_nodes#AAtArg#init for (self: Object) */
2680 void VIRTUAL_parser_nodes__AAtArg__init(val* self) {
2681 parser_nodes__AAtArg__init(self);
2682 RET_LABEL:;
2683 }
2684 /* method parser_nodes#ATypeAtArg#n_type for (self: ATypeAtArg): AType */
2685 val* parser_nodes__ATypeAtArg__n_type(val* self) {
2686 val* var /* : AType */;
2687 val* var1 /* : AType */;
2688 var1 = self->attrs[COLOR_parser_nodes__ATypeAtArg___n_type].val; /* _n_type on <self:ATypeAtArg> */
2689 if (var1 == NULL) {
2690 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_type");
2691 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1688);
2692 show_backtrace(1);
2693 }
2694 var = var1;
2695 RET_LABEL:;
2696 return var;
2697 }
2698 /* method parser_nodes#ATypeAtArg#n_type for (self: Object): AType */
2699 val* VIRTUAL_parser_nodes__ATypeAtArg__n_type(val* self) {
2700 val* var /* : AType */;
2701 val* var1 /* : AType */;
2702 var1 = parser_nodes__ATypeAtArg__n_type(self);
2703 var = var1;
2704 RET_LABEL:;
2705 return var;
2706 }
2707 /* method parser_nodes#ATypeAtArg#n_type= for (self: ATypeAtArg, AType) */
2708 void parser_nodes__ATypeAtArg__n_type_61d(val* self, val* p0) {
2709 self->attrs[COLOR_parser_nodes__ATypeAtArg___n_type].val = p0; /* _n_type on <self:ATypeAtArg> */
2710 RET_LABEL:;
2711 }
2712 /* method parser_nodes#ATypeAtArg#n_type= for (self: Object, AType) */
2713 void VIRTUAL_parser_nodes__ATypeAtArg__n_type_61d(val* self, val* p0) {
2714 parser_nodes__ATypeAtArg__n_type_61d(self, p0);
2715 RET_LABEL:;
2716 }
2717 /* method parser_nodes#ATypeAtArg#init for (self: ATypeAtArg) */
2718 void parser_nodes__ATypeAtArg__init(val* self) {
2719 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtArg__init]))(self) /* init on <self:ATypeAtArg>*/;
2720 RET_LABEL:;
2721 }
2722 /* method parser_nodes#ATypeAtArg#init for (self: Object) */
2723 void VIRTUAL_parser_nodes__ATypeAtArg__init(val* self) {
2724 parser_nodes__ATypeAtArg__init(self);
2725 RET_LABEL:;
2726 }
2727 /* method parser_nodes#AExprAtArg#n_expr for (self: AExprAtArg): AExpr */
2728 val* parser_nodes__AExprAtArg__n_expr(val* self) {
2729 val* var /* : AExpr */;
2730 val* var1 /* : AExpr */;
2731 var1 = self->attrs[COLOR_parser_nodes__AExprAtArg___n_expr].val; /* _n_expr on <self:AExprAtArg> */
2732 if (var1 == NULL) {
2733 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_expr");
2734 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1692);
2735 show_backtrace(1);
2736 }
2737 var = var1;
2738 RET_LABEL:;
2739 return var;
2740 }
2741 /* method parser_nodes#AExprAtArg#n_expr for (self: Object): AExpr */
2742 val* VIRTUAL_parser_nodes__AExprAtArg__n_expr(val* self) {
2743 val* var /* : AExpr */;
2744 val* var1 /* : AExpr */;
2745 var1 = parser_nodes__AExprAtArg__n_expr(self);
2746 var = var1;
2747 RET_LABEL:;
2748 return var;
2749 }
2750 /* method parser_nodes#AExprAtArg#n_expr= for (self: AExprAtArg, AExpr) */
2751 void parser_nodes__AExprAtArg__n_expr_61d(val* self, val* p0) {
2752 self->attrs[COLOR_parser_nodes__AExprAtArg___n_expr].val = p0; /* _n_expr on <self:AExprAtArg> */
2753 RET_LABEL:;
2754 }
2755 /* method parser_nodes#AExprAtArg#n_expr= for (self: Object, AExpr) */
2756 void VIRTUAL_parser_nodes__AExprAtArg__n_expr_61d(val* self, val* p0) {
2757 parser_nodes__AExprAtArg__n_expr_61d(self, p0);
2758 RET_LABEL:;
2759 }
2760 /* method parser_nodes#AExprAtArg#init for (self: AExprAtArg) */
2761 void parser_nodes__AExprAtArg__init(val* self) {
2762 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtArg__init]))(self) /* init on <self:AExprAtArg>*/;
2763 RET_LABEL:;
2764 }
2765 /* method parser_nodes#AExprAtArg#init for (self: Object) */
2766 void VIRTUAL_parser_nodes__AExprAtArg__init(val* self) {
2767 parser_nodes__AExprAtArg__init(self);
2768 RET_LABEL:;
2769 }
2770 /* method parser_nodes#AAtAtArg#init for (self: AAtAtArg) */
2771 void parser_nodes__AAtAtArg__init(val* self) {
2772 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtArg__init]))(self) /* init on <self:AAtAtArg>*/;
2773 RET_LABEL:;
2774 }
2775 /* method parser_nodes#AAtAtArg#init for (self: Object) */
2776 void VIRTUAL_parser_nodes__AAtAtArg__init(val* self) {
2777 parser_nodes__AAtAtArg__init(self);
2778 RET_LABEL:;
2779 }
2780 /* method parser_nodes#AAtid#n_id for (self: AAtid): Token */
2781 val* parser_nodes__AAtid__n_id(val* self) {
2782 val* var /* : Token */;
2783 val* var1 /* : Token */;
2784 var1 = self->attrs[COLOR_parser_nodes__AAtid___n_id].val; /* _n_id on <self:AAtid> */
2785 if (var1 == NULL) {
2786 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_id");
2787 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1699);
2788 show_backtrace(1);
2789 }
2790 var = var1;
2791 RET_LABEL:;
2792 return var;
2793 }
2794 /* method parser_nodes#AAtid#n_id for (self: Object): Token */
2795 val* VIRTUAL_parser_nodes__AAtid__n_id(val* self) {
2796 val* var /* : Token */;
2797 val* var1 /* : Token */;
2798 var1 = parser_nodes__AAtid__n_id(self);
2799 var = var1;
2800 RET_LABEL:;
2801 return var;
2802 }
2803 /* method parser_nodes#AAtid#n_id= for (self: AAtid, Token) */
2804 void parser_nodes__AAtid__n_id_61d(val* self, val* p0) {
2805 self->attrs[COLOR_parser_nodes__AAtid___n_id].val = p0; /* _n_id on <self:AAtid> */
2806 RET_LABEL:;
2807 }
2808 /* method parser_nodes#AAtid#n_id= for (self: Object, Token) */
2809 void VIRTUAL_parser_nodes__AAtid__n_id_61d(val* self, val* p0) {
2810 parser_nodes__AAtid__n_id_61d(self, p0);
2811 RET_LABEL:;
2812 }
2813 /* method parser_nodes#AAtid#init for (self: AAtid) */
2814 void parser_nodes__AAtid__init(val* self) {
2815 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:AAtid>*/;
2816 RET_LABEL:;
2817 }
2818 /* method parser_nodes#AAtid#init for (self: Object) */
2819 void VIRTUAL_parser_nodes__AAtid__init(val* self) {
2820 parser_nodes__AAtid__init(self);
2821 RET_LABEL:;
2822 }
2823 /* method parser_nodes#AIdAtid#init for (self: AIdAtid) */
2824 void parser_nodes__AIdAtid__init(val* self) {
2825 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtid__init]))(self) /* init on <self:AIdAtid>*/;
2826 RET_LABEL:;
2827 }
2828 /* method parser_nodes#AIdAtid#init for (self: Object) */
2829 void VIRTUAL_parser_nodes__AIdAtid__init(val* self) {
2830 parser_nodes__AIdAtid__init(self);
2831 RET_LABEL:;
2832 }
2833 /* method parser_nodes#AKwexternAtid#init for (self: AKwexternAtid) */
2834 void parser_nodes__AKwexternAtid__init(val* self) {
2835 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtid__init]))(self) /* init on <self:AKwexternAtid>*/;
2836 RET_LABEL:;
2837 }
2838 /* method parser_nodes#AKwexternAtid#init for (self: Object) */
2839 void VIRTUAL_parser_nodes__AKwexternAtid__init(val* self) {
2840 parser_nodes__AKwexternAtid__init(self);
2841 RET_LABEL:;
2842 }
2843 /* method parser_nodes#AKwinternAtid#init for (self: AKwinternAtid) */
2844 void parser_nodes__AKwinternAtid__init(val* self) {
2845 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtid__init]))(self) /* init on <self:AKwinternAtid>*/;
2846 RET_LABEL:;
2847 }
2848 /* method parser_nodes#AKwinternAtid#init for (self: Object) */
2849 void VIRTUAL_parser_nodes__AKwinternAtid__init(val* self) {
2850 parser_nodes__AKwinternAtid__init(self);
2851 RET_LABEL:;
2852 }
2853 /* method parser_nodes#AKwreadableAtid#init for (self: AKwreadableAtid) */
2854 void parser_nodes__AKwreadableAtid__init(val* self) {
2855 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtid__init]))(self) /* init on <self:AKwreadableAtid>*/;
2856 RET_LABEL:;
2857 }
2858 /* method parser_nodes#AKwreadableAtid#init for (self: Object) */
2859 void VIRTUAL_parser_nodes__AKwreadableAtid__init(val* self) {
2860 parser_nodes__AKwreadableAtid__init(self);
2861 RET_LABEL:;
2862 }
2863 /* method parser_nodes#AKwwritableAtid#init for (self: AKwwritableAtid) */
2864 void parser_nodes__AKwwritableAtid__init(val* self) {
2865 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtid__init]))(self) /* init on <self:AKwwritableAtid>*/;
2866 RET_LABEL:;
2867 }
2868 /* method parser_nodes#AKwwritableAtid#init for (self: Object) */
2869 void VIRTUAL_parser_nodes__AKwwritableAtid__init(val* self) {
2870 parser_nodes__AKwwritableAtid__init(self);
2871 RET_LABEL:;
2872 }
2873 /* method parser_nodes#AKwimportAtid#init for (self: AKwimportAtid) */
2874 void parser_nodes__AKwimportAtid__init(val* self) {
2875 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__AAtid__init]))(self) /* init on <self:AKwimportAtid>*/;
2876 RET_LABEL:;
2877 }
2878 /* method parser_nodes#AKwimportAtid#init for (self: Object) */
2879 void VIRTUAL_parser_nodes__AKwimportAtid__init(val* self) {
2880 parser_nodes__AKwimportAtid__init(self);
2881 RET_LABEL:;
2882 }
2883 /* method parser_nodes#Start#n_base for (self: Start): nullable AModule */
2884 val* parser_nodes__Start__n_base(val* self) {
2885 val* var /* : nullable AModule */;
2886 val* var1 /* : nullable AModule */;
2887 var1 = self->attrs[COLOR_parser_nodes__Start___n_base].val; /* _n_base on <self:Start> */
2888 var = var1;
2889 RET_LABEL:;
2890 return var;
2891 }
2892 /* method parser_nodes#Start#n_base for (self: Object): nullable AModule */
2893 val* VIRTUAL_parser_nodes__Start__n_base(val* self) {
2894 val* var /* : nullable AModule */;
2895 val* var1 /* : nullable AModule */;
2896 var1 = parser_nodes__Start__n_base(self);
2897 var = var1;
2898 RET_LABEL:;
2899 return var;
2900 }
2901 /* method parser_nodes#Start#n_base= for (self: Start, nullable AModule) */
2902 void parser_nodes__Start__n_base_61d(val* self, val* p0) {
2903 self->attrs[COLOR_parser_nodes__Start___n_base].val = p0; /* _n_base on <self:Start> */
2904 RET_LABEL:;
2905 }
2906 /* method parser_nodes#Start#n_base= for (self: Object, nullable AModule) */
2907 void VIRTUAL_parser_nodes__Start__n_base_61d(val* self, val* p0) {
2908 parser_nodes__Start__n_base_61d(self, p0);
2909 RET_LABEL:;
2910 }
2911 /* method parser_nodes#Start#n_eof for (self: Start): EOF */
2912 val* parser_nodes__Start__n_eof(val* self) {
2913 val* var /* : EOF */;
2914 val* var1 /* : EOF */;
2915 var1 = self->attrs[COLOR_parser_nodes__Start___n_eof].val; /* _n_eof on <self:Start> */
2916 if (var1 == NULL) {
2917 fprintf(stderr, "Runtime error: %s", "Uninitialized attribute _n_eof");
2918 fprintf(stderr, " (%s:%d)\n", "src/parser/parser_nodes.nit", 1724);
2919 show_backtrace(1);
2920 }
2921 var = var1;
2922 RET_LABEL:;
2923 return var;
2924 }
2925 /* method parser_nodes#Start#n_eof for (self: Object): EOF */
2926 val* VIRTUAL_parser_nodes__Start__n_eof(val* self) {
2927 val* var /* : EOF */;
2928 val* var1 /* : EOF */;
2929 var1 = parser_nodes__Start__n_eof(self);
2930 var = var1;
2931 RET_LABEL:;
2932 return var;
2933 }
2934 /* method parser_nodes#Start#n_eof= for (self: Start, EOF) */
2935 void parser_nodes__Start__n_eof_61d(val* self, val* p0) {
2936 self->attrs[COLOR_parser_nodes__Start___n_eof].val = p0; /* _n_eof on <self:Start> */
2937 RET_LABEL:;
2938 }
2939 /* method parser_nodes#Start#n_eof= for (self: Object, EOF) */
2940 void VIRTUAL_parser_nodes__Start__n_eof_61d(val* self, val* p0) {
2941 parser_nodes__Start__n_eof_61d(self, p0);
2942 RET_LABEL:;
2943 }
2944 /* method parser_nodes#Start#init for (self: Start, nullable AModule, EOF) */
2945 void parser_nodes__Start__init(val* self, val* p0, val* p1) {
2946 val* var_n_base /* var n_base: nullable AModule */;
2947 val* var_n_eof /* var n_eof: EOF */;
2948 var_n_base = p0;
2949 var_n_eof = p1;
2950 ((void (*)(val*))(self->class->vft[COLOR_parser_nodes__Prod__init]))(self) /* init on <self:Start>*/;
2951 self->attrs[COLOR_parser_nodes__Start___n_base].val = var_n_base; /* _n_base on <self:Start> */
2952 self->attrs[COLOR_parser_nodes__Start___n_eof].val = var_n_eof; /* _n_eof on <self:Start> */
2953 RET_LABEL:;
2954 }
2955 /* method parser_nodes#Start#init for (self: Object, nullable AModule, EOF) */
2956 void VIRTUAL_parser_nodes__Start__init(val* self, val* p0, val* p1) {
2957 parser_nodes__Start__init(self, p0, p1);
2958 RET_LABEL:;
2959 }