gcc/melt/generated/meltrunsup-inc.cc

   1 /** Copyright (C) 2015 Free Software Foundation, Inc.
   2   This generated file meltrunsup-inc.cc is part of GCC.
   3
   4                   [DON'T EDIT THIS GENERATED FILE]
   5
   6     GCC is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 3, or (at your option)
   9     any later version.
  10
  11     GCC is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with GCC; see the file COPYING3.  If not see
  18     <http://www.gnu.org/licenses/>.
  19 **/
  20
  21
  22
  23
  24 /* start of code generated by generate_runtypesupport_cod2ctype */
  25 melt_ptr_t melt_code_to_ctype (int code)
  26 {
  27     switch (code)
  28         {
  29
  30             /* #1: CTYPE_BASIC_BLOCK */
  31         case MELTBPAR_BB:
  32             return MELT_PREDEF(CTYPE_BASIC_BLOCK);
  33             /* #2: CTYPE_BITMAP */
  34         case MELTBPAR_BITMAP:
  35             return MELT_PREDEF(CTYPE_BITMAP);
  36             /* #3: CTYPE_CSTRING */
  37         case MELTBPAR_CSTRING:
  38             return MELT_PREDEF(CTYPE_CSTRING);
  39             /* #4: CTYPE_DOUBLE */
  40         case MELTBPAR_DOUBLE:
  41             return MELT_PREDEF(CTYPE_DOUBLE);
  42             /* #5: CTYPE_EDGE */
  43         case MELTBPAR_EDGE:
  44             return MELT_PREDEF(CTYPE_EDGE);
  45             /* #6: CTYPE_GIMPLE */
  46         case MELTBPAR_GIMPLE:
  47             return MELT_PREDEF(CTYPE_GIMPLE);
  48             /* #7: CTYPE_GIMPLE_SEQ */
  49         case MELTBPAR_GIMPLESEQ:
  50             return MELT_PREDEF(CTYPE_GIMPLE_SEQ);
  51             /* #8: CTYPE_LONG */
  52         case MELTBPAR_LONG:
  53             return MELT_PREDEF(CTYPE_LONG);
  54             /* #9: CTYPE_LOOP */
  55         case MELTBPAR_LOOP:
  56             return MELT_PREDEF(CTYPE_LOOP);
  57             /* #10: CTYPE_RTVEC */
  58         case MELTBPAR_RTVEC:
  59             return MELT_PREDEF(CTYPE_RTVEC);
  60             /* #11: CTYPE_RTX */
  61         case MELTBPAR_RTX:
  62             return MELT_PREDEF(CTYPE_RTX);
  63             /* #12: CTYPE_TREE */
  64         case MELTBPAR_TREE:
  65             return MELT_PREDEF(CTYPE_TREE);
  66             /* #13: CTYPE_VALUE */
  67         case MELTBPAR_PTR:
  68             return MELT_PREDEF(CTYPE_VALUE);
  69             /* #14: CTYPE_VOID */
  70
  71         default:
  72             break;
  73         } /*end switch code*/
  74     return NULL;
  75 } /* end of generated melt_code_to_ctype */
  76
  77
  78
  79 /** start of code generated by generate_runtypesupport_mag2str **/
  80 const char* melt_obmag_string (int i)
  81 {
  82 #define MELT_MAG2STR_CACHEBUF 17
  83 #define MELT_MAG2STR_MAGLEN   16
  84     static char melt_cacheobmagbuf[MELT_MAG2STR_CACHEBUF][MELT_MAG2STR_MAGLEN] ;
  85     switch (i)
  86         {
  87         case 0:
  88             return "MeltObMag!0" ;
  89             /*gtyctype #1 CTYPE_BASIC_BLOCK*/
  90         case MELTOBMAG_BASICBLOCK:
  91             return "MELTOBMAG_BASICBLOCK";
  92         case MELTOBMAG_MAPBASICBLOCKS:
  93             return "MELTOBMAG_MAPBASICBLOCKS";
  94
  95             /*gtyctype #2 CTYPE_BITMAP*/
  96         case MELTOBMAG_BITMAP:
  97             return "MELTOBMAG_BITMAP";
  98         case MELTOBMAG_MAPBITMAPS:
  99             return "MELTOBMAG_MAPBITMAPS";
 100
 101             /*gtyctype #3 CTYPE_CSTRING*/
 102             /*runtypesupport_mag2str no boxed magic */
 103             /*runtypesupport_mag2str no map magic */
 104
 105             /*gtyctype #4 CTYPE_DOUBLE*/
 106             /*runtypesupport_mag2str no boxed magic */
 107             /*runtypesupport_mag2str no map magic */
 108
 109             /*gtyctype #5 CTYPE_EDGE*/
 110         case MELTOBMAG_EDGE:
 111             return "MELTOBMAG_EDGE";
 112         case MELTOBMAG_MAPEDGES:
 113             return "MELTOBMAG_MAPEDGES";
 114
 115             /*gtyctype #6 CTYPE_GIMPLE*/
 116         case MELTOBMAG_GIMPLE:
 117             return "MELTOBMAG_GIMPLE";
 118         case MELTOBMAG_MAPGIMPLES:
 119             return "MELTOBMAG_MAPGIMPLES";
 120
 121             /*gtyctype #7 CTYPE_GIMPLE_SEQ*/
 122         case MELTOBMAG_GIMPLESEQ:
 123             return "MELTOBMAG_GIMPLESEQ";
 124         case MELTOBMAG_MAPGIMPLESEQS:
 125             return "MELTOBMAG_MAPGIMPLESEQS";
 126
 127             /*gtyctype #8 CTYPE_LONG*/
 128             /*runtypesupport_mag2str no boxed magic */
 129             /*runtypesupport_mag2str no map magic */
 130
 131             /*gtyctype #9 CTYPE_LOOP*/
 132         case MELTOBMAG_LOOP:
 133             return "MELTOBMAG_LOOP";
 134         case MELTOBMAG_MAPLOOPS:
 135             return "MELTOBMAG_MAPLOOPS";
 136
 137             /*gtyctype #10 CTYPE_RTVEC*/
 138         case MELTOBMAG_RTVEC:
 139             return "MELTOBMAG_RTVEC";
 140         case MELTOBMAG_MAPRTVECS:
 141             return "MELTOBMAG_MAPRTVECS";
 142
 143             /*gtyctype #11 CTYPE_RTX*/
 144         case MELTOBMAG_RTX:
 145             return "MELTOBMAG_RTX";
 146         case MELTOBMAG_MAPRTXS:
 147             return "MELTOBMAG_MAPRTXS";
 148
 149             /*gtyctype #12 CTYPE_TREE*/
 150         case MELTOBMAG_TREE:
 151             return "MELTOBMAG_TREE";
 152         case MELTOBMAG_MAPTREES:
 153             return "MELTOBMAG_MAPTREES";
 154
 155             /*gtyctype #13 CTYPE_VALUE*/
 156             /*runtypesupport_mag2str no boxed magic */
 157             /*runtypesupport_mag2str no map magic */
 158
 159             /*gtyctype #14 CTYPE_VOID*/
 160             /*runtypesupport_mag2str no boxed magic */
 161             /*runtypesupport_mag2str no map magic */
 162
 163
 164             /*valdesc #1 VALDESC_BUCKETLONGS*/
 165         case MELTOBMAG_BUCKETLONGS:
 166             return "MELTOBMAG_BUCKETLONGS";
 167
 168             /*valdesc #2 VALDESC_CLOSURE*/
 169         case MELTOBMAG_CLOSURE:
 170             return "MELTOBMAG_CLOSURE";
 171
 172             /*valdesc #3 VALDESC_DECAY*/
 173         case MELTOBMAG_DECAY:
 174             return "MELTOBMAG_DECAY";
 175
 176             /*valdesc #4 VALDESC_DOUBLE*/
 177         case MELTOBMAG_DOUBLE:
 178             return "MELTOBMAG_DOUBLE";
 179
 180             /*valdesc #5 VALDESC_HOOK*/
 181         case MELTOBMAG_HOOK:
 182             return "MELTOBMAG_HOOK";
 183
 184             /*valdesc #6 VALDESC_INT*/
 185         case MELTOBMAG_INT:
 186             return "MELTOBMAG_INT";
 187
 188             /*valdesc #7 VALDESC_JSONOBJECT*/
 189         case MELTOBMAG_JSONOBJECT:
 190             return "MELTOBMAG_JSONOBJECT";
 191
 192             /*valdesc #8 VALDESC_LIST*/
 193         case MELTOBMAG_LIST:
 194             return "MELTOBMAG_LIST";
 195
 196             /*valdesc #9 VALDESC_MAPOBJECTS*/
 197         case MELTOBMAG_MAPOBJECTS:
 198             return "MELTOBMAG_MAPOBJECTS";
 199
 200             /*valdesc #10 VALDESC_MAPSTRINGS*/
 201         case MELTOBMAG_MAPSTRINGS:
 202             return "MELTOBMAG_MAPSTRINGS";
 203
 204             /*valdesc #11 VALDESC_MIXBIGINT*/
 205         case MELTOBMAG_MIXBIGINT:
 206             return "MELTOBMAG_MIXBIGINT";
 207
 208             /*valdesc #12 VALDESC_MIXINT*/
 209         case MELTOBMAG_MIXINT:
 210             return "MELTOBMAG_MIXINT";
 211
 212             /*valdesc #13 VALDESC_MIXLOC*/
 213         case MELTOBMAG_MIXLOC:
 214             return "MELTOBMAG_MIXLOC";
 215
 216             /*valdesc #14 VALDESC_MULTIPLE*/
 217         case MELTOBMAG_MULTIPLE:
 218             return "MELTOBMAG_MULTIPLE";
 219
 220             /*valdesc #15 VALDESC_OBJECT*/
 221         case MELTOBMAG_OBJECT:
 222             return "MELTOBMAG_OBJECT";
 223
 224             /*valdesc #16 VALDESC_PAIR*/
 225         case MELTOBMAG_PAIR:
 226             return "MELTOBMAG_PAIR";
 227
 228             /*valdesc #17 VALDESC_REAL*/
 229         case MELTOBMAG_REAL:
 230             return "MELTOBMAG_REAL";
 231
 232             /*valdesc #18 VALDESC_ROUTINE*/
 233         case MELTOBMAG_ROUTINE:
 234             return "MELTOBMAG_ROUTINE";
 235
 236             /*valdesc #19 VALDESC_SPECIAL_DATA*/
 237         case MELTOBMAG_SPECIAL_DATA:
 238             return "MELTOBMAG_SPECIAL_DATA";
 239
 240             /*valdesc #20 VALDESC_STRBUF*/
 241         case MELTOBMAG_STRBUF:
 242             return "MELTOBMAG_STRBUF";
 243
 244             /*valdesc #21 VALDESC_STRING*/
 245         case MELTOBMAG_STRING:
 246             return "MELTOBMAG_STRING";
 247         default:
 248         {
 249             int ix = (i & 0x3ffffff) % MELT_MAG2STR_CACHEBUF;
 250             snprintf (melt_cacheobmagbuf[ix], MELT_MAG2STR_MAGLEN-1, "?MeltObjMag?%d", i);
 251             return melt_cacheobmagbuf[ix];
 252         }
 253         } /* end switch */
 254 } /* end generated melt_obmag_string */
 255
 256 /** end of code generated by generate_runtypesupport_mag2str **/
 257
 258
 259 /** generated by generate_runtypesupport_forwcopy_fun **/
 260
 261 /* cheney like forwarding generated function */
 262 melt_ptr_t
 263 melt_forwarded_copy (melt_ptr_t p)
 264 {
 265     /* header generated by generate_runtypesupport_forwcopy_fun */
 266     melt_ptr_t n = 0;
 267     int mag = 0;
 268     gcc_assert (melt_is_young (p));
 269     gcc_assert (p->u_discr && p->u_discr != MELT_FORWARDED_DISCR);
 270     if (p->u_discr->meltobj_class == MELT_FORWARDED_DISCR)
 271         mag =
 272             ((meltobject_ptr_t)
 273              (((struct meltforward_st *) p->u_discr)->forward))->meltobj_magic;
 274     else
 275         mag = p->u_discr->meltobj_magic;
 276     melt_forward_counter++;
 277     switch (mag)   /* end of generated header */
 278         {
 279
 280             /* value descriptor forward copy for melt_forwarded_copy  */
 281
 282             /*valdesc #1 VALDESC_BUCKETLONGS*/
 283         case MELTOBMAG_BUCKETLONGS:
 284         {
 285             struct meltbucketlongs_st*src = (struct meltbucketlongs_st*) p;
 286             struct meltbucketlongs_st*dst = NULL;
 287             /* copy chunk from  VALDESC_BUCKETLONGS  in warmelt-base.melt */
 288             // in file warmelt-base.melt line 2856
 289             /* ggc_alloc_meltbucketlongs_st should be gengtype generated for VALDESC_BUCKETLONGS */
 290             unsigned lnix = src->buckl_lenix;
 291             unsigned len = melt_primtab[lnix];
 292             unsigned ucnt = 0;
 293             unsigned ix = 0;
 294             size_t sz = len*sizeof (struct melt_bucketlongentry_st)
 295                         + offsetof(struct meltbucketlongs_st, buckl_entab);
 296             gcc_assert (lnix > 0);
 297             gcc_assert (len > 0);
 298             dst = /* Don't need a cleared allocation! */
 299                 ggc_alloc_meltbucketlongs_st (sz);
 300             melt_forwarded_copy_byte_count += sz;
 301             dst->discr = src->discr;
 302             dst->buckl_lenix = src->buckl_lenix;
 303             dst->buckl_aux = src->buckl_aux;
 304             dst->buckl_xnum = src->buckl_xnum;
 305             ucnt = dst->buckl_ucount = src->buckl_ucount;
 306             for (ix = 0;
 307                     ix < ucnt;
 308                     ix++)
 309                 dst->buckl_entab[ix] = src->buckl_entab[ix];
 310             for (ix = ucnt;
 311                     ix < len;
 312                     ix++)
 313                 {
 314                     dst->buckl_entab[ix].ebl_at = 0L;
 315                     dst->buckl_entab[ix].ebl_va = NULL;
 316                 }
 317             /* end copy chunk VALDESC_BUCKETLONGS */
 318
 319             n = (melt_ptr_t) dst;
 320             break;
 321         }
 322
 323         /*valdesc #2 VALDESC_CLOSURE*/
 324         case MELTOBMAG_CLOSURE:
 325         {
 326             struct meltclosure_st*src = (struct meltclosure_st*) p;
 327             struct meltclosure_st*dst = NULL;
 328             /* copy VALDESC_CLOSURE in warmelt-base.melt  */
 329             // in file warmelt-base.melt line 2606
 330             /* ggc_alloc_meltclosure_st should be gengtype generated for VALDESC_CLOSURE */
 331 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 332 #ifndef ggc_alloc_meltclosure_st
 333 #define ggc_alloc_meltclosure_st(SIZE) ((struct meltclosure_st *)(ggc_internal_alloc (SIZE)))
 334 #endif /* ggc_alloc_meltclosure_st */
 335 #else /* GCC 4.9 */
 336 #ifndef ggc_alloc_meltclosure_st
 337 #define ggc_alloc_meltclosure_st(SIZE) ((struct meltclosure_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 338 #endif /* ggc_alloc_meltclosure_st */
 339 #endif /* GCC 4.9 or 5.0 */
 340             int nbv = (int) src->nbval;
 341             size_t sz = nbv*sizeof(void*) + offsetof(struct meltclosure_st, tabval);
 342             dst =
 343                 /* Don't need a cleared allocation!  */
 344                 ggc_alloc_meltclosure_st  (sz);
 345             melt_forwarded_copy_byte_count += sz;
 346             dst->discr = src->discr;
 347             dst->rout = src->rout;
 348             dst->nbval = (unsigned) nbv;
 349             for (int ix = 0;
 350                     ix < nbv;
 351                     ix++)
 352                 dst->tabval[ix] = src->tabval[ix];
 353
 354             n = (melt_ptr_t) dst;
 355             break;
 356         }
 357
 358         /*valdesc #3 VALDESC_DECAY*/
 359         case MELTOBMAG_DECAY:
 360         {
 361             struct meltdecay_st*src = (struct meltdecay_st*) p;
 362             struct meltdecay_st*dst = NULL;
 363             /* from VALDESC_DECAY in warmelt-base.melt */
 364             // in file warmelt-base.melt line 2484
 365             /* ggc_alloc_meltdecay_st should be gengtype generated for VALDESC_DECAY */
 366 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 367 #ifndef ggc_alloc_meltdecay_st
 368 #define ggc_alloc_meltdecay_st() ((struct meltdecay_st *)(ggc_internal_alloc (sizeof (struct meltdecay_st))))
 369 #endif /* ggc_alloc_meltdecay_st */
 370 #else /* GCC 4.9 */
 371 #ifndef ggc_alloc_meltdecay_st
 372 #define ggc_alloc_meltdecay_st() ((struct meltdecay_st *)(ggc_internal_alloc_stat (sizeof (struct meltdecay_st) MEM_STAT_INFO)))
 373 #endif /* ggc_alloc_meltdecay_st */
 374 #endif /* GCC not 5.0 */
 375             dst = ggc_alloc_meltdecay_st ();
 376             *dst = *src;
 377             melt_forwarded_copy_byte_count += sizeof(*dst);
 378
 379             n = (melt_ptr_t) dst;
 380             break;
 381         }
 382
 383         /*valdesc #4 VALDESC_DOUBLE*/
 384         case MELTOBMAG_DOUBLE:
 385         {
 386             struct meltdouble_st*src = (struct meltdouble_st*) p;
 387             struct meltdouble_st*dst = NULL;
 388             /* from VALDESC_DOUBLE in warmelt-base.melt  */
 389             /* ggc_alloc_meltdouble_st should be gengtype generated for VALDESC_DOUBLE */
 390 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 391 #ifndef ggc_alloc_meltdouble_st
 392 #define ggc_alloc_meltdouble_st() ((struct meltdouble_st *)(ggc_internal_alloc (sizeof (struct meltdouble_st))))
 393 #endif
 394 #else /* GCC 4.9 */
 395 #ifndef ggc_alloc_meltdouble_st
 396 #define ggc_alloc_meltdouble_st() ((struct meltdouble_st *)(ggc_internal_alloc_stat (sizeof (struct meltdouble_st) MEM_STAT_INFO)))
 397 #endif
 398 #endif /* GCC not 5.0 */
 399             dst =
 400                 /* Don't need a cleared allocation.  */
 401                 ggc_alloc_meltdouble_st ();
 402             melt_forwarded_copy_byte_count += sizeof(*dst);
 403             *dst = *src;
 404
 405             n = (melt_ptr_t) dst;
 406             break;
 407         }
 408
 409         /*valdesc #5 VALDESC_HOOK*/
 410         case MELTOBMAG_HOOK:
 411         {
 412             struct melthook_st*src = (struct melthook_st*) p;
 413             struct melthook_st*dst = NULL;
 414             /* from VALDESC_HOOK in warmelt-base.melt */
 415             // in file warmelt-base.melt line 2777
 416             /* ggc_alloc_melthook_st should be gengtype generated for VALDESC_HOOK */
 417 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 418 #ifndef ggc_alloc_melthook_st
 419 #define ggc_alloc_melthook_st(SIZE) ((struct melthook_st *)(ggc_internal_alloc (SIZE)))
 420 #endif
 421 #else /* GCC 4.9 */
 422 #ifndef ggc_alloc_melthook_st
 423 #define ggc_alloc_melthook_st(SIZE) ((struct melthook_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 424 #endif
 425 #endif /* GCC not 5.0 */
 426             int nbv = (int) src->nbval;
 427             int ix = 0;
 428             size_t sz = nbv*sizeof(void*) + offsetof(struct melthook_st, tabval);
 429             dst =
 430                 /* Don't need a cleared allocation!  */
 431                 ggc_alloc_melthook_st (sz);
 432             melt_forwarded_copy_byte_count += sz;
 433             dst->discr = src->discr;
 434             strncpy (dst->hookname, src->hookname, MELT_HOOKNAME_LEN);
 435             dst->hookname[MELT_HOOKNAME_LEN - 1] = 0;
 436             dst->nbval = (unsigned) nbv;
 437             dst->hookad = src->hookad;
 438             for (ix = 0;
 439                     ix < nbv;
 440                     ix++)
 441                 dst->tabval[ix] = src->tabval[ix];
 442             dst->hookdata = src->hookdata;
 443
 444             n = (melt_ptr_t) dst;
 445             break;
 446         }
 447
 448         /*valdesc #6 VALDESC_INT*/
 449         case MELTOBMAG_INT:
 450         {
 451             struct meltint_st*src = (struct meltint_st*) p;
 452             struct meltint_st*dst = NULL;
 453             /* from VALDESC_INT */
 454             /* ggc_alloc_meltint_st should be gengtype generated for VALDESC_INT */
 455 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 456 #ifndef ggc_alloc_meltint_st
 457 #define ggc_alloc_meltint_st() ((struct meltint_st *)(ggc_internal_alloc (sizeof (struct meltint_st))))
 458 #endif
 459 #else /* GCC 4.9 */
 460 #ifndef ggc_alloc_meltint_st
 461 #define ggc_alloc_meltint_st() ((struct meltint_st *)(ggc_internal_alloc_stat (sizeof (struct meltint_st) MEM_STAT_INFO)))
 462 #endif
 463 #endif /* GCC not 5.0 */
 464             dst =
 465                 /* Don't need a cleared allocation.  */
 466                 ggc_alloc_meltint_st ();
 467             melt_forwarded_copy_byte_count += sizeof(*dst);
 468             *dst = *src;
 469
 470             n = (melt_ptr_t) dst;
 471             break;
 472         }
 473
 474         /*valdesc #7 VALDESC_JSONOBJECT*/
 475         case MELTOBMAG_JSONOBJECT:
 476         {
 477             struct meltjsonobject_st*src = (struct meltjsonobject_st*) p;
 478             struct meltjsonobject_st*dst = NULL;
 479             /* copy chunk from  VALDESC_JSONOBJECT in warmelt-base.melt */
 480             // in file warmelt-base.melt line 3025
 481             /* ggc_alloc_meltjsonobject_st should be gengtype generated for VALDESC_JSONOBJECT */
 482             unsigned srcsize = src->jsob_size;
 483             size_t sz = srcsize * sizeof(melt_jsonobentry_st)
 484                         + offsetof(struct meltjsonobject_st, jsob_entab);
 485             dst = /* Don't need a cleared allocation! */
 486                 ggc_alloc_meltjsonobject_st (sz);
 487             melt_forwarded_copy_byte_count += sz;
 488             dst->discr = src->discr;
 489             dst->jsob_aux = src->jsob_aux;
 490             dst->jsob_size = srcsize;
 491             for (unsigned ix = 0;
 492                     ix < srcsize;
 493                     ix++)
 494                 dst->jsob_entab[ix] = src->jsob_entab[ix];
 495             /* end copy chunk VALDESC_JSONOBJECT */
 496
 497             n = (melt_ptr_t) dst;
 498             break;
 499         }
 500
 501         /*valdesc #8 VALDESC_LIST*/
 502         case MELTOBMAG_LIST:
 503         {
 504             struct meltlist_st*src = (struct meltlist_st*) p;
 505             struct meltlist_st*dst = NULL;
 506             /* copy chunk from VALDESC_LIST */
 507             // in file warmelt-base.melt line 3250
 508             /* ggc_alloc_meltlist_st should be gengtype generated for VALDESC_LIST */
 509 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 510 #ifndef ggc_alloc_meltlist_st
 511 #define ggc_alloc_meltlist_st() ((struct meltlist_st *)(ggc_internal_alloc (sizeof (struct meltlist_st))))
 512 #endif
 513 #else /* GCC 4.9 */
 514 #ifndef ggc_alloc_meltlist_st
 515 #define ggc_alloc_meltlist_st() ((struct meltlist_st *)(ggc_internal_alloc_stat (sizeof (struct meltlist_st) MEM_STAT_INFO)))
 516 #endif
 517 #endif /* GCC not 5.0 */
 518             dst =
 519                 /* Don't need a cleared allocation!  */
 520                 ggc_alloc_meltlist_st ();
 521             *dst = *src;
 522             melt_forwarded_copy_byte_count += sizeof(*dst);
 523             /* end chunk from VALDESC_LIST */
 524
 525             n = (melt_ptr_t) dst;
 526             break;
 527         }
 528
 529         /*valdesc #9 VALDESC_MAPOBJECTS*/
 530         case MELTOBMAG_MAPOBJECTS:
 531         {
 532             struct meltmapobjects_st*src = (struct meltmapobjects_st*) p;
 533             struct meltmapobjects_st*dst = NULL;
 534             /* copy VALDESC_MAPOBJECTS in warmelt-base.melt */
 535             // in file warmelt-base.melt line 2235
 536             /* ggc_alloc_meltmapobjects_st should be gengtype generated for VALDESC_MAPOBJECTS */
 537 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 538 #ifndef ggc_alloc_meltmapobjects_st
 539 #define ggc_alloc_meltmapobjects_st() ((struct meltmapobjects_st *)(ggc_internal_alloc(sizeof(struct meltmapobjects_st))))
 540 #endif /* ggc_alloc_meltmapobjects_st */
 541 #ifndef ggc_alloc_vec_entryobjectsmelt_st
 542 #define ggc_alloc_vec_entryobjectsmelt_st(N) ((struct entryobjectsmelt_st *) (ggc_internal_alloc(sizeof(struct entryobjectsmelt_st)*(N))))
 543 #endif /* ggc_alloc_vec_entryobjectsmelt_st */
 544 #ifndef  ggc_alloc_cleared_vec_entryobjectsmelt_st
 545 #define ggc_alloc_cleared_vec_entryobjectsmelt_st(N)  ((struct entryobjectsmelt_st *) (ggc_internal_cleared_alloc(sizeof(struct entryobjectsmelt_st)*(N))))
 546 #endif /* ggc_alloc_cleared_vec_entryobjectsmelt_st */
 547 #else /* GCC 4.9 */
 548 #ifndef ggc_alloc_meltmapobjects_st
 549 #define ggc_alloc_meltmapobjects_st() ((struct meltmapobjects_st *)(ggc_internal_alloc_stat (sizeof (struct meltmapobjects_st) MEM_STAT_INFO)))
 550 #endif /* ggc_alloc_meltmapobjects_st */
 551 #ifndef ggc_alloc_vec_entryobjectsmelt_st
 552 #define ggc_alloc_vec_entryobjectsmelt_st(N) ((struct entryobjectsmelt_st *) (ggc_internal_vec_alloc_stat (sizeof (struct entryobjectsmelt_st), N MEM_STAT_INFO)))
 553 #endif /* ggc_alloc_vec_entryobjectsmelt_st */
 554 #ifndef  ggc_alloc_cleared_vec_entryobjectsmelt_st
 555 #define ggc_alloc_cleared_vec_entryobjectsmelt_st(n) ((struct entryobjectsmelt_st *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct entryobjectsmelt_st), n MEM_STAT_INFO)))
 556 #endif /* ggc_alloc_cleared_vec_entryobjectsmelt_st */
 557 #endif /* GCC 4.9 */
 558             int siz = melt_primtab[src->lenix];
 559             size_t sz = 0;
 560             dst =
 561                 /* copychunk mapobject on't need a cleared allocation.  */
 562                 ggc_alloc_meltmapobjects_st ();
 563             dst->discr = src->discr;
 564             dst->count = src->count;
 565             dst->lenix = src->lenix;
 566             dst->meltmap_hash = src->meltmap_hash;
 567             dst->meltmap_aux = src->meltmap_aux;
 568             sz = sizeof(*dst);
 569             if (siz > 0 && src->entab)
 570                 {
 571                     /* Don't need a cleared allocation.  */
 572                     dst->entab = ggc_alloc_vec_entryobjectsmelt_st (siz);
 573                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
 574                     sz += siz * sizeof(dst->entab[0]);
 575                 }
 576             else
 577                 dst->entab = NULL;
 578             melt_forwarded_copy_byte_count += sz;
 579
 580             n = (melt_ptr_t) dst;
 581             break;
 582         }
 583
 584         /*valdesc #10 VALDESC_MAPSTRINGS*/
 585         case MELTOBMAG_MAPSTRINGS:
 586         {
 587             struct meltmapstrings_st*src = (struct meltmapstrings_st*) p;
 588             struct meltmapstrings_st*dst = NULL;
 589             /* copy VALDESC_MAPSTRINGS in warmelt-base.melt */
 590             // in file warmelt-base.melt line 2360
 591             /* ggc_alloc_meltmapstrings_st should be gengtype generated for VALDESC_MAPSTRINGS */
 592 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 593 #ifndef ggc_alloc_meltmapstrings_st
 594 #define ggc_alloc_meltmapstrings_st() ((struct meltmapstrings_st *)(ggc_internal_alloc (sizeof (struct meltmapstrings_st))))
 595 #endif /* ggc_alloc_meltmapstrings_st */
 596 #ifndef ggc_alloc_vec_entrystringsmelt_st
 597 #define ggc_alloc_vec_entrystringsmelt_st(N) ((struct entrystringsmelt_st *)(ggc_internal_alloc (sizeof (struct entrystringsmelt_st)*(N))))
 598 #endif /* ggc_alloc_vec_entrystringsmelt_st */
 599 #ifndef ggc_alloc_cleared_vec_entrystringsmelt_st
 600 #define ggc_alloc_cleared_vec_entrystringsmelt_st(N) ((struct entrystringsmelt_st *)(ggc_internal_cleared_alloc (sizeof (struct entrystringsmelt_st)*(N))))
 601 #endif /* ggc_alloc_cleared_vec_entrystringsmelt_st */
 602 #else /* GCC 4.9 */
 603 #ifndef ggc_alloc_meltmapstrings_st
 604 #define ggc_alloc_meltmapstrings_st() ((struct meltmapstrings_st *)(ggc_internal_alloc_stat (sizeof (struct meltmapstrings_st) MEM_STAT_INFO)))
 605 #endif /* ggc_alloc_meltmapstrings_st */
 606 #ifndef ggc_alloc_vec_entrystringsmelt_st
 607 #define ggc_alloc_vec_entrystringsmelt_st(n) ((struct entrystringsmelt_st *)(ggc_internal_vec_alloc_stat (sizeof (struct entrystringsmelt_st), n MEM_STAT_INFO)))
 608 #endif /* ggc_alloc_vec_entrystringsmelt_st */
 609 #ifndef ggc_alloc_cleared_vec_entrystringsmelt_st
 610 #define ggc_alloc_cleared_vec_entrystringsmelt_st(n) ((struct entrystringsmelt_st *)(ggc_internal_cleared_vec_alloc_stat (sizeof (struct entrystringsmelt_st), n MEM_STAT_INFO)))
 611 #endif /* ggc_alloc_cleared_vec_entrystringsmelt_st */
 612 #endif /* GCC 5.0 or 4.9 */
 613             int siz = melt_primtab[src->lenix];
 614             size_t sz = 0;
 615             dst =
 616                 /* copychunk mapstring on't need a cleared allocation.  */
 617                 ggc_alloc_meltmapstrings_st ();
 618             sz = sizeof (*dst);
 619             dst->discr = src->discr;
 620             dst->count = src->count;
 621             dst->lenix = src->lenix;
 622             dst->meltmap_aux = src->meltmap_aux;
 623             dst->meltmap_hash = src->meltmap_hash;
 624             if (siz > 0 && src->entab)
 625                 {
 626                     /* Don't need a cleared allocation.  */
 627                     dst->entab = ggc_alloc_vec_entrystringsmelt_st (siz);
 628                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
 629                     sz += siz * sizeof(dst->entab[0]);
 630                 }
 631             else
 632                 dst->entab = NULL;
 633             melt_forwarded_copy_byte_count += sz;
 634
 635             n = (melt_ptr_t) dst;
 636             break;
 637         }
 638
 639         /*valdesc #11 VALDESC_MIXBIGINT*/
 640         case MELTOBMAG_MIXBIGINT:
 641         {
 642             struct meltmixbigint_st*src = (struct meltmixbigint_st*) p;
 643             struct meltmixbigint_st*dst = NULL;
 644             /* from VALDESC_MIXBIGINT in warmelt-base.melt */
 645             // in file warmelt-base.melt line 3470
 646             /* ggc_alloc_meltmixbigint_st should be gengtype generated for VALDESC_MIXBIGINT */
 647 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 648 #ifndef ggc_alloc_meltmixbigint_st
 649 #define ggc_alloc_meltmixbigint_st(SIZE) ((struct meltmixbigint_st *)(ggc_internal_alloc (SIZE)))
 650 #endif
 651 #else /* GCC 4.9 */
 652 #ifndef ggc_alloc_meltmixbigint_st
 653 #define ggc_alloc_meltmixbigint_st(SIZE) ((struct meltmixbigint_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 654 #endif
 655 #endif /* GCC not 5.0 */
 656             unsigned blen = src->biglen;
 657             size_t sz = blen*sizeof(long) + offsetof(struct meltmixbigint_st, tabig);
 658             dst =
 659                 /* Don't need a cleared allocation.  */
 660                 ggc_alloc_meltmixbigint_st   (sz);
 661             dst->discr = src->discr;
 662             dst->ptrval = src->ptrval;
 663             dst->negative = src->negative;
 664             dst->biglen = blen;
 665             memcpy (dst->tabig, src->tabig, blen*sizeof(dst->tabig[0]));
 666             melt_forwarded_copy_byte_count += sz;
 667
 668             n = (melt_ptr_t) dst;
 669             break;
 670         }
 671
 672         /*valdesc #12 VALDESC_MIXINT*/
 673         case MELTOBMAG_MIXINT:
 674         {
 675             struct meltmixint_st*src = (struct meltmixint_st*) p;
 676             struct meltmixint_st*dst = NULL;
 677             /* from VALDESC_MIXINT in warmelt-base.melt  */
 678             // in file warmelt-base.melt line 3388
 679             /* ggc_alloc_meltmixint_st should be gengtype generated for VALDESC_MIXINT */
 680 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 681 #ifndef ggc_alloc_meltmixint_st
 682 #define ggc_alloc_meltmixint_st() ((struct meltmixint_st *)(ggc_internal_alloc (sizeof (struct meltmixint_st))))
 683 #endif
 684 #else /* GCC 4.9 */
 685 #ifndef ggc_alloc_meltmixint_st
 686 #define ggc_alloc_meltmixint_st() ((struct meltmixint_st *)(ggc_internal_alloc_stat (sizeof (struct meltmixint_st) MEM_STAT_INFO)))
 687 #endif
 688 #endif /* GCC not 5.0 */
 689             dst =
 690                 /* Don't need a cleared allocation.  */
 691                 ggc_alloc_meltmixint_st ();
 692             melt_forwarded_copy_byte_count += sizeof(*dst);
 693             *dst = *src;
 694
 695             n = (melt_ptr_t) dst;
 696             break;
 697         }
 698
 699         /*valdesc #13 VALDESC_MIXLOC*/
 700         case MELTOBMAG_MIXLOC:
 701         {
 702             struct meltmixloc_st*src = (struct meltmixloc_st*) p;
 703             struct meltmixloc_st*dst = NULL;
 704             /* from VALDESC_MIXLOC in warmelt-base.melt */
 705             // in file warmelt-base.melt line 3426
 706             /* ggc_alloc_meltmixloc_st should be gengtype generated for VALDESC_MIXLOC */
 707 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 708 #ifndef ggc_alloc_meltmixloc_st
 709 #define ggc_alloc_meltmixloc_st() ((struct meltmixloc_st *)(ggc_internal_alloc (sizeof (struct meltmixloc_st))))
 710 #endif
 711 #else /* GCC 4.9 */
 712 #ifndef ggc_alloc_meltmixloc_st
 713 #define ggc_alloc_meltmixloc_st() ((struct meltmixloc_st *)(ggc_internal_alloc_stat (sizeof (struct meltmixloc_st) MEM_STAT_INFO)))
 714 #endif
 715 #endif /* GCC not 5.0 */
 716             dst =
 717                 /* Don't need a cleared allocation.  */
 718                 ggc_alloc_meltmixloc_st ();
 719             *dst = *src;
 720             melt_forwarded_copy_byte_count += sizeof(*dst);
 721
 722             n = (melt_ptr_t) dst;
 723             break;
 724         }
 725
 726         /*valdesc #14 VALDESC_MULTIPLE*/
 727         case MELTOBMAG_MULTIPLE:
 728         {
 729             struct meltmultiple_st*src = (struct meltmultiple_st*) p;
 730             struct meltmultiple_st*dst = NULL;
 731             /* copy chunk from VALDESC_MULTIPLE in warmelt-base.melt */
 732             // in file warmelt-base.melt line 2532
 733             /* ggc_alloc_meltmultiple_st should be gengtype generated for VALDESC_MULTIPLE */
 734 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 735 #ifndef ggc_alloc_meltmultiple_st
 736 #define ggc_alloc_meltmultiple_st(SIZE) ((struct meltmultiple_st *)(ggc_internal_alloc(SIZE)))
 737 #endif /* ggc_alloc_meltmultiple_st */
 738 #else /* GCC 4.9 */
 739 #ifndef ggc_alloc_meltmultiple_st
 740 #define ggc_alloc_meltmultiple_st(SIZE) ((struct meltmultiple_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 741 #endif /* ggc_alloc_meltmultiple_st */
 742 #endif /* GCC not 5.0 */
 743             int nbv = (int) src->nbval;
 744             size_t sz = nbv*sizeof(void*) + offsetof(struct meltmultiple_st, tabval);
 745             dst =
 746                 /* Don't need a cleared allocation!  */
 747                 ggc_alloc_meltmultiple_st (sz);
 748             melt_forwarded_copy_byte_count += sz;
 749             /* we cannot copy the whole src, because MELT_FLEXIBLE_DIM might be
 750                1 and nbval could be 0 */
 751             dst->discr = src->discr;
 752             dst->nbval = src->nbval;
 753             for (int ix = 0;
 754                     ix < nbv;
 755                     ix++)
 756                 dst->tabval[ix] = src->tabval[ix];
 757             /* end copy chunk from VALDESC_MULTIPLE */
 758
 759             n = (melt_ptr_t) dst;
 760             break;
 761         }
 762
 763         /*valdesc #15 VALDESC_OBJECT*/
 764         case MELTOBMAG_OBJECT:
 765         {
 766             struct meltobject_st*src = (struct meltobject_st*) p;
 767             struct meltobject_st*dst = NULL;
 768             /* from VALDESC_OBJECT file warmelt-base.melt */
 769             // in file warmelt-base.melt line 2101
 770             /* ggc_alloc_meltobject_st should be gengtype generated for VALDESC_OBJECT */
 771 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 772 #ifndef ggc_alloc_meltobject_st
 773 #define ggc_alloc_meltobject_st(SIZE) ((struct meltobject_st *)(ggc_internal_alloc (SIZE)))
 774 #endif  /* ggc_alloc_meltobject_st */
 775 #else /* GCC 4.9 and before */
 776 #ifndef ggc_alloc_meltobject_st
 777 #define ggc_alloc_meltobject_st(SIZE) ((struct meltobject_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 778 #endif  /* ggc_alloc_meltobject_st */
 779 #endif /* GCC 4.9 or GCC 5.0 */
 780
 781             int ix = 0;
 782             int oblen = (int) (src->obj_len);
 783             size_t sz = 0;
 784             /* We don't need to clear at allocation, since the object is
 785                explicitly filled here! */
 786             sz = oblen*sizeof(void*)
 787                  + offsetof(struct meltobject_st, obj_vartab);
 788             dst = ggc_alloc_meltobject_st (sz);
 789             melt_forwarded_copy_byte_count += sz;
 790             /* we cannot copy the whole src, because MELT_FLEXIBLE_DIM might be 1 */
 791             dst->meltobj_class = src->meltobj_class;
 792             dst->obj_hash = src->obj_hash;
 793             dst->obj_num = src->obj_num;
 794             dst->obj_len = oblen;
 795             for (ix = 0;
 796                     ix < oblen;
 797                     ix++)
 798                 dst->obj_vartab[ix] = src->obj_vartab[ix];
 799 #if ENABLE_CHECKING
 800             /* for low level debugging with gdb, we may want to catch some copy operations */
 801             if (melt_alptr_1 && (void*) src == melt_alptr_1)
 802                 melt_break_alptr_1 ("copyobj src=alptr1");
 803             if (melt_alptr_2 && (void*) src == melt_alptr_2)
 804                 melt_break_alptr_2 ("copyobj src=alptr2");
 805             if (src->obj_hash == melt_objhash_1)
 806                 melt_break_objhash_1("copyobj src with objhash1");
 807             if (src->obj_hash == melt_objhash_2)
 808                 melt_break_objhash_2("copyobj src with objhash2");
 809 #endif /* ENABLE_CHECKING */
 810
 811             n = (melt_ptr_t) dst;
 812             break;
 813         }
 814
 815         /*valdesc #16 VALDESC_PAIR*/
 816         case MELTOBMAG_PAIR:
 817         {
 818             struct meltpair_st*src = (struct meltpair_st*) p;
 819             struct meltpair_st*dst = NULL;
 820             /* copy VALDESC_PAIR in warmelt-base.melt */
 821             // in file warmelt-base.melt line 3207
 822             /* ggc_alloc_meltpair_st should be gengtype gengtype for VALDESC_PAIR */
 823 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 824 #ifndef ggc_alloc_meltpair_st
 825 #define ggc_alloc_meltpair_st() ((struct meltpair_st *)(ggc_internal_alloc (sizeof (struct meltpair_st))))
 826 #endif
 827 #else /* GCC 4.9 */
 828 #ifndef ggc_alloc_meltpair_st
 829 #define ggc_alloc_meltpair_st() ((struct meltpair_st *)(ggc_internal_alloc_stat (sizeof (struct meltpair_st) MEM_STAT_INFO)))
 830 #endif
 831 #endif /* GCC not 5.0 */
 832             dst = /* Don't need a cleared allocation.  */
 833                 ggc_alloc_meltpair_st ();
 834             *dst = *src;
 835             melt_forwarded_copy_byte_count += sizeof(*dst);
 836
 837             n = (melt_ptr_t) dst;
 838             break;
 839         }
 840
 841         /*valdesc #17 VALDESC_REAL*/
 842         case MELTOBMAG_REAL:
 843         {
 844             struct meltreal_st*src = (struct meltreal_st*) p;
 845             struct meltreal_st*dst = NULL;
 846             /* from VALDESC_REAL in warmelt-base.melt */
 847             // in file warmelt-base.melt line 3513
 848             /* ggc_alloc_meltreal_st should be gengtype generated for VALDESC_REAL */
 849 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 850 #ifndef ggc_alloc_meltreal_st
 851 #define ggc_alloc_meltreal_st() ((struct meltreal_st *)(ggc_internal_alloc (sizeof (struct meltreal_st))))
 852 #endif
 853 #else /* GCC 4.9 */
 854 #ifndef ggc_alloc_meltreal_st
 855 #define ggc_alloc_meltreal_st() ((struct meltreal_st *)(ggc_internal_alloc_stat (sizeof (struct meltreal_st) MEM_STAT_INFO)))
 856 #endif
 857 #endif /* GCC not 5.0 */
 858             dst =
 859                 /* Don't need a cleared allocation.  */
 860                 ggc_alloc_meltreal_st ();
 861             melt_forwarded_copy_byte_count += sizeof(*dst);
 862             *dst = *src;
 863
 864             n = (melt_ptr_t) dst;
 865             break;
 866         }
 867
 868         /*valdesc #18 VALDESC_ROUTINE*/
 869         case MELTOBMAG_ROUTINE:
 870         {
 871             struct meltroutine_st*src = (struct meltroutine_st*) p;
 872             struct meltroutine_st*dst = NULL;
 873             /* from VALDESC_ROUTINE in warmelt-base.melt */
 874             // in file warmelt-base.melt line 2697
 875             /* ggc_alloc_meltroutine_st should be gengtype generated for VALDESC_ROUTINE */
 876 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 877 #ifndef ggc_alloc_meltroutine_st
 878 #define ggc_alloc_meltroutine_st(SIZE) ((struct meltroutine_st *)(ggc_internal_alloc (SIZE)))
 879 #endif
 880 #else /* GCC 4.9 */
 881 #ifndef ggc_alloc_meltroutine_st
 882 #define ggc_alloc_meltroutine_st(SIZE) ((struct meltroutine_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 883 #endif
 884 #endif /* GCC 4.9 or 5.0 */
 885             int nbv = (int) src->nbval;
 886             size_t sz = nbv*sizeof(void*) + offsetof(struct meltroutine_st, tabval);
 887             int ix = 0;
 888             dst =
 889                 /* Don't need a cleared allocation!  */
 890                 ggc_alloc_meltroutine_st (sz);
 891             melt_forwarded_copy_byte_count += sz;
 892             dst->discr = src->discr;
 893             strncpy (dst->routdescr, src->routdescr, MELT_ROUTDESCR_LEN);
 894             dst->routdescr[MELT_ROUTDESCR_LEN - 1] = 0;
 895             dst->nbval = (unsigned) nbv;
 896             dst->routfunad = src->routfunad;
 897             for (ix = 0;
 898                     ix < nbv;
 899                     ix++)
 900                 dst->tabval[ix] = src->tabval[ix];
 901             dst->routdata = src->routdata;
 902
 903             n = (melt_ptr_t) dst;
 904             break;
 905         }
 906
 907         /*valdesc #19 VALDESC_SPECIAL_DATA*/
 908         case MELTOBMAG_SPECIAL_DATA:
 909         {
 910             struct meltspecialdata_st*src = (struct meltspecialdata_st*) p;
 911             struct meltspecialdata_st*dst = NULL;
 912             /* from VALDESC_SPECIAL_DATA in warmelt-base.melt */
 913             // in file warmelt-base.melt line 3550
 914             /* ggc_alloc_meltspecialdata_st should be gengtype generated for VALDESC_SPECIAL_DATA */
 915 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 916 #ifndef ggc_alloc_meltspecialdata_st
 917 #define ggc_alloc_meltspecialdata_st() ((struct meltspecialdata_st *)(ggc_internal_alloc (sizeof (struct meltspecialdata_st))))
 918 #endif
 919 #else /* GCC 4.9 */
 920 #ifndef ggc_alloc_meltspecialdata_st
 921 #define ggc_alloc_meltspecialdata_st() ((struct meltspecialdata_st *)(ggc_internal_alloc_stat (sizeof (struct meltspecialdata_st) MEM_STAT_INFO)))
 922 #endif
 923 #endif /* GCC not 5.0 */
 924             dst = ggc_alloc_meltspecialdata_st ();
 925             *dst = *src;
 926             /* mark the new copy! */
 927             dst->meltspec_mark = 1;
 928             /* add the new copy to the old (major) special list */
 929             dst->meltspec_next = melt_oldspecdatalist;
 930             melt_oldspecdatalist = dst;
 931             melt_forwarded_copy_byte_count += sizeof(*dst);
 932
 933             n = (melt_ptr_t) dst;
 934             break;
 935         }
 936
 937         /*valdesc #20 VALDESC_STRBUF*/
 938         case MELTOBMAG_STRBUF:
 939         {
 940             struct meltstrbuf_st*src = (struct meltstrbuf_st*) p;
 941             struct meltstrbuf_st*dst = NULL;
 942             /* copy chunk from VALDESC_STRBUF in warmelt-base.melt */
 943             // in file warmelt-base.melt line 3145
 944             /* ggc_alloc_meltstrbuf_st should be gengtype gengtype for VALDESC_STRBUF */
 945 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 946 #ifndef ggc_alloc_meltstrbuf_st
 947 #define ggc_alloc_meltstrbuf_st() ((struct meltstrbuf_st *)(ggc_internal_alloc (sizeof (struct meltstrbuf_st))))
 948 #endif
 949 #else /* GCC 4.9 */
 950 #ifndef ggc_alloc_meltstrbuf_st
 951 #define ggc_alloc_meltstrbuf_st() ((struct meltstrbuf_st *)(ggc_internal_alloc_stat (sizeof (struct meltstrbuf_st) MEM_STAT_INFO)))
 952 #endif
 953 #endif /* GCC not 5.0 */
 954             unsigned blen = melt_primtab[src->buflenix];
 955             size_t sz = sizeof(*dst);
 956             dst =
 957                 /* Don't need a cleared allocation.  */
 958                 ggc_alloc_meltstrbuf_st ();
 959             dst->discr = src->discr;
 960             dst->bufstart = src->bufstart;
 961             dst->bufend = src->bufend;
 962             dst->buflenix = src->buflenix;
 963             if (blen > 0)
 964                 {
 965                     dst->bufzn = CONST_CAST (char *, ggc_alloc_string (src->bufzn, blen+1));
 966                     dst->bufzn[blen] = (char)0;
 967                     sz += blen+1;
 968                 }
 969             else
 970                 dst->bufzn = NULL;
 971             melt_forwarded_copy_byte_count += sz;
 972             /* end copy chunk from VALDESC_STRBUF */
 973
 974             n = (melt_ptr_t) dst;
 975             break;
 976         }
 977
 978         /*valdesc #21 VALDESC_STRING*/
 979         case MELTOBMAG_STRING:
 980         {
 981             struct meltstring_st*src = (struct meltstring_st*) p;
 982             struct meltstring_st*dst = NULL;
 983             /* copy from VALDESC_STRING file warmelt-base.melt */
 984             // in file warmelt-base.melt line 3090
 985             /* ggc_alloc_meltstring_st should be gengtype generated for VALDESC_STRING */
 986 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
 987 #ifndef ggc_alloc_meltstring_st
 988 #define ggc_alloc_meltstring_st(SIZE) ((struct meltstring_st *)(ggc_internal_alloc (SIZE)))
 989 #endif
 990 #else /* GCC 4.9 */
 991 #ifndef ggc_alloc_meltstring_st
 992 #define ggc_alloc_meltstring_st(SIZE) ((struct meltstring_st *)(ggc_internal_alloc_stat (SIZE MEM_STAT_INFO)))
 993 #endif
 994 #endif /* GCC not 5.0 */
 995             int srclen = (src->val)?strlen (src->val):0;
 996             size_t sz = offsetof(struct meltstring_st, val) + (srclen+1);
 997             dst =
 998                 /* Don't need a cleared allocation.  */
 999                 ggc_alloc_meltstring_st  (sz);
1000             melt_forwarded_copy_byte_count += sz;
1001             dst->discr = src->discr;
1002             memcpy (dst->val, src->val, srclen);
1003             dst->val[srclen] = (char)0;
1004             dst->slen = (unsigned) srclen;
1005             /* end copy from VALDESC_STRING */
1006
1007             n = (melt_ptr_t) dst;
1008             break;
1009         }
1010
1011
1012         /* gty ctype forward copy for melt_forwarded_copy */
1013         /*forwcopy gtyctype #1 CTYPE_BASIC_BLOCK generated in warmelt-modes */
1014         case MELTOBMAG_BASICBLOCK:
1015         {
1016             /* macro ggc_alloc_meltbasicblock_st should be generated by gengtype not by runtypesupport_forwcopy */
1017 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1018 #ifndef ggc_alloc_meltbasicblock_st
1019 #define ggc_alloc_meltbasicblock_st() ((struct meltbasicblock_st*)(ggc_internal_alloc (sizeof (struct meltbasicblock_st))))
1020 #endif /* ggc_alloc_meltbasicblock_st */
1021 #else /* GCC 4.9 */
1022 #ifndef ggc_alloc_meltbasicblock_st
1023 #define ggc_alloc_meltbasicblock_st() ((struct meltbasicblock_st*)(ggc_internal_alloc_stat (sizeof (struct meltbasicblock_st) MEM_STAT_INFO)))
1024 #endif /* ggc_alloc_meltbasicblock_st */
1025 #endif /* GCC 4.9 or 5.0 */
1026             struct meltbasicblock_st *src = (struct meltbasicblock_st*) p;
1027             struct meltbasicblock_st *dst = ggc_alloc_meltbasicblock_st ();
1028             *dst = *src;
1029             n = (melt_ptr_t) dst;
1030             break;
1031         }
1032         case MELTOBMAG_MAPBASICBLOCKS:
1033         {
1034             /* ggc_alloc_meltmapbasicblocks_st should be generated by gengtype not by runtypesupport_forwcopy */
1035 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1036 #ifndef ggc_alloc_meltmapbasicblocks_st
1037 #define ggc_alloc_meltmapbasicblocks_st() ((struct meltmapbasicblocks_st*) (ggc_internal_alloc (sizeof (struct meltmapbasicblocks_st))))
1038 #endif /* ggc_alloc_meltmapbasicblocks_st */
1039 #else /* GCC 4.9 */
1040 #ifndef ggc_alloc_meltmapbasicblocks_st
1041 #define ggc_alloc_meltmapbasicblocks_st() ((struct meltmapbasicblocks_st*) (ggc_internal_alloc_stat (sizeof (struct meltmapbasicblocks_st) MEM_STAT_INFO)))
1042 #endif /* ggc_alloc_meltmapbasicblocks_st */
1043 #endif /* GCC 4.9 or 5.0 */
1044
1045             /* ggc_alloc_vec_entrybasicblockmelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1046 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1047 #ifndef ggc_alloc_vec_entrybasicblockmelt_st
1048 #define ggc_alloc_vec_entrybasicblockmelt_st(N) ((struct entrybasicblockmelt_st*) (ggc_internal_alloc (sizeof (struct entrybasicblockmelt_st) * (N))))
1049 #endif
1050 #else /* GCC 4.9 */
1051 #ifndef ggc_alloc_vec_entrybasicblockmelt_st
1052 #define ggc_alloc_vec_entrybasicblockmelt_st(n) ((struct entrybasicblockmelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entrybasicblockmelt_st), n MEM_STAT_INFO)))
1053 #endif
1054 #endif /* GCC 4.9 or 5.0 */
1055             struct meltmapbasicblocks_st *src = (struct meltmapbasicblocks_st*) p;
1056             int siz = melt_primtab[src->lenix];
1057             struct meltmapbasicblocks_st *dst = ggc_alloc_meltmapbasicblocks_st ();
1058             dst->discr = src->discr;
1059             dst->count = src->count;
1060             dst->lenix = src->lenix;
1061             dst->meltmap_aux = src->meltmap_aux;
1062             dst->meltmap_hash = src->meltmap_hash;
1063             if (siz > 0 && src->entab)
1064                 {
1065                     dst->entab = ggc_alloc_vec_entrybasicblockmelt_st (siz);
1066                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1067                 }
1068             else dst->entab = NULL;
1069             n = (melt_ptr_t) dst;
1070             break;
1071         }
1072         /*forwcopy gtyctype #2 CTYPE_BITMAP generated in warmelt-modes */
1073         case MELTOBMAG_BITMAP:
1074         {
1075             /* macro ggc_alloc_meltbitmap_st should be generated by gengtype not by runtypesupport_forwcopy */
1076 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1077 #ifndef ggc_alloc_meltbitmap_st
1078 #define ggc_alloc_meltbitmap_st() ((struct meltbitmap_st*)(ggc_internal_alloc (sizeof (struct meltbitmap_st))))
1079 #endif /* ggc_alloc_meltbitmap_st */
1080 #else /* GCC 4.9 */
1081 #ifndef ggc_alloc_meltbitmap_st
1082 #define ggc_alloc_meltbitmap_st() ((struct meltbitmap_st*)(ggc_internal_alloc_stat (sizeof (struct meltbitmap_st) MEM_STAT_INFO)))
1083 #endif /* ggc_alloc_meltbitmap_st */
1084 #endif /* GCC 4.9 or 5.0 */
1085             struct meltbitmap_st *src = (struct meltbitmap_st*) p;
1086             struct meltbitmap_st *dst = ggc_alloc_meltbitmap_st ();
1087             *dst = *src;
1088             n = (melt_ptr_t) dst;
1089             break;
1090         }
1091         case MELTOBMAG_MAPBITMAPS:
1092         {
1093             /* ggc_alloc_meltmapbitmaps_st should be generated by gengtype not by runtypesupport_forwcopy */
1094 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1095 #ifndef ggc_alloc_meltmapbitmaps_st
1096 #define ggc_alloc_meltmapbitmaps_st() ((struct meltmapbitmaps_st*) (ggc_internal_alloc (sizeof (struct meltmapbitmaps_st))))
1097 #endif /* ggc_alloc_meltmapbitmaps_st */
1098 #else /* GCC 4.9 */
1099 #ifndef ggc_alloc_meltmapbitmaps_st
1100 #define ggc_alloc_meltmapbitmaps_st() ((struct meltmapbitmaps_st*) (ggc_internal_alloc_stat (sizeof (struct meltmapbitmaps_st) MEM_STAT_INFO)))
1101 #endif /* ggc_alloc_meltmapbitmaps_st */
1102 #endif /* GCC 4.9 or 5.0 */
1103
1104             /* ggc_alloc_vec_entrybitmapmelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1105 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1106 #ifndef ggc_alloc_vec_entrybitmapmelt_st
1107 #define ggc_alloc_vec_entrybitmapmelt_st(N) ((struct entrybitmapmelt_st*) (ggc_internal_alloc (sizeof (struct entrybitmapmelt_st) * (N))))
1108 #endif
1109 #else /* GCC 4.9 */
1110 #ifndef ggc_alloc_vec_entrybitmapmelt_st
1111 #define ggc_alloc_vec_entrybitmapmelt_st(n) ((struct entrybitmapmelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entrybitmapmelt_st), n MEM_STAT_INFO)))
1112 #endif
1113 #endif /* GCC 4.9 or 5.0 */
1114             struct meltmapbitmaps_st *src = (struct meltmapbitmaps_st*) p;
1115             int siz = melt_primtab[src->lenix];
1116             struct meltmapbitmaps_st *dst = ggc_alloc_meltmapbitmaps_st ();
1117             dst->discr = src->discr;
1118             dst->count = src->count;
1119             dst->lenix = src->lenix;
1120             dst->meltmap_aux = src->meltmap_aux;
1121             dst->meltmap_hash = src->meltmap_hash;
1122             if (siz > 0 && src->entab)
1123                 {
1124                     dst->entab = ggc_alloc_vec_entrybitmapmelt_st (siz);
1125                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1126                 }
1127             else dst->entab = NULL;
1128             n = (melt_ptr_t) dst;
1129             break;
1130         }
1131         /*forwcopy gtyctype #3 CTYPE_EDGE generated in warmelt-modes */
1132         case MELTOBMAG_EDGE:
1133         {
1134             /* macro ggc_alloc_meltedge_st should be generated by gengtype not by runtypesupport_forwcopy */
1135 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1136 #ifndef ggc_alloc_meltedge_st
1137 #define ggc_alloc_meltedge_st() ((struct meltedge_st*)(ggc_internal_alloc (sizeof (struct meltedge_st))))
1138 #endif /* ggc_alloc_meltedge_st */
1139 #else /* GCC 4.9 */
1140 #ifndef ggc_alloc_meltedge_st
1141 #define ggc_alloc_meltedge_st() ((struct meltedge_st*)(ggc_internal_alloc_stat (sizeof (struct meltedge_st) MEM_STAT_INFO)))
1142 #endif /* ggc_alloc_meltedge_st */
1143 #endif /* GCC 4.9 or 5.0 */
1144             struct meltedge_st *src = (struct meltedge_st*) p;
1145             struct meltedge_st *dst = ggc_alloc_meltedge_st ();
1146             *dst = *src;
1147             n = (melt_ptr_t) dst;
1148             break;
1149         }
1150         case MELTOBMAG_MAPEDGES:
1151         {
1152             /* ggc_alloc_meltmapedges_st should be generated by gengtype not by runtypesupport_forwcopy */
1153 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1154 #ifndef ggc_alloc_meltmapedges_st
1155 #define ggc_alloc_meltmapedges_st() ((struct meltmapedges_st*) (ggc_internal_alloc (sizeof (struct meltmapedges_st))))
1156 #endif /* ggc_alloc_meltmapedges_st */
1157 #else /* GCC 4.9 */
1158 #ifndef ggc_alloc_meltmapedges_st
1159 #define ggc_alloc_meltmapedges_st() ((struct meltmapedges_st*) (ggc_internal_alloc_stat (sizeof (struct meltmapedges_st) MEM_STAT_INFO)))
1160 #endif /* ggc_alloc_meltmapedges_st */
1161 #endif /* GCC 4.9 or 5.0 */
1162
1163             /* ggc_alloc_vec_entryedgemelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1164 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1165 #ifndef ggc_alloc_vec_entryedgemelt_st
1166 #define ggc_alloc_vec_entryedgemelt_st(N) ((struct entryedgemelt_st*) (ggc_internal_alloc (sizeof (struct entryedgemelt_st) * (N))))
1167 #endif
1168 #else /* GCC 4.9 */
1169 #ifndef ggc_alloc_vec_entryedgemelt_st
1170 #define ggc_alloc_vec_entryedgemelt_st(n) ((struct entryedgemelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entryedgemelt_st), n MEM_STAT_INFO)))
1171 #endif
1172 #endif /* GCC 4.9 or 5.0 */
1173             struct meltmapedges_st *src = (struct meltmapedges_st*) p;
1174             int siz = melt_primtab[src->lenix];
1175             struct meltmapedges_st *dst = ggc_alloc_meltmapedges_st ();
1176             dst->discr = src->discr;
1177             dst->count = src->count;
1178             dst->lenix = src->lenix;
1179             dst->meltmap_aux = src->meltmap_aux;
1180             dst->meltmap_hash = src->meltmap_hash;
1181             if (siz > 0 && src->entab)
1182                 {
1183                     dst->entab = ggc_alloc_vec_entryedgemelt_st (siz);
1184                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1185                 }
1186             else dst->entab = NULL;
1187             n = (melt_ptr_t) dst;
1188             break;
1189         }
1190         /*forwcopy gtyctype #4 CTYPE_GIMPLE generated in warmelt-modes */
1191         case MELTOBMAG_GIMPLE:
1192         {
1193             /* macro ggc_alloc_meltgimple_st should be generated by gengtype not by runtypesupport_forwcopy */
1194 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1195 #ifndef ggc_alloc_meltgimple_st
1196 #define ggc_alloc_meltgimple_st() ((struct meltgimple_st*)(ggc_internal_alloc (sizeof (struct meltgimple_st))))
1197 #endif /* ggc_alloc_meltgimple_st */
1198 #else /* GCC 4.9 */
1199 #ifndef ggc_alloc_meltgimple_st
1200 #define ggc_alloc_meltgimple_st() ((struct meltgimple_st*)(ggc_internal_alloc_stat (sizeof (struct meltgimple_st) MEM_STAT_INFO)))
1201 #endif /* ggc_alloc_meltgimple_st */
1202 #endif /* GCC 4.9 or 5.0 */
1203             struct meltgimple_st *src = (struct meltgimple_st*) p;
1204             struct meltgimple_st *dst = ggc_alloc_meltgimple_st ();
1205             *dst = *src;
1206             n = (melt_ptr_t) dst;
1207             break;
1208         }
1209         case MELTOBMAG_MAPGIMPLES:
1210         {
1211             /* ggc_alloc_meltmapgimples_st should be generated by gengtype not by runtypesupport_forwcopy */
1212 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1213 #ifndef ggc_alloc_meltmapgimples_st
1214 #define ggc_alloc_meltmapgimples_st() ((struct meltmapgimples_st*) (ggc_internal_alloc (sizeof (struct meltmapgimples_st))))
1215 #endif /* ggc_alloc_meltmapgimples_st */
1216 #else /* GCC 4.9 */
1217 #ifndef ggc_alloc_meltmapgimples_st
1218 #define ggc_alloc_meltmapgimples_st() ((struct meltmapgimples_st*) (ggc_internal_alloc_stat (sizeof (struct meltmapgimples_st) MEM_STAT_INFO)))
1219 #endif /* ggc_alloc_meltmapgimples_st */
1220 #endif /* GCC 4.9 or 5.0 */
1221
1222             /* ggc_alloc_vec_entrygimplemelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1223 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1224 #ifndef ggc_alloc_vec_entrygimplemelt_st
1225 #define ggc_alloc_vec_entrygimplemelt_st(N) ((struct entrygimplemelt_st*) (ggc_internal_alloc (sizeof (struct entrygimplemelt_st) * (N))))
1226 #endif
1227 #else /* GCC 4.9 */
1228 #ifndef ggc_alloc_vec_entrygimplemelt_st
1229 #define ggc_alloc_vec_entrygimplemelt_st(n) ((struct entrygimplemelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entrygimplemelt_st), n MEM_STAT_INFO)))
1230 #endif
1231 #endif /* GCC 4.9 or 5.0 */
1232             struct meltmapgimples_st *src = (struct meltmapgimples_st*) p;
1233             int siz = melt_primtab[src->lenix];
1234             struct meltmapgimples_st *dst = ggc_alloc_meltmapgimples_st ();
1235             dst->discr = src->discr;
1236             dst->count = src->count;
1237             dst->lenix = src->lenix;
1238             dst->meltmap_aux = src->meltmap_aux;
1239             dst->meltmap_hash = src->meltmap_hash;
1240             if (siz > 0 && src->entab)
1241                 {
1242                     dst->entab = ggc_alloc_vec_entrygimplemelt_st (siz);
1243                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1244                 }
1245             else dst->entab = NULL;
1246             n = (melt_ptr_t) dst;
1247             break;
1248         }
1249         /*forwcopy gtyctype #5 CTYPE_GIMPLE_SEQ generated in warmelt-modes */
1250         case MELTOBMAG_GIMPLESEQ:
1251         {
1252             /* macro ggc_alloc_meltgimpleseq_st should be generated by gengtype not by runtypesupport_forwcopy */
1253 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1254 #ifndef ggc_alloc_meltgimpleseq_st
1255 #define ggc_alloc_meltgimpleseq_st() ((struct meltgimpleseq_st*)(ggc_internal_alloc (sizeof (struct meltgimpleseq_st))))
1256 #endif /* ggc_alloc_meltgimpleseq_st */
1257 #else /* GCC 4.9 */
1258 #ifndef ggc_alloc_meltgimpleseq_st
1259 #define ggc_alloc_meltgimpleseq_st() ((struct meltgimpleseq_st*)(ggc_internal_alloc_stat (sizeof (struct meltgimpleseq_st) MEM_STAT_INFO)))
1260 #endif /* ggc_alloc_meltgimpleseq_st */
1261 #endif /* GCC 4.9 or 5.0 */
1262             struct meltgimpleseq_st *src = (struct meltgimpleseq_st*) p;
1263             struct meltgimpleseq_st *dst = ggc_alloc_meltgimpleseq_st ();
1264             *dst = *src;
1265             n = (melt_ptr_t) dst;
1266             break;
1267         }
1268         case MELTOBMAG_MAPGIMPLESEQS:
1269         {
1270             /* ggc_alloc_meltmapgimpleseqs_st should be generated by gengtype not by runtypesupport_forwcopy */
1271 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1272 #ifndef ggc_alloc_meltmapgimpleseqs_st
1273 #define ggc_alloc_meltmapgimpleseqs_st() ((struct meltmapgimpleseqs_st*) (ggc_internal_alloc (sizeof (struct meltmapgimpleseqs_st))))
1274 #endif /* ggc_alloc_meltmapgimpleseqs_st */
1275 #else /* GCC 4.9 */
1276 #ifndef ggc_alloc_meltmapgimpleseqs_st
1277 #define ggc_alloc_meltmapgimpleseqs_st() ((struct meltmapgimpleseqs_st*) (ggc_internal_alloc_stat (sizeof (struct meltmapgimpleseqs_st) MEM_STAT_INFO)))
1278 #endif /* ggc_alloc_meltmapgimpleseqs_st */
1279 #endif /* GCC 4.9 or 5.0 */
1280
1281             /* ggc_alloc_vec_entrygimpleseqmelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1282 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1283 #ifndef ggc_alloc_vec_entrygimpleseqmelt_st
1284 #define ggc_alloc_vec_entrygimpleseqmelt_st(N) ((struct entrygimpleseqmelt_st*) (ggc_internal_alloc (sizeof (struct entrygimpleseqmelt_st) * (N))))
1285 #endif
1286 #else /* GCC 4.9 */
1287 #ifndef ggc_alloc_vec_entrygimpleseqmelt_st
1288 #define ggc_alloc_vec_entrygimpleseqmelt_st(n) ((struct entrygimpleseqmelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entrygimpleseqmelt_st), n MEM_STAT_INFO)))
1289 #endif
1290 #endif /* GCC 4.9 or 5.0 */
1291             struct meltmapgimpleseqs_st *src = (struct meltmapgimpleseqs_st*) p;
1292             int siz = melt_primtab[src->lenix];
1293             struct meltmapgimpleseqs_st *dst = ggc_alloc_meltmapgimpleseqs_st ();
1294             dst->discr = src->discr;
1295             dst->count = src->count;
1296             dst->lenix = src->lenix;
1297             dst->meltmap_aux = src->meltmap_aux;
1298             dst->meltmap_hash = src->meltmap_hash;
1299             if (siz > 0 && src->entab)
1300                 {
1301                     dst->entab = ggc_alloc_vec_entrygimpleseqmelt_st (siz);
1302                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1303                 }
1304             else dst->entab = NULL;
1305             n = (melt_ptr_t) dst;
1306             break;
1307         }
1308         /*forwcopy gtyctype #6 CTYPE_LOOP generated in warmelt-modes */
1309         case MELTOBMAG_LOOP:
1310         {
1311             /* macro ggc_alloc_meltloop_st should be generated by gengtype not by runtypesupport_forwcopy */
1312 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1313 #ifndef ggc_alloc_meltloop_st
1314 #define ggc_alloc_meltloop_st() ((struct meltloop_st*)(ggc_internal_alloc (sizeof (struct meltloop_st))))
1315 #endif /* ggc_alloc_meltloop_st */
1316 #else /* GCC 4.9 */
1317 #ifndef ggc_alloc_meltloop_st
1318 #define ggc_alloc_meltloop_st() ((struct meltloop_st*)(ggc_internal_alloc_stat (sizeof (struct meltloop_st) MEM_STAT_INFO)))
1319 #endif /* ggc_alloc_meltloop_st */
1320 #endif /* GCC 4.9 or 5.0 */
1321             struct meltloop_st *src = (struct meltloop_st*) p;
1322             struct meltloop_st *dst = ggc_alloc_meltloop_st ();
1323             *dst = *src;
1324             n = (melt_ptr_t) dst;
1325             break;
1326         }
1327         case MELTOBMAG_MAPLOOPS:
1328         {
1329             /* ggc_alloc_meltmaploops_st should be generated by gengtype not by runtypesupport_forwcopy */
1330 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1331 #ifndef ggc_alloc_meltmaploops_st
1332 #define ggc_alloc_meltmaploops_st() ((struct meltmaploops_st*) (ggc_internal_alloc (sizeof (struct meltmaploops_st))))
1333 #endif /* ggc_alloc_meltmaploops_st */
1334 #else /* GCC 4.9 */
1335 #ifndef ggc_alloc_meltmaploops_st
1336 #define ggc_alloc_meltmaploops_st() ((struct meltmaploops_st*) (ggc_internal_alloc_stat (sizeof (struct meltmaploops_st) MEM_STAT_INFO)))
1337 #endif /* ggc_alloc_meltmaploops_st */
1338 #endif /* GCC 4.9 or 5.0 */
1339
1340             /* ggc_alloc_vec_entryloopmelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1341 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1342 #ifndef ggc_alloc_vec_entryloopmelt_st
1343 #define ggc_alloc_vec_entryloopmelt_st(N) ((struct entryloopmelt_st*) (ggc_internal_alloc (sizeof (struct entryloopmelt_st) * (N))))
1344 #endif
1345 #else /* GCC 4.9 */
1346 #ifndef ggc_alloc_vec_entryloopmelt_st
1347 #define ggc_alloc_vec_entryloopmelt_st(n) ((struct entryloopmelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entryloopmelt_st), n MEM_STAT_INFO)))
1348 #endif
1349 #endif /* GCC 4.9 or 5.0 */
1350             struct meltmaploops_st *src = (struct meltmaploops_st*) p;
1351             int siz = melt_primtab[src->lenix];
1352             struct meltmaploops_st *dst = ggc_alloc_meltmaploops_st ();
1353             dst->discr = src->discr;
1354             dst->count = src->count;
1355             dst->lenix = src->lenix;
1356             dst->meltmap_aux = src->meltmap_aux;
1357             dst->meltmap_hash = src->meltmap_hash;
1358             if (siz > 0 && src->entab)
1359                 {
1360                     dst->entab = ggc_alloc_vec_entryloopmelt_st (siz);
1361                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1362                 }
1363             else dst->entab = NULL;
1364             n = (melt_ptr_t) dst;
1365             break;
1366         }
1367         /*forwcopy gtyctype #7 CTYPE_RTVEC generated in warmelt-modes */
1368         case MELTOBMAG_RTVEC:
1369         {
1370             /* macro ggc_alloc_meltrtvec_st should be generated by gengtype not by runtypesupport_forwcopy */
1371 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1372 #ifndef ggc_alloc_meltrtvec_st
1373 #define ggc_alloc_meltrtvec_st() ((struct meltrtvec_st*)(ggc_internal_alloc (sizeof (struct meltrtvec_st))))
1374 #endif /* ggc_alloc_meltrtvec_st */
1375 #else /* GCC 4.9 */
1376 #ifndef ggc_alloc_meltrtvec_st
1377 #define ggc_alloc_meltrtvec_st() ((struct meltrtvec_st*)(ggc_internal_alloc_stat (sizeof (struct meltrtvec_st) MEM_STAT_INFO)))
1378 #endif /* ggc_alloc_meltrtvec_st */
1379 #endif /* GCC 4.9 or 5.0 */
1380             struct meltrtvec_st *src = (struct meltrtvec_st*) p;
1381             struct meltrtvec_st *dst = ggc_alloc_meltrtvec_st ();
1382             *dst = *src;
1383             n = (melt_ptr_t) dst;
1384             break;
1385         }
1386         case MELTOBMAG_MAPRTVECS:
1387         {
1388             /* ggc_alloc_meltmaprtvecs_st should be generated by gengtype not by runtypesupport_forwcopy */
1389 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1390 #ifndef ggc_alloc_meltmaprtvecs_st
1391 #define ggc_alloc_meltmaprtvecs_st() ((struct meltmaprtvecs_st*) (ggc_internal_alloc (sizeof (struct meltmaprtvecs_st))))
1392 #endif /* ggc_alloc_meltmaprtvecs_st */
1393 #else /* GCC 4.9 */
1394 #ifndef ggc_alloc_meltmaprtvecs_st
1395 #define ggc_alloc_meltmaprtvecs_st() ((struct meltmaprtvecs_st*) (ggc_internal_alloc_stat (sizeof (struct meltmaprtvecs_st) MEM_STAT_INFO)))
1396 #endif /* ggc_alloc_meltmaprtvecs_st */
1397 #endif /* GCC 4.9 or 5.0 */
1398
1399             /* ggc_alloc_vec_entryrtvecmelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1400 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1401 #ifndef ggc_alloc_vec_entryrtvecmelt_st
1402 #define ggc_alloc_vec_entryrtvecmelt_st(N) ((struct entryrtvecmelt_st*) (ggc_internal_alloc (sizeof (struct entryrtvecmelt_st) * (N))))
1403 #endif
1404 #else /* GCC 4.9 */
1405 #ifndef ggc_alloc_vec_entryrtvecmelt_st
1406 #define ggc_alloc_vec_entryrtvecmelt_st(n) ((struct entryrtvecmelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entryrtvecmelt_st), n MEM_STAT_INFO)))
1407 #endif
1408 #endif /* GCC 4.9 or 5.0 */
1409             struct meltmaprtvecs_st *src = (struct meltmaprtvecs_st*) p;
1410             int siz = melt_primtab[src->lenix];
1411             struct meltmaprtvecs_st *dst = ggc_alloc_meltmaprtvecs_st ();
1412             dst->discr = src->discr;
1413             dst->count = src->count;
1414             dst->lenix = src->lenix;
1415             dst->meltmap_aux = src->meltmap_aux;
1416             dst->meltmap_hash = src->meltmap_hash;
1417             if (siz > 0 && src->entab)
1418                 {
1419                     dst->entab = ggc_alloc_vec_entryrtvecmelt_st (siz);
1420                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1421                 }
1422             else dst->entab = NULL;
1423             n = (melt_ptr_t) dst;
1424             break;
1425         }
1426         /*forwcopy gtyctype #8 CTYPE_RTX generated in warmelt-modes */
1427         case MELTOBMAG_RTX:
1428         {
1429             /* macro ggc_alloc_meltrtx_st should be generated by gengtype not by runtypesupport_forwcopy */
1430 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1431 #ifndef ggc_alloc_meltrtx_st
1432 #define ggc_alloc_meltrtx_st() ((struct meltrtx_st*)(ggc_internal_alloc (sizeof (struct meltrtx_st))))
1433 #endif /* ggc_alloc_meltrtx_st */
1434 #else /* GCC 4.9 */
1435 #ifndef ggc_alloc_meltrtx_st
1436 #define ggc_alloc_meltrtx_st() ((struct meltrtx_st*)(ggc_internal_alloc_stat (sizeof (struct meltrtx_st) MEM_STAT_INFO)))
1437 #endif /* ggc_alloc_meltrtx_st */
1438 #endif /* GCC 4.9 or 5.0 */
1439             struct meltrtx_st *src = (struct meltrtx_st*) p;
1440             struct meltrtx_st *dst = ggc_alloc_meltrtx_st ();
1441             *dst = *src;
1442             n = (melt_ptr_t) dst;
1443             break;
1444         }
1445         case MELTOBMAG_MAPRTXS:
1446         {
1447             /* ggc_alloc_meltmaprtxs_st should be generated by gengtype not by runtypesupport_forwcopy */
1448 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1449 #ifndef ggc_alloc_meltmaprtxs_st
1450 #define ggc_alloc_meltmaprtxs_st() ((struct meltmaprtxs_st*) (ggc_internal_alloc (sizeof (struct meltmaprtxs_st))))
1451 #endif /* ggc_alloc_meltmaprtxs_st */
1452 #else /* GCC 4.9 */
1453 #ifndef ggc_alloc_meltmaprtxs_st
1454 #define ggc_alloc_meltmaprtxs_st() ((struct meltmaprtxs_st*) (ggc_internal_alloc_stat (sizeof (struct meltmaprtxs_st) MEM_STAT_INFO)))
1455 #endif /* ggc_alloc_meltmaprtxs_st */
1456 #endif /* GCC 4.9 or 5.0 */
1457
1458             /* ggc_alloc_vec_entryrtxmelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1459 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1460 #ifndef ggc_alloc_vec_entryrtxmelt_st
1461 #define ggc_alloc_vec_entryrtxmelt_st(N) ((struct entryrtxmelt_st*) (ggc_internal_alloc (sizeof (struct entryrtxmelt_st) * (N))))
1462 #endif
1463 #else /* GCC 4.9 */
1464 #ifndef ggc_alloc_vec_entryrtxmelt_st
1465 #define ggc_alloc_vec_entryrtxmelt_st(n) ((struct entryrtxmelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entryrtxmelt_st), n MEM_STAT_INFO)))
1466 #endif
1467 #endif /* GCC 4.9 or 5.0 */
1468             struct meltmaprtxs_st *src = (struct meltmaprtxs_st*) p;
1469             int siz = melt_primtab[src->lenix];
1470             struct meltmaprtxs_st *dst = ggc_alloc_meltmaprtxs_st ();
1471             dst->discr = src->discr;
1472             dst->count = src->count;
1473             dst->lenix = src->lenix;
1474             dst->meltmap_aux = src->meltmap_aux;
1475             dst->meltmap_hash = src->meltmap_hash;
1476             if (siz > 0 && src->entab)
1477                 {
1478                     dst->entab = ggc_alloc_vec_entryrtxmelt_st (siz);
1479                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1480                 }
1481             else dst->entab = NULL;
1482             n = (melt_ptr_t) dst;
1483             break;
1484         }
1485         /*forwcopy gtyctype #9 CTYPE_TREE generated in warmelt-modes */
1486         case MELTOBMAG_TREE:
1487         {
1488             /* macro ggc_alloc_melttree_st should be generated by gengtype not by runtypesupport_forwcopy */
1489 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1490 #ifndef ggc_alloc_melttree_st
1491 #define ggc_alloc_melttree_st() ((struct melttree_st*)(ggc_internal_alloc (sizeof (struct melttree_st))))
1492 #endif /* ggc_alloc_melttree_st */
1493 #else /* GCC 4.9 */
1494 #ifndef ggc_alloc_melttree_st
1495 #define ggc_alloc_melttree_st() ((struct melttree_st*)(ggc_internal_alloc_stat (sizeof (struct melttree_st) MEM_STAT_INFO)))
1496 #endif /* ggc_alloc_melttree_st */
1497 #endif /* GCC 4.9 or 5.0 */
1498             struct melttree_st *src = (struct melttree_st*) p;
1499             struct melttree_st *dst = ggc_alloc_melttree_st ();
1500             *dst = *src;
1501             n = (melt_ptr_t) dst;
1502             break;
1503         }
1504         case MELTOBMAG_MAPTREES:
1505         {
1506             /* ggc_alloc_meltmaptrees_st should be generated by gengtype not by runtypesupport_forwcopy */
1507 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1508 #ifndef ggc_alloc_meltmaptrees_st
1509 #define ggc_alloc_meltmaptrees_st() ((struct meltmaptrees_st*) (ggc_internal_alloc (sizeof (struct meltmaptrees_st))))
1510 #endif /* ggc_alloc_meltmaptrees_st */
1511 #else /* GCC 4.9 */
1512 #ifndef ggc_alloc_meltmaptrees_st
1513 #define ggc_alloc_meltmaptrees_st() ((struct meltmaptrees_st*) (ggc_internal_alloc_stat (sizeof (struct meltmaptrees_st) MEM_STAT_INFO)))
1514 #endif /* ggc_alloc_meltmaptrees_st */
1515 #endif /* GCC 4.9 or 5.0 */
1516
1517             /* ggc_alloc_vec_entrytreemelt_st should be generated by gengtype not by runtypesupport_forwcopy */
1518 #if GCCPLUGIN_VERSION >= 5000 /* GCC 5.0 */
1519 #ifndef ggc_alloc_vec_entrytreemelt_st
1520 #define ggc_alloc_vec_entrytreemelt_st(N) ((struct entrytreemelt_st*) (ggc_internal_alloc (sizeof (struct entrytreemelt_st) * (N))))
1521 #endif
1522 #else /* GCC 4.9 */
1523 #ifndef ggc_alloc_vec_entrytreemelt_st
1524 #define ggc_alloc_vec_entrytreemelt_st(n) ((struct entrytreemelt_st*) (ggc_internal_vec_alloc_stat (sizeof (struct entrytreemelt_st), n MEM_STAT_INFO)))
1525 #endif
1526 #endif /* GCC 4.9 or 5.0 */
1527             struct meltmaptrees_st *src = (struct meltmaptrees_st*) p;
1528             int siz = melt_primtab[src->lenix];
1529             struct meltmaptrees_st *dst = ggc_alloc_meltmaptrees_st ();
1530             dst->discr = src->discr;
1531             dst->count = src->count;
1532             dst->lenix = src->lenix;
1533             dst->meltmap_aux = src->meltmap_aux;
1534             dst->meltmap_hash = src->meltmap_hash;
1535             if (siz > 0 && src->entab)
1536                 {
1537                     dst->entab = ggc_alloc_vec_entrytreemelt_st (siz);
1538                     memcpy (dst->entab, src->entab, siz * sizeof (dst->entab[0]));
1539                 }
1540             else dst->entab = NULL;
1541             n = (melt_ptr_t) dst;
1542             break;
1543         }
1544         /* trailer generated by generate_runtypesupport_forwcopy_fun  */
1545         default:
1546             melt_fatal_error ("MELT corruption: forward invalid p=%p discr=%p magic=%d [%s]",
1547                               (void *) p, (void *) p->u_discr, mag, melt_obmag_string (mag));
1548         } /* end switch (mag) */
1549
1550     melt_debuggc_eprintf ("melt_forwarded_copy#%ld/%04ld %p => %p %s",
1551                           melt_nb_garbcoll, melt_forward_counter, (void*)p,
1552                           (void*)n, melt_obmag_string (mag));
1553     if (n)
1554         {
1555 #if ENABLE_CHECKING
1556             if (melt_alptr_1 && (void*)melt_alptr_1 == (void*)n)
1557                 {
1558                     fprintf (stderr, "melt_forwarded_copy to alptr_1 %p mag %d\n",  melt_alptr_1, mag);
1559                     fflush (stderr);
1560                     melt_debuggc_eprintf("melt_forwarded_copy #%ld alptr_1 %p mag %d",
1561                                          melt_nb_garbcoll, melt_alptr_1, mag);
1562                     melt_break_alptr_1 ("forwarded copy to alptr_1");
1563                 }
1564             if (melt_alptr_2 && (void*)melt_alptr_2 == (void*)n)
1565                 {
1566                     fprintf (stderr, "melt_forwarded_copy to alptr_2 %p mag %d\n",  melt_alptr_2, mag);
1567                     fflush (stderr);
1568                     melt_debuggc_eprintf("melt_forwarded_copy #%ld alptr_2 %p",
1569                                          melt_nb_garbcoll, melt_alptr_2);
1570                     melt_break_alptr_2 ("forwarded copy to alptr_2");
1571                 };
1572 #endif /*ENABLE_CHECKING*/
1573
1574             p->u_forward.discr = MELT_FORWARDED_DISCR;
1575             p->u_forward.forward = n;
1576
1577             gcc_assert (melt_scangcvect != NULL);
1578             {
1579                 unsigned long ulen = melt_scangcvect->vv_ulen;
1580                 if (MELT_UNLIKELY(ulen + 3 < melt_scangcvect->vv_size))
1581                     {
1582                         unsigned long newsiz = (ulen + ulen/4 + 100);
1583                         melt_resize_scangcvect (newsiz);
1584                     }
1585                 melt_scangcvect->vv_tab[ulen] = n;
1586                 melt_scangcvect->vv_ulen = ulen+1;
1587             }
1588
1589         }
1590     return n;
1591 }  /* end of melt_forwarded_copy generated by generate_runtypesupport_forwcopy_fun */
1592
1593 /** end of code generated by generate_runtypesupport_forwcopy_fun **/
1594
1595
1596
1597 /** start of code generated by generate_runtypesupport_scanning **/
1598 /* header from generate_runtypesupport_scanning */
1599 /* The melt_scanning routine is mostly Chesney like ; however some types,
1600    including objects, strbuf, stringmaps, objectmaps, all the other
1601    *maps, contain a pointer to a non value ; this pointer should be
1602    carefully updated if it was young. */
1603 static void
1604 melt_scanning (melt_ptr_t p)
1605 {
1606     unsigned omagic = 0;
1607     if (!p)
1608         return;
1609     gcc_assert (p != (void *) HTAB_DELETED_ENTRY);
1610     gcc_assert (p->u_discr && p->u_discr != (meltobject_ptr_t) 1);
1611     MELT_FORWARDED (p->u_discr);
1612     gcc_assert (!melt_is_young (p));
1613     omagic = p->u_discr->meltobj_magic;
1614     switch (omagic)
1615         {
1616             /* end of header from generate_runtypesupport_scanning*/
1617
1618             /*valdesc #1 VALDESC_BUCKETLONGS*/
1619         case MELTOBMAG_BUCKETLONGS:
1620         {
1621             struct meltbucketlongs_st*src = (struct meltbucketlongs_st*) p;
1622             /* forwarding chunk from VALDESC_BUCKETLONGS in warmelt-base.melt */
1623             // in file warmelt-base.melt line 2917
1624             unsigned lnix = src->buckl_lenix;
1625             unsigned len = melt_primtab[lnix];
1626             unsigned ucnt = src->buckl_ucount;
1627             unsigned ix = 0;
1628             gcc_assert (lnix > 0);
1629             gcc_assert (len > 0);
1630             MELT_FORWARDED (src->buckl_aux);
1631             gcc_assert (ucnt <= len);
1632             for (ix = 0;
1633                     ix < ucnt;
1634                     ix++)
1635                 MELT_FORWARDED (src->buckl_entab[ix].ebl_va);
1636             /* end forwarding VALDESC_BUCKETLONGS */
1637
1638             break;
1639         }
1640
1641         /*valdesc #2 VALDESC_CLOSURE*/
1642         case MELTOBMAG_CLOSURE:
1643         {
1644             struct meltclosure_st*src = (struct meltclosure_st*) p;
1645             /* forwarding from VALDESC_CLOSURE in warmelt-base.melt */
1646             // in file warmelt-base.melt line 2632
1647             int nbval = (int) src->nbval;
1648             MELT_FORWARDED (src->rout);
1649             for (int ix = 0;
1650                     ix < nbval;
1651                     ix++)
1652                 MELT_FORWARDED (src->tabval[ix]);
1653
1654             break;
1655         }
1656
1657         /*valdesc #3 VALDESC_DECAY*/
1658         case MELTOBMAG_DECAY:
1659         {
1660             struct meltdecay_st*src = (struct meltdecay_st*) p;
1661             /* from VALDESC_DECAY  in warmelt-base.melt */
1662             // in file warmelt-base.melt line 2501
1663             MELT_FORWARDED (src->val);
1664
1665             break;
1666         }
1667
1668         /*valdesc #4 VALDESC_DOUBLE*/
1669         case MELTOBMAG_DOUBLE:
1670         {
1671             break;
1672         }
1673
1674         /*valdesc #5 VALDESC_HOOK*/
1675         case MELTOBMAG_HOOK:
1676         {
1677             struct melthook_st*src = (struct melthook_st*) p;
1678             /* from VALDESC_HOOK in warmelt-base.melt */
1679             // in file warmelt-base.melt line 2808
1680             int nbval = (int) src->nbval;
1681             int ix = 0;
1682             for (ix = 0;
1683                     ix < nbval;
1684                     ix++)
1685                 MELT_FORWARDED (src->tabval[ix]);
1686             MELT_FORWARDED (src->hookdata);
1687
1688             break;
1689         }
1690
1691         /*valdesc #6 VALDESC_INT*/
1692         case MELTOBMAG_INT:
1693         {
1694             break;
1695         }
1696
1697         /*valdesc #7 VALDESC_JSONOBJECT*/
1698         case MELTOBMAG_JSONOBJECT:
1699         {
1700             struct meltjsonobject_st*src = (struct meltjsonobject_st*) p;
1701             /* forwarding chunk from VALDESC_JSONOBJECT in warmelt-base.melt */
1702             // in file warmelt-base.melt line 3054
1703             unsigned srcsize = src->jsob_size;
1704             MELT_FORWARDED(src->jsob_aux);
1705             for (unsigned ix = 0;
1706                     ix < srcsize;
1707                     ix++)
1708                 {
1709                     MELT_FORWARDED(src->jsob_entab[ix].jsonob_name);
1710                     MELT_FORWARDED(src->jsob_entab[ix].jsonob_val);
1711                 };
1712             /* end forwarding chunk VALDESC_JSONOBJECT */
1713
1714             break;
1715         }
1716
1717         /*valdesc #8 VALDESC_LIST*/
1718         case MELTOBMAG_LIST:
1719         {
1720             struct meltlist_st*src = (struct meltlist_st*) p;
1721             /* from VALDESC_LIST in warmelt-base.melt */
1722             // in file warmelt-base.melt line 3289
1723             MELT_FORWARDED (src->first);
1724             MELT_FORWARDED (src->last);
1725
1726             break;
1727         }
1728
1729         /*valdesc #9 VALDESC_MAPOBJECTS*/
1730         case MELTOBMAG_MAPOBJECTS:
1731         {
1732             struct meltmapobjects_st*src = (struct meltmapobjects_st*) p;
1733             /* forwarding from VALDESC_MAPOBJECTS in warmelt-base.melt */
1734             // in file warmelt-base.melt line 2307
1735             int siz, ix;
1736             MELT_FORWARDED(src->meltmap_aux);
1737             if (!src->entab)
1738                 break;
1739             siz = melt_primtab[src->lenix];
1740             gcc_assert (siz > 0);
1741             if (melt_is_young (src->entab))
1742                 {
1743                     struct entryobjectsmelt_st *newtab =
1744                     /* Don't need a cleared allocation!  */
1745                     ggc_alloc_vec_entryobjectsmelt_st (siz);
1746                     memcpy (newtab, src->entab,
1747                             siz * sizeof (struct entryobjectsmelt_st));
1748                     src->entab = newtab;
1749                 }
1750             for (ix = 0;
1751                     ix < siz;
1752                     ix++)
1753                 {
1754                     meltobject_ptr_t at = src->entab[ix].e_at;
1755                     if (!at || at == (void *) HTAB_DELETED_ENTRY)
1756                         {
1757                             src->entab[ix].e_va = NULL;
1758                             continue;
1759                         }
1760                     MELT_FORWARDED (at);
1761                     src->entab[ix].e_at = at;
1762                     MELT_FORWARDED (src->entab[ix].e_va);
1763                 }
1764             /* end forwarding from VALDESC_MAPOBJECTS */
1765
1766             break;
1767         }
1768
1769         /*valdesc #10 VALDESC_MAPSTRINGS*/
1770         case MELTOBMAG_MAPSTRINGS:
1771         {
1772             struct meltmapstrings_st*src = (struct meltmapstrings_st*) p;
1773             /* forwarding from VALDESC_MAPSTRINGS  in warmelt-base.melt */
1774             // in file warmelt-base.melt line 2433
1775             int ix, siz;
1776             MELT_FORWARDED(src->meltmap_aux);
1777             if (!src->entab)
1778                 break;
1779             siz = melt_primtab[src->lenix];
1780             gcc_assert (siz > 0);
1781             if (melt_is_young (src->entab))
1782                 {
1783                     struct entrystringsmelt_st *newtab
1784                 /* Don't need a cleared allocation!  */
1785                     = ggc_alloc_vec_entrystringsmelt_st (siz);
1786                     memcpy (newtab, src->entab,
1787                             siz * sizeof (struct entrystringsmelt_st));
1788                     src->entab = newtab;
1789                 }
1790             for (ix = 0;
1791                     ix < siz;
1792                     ix++)
1793                 {
1794                     const char *at = src->entab[ix].e_at;
1795                     if (!at || at == (void *) HTAB_DELETED_ENTRY)
1796                         {
1797                             src->entab[ix].e_va = NULL;
1798                             continue;
1799                         }
1800                     if (melt_is_young ((const void *) at))
1801                         src->entab[ix].e_at = (const char *) ggc_strdup (at);
1802                     MELT_FORWARDED (src->entab[ix].e_va);
1803                 }
1804             /* end  forwarding from VALDESC_MAPSTRINGS */
1805
1806             break;
1807         }
1808
1809         /*valdesc #11 VALDESC_MIXBIGINT*/
1810         case MELTOBMAG_MIXBIGINT:
1811         {
1812             struct meltmixbigint_st*src = (struct meltmixbigint_st*) p;
1813             /* from VALDESC_MIXBIGINT file warmelt-base.melt */
1814             // in file warmelt-base.melt line 3494
1815             MELT_FORWARDED (src->ptrval);
1816
1817             break;
1818         }
1819
1820         /*valdesc #12 VALDESC_MIXINT*/
1821         case MELTOBMAG_MIXINT:
1822         {
1823             struct meltmixint_st*src = (struct meltmixint_st*) p;
1824             /* from VALDESC_MIXINT file warmelt-base.melt */
1825             MELT_FORWARDED (src->ptrval);
1826
1827             break;
1828         }
1829
1830         /*valdesc #13 VALDESC_MIXLOC*/
1831         case MELTOBMAG_MIXLOC:
1832         {
1833             struct meltmixloc_st*src = (struct meltmixloc_st*) p;
1834             /* from VALDESC_MIXLOC file warmelt-base.melt */
1835             // in file warmelt-base.melt line 3445
1836             MELT_FORWARDED (src->ptrval);
1837
1838             break;
1839         }
1840
1841         /*valdesc #14 VALDESC_MULTIPLE*/
1842         case MELTOBMAG_MULTIPLE:
1843         {
1844             struct meltmultiple_st*src = (struct meltmultiple_st*) p;
1845             /* forwarding chunk from VALDESC_MULTIPLE in warmelt-base.melt */
1846             // in file warmelt-base.melt line 2573
1847             int nbval = (int) src->nbval;
1848             for (int ix = 0;
1849                     ix < nbval;
1850                     ix++)
1851                 MELT_FORWARDED (src->tabval[ix]);
1852             /* end forwarding chunk from VALDESC_MULTIPLE */
1853
1854             break;
1855         }
1856
1857         /*valdesc #15 VALDESC_OBJECT*/
1858         case MELTOBMAG_OBJECT:
1859         {
1860             struct meltobject_st*src = (struct meltobject_st*) p;
1861             /* from VALDESC_OBJECT */
1862             // in file warmelt-base.melt line 2187
1863             int ix = 0;
1864             int oblen = (int) (src->obj_len);
1865             for (ix = 0; ix < oblen; ix++)
1866                 MELT_FORWARDED (src->obj_vartab[ix]);
1867 #if ENABLE_CHECKING
1868             /* for low level debugging with gdb, we may want to catch some forwarding operations */
1869             if (melt_alptr_1 && (void*) src == melt_alptr_1)
1870                 melt_break_alptr_1 ("forwardobj src=alptr1");
1871             if (melt_alptr_2 && (void*) src == melt_alptr_2)
1872                 melt_break_alptr_2 ("forwardobj src=alptr2");
1873             if (src->obj_hash == melt_objhash_1)
1874                 melt_break_objhash_1("forwardobj src with objhash1");
1875             if (src->obj_hash == melt_objhash_2)
1876                 melt_break_objhash_2("forwardobj src with objhash2");
1877 #endif /* ENABLE_CHECKING */
1878
1879             break;
1880         }
1881
1882         /*valdesc #16 VALDESC_PAIR*/
1883         case MELTOBMAG_PAIR:
1884         {
1885             struct meltpair_st*src = (struct meltpair_st*) p;
1886             /* forward VALDESC_PAIR in warmelt-base.melt */
1887             // in file warmelt-base.melt line 3225
1888             MELT_FORWARDED (src->hd);
1889             MELT_FORWARDED (src->tl);
1890
1891             break;
1892         }
1893
1894         /*valdesc #17 VALDESC_REAL*/
1895         case MELTOBMAG_REAL:
1896         {
1897             break;
1898         }
1899
1900         /*valdesc #18 VALDESC_ROUTINE*/
1901         case MELTOBMAG_ROUTINE:
1902         {
1903             struct meltroutine_st*src = (struct meltroutine_st*) p;
1904             /* from VALDESC_ROUTINE in warmelt-base.melt */
1905             // in file warmelt-base.melt line 2728
1906             int nbval = (int) src->nbval;
1907             for (int ix = 0;
1908                     ix < nbval;
1909                     ix++)
1910                 MELT_FORWARDED (src->tabval[ix]);
1911             MELT_FORWARDED (src->routdata);
1912
1913             break;
1914         }
1915
1916         /*valdesc #19 VALDESC_SPECIAL_DATA*/
1917         case MELTOBMAG_SPECIAL_DATA:
1918         {
1919             struct meltspecialdata_st*src = (struct meltspecialdata_st*) p;
1920             /* from VALDESC_SPECIAL_DATA file warmelt-base.melt */
1921             src->meltspec_mark = 1;
1922             MELT_FORWARDED (src->meltspec_value);
1923
1924             break;
1925         }
1926
1927         /*valdesc #20 VALDESC_STRBUF*/
1928         case MELTOBMAG_STRBUF:
1929         {
1930             break;
1931         }
1932
1933         /*valdesc #21 VALDESC_STRING*/
1934         case MELTOBMAG_STRING:
1935         {
1936             break;
1937         }
1938
1939         /* GTY-ed ctypes scan forward for melt_scanning  */
1940         /*gtyctype #1 CTYPE_BASIC_BLOCK*/
1941         case MELTOBMAG_BASICBLOCK:
1942             break;
1943         case MELTOBMAG_MAPBASICBLOCKS:
1944         {
1945             struct meltmapbasicblocks_st *src = (struct meltmapbasicblocks_st*) p;
1946             int siz=0, ix=0;
1947             MELT_FORWARDED(src->meltmap_aux);
1948             if (!src->entab) break;
1949             siz = melt_primtab[src->lenix];
1950             gcc_assert (siz>0);
1951             if (melt_is_young (src->entab))
1952                 {
1953                     struct entrybasicblockmelt_st* newtab = ggc_alloc_vec_entrybasicblockmelt_st (siz);
1954                     memcpy (newtab, src->entab, siz * sizeof (struct entrybasicblockmelt_st));
1955                     src->entab = newtab;
1956                 } /*end if young entab */
1957             for (ix = 0; ix < siz; ix++)
1958                 {
1959                     basic_block at = src->entab[ix].e_at;
1960                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
1961                         {
1962                             src->entab[ix].e_va = NULL;
1963                             continue;
1964                         } /*end if empty at */
1965                     MELT_FORWARDED (src->entab[ix].e_va);
1966                 } /*end for ix*/
1967         };    /* end case MELTOBMAG_MAPBASICBLOCKS */
1968         break;
1969         /*gtyctype #2 CTYPE_BITMAP*/
1970         case MELTOBMAG_BITMAP:
1971             break;
1972         case MELTOBMAG_MAPBITMAPS:
1973         {
1974             struct meltmapbitmaps_st *src = (struct meltmapbitmaps_st*) p;
1975             int siz=0, ix=0;
1976             MELT_FORWARDED(src->meltmap_aux);
1977             if (!src->entab) break;
1978             siz = melt_primtab[src->lenix];
1979             gcc_assert (siz>0);
1980             if (melt_is_young (src->entab))
1981                 {
1982                     struct entrybitmapmelt_st* newtab = ggc_alloc_vec_entrybitmapmelt_st (siz);
1983                     memcpy (newtab, src->entab, siz * sizeof (struct entrybitmapmelt_st));
1984                     src->entab = newtab;
1985                 } /*end if young entab */
1986             for (ix = 0; ix < siz; ix++)
1987                 {
1988                     bitmap at = src->entab[ix].e_at;
1989                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
1990                         {
1991                             src->entab[ix].e_va = NULL;
1992                             continue;
1993                         } /*end if empty at */
1994                     MELT_FORWARDED (src->entab[ix].e_va);
1995                 } /*end for ix*/
1996         };    /* end case MELTOBMAG_MAPBITMAPS */
1997         break;
1998         /*gtyctype #3 CTYPE_EDGE*/
1999         case MELTOBMAG_EDGE:
2000             break;
2001         case MELTOBMAG_MAPEDGES:
2002         {
2003             struct meltmapedges_st *src = (struct meltmapedges_st*) p;
2004             int siz=0, ix=0;
2005             MELT_FORWARDED(src->meltmap_aux);
2006             if (!src->entab) break;
2007             siz = melt_primtab[src->lenix];
2008             gcc_assert (siz>0);
2009             if (melt_is_young (src->entab))
2010                 {
2011                     struct entryedgemelt_st* newtab = ggc_alloc_vec_entryedgemelt_st (siz);
2012                     memcpy (newtab, src->entab, siz * sizeof (struct entryedgemelt_st));
2013                     src->entab = newtab;
2014                 } /*end if young entab */
2015             for (ix = 0; ix < siz; ix++)
2016                 {
2017                     edge at = src->entab[ix].e_at;
2018                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2019                         {
2020                             src->entab[ix].e_va = NULL;
2021                             continue;
2022                         } /*end if empty at */
2023                     MELT_FORWARDED (src->entab[ix].e_va);
2024                 } /*end for ix*/
2025         };    /* end case MELTOBMAG_MAPEDGES */
2026         break;
2027         /*gtyctype #4 CTYPE_GIMPLE*/
2028         case MELTOBMAG_GIMPLE:
2029             break;
2030         case MELTOBMAG_MAPGIMPLES:
2031         {
2032             struct meltmapgimples_st *src = (struct meltmapgimples_st*) p;
2033             int siz=0, ix=0;
2034             MELT_FORWARDED(src->meltmap_aux);
2035             if (!src->entab) break;
2036             siz = melt_primtab[src->lenix];
2037             gcc_assert (siz>0);
2038             if (melt_is_young (src->entab))
2039                 {
2040                     struct entrygimplemelt_st* newtab = ggc_alloc_vec_entrygimplemelt_st (siz);
2041                     memcpy (newtab, src->entab, siz * sizeof (struct entrygimplemelt_st));
2042                     src->entab = newtab;
2043                 } /*end if young entab */
2044             for (ix = 0; ix < siz; ix++)
2045                 {
2046                     gimple at = src->entab[ix].e_at;
2047                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2048                         {
2049                             src->entab[ix].e_va = NULL;
2050                             continue;
2051                         } /*end if empty at */
2052                     MELT_FORWARDED (src->entab[ix].e_va);
2053                 } /*end for ix*/
2054         };    /* end case MELTOBMAG_MAPGIMPLES */
2055         break;
2056         /*gtyctype #5 CTYPE_GIMPLE_SEQ*/
2057         case MELTOBMAG_GIMPLESEQ:
2058             break;
2059         case MELTOBMAG_MAPGIMPLESEQS:
2060         {
2061             struct meltmapgimpleseqs_st *src = (struct meltmapgimpleseqs_st*) p;
2062             int siz=0, ix=0;
2063             MELT_FORWARDED(src->meltmap_aux);
2064             if (!src->entab) break;
2065             siz = melt_primtab[src->lenix];
2066             gcc_assert (siz>0);
2067             if (melt_is_young (src->entab))
2068                 {
2069                     struct entrygimpleseqmelt_st* newtab = ggc_alloc_vec_entrygimpleseqmelt_st (siz);
2070                     memcpy (newtab, src->entab, siz * sizeof (struct entrygimpleseqmelt_st));
2071                     src->entab = newtab;
2072                 } /*end if young entab */
2073             for (ix = 0; ix < siz; ix++)
2074                 {
2075                     gimple_seq at = src->entab[ix].e_at;
2076                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2077                         {
2078                             src->entab[ix].e_va = NULL;
2079                             continue;
2080                         } /*end if empty at */
2081                     MELT_FORWARDED (src->entab[ix].e_va);
2082                 } /*end for ix*/
2083         };    /* end case MELTOBMAG_MAPGIMPLESEQS */
2084         break;
2085         /*gtyctype #6 CTYPE_LOOP*/
2086         case MELTOBMAG_LOOP:
2087             break;
2088         case MELTOBMAG_MAPLOOPS:
2089         {
2090             struct meltmaploops_st *src = (struct meltmaploops_st*) p;
2091             int siz=0, ix=0;
2092             MELT_FORWARDED(src->meltmap_aux);
2093             if (!src->entab) break;
2094             siz = melt_primtab[src->lenix];
2095             gcc_assert (siz>0);
2096             if (melt_is_young (src->entab))
2097                 {
2098                     struct entryloopmelt_st* newtab = ggc_alloc_vec_entryloopmelt_st (siz);
2099                     memcpy (newtab, src->entab, siz * sizeof (struct entryloopmelt_st));
2100                     src->entab = newtab;
2101                 } /*end if young entab */
2102             for (ix = 0; ix < siz; ix++)
2103                 {
2104                     loop_p at = src->entab[ix].e_at;
2105                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2106                         {
2107                             src->entab[ix].e_va = NULL;
2108                             continue;
2109                         } /*end if empty at */
2110                     MELT_FORWARDED (src->entab[ix].e_va);
2111                 } /*end for ix*/
2112         };    /* end case MELTOBMAG_MAPLOOPS */
2113         break;
2114         /*gtyctype #7 CTYPE_RTVEC*/
2115         case MELTOBMAG_RTVEC:
2116             break;
2117         case MELTOBMAG_MAPRTVECS:
2118         {
2119             struct meltmaprtvecs_st *src = (struct meltmaprtvecs_st*) p;
2120             int siz=0, ix=0;
2121             MELT_FORWARDED(src->meltmap_aux);
2122             if (!src->entab) break;
2123             siz = melt_primtab[src->lenix];
2124             gcc_assert (siz>0);
2125             if (melt_is_young (src->entab))
2126                 {
2127                     struct entryrtvecmelt_st* newtab = ggc_alloc_vec_entryrtvecmelt_st (siz);
2128                     memcpy (newtab, src->entab, siz * sizeof (struct entryrtvecmelt_st));
2129                     src->entab = newtab;
2130                 } /*end if young entab */
2131             for (ix = 0; ix < siz; ix++)
2132                 {
2133                     rtvec at = src->entab[ix].e_at;
2134                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2135                         {
2136                             src->entab[ix].e_va = NULL;
2137                             continue;
2138                         } /*end if empty at */
2139                     MELT_FORWARDED (src->entab[ix].e_va);
2140                 } /*end for ix*/
2141         };    /* end case MELTOBMAG_MAPRTVECS */
2142         break;
2143         /*gtyctype #8 CTYPE_RTX*/
2144         case MELTOBMAG_RTX:
2145             break;
2146         case MELTOBMAG_MAPRTXS:
2147         {
2148             struct meltmaprtxs_st *src = (struct meltmaprtxs_st*) p;
2149             int siz=0, ix=0;
2150             MELT_FORWARDED(src->meltmap_aux);
2151             if (!src->entab) break;
2152             siz = melt_primtab[src->lenix];
2153             gcc_assert (siz>0);
2154             if (melt_is_young (src->entab))
2155                 {
2156                     struct entryrtxmelt_st* newtab = ggc_alloc_vec_entryrtxmelt_st (siz);
2157                     memcpy (newtab, src->entab, siz * sizeof (struct entryrtxmelt_st));
2158                     src->entab = newtab;
2159                 } /*end if young entab */
2160             for (ix = 0; ix < siz; ix++)
2161                 {
2162                     rtx at = src->entab[ix].e_at;
2163                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2164                         {
2165                             src->entab[ix].e_va = NULL;
2166                             continue;
2167                         } /*end if empty at */
2168                     MELT_FORWARDED (src->entab[ix].e_va);
2169                 } /*end for ix*/
2170         };    /* end case MELTOBMAG_MAPRTXS */
2171         break;
2172         /*gtyctype #9 CTYPE_TREE*/
2173         case MELTOBMAG_TREE:
2174             break;
2175         case MELTOBMAG_MAPTREES:
2176         {
2177             struct meltmaptrees_st *src = (struct meltmaptrees_st*) p;
2178             int siz=0, ix=0;
2179             MELT_FORWARDED(src->meltmap_aux);
2180             if (!src->entab) break;
2181             siz = melt_primtab[src->lenix];
2182             gcc_assert (siz>0);
2183             if (melt_is_young (src->entab))
2184                 {
2185                     struct entrytreemelt_st* newtab = ggc_alloc_vec_entrytreemelt_st (siz);
2186                     memcpy (newtab, src->entab, siz * sizeof (struct entrytreemelt_st));
2187                     src->entab = newtab;
2188                 } /*end if young entab */
2189             for (ix = 0; ix < siz; ix++)
2190                 {
2191                     tree at = src->entab[ix].e_at;
2192                     if (!at || (void*) at == (void*) HTAB_DELETED_ENTRY)
2193                         {
2194                             src->entab[ix].e_va = NULL;
2195                             continue;
2196                         } /*end if empty at */
2197                     MELT_FORWARDED (src->entab[ix].e_va);
2198                 } /*end for ix*/
2199         };    /* end case MELTOBMAG_MAPTREES */
2200         break;
2201         /* trailer generated by generate_runtypesupport_scanning */
2202         default:
2203             /* gcc_unreachable (); */
2204             melt_fatal_error ("melt melt_scanning GC: corrupted heap, p=%p omagic=%d\n",
2205                               (void *) p, (int) omagic);
2206         }
2207 } /* end of melt_scanning generated by generate_runtypesupport_scanning */
2208
2209 /**end of code generated by generate_runtypesupport_scanning **/
2210
2211
2212 /** start of code generated by generate_runtypesupport_boxingfun **/
2213 /*gtyctype #1 CTYPE_BASIC_BLOCK*/
2214
2215 melt_ptr_t
2216 meltgc_new_basicblock(meltobject_ptr_t discr_p, basic_block val)   /*runtypesupport generated boxingfun*/
2217 {
2218     MELT_ENTERFRAME (2, NULL);
2219 #define resv meltfram__.mcfr_varptr[0]
2220 #define discrv meltfram__.mcfr_varptr[1]
2221     discrv = (melt_ptr_t) discr_p;
2222     if (!discrv) discrv = MELT_PREDEF(DISCR_BASIC_BLOCK);
2223     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2224     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_BASICBLOCK) goto end;
2225     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltbasicblock_st), 0);
2226     ((struct meltbasicblock_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2227     ((struct meltbasicblock_st*) (resv))->val = val;
2228 end:
2229     MELT_EXITFRAME ();
2230     return ((melt_ptr_t)(resv));
2231 #undef resv
2232 #undef discrv
2233 } /* end generated boxingfun meltgc_new_basicblock */
2234
2235 void
2236 meltgc_basicblock_updatebox(melt_ptr_t box_p, basic_block val)   /*generated updateboxfun */
2237 {
2238     MELT_ENTERFRAME (1, NULL);
2239 #define boxv meltfram__.mcfr_varptr[0]
2240     boxv = box_p;
2241     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_BASICBLOCK) goto end;
2242     if (((melt_ptr_t) boxv)->u_discr
2243             /* generated updatebox nonconst */
2244             == (meltobject_ptr_t) MELT_PREDEF (DISCR_CONSTANT_BASIC_BLOCK))
2245         goto end ;
2246     ((struct meltbasicblock_st*) (boxv))->val = val;
2247     meltgc_touch ((melt_ptr_t)boxv);
2248 end:
2249     MELT_EXITFRAME ();
2250 #undef boxv
2251 } /* end generated updateboxfun meltgc_basicblock_updatebox */
2252
2253 /*gtyctype #2 CTYPE_BITMAP*/
2254
2255 melt_ptr_t
2256 meltgc_new_bitmap(meltobject_ptr_t discr_p, bitmap val)   /*runtypesupport generated boxingfun*/
2257 {
2258     MELT_ENTERFRAME (2, NULL);
2259 #define resv meltfram__.mcfr_varptr[0]
2260 #define discrv meltfram__.mcfr_varptr[1]
2261     discrv = (melt_ptr_t) discr_p;
2262     if (!discrv) discrv = MELT_PREDEF(DISCR_BITMAP);
2263     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2264     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_BITMAP) goto end;
2265     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltbitmap_st), 0);
2266     ((struct meltbitmap_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2267     ((struct meltbitmap_st*) (resv))->val = val;
2268 end:
2269     MELT_EXITFRAME ();
2270     return ((melt_ptr_t)(resv));
2271 #undef resv
2272 #undef discrv
2273 } /* end generated boxingfun meltgc_new_bitmap */
2274
2275 void
2276 meltgc_bitmap_updatebox(melt_ptr_t box_p, bitmap val)   /*generated updateboxfun */
2277 {
2278     MELT_ENTERFRAME (1, NULL);
2279 #define boxv meltfram__.mcfr_varptr[0]
2280     boxv = box_p;
2281     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_BITMAP) goto end;
2282     ((struct meltbitmap_st*) (boxv))->val = val;
2283     meltgc_touch ((melt_ptr_t)boxv);
2284 end:
2285     MELT_EXITFRAME ();
2286 #undef boxv
2287 } /* end generated updateboxfun meltgc_bitmap_updatebox */
2288
2289 /*gtyctype #3 CTYPE_EDGE*/
2290
2291 melt_ptr_t
2292 meltgc_new_edge(meltobject_ptr_t discr_p, edge val)   /*runtypesupport generated boxingfun*/
2293 {
2294     MELT_ENTERFRAME (2, NULL);
2295 #define resv meltfram__.mcfr_varptr[0]
2296 #define discrv meltfram__.mcfr_varptr[1]
2297     discrv = (melt_ptr_t) discr_p;
2298     if (!discrv) discrv = MELT_PREDEF(DISCR_EDGE);
2299     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2300     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_EDGE) goto end;
2301     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltedge_st), 0);
2302     ((struct meltedge_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2303     ((struct meltedge_st*) (resv))->val = val;
2304 end:
2305     MELT_EXITFRAME ();
2306     return ((melt_ptr_t)(resv));
2307 #undef resv
2308 #undef discrv
2309 } /* end generated boxingfun meltgc_new_edge */
2310
2311 void
2312 meltgc_edge_updatebox(melt_ptr_t box_p, edge val)   /*generated updateboxfun */
2313 {
2314     MELT_ENTERFRAME (1, NULL);
2315 #define boxv meltfram__.mcfr_varptr[0]
2316     boxv = box_p;
2317     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_EDGE) goto end;
2318     if (((melt_ptr_t) boxv)->u_discr
2319             /* generated updatebox nonconst */
2320             == (meltobject_ptr_t) MELT_PREDEF (DISCR_CONSTANT_EDGE))
2321         goto end ;
2322     ((struct meltedge_st*) (boxv))->val = val;
2323     meltgc_touch ((melt_ptr_t)boxv);
2324 end:
2325     MELT_EXITFRAME ();
2326 #undef boxv
2327 } /* end generated updateboxfun meltgc_edge_updatebox */
2328
2329 /*gtyctype #4 CTYPE_GIMPLE*/
2330
2331 melt_ptr_t
2332 meltgc_new_gimple(meltobject_ptr_t discr_p, gimple val)   /*runtypesupport generated boxingfun*/
2333 {
2334     MELT_ENTERFRAME (2, NULL);
2335 #define resv meltfram__.mcfr_varptr[0]
2336 #define discrv meltfram__.mcfr_varptr[1]
2337     discrv = (melt_ptr_t) discr_p;
2338     if (!discrv) discrv = MELT_PREDEF(DISCR_GIMPLE);
2339     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2340     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_GIMPLE) goto end;
2341     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltgimple_st), 0);
2342     ((struct meltgimple_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2343     ((struct meltgimple_st*) (resv))->val = val;
2344 end:
2345     MELT_EXITFRAME ();
2346     return ((melt_ptr_t)(resv));
2347 #undef resv
2348 #undef discrv
2349 } /* end generated boxingfun meltgc_new_gimple */
2350
2351 void
2352 meltgc_gimple_updatebox(melt_ptr_t box_p, gimple val)   /*generated updateboxfun */
2353 {
2354     MELT_ENTERFRAME (1, NULL);
2355 #define boxv meltfram__.mcfr_varptr[0]
2356     boxv = box_p;
2357     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_GIMPLE) goto end;
2358     if (((melt_ptr_t) boxv)->u_discr
2359             /* generated updatebox nonconst */
2360             == (meltobject_ptr_t) MELT_PREDEF (DISCR_CONSTANT_GIMPLE))
2361         goto end ;
2362     ((struct meltgimple_st*) (boxv))->val = val;
2363     meltgc_touch ((melt_ptr_t)boxv);
2364 end:
2365     MELT_EXITFRAME ();
2366 #undef boxv
2367 } /* end generated updateboxfun meltgc_gimple_updatebox */
2368
2369 /*gtyctype #5 CTYPE_GIMPLE_SEQ*/
2370
2371 melt_ptr_t
2372 meltgc_new_gimpleseq(meltobject_ptr_t discr_p, gimple_seq val)   /*runtypesupport generated boxingfun*/
2373 {
2374     MELT_ENTERFRAME (2, NULL);
2375 #define resv meltfram__.mcfr_varptr[0]
2376 #define discrv meltfram__.mcfr_varptr[1]
2377     discrv = (melt_ptr_t) discr_p;
2378     if (!discrv) discrv = MELT_PREDEF(DISCR_GIMPLE_SEQ);
2379     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2380     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_GIMPLESEQ) goto end;
2381     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltgimpleseq_st), 0);
2382     ((struct meltgimpleseq_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2383     ((struct meltgimpleseq_st*) (resv))->val = val;
2384 end:
2385     MELT_EXITFRAME ();
2386     return ((melt_ptr_t)(resv));
2387 #undef resv
2388 #undef discrv
2389 } /* end generated boxingfun meltgc_new_gimpleseq */
2390
2391 void
2392 meltgc_gimpleseq_updatebox(melt_ptr_t box_p, gimple_seq val)   /*generated updateboxfun */
2393 {
2394     MELT_ENTERFRAME (1, NULL);
2395 #define boxv meltfram__.mcfr_varptr[0]
2396     boxv = box_p;
2397     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_GIMPLESEQ) goto end;
2398     if (((melt_ptr_t) boxv)->u_discr
2399             /* generated updatebox nonconst */
2400             == (meltobject_ptr_t) MELT_PREDEF (DISCR_CONSTANT_GIMPLE_SEQ))
2401         goto end ;
2402     ((struct meltgimpleseq_st*) (boxv))->val = val;
2403     meltgc_touch ((melt_ptr_t)boxv);
2404 end:
2405     MELT_EXITFRAME ();
2406 #undef boxv
2407 } /* end generated updateboxfun meltgc_gimpleseq_updatebox */
2408
2409 /*gtyctype #6 CTYPE_LOOP*/
2410
2411 melt_ptr_t
2412 meltgc_new_loop(meltobject_ptr_t discr_p, loop_p val)   /*runtypesupport generated boxingfun*/
2413 {
2414     MELT_ENTERFRAME (2, NULL);
2415 #define resv meltfram__.mcfr_varptr[0]
2416 #define discrv meltfram__.mcfr_varptr[1]
2417     discrv = (melt_ptr_t) discr_p;
2418     if (!discrv) discrv = MELT_PREDEF(DISCR_LOOP);
2419     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2420     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_LOOP) goto end;
2421     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltloop_st), 0);
2422     ((struct meltloop_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2423     ((struct meltloop_st*) (resv))->val = val;
2424 end:
2425     MELT_EXITFRAME ();
2426     return ((melt_ptr_t)(resv));
2427 #undef resv
2428 #undef discrv
2429 } /* end generated boxingfun meltgc_new_loop */
2430
2431 void
2432 melt_loop_updatebox(melt_ptr_t box_p, loop_p val)   /*generated updateboxfun */
2433 {
2434     MELT_ENTERFRAME (1, NULL);
2435 #define boxv meltfram__.mcfr_varptr[0]
2436     boxv = box_p;
2437     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_LOOP) goto end;
2438     if (((melt_ptr_t) boxv)->u_discr
2439             /* generated updatebox nonconst */
2440             == (meltobject_ptr_t) MELT_PREDEF (DISCR_CONSTANT_LOOP))
2441         goto end ;
2442     ((struct meltloop_st*) (boxv))->val = val;
2443     meltgc_touch ((melt_ptr_t)boxv);
2444 end:
2445     MELT_EXITFRAME ();
2446 #undef boxv
2447 } /* end generated updateboxfun melt_loop_updatebox */
2448
2449 /*gtyctype #7 CTYPE_RTVEC*/
2450
2451 melt_ptr_t
2452 meltgc_new_rtvec(meltobject_ptr_t discr_p, rtvec val)   /*runtypesupport generated boxingfun*/
2453 {
2454     MELT_ENTERFRAME (2, NULL);
2455 #define resv meltfram__.mcfr_varptr[0]
2456 #define discrv meltfram__.mcfr_varptr[1]
2457     discrv = (melt_ptr_t) discr_p;
2458     if (!discrv) discrv = MELT_PREDEF(DISCR_RTVEC);
2459     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2460     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_RTVEC) goto end;
2461     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltrtvec_st), 0);
2462     ((struct meltrtvec_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2463     ((struct meltrtvec_st*) (resv))->val = val;
2464 end:
2465     MELT_EXITFRAME ();
2466     return ((melt_ptr_t)(resv));
2467 #undef resv
2468 #undef discrv
2469 } /* end generated boxingfun meltgc_new_rtvec */
2470
2471 void
2472 meltgc_rtvec_updatebox(melt_ptr_t box_p, rtvec val)   /*generated updateboxfun */
2473 {
2474     MELT_ENTERFRAME (1, NULL);
2475 #define boxv meltfram__.mcfr_varptr[0]
2476     boxv = box_p;
2477     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_RTVEC) goto end;
2478     ((struct meltrtvec_st*) (boxv))->val = val;
2479     meltgc_touch ((melt_ptr_t)boxv);
2480 end:
2481     MELT_EXITFRAME ();
2482 #undef boxv
2483 } /* end generated updateboxfun meltgc_rtvec_updatebox */
2484
2485 /*gtyctype #8 CTYPE_RTX*/
2486
2487 melt_ptr_t
2488 meltgc_new_rtx(meltobject_ptr_t discr_p, rtx val)   /*runtypesupport generated boxingfun*/
2489 {
2490     MELT_ENTERFRAME (2, NULL);
2491 #define resv meltfram__.mcfr_varptr[0]
2492 #define discrv meltfram__.mcfr_varptr[1]
2493     discrv = (melt_ptr_t) discr_p;
2494     if (!discrv) discrv = MELT_PREDEF(DISCR_RTX);
2495     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2496     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_RTX) goto end;
2497     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct meltrtx_st), 0);
2498     ((struct meltrtx_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2499     ((struct meltrtx_st*) (resv))->val = val;
2500 end:
2501     MELT_EXITFRAME ();
2502     return ((melt_ptr_t)(resv));
2503 #undef resv
2504 #undef discrv
2505 } /* end generated boxingfun meltgc_new_rtx */
2506
2507 void
2508 meltgc_rtx_updatebox(melt_ptr_t box_p, rtx val)   /*generated updateboxfun */
2509 {
2510     MELT_ENTERFRAME (1, NULL);
2511 #define boxv meltfram__.mcfr_varptr[0]
2512     boxv = box_p;
2513     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_RTX) goto end;
2514     ((struct meltrtx_st*) (boxv))->val = val;
2515     meltgc_touch ((melt_ptr_t)boxv);
2516 end:
2517     MELT_EXITFRAME ();
2518 #undef boxv
2519 } /* end generated updateboxfun meltgc_rtx_updatebox */
2520
2521 /*gtyctype #9 CTYPE_TREE*/
2522
2523 melt_ptr_t
2524 meltgc_new_tree(meltobject_ptr_t discr_p, tree val)   /*runtypesupport generated boxingfun*/
2525 {
2526     MELT_ENTERFRAME (2, NULL);
2527 #define resv meltfram__.mcfr_varptr[0]
2528 #define discrv meltfram__.mcfr_varptr[1]
2529     discrv = (melt_ptr_t) discr_p;
2530     if (!discrv) discrv = MELT_PREDEF(DISCR_TREE);
2531     if (melt_magic_discr((melt_ptr_t)discrv) != MELTOBMAG_OBJECT) goto end;
2532     if (((meltobject_ptr_t)(discrv))->meltobj_magic != MELTOBMAG_TREE) goto end;
2533     resv = (melt_ptr_t) meltgc_allocate (sizeof (struct melttree_st), 0);
2534     ((struct melttree_st*) (resv))->discr = (meltobject_ptr_t)discrv;
2535     ((struct melttree_st*) (resv))->val = val;
2536 end:
2537     MELT_EXITFRAME ();
2538     return ((melt_ptr_t)(resv));
2539 #undef resv
2540 #undef discrv
2541 } /* end generated boxingfun meltgc_new_tree */
2542
2543 void
2544 meltgc_tree_updatebox(melt_ptr_t box_p, tree val)   /*generated updateboxfun */
2545 {
2546     MELT_ENTERFRAME (1, NULL);
2547 #define boxv meltfram__.mcfr_varptr[0]
2548     boxv = box_p;
2549     if (melt_magic_discr((melt_ptr_t)boxv) != MELTOBMAG_TREE) goto end;
2550     if (((melt_ptr_t) boxv)->u_discr
2551             /* generated updatebox nonconst */
2552             == (meltobject_ptr_t) MELT_PREDEF (DISCR_CONSTANT_TREE))
2553         goto end ;
2554     ((struct melttree_st*) (boxv))->val = val;
2555     meltgc_touch ((melt_ptr_t)boxv);
2556 end:
2557     MELT_EXITFRAME ();
2558 #undef boxv
2559 } /* end generated updateboxfun meltgc_tree_updatebox */
2560
2561
2562 /** end of code generated by generate_runtypesupport_boxingfun **/
2563
2564
2565
2566 /** generated by generate_runtypesupport_cloning_fun **/
2567 /* generated cloning routine head */
2568 melt_ptr_t
2569 meltgc_clone_with_discriminant (melt_ptr_t srcval_p, melt_ptr_t newdiscr_p)
2570 {
2571     unsigned srcmagic = 0;
2572     unsigned newmagic = 0;
2573     MELT_ENTERFRAME (5, NULL);
2574 #define resv       meltfram__.mcfr_varptr[0]
2575 #define srcvalv    meltfram__.mcfr_varptr[1]
2576 #define newdiscrv  meltfram__.mcfr_varptr[2]
2577 #define srcdiscrv  meltfram__.mcfr_varptr[3]
2578 #define compv      meltfram__.mcfr_varptr[4]
2579     srcvalv = srcval_p;
2580     newdiscrv = newdiscr_p;
2581     resv = srcvalv;
2582     if (!srcvalv)
2583         goto end;
2584     srcdiscrv = (melt_ptr_t) (((melt_ptr_t)srcvalv)->u_discr);
2585     if (!newdiscrv)
2586         newdiscrv = srcdiscrv;
2587     if (melt_magic_discr((melt_ptr_t)newdiscrv) != MELTOBMAG_OBJECT
2588             || ((meltobject_ptr_t)newdiscrv)->obj_len < MELTLENGTH_CLASS_DISCRIMINANT)
2589         goto end;
2590     if (!melt_is_instance_of((melt_ptr_t)newdiscrv,
2591                              MELT_PREDEF (CLASS_DISCRIMINANT)))
2592         goto end;
2593     srcmagic = melt_magic_discr ((melt_ptr_t)srcvalv);
2594     newmagic = ((meltobject_ptr_t)newdiscrv)->meltobj_magic;
2595     if (srcmagic != newmagic)
2596         goto end;
2597     switch (srcmagic)   /* end cloning heeader */
2598         {
2599
2600
2601             /*** cloning 9 GTY-ed ctypes ***/
2602
2603             /*cloning gtyctype #1 CTYPE_BASIC_BLOCK */
2604         case MELTOBMAG_BASICBLOCK :   /* cloning boxed value CTYPE_BASIC_BLOCK */
2605         {
2606             struct meltbasicblock_st *src = (struct meltbasicblock_st *) srcvalv;
2607             struct meltbasicblock_st *dst = (struct meltbasicblock_st *) meltgc_allocate (sizeof(struct meltbasicblock_st), 0);
2608
2609             *dst = *src;
2610             dst->discr = (meltobject_ptr_t) newdiscrv;
2611             resv = (melt_ptr_t) dst;
2612         }
2613         break;
2614         case MELTOBMAG_MAPBASICBLOCKS :   /* cloning map value CTYPE_BASIC_BLOCK */
2615         {
2616             struct meltmapbasicblocks_st *src = (struct meltmapbasicblocks_st *) srcvalv;
2617             unsigned oldlen =  melt_primtab[src->lenix];
2618             unsigned newlen = 4*src->count/3 + 5;
2619             struct meltmapbasicblocks_st *dst =
2620             (struct meltmapbasicblocks_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2621             unsigned ix = 0;
2622             dst->meltmap_aux = src->meltmap_aux;
2623             if (src->entab)
2624                 for (ix=0; ix<oldlen;
2625                         ix++)
2626                     {
2627                         melt_ptr_t curva = src->entab[ix].e_va;
2628                         basic_block curat = src->entab[ix].e_at;
2629                         if (curva != NULL && curat != (basic_block) HTAB_DELETED_ENTRY)
2630                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2631                     }
2632             resv = (melt_ptr_t) dst;
2633         };
2634         break;
2635         /*cloning gtyctype #2 CTYPE_BITMAP */
2636         case MELTOBMAG_BITMAP :   /* cloning boxed value CTYPE_BITMAP */
2637         {
2638             struct meltbitmap_st *src = (struct meltbitmap_st *) srcvalv;
2639             struct meltbitmap_st *dst = (struct meltbitmap_st *) meltgc_allocate (sizeof(struct meltbitmap_st), 0);
2640
2641             *dst = *src;
2642             dst->discr = (meltobject_ptr_t) newdiscrv;
2643             resv = (melt_ptr_t) dst;
2644         }
2645         break;
2646         case MELTOBMAG_MAPBITMAPS :   /* cloning map value CTYPE_BITMAP */
2647         {
2648             struct meltmapbitmaps_st *src = (struct meltmapbitmaps_st *) srcvalv;
2649             unsigned oldlen =  melt_primtab[src->lenix];
2650             unsigned newlen = 4*src->count/3 + 5;
2651             struct meltmapbitmaps_st *dst =
2652             (struct meltmapbitmaps_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2653             unsigned ix = 0;
2654             dst->meltmap_aux = src->meltmap_aux;
2655             if (src->entab)
2656                 for (ix=0; ix<oldlen;
2657                         ix++)
2658                     {
2659                         melt_ptr_t curva = src->entab[ix].e_va;
2660                         bitmap curat = src->entab[ix].e_at;
2661                         if (curva != NULL && curat != (bitmap) HTAB_DELETED_ENTRY)
2662                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2663                     }
2664             resv = (melt_ptr_t) dst;
2665         };
2666         break;
2667         /*cloning gtyctype #3 CTYPE_EDGE */
2668         case MELTOBMAG_EDGE :   /* cloning boxed value CTYPE_EDGE */
2669         {
2670             struct meltedge_st *src = (struct meltedge_st *) srcvalv;
2671             struct meltedge_st *dst = (struct meltedge_st *) meltgc_allocate (sizeof(struct meltedge_st), 0);
2672
2673             *dst = *src;
2674             dst->discr = (meltobject_ptr_t) newdiscrv;
2675             resv = (melt_ptr_t) dst;
2676         }
2677         break;
2678         case MELTOBMAG_MAPEDGES :   /* cloning map value CTYPE_EDGE */
2679         {
2680             struct meltmapedges_st *src = (struct meltmapedges_st *) srcvalv;
2681             unsigned oldlen =  melt_primtab[src->lenix];
2682             unsigned newlen = 4*src->count/3 + 5;
2683             struct meltmapedges_st *dst =
2684             (struct meltmapedges_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2685             unsigned ix = 0;
2686             dst->meltmap_aux = src->meltmap_aux;
2687             if (src->entab)
2688                 for (ix=0; ix<oldlen;
2689                         ix++)
2690                     {
2691                         melt_ptr_t curva = src->entab[ix].e_va;
2692                         edge curat = src->entab[ix].e_at;
2693                         if (curva != NULL && curat != (edge) HTAB_DELETED_ENTRY)
2694                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2695                     }
2696             resv = (melt_ptr_t) dst;
2697         };
2698         break;
2699         /*cloning gtyctype #4 CTYPE_GIMPLE */
2700         case MELTOBMAG_GIMPLE :   /* cloning boxed value CTYPE_GIMPLE */
2701         {
2702             struct meltgimple_st *src = (struct meltgimple_st *) srcvalv;
2703             struct meltgimple_st *dst = (struct meltgimple_st *) meltgc_allocate (sizeof(struct meltgimple_st), 0);
2704
2705             *dst = *src;
2706             dst->discr = (meltobject_ptr_t) newdiscrv;
2707             resv = (melt_ptr_t) dst;
2708         }
2709         break;
2710         case MELTOBMAG_MAPGIMPLES :   /* cloning map value CTYPE_GIMPLE */
2711         {
2712             struct meltmapgimples_st *src = (struct meltmapgimples_st *) srcvalv;
2713             unsigned oldlen =  melt_primtab[src->lenix];
2714             unsigned newlen = 4*src->count/3 + 5;
2715             struct meltmapgimples_st *dst =
2716             (struct meltmapgimples_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2717             unsigned ix = 0;
2718             dst->meltmap_aux = src->meltmap_aux;
2719             if (src->entab)
2720                 for (ix=0; ix<oldlen;
2721                         ix++)
2722                     {
2723                         melt_ptr_t curva = src->entab[ix].e_va;
2724                         gimple curat = src->entab[ix].e_at;
2725                         if (curva != NULL && curat != (gimple) HTAB_DELETED_ENTRY)
2726                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2727                     }
2728             resv = (melt_ptr_t) dst;
2729         };
2730         break;
2731         /*cloning gtyctype #5 CTYPE_GIMPLE_SEQ */
2732         case MELTOBMAG_GIMPLESEQ :   /* cloning boxed value CTYPE_GIMPLE_SEQ */
2733         {
2734             struct meltgimpleseq_st *src = (struct meltgimpleseq_st *) srcvalv;
2735             struct meltgimpleseq_st *dst = (struct meltgimpleseq_st *) meltgc_allocate (sizeof(struct meltgimpleseq_st), 0);
2736
2737             *dst = *src;
2738             dst->discr = (meltobject_ptr_t) newdiscrv;
2739             resv = (melt_ptr_t) dst;
2740         }
2741         break;
2742         case MELTOBMAG_MAPGIMPLESEQS :   /* cloning map value CTYPE_GIMPLE_SEQ */
2743         {
2744             struct meltmapgimpleseqs_st *src = (struct meltmapgimpleseqs_st *) srcvalv;
2745             unsigned oldlen =  melt_primtab[src->lenix];
2746             unsigned newlen = 4*src->count/3 + 5;
2747             struct meltmapgimpleseqs_st *dst =
2748             (struct meltmapgimpleseqs_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2749             unsigned ix = 0;
2750             dst->meltmap_aux = src->meltmap_aux;
2751             if (src->entab)
2752                 for (ix=0; ix<oldlen;
2753                         ix++)
2754                     {
2755                         melt_ptr_t curva = src->entab[ix].e_va;
2756                         gimple_seq curat = src->entab[ix].e_at;
2757                         if (curva != NULL && curat != (gimple_seq) HTAB_DELETED_ENTRY)
2758                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2759                     }
2760             resv = (melt_ptr_t) dst;
2761         };
2762         break;
2763         /*cloning gtyctype #6 CTYPE_LOOP */
2764         case MELTOBMAG_LOOP :   /* cloning boxed value CTYPE_LOOP */
2765         {
2766             struct meltloop_st *src = (struct meltloop_st *) srcvalv;
2767             struct meltloop_st *dst = (struct meltloop_st *) meltgc_allocate (sizeof(struct meltloop_st), 0);
2768
2769             *dst = *src;
2770             dst->discr = (meltobject_ptr_t) newdiscrv;
2771             resv = (melt_ptr_t) dst;
2772         }
2773         break;
2774         case MELTOBMAG_MAPLOOPS :   /* cloning map value CTYPE_LOOP */
2775         {
2776             struct meltmaploops_st *src = (struct meltmaploops_st *) srcvalv;
2777             unsigned oldlen =  melt_primtab[src->lenix];
2778             unsigned newlen = 4*src->count/3 + 5;
2779             struct meltmaploops_st *dst =
2780             (struct meltmaploops_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2781             unsigned ix = 0;
2782             dst->meltmap_aux = src->meltmap_aux;
2783             if (src->entab)
2784                 for (ix=0; ix<oldlen;
2785                         ix++)
2786                     {
2787                         melt_ptr_t curva = src->entab[ix].e_va;
2788                         loop_p curat = src->entab[ix].e_at;
2789                         if (curva != NULL && curat != (loop_p) HTAB_DELETED_ENTRY)
2790                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2791                     }
2792             resv = (melt_ptr_t) dst;
2793         };
2794         break;
2795         /*cloning gtyctype #7 CTYPE_RTVEC */
2796         case MELTOBMAG_RTVEC :   /* cloning boxed value CTYPE_RTVEC */
2797         {
2798             struct meltrtvec_st *src = (struct meltrtvec_st *) srcvalv;
2799             struct meltrtvec_st *dst = (struct meltrtvec_st *) meltgc_allocate (sizeof(struct meltrtvec_st), 0);
2800
2801             *dst = *src;
2802             dst->discr = (meltobject_ptr_t) newdiscrv;
2803             resv = (melt_ptr_t) dst;
2804         }
2805         break;
2806         case MELTOBMAG_MAPRTVECS :   /* cloning map value CTYPE_RTVEC */
2807         {
2808             struct meltmaprtvecs_st *src = (struct meltmaprtvecs_st *) srcvalv;
2809             unsigned oldlen =  melt_primtab[src->lenix];
2810             unsigned newlen = 4*src->count/3 + 5;
2811             struct meltmaprtvecs_st *dst =
2812             (struct meltmaprtvecs_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2813             unsigned ix = 0;
2814             dst->meltmap_aux = src->meltmap_aux;
2815             if (src->entab)
2816                 for (ix=0; ix<oldlen;
2817                         ix++)
2818                     {
2819                         melt_ptr_t curva = src->entab[ix].e_va;
2820                         rtvec curat = src->entab[ix].e_at;
2821                         if (curva != NULL && curat != (rtvec) HTAB_DELETED_ENTRY)
2822                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2823                     }
2824             resv = (melt_ptr_t) dst;
2825         };
2826         break;
2827         /*cloning gtyctype #8 CTYPE_RTX */
2828         case MELTOBMAG_RTX :   /* cloning boxed value CTYPE_RTX */
2829         {
2830             struct meltrtx_st *src = (struct meltrtx_st *) srcvalv;
2831             struct meltrtx_st *dst = (struct meltrtx_st *) meltgc_allocate (sizeof(struct meltrtx_st), 0);
2832
2833             *dst = *src;
2834             dst->discr = (meltobject_ptr_t) newdiscrv;
2835             resv = (melt_ptr_t) dst;
2836         }
2837         break;
2838         case MELTOBMAG_MAPRTXS :   /* cloning map value CTYPE_RTX */
2839         {
2840             struct meltmaprtxs_st *src = (struct meltmaprtxs_st *) srcvalv;
2841             unsigned oldlen =  melt_primtab[src->lenix];
2842             unsigned newlen = 4*src->count/3 + 5;
2843             struct meltmaprtxs_st *dst =
2844             (struct meltmaprtxs_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2845             unsigned ix = 0;
2846             dst->meltmap_aux = src->meltmap_aux;
2847             if (src->entab)
2848                 for (ix=0; ix<oldlen;
2849                         ix++)
2850                     {
2851                         melt_ptr_t curva = src->entab[ix].e_va;
2852                         rtx curat = src->entab[ix].e_at;
2853                         if (curva != NULL && curat != (rtx) HTAB_DELETED_ENTRY)
2854                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2855                     }
2856             resv = (melt_ptr_t) dst;
2857         };
2858         break;
2859         /*cloning gtyctype #9 CTYPE_TREE */
2860         case MELTOBMAG_TREE :   /* cloning boxed value CTYPE_TREE */
2861         {
2862             struct melttree_st *src = (struct melttree_st *) srcvalv;
2863             struct melttree_st *dst = (struct melttree_st *) meltgc_allocate (sizeof(struct melttree_st), 0);
2864
2865             *dst = *src;
2866             dst->discr = (meltobject_ptr_t) newdiscrv;
2867             resv = (melt_ptr_t) dst;
2868         }
2869         break;
2870         case MELTOBMAG_MAPTREES :   /* cloning map value CTYPE_TREE */
2871         {
2872             struct meltmaptrees_st *src = (struct meltmaptrees_st *) srcvalv;
2873             unsigned oldlen =  melt_primtab[src->lenix];
2874             unsigned newlen = 4*src->count/3 + 5;
2875             struct meltmaptrees_st *dst =
2876             (struct meltmaptrees_st *) meltgc_raw_new_mappointers((meltobject_ptr_t)newdiscrv, newlen);
2877             unsigned ix = 0;
2878             dst->meltmap_aux = src->meltmap_aux;
2879             if (src->entab)
2880                 for (ix=0; ix<oldlen;
2881                         ix++)
2882                     {
2883                         melt_ptr_t curva = src->entab[ix].e_va;
2884                         tree curat = src->entab[ix].e_at;
2885                         if (curva != NULL && curat != (tree) HTAB_DELETED_ENTRY)
2886                             meltgc_raw_put_mappointers((void*)dst, (const void*)curat, curva);
2887                     }
2888             resv = (melt_ptr_t) dst;
2889         };
2890         break;
2891
2892         /******* cloning the 21 value descriptors *******/
2893         /** cloning value descriptor #1 VALDESC_BUCKETLONGS **/
2894         /*explicit cloning for VALDESC_BUCKETLONGS*/
2895         case MELTOBMAG_BUCKETLONGS:
2896         {
2897             struct meltbucketlongs_st *src = (struct meltbucketlongs_st*) srcvalv;
2898             struct meltbucketlongs_st *dst = NULL;
2899             /* explicit clone chunk for VALDESC_BUCKETLONGS:*/
2900             /* cloning chunk from VALDESC_BUCKETLONGS in warmelt-base.melt */
2901             // in file warmelt-base.melt line 2887
2902             unsigned lnix = src->buckl_lenix;
2903             unsigned len = melt_primtab[lnix];
2904             unsigned cnt = src->buckl_ucount;
2905             unsigned dstlen = 0;
2906             unsigned ix = 0;
2907             gcc_assert (lnix > 0);
2908             gcc_assert (len > 0);
2909             gcc_assert (cnt <= len);
2910             dst = (struct meltbucketlongs_st*)
2911                   meltgc_new_longsbucket ((meltobject_ptr_t)newdiscrv, cnt + cnt/8 + 2);
2912             resv = (melt_ptr_t) dst;
2913             dstlen = melt_primtab[dst->buckl_lenix];
2914             dst->buckl_aux = src->buckl_aux;
2915             dst->buckl_xnum = src->buckl_xnum;
2916             dst->buckl_lenix = src->buckl_lenix;
2917             for (ix = 0;
2918                     ix < cnt;
2919                     ix++)
2920                 dst->buckl_entab[ix] = src->buckl_entab[ix];
2921             for (ix = cnt;
2922                     ix < dstlen;
2923                     ix++)
2924                 {
2925                     dst->buckl_entab[ix].ebl_at = 0L;
2926                     dst->buckl_entab[ix].ebl_va = NULL;
2927                 }
2928             /* end clone chunk VALDESC_BUCKETLONGS */
2929             ;
2930             if (dst)
2931                 resv = (melt_ptr_t) dst;
2932         };
2933         break;
2934         /** cloning value descriptor #2 VALDESC_CLOSURE **/
2935         /*explicit cloning for VALDESC_CLOSURE*/
2936         case MELTOBMAG_CLOSURE:
2937         {
2938             struct meltclosure_st *src = (struct meltclosure_st*) srcvalv;
2939             struct meltclosure_st *dst = NULL;
2940             /* explicit clone chunk for VALDESC_CLOSURE:*/
2941             /* cloning from VALDESC_CLOSURE  in warmelt-base.melt*/
2942             // in file warmelt-base.melt line 2641
2943             unsigned nbval = (int) src->nbval;
2944             dst
2945                 = (struct meltclosure_st*)meltgc_allocate (sizeof(struct meltclosure_st),
2946                         nbval*sizeof(void*));
2947             resv = (melt_ptr_t) dst;
2948             src = (struct meltclosure_st*)srcvalv;
2949             dst->discr = (meltobject_ptr_t)newdiscrv;
2950             dst->rout = src->rout;
2951             for (unsigned ix = 0;
2952                     ix < nbval;
2953                     ix++)
2954                 dst->tabval[ix] = src->tabval[ix];
2955             /* end cloning from VALDESC_CLOSURE */
2956             ;
2957             if (dst)
2958                 resv = (melt_ptr_t) dst;
2959         };
2960         break;
2961         /** cloning value descriptor #3 VALDESC_DECAY **/
2962         /*default cloning for VALDESC_DECAY*/
2963         case MELTOBMAG_DECAY:
2964         {
2965             struct meltdecay_st *src = (struct meltdecay_st*) srcvalv;
2966             struct meltdecay_st *dst =
2967             (struct meltdecay_st*) meltgc_allocate (sizeof(struct meltdecay_st), 0);
2968             *dst = *src;
2969             dst->discr = (meltobject_ptr_t)newdiscrv;
2970             resv = (melt_ptr_t) dst;
2971         }
2972         break;
2973         /** cloning value descriptor #4 VALDESC_DOUBLE **/
2974         /*default cloning for VALDESC_DOUBLE*/
2975         case MELTOBMAG_DOUBLE:
2976         {
2977             struct meltdouble_st *src = (struct meltdouble_st*) srcvalv;
2978             struct meltdouble_st *dst =
2979             (struct meltdouble_st*) meltgc_allocate (sizeof(struct meltdouble_st), 0);
2980             *dst = *src;
2981             dst->discr = (meltobject_ptr_t)newdiscrv;
2982             resv = (melt_ptr_t) dst;
2983         }
2984         break;
2985         /** cloning value descriptor #5 VALDESC_HOOK **/
2986         /*no cloning for VALDESC_HOOK*/
2987         case MELTOBMAG_HOOK:
2988             break;
2989             /** cloning value descriptor #6 VALDESC_INT **/
2990             /*default cloning for VALDESC_INT*/
2991         case MELTOBMAG_INT:
2992         {
2993             struct meltint_st *src = (struct meltint_st*) srcvalv;
2994             struct meltint_st *dst =
2995             (struct meltint_st*) meltgc_allocate (sizeof(struct meltint_st), 0);
2996             *dst = *src;
2997             dst->discr = (meltobject_ptr_t)newdiscrv;
2998             resv = (melt_ptr_t) dst;
2999         }
3000         break;
3001         /** cloning value descriptor #7 VALDESC_JSONOBJECT **/
3002         /*explicit cloning for VALDESC_JSONOBJECT*/
3003         case MELTOBMAG_JSONOBJECT:
3004         {
3005             struct meltjsonobject_st *src = (struct meltjsonobject_st*) srcvalv;
3006             struct meltjsonobject_st *dst = NULL;
3007             /* explicit clone chunk for VALDESC_JSONOBJECT:*/
3008             /* cloning chunk from VALDESC_JSONOBJECT in warmelt-base.melt */
3009             // in file warmelt-base.melt line 3043
3010             unsigned srcsize = src->jsob_size;
3011             dst = (struct meltjsonobject_st*)meltgc_allocate(sizeof(struct meltjsonobject_st),
3012                     srcsize*sizeof(melt_jsonobentry_st));
3013             dst->discr = (meltobject_ptr_t)newdiscrv;
3014             dst->jsob_aux = src->jsob_aux;
3015             for (unsigned ix=0; ix<srcsize; ix++)
3016                 dst->jsob_entab[ix] = src->jsob_entab[ix];
3017             /* end cloning chunk VALDESC_JSONOBJECT */
3018             ;
3019             if (dst)
3020                 resv = (melt_ptr_t) dst;
3021         };
3022         break;
3023         /** cloning value descriptor #8 VALDESC_LIST **/
3024         /*explicit cloning for VALDESC_LIST*/
3025         case MELTOBMAG_LIST:
3026         {
3027             struct meltlist_st *src = (struct meltlist_st*) srcvalv;
3028             struct meltlist_st *dst = NULL;
3029             /* explicit clone chunk for VALDESC_LIST:*/
3030             /* cloning from VALDESC_LIST in warmelt-base.melt */
3031             // in file warmelt-base.melt line 3269
3032             struct meltpair_st* curpair = NULL;
3033             dst = (struct meltlist_st*) meltgc_new_list ((meltobject_ptr_t)newdiscrv);
3034             resv = (melt_ptr_t) dst;
3035             src = (struct meltlist_st*) srcvalv;
3036             for (curpair = ((struct meltlist_st *) src)->first;
3037                     melt_magic_discr ((melt_ptr_t) curpair) == MELTOBMAG_PAIR;
3038                     curpair = (struct meltpair_st *) (curpair->tl))
3039                 {
3040                     src = (struct meltlist_st*) srcvalv;
3041                     dst = (struct meltlist_st*) resv;
3042                     compv = (melt_ptr_t) curpair;
3043                     meltgc_append_list ((melt_ptr_t) resv, curpair->hd);
3044                     /* copy, because GC might have moved values. */
3045                     curpair = (struct meltpair_st*) compv;
3046                     src = (struct meltlist_st*) srcvalv;
3047                     dst = (struct meltlist_st*) resv;
3048                 }
3049             /* end cloning from VALDESC_LIST */
3050             ;
3051             if (dst)
3052                 resv = (melt_ptr_t) dst;
3053         };
3054         break;
3055         /** cloning value descriptor #9 VALDESC_MAPOBJECTS **/
3056         /*explicit cloning for VALDESC_MAPOBJECTS*/
3057         case MELTOBMAG_MAPOBJECTS:
3058         {
3059             struct meltmapobjects_st *src = (struct meltmapobjects_st*) srcvalv;
3060             struct meltmapobjects_st *dst = NULL;
3061             /* explicit clone chunk for VALDESC_MAPOBJECTS:*/
3062             /* cloning, from VALDESC_MAPOBJECTS in warmelt-base.melt */
3063             // in file warmelt-base.melt line 2281
3064             unsigned srccount = src->count;
3065             unsigned srclen = melt_primtab[src->lenix];
3066             unsigned newlen = 4*srccount/3+4;
3067             dst = (struct meltmapobjects_st*)
3068                   meltgc_new_mapobjects ((meltobject_ptr_t)newdiscrv, newlen);
3069             resv = (melt_ptr_t) dst;
3070             dst->meltmap_hash = melt_nonzerohash ();
3071             dst->meltmap_aux = src->meltmap_aux;
3072             for (unsigned srcix = 0;
3073                     srcix < srclen;
3074                     srcix++)
3075                 {
3076                     meltobject_ptr_t curat = NULL;
3077                     melt_ptr_t curva = NULL;
3078                     src = (struct meltmapobjects_st*) srcvalv;
3079                     curat = src->entab[srcix].e_at;
3080                     curva = src->entab[srcix].e_va;
3081                     if (!curat || curat == (meltobject_ptr_t) HTAB_DELETED_ENTRY
3082                             || !curva)
3083                         continue;
3084                     meltgc_put_mapobjects((meltmapobjects_ptr_t)resv, curat, curva);
3085                     /* update the dst, since it could have moved */
3086                     dst =  (struct meltmapobjects_st*) resv;
3087                 } /* end cloning, from VALDESC_MAPOBJECTS */
3088             ;
3089             if (dst)
3090                 resv = (melt_ptr_t) dst;
3091         };
3092         break;
3093         /** cloning value descriptor #10 VALDESC_MAPSTRINGS **/
3094         /*explicit cloning for VALDESC_MAPSTRINGS*/
3095         case MELTOBMAG_MAPSTRINGS:
3096         {
3097             struct meltmapstrings_st *src = (struct meltmapstrings_st*) srcvalv;
3098             struct meltmapstrings_st *dst = NULL;
3099             /* explicit clone chunk for VALDESC_MAPSTRINGS:*/
3100             /* cloning from VALDESC_MAPSTRINGS in warmelt-base.melt */
3101             // in file warmelt-base.melt line 2406
3102             unsigned srccount = src->count;
3103             unsigned srclen = melt_primtab[src->lenix];
3104             unsigned newlen = 4*srccount/3+4;
3105             dst = (struct meltmapstrings_st*) meltgc_new_mapstrings ((meltobject_ptr_t)newdiscrv, newlen);
3106             resv = (melt_ptr_t) dst;
3107             dst->meltmap_aux = src->meltmap_aux;
3108             dst->meltmap_hash = melt_nonzerohash ();
3109             for (unsigned srcix = 0;
3110                     srcix < srclen;
3111                     srcix++)
3112                 {
3113                     const char* curat = NULL;
3114                     melt_ptr_t curva = NULL;
3115                     src = (struct meltmapstrings_st*) srcvalv;
3116                     dst = (struct meltmapstrings_st*) resv;
3117                     curat = src->entab[srcix].e_at;
3118                     if (!curat || curat == (const char*) HTAB_DELETED_ENTRY || !curat[0])
3119                         continue;
3120                     curva = src->entab[srcix].e_va;
3121                     if (!curva)
3122                         continue;
3123                     meltgc_put_mapstrings (dst, curat, curva);
3124                     dst = (struct meltmapstrings_st*) resv;
3125                 }
3126             /* end  cloning from VALDESC_MAPSTRINGS */
3127             ;
3128             if (dst)
3129                 resv = (melt_ptr_t) dst;
3130         };
3131         break;
3132         /** cloning value descriptor #11 VALDESC_MIXBIGINT **/
3133         /*no cloning for VALDESC_MIXBIGINT*/
3134         case MELTOBMAG_MIXBIGINT:
3135             break;
3136             /** cloning value descriptor #12 VALDESC_MIXINT **/
3137             /*default cloning for VALDESC_MIXINT*/
3138         case MELTOBMAG_MIXINT:
3139         {
3140             struct meltmixint_st *src = (struct meltmixint_st*) srcvalv;
3141             struct meltmixint_st *dst =
3142             (struct meltmixint_st*) meltgc_allocate (sizeof(struct meltmixint_st), 0);
3143             *dst = *src;
3144             dst->discr = (meltobject_ptr_t)newdiscrv;
3145             resv = (melt_ptr_t) dst;
3146         }
3147         break;
3148         /** cloning value descriptor #13 VALDESC_MIXLOC **/
3149         /*default cloning for VALDESC_MIXLOC*/
3150         case MELTOBMAG_MIXLOC:
3151         {
3152             struct meltmixloc_st *src = (struct meltmixloc_st*) srcvalv;
3153             struct meltmixloc_st *dst =
3154             (struct meltmixloc_st*) meltgc_allocate (sizeof(struct meltmixloc_st), 0);
3155             *dst = *src;
3156             dst->discr = (meltobject_ptr_t)newdiscrv;
3157             resv = (melt_ptr_t) dst;
3158         }
3159         break;
3160         /** cloning value descriptor #14 VALDESC_MULTIPLE **/
3161         /*explicit cloning for VALDESC_MULTIPLE*/
3162         case MELTOBMAG_MULTIPLE:
3163         {
3164             struct meltmultiple_st *src = (struct meltmultiple_st*) srcvalv;
3165             struct meltmultiple_st *dst = NULL;
3166             /* explicit clone chunk for VALDESC_MULTIPLE:*/
3167             /* cloning from VALDESC_MULTIPLE in warmelt-base.melt */
3168             // in file warmelt-base.melt line 2560
3169             unsigned srclen = src->nbval;
3170             dst =
3171                 (struct meltmultiple_st*) meltgc_new_multiple ((meltobject_ptr_t)newdiscrv, srclen);
3172             resv = (melt_ptr_t) dst;
3173             src = (struct meltmultiple_st*) srcvalv; /* could have moved */
3174             for (unsigned srcix = 0;
3175                     srcix < srclen;
3176                     srcix++)
3177                 dst->tabval[srcix] = src->tabval[srcix];
3178             /* end cloning from VALDESC_MULTIPLE */
3179             ;
3180             if (dst)
3181                 resv = (melt_ptr_t) dst;
3182         };
3183         break;
3184         /** cloning value descriptor #15 VALDESC_OBJECT **/
3185         /*explicit cloning for VALDESC_OBJECT*/
3186         case MELTOBMAG_OBJECT:
3187         {
3188             struct meltobject_st *src = (struct meltobject_st*) srcvalv;
3189             struct meltobject_st *dst = NULL;
3190             /* explicit clone chunk for VALDESC_OBJECT:*/
3191             /* cloning, from VALDESC_OBJECT */
3192             // in file warmelt-base.melt line 2144
3193             unsigned newlen = 0;
3194             unsigned srclen = src->obj_len;
3195             unsigned slotix = 0;
3196             if (melt_is_subclass_of((meltobject_ptr_t)srcdiscrv,
3197                                     (meltobject_ptr_t)newdiscrv))
3198                 {
3199                     newlen =
3200                         melt_multiple_length ((melt_ptr_t)
3201                                               (((meltobject_ptr_t)newdiscrv)->obj_vartab[MELTFIELD_CLASS_FIELDS]));
3202                     gcc_assert (newlen <= srclen);
3203                     dst =  meltgc_new_raw_object ((meltobject_ptr_t)newdiscrv, newlen);
3204                     for (slotix = 0;
3205                             slotix < newlen;
3206                             slotix++)
3207                         dst->obj_vartab[slotix] = src->obj_vartab[slotix];
3208                     dst->obj_num = src->obj_num;
3209                 }
3210             else if (melt_is_subclass_of((meltobject_ptr_t)newdiscrv,
3211                                          (meltobject_ptr_t)srcdiscrv))
3212                 {
3213                     newlen =
3214                         melt_multiple_length ((melt_ptr_t)
3215                                               (((meltobject_ptr_t)newdiscrv)->obj_vartab[MELTFIELD_CLASS_FIELDS]));
3216                     gcc_assert (newlen >= srclen);
3217                     dst =  meltgc_new_raw_object ((meltobject_ptr_t)newdiscrv, newlen);
3218                     for (slotix = 0;
3219                             slotix < srclen;
3220                             slotix++)
3221                         dst->obj_vartab[slotix] = src->obj_vartab[slotix];
3222                     dst->obj_num = src->obj_num;
3223                 }
3224 #if ENABLE_CHECKING
3225             /* for low level debugging with gdb, we may want to catch some clone operations */
3226             if (melt_alptr_1 && (void*) src == melt_alptr_1)
3227                 melt_break_alptr_1 ("cloneobj src=alptr1");
3228             if (melt_alptr_2 && (void*) src == melt_alptr_2)
3229                 melt_break_alptr_2 ("cloneobj src=alptr2");
3230             if (src->obj_hash == melt_objhash_1)
3231                 melt_break_objhash_1("cloneobj src with objhash1");
3232             if (src->obj_hash == melt_objhash_2)
3233                 melt_break_objhash_2("cloneobj src with objhash2");
3234 #endif /* ENABLE_CHECKING */
3235             ;
3236             if (dst)
3237                 resv = (melt_ptr_t) dst;
3238         };
3239         break;
3240         /** cloning value descriptor #16 VALDESC_PAIR **/
3241         /*default cloning for VALDESC_PAIR*/
3242         case MELTOBMAG_PAIR:
3243         {
3244             struct meltpair_st *src = (struct meltpair_st*) srcvalv;
3245             struct meltpair_st *dst =
3246             (struct meltpair_st*) meltgc_allocate (sizeof(struct meltpair_st), 0);
3247             *dst = *src;
3248             dst->discr = (meltobject_ptr_t)newdiscrv;
3249             resv = (melt_ptr_t) dst;
3250         }
3251         break;
3252         /** cloning value descriptor #17 VALDESC_REAL **/
3253         /*default cloning for VALDESC_REAL*/
3254         case MELTOBMAG_REAL:
3255         {
3256             struct meltreal_st *src = (struct meltreal_st*) srcvalv;
3257             struct meltreal_st *dst =
3258             (struct meltreal_st*) meltgc_allocate (sizeof(struct meltreal_st), 0);
3259             *dst = *src;
3260             dst->discr = (meltobject_ptr_t)newdiscrv;
3261             resv = (melt_ptr_t) dst;
3262         }
3263         break;
3264         /** cloning value descriptor #18 VALDESC_ROUTINE **/
3265         /*no cloning for VALDESC_ROUTINE*/
3266         case MELTOBMAG_ROUTINE:
3267             break;
3268             /** cloning value descriptor #19 VALDESC_SPECIAL_DATA **/
3269             /*no cloning for VALDESC_SPECIAL_DATA*/
3270         case MELTOBMAG_SPECIAL_DATA:
3271             break;
3272             /** cloning value descriptor #20 VALDESC_STRBUF **/
3273             /*explicit cloning for VALDESC_STRBUF*/
3274         case MELTOBMAG_STRBUF:
3275         {
3276             struct meltstrbuf_st *src = (struct meltstrbuf_st*) srcvalv;
3277             struct meltstrbuf_st *dst = NULL;
3278             /* explicit clone chunk for VALDESC_STRBUF:*/
3279             /* clone chunk from VALDESC_STRBUF in warmelt-base.melt */
3280             // in file warmelt-base.melt line 3177
3281             dst = (struct meltstrbuf_st*)
3282                   meltgc_new_strbuf ((meltobject_ptr_t)newdiscrv, NULL);
3283             resv = (melt_ptr_t) dst;
3284             src = (struct meltstrbuf_st*)srcvalv;
3285             meltgc_add_strbuf ((melt_ptr_t) dst, melt_strbuf_str ((melt_ptr_t)src));
3286             /* end clone chunk from VALDESC_STRBUF */
3287             ;
3288             if (dst)
3289                 resv = (melt_ptr_t) dst;
3290         };
3291         break;
3292         /** cloning value descriptor #21 VALDESC_STRING **/
3293         /*explicit cloning for VALDESC_STRING*/
3294         case MELTOBMAG_STRING:
3295         {
3296             struct meltstring_st *src = (struct meltstring_st*) srcvalv;
3297             struct meltstring_st *dst = NULL;
3298             /* explicit clone chunk for VALDESC_STRING:*/
3299             /* clone from VALDESC_STRING  file warmelt-base.melt */
3300             // in file warmelt-base.melt line 3114
3301             dst = (struct meltstring_st*)
3302                   meltgc_new_stringdup ((meltobject_ptr_t)newdiscrv,
3303                                         src->val);
3304             resv = (melt_ptr_t) dst;
3305             /* end clone from VALDESC_STRING  */
3306             ;
3307             if (dst)
3308                 resv = (melt_ptr_t) dst;
3309         };
3310         break;
3311
3312         /* generated cloning routine trailer */
3313         default:
3314             ;
3315         } /*end switch srcmagic for cloning */
3316 end:
3317     MELT_EXITFRAME();
3318     return (melt_ptr_t) resv;
3319 }  /* end of generated meltgc_clone_with_discriminant */
3320 #undef resv
3321 #undef srcvalv
3322 #undef newdiscrv
3323 #undef discrv
3324 #undef compv
3325
3326
3327 /*code generated by generate_runtypesupport_predefined_hooks for 161 predefined */
3328
3329
3330
3331
3332
3333
3334
3335
3336
3337
3338
3339
3340
3341
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352
3353
3354
3355
3356
3357
3358
3359
3360
3361
3362
3363
3364
3365
3366
3367
3368
3369
3370
3371
3372
3373
3374
3375
3376
3377
3378
3379
3380
3381
3382
3383
3384
3385
3386
3387
3388
3389
3390
3391
3392
3393
3394
3395
3396
3397
3398
3399
3400
3401
3402
3403
3404
3405
3406
3407
3408
3409
3410
3411
3412
3413
3414
3415
3416
3417
3418
3419
3420
3421
3422
3423
3424
3425
3426
3427
3428
3429
3430
3431
3432
3433
3434
3435
3436
3437
3438
3439
3440 /*predefined hook definition HOOK_ALL_IPA_PASSES_END #112*/
3441 void melthookproc_HOOK_ALL_IPA_PASSES_END()
3442 {
3443     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_ALL_IPA_PASSES_END*/
3444 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3445     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_ALL_IPA_PASSES_END);
3446     typedef void melthooksig_HOOK_ALL_IPA_PASSES_END_t (melt_ptr_t);
3447     /*checkhook exist*/
3448     melt_assertmsg (" check predefhook HOOK_ALL_IPA_PASSES_END exists",
3449                     melthkp != NULL);
3450     /*checkhook ishook*/
3451     melt_assertmsg (" check predefhook HOOK_ALL_IPA_PASSES_END is hook",
3452                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3453     /* check hook routine HOOK_ALL_IPA_PASSES_END */
3454     melthooksig_HOOK_ALL_IPA_PASSES_END_t *melthookptr_HOOK_ALL_IPA_PASSES_END =
3455         reinterpret_cast <melthooksig_HOOK_ALL_IPA_PASSES_END_t*>
3456         (melthkp->hookad) ;
3457     melt_assertmsg("check predefhook routine HOOK_ALL_IPA_PASSES_END",
3458                    melthookptr_HOOK_ALL_IPA_PASSES_END);
3459
3460     /* check predefhook HOOK_ALL_IPA_PASSES_END name */
3461     melt_assertmsg("check predefhook name HOOK_ALL_IPA_PASSES_END",
3462                    !strncmp (melthkp->hookname,
3463                              "HOOK_ALL_IPA_PASSES_END", MELT_HOOKNAME_LEN-1));
3464     return (*melthookptr_HOOK_ALL_IPA_PASSES_END) ((melt_ptr_t)melthkp);
3465 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3466 } /* end  melthookproc_HOOK_ALL_IPA_PASSES_END */
3467
3468
3469
3470 /*predefined hook definition HOOK_ALL_IPA_PASSES_START #113*/
3471 void melthookproc_HOOK_ALL_IPA_PASSES_START()
3472 {
3473     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_ALL_IPA_PASSES_START*/
3474 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3475     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_ALL_IPA_PASSES_START);
3476     typedef void melthooksig_HOOK_ALL_IPA_PASSES_START_t (melt_ptr_t);
3477     /*checkhook exist*/
3478     melt_assertmsg (" check predefhook HOOK_ALL_IPA_PASSES_START exists",
3479                     melthkp != NULL);
3480     /*checkhook ishook*/
3481     melt_assertmsg (" check predefhook HOOK_ALL_IPA_PASSES_START is hook",
3482                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3483     /* check hook routine HOOK_ALL_IPA_PASSES_START */
3484     melthooksig_HOOK_ALL_IPA_PASSES_START_t *melthookptr_HOOK_ALL_IPA_PASSES_START =
3485         reinterpret_cast <melthooksig_HOOK_ALL_IPA_PASSES_START_t*>
3486         (melthkp->hookad) ;
3487     melt_assertmsg("check predefhook routine HOOK_ALL_IPA_PASSES_START",
3488                    melthookptr_HOOK_ALL_IPA_PASSES_START);
3489
3490     /* check predefhook HOOK_ALL_IPA_PASSES_START name */
3491     melt_assertmsg("check predefhook name HOOK_ALL_IPA_PASSES_START",
3492                    !strncmp (melthkp->hookname,
3493                              "HOOK_ALL_IPA_PASSES_START", MELT_HOOKNAME_LEN-1));
3494     return (*melthookptr_HOOK_ALL_IPA_PASSES_START) ((melt_ptr_t)melthkp);
3495 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3496 } /* end  melthookproc_HOOK_ALL_IPA_PASSES_START */
3497
3498
3499
3500 /*predefined hook definition HOOK_ALL_PASSES_END #114*/
3501 void melthookproc_HOOK_ALL_PASSES_END()
3502 {
3503     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_ALL_PASSES_END*/
3504 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3505     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_ALL_PASSES_END);
3506     typedef void melthooksig_HOOK_ALL_PASSES_END_t (melt_ptr_t);
3507     /*checkhook exist*/
3508     melt_assertmsg (" check predefhook HOOK_ALL_PASSES_END exists",
3509                     melthkp != NULL);
3510     /*checkhook ishook*/
3511     melt_assertmsg (" check predefhook HOOK_ALL_PASSES_END is hook",
3512                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3513     /* check hook routine HOOK_ALL_PASSES_END */
3514     melthooksig_HOOK_ALL_PASSES_END_t *melthookptr_HOOK_ALL_PASSES_END =
3515         reinterpret_cast <melthooksig_HOOK_ALL_PASSES_END_t*>
3516         (melthkp->hookad) ;
3517     melt_assertmsg("check predefhook routine HOOK_ALL_PASSES_END",
3518                    melthookptr_HOOK_ALL_PASSES_END);
3519
3520     /* check predefhook HOOK_ALL_PASSES_END name */
3521     melt_assertmsg("check predefhook name HOOK_ALL_PASSES_END",
3522                    !strncmp (melthkp->hookname,
3523                              "HOOK_ALL_PASSES_END", MELT_HOOKNAME_LEN-1));
3524     return (*melthookptr_HOOK_ALL_PASSES_END) ((melt_ptr_t)melthkp);
3525 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3526 } /* end  melthookproc_HOOK_ALL_PASSES_END */
3527
3528
3529
3530 /*predefined hook definition HOOK_ALL_PASSES_START #115*/
3531 void melthookproc_HOOK_ALL_PASSES_START()
3532 {
3533     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_ALL_PASSES_START*/
3534 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3535     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_ALL_PASSES_START);
3536     typedef void melthooksig_HOOK_ALL_PASSES_START_t (melt_ptr_t);
3537     /*checkhook exist*/
3538     melt_assertmsg (" check predefhook HOOK_ALL_PASSES_START exists",
3539                     melthkp != NULL);
3540     /*checkhook ishook*/
3541     melt_assertmsg (" check predefhook HOOK_ALL_PASSES_START is hook",
3542                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3543     /* check hook routine HOOK_ALL_PASSES_START */
3544     melthooksig_HOOK_ALL_PASSES_START_t *melthookptr_HOOK_ALL_PASSES_START =
3545         reinterpret_cast <melthooksig_HOOK_ALL_PASSES_START_t*>
3546         (melthkp->hookad) ;
3547     melt_assertmsg("check predefhook routine HOOK_ALL_PASSES_START",
3548                    melthookptr_HOOK_ALL_PASSES_START);
3549
3550     /* check predefhook HOOK_ALL_PASSES_START name */
3551     melt_assertmsg("check predefhook name HOOK_ALL_PASSES_START",
3552                    !strncmp (melthkp->hookname,
3553                              "HOOK_ALL_PASSES_START", MELT_HOOKNAME_LEN-1));
3554     return (*melthookptr_HOOK_ALL_PASSES_START) ((melt_ptr_t)melthkp);
3555 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3556 } /* end  melthookproc_HOOK_ALL_PASSES_START */
3557
3558
3559
3560 /*predefined hook definition HOOK_EARLY_GIMPLE_PASSES_END #116*/
3561 void melthookproc_HOOK_EARLY_GIMPLE_PASSES_END()
3562 {
3563     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_EARLY_GIMPLE_PASSES_END*/
3564 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3565     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_EARLY_GIMPLE_PASSES_END);
3566     typedef void melthooksig_HOOK_EARLY_GIMPLE_PASSES_END_t (melt_ptr_t);
3567     /*checkhook exist*/
3568     melt_assertmsg (" check predefhook HOOK_EARLY_GIMPLE_PASSES_END exists",
3569                     melthkp != NULL);
3570     /*checkhook ishook*/
3571     melt_assertmsg (" check predefhook HOOK_EARLY_GIMPLE_PASSES_END is hook",
3572                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3573     /* check hook routine HOOK_EARLY_GIMPLE_PASSES_END */
3574     melthooksig_HOOK_EARLY_GIMPLE_PASSES_END_t *melthookptr_HOOK_EARLY_GIMPLE_PASSES_END =
3575         reinterpret_cast <melthooksig_HOOK_EARLY_GIMPLE_PASSES_END_t*>
3576         (melthkp->hookad) ;
3577     melt_assertmsg("check predefhook routine HOOK_EARLY_GIMPLE_PASSES_END",
3578                    melthookptr_HOOK_EARLY_GIMPLE_PASSES_END);
3579
3580     /* check predefhook HOOK_EARLY_GIMPLE_PASSES_END name */
3581     melt_assertmsg("check predefhook name HOOK_EARLY_GIMPLE_PASSES_END",
3582                    !strncmp (melthkp->hookname,
3583                              "HOOK_EARLY_GIMPLE_PASSES_END", MELT_HOOKNAME_LEN-1));
3584     return (*melthookptr_HOOK_EARLY_GIMPLE_PASSES_END) ((melt_ptr_t)melthkp);
3585 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3586 } /* end  melthookproc_HOOK_EARLY_GIMPLE_PASSES_END */
3587
3588
3589
3590 /*predefined hook definition HOOK_EARLY_GIMPLE_PASSES_START #117*/
3591 void melthookproc_HOOK_EARLY_GIMPLE_PASSES_START()
3592 {
3593     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_EARLY_GIMPLE_PASSES_START*/
3594 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3595     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_EARLY_GIMPLE_PASSES_START);
3596     typedef void melthooksig_HOOK_EARLY_GIMPLE_PASSES_START_t (melt_ptr_t);
3597     /*checkhook exist*/
3598     melt_assertmsg (" check predefhook HOOK_EARLY_GIMPLE_PASSES_START exists",
3599                     melthkp != NULL);
3600     /*checkhook ishook*/
3601     melt_assertmsg (" check predefhook HOOK_EARLY_GIMPLE_PASSES_START is hook",
3602                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3603     /* check hook routine HOOK_EARLY_GIMPLE_PASSES_START */
3604     melthooksig_HOOK_EARLY_GIMPLE_PASSES_START_t *melthookptr_HOOK_EARLY_GIMPLE_PASSES_START =
3605         reinterpret_cast <melthooksig_HOOK_EARLY_GIMPLE_PASSES_START_t*>
3606         (melthkp->hookad) ;
3607     melt_assertmsg("check predefhook routine HOOK_EARLY_GIMPLE_PASSES_START",
3608                    melthookptr_HOOK_EARLY_GIMPLE_PASSES_START);
3609
3610     /* check predefhook HOOK_EARLY_GIMPLE_PASSES_START name */
3611     melt_assertmsg("check predefhook name HOOK_EARLY_GIMPLE_PASSES_START",
3612                    !strncmp (melthkp->hookname,
3613                              "HOOK_EARLY_GIMPLE_PASSES_START", MELT_HOOKNAME_LEN-1));
3614     return (*melthookptr_HOOK_EARLY_GIMPLE_PASSES_START) ((melt_ptr_t)melthkp);
3615 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3616 } /* end  melthookproc_HOOK_EARLY_GIMPLE_PASSES_START */
3617
3618
3619
3620 /*predefined hook definition HOOK_EXIT_FINALIZER #118*/
3621 void melthookproc_HOOK_EXIT_FINALIZER()
3622 {
3623     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_EXIT_FINALIZER*/
3624 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3625     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_EXIT_FINALIZER);
3626     typedef void melthooksig_HOOK_EXIT_FINALIZER_t (melt_ptr_t);
3627     /*checkhook exist*/
3628     melt_assertmsg (" check predefhook HOOK_EXIT_FINALIZER exists",
3629                     melthkp != NULL);
3630     /*checkhook ishook*/
3631     melt_assertmsg (" check predefhook HOOK_EXIT_FINALIZER is hook",
3632                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3633     /* check hook routine HOOK_EXIT_FINALIZER */
3634     melthooksig_HOOK_EXIT_FINALIZER_t *melthookptr_HOOK_EXIT_FINALIZER =
3635         reinterpret_cast <melthooksig_HOOK_EXIT_FINALIZER_t*>
3636         (melthkp->hookad) ;
3637     melt_assertmsg("check predefhook routine HOOK_EXIT_FINALIZER",
3638                    melthookptr_HOOK_EXIT_FINALIZER);
3639
3640     /* check predefhook HOOK_EXIT_FINALIZER name */
3641     melt_assertmsg("check predefhook name HOOK_EXIT_FINALIZER",
3642                    !strncmp (melthkp->hookname,
3643                              "HOOK_EXIT_FINALIZER", MELT_HOOKNAME_LEN-1));
3644     return (*melthookptr_HOOK_EXIT_FINALIZER) ((melt_ptr_t)melthkp);
3645 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3646 } /* end  melthookproc_HOOK_EXIT_FINALIZER */
3647
3648
3649
3650 /*predefined hook definition HOOK_FINISH_DECL #119*/
3651 void melthookproc_HOOK_FINISH_DECL(tree meltin_TFNDECL_p0)
3652 {
3653     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_FINISH_DECL*/
3654 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3655     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_FINISH_DECL);
3656     typedef void melthooksig_HOOK_FINISH_DECL_t (melt_ptr_t, tree);
3657     /*checkhook exist*/
3658     melt_assertmsg (" check predefhook HOOK_FINISH_DECL exists",
3659                     melthkp != NULL);
3660     /*checkhook ishook*/
3661     melt_assertmsg (" check predefhook HOOK_FINISH_DECL is hook",
3662                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3663     /* check hook routine HOOK_FINISH_DECL */
3664     melthooksig_HOOK_FINISH_DECL_t *melthookptr_HOOK_FINISH_DECL =
3665         reinterpret_cast <melthooksig_HOOK_FINISH_DECL_t*>
3666         (melthkp->hookad) ;
3667     melt_assertmsg("check predefhook routine HOOK_FINISH_DECL",
3668                    melthookptr_HOOK_FINISH_DECL);
3669
3670     /* check predefhook HOOK_FINISH_DECL name */
3671     melt_assertmsg("check predefhook name HOOK_FINISH_DECL",
3672                    !strncmp (melthkp->hookname,
3673                              "HOOK_FINISH_DECL", MELT_HOOKNAME_LEN-1));
3674     return (*melthookptr_HOOK_FINISH_DECL) ((melt_ptr_t)melthkp,
3675                                             meltin_TFNDECL_p0);
3676 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3677 } /* end  melthookproc_HOOK_FINISH_DECL */
3678
3679
3680
3681 /*predefined hook definition HOOK_FINISH_TYPE #120*/
3682 void melthookproc_HOOK_FINISH_TYPE(tree meltin_TFNDECL_p0)
3683 {
3684     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_FINISH_TYPE*/
3685 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3686     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_FINISH_TYPE);
3687     typedef void melthooksig_HOOK_FINISH_TYPE_t (melt_ptr_t, tree);
3688     /*checkhook exist*/
3689     melt_assertmsg (" check predefhook HOOK_FINISH_TYPE exists",
3690                     melthkp != NULL);
3691     /*checkhook ishook*/
3692     melt_assertmsg (" check predefhook HOOK_FINISH_TYPE is hook",
3693                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3694     /* check hook routine HOOK_FINISH_TYPE */
3695     melthooksig_HOOK_FINISH_TYPE_t *melthookptr_HOOK_FINISH_TYPE =
3696         reinterpret_cast <melthooksig_HOOK_FINISH_TYPE_t*>
3697         (melthkp->hookad) ;
3698     melt_assertmsg("check predefhook routine HOOK_FINISH_TYPE",
3699                    melthookptr_HOOK_FINISH_TYPE);
3700
3701     /* check predefhook HOOK_FINISH_TYPE name */
3702     melt_assertmsg("check predefhook name HOOK_FINISH_TYPE",
3703                    !strncmp (melthkp->hookname,
3704                              "HOOK_FINISH_TYPE", MELT_HOOKNAME_LEN-1));
3705     return (*melthookptr_HOOK_FINISH_TYPE) ((melt_ptr_t)melthkp,
3706                                             meltin_TFNDECL_p0);
3707 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3708 } /* end  melthookproc_HOOK_FINISH_TYPE */
3709
3710
3711
3712 /*predefined hook definition HOOK_FINISH_UNIT #121*/
3713 void melthookproc_HOOK_FINISH_UNIT()
3714 {
3715     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_FINISH_UNIT*/
3716 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3717     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_FINISH_UNIT);
3718     typedef void melthooksig_HOOK_FINISH_UNIT_t (melt_ptr_t);
3719     /*checkhook exist*/
3720     melt_assertmsg (" check predefhook HOOK_FINISH_UNIT exists",
3721                     melthkp != NULL);
3722     /*checkhook ishook*/
3723     melt_assertmsg (" check predefhook HOOK_FINISH_UNIT is hook",
3724                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3725     /* check hook routine HOOK_FINISH_UNIT */
3726     melthooksig_HOOK_FINISH_UNIT_t *melthookptr_HOOK_FINISH_UNIT =
3727         reinterpret_cast <melthooksig_HOOK_FINISH_UNIT_t*>
3728         (melthkp->hookad) ;
3729     melt_assertmsg("check predefhook routine HOOK_FINISH_UNIT",
3730                    melthookptr_HOOK_FINISH_UNIT);
3731
3732     /* check predefhook HOOK_FINISH_UNIT name */
3733     melt_assertmsg("check predefhook name HOOK_FINISH_UNIT",
3734                    !strncmp (melthkp->hookname,
3735                              "HOOK_FINISH_UNIT", MELT_HOOKNAME_LEN-1));
3736     return (*melthookptr_HOOK_FINISH_UNIT) ((melt_ptr_t)melthkp);
3737 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3738 } /* end  melthookproc_HOOK_FINISH_UNIT */
3739
3740
3741
3742 /*predefined hook definition HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER #122*/
3743 melt_ptr_t melthookproc_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER(melt_ptr_t meltin_PREVENV_p0, const char* meltin_MODULNAME_p1)
3744 {
3745     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER*/
3746 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3747     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER);
3748     typedef melt_ptr_t melthooksig_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER_t (melt_ptr_t, melt_ptr_t, const char*);
3749     /*checkhook exist*/
3750     melt_assertmsg (" check predefhook HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER exists",
3751                     melthkp != NULL);
3752     /*checkhook ishook*/
3753     melt_assertmsg (" check predefhook HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER is hook",
3754                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3755     /* check hook routine HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER */
3756     melthooksig_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER_t *melthookptr_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER =
3757         reinterpret_cast <melthooksig_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER_t*>
3758         (melthkp->hookad) ;
3759     melt_assertmsg("check predefhook routine HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER",
3760                    melthookptr_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER);
3761
3762     /* check predefhook HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER name */
3763     melt_assertmsg("check predefhook name HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER",
3764                    !strncmp (melthkp->hookname,
3765                              "HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER", MELT_HOOKNAME_LEN-1));
3766     return (*melthookptr_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER) ((melt_ptr_t)melthkp,
3767             meltin_PREVENV_p0,
3768             meltin_MODULNAME_p1);
3769 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3770 } /* end  melthookproc_HOOK_FRESH_ENVIRONMENT_REFERENCE_MAKER */
3771
3772
3773
3774 /*predefined hook definition HOOK_GIMPLE_EXECUTE #123*/
3775 long melthookproc_HOOK_GIMPLE_EXECUTE()
3776 {
3777     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_GIMPLE_EXECUTE*/
3778 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3779     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_GIMPLE_EXECUTE);
3780     typedef long melthooksig_HOOK_GIMPLE_EXECUTE_t (melt_ptr_t);
3781     /*checkhook exist*/
3782     melt_assertmsg (" check predefhook HOOK_GIMPLE_EXECUTE exists",
3783                     melthkp != NULL);
3784     /*checkhook ishook*/
3785     melt_assertmsg (" check predefhook HOOK_GIMPLE_EXECUTE is hook",
3786                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3787     /* check hook routine HOOK_GIMPLE_EXECUTE */
3788     melthooksig_HOOK_GIMPLE_EXECUTE_t *melthookptr_HOOK_GIMPLE_EXECUTE =
3789         reinterpret_cast <melthooksig_HOOK_GIMPLE_EXECUTE_t*>
3790         (melthkp->hookad) ;
3791     melt_assertmsg("check predefhook routine HOOK_GIMPLE_EXECUTE",
3792                    melthookptr_HOOK_GIMPLE_EXECUTE);
3793
3794     /* check predefhook HOOK_GIMPLE_EXECUTE name */
3795     melt_assertmsg("check predefhook name HOOK_GIMPLE_EXECUTE",
3796                    !strncmp (melthkp->hookname,
3797                              "HOOK_GIMPLE_EXECUTE", MELT_HOOKNAME_LEN-1));
3798     return (*melthookptr_HOOK_GIMPLE_EXECUTE) ((melt_ptr_t)melthkp);
3799 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3800 } /* end  melthookproc_HOOK_GIMPLE_EXECUTE */
3801
3802
3803
3804 /*predefined hook definition HOOK_GIMPLE_GATE #124*/
3805 long melthookproc_HOOK_GIMPLE_GATE()
3806 {
3807     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_GIMPLE_GATE*/
3808 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3809     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_GIMPLE_GATE);
3810     typedef long melthooksig_HOOK_GIMPLE_GATE_t (melt_ptr_t);
3811     /*checkhook exist*/
3812     melt_assertmsg (" check predefhook HOOK_GIMPLE_GATE exists",
3813                     melthkp != NULL);
3814     /*checkhook ishook*/
3815     melt_assertmsg (" check predefhook HOOK_GIMPLE_GATE is hook",
3816                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3817     /* check hook routine HOOK_GIMPLE_GATE */
3818     melthooksig_HOOK_GIMPLE_GATE_t *melthookptr_HOOK_GIMPLE_GATE =
3819         reinterpret_cast <melthooksig_HOOK_GIMPLE_GATE_t*>
3820         (melthkp->hookad) ;
3821     melt_assertmsg("check predefhook routine HOOK_GIMPLE_GATE",
3822                    melthookptr_HOOK_GIMPLE_GATE);
3823
3824     /* check predefhook HOOK_GIMPLE_GATE name */
3825     melt_assertmsg("check predefhook name HOOK_GIMPLE_GATE",
3826                    !strncmp (melthkp->hookname,
3827                              "HOOK_GIMPLE_GATE", MELT_HOOKNAME_LEN-1));
3828     return (*melthookptr_HOOK_GIMPLE_GATE) ((melt_ptr_t)melthkp);
3829 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3830 } /* end  melthookproc_HOOK_GIMPLE_GATE */
3831
3832
3833
3834 /*predefined hook definition HOOK_HANDLE_ATTRIBUTE #125*/
3835 tree melthookproc_HOOK_HANDLE_ATTRIBUTE(tree meltin_TR_IN_NODE_p0, tree meltin_TR_NAME_p1, tree meltin_TR_ARGS_p2, long meltin_FLAGS_p3, tree* meltout_TR_OUT_NODE_o0, long* meltout_OUT_NO_ADD_ATTRS_o1)
3836 {
3837     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_HANDLE_ATTRIBUTE*/
3838 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3839     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_HANDLE_ATTRIBUTE);
3840     typedef tree melthooksig_HOOK_HANDLE_ATTRIBUTE_t (melt_ptr_t, tree, tree, tree, long, tree* , long* );
3841     /*checkhook exist*/
3842     melt_assertmsg (" check predefhook HOOK_HANDLE_ATTRIBUTE exists",
3843                     melthkp != NULL);
3844     /*checkhook ishook*/
3845     melt_assertmsg (" check predefhook HOOK_HANDLE_ATTRIBUTE is hook",
3846                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3847     /* check hook routine HOOK_HANDLE_ATTRIBUTE */
3848     melthooksig_HOOK_HANDLE_ATTRIBUTE_t *melthookptr_HOOK_HANDLE_ATTRIBUTE =
3849         reinterpret_cast <melthooksig_HOOK_HANDLE_ATTRIBUTE_t*>
3850         (melthkp->hookad) ;
3851     melt_assertmsg("check predefhook routine HOOK_HANDLE_ATTRIBUTE",
3852                    melthookptr_HOOK_HANDLE_ATTRIBUTE);
3853
3854     /* check predefhook HOOK_HANDLE_ATTRIBUTE name */
3855     melt_assertmsg("check predefhook name HOOK_HANDLE_ATTRIBUTE",
3856                    !strncmp (melthkp->hookname,
3857                              "HOOK_HANDLE_ATTRIBUTE", MELT_HOOKNAME_LEN-1));
3858     return (*melthookptr_HOOK_HANDLE_ATTRIBUTE) ((melt_ptr_t)melthkp,
3859             meltin_TR_IN_NODE_p0,
3860             meltin_TR_NAME_p1,
3861             meltin_TR_ARGS_p2,
3862             meltin_FLAGS_p3,
3863             meltout_TR_OUT_NODE_o0,
3864             meltout_OUT_NO_ADD_ATTRS_o1);
3865 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3866 } /* end  melthookproc_HOOK_HANDLE_ATTRIBUTE */
3867
3868
3869
3870 /*predefined hook definition HOOK_HANDLE_SIGALRM #126*/
3871 void melthookproc_HOOK_HANDLE_SIGALRM()
3872 {
3873     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_HANDLE_SIGALRM*/
3874 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3875     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_HANDLE_SIGALRM);
3876     typedef void melthooksig_HOOK_HANDLE_SIGALRM_t (melt_ptr_t);
3877     /*checkhook exist*/
3878     melt_assertmsg (" check predefhook HOOK_HANDLE_SIGALRM exists",
3879                     melthkp != NULL);
3880     /*checkhook ishook*/
3881     melt_assertmsg (" check predefhook HOOK_HANDLE_SIGALRM is hook",
3882                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3883     /* check hook routine HOOK_HANDLE_SIGALRM */
3884     melthooksig_HOOK_HANDLE_SIGALRM_t *melthookptr_HOOK_HANDLE_SIGALRM =
3885         reinterpret_cast <melthooksig_HOOK_HANDLE_SIGALRM_t*>
3886         (melthkp->hookad) ;
3887     melt_assertmsg("check predefhook routine HOOK_HANDLE_SIGALRM",
3888                    melthookptr_HOOK_HANDLE_SIGALRM);
3889
3890     /* check predefhook HOOK_HANDLE_SIGALRM name */
3891     melt_assertmsg("check predefhook name HOOK_HANDLE_SIGALRM",
3892                    !strncmp (melthkp->hookname,
3893                              "HOOK_HANDLE_SIGALRM", MELT_HOOKNAME_LEN-1));
3894     return (*melthookptr_HOOK_HANDLE_SIGALRM) ((melt_ptr_t)melthkp);
3895 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3896 } /* end  melthookproc_HOOK_HANDLE_SIGALRM */
3897
3898
3899
3900 /*predefined hook definition HOOK_HANDLE_SIGCHLD #127*/
3901 void melthookproc_HOOK_HANDLE_SIGCHLD()
3902 {
3903     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_HANDLE_SIGCHLD*/
3904 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3905     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_HANDLE_SIGCHLD);
3906     typedef void melthooksig_HOOK_HANDLE_SIGCHLD_t (melt_ptr_t);
3907     /*checkhook exist*/
3908     melt_assertmsg (" check predefhook HOOK_HANDLE_SIGCHLD exists",
3909                     melthkp != NULL);
3910     /*checkhook ishook*/
3911     melt_assertmsg (" check predefhook HOOK_HANDLE_SIGCHLD is hook",
3912                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3913     /* check hook routine HOOK_HANDLE_SIGCHLD */
3914     melthooksig_HOOK_HANDLE_SIGCHLD_t *melthookptr_HOOK_HANDLE_SIGCHLD =
3915         reinterpret_cast <melthooksig_HOOK_HANDLE_SIGCHLD_t*>
3916         (melthkp->hookad) ;
3917     melt_assertmsg("check predefhook routine HOOK_HANDLE_SIGCHLD",
3918                    melthookptr_HOOK_HANDLE_SIGCHLD);
3919
3920     /* check predefhook HOOK_HANDLE_SIGCHLD name */
3921     melt_assertmsg("check predefhook name HOOK_HANDLE_SIGCHLD",
3922                    !strncmp (melthkp->hookname,
3923                              "HOOK_HANDLE_SIGCHLD", MELT_HOOKNAME_LEN-1));
3924     return (*melthookptr_HOOK_HANDLE_SIGCHLD) ((melt_ptr_t)melthkp);
3925 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3926 } /* end  melthookproc_HOOK_HANDLE_SIGCHLD */
3927
3928
3929
3930 /*predefined hook definition HOOK_HANDLE_SIGIO #128*/
3931 void melthookproc_HOOK_HANDLE_SIGIO()
3932 {
3933     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_HANDLE_SIGIO*/
3934 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3935     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_HANDLE_SIGIO);
3936     typedef void melthooksig_HOOK_HANDLE_SIGIO_t (melt_ptr_t);
3937     /*checkhook exist*/
3938     melt_assertmsg (" check predefhook HOOK_HANDLE_SIGIO exists",
3939                     melthkp != NULL);
3940     /*checkhook ishook*/
3941     melt_assertmsg (" check predefhook HOOK_HANDLE_SIGIO is hook",
3942                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3943     /* check hook routine HOOK_HANDLE_SIGIO */
3944     melthooksig_HOOK_HANDLE_SIGIO_t *melthookptr_HOOK_HANDLE_SIGIO =
3945         reinterpret_cast <melthooksig_HOOK_HANDLE_SIGIO_t*>
3946         (melthkp->hookad) ;
3947     melt_assertmsg("check predefhook routine HOOK_HANDLE_SIGIO",
3948                    melthookptr_HOOK_HANDLE_SIGIO);
3949
3950     /* check predefhook HOOK_HANDLE_SIGIO name */
3951     melt_assertmsg("check predefhook name HOOK_HANDLE_SIGIO",
3952                    !strncmp (melthkp->hookname,
3953                              "HOOK_HANDLE_SIGIO", MELT_HOOKNAME_LEN-1));
3954     return (*melthookptr_HOOK_HANDLE_SIGIO) ((melt_ptr_t)melthkp);
3955 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3956 } /* end  melthookproc_HOOK_HANDLE_SIGIO */
3957
3958
3959
3960 /*predefined hook definition HOOK_INTERN_KEYWORD #129*/
3961 melt_ptr_t melthookproc_HOOK_INTERN_KEYWORD(melt_ptr_t meltin_KEYWV_p0)
3962 {
3963     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_INTERN_KEYWORD*/
3964 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3965     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_INTERN_KEYWORD);
3966     typedef melt_ptr_t melthooksig_HOOK_INTERN_KEYWORD_t (melt_ptr_t, melt_ptr_t);
3967     /*checkhook exist*/
3968     melt_assertmsg (" check predefhook HOOK_INTERN_KEYWORD exists",
3969                     melthkp != NULL);
3970     /*checkhook ishook*/
3971     melt_assertmsg (" check predefhook HOOK_INTERN_KEYWORD is hook",
3972                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
3973     /* check hook routine HOOK_INTERN_KEYWORD */
3974     melthooksig_HOOK_INTERN_KEYWORD_t *melthookptr_HOOK_INTERN_KEYWORD =
3975         reinterpret_cast <melthooksig_HOOK_INTERN_KEYWORD_t*>
3976         (melthkp->hookad) ;
3977     melt_assertmsg("check predefhook routine HOOK_INTERN_KEYWORD",
3978                    melthookptr_HOOK_INTERN_KEYWORD);
3979
3980     /* check predefhook HOOK_INTERN_KEYWORD name */
3981     melt_assertmsg("check predefhook name HOOK_INTERN_KEYWORD",
3982                    !strncmp (melthkp->hookname,
3983                              "HOOK_INTERN_KEYWORD", MELT_HOOKNAME_LEN-1));
3984     return (*melthookptr_HOOK_INTERN_KEYWORD) ((melt_ptr_t)melthkp,
3985             meltin_KEYWV_p0);
3986 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
3987 } /* end  melthookproc_HOOK_INTERN_KEYWORD */
3988
3989
3990
3991 /*predefined hook definition HOOK_INTERN_SYMBOL #130*/
3992 melt_ptr_t melthookproc_HOOK_INTERN_SYMBOL(melt_ptr_t meltin_SYMBV_p0)
3993 {
3994     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_INTERN_SYMBOL*/
3995 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
3996     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_INTERN_SYMBOL);
3997     typedef melt_ptr_t melthooksig_HOOK_INTERN_SYMBOL_t (melt_ptr_t, melt_ptr_t);
3998     /*checkhook exist*/
3999     melt_assertmsg (" check predefhook HOOK_INTERN_SYMBOL exists",
4000                     melthkp != NULL);
4001     /*checkhook ishook*/
4002     melt_assertmsg (" check predefhook HOOK_INTERN_SYMBOL is hook",
4003                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4004     /* check hook routine HOOK_INTERN_SYMBOL */
4005     melthooksig_HOOK_INTERN_SYMBOL_t *melthookptr_HOOK_INTERN_SYMBOL =
4006         reinterpret_cast <melthooksig_HOOK_INTERN_SYMBOL_t*>
4007         (melthkp->hookad) ;
4008     melt_assertmsg("check predefhook routine HOOK_INTERN_SYMBOL",
4009                    melthookptr_HOOK_INTERN_SYMBOL);
4010
4011     /* check predefhook HOOK_INTERN_SYMBOL name */
4012     melt_assertmsg("check predefhook name HOOK_INTERN_SYMBOL",
4013                    !strncmp (melthkp->hookname,
4014                              "HOOK_INTERN_SYMBOL", MELT_HOOKNAME_LEN-1));
4015     return (*melthookptr_HOOK_INTERN_SYMBOL) ((melt_ptr_t)melthkp,
4016             meltin_SYMBV_p0);
4017 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4018 } /* end  melthookproc_HOOK_INTERN_SYMBOL */
4019
4020
4021
4022 /*predefined hook definition HOOK_INSTALL_ATTRIBUTES #131*/
4023 void melthookproc_HOOK_INSTALL_ATTRIBUTES()
4024 {
4025     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_INSTALL_ATTRIBUTES*/
4026 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4027     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_INSTALL_ATTRIBUTES);
4028     typedef void melthooksig_HOOK_INSTALL_ATTRIBUTES_t (melt_ptr_t);
4029     /*checkhook exist*/
4030     melt_assertmsg (" check predefhook HOOK_INSTALL_ATTRIBUTES exists",
4031                     melthkp != NULL);
4032     /*checkhook ishook*/
4033     melt_assertmsg (" check predefhook HOOK_INSTALL_ATTRIBUTES is hook",
4034                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4035     /* check hook routine HOOK_INSTALL_ATTRIBUTES */
4036     melthooksig_HOOK_INSTALL_ATTRIBUTES_t *melthookptr_HOOK_INSTALL_ATTRIBUTES =
4037         reinterpret_cast <melthooksig_HOOK_INSTALL_ATTRIBUTES_t*>
4038         (melthkp->hookad) ;
4039     melt_assertmsg("check predefhook routine HOOK_INSTALL_ATTRIBUTES",
4040                    melthookptr_HOOK_INSTALL_ATTRIBUTES);
4041
4042     /* check predefhook HOOK_INSTALL_ATTRIBUTES name */
4043     melt_assertmsg("check predefhook name HOOK_INSTALL_ATTRIBUTES",
4044                    !strncmp (melthkp->hookname,
4045                              "HOOK_INSTALL_ATTRIBUTES", MELT_HOOKNAME_LEN-1));
4046     return (*melthookptr_HOOK_INSTALL_ATTRIBUTES) ((melt_ptr_t)melthkp);
4047 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4048 } /* end  melthookproc_HOOK_INSTALL_ATTRIBUTES */
4049
4050
4051
4052 /*predefined hook definition HOOK_LOW_DEBUG_VALUE_AT #132*/
4053 void melthookproc_HOOK_LOW_DEBUG_VALUE_AT(melt_ptr_t meltin_VAL_p0, const char* meltin_FILENAME_p1, long meltin_LINENO_p2, const char* meltin_MSG_p3, long meltin_COUNT_p4)
4054 {
4055     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_LOW_DEBUG_VALUE_AT*/
4056 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4057     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_LOW_DEBUG_VALUE_AT);
4058     typedef void melthooksig_HOOK_LOW_DEBUG_VALUE_AT_t (melt_ptr_t, melt_ptr_t, const char*, long, const char*, long);
4059     /*checkhook exist*/
4060     melt_assertmsg (" check predefhook HOOK_LOW_DEBUG_VALUE_AT exists",
4061                     melthkp != NULL);
4062     /*checkhook ishook*/
4063     melt_assertmsg (" check predefhook HOOK_LOW_DEBUG_VALUE_AT is hook",
4064                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4065     /* check hook routine HOOK_LOW_DEBUG_VALUE_AT */
4066     melthooksig_HOOK_LOW_DEBUG_VALUE_AT_t *melthookptr_HOOK_LOW_DEBUG_VALUE_AT =
4067         reinterpret_cast <melthooksig_HOOK_LOW_DEBUG_VALUE_AT_t*>
4068         (melthkp->hookad) ;
4069     melt_assertmsg("check predefhook routine HOOK_LOW_DEBUG_VALUE_AT",
4070                    melthookptr_HOOK_LOW_DEBUG_VALUE_AT);
4071
4072     /* check predefhook HOOK_LOW_DEBUG_VALUE_AT name */
4073     melt_assertmsg("check predefhook name HOOK_LOW_DEBUG_VALUE_AT",
4074                    !strncmp (melthkp->hookname,
4075                              "HOOK_LOW_DEBUG_VALUE_AT", MELT_HOOKNAME_LEN-1));
4076     return (*melthookptr_HOOK_LOW_DEBUG_VALUE_AT) ((melt_ptr_t)melthkp,
4077             meltin_VAL_p0,
4078             meltin_FILENAME_p1,
4079             meltin_LINENO_p2,
4080             meltin_MSG_p3,
4081             meltin_COUNT_p4);
4082 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4083 } /* end  melthookproc_HOOK_LOW_DEBUG_VALUE_AT */
4084
4085
4086
4087 /*predefined hook definition HOOK_LOW_STDERR_VALUE_AT #133*/
4088 void melthookproc_HOOK_LOW_STDERR_VALUE_AT(melt_ptr_t meltin_VAL_p0, const char* meltin_FILENAME_p1, long meltin_LINENO_p2, const char* meltin_MSG_p3, long meltin_COUNT_p4)
4089 {
4090     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_LOW_STDERR_VALUE_AT*/
4091 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4092     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_LOW_STDERR_VALUE_AT);
4093     typedef void melthooksig_HOOK_LOW_STDERR_VALUE_AT_t (melt_ptr_t, melt_ptr_t, const char*, long, const char*, long);
4094     /*checkhook exist*/
4095     melt_assertmsg (" check predefhook HOOK_LOW_STDERR_VALUE_AT exists",
4096                     melthkp != NULL);
4097     /*checkhook ishook*/
4098     melt_assertmsg (" check predefhook HOOK_LOW_STDERR_VALUE_AT is hook",
4099                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4100     /* check hook routine HOOK_LOW_STDERR_VALUE_AT */
4101     melthooksig_HOOK_LOW_STDERR_VALUE_AT_t *melthookptr_HOOK_LOW_STDERR_VALUE_AT =
4102         reinterpret_cast <melthooksig_HOOK_LOW_STDERR_VALUE_AT_t*>
4103         (melthkp->hookad) ;
4104     melt_assertmsg("check predefhook routine HOOK_LOW_STDERR_VALUE_AT",
4105                    melthookptr_HOOK_LOW_STDERR_VALUE_AT);
4106
4107     /* check predefhook HOOK_LOW_STDERR_VALUE_AT name */
4108     melt_assertmsg("check predefhook name HOOK_LOW_STDERR_VALUE_AT",
4109                    !strncmp (melthkp->hookname,
4110                              "HOOK_LOW_STDERR_VALUE_AT", MELT_HOOKNAME_LEN-1));
4111     return (*melthookptr_HOOK_LOW_STDERR_VALUE_AT) ((melt_ptr_t)melthkp,
4112             meltin_VAL_p0,
4113             meltin_FILENAME_p1,
4114             meltin_LINENO_p2,
4115             meltin_MSG_p3,
4116             meltin_COUNT_p4);
4117 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4118 } /* end  melthookproc_HOOK_LOW_STDERR_VALUE_AT */
4119
4120
4121
4122 /*predefined hook definition HOOK_MACRO_EXPORTER #134*/
4123 void melthookproc_HOOK_MACRO_EXPORTER(melt_ptr_t meltin_SYM_p0, melt_ptr_t meltin_VAL_p1, melt_ptr_t meltin_CONTENV_p2)
4124 {
4125     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_MACRO_EXPORTER*/
4126 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4127     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_MACRO_EXPORTER);
4128     typedef void melthooksig_HOOK_MACRO_EXPORTER_t (melt_ptr_t, melt_ptr_t, melt_ptr_t, melt_ptr_t);
4129     /*checkhook exist*/
4130     melt_assertmsg (" check predefhook HOOK_MACRO_EXPORTER exists",
4131                     melthkp != NULL);
4132     /*checkhook ishook*/
4133     melt_assertmsg (" check predefhook HOOK_MACRO_EXPORTER is hook",
4134                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4135     /* check hook routine HOOK_MACRO_EXPORTER */
4136     melthooksig_HOOK_MACRO_EXPORTER_t *melthookptr_HOOK_MACRO_EXPORTER =
4137         reinterpret_cast <melthooksig_HOOK_MACRO_EXPORTER_t*>
4138         (melthkp->hookad) ;
4139     melt_assertmsg("check predefhook routine HOOK_MACRO_EXPORTER",
4140                    melthookptr_HOOK_MACRO_EXPORTER);
4141
4142     /* check predefhook HOOK_MACRO_EXPORTER name */
4143     melt_assertmsg("check predefhook name HOOK_MACRO_EXPORTER",
4144                    !strncmp (melthkp->hookname,
4145                              "HOOK_MACRO_EXPORTER", MELT_HOOKNAME_LEN-1));
4146     return (*melthookptr_HOOK_MACRO_EXPORTER) ((melt_ptr_t)melthkp,
4147             meltin_SYM_p0,
4148             meltin_VAL_p1,
4149             meltin_CONTENV_p2);
4150 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4151 } /* end  melthookproc_HOOK_MACRO_EXPORTER */
4152
4153
4154
4155 /*predefined hook definition HOOK_MACRO_INSTALLER #135*/
4156 void melthookproc_HOOK_MACRO_INSTALLER(melt_ptr_t meltin_MBIND_p0, melt_ptr_t meltin_MEXPCLOS_p1)
4157 {
4158     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_MACRO_INSTALLER*/
4159 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4160     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_MACRO_INSTALLER);
4161     typedef void melthooksig_HOOK_MACRO_INSTALLER_t (melt_ptr_t, melt_ptr_t, melt_ptr_t);
4162     /*checkhook exist*/
4163     melt_assertmsg (" check predefhook HOOK_MACRO_INSTALLER exists",
4164                     melthkp != NULL);
4165     /*checkhook ishook*/
4166     melt_assertmsg (" check predefhook HOOK_MACRO_INSTALLER is hook",
4167                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4168     /* check hook routine HOOK_MACRO_INSTALLER */
4169     melthooksig_HOOK_MACRO_INSTALLER_t *melthookptr_HOOK_MACRO_INSTALLER =
4170         reinterpret_cast <melthooksig_HOOK_MACRO_INSTALLER_t*>
4171         (melthkp->hookad) ;
4172     melt_assertmsg("check predefhook routine HOOK_MACRO_INSTALLER",
4173                    melthookptr_HOOK_MACRO_INSTALLER);
4174
4175     /* check predefhook HOOK_MACRO_INSTALLER name */
4176     melt_assertmsg("check predefhook name HOOK_MACRO_INSTALLER",
4177                    !strncmp (melthkp->hookname,
4178                              "HOOK_MACRO_INSTALLER", MELT_HOOKNAME_LEN-1));
4179     return (*melthookptr_HOOK_MACRO_INSTALLER) ((melt_ptr_t)melthkp,
4180             meltin_MBIND_p0,
4181             meltin_MEXPCLOS_p1);
4182 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4183 } /* end  melthookproc_HOOK_MACRO_INSTALLER */
4184
4185
4186
4187 /*predefined hook definition HOOK_MELT_DO_INITIAL_MODE #136*/
4188 void melthookproc_HOOK_MELT_DO_INITIAL_MODE(melt_ptr_t meltin_MODATA_p0, const char* meltin_MODSTR_p1)
4189 {
4190     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_MELT_DO_INITIAL_MODE*/
4191 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4192     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_MELT_DO_INITIAL_MODE);
4193     typedef void melthooksig_HOOK_MELT_DO_INITIAL_MODE_t (melt_ptr_t, melt_ptr_t, const char*);
4194     /*checkhook exist*/
4195     melt_assertmsg (" check predefhook HOOK_MELT_DO_INITIAL_MODE exists",
4196                     melthkp != NULL);
4197     /*checkhook ishook*/
4198     melt_assertmsg (" check predefhook HOOK_MELT_DO_INITIAL_MODE is hook",
4199                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4200     /* check hook routine HOOK_MELT_DO_INITIAL_MODE */
4201     melthooksig_HOOK_MELT_DO_INITIAL_MODE_t *melthookptr_HOOK_MELT_DO_INITIAL_MODE =
4202         reinterpret_cast <melthooksig_HOOK_MELT_DO_INITIAL_MODE_t*>
4203         (melthkp->hookad) ;
4204     melt_assertmsg("check predefhook routine HOOK_MELT_DO_INITIAL_MODE",
4205                    melthookptr_HOOK_MELT_DO_INITIAL_MODE);
4206
4207     /* check predefhook HOOK_MELT_DO_INITIAL_MODE name */
4208     melt_assertmsg("check predefhook name HOOK_MELT_DO_INITIAL_MODE",
4209                    !strncmp (melthkp->hookname,
4210                              "HOOK_MELT_DO_INITIAL_MODE", MELT_HOOKNAME_LEN-1));
4211     return (*melthookptr_HOOK_MELT_DO_INITIAL_MODE) ((melt_ptr_t)melthkp,
4212             meltin_MODATA_p0,
4213             meltin_MODSTR_p1);
4214 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4215 } /* end  melthookproc_HOOK_MELT_DO_INITIAL_MODE */
4216
4217
4218
4219 /*predefined hook definition HOOK_MELT_MAKE_LOCATION #137*/
4220 melt_ptr_t melthookproc_HOOK_MELT_MAKE_LOCATION(const char* meltin_FILENAME_p0, long meltin_LINENO_p1)
4221 {
4222     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_MELT_MAKE_LOCATION*/
4223 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4224     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_MELT_MAKE_LOCATION);
4225     typedef melt_ptr_t melthooksig_HOOK_MELT_MAKE_LOCATION_t (melt_ptr_t, const char*, long);
4226     /*checkhook exist*/
4227     melt_assertmsg (" check predefhook HOOK_MELT_MAKE_LOCATION exists",
4228                     melthkp != NULL);
4229     /*checkhook ishook*/
4230     melt_assertmsg (" check predefhook HOOK_MELT_MAKE_LOCATION is hook",
4231                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4232     /* check hook routine HOOK_MELT_MAKE_LOCATION */
4233     melthooksig_HOOK_MELT_MAKE_LOCATION_t *melthookptr_HOOK_MELT_MAKE_LOCATION =
4234         reinterpret_cast <melthooksig_HOOK_MELT_MAKE_LOCATION_t*>
4235         (melthkp->hookad) ;
4236     melt_assertmsg("check predefhook routine HOOK_MELT_MAKE_LOCATION",
4237                    melthookptr_HOOK_MELT_MAKE_LOCATION);
4238
4239     /* check predefhook HOOK_MELT_MAKE_LOCATION name */
4240     melt_assertmsg("check predefhook name HOOK_MELT_MAKE_LOCATION",
4241                    !strncmp (melthkp->hookname,
4242                              "HOOK_MELT_MAKE_LOCATION", MELT_HOOKNAME_LEN-1));
4243     return (*melthookptr_HOOK_MELT_MAKE_LOCATION) ((melt_ptr_t)melthkp,
4244             meltin_FILENAME_p0,
4245             meltin_LINENO_p1);
4246 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4247 } /* end  melthookproc_HOOK_MELT_MAKE_LOCATION */
4248
4249
4250
4251 /*predefined hook definition HOOK_NAMED_KEYWORD #138*/
4252 melt_ptr_t melthookproc_HOOK_NAMED_KEYWORD(const char* meltin_NAM_p0, long meltin_CREATE_p1)
4253 {
4254     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_NAMED_KEYWORD*/
4255 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4256     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_NAMED_KEYWORD);
4257     typedef melt_ptr_t melthooksig_HOOK_NAMED_KEYWORD_t (melt_ptr_t, const char*, long);
4258     /*checkhook exist*/
4259     melt_assertmsg (" check predefhook HOOK_NAMED_KEYWORD exists",
4260                     melthkp != NULL);
4261     /*checkhook ishook*/
4262     melt_assertmsg (" check predefhook HOOK_NAMED_KEYWORD is hook",
4263                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4264     /* check hook routine HOOK_NAMED_KEYWORD */
4265     melthooksig_HOOK_NAMED_KEYWORD_t *melthookptr_HOOK_NAMED_KEYWORD =
4266         reinterpret_cast <melthooksig_HOOK_NAMED_KEYWORD_t*>
4267         (melthkp->hookad) ;
4268     melt_assertmsg("check predefhook routine HOOK_NAMED_KEYWORD",
4269                    melthookptr_HOOK_NAMED_KEYWORD);
4270
4271     /* check predefhook HOOK_NAMED_KEYWORD name */
4272     melt_assertmsg("check predefhook name HOOK_NAMED_KEYWORD",
4273                    !strncmp (melthkp->hookname,
4274                              "HOOK_NAMED_KEYWORD", MELT_HOOKNAME_LEN-1));
4275     return (*melthookptr_HOOK_NAMED_KEYWORD) ((melt_ptr_t)melthkp,
4276             meltin_NAM_p0,
4277             meltin_CREATE_p1);
4278 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4279 } /* end  melthookproc_HOOK_NAMED_KEYWORD */
4280
4281
4282
4283 /*predefined hook definition HOOK_NAMED_SYMBOL #139*/
4284 melt_ptr_t melthookproc_HOOK_NAMED_SYMBOL(const char* meltin_NAM_p0, long meltin_CREATE_p1)
4285 {
4286     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_NAMED_SYMBOL*/
4287 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4288     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_NAMED_SYMBOL);
4289     typedef melt_ptr_t melthooksig_HOOK_NAMED_SYMBOL_t (melt_ptr_t, const char*, long);
4290     /*checkhook exist*/
4291     melt_assertmsg (" check predefhook HOOK_NAMED_SYMBOL exists",
4292                     melthkp != NULL);
4293     /*checkhook ishook*/
4294     melt_assertmsg (" check predefhook HOOK_NAMED_SYMBOL is hook",
4295                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4296     /* check hook routine HOOK_NAMED_SYMBOL */
4297     melthooksig_HOOK_NAMED_SYMBOL_t *melthookptr_HOOK_NAMED_SYMBOL =
4298         reinterpret_cast <melthooksig_HOOK_NAMED_SYMBOL_t*>
4299         (melthkp->hookad) ;
4300     melt_assertmsg("check predefhook routine HOOK_NAMED_SYMBOL",
4301                    melthookptr_HOOK_NAMED_SYMBOL);
4302
4303     /* check predefhook HOOK_NAMED_SYMBOL name */
4304     melt_assertmsg("check predefhook name HOOK_NAMED_SYMBOL",
4305                    !strncmp (melthkp->hookname,
4306                              "HOOK_NAMED_SYMBOL", MELT_HOOKNAME_LEN-1));
4307     return (*melthookptr_HOOK_NAMED_SYMBOL) ((melt_ptr_t)melthkp,
4308             meltin_NAM_p0,
4309             meltin_CREATE_p1);
4310 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4311 } /* end  melthookproc_HOOK_NAMED_SYMBOL */
4312
4313
4314
4315 /*predefined hook definition HOOK_OVERRIDE_GATE #140*/
4316 void melthookproc_HOOK_OVERRIDE_GATE(long meltin_BEFOREGATE_p0, long* meltout_AFTERGATE_o0)
4317 {
4318     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_OVERRIDE_GATE*/
4319 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4320     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_OVERRIDE_GATE);
4321     typedef void melthooksig_HOOK_OVERRIDE_GATE_t (melt_ptr_t, long, long* );
4322     /*checkhook exist*/
4323     melt_assertmsg (" check predefhook HOOK_OVERRIDE_GATE exists",
4324                     melthkp != NULL);
4325     /*checkhook ishook*/
4326     melt_assertmsg (" check predefhook HOOK_OVERRIDE_GATE is hook",
4327                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4328     /* check hook routine HOOK_OVERRIDE_GATE */
4329     melthooksig_HOOK_OVERRIDE_GATE_t *melthookptr_HOOK_OVERRIDE_GATE =
4330         reinterpret_cast <melthooksig_HOOK_OVERRIDE_GATE_t*>
4331         (melthkp->hookad) ;
4332     melt_assertmsg("check predefhook routine HOOK_OVERRIDE_GATE",
4333                    melthookptr_HOOK_OVERRIDE_GATE);
4334
4335     /* check predefhook HOOK_OVERRIDE_GATE name */
4336     melt_assertmsg("check predefhook name HOOK_OVERRIDE_GATE",
4337                    !strncmp (melthkp->hookname,
4338                              "HOOK_OVERRIDE_GATE", MELT_HOOKNAME_LEN-1));
4339     return (*melthookptr_HOOK_OVERRIDE_GATE) ((melt_ptr_t)melthkp,
4340             meltin_BEFOREGATE_p0,
4341             meltout_AFTERGATE_o0);
4342 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4343 } /* end  melthookproc_HOOK_OVERRIDE_GATE */
4344
4345
4346
4347 /*predefined hook definition HOOK_PASS_EXECUTION #141*/
4348 void melthookproc_HOOK_PASS_EXECUTION(const char* meltin_PASSNAME_p0, long meltin_PASSNUM_p1, long meltin_TYPENUM_p2)
4349 {
4350     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_PASS_EXECUTION*/
4351 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4352     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_PASS_EXECUTION);
4353     typedef void melthooksig_HOOK_PASS_EXECUTION_t (melt_ptr_t, const char*, long, long);
4354     /*checkhook exist*/
4355     melt_assertmsg (" check predefhook HOOK_PASS_EXECUTION exists",
4356                     melthkp != NULL);
4357     /*checkhook ishook*/
4358     melt_assertmsg (" check predefhook HOOK_PASS_EXECUTION is hook",
4359                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4360     /* check hook routine HOOK_PASS_EXECUTION */
4361     melthooksig_HOOK_PASS_EXECUTION_t *melthookptr_HOOK_PASS_EXECUTION =
4362         reinterpret_cast <melthooksig_HOOK_PASS_EXECUTION_t*>
4363         (melthkp->hookad) ;
4364     melt_assertmsg("check predefhook routine HOOK_PASS_EXECUTION",
4365                    melthookptr_HOOK_PASS_EXECUTION);
4366
4367     /* check predefhook HOOK_PASS_EXECUTION name */
4368     melt_assertmsg("check predefhook name HOOK_PASS_EXECUTION",
4369                    !strncmp (melthkp->hookname,
4370                              "HOOK_PASS_EXECUTION", MELT_HOOKNAME_LEN-1));
4371     return (*melthookptr_HOOK_PASS_EXECUTION) ((melt_ptr_t)melthkp,
4372             meltin_PASSNAME_p0,
4373             meltin_PASSNUM_p1,
4374             meltin_TYPENUM_p2);
4375 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4376 } /* end  melthookproc_HOOK_PASS_EXECUTION */
4377
4378
4379
4380 /*predefined hook definition HOOK_PATMACRO_EXPORTER #142*/
4381 void melthookproc_HOOK_PATMACRO_EXPORTER(melt_ptr_t meltin_SYM_p0, melt_ptr_t meltin_MACVAL_p1, melt_ptr_t meltin_PATVAL_p2, melt_ptr_t meltin_CONTENV_p3)
4382 {
4383     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_PATMACRO_EXPORTER*/
4384 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4385     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_PATMACRO_EXPORTER);
4386     typedef void melthooksig_HOOK_PATMACRO_EXPORTER_t (melt_ptr_t, melt_ptr_t, melt_ptr_t, melt_ptr_t, melt_ptr_t);
4387     /*checkhook exist*/
4388     melt_assertmsg (" check predefhook HOOK_PATMACRO_EXPORTER exists",
4389                     melthkp != NULL);
4390     /*checkhook ishook*/
4391     melt_assertmsg (" check predefhook HOOK_PATMACRO_EXPORTER is hook",
4392                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4393     /* check hook routine HOOK_PATMACRO_EXPORTER */
4394     melthooksig_HOOK_PATMACRO_EXPORTER_t *melthookptr_HOOK_PATMACRO_EXPORTER =
4395         reinterpret_cast <melthooksig_HOOK_PATMACRO_EXPORTER_t*>
4396         (melthkp->hookad) ;
4397     melt_assertmsg("check predefhook routine HOOK_PATMACRO_EXPORTER",
4398                    melthookptr_HOOK_PATMACRO_EXPORTER);
4399
4400     /* check predefhook HOOK_PATMACRO_EXPORTER name */
4401     melt_assertmsg("check predefhook name HOOK_PATMACRO_EXPORTER",
4402                    !strncmp (melthkp->hookname,
4403                              "HOOK_PATMACRO_EXPORTER", MELT_HOOKNAME_LEN-1));
4404     return (*melthookptr_HOOK_PATMACRO_EXPORTER) ((melt_ptr_t)melthkp,
4405             meltin_SYM_p0,
4406             meltin_MACVAL_p1,
4407             meltin_PATVAL_p2,
4408             meltin_CONTENV_p3);
4409 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4410 } /* end  melthookproc_HOOK_PATMACRO_EXPORTER */
4411
4412
4413
4414 /*predefined hook definition HOOK_POLL_INPUTS #143*/
4415 void melthookproc_HOOK_POLL_INPUTS(long meltin_DELAYMS_p0)
4416 {
4417     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_POLL_INPUTS*/
4418 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4419     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_POLL_INPUTS);
4420     typedef void melthooksig_HOOK_POLL_INPUTS_t (melt_ptr_t, long);
4421     /*checkhook exist*/
4422     melt_assertmsg (" check predefhook HOOK_POLL_INPUTS exists",
4423                     melthkp != NULL);
4424     /*checkhook ishook*/
4425     melt_assertmsg (" check predefhook HOOK_POLL_INPUTS is hook",
4426                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4427     /* check hook routine HOOK_POLL_INPUTS */
4428     melthooksig_HOOK_POLL_INPUTS_t *melthookptr_HOOK_POLL_INPUTS =
4429         reinterpret_cast <melthooksig_HOOK_POLL_INPUTS_t*>
4430         (melthkp->hookad) ;
4431     melt_assertmsg("check predefhook routine HOOK_POLL_INPUTS",
4432                    melthookptr_HOOK_POLL_INPUTS);
4433
4434     /* check predefhook HOOK_POLL_INPUTS name */
4435     melt_assertmsg("check predefhook name HOOK_POLL_INPUTS",
4436                    !strncmp (melthkp->hookname,
4437                              "HOOK_POLL_INPUTS", MELT_HOOKNAME_LEN-1));
4438     return (*melthookptr_HOOK_POLL_INPUTS) ((melt_ptr_t)melthkp,
4439                                             meltin_DELAYMS_p0);
4440 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4441 } /* end  melthookproc_HOOK_POLL_INPUTS */
4442
4443
4444
4445 /*predefined hook definition HOOK_PRE_GENERICIZE #144*/
4446 void melthookproc_HOOK_PRE_GENERICIZE(tree meltin_TFNDECL_p0)
4447 {
4448     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_PRE_GENERICIZE*/
4449 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4450     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_PRE_GENERICIZE);
4451     typedef void melthooksig_HOOK_PRE_GENERICIZE_t (melt_ptr_t, tree);
4452     /*checkhook exist*/
4453     melt_assertmsg (" check predefhook HOOK_PRE_GENERICIZE exists",
4454                     melthkp != NULL);
4455     /*checkhook ishook*/
4456     melt_assertmsg (" check predefhook HOOK_PRE_GENERICIZE is hook",
4457                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4458     /* check hook routine HOOK_PRE_GENERICIZE */
4459     melthooksig_HOOK_PRE_GENERICIZE_t *melthookptr_HOOK_PRE_GENERICIZE =
4460         reinterpret_cast <melthooksig_HOOK_PRE_GENERICIZE_t*>
4461         (melthkp->hookad) ;
4462     melt_assertmsg("check predefhook routine HOOK_PRE_GENERICIZE",
4463                    melthookptr_HOOK_PRE_GENERICIZE);
4464
4465     /* check predefhook HOOK_PRE_GENERICIZE name */
4466     melt_assertmsg("check predefhook name HOOK_PRE_GENERICIZE",
4467                    !strncmp (melthkp->hookname,
4468                              "HOOK_PRE_GENERICIZE", MELT_HOOKNAME_LEN-1));
4469     return (*melthookptr_HOOK_PRE_GENERICIZE) ((melt_ptr_t)melthkp,
4470             meltin_TFNDECL_p0);
4471 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4472 } /* end  melthookproc_HOOK_PRE_GENERICIZE */
4473
4474
4475
4476 /*predefined hook definition HOOK_PROCESS_PRAGMA #145*/
4477 void melthookproc_HOOK_PROCESS_PRAGMA(long meltin_LIX_p0)
4478 {
4479     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_PROCESS_PRAGMA*/
4480 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4481     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_PROCESS_PRAGMA);
4482     typedef void melthooksig_HOOK_PROCESS_PRAGMA_t (melt_ptr_t, long);
4483     /*checkhook exist*/
4484     melt_assertmsg (" check predefhook HOOK_PROCESS_PRAGMA exists",
4485                     melthkp != NULL);
4486     /*checkhook ishook*/
4487     melt_assertmsg (" check predefhook HOOK_PROCESS_PRAGMA is hook",
4488                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4489     /* check hook routine HOOK_PROCESS_PRAGMA */
4490     melthooksig_HOOK_PROCESS_PRAGMA_t *melthookptr_HOOK_PROCESS_PRAGMA =
4491         reinterpret_cast <melthooksig_HOOK_PROCESS_PRAGMA_t*>
4492         (melthkp->hookad) ;
4493     melt_assertmsg("check predefhook routine HOOK_PROCESS_PRAGMA",
4494                    melthookptr_HOOK_PROCESS_PRAGMA);
4495
4496     /* check predefhook HOOK_PROCESS_PRAGMA name */
4497     melt_assertmsg("check predefhook name HOOK_PROCESS_PRAGMA",
4498                    !strncmp (melthkp->hookname,
4499                              "HOOK_PROCESS_PRAGMA", MELT_HOOKNAME_LEN-1));
4500     return (*melthookptr_HOOK_PROCESS_PRAGMA) ((melt_ptr_t)melthkp,
4501             meltin_LIX_p0);
4502 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4503 } /* end  melthookproc_HOOK_PROCESS_PRAGMA */
4504
4505
4506
4507 /*predefined hook definition HOOK_REGISTER_PRAGMAS #146*/
4508 void melthookproc_HOOK_REGISTER_PRAGMAS()
4509 {
4510     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_REGISTER_PRAGMAS*/
4511 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4512     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_REGISTER_PRAGMAS);
4513     typedef void melthooksig_HOOK_REGISTER_PRAGMAS_t (melt_ptr_t);
4514     /*checkhook exist*/
4515     melt_assertmsg (" check predefhook HOOK_REGISTER_PRAGMAS exists",
4516                     melthkp != NULL);
4517     /*checkhook ishook*/
4518     melt_assertmsg (" check predefhook HOOK_REGISTER_PRAGMAS is hook",
4519                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4520     /* check hook routine HOOK_REGISTER_PRAGMAS */
4521     melthooksig_HOOK_REGISTER_PRAGMAS_t *melthookptr_HOOK_REGISTER_PRAGMAS =
4522         reinterpret_cast <melthooksig_HOOK_REGISTER_PRAGMAS_t*>
4523         (melthkp->hookad) ;
4524     melt_assertmsg("check predefhook routine HOOK_REGISTER_PRAGMAS",
4525                    melthookptr_HOOK_REGISTER_PRAGMAS);
4526
4527     /* check predefhook HOOK_REGISTER_PRAGMAS name */
4528     melt_assertmsg("check predefhook name HOOK_REGISTER_PRAGMAS",
4529                    !strncmp (melthkp->hookname,
4530                              "HOOK_REGISTER_PRAGMAS", MELT_HOOKNAME_LEN-1));
4531     return (*melthookptr_HOOK_REGISTER_PRAGMAS) ((melt_ptr_t)melthkp);
4532 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4533 } /* end  melthookproc_HOOK_REGISTER_PRAGMAS */
4534
4535
4536
4537 /*predefined hook definition HOOK_RTL_EXECUTE #147*/
4538 long melthookproc_HOOK_RTL_EXECUTE()
4539 {
4540     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_RTL_EXECUTE*/
4541 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4542     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_RTL_EXECUTE);
4543     typedef long melthooksig_HOOK_RTL_EXECUTE_t (melt_ptr_t);
4544     /*checkhook exist*/
4545     melt_assertmsg (" check predefhook HOOK_RTL_EXECUTE exists",
4546                     melthkp != NULL);
4547     /*checkhook ishook*/
4548     melt_assertmsg (" check predefhook HOOK_RTL_EXECUTE is hook",
4549                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4550     /* check hook routine HOOK_RTL_EXECUTE */
4551     melthooksig_HOOK_RTL_EXECUTE_t *melthookptr_HOOK_RTL_EXECUTE =
4552         reinterpret_cast <melthooksig_HOOK_RTL_EXECUTE_t*>
4553         (melthkp->hookad) ;
4554     melt_assertmsg("check predefhook routine HOOK_RTL_EXECUTE",
4555                    melthookptr_HOOK_RTL_EXECUTE);
4556
4557     /* check predefhook HOOK_RTL_EXECUTE name */
4558     melt_assertmsg("check predefhook name HOOK_RTL_EXECUTE",
4559                    !strncmp (melthkp->hookname,
4560                              "HOOK_RTL_EXECUTE", MELT_HOOKNAME_LEN-1));
4561     return (*melthookptr_HOOK_RTL_EXECUTE) ((melt_ptr_t)melthkp);
4562 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4563 } /* end  melthookproc_HOOK_RTL_EXECUTE */
4564
4565
4566
4567 /*predefined hook definition HOOK_RTL_GATE #148*/
4568 long melthookproc_HOOK_RTL_GATE()
4569 {
4570     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_RTL_GATE*/
4571 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4572     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_RTL_GATE);
4573     typedef long melthooksig_HOOK_RTL_GATE_t (melt_ptr_t);
4574     /*checkhook exist*/
4575     melt_assertmsg (" check predefhook HOOK_RTL_GATE exists",
4576                     melthkp != NULL);
4577     /*checkhook ishook*/
4578     melt_assertmsg (" check predefhook HOOK_RTL_GATE is hook",
4579                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4580     /* check hook routine HOOK_RTL_GATE */
4581     melthooksig_HOOK_RTL_GATE_t *melthookptr_HOOK_RTL_GATE =
4582         reinterpret_cast <melthooksig_HOOK_RTL_GATE_t*>
4583         (melthkp->hookad) ;
4584     melt_assertmsg("check predefhook routine HOOK_RTL_GATE",
4585                    melthookptr_HOOK_RTL_GATE);
4586
4587     /* check predefhook HOOK_RTL_GATE name */
4588     melt_assertmsg("check predefhook name HOOK_RTL_GATE",
4589                    !strncmp (melthkp->hookname,
4590                              "HOOK_RTL_GATE", MELT_HOOKNAME_LEN-1));
4591     return (*melthookptr_HOOK_RTL_GATE) ((melt_ptr_t)melthkp);
4592 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4593 } /* end  melthookproc_HOOK_RTL_GATE */
4594
4595
4596
4597 /*predefined hook definition HOOK_SIMPLE_IPA_EXECUTE #149*/
4598 long melthookproc_HOOK_SIMPLE_IPA_EXECUTE()
4599 {
4600     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_SIMPLE_IPA_EXECUTE*/
4601 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4602     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_SIMPLE_IPA_EXECUTE);
4603     typedef long melthooksig_HOOK_SIMPLE_IPA_EXECUTE_t (melt_ptr_t);
4604     /*checkhook exist*/
4605     melt_assertmsg (" check predefhook HOOK_SIMPLE_IPA_EXECUTE exists",
4606                     melthkp != NULL);
4607     /*checkhook ishook*/
4608     melt_assertmsg (" check predefhook HOOK_SIMPLE_IPA_EXECUTE is hook",
4609                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4610     /* check hook routine HOOK_SIMPLE_IPA_EXECUTE */
4611     melthooksig_HOOK_SIMPLE_IPA_EXECUTE_t *melthookptr_HOOK_SIMPLE_IPA_EXECUTE =
4612         reinterpret_cast <melthooksig_HOOK_SIMPLE_IPA_EXECUTE_t*>
4613         (melthkp->hookad) ;
4614     melt_assertmsg("check predefhook routine HOOK_SIMPLE_IPA_EXECUTE",
4615                    melthookptr_HOOK_SIMPLE_IPA_EXECUTE);
4616
4617     /* check predefhook HOOK_SIMPLE_IPA_EXECUTE name */
4618     melt_assertmsg("check predefhook name HOOK_SIMPLE_IPA_EXECUTE",
4619                    !strncmp (melthkp->hookname,
4620                              "HOOK_SIMPLE_IPA_EXECUTE", MELT_HOOKNAME_LEN-1));
4621     return (*melthookptr_HOOK_SIMPLE_IPA_EXECUTE) ((melt_ptr_t)melthkp);
4622 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4623 } /* end  melthookproc_HOOK_SIMPLE_IPA_EXECUTE */
4624
4625
4626
4627 /*predefined hook definition HOOK_SORT_COMPARE_LESS #150*/
4628 long melthookproc_HOOK_SORT_COMPARE_LESS(melt_ptr_t meltin_LEFT_p0, melt_ptr_t meltin_RIGHT_p1, melt_ptr_t meltin_CMP_p2)
4629 {
4630     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_SORT_COMPARE_LESS*/
4631 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4632     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_SORT_COMPARE_LESS);
4633     typedef long melthooksig_HOOK_SORT_COMPARE_LESS_t (melt_ptr_t, melt_ptr_t, melt_ptr_t, melt_ptr_t);
4634     /*checkhook exist*/
4635     melt_assertmsg (" check predefhook HOOK_SORT_COMPARE_LESS exists",
4636                     melthkp != NULL);
4637     /*checkhook ishook*/
4638     melt_assertmsg (" check predefhook HOOK_SORT_COMPARE_LESS is hook",
4639                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4640     /* check hook routine HOOK_SORT_COMPARE_LESS */
4641     melthooksig_HOOK_SORT_COMPARE_LESS_t *melthookptr_HOOK_SORT_COMPARE_LESS =
4642         reinterpret_cast <melthooksig_HOOK_SORT_COMPARE_LESS_t*>
4643         (melthkp->hookad) ;
4644     melt_assertmsg("check predefhook routine HOOK_SORT_COMPARE_LESS",
4645                    melthookptr_HOOK_SORT_COMPARE_LESS);
4646
4647     /* check predefhook HOOK_SORT_COMPARE_LESS name */
4648     melt_assertmsg("check predefhook name HOOK_SORT_COMPARE_LESS",
4649                    !strncmp (melthkp->hookname,
4650                              "HOOK_SORT_COMPARE_LESS", MELT_HOOKNAME_LEN-1));
4651     return (*melthookptr_HOOK_SORT_COMPARE_LESS) ((melt_ptr_t)melthkp,
4652             meltin_LEFT_p0,
4653             meltin_RIGHT_p1,
4654             meltin_CMP_p2);
4655 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4656 } /* end  melthookproc_HOOK_SORT_COMPARE_LESS */
4657
4658
4659
4660 /*predefined hook definition HOOK_START_UNIT #151*/
4661 void melthookproc_HOOK_START_UNIT()
4662 {
4663     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_START_UNIT*/
4664 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4665     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_START_UNIT);
4666     typedef void melthooksig_HOOK_START_UNIT_t (melt_ptr_t);
4667     /*checkhook exist*/
4668     melt_assertmsg (" check predefhook HOOK_START_UNIT exists",
4669                     melthkp != NULL);
4670     /*checkhook ishook*/
4671     melt_assertmsg (" check predefhook HOOK_START_UNIT is hook",
4672                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4673     /* check hook routine HOOK_START_UNIT */
4674     melthooksig_HOOK_START_UNIT_t *melthookptr_HOOK_START_UNIT =
4675         reinterpret_cast <melthooksig_HOOK_START_UNIT_t*>
4676         (melthkp->hookad) ;
4677     melt_assertmsg("check predefhook routine HOOK_START_UNIT",
4678                    melthookptr_HOOK_START_UNIT);
4679
4680     /* check predefhook HOOK_START_UNIT name */
4681     melt_assertmsg("check predefhook name HOOK_START_UNIT",
4682                    !strncmp (melthkp->hookname,
4683                              "HOOK_START_UNIT", MELT_HOOKNAME_LEN-1));
4684     return (*melthookptr_HOOK_START_UNIT) ((melt_ptr_t)melthkp);
4685 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4686 } /* end  melthookproc_HOOK_START_UNIT */
4687
4688
4689
4690 /*predefined hook definition HOOK_SYMBOL_IMPORTER #152*/
4691 melt_ptr_t melthookproc_HOOK_SYMBOL_IMPORTER(const char* meltin_SYMNAMESTR_p0, const char* meltin_MODULENAMESTR_p1, melt_ptr_t meltin_PARENV_p2)
4692 {
4693     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_SYMBOL_IMPORTER*/
4694 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4695     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_SYMBOL_IMPORTER);
4696     typedef melt_ptr_t melthooksig_HOOK_SYMBOL_IMPORTER_t (melt_ptr_t, const char*, const char*, melt_ptr_t);
4697     /*checkhook exist*/
4698     melt_assertmsg (" check predefhook HOOK_SYMBOL_IMPORTER exists",
4699                     melthkp != NULL);
4700     /*checkhook ishook*/
4701     melt_assertmsg (" check predefhook HOOK_SYMBOL_IMPORTER is hook",
4702                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4703     /* check hook routine HOOK_SYMBOL_IMPORTER */
4704     melthooksig_HOOK_SYMBOL_IMPORTER_t *melthookptr_HOOK_SYMBOL_IMPORTER =
4705         reinterpret_cast <melthooksig_HOOK_SYMBOL_IMPORTER_t*>
4706         (melthkp->hookad) ;
4707     melt_assertmsg("check predefhook routine HOOK_SYMBOL_IMPORTER",
4708                    melthookptr_HOOK_SYMBOL_IMPORTER);
4709
4710     /* check predefhook HOOK_SYMBOL_IMPORTER name */
4711     melt_assertmsg("check predefhook name HOOK_SYMBOL_IMPORTER",
4712                    !strncmp (melthkp->hookname,
4713                              "HOOK_SYMBOL_IMPORTER", MELT_HOOKNAME_LEN-1));
4714     return (*melthookptr_HOOK_SYMBOL_IMPORTER) ((melt_ptr_t)melthkp,
4715             meltin_SYMNAMESTR_p0,
4716             meltin_MODULENAMESTR_p1,
4717             meltin_PARENV_p2);
4718 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4719 } /* end  melthookproc_HOOK_SYMBOL_IMPORTER */
4720
4721
4722
4723 /*predefined hook definition HOOK_VALUE_EXPORTER #153*/
4724 void melthookproc_HOOK_VALUE_EXPORTER(melt_ptr_t meltin_SYM_p0, melt_ptr_t meltin_VAL_p1, melt_ptr_t meltin_CONTENV_p2)
4725 {
4726     /* code emitted by generate_runtypesupport_predefined_hooks for HOOK_VALUE_EXPORTER*/
4727 #ifndef MELT_SKIP_HOOK_PREDEFINED_CODE
4728     melthook_ptr_t melthkp = (melthook_ptr_t) MELT_PREDEF (HOOK_VALUE_EXPORTER);
4729     typedef void melthooksig_HOOK_VALUE_EXPORTER_t (melt_ptr_t, melt_ptr_t, melt_ptr_t, melt_ptr_t);
4730     /*checkhook exist*/
4731     melt_assertmsg (" check predefhook HOOK_VALUE_EXPORTER exists",
4732                     melthkp != NULL);
4733     /*checkhook ishook*/
4734     melt_assertmsg (" check predefhook HOOK_VALUE_EXPORTER is hook",
4735                     melt_magic_discr ((melt_ptr_t) melthkp) == MELTOBMAG_HOOK);
4736     /* check hook routine HOOK_VALUE_EXPORTER */
4737     melthooksig_HOOK_VALUE_EXPORTER_t *melthookptr_HOOK_VALUE_EXPORTER =
4738         reinterpret_cast <melthooksig_HOOK_VALUE_EXPORTER_t*>
4739         (melthkp->hookad) ;
4740     melt_assertmsg("check predefhook routine HOOK_VALUE_EXPORTER",
4741                    melthookptr_HOOK_VALUE_EXPORTER);
4742
4743     /* check predefhook HOOK_VALUE_EXPORTER name */
4744     melt_assertmsg("check predefhook name HOOK_VALUE_EXPORTER",
4745                    !strncmp (melthkp->hookname,
4746                              "HOOK_VALUE_EXPORTER", MELT_HOOKNAME_LEN-1));
4747     return (*melthookptr_HOOK_VALUE_EXPORTER) ((melt_ptr_t)melthkp,
4748             meltin_SYM_p0,
4749             meltin_VAL_p1,
4750             meltin_CONTENV_p2);
4751 #endif /* MELT_SKIP_HOOK_PREDEFINED_CODE */
4752 } /* end  melthookproc_HOOK_VALUE_EXPORTER */
4753
4754
4755
4756
4757
4758
4759
4760
4761
4762
4763 /* end of code generated by generate_runtypesupport_predefined_hooks for 161 predefined */
4764
4765 /*** End of code file meltbuild-sources/generated/meltrunsup-inc.cc generated on 2015 Jun 12
4766  * by GCC MELT 6.0.0 20150415 (experimental) [melt-branch revision 224408] MELT_1.2-pre-merged . ***/