/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.45 from the
 * contents of CFC.xs. Do not edit this file, edit CFC.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "lib/Clownfish/CFC.xs"
/* Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "CFC.h"

/* Rather than provide an XSUB for each accessor, we can use one multipath
 * accessor function per class, with several Perl-space aliases.  All set
 * functions have odd-numbered aliases, and all get functions have
 * even-numbered aliases.  These two macros serve as bookends for the switch
 * function.
 */
#define START_SET_OR_GET_SWITCH \
    SV *retval = &PL_sv_undef; \
    /* If called as a setter, make sure the extra arg is there. */ \
    if (ix % 2 == 1) { \
        if (items != 2) { croak("usage: $object->set_xxxxxx($val)"); } \
    } \
    else { \
        if (items != 1) { croak("usage: $object->get_xxxxx()"); } \
    } \
    switch (ix) {

#define END_SET_OR_GET_SWITCH \
        default: croak("Internal error. ix: %d", (int)ix); \
    } \
    if (ix % 2 == 0) { \
        XPUSHs(sv_2mortal(retval)); \
        XSRETURN(1); \
    } \
    else { \
        XSRETURN(0); \
    }

static SV*
S_cfcbase_to_perlref(void *thing) {
    SV *ref = newSV(0);
    if (thing) {
        const char *klass = CFCBase_get_cfc_class((CFCBase*)thing);
        CFCBase_incref((CFCBase*)thing);
        sv_setref_pv(ref, klass, (void*)thing);
    }
    return ref;
}

// Transform a NULL-terminated array of char* into a Perl arrayref.
static SV*
S_string_array_to_av(const char **strings) {
    AV *av = newAV();
    for (size_t i = 0; strings[i] != NULL; i++) {
        SV *val = newSVpvn(strings[i], strlen(strings[i]));
        av_store(av, i, val);
    }
    SV *retval = newRV_noinc((SV*)av);
    return retval;
}

// Transform a NULL-terminated array of CFCBase* into a Perl arrayref.
static SV*
S_array_of_cfcbase_to_av(CFCBase **things) {
    AV *av = newAV();
    for (size_t i = 0; things[i] != NULL; i++) {
        SV *val = S_cfcbase_to_perlref(things[i]);
        av_store(av, i, val);
    }
    SV *retval = newRV((SV*)av);
    SvREFCNT_dec(av);
    return retval;
}

// Transform a Perl arrayref into a NULL-terminated array of CFCBase*.
static CFCBase**
S_av_to_array_of_cfcbase(SV *ref, const char *class_name) {
    if (!SvROK(ref)) { croak("Not an arrayref"); }
    SV *sv = SvRV(ref);
    if (SvTYPE(sv) != SVt_PVAV) { croak("Not an arrayref"); }
    AV *av = (AV*)sv;
    size_t size = av_len(av) + 1;
    CFCBase **retval = (CFCBase**)CALLOCATE(size + 1, sizeof(CFCBase*));
    for (size_t i = 0; i < size; i++) {
        SV **elem = av_fetch(av, i, 0);
        if (!elem || !sv_derived_from(*elem, class_name)) {
            croak("Array element not of type %s", class_name);
        }
        IV objint = SvIV((SV*)SvRV(*elem));
        retval[i] = INT2PTR(CFCBase*, objint);
    }
    return retval;
}

static SV*
S_sv_eat_c_string(char *string) {
    if (string) {
        SV *sv = newSVpvn(string, strlen(string));
        FREEMEM(string);
        return sv;
    }
    else {
        return newSV(0);
    }
}

#line 129 "lib/Clownfish/CFC.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 273 "lib/Clownfish/CFC.c"

XS_EUPXS(XS_Clownfish__CFC__Base_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Base_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCBase *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Base")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCBase *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Base");
	}
;
#line 125 "lib/Clownfish/CFC.xs"
    CFCBase_decref((CFCBase*)self);
#line 299 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__CBlock__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__CBlock__new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "contents");
    {
	const char *	contents = (const char *)SvPV_nolen(ST(0))
;
	SV *	RETVAL;
#line 134 "lib/Clownfish/CFC.xs"
    CFCCBlock *self = CFCCBlock_new(contents);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 320 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__CBlock__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__CBlock__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCCBlock *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::CBlock")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCCBlock *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::CBlock");
	}
;
#line 145 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *contents = CFCCBlock_get_contents(self);
                retval = newSVpvn(contents, strlen(contents));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 361 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class__create); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class__create)
{
    dVAR; dXSARGS;
    if (items != 10)
       croak_xs_usage(cv,  "parcel, exposure_sv, class_name_sv, class_nickname_sv, docucomment, file_spec, parent_class_name_sv, is_final, is_inert, is_abstract");
    {
	CFCParcel *	parcel;
	SV *	exposure_sv = ST(1)
;
	SV *	class_name_sv = ST(2)
;
	SV *	class_nickname_sv = ST(3)
;
	CFCDocuComment *	docucomment;
	CFCFileSpec *	file_spec;
	SV *	parent_class_name_sv = ST(6)
;
	bool	is_final = (bool)SvTRUE(ST(7))
;
	bool	is_inert = (bool)SvTRUE(ST(8))
;
	bool	is_abstract = (bool)SvTRUE(ST(9))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;

	if (!SvOK(ST(4))) {
        docucomment = NULL;
    }
	else if (sv_derived_from(ST(4), "Clownfish::CFC::Model::DocuComment")) {
		IV objint = SvIV((SV*)SvRV(ST(4)));
		docucomment = INT2PTR(CFCDocuComment *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::DocuComment");
	}
;

	if (!SvOK(ST(5))) {
        file_spec = NULL;
    }
	else if (sv_derived_from(ST(5), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(5)));
		file_spec = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 170 "lib/Clownfish/CFC.xs"
    const char *exposure =
        SvOK(exposure_sv) ? SvPV_nolen(exposure_sv) : NULL;
    const char *class_name =
        SvOK(class_name_sv) ? SvPV_nolen(class_name_sv) : NULL;
    const char *class_nickname =
        SvOK(class_nickname_sv) ? SvPV_nolen(class_nickname_sv) : NULL;
    const char *parent_class_name =
        SvOK(parent_class_name_sv) ? SvPV_nolen(parent_class_name_sv) : NULL;
    CFCClass *self
        = CFCClass_create(parcel, exposure, class_name, class_nickname,
                          docucomment, file_spec, parent_class_name,
                          is_final, is_inert, is_abstract);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 444 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_fetch_singleton); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_fetch_singleton)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "unused, class_name");
    {
	SV *	unused = ST(0)
;
	const char *	class_name = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;
#line 191 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    CFCClass *klass = CFCClass_fetch_singleton(class_name);
    RETVAL = S_cfcbase_to_perlref(klass);
#line 468 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class__clear_registry); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class__clear_registry)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 199 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    CFCClass_clear_registry();
#line 488 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_child); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_child)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, child");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;
	CFCClass *	child;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;

	if (!SvOK(ST(1))) {
        child = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		child = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 207 "lib/Clownfish/CFC.xs"
    CFCClass_add_child(self, child);
#line 532 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_member_var); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_member_var)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, var");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;
	CFCVariable *	var;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;

	if (!SvOK(ST(1))) {
        var = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		var = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;
#line 214 "lib/Clownfish/CFC.xs"
    CFCClass_add_member_var(self, var);
#line 576 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_function); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_function)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;
	CFCFunction *	func;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;

	if (!SvOK(ST(1))) {
        func = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Function")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		func = INT2PTR(CFCFunction *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Function");
	}
;
#line 221 "lib/Clownfish/CFC.xs"
    CFCClass_add_function(self, func);
#line 620 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_method)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, method");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;
	CFCMethod *	method;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;

	if (!SvOK(ST(1))) {
        method = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		method = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 228 "lib/Clownfish/CFC.xs"
    CFCClass_add_method(self, method);
#line 664 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_grow_tree); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_grow_tree)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 234 "lib/Clownfish/CFC.xs"
    CFCClass_grow_tree(self);
#line 695 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_inert_var); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_add_inert_var)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, var");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;
	CFCVariable *	var;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;

	if (!SvOK(ST(1))) {
        var = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		var = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;
#line 241 "lib/Clownfish/CFC.xs"
    CFCClass_add_inert_var(self, var);
#line 739 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_function); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_function)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, sym");
    {
	CFCClass *	self;
	const char *	sym = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 248 "lib/Clownfish/CFC.xs"
    CFCFunction *func = CFCClass_function(self, sym);
    RETVAL = S_cfcbase_to_perlref(func);
#line 772 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_method)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, sym");
    {
	CFCClass *	self;
	const char *	sym = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 257 "lib/Clownfish/CFC.xs"
    CFCMethod *method = CFCClass_method(self, sym);
    RETVAL = S_cfcbase_to_perlref(method);
#line 806 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_fresh_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_fresh_method)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, sym");
    {
	CFCClass *	self;
	const char *	sym = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 266 "lib/Clownfish/CFC.xs"
    CFCMethod *method = CFCClass_fresh_method(self, sym);
    RETVAL = S_cfcbase_to_perlref(method);
#line 840 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class_resolve_types); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class_resolve_types)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 274 "lib/Clownfish/CFC.xs"
    CFCClass_resolve_types(self);
#line 872 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Class__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Class__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCClass *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 306 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *value = CFCClass_get_exposure(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 4: {
                const char *value = CFCClass_get_name(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 6: {
                const char *value = CFCClass_get_nickname(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 7: {
                CFCClass *parent = NULL;
                if (SvOK(ST(1))
                    && sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")
                   ) {
                    IV objint = SvIV((SV*)SvRV(ST(1)));
                    parent = INT2PTR(CFCClass*, objint);
                }
                CFCClass_set_parent(self, parent);
                break;
            }
        case 8: {
                CFCClass *parent = CFCClass_get_parent(self);
                retval = S_cfcbase_to_perlref(parent);
                break;
            }
        case 10: {
                const char *value = CFCClass_get_path_part(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 12: {
                const char *value = CFCClass_get_parent_class_name(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 14:
            retval = newSViv(CFCClass_final(self));
            break;
        case 16:
            retval = newSViv(CFCClass_inert(self));
            break;
        case 18: {
                const char *value = CFCClass_get_struct_sym(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 20: {
                const char *value = CFCClass_full_struct_sym(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 22: {
                const char *value = CFCClass_short_class_var(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 24: {
                const char *value = CFCClass_full_class_var(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 28: {
                const char *value = CFCClass_include_h(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 30: {
                CFCDocuComment *docucomment = CFCClass_get_docucomment(self);
                retval = S_cfcbase_to_perlref(docucomment);
            }
            break;
        case 32:
            retval = S_array_of_cfcbase_to_av(
                (CFCBase**)CFCClass_children(self));
            break;
        case 34:
            retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_functions(self));
            break;
        case 36:
            retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_methods(self));
            break;
        case 38:
            retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_member_vars(self));
            break;
        case 40:
            retval = S_array_of_cfcbase_to_av((CFCBase**)CFCClass_inert_vars(self));
            break;
        case 42: {
                CFCClass **ladder = CFCClass_tree_to_ladder(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)ladder);
                FREEMEM(ladder);
                break;
            }
        case 44: {
                CFCMethod **fresh = CFCClass_fresh_methods(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)fresh);
                break;
            }
        case 46: {
                CFCVariable **fresh = CFCClass_fresh_member_vars(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)fresh);
                break;
            }
        case 48: {
                const char *value = CFCClass_privacy_symbol(self);
                retval = value ? newSVpvn(value, strlen(value)) : newSV(0);
            }
            break;
        case 50:
            retval = newSViv(CFCClass_included(self));
            break;
    END_SET_OR_GET_SWITCH
}
#line 1024 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__DocuComment_parse); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__DocuComment_parse)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "klass, text");
    {
	const char *	klass = (const char *)SvPV_nolen(ST(0))
;
	const char *	text = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;
#line 436 "lib/Clownfish/CFC.xs"
    if (strcmp(klass, "Clownfish::CFC::Model::DocuComment")) {
        croak("No subclassing allowed");
    }
    CFCDocuComment *self = CFCDocuComment_parse(text);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 1050 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__DocuComment__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__DocuComment__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCDocuComment *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::DocuComment")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCDocuComment *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::DocuComment");
	}
;
#line 455 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *description = CFCDocuComment_get_description(self);
                retval = newSVpvn(description, strlen(description));
            }
            break;
        case 4: {
                const char *brief = CFCDocuComment_get_brief(self);
                retval = newSVpvn(brief, strlen(brief));
            }
            break;
        case 6: {
                const char *long_description = CFCDocuComment_get_long(self);
                retval = newSVpvn(long_description, strlen(long_description));
            }
            break;
        case 8: {
                const char **names = CFCDocuComment_get_param_names(self);
                retval = S_string_array_to_av(names);
            }
            break;
        case 10: {
                const char **docs = CFCDocuComment_get_param_docs(self);
                retval = S_string_array_to_av(docs);
            }
            break;
        case 12: {
                const char *rv = CFCDocuComment_get_retval(self);
                retval = rv ? newSVpvn(rv, strlen(rv)) : newSV(0);
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 1116 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__File__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__File__new)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "parcel, spec");
    {
	CFCParcel *	parcel;
	CFCFileSpec *	spec;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;

	if (!SvOK(ST(1))) {
        spec = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		spec = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 498 "lib/Clownfish/CFC.xs"
    CFCFile *self = CFCFile_new(parcel, spec);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 1161 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__File_add_block); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__File_add_block)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, block");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCFile *	self;
	CFCBase *	block;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::File")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFile *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::File");
	}
;

	if (!SvOK(ST(1))) {
        block = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Base")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		block = INT2PTR(CFCBase *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Base");
	}
;
#line 508 "lib/Clownfish/CFC.xs"
    CFCFile_add_block(self, block);
#line 1206 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__File__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__File__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCFile *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::File")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFile *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::File");
	}
;
#line 527 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 1:
            CFCFile_set_modified(self, !!SvTRUE(ST(1)));
            break;
        case 2:
            retval = newSViv(CFCFile_get_modified(self));
            break;
        case 4: {
                const char *value = CFCFile_get_path_part(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 6: {
                const char *value = CFCFile_guard_name(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 8: {
                const char *value = CFCFile_guard_start(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 10: {
                const char *value = CFCFile_guard_close(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 12:
            retval = S_array_of_cfcbase_to_av(CFCFile_blocks(self));
            break;
        case 14:
            retval = S_array_of_cfcbase_to_av(
                         (CFCBase**)CFCFile_classes(self));
            break;
        case 16: {
                const char *value = CFCFile_get_source_dir(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 18:
            retval = newSViv(CFCFile_included(self));
            break;
        case 20: {
                CFCParcel *parcel = CFCFile_get_parcel(self);
                retval = S_cfcbase_to_perlref(parcel);
            }
            break;
        case 22: {
                const char *value = CFCFile_get_path(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 1292 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__File__gen_path); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__File__gen_path)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "self, base_dir = NULL");
    {
	CFCFile *	self;
	const char *	base_dir;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::File")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFile *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::File");
	}
;

	if (items < 2)
	    base_dir = NULL;
	else {
	    base_dir = (const char *)SvPV_nolen(ST(1))
;
	}
#line 591 "lib/Clownfish/CFC.xs"
{
    char *buf;
    switch (ix) {
        case 1:
            buf = CFCFile_c_path(self, base_dir);
            break;
        case 2:
            buf = CFCFile_h_path(self, base_dir);
            break;
        default:
            croak("unexpected ix value: %d", (int)ix);
    }
    RETVAL = newSVpvn(buf, strlen(buf));
    FREEMEM(buf);
}
#line 1345 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__FileSpec__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__FileSpec__new)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "source_dir, path_part, ext, is_included");
    {
	const char *	source_dir = (const char *)SvPV_nolen(ST(0))
;
	const char *	path_part = (const char *)SvPV_nolen(ST(1))
;
	const char *	ext = (const char *)SvPV_nolen(ST(2))
;
	bool	is_included = (bool)SvTRUE(ST(3))
;
	SV *	RETVAL;
#line 618 "lib/Clownfish/CFC.xs"
    CFCFileSpec *self = CFCFileSpec_new(source_dir, path_part, ext,
                                        is_included);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 1374 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__FileSpec__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__FileSpec__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCFileSpec *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 632 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *value = CFCFileSpec_get_source_dir(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 4: {
                const char *value = CFCFileSpec_get_path_part(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 6:
            retval = newSViv(CFCFileSpec_included(self));
            break;
    END_SET_OR_GET_SWITCH
}
#line 1423 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Function__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Function__new)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "exposure_sv, name_sv, return_type, param_list, docucomment, is_inline");
    {
	SV *	exposure_sv = ST(0)
;
	SV *	name_sv = ST(1)
;
	CFCType *	return_type;
	CFCParamList *	param_list;
	CFCDocuComment *	docucomment;
	int	is_inline = (int)SvIV(ST(5))
;
	SV *	RETVAL;

	if (!SvOK(ST(2))) {
        return_type = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		return_type = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;

	if (!SvOK(ST(3))) {
        param_list = NULL;
    }
	else if (sv_derived_from(ST(3), "Clownfish::CFC::Model::ParamList")) {
		IV objint = SvIV((SV*)SvRV(ST(3)));
		param_list = INT2PTR(CFCParamList *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::ParamList");
	}
;

	if (!SvOK(ST(4))) {
        docucomment = NULL;
    }
	else if (sv_derived_from(ST(4), "Clownfish::CFC::Model::DocuComment")) {
		IV objint = SvIV((SV*)SvRV(ST(4)));
		docucomment = INT2PTR(CFCDocuComment *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::DocuComment");
	}
;
#line 662 "lib/Clownfish/CFC.xs"
    const char *exposure =
        SvOK(exposure_sv) ? SvPV_nolen(exposure_sv) : NULL;
    const char *name =
        SvOK(name_sv) ? SvPV_nolen(name_sv) : NULL;
    CFCFunction *self = CFCFunction_new(exposure, name, return_type,
                                        param_list, docucomment, is_inline);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 1492 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Function_resolve_types); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Function_resolve_types)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCFunction *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Function")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFunction *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Function");
	}
;
#line 676 "lib/Clownfish/CFC.xs"
    CFCFunction_resolve_types(self);
#line 1524 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Function__various_function_syms); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Function__various_function_syms)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCFunction *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Function")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFunction *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Function");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 686 "lib/Clownfish/CFC.xs"
    char *buf;
    switch (ix) {
        case 1:
            buf = CFCFunction_short_func_sym(self, klass);
            break;
        case 2:
            buf = CFCFunction_full_func_sym(self, klass);
            break;
        default: croak("Unexpected ix: %d", (int)ix);
    }
    RETVAL = S_sv_eat_c_string(buf);
#line 1578 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Function__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Function__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCFunction *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Function")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCFunction *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Function");
	}
;
#line 709 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                CFCType *type = CFCFunction_get_return_type(self);
                retval = S_cfcbase_to_perlref(type);
            }
            break;
        case 4: {
                CFCParamList *param_list = CFCFunction_get_param_list(self);
                retval = S_cfcbase_to_perlref(param_list);
            }
            break;
        case 6: {
                CFCDocuComment *docucomment
                    = CFCFunction_get_docucomment(self);
                retval = S_cfcbase_to_perlref(docucomment);
            }
            break;
        case 8:
            retval = newSViv(CFCFunction_inline(self));
            break;
        case 10:
            retval = newSViv(CFCFunction_void(self));
            break;
    END_SET_OR_GET_SWITCH
}
#line 1636 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy__new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "dest");
    {
	const char *	dest = (const char *)SvPV_nolen(ST(0))
;
	SV *	RETVAL;
#line 742 "lib/Clownfish/CFC.xs"
    CFCHierarchy *self = CFCHierarchy_new(dest);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 1657 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_add_source_dir); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_add_source_dir)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, source_dir");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	self;
	const char *	source_dir = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 752 "lib/Clownfish/CFC.xs"
    CFCHierarchy_add_source_dir(self, source_dir);
#line 1691 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_add_include_dir); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_add_include_dir)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, include_dir");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	self;
	const char *	include_dir = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 759 "lib/Clownfish/CFC.xs"
    CFCHierarchy_add_include_dir(self, include_dir);
#line 1724 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_build); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_build)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 765 "lib/Clownfish/CFC.xs"
    CFCHierarchy_build(self);
#line 1755 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_read_host_data_json); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_read_host_data_json)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 771 "lib/Clownfish/CFC.xs"
    CFCHierarchy_read_host_data_json(self, "perl");
#line 1786 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_propagate_modified); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_propagate_modified)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    {
	CFCHierarchy *	self;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 777 "lib/Clownfish/CFC.xs"
    int modified = items > 1 ? !!SvTRUE(ST(1)) : 0;
    RETVAL = CFCHierarchy_propagate_modified(self, modified);
#line 1818 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_write_log); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy_write_log)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 785 "lib/Clownfish/CFC.xs"
    CFCHierarchy_write_log(self);
#line 1850 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Hierarchy__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 799 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *value = CFCHierarchy_get_dest(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 4: {
                const char *value = CFCHierarchy_get_include_dest(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 6: {
                const char *value = CFCHierarchy_get_source_dest(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 8:
            retval = S_array_of_cfcbase_to_av(
                (CFCBase**)CFCHierarchy_files(self));
            break;
        case 10: {
                CFCClass **ladder = CFCHierarchy_ordered_classes(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)ladder);
                FREEMEM(ladder);
            }
            break;
        case 12: {
                const char **source_dirs = CFCHierarchy_get_source_dirs(self);
                retval = S_string_array_to_av(source_dirs);
            }
            break;
        case 14: {
                const char **include_dirs = CFCHierarchy_get_include_dirs(self);
                retval = S_string_array_to_av(include_dirs);
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 1920 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method__new)
{
    dVAR; dXSARGS;
    if (items != 8)
       croak_xs_usage(cv,  "exposure_sv, name, return_type, param_list, docucomment, class_name_sv, is_final, is_abstract");
    {
	SV *	exposure_sv = ST(0)
;
	const char *	name = (const char *)SvPV_nolen(ST(1))
;
	CFCType *	return_type;
	CFCParamList *	param_list;
	CFCDocuComment *	docucomment;
	SV *	class_name_sv = ST(5)
;
	int	is_final = (int)SvIV(ST(6))
;
	int	is_abstract = (int)SvIV(ST(7))
;
	SV *	RETVAL;

	if (!SvOK(ST(2))) {
        return_type = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		return_type = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;

	if (!SvOK(ST(3))) {
        param_list = NULL;
    }
	else if (sv_derived_from(ST(3), "Clownfish::CFC::Model::ParamList")) {
		IV objint = SvIV((SV*)SvRV(ST(3)));
		param_list = INT2PTR(CFCParamList *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::ParamList");
	}
;

	if (!SvOK(ST(4))) {
        docucomment = NULL;
    }
	else if (sv_derived_from(ST(4), "Clownfish::CFC::Model::DocuComment")) {
		IV objint = SvIV((SV*)SvRV(ST(4)));
		docucomment = INT2PTR(CFCDocuComment *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::DocuComment");
	}
;
#line 853 "lib/Clownfish/CFC.xs"
    const char *exposure =
        SvOK(exposure_sv) ? SvPV_nolen(exposure_sv) : NULL;
    const char *class_name =
        SvOK(class_name_sv) ? SvPV_nolen(class_name_sv) : NULL;
    CFCMethod *self
        = CFCMethod_new(exposure, name, return_type, param_list, docucomment,
                        class_name, is_final, is_abstract);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 1994 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method_compatible); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method_compatible)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCMethod *	self;
	CFCMethod *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 869 "lib/Clownfish/CFC.xs"
    RETVAL = CFCMethod_compatible(self, other);
#line 2039 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method_override); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method_override)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCMethod *	self;
	CFCMethod *	other;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 877 "lib/Clownfish/CFC.xs"
    CFCMethod_override(self, other);
#line 2084 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method_finalize); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method_finalize)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCMethod *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 883 "lib/Clownfish/CFC.xs"
    CFCMethod *finalized = CFCMethod_finalize(self);
    RETVAL = S_cfcbase_to_perlref(finalized);
    CFCBase_decref((CFCBase*)finalized);
#line 2116 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method_resolve_types); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method_resolve_types)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCMethod *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 892 "lib/Clownfish/CFC.xs"
    CFCMethod_resolve_types(self);
#line 2148 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method_exclude_from_host); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method_exclude_from_host)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCMethod *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 898 "lib/Clownfish/CFC.xs"
    CFCMethod_exclude_from_host(self);
#line 2179 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method__various_method_syms); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method__various_method_syms)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 2)
       croak_xs_usage(cv,  "self, invoker");
    {
	CFCMethod *	self;
	CFCClass *	invoker;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;

	if (!SvOK(ST(1))) {
        invoker = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		invoker = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 912 "lib/Clownfish/CFC.xs"
    char *buf;
    switch (ix) {
        case 1:
            buf = CFCMethod_short_method_sym(self, invoker);
            break;
        case 2:
            buf = CFCMethod_full_method_sym(self, invoker);
            break;
        case 3:
            buf = CFCMethod_full_offset_sym(self, invoker);
            break;
        case 4:
            buf = CFCMethod_short_typedef(self, invoker);
            break;
        case 5:
            buf = CFCMethod_full_typedef(self, invoker);
            break;
        case 6:
            buf = CFCMethod_full_override_sym(self, invoker);
            break;
        default: croak("Unexpected ix: %d", (int)ix);
    }
    RETVAL = newSVpvn(buf, strlen(buf));
    FREEMEM(buf);
#line 2246 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Method__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Method__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCMethod *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 950 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 12:
            retval = newSViv(CFCMethod_abstract(self));
            break;
        case 14:
            retval = newSViv(CFCMethod_novel(self));
            break;
        case 16:
            retval = newSViv(CFCMethod_final(self));
            break;
        case 18: {
                CFCType *type = CFCMethod_self_type(self);
                retval = S_cfcbase_to_perlref(type);
            }
            break;
        case 19: {
                const char *value = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
                CFCMethod_set_host_alias(self, value);
            }
            break;
        case 20: {
                const char *value = CFCMethod_get_host_alias(self);
                if (value) {
                    retval = newSVpvn(value, strlen(value));
                }
            }
            break;
        case 22:
            retval = newSViv(CFCMethod_excluded_from_host(self));
            break;
    END_SET_OR_GET_SWITCH
}
#line 2311 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__ParamList__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__ParamList__new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "variadic");
    {
	int	variadic = (int)SvIV(ST(0))
;
	SV *	RETVAL;
#line 991 "lib/Clownfish/CFC.xs"
    CFCParamList *self = CFCParamList_new(variadic);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 2332 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__ParamList_add_param); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__ParamList_add_param)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, variable, value_sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParamList *	self;
	CFCVariable *	variable;
	SV *	value_sv = ST(2)
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::ParamList")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParamList *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::ParamList");
	}
;

	if (!SvOK(ST(1))) {
        variable = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		variable = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;
#line 1002 "lib/Clownfish/CFC.xs"
    const char *value = SvOK(value_sv) ? SvPV_nolen(value_sv) : NULL;
    CFCParamList_add_param(self, variable, value);
#line 2380 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__ParamList_resolve_types); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__ParamList_resolve_types)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParamList *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::ParamList")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParamList *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::ParamList");
	}
;
#line 1009 "lib/Clownfish/CFC.xs"
    CFCParamList_resolve_types(self);
#line 2411 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__ParamList__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__ParamList__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParamList *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::ParamList")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParamList *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::ParamList");
	}
;
#line 1022 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                AV *av = newAV();
                CFCVariable **vars = CFCParamList_get_variables(self);
                int num_vars = CFCParamList_num_vars(self);
                for (int i = 0; i < num_vars; i++) {
                    SV *ref = S_cfcbase_to_perlref(vars[i]);
                    av_store(av, i, ref);
                }
                retval = newRV((SV*)av);
                SvREFCNT_dec(av);
                break;
            }
        case 4: {
                AV *av = newAV();
                const char **values = CFCParamList_get_initial_values(self);
                int num_vars = CFCParamList_num_vars(self);
                for (int i = 0; i < num_vars; i++) {
                    if (values[i] != NULL) {
                        SV *val_sv = newSVpvn(values[i], strlen(values[i]));
                        av_store(av, i, val_sv);
                    }
                    else {
                        av_store(av, i, newSV(0));
                    }
                }
                retval = newRV((SV*)av);
                SvREFCNT_dec(av);
                break;
            }
        case 6:
            retval = newSViv(CFCParamList_variadic(self));
            break;
        case 8:
            retval = newSViv(CFCParamList_num_vars(self));
            break;
        case 10: {
                const char *value = CFCParamList_to_c(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
        case 12: {
                const char *value = CFCParamList_name_list(self);
                retval = newSVpv(value, strlen(value));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 2491 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__new)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "name_sv, nickname_sv, version, major_version, file_spec");
    {
	SV *	name_sv = ST(0)
;
	SV *	nickname_sv = ST(1)
;
	CFCVersion *	version;
	CFCVersion *	major_version;
	CFCFileSpec *	file_spec;
	SV *	RETVAL;

	if (!SvOK(ST(2))) {
        version = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::Version")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		version = INT2PTR(CFCVersion *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Version");
	}
;

	if (!SvOK(ST(3))) {
        major_version = NULL;
    }
	else if (sv_derived_from(ST(3), "Clownfish::CFC::Model::Version")) {
		IV objint = SvIV((SV*)SvRV(ST(3)));
		major_version = INT2PTR(CFCVersion *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Version");
	}
;

	if (!SvOK(ST(4))) {
        file_spec = NULL;
    }
	else if (sv_derived_from(ST(4), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(4)));
		file_spec = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 1083 "lib/Clownfish/CFC.xs"
    const char *name     = SvOK(name_sv)  ? SvPV_nolen(name_sv)  : NULL;
    const char *nickname = SvOK(nickname_sv) ? SvPV_nolen(nickname_sv) : NULL;
    CFCParcel *self = CFCParcel_new(name, nickname, version, major_version,
                                    file_spec);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 2556 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__new_from_file); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__new_from_file)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "file_spec");
    {
	CFCFileSpec *	file_spec;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        file_spec = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		file_spec = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 1095 "lib/Clownfish/CFC.xs"
    CFCParcel *self = CFCParcel_new_from_file(file_spec);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 2589 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__new_from_json); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__new_from_json)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "json, file_spec");
    {
	const char *	json = (const char *)SvPV_nolen(ST(0))
;
	CFCFileSpec *	file_spec;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        file_spec = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		file_spec = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 1105 "lib/Clownfish/CFC.xs"
    CFCParcel *self = CFCParcel_new_from_json(json, file_spec);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 2624 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_fetch); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_fetch)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "unused, name_sv");
    {
	SV *	unused = ST(0)
;
	SV *	name_sv = ST(1)
;
	SV *	RETVAL;
#line 1115 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    const char *name  = SvOK(name_sv)  ? SvPV_nolen(name_sv)  : NULL;
    CFCParcel *self = CFCParcel_fetch(name);
    RETVAL = S_cfcbase_to_perlref(self);
#line 2649 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_register); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_register)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParcel *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1126 "lib/Clownfish/CFC.xs"
    CFCParcel_register(self);
#line 2681 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_equals); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_equals)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCParcel *	self;
	CFCParcel *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1133 "lib/Clownfish/CFC.xs"
    RETVAL = CFCParcel_equals(self, other);
#line 2725 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_all_parcels); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_all_parcels)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	SV *	RETVAL;
#line 1139 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    CFCParcel **all_parcels = CFCParcel_all_parcels();
    RETVAL = S_array_of_cfcbase_to_av((CFCBase**)all_parcels);
#line 2745 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_add_inherited_parcel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_add_inherited_parcel)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, inherited");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParcel *	self;
	CFCParcel *	inherited;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;

	if (!SvOK(ST(1))) {
        inherited = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		inherited = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1149 "lib/Clownfish/CFC.xs"
    CFCParcel_add_inherited_parcel(self, inherited);
#line 2790 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_has_prereq); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_has_prereq)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, parcel");
    {
	CFCParcel *	self;
	CFCParcel *	parcel;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;

	if (!SvOK(ST(1))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1156 "lib/Clownfish/CFC.xs"
    RETVAL = CFCParcel_has_prereq(self, parcel);
#line 2834 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_add_struct_sym); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_add_struct_sym)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, struct_sym");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParcel *	self;
	const char *	struct_sym = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1164 "lib/Clownfish/CFC.xs"
    CFCParcel_add_struct_sym(self, struct_sym);
#line 2868 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_lookup_struct_sym); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_lookup_struct_sym)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, struct_sym");
    {
	CFCParcel *	self;
	const char *	struct_sym = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1171 "lib/Clownfish/CFC.xs"
    CFCParcel *parcel = CFCParcel_lookup_struct_sym(self, struct_sym);
    RETVAL = S_cfcbase_to_perlref(parcel);
#line 2901 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_reap_singletons); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel_reap_singletons)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1178 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    CFCParcel_reap_singletons();
#line 2921 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Parcel__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParcel *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1197 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *name = CFCParcel_get_name(self);
                retval = newSVpvn(name, strlen(name));
            }
            break;
        case 4: {
                const char *nickname = CFCParcel_get_nickname(self);
                retval = newSVpvn(nickname, strlen(nickname));
            }
            break;
        case 6: {
                const char *value = CFCParcel_get_prefix(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 8: {
                const char *value = CFCParcel_get_Prefix(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 10: {
                const char *value = CFCParcel_get_PREFIX(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 12: {
                CFCVersion *value = CFCParcel_get_version(self);
                retval = S_cfcbase_to_perlref(value);
            }
            break;
        case 14: {
                CFCPrereq **prereqs = CFCParcel_get_prereqs(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)prereqs);
            }
            break;
        case 16:
            retval = newSViv(CFCParcel_included(self));
            break;
        case 20: {
                CFCParcel **parcels = CFCParcel_prereq_parcels(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)parcels);
                FREEMEM(parcels);
            }
            break;
        case 22: {
                CFCParcel **parcels = CFCParcel_inherited_parcels(self);
                retval = S_array_of_cfcbase_to_av((CFCBase**)parcels);
                FREEMEM(parcels);
            }
            break;
        case 24: {
                const char *xs_module = CFCParcel_get_host_module_name(self);
                retval = newSVpvn(xs_module, strlen(xs_module));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 3011 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Prereq__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Prereq__new)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "name_sv, version");
    {
	SV *	name_sv = ST(0)
;
	CFCVersion *	version;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        version = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Version")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		version = INT2PTR(CFCVersion *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Version");
	}
;
#line 1265 "lib/Clownfish/CFC.xs"
    const char *name  = SvOK(name_sv)  ? SvPV_nolen(name_sv)  : NULL;
    CFCPrereq *self = CFCPrereq_new(name, version);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3046 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Prereq__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Prereq__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPrereq *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Prereq")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPrereq *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Prereq");
	}
;
#line 1278 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *name = CFCPrereq_get_name(self);
                retval = newSVpvn(name, strlen(name));
            }
            break;
        case 4: {
                CFCVersion *value = CFCPrereq_get_version(self);
                retval = S_cfcbase_to_perlref(value);
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 3092 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Symbol__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Symbol__new)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "exposure, name_sv");
    {
	const char *	exposure = (const char *)SvPV_nolen(ST(0))
;
	SV *	name_sv = ST(1)
;
	SV *	RETVAL;
#line 1301 "lib/Clownfish/CFC.xs"
    const char *name = SvOK(name_sv)
                       ? SvPV_nolen(name_sv)
                       : NULL;
    CFCSymbol *self = CFCSymbol_new(exposure, name);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3118 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Symbol_equals); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Symbol_equals)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCSymbol *	self;
	CFCSymbol *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Symbol")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCSymbol *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Symbol");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Symbol")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCSymbol *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Symbol");
	}
;
#line 1314 "lib/Clownfish/CFC.xs"
    RETVAL = CFCSymbol_equals(self, other);
#line 3163 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Symbol__various_syms); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Symbol__various_syms)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCSymbol *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Symbol")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCSymbol *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Symbol");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 1325 "lib/Clownfish/CFC.xs"
    char *buf;
    switch (ix) {
        case 1:
            buf = CFCSymbol_short_sym(self, klass);
            break;
        case 2:
            buf = CFCSymbol_full_sym(self, klass);
            break;
        default: croak("Unexpected ix: %d", (int)ix);
    }
    RETVAL = S_sv_eat_c_string(buf);
#line 3218 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Symbol__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Symbol__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCSymbol *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Symbol")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCSymbol *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Symbol");
	}
;
#line 1349 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 8: {
                const char *exposure = CFCSymbol_get_exposure(self);
                retval = newSVpvn(exposure, strlen(exposure));
            }
            break;
        case 10: {
                const char *name = CFCSymbol_get_name(self);
                retval = newSVpvn(name, strlen(name));
            }
            break;
        case 18:
            retval = newSViv(CFCSymbol_public(self));
            break;
        case 20:
            retval = newSViv(CFCSymbol_private(self));
            break;
        case 22:
            retval = newSViv(CFCSymbol_parcel(self));
            break;
        case 24:
            retval = newSViv(CFCSymbol_local(self));
            break;
    END_SET_OR_GET_SWITCH
}
#line 3276 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "flags, parcel, specifier, indirection");
    {
	int	flags = (int)SvIV(ST(0))
;
	CFCParcel *	parcel;
	const char *	specifier = (const char *)SvPV_nolen(ST(2))
;
	int	indirection = (int)SvIV(ST(3))
;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1386 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new(flags, parcel, specifier, indirection);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3314 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_integer); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_integer)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "flags, specifier");
    {
	int	flags = (int)SvIV(ST(0))
;
	const char *	specifier = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;
#line 1396 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new_integer(flags, specifier);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3338 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_float); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_float)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "flags, specifier");
    {
	int	flags = (int)SvIV(ST(0))
;
	const char *	specifier = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;
#line 1406 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new_float(flags, specifier);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3362 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_object); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_object)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "flags, parcel, specifier, indirection");
    {
	int	flags = (int)SvIV(ST(0))
;
	CFCParcel *	parcel;
	const char *	specifier = (const char *)SvPV_nolen(ST(2))
;
	int	indirection = (int)SvIV(ST(3))
;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1418 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new_object(flags, parcel, specifier, indirection);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3401 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_composite); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_composite)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "flags, child_sv, indirection, array");
    {
	int	flags = (int)SvIV(ST(0))
;
	SV *	child_sv = ST(1)
;
	int	indirection = (int)SvIV(ST(2))
;
	const char *	array = (const char *)SvPV_nolen(ST(3))
;
	SV *	RETVAL;
#line 1430 "lib/Clownfish/CFC.xs"
    CFCType *child = NULL;
    if (SvOK(child_sv) && sv_derived_from(child_sv, "Clownfish::CFC::Model::Type")) {
        IV objint = SvIV((SV*)SvRV(child_sv));
        child = INT2PTR(CFCType*, objint);
    }
    else {
        croak("Param 'child' not a Clownfish::CFC::Model::Type");
    }
    CFCType *self = CFCType_new_composite(flags, child, indirection, array);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3437 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_void); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_void)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "is_const");
    {
	int	is_const = (int)SvIV(ST(0))
;
	SV *	RETVAL;
#line 1447 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new_void(is_const);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3459 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_va_list); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_va_list)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 1455 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new_va_list();
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3479 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_arbitrary); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__new_arbitrary)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "parcel, specifier");
    {
	CFCParcel *	parcel;
	const char *	specifier = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 1465 "lib/Clownfish/CFC.xs"
    CFCType *self = CFCType_new_arbitrary(parcel, specifier);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 3514 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_equals); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_equals)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCType *	self;
	CFCType *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;
#line 1475 "lib/Clownfish/CFC.xs"
    RETVAL = CFCType_equals(self, other);
#line 3559 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_similar); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_similar)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCType *	self;
	CFCType *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;
#line 1483 "lib/Clownfish/CFC.xs"
    RETVAL = CFCType_similar(self, other);
#line 3604 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_CONST); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_CONST)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1489 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_CONST;
#line 3624 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_NULLABLE); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_NULLABLE)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1496 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_NULLABLE;
#line 3644 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_INCREMENTED); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_INCREMENTED)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1503 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_INCREMENTED;
#line 3664 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_DECREMENTED); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_DECREMENTED)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1510 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_DECREMENTED;
#line 3684 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_VOID); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_VOID)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1517 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_VOID;
#line 3704 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_OBJECT); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_OBJECT)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1524 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_OBJECT;
#line 3724 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_PRIMITIVE); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_PRIMITIVE)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1531 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_PRIMITIVE;
#line 3744 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_INTEGER); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_INTEGER)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1538 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_INTEGER;
#line 3764 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_FLOATING); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_FLOATING)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1545 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_FLOATING;
#line 3784 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_CFISH_STRING); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_CFISH_STRING)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1552 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_CFISH_STRING;
#line 3804 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_VA_LIST); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_VA_LIST)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1559 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_VA_LIST;
#line 3824 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_ARBITRARY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_ARBITRARY)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1566 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_ARBITRARY;
#line 3844 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_COMPOSITE); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_COMPOSITE)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	unsigned	RETVAL;
	dXSTARG;
#line 1573 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = CFCTYPE_COMPOSITE;
#line 3864 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type_resolve); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type_resolve)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCType *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;
#line 1581 "lib/Clownfish/CFC.xs"
    CFCType_resolve(self);
#line 3896 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Type__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Type__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCType *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;
#line 1609 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 1:
            CFCType_set_specifier(self, SvPV_nolen(ST(1)));
            break;
        case 2: {
                const char *specifier = CFCType_get_specifier(self);
                retval = newSVpvn(specifier, strlen(specifier));
            }
            break;
        case 4: {
                CFCParcel *parcel = CFCType_get_parcel(self);
                retval = S_cfcbase_to_perlref(parcel);
            }
            break;
        case 6:
            retval = newSViv(CFCType_get_indirection(self));
            break;
        case 8: {
                const char *c_string = CFCType_to_c(self);
                retval = newSVpvn(c_string, strlen(c_string));
            }
            break;
        case 10:
            retval = newSViv(CFCType_const(self));
            break;
        case 11:
            CFCType_set_nullable(self, !!SvTRUE(ST(1)));
            break;
        case 12:
            retval = newSViv(CFCType_nullable(self));
            break;
        case 14:
            retval = newSViv(CFCType_is_void(self));
            break;
        case 16:
            retval = newSViv(CFCType_is_object(self));
            break;
        case 18:
            retval = newSViv(CFCType_is_primitive(self));
            break;
        case 20:
            retval = newSViv(CFCType_is_integer(self));
            break;
        case 22:
            retval = newSViv(CFCType_is_floating(self));
            break;
        case 24:
            retval = newSViv(CFCType_cfish_string(self));
            break;
        case 26:
            retval = newSViv(CFCType_is_va_list(self));
            break;
        case 28:
            retval = newSViv(CFCType_is_arbitrary(self));
            break;
        case 30:
            retval = newSViv(CFCType_is_composite(self));
            break;
        case 32:
            retval = newSVuv(CFCType_get_width(self));
            break;
        case 34:
            retval = newSVuv(CFCType_incremented(self));
            break;
        case 36:
            retval = newSVuv(CFCType_decremented(self));
            break;
        case 38: {
                const char *array = CFCType_get_array(self);
                retval = array
                         ? newSVpvn(array, strlen(array))
                         : newSV(0);
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 4004 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Util_trim_whitespace); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_trim_whitespace)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "text");
    {
	SV *	text = ST(0)
;
	SV *	RETVAL;
#line 1694 "lib/Clownfish/CFC.xs"
    RETVAL = newSVsv(text);
    STRLEN len;
    char *ptr = SvPV(RETVAL, len);
    CFCUtil_trim_whitespace(ptr);
    SvCUR_set(RETVAL, strlen(ptr));
#line 4027 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Util_slurp_text); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_slurp_text)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "path");
    {
	const char *	path = (const char *)SvPV_nolen(ST(0))
;
	SV *	RETVAL;
#line 1705 "lib/Clownfish/CFC.xs"
    size_t len;
    char *contents = CFCUtil_slurp_text(path, &len);
    RETVAL = newSVpvn(contents, len);
    FREEMEM(contents);
#line 4050 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Util_current); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_current)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "orig, dest");
    {
	const char *	orig = (const char *)SvPV_nolen(ST(0))
;
	const char *	dest = (const char *)SvPV_nolen(ST(1))
;
	int	RETVAL;
	dXSTARG;
#line 1716 "lib/Clownfish/CFC.xs"
    RETVAL = CFCUtil_current(orig, dest);
#line 4073 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Util_write_if_changed); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_write_if_changed)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "path, content_sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	const char *	path = (const char *)SvPV_nolen(ST(0))
;
	SV *	content_sv = ST(1)
;
#line 1724 "lib/Clownfish/CFC.xs"
    STRLEN len;
    char *content = SvPV(content_sv, len);
    CFCUtil_write_if_changed(path, content, len);
#line 4098 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Util_is_dir); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_is_dir)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "path");
    {
	const char *	path = (const char *)SvPV_nolen(ST(0))
;
	int	RETVAL;
	dXSTARG;
#line 1732 "lib/Clownfish/CFC.xs"
    RETVAL = CFCUtil_is_dir(path);
#line 4118 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Util_make_dir); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_make_dir)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "dir");
    {
	const char *	dir = (const char *)SvPV_nolen(ST(0))
;
	int	RETVAL;
	dXSTARG;
#line 1739 "lib/Clownfish/CFC.xs"
    RETVAL = CFCUtil_make_dir(dir);
#line 4139 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Util_make_path); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Util_make_path)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "path");
    {
	const char *	path = (const char *)SvPV_nolen(ST(0))
;
	int	RETVAL;
	dXSTARG;
#line 1746 "lib/Clownfish/CFC.xs"
    RETVAL = CFCUtil_make_path(path);
#line 4160 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Variable__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Variable__new)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "exposure, name_sv, type_sv, inert_sv");
    {
	const char *	exposure = (const char *)SvPV_nolen(ST(0))
;
	SV *	name_sv = ST(1)
;
	SV *	type_sv = ST(2)
;
	SV *	inert_sv = ST(3)
;
	SV *	RETVAL;
#line 1758 "lib/Clownfish/CFC.xs"
    const char *name = SvOK(name_sv)
                       ? SvPV_nolen(name_sv)
                       : NULL;
    int inert        = SvOK(inert_sv)
                       ? !!SvTRUE(inert_sv) : 0;
    CFCType *type = NULL;
    if (SvOK(type_sv) && sv_derived_from(type_sv, "Clownfish::CFC::Model::Type")) {
        IV objint = SvIV((SV*)SvRV(type_sv));
        type = INT2PTR(CFCType*, objint);
    }
    else {
        croak("Param 'type' is not a Clownfish::CFC::Model::Type");
    }
    CFCVariable *self = CFCVariable_new(exposure, name, type, inert);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 4201 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Variable_equals); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Variable_equals)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCVariable *	self;
	CFCVariable *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;
#line 1781 "lib/Clownfish/CFC.xs"
    RETVAL = CFCVariable_equals(self, other);
#line 4246 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Variable_resolve_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Variable_resolve_type)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCVariable *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;
#line 1788 "lib/Clownfish/CFC.xs"
    CFCVariable_resolve_type(self);
#line 4278 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Variable_global_c); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Variable_global_c)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCVariable *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 1795 "lib/Clownfish/CFC.xs"
    char *global_c = CFCVariable_global_c(self, klass);
    RETVAL = S_sv_eat_c_string(global_c);
#line 4322 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Variable__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Variable__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCVariable *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Variable")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCVariable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Variable");
	}
;
#line 1807 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                CFCType *type = CFCVariable_get_type(self);
                retval = S_cfcbase_to_perlref(type);
            }
            break;
        case 4: {
                const char *local_c = CFCVariable_local_c(self);
                retval = newSVpvn(local_c, strlen(local_c));
            }
            break;
        case 8: {
                const char *local_dec = CFCVariable_local_declaration(self);
                retval = newSVpvn(local_dec, strlen(local_dec));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 4373 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Version__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Version__new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "vstring");
    {
	const char *	vstring = (const char *)SvPV_nolen(ST(0))
;
	SV *	RETVAL;
#line 1833 "lib/Clownfish/CFC.xs"
    CFCVersion *self = CFCVersion_new(vstring);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 4394 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Model__Version__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Version__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCVersion *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Version")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCVersion *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Version");
	}
;
#line 1845 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: 
            retval = newSVuv(CFCVersion_get_major(self));
            break;
        case 4: {
                const char *value = CFCVersion_get_vstring(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 4438 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Model__Version_compare_to); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Model__Version_compare_to)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, other");
    {
	CFCVersion *	self;
	CFCVersion *	other;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Version")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCVersion *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Version");
	}
;

	if (!SvOK(ST(1))) {
        other = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Version")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		other = INT2PTR(CFCVersion *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Version");
	}
;
#line 1863 "lib/Clownfish/CFC.xs"
    RETVAL = CFCVersion_compare_to(self, other);
#line 4482 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__new)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "hierarchy, header, footer");
    {
	CFCHierarchy *	hierarchy;
	const char *	header = (const char *)SvPV_nolen(ST(1))
;
	const char *	footer = (const char *)SvPV_nolen(ST(2))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        hierarchy = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		hierarchy = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 1874 "lib/Clownfish/CFC.xs"
    CFCBindCore *self = CFCBindCore_new(hierarchy, header, footer);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 4519 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core_write_all_modified); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core_write_all_modified)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    {
	CFCBindCore *	self;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Core")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCBindCore *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Core");
	}
;
#line 1883 "lib/Clownfish/CFC.xs"
{
    int modified = 0;
    if (items > 1 && SvOK(ST(1))) {
        modified = !!SvIV(ST(1));
    }
    RETVAL = CFCBindCore_write_all_modified(self, modified);
}
#line 4557 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core_copy_headers); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core_copy_headers)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, dest_dir");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCBindCore *	self;
	const char *	dest_dir = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Core")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCBindCore *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Core");
	}
;
#line 1897 "lib/Clownfish/CFC.xs"
    CFCBindCore_copy_headers(self, dest_dir);
#line 4591 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core_write_host_data_json); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core_write_host_data_json)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, dest_dir");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCBindCore *	self;
	const char *	dest_dir = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Core")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCBindCore *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Core");
	}
;
#line 1904 "lib/Clownfish/CFC.xs"
    CFCBindCore_write_host_data_json(self, dest_dir, "perl");
#line 4624 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Function_func_declaration); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Function_func_declaration)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "unused, func, klass");
    {
	SV *	unused = ST(0)
;
	CFCFunction *	func;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        func = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Function")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		func = INT2PTR(CFCFunction *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Function");
	}
;

	if (!SvOK(ST(2))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 1915 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    RETVAL = S_sv_eat_c_string(CFCBindFunc_func_declaration(func, klass));
#line 4670 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Method_abstract_method_def); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Method_abstract_method_def)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "unused, meth, klass");
    {
	SV *	unused = ST(0)
;
	CFCMethod *	meth;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        meth = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		meth = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;

	if (!SvOK(ST(2))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 1927 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    RETVAL = S_sv_eat_c_string(CFCBindMeth_abstract_method_def(meth, klass));
#line 4717 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Method__method_def); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Method__method_def)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "meth, klass");
    {
	CFCMethod *	meth;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        meth = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		meth = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 1936 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCBindMeth_method_def(meth, klass));
#line 4761 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Aliases_c_aliases); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Aliases_c_aliases)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	SV *	RETVAL;
#line 1944 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    RETVAL = S_sv_eat_c_string(CFCBindAliases_c_aliases());
#line 4780 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Class__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Class__new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "client");
    {
	CFCClass *	client;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        client = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		client = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 1954 "lib/Clownfish/CFC.xs"
    CFCBindClass *self = CFCBindClass_new(client);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 4813 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Class_to_c_data); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Class_to_c_data)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCBindClass *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Core::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCBindClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Core::Class");
	}
;
#line 1963 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCBindClass_to_c_data(self));
#line 4844 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Class_to_c_header); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__Class_to_c_header)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCBindClass *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Core::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCBindClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Core::Class");
	}
;
#line 1970 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCBindClass_to_c_header(self));
#line 4875 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Core__File__write_h); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Core__File__write_h)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "file, dest, header, footer");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCFile *	file;
	const char *	dest = (const char *)SvPV_nolen(ST(1))
;
	const char *	header = (const char *)SvPV_nolen(ST(2))
;
	const char *	footer = (const char *)SvPV_nolen(ST(3))
;

	if (!SvOK(ST(0))) {
        file = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::File")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		file = INT2PTR(CFCFile *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::File");
	}
;
#line 1982 "lib/Clownfish/CFC.xs"
    CFCBindFile_write_h(file, dest, header, footer);
#line 4913 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__new)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "hierarchy, lib_dir, header, footer");
    {
	CFCHierarchy *	hierarchy;
	const char *	lib_dir = (const char *)SvPV_nolen(ST(1))
;
	const char *	header = (const char *)SvPV_nolen(ST(2))
;
	const char *	footer = (const char *)SvPV_nolen(ST(3))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        hierarchy = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		hierarchy = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 1993 "lib/Clownfish/CFC.xs"
    CFCPerl *self = CFCPerl_new(hierarchy, lib_dir, header, footer);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 4951 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_pod); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_pod)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCPerl *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerl *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl");
	}
;
#line 2002 "lib/Clownfish/CFC.xs"
    char **written = CFCPerl_write_pod(self);
    AV *modified = newAV();
    for (size_t i = 0; written[i] != NULL; i++) {
        SV *path = S_sv_eat_c_string(written[i]);
        av_push(modified, path);
    }
    FREEMEM(written);
    RETVAL = newRV_noinc((SV*)modified);
#line 4989 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_host_code); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_host_code)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerl *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerl *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl");
	}
;
#line 2016 "lib/Clownfish/CFC.xs"
    CFCPerl_write_host_code(self);
#line 5021 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_hostdefs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_hostdefs)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerl *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerl *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl");
	}
;
#line 2022 "lib/Clownfish/CFC.xs"
    CFCPerl_write_hostdefs(self);
#line 5052 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__write_bindings); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__write_bindings)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, boot_class, sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerl *	self;
	const char *	boot_class = (const char *)SvPV_nolen(ST(1))
;
	SV *	sv = ST(2)
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerl *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl");
	}
;
#line 2030 "lib/Clownfish/CFC.xs"
    CFCParcel **parcels = (CFCParcel**)
        S_av_to_array_of_cfcbase(sv, "Clownfish::CFC::Model::Parcel");
    CFCPerl_write_bindings(self, boot_class, parcels);
    FREEMEM(parcels);
#line 5090 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_xs_typemap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl_write_xs_typemap)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerl *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerl *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl");
	}
;
#line 2039 "lib/Clownfish/CFC.xs"
    CFCPerl_write_xs_typemap(self);
#line 5121 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlSub *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Subroutine")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlSub *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Subroutine");
	}
;
#line 2055 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *value = CFCPerlSub_get_class_name(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 4:
            retval = newSViv(CFCPerlSub_use_labeled_params(self));
            break;
        case 6: {
                const char *value = CFCPerlSub_perl_name(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 8: {
                CFCParamList *value = CFCPerlSub_get_param_list(self);
                retval = S_cfcbase_to_perlref(value);
            }
            break;
        case 10: {
                const char *value = CFCPerlSub_c_name(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 12: {
                const char *value = CFCPerlSub_c_name_list(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 5184 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Subroutine_build_param_specs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Subroutine_build_param_specs)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, first");
    {
	CFCPerlSub *	self;
	int	first = (int)SvIV(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Subroutine")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlSub *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Subroutine");
	}
;
#line 2093 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCPerlSub_build_param_specs(self, first));
#line 5216 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Method__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Method__new)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "klass, method");
    {
	CFCClass *	klass;
	CFCMethod *	method;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;

	if (!SvOK(ST(1))) {
        method = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		method = INT2PTR(CFCMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Method");
	}
;
#line 2104 "lib/Clownfish/CFC.xs"
    CFCPerlMethod *self = CFCPerlMethod_new(klass, method);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 5262 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Method_xsub_def); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Method_xsub_def)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCPerlMethod *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Method")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlMethod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Method");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2114 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCPerlMethod_xsub_def(self, klass));
#line 5306 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Constructor__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Constructor__new)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "klass, alias, init_sv");
    {
	CFCClass *	klass;
	const char *	alias = (const char *)SvPV_nolen(ST(1))
;
	SV *	init_sv = ST(2)
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2126 "lib/Clownfish/CFC.xs"
    const char *init = SvOK(init_sv) ? SvPVutf8_nolen(init_sv) : NULL;
    CFCPerlConstructor *self = CFCPerlConstructor_new(klass, alias, init);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 5344 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Constructor_xsub_def); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Constructor_xsub_def)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCPerlConstructor *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Constructor")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlConstructor *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Constructor");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2137 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCPerlConstructor_xsub_def(self, klass));
#line 5388 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__new)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "parcel, class_name");
    {
	CFCParcel *	parcel;
	const char *	class_name = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 2147 "lib/Clownfish/CFC.xs"
    CFCPerlClass *self = CFCPerlClass_new(parcel, class_name);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 5423 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_register); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_register)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "unused, binding");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	unused = ST(0)
;
	CFCPerlClass *	binding;

	if (!SvOK(ST(1))) {
        binding = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		binding = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2157 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    CFCPerlClass_add_to_registry(binding);
#line 5458 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_singleton); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_singleton)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "unused_sv, class_name");
    {
	SV *	unused_sv = ST(0)
;
	const char *	class_name = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;
#line 2165 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused_sv);
    CFCPerlClass *binding = CFCPerlClass_singleton(class_name);
    RETVAL = S_cfcbase_to_perlref(binding);
#line 5481 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_registered); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_registered)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	SV *	RETVAL;
#line 2173 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    CFCPerlClass **registry = CFCPerlClass_registry();
    RETVAL = S_array_of_cfcbase_to_av((CFCBase**)registry);
#line 5501 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__clear_registry); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__clear_registry)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2181 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(items);
    CFCPerlClass_clear_registry();
#line 5521 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__bind_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__bind_method)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, alias_sv, meth_sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;
	SV *	alias_sv = ST(1)
;
	SV *	meth_sv = ST(2)
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2190 "lib/Clownfish/CFC.xs"
    const char *alias = SvOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
    const char *meth  = SvOK(meth_sv)  ? SvPVutf8_nolen(meth_sv)  : NULL;
    CFCPerlClass_bind_method(self, alias, meth);
#line 5558 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__bind_constructor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__bind_constructor)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, alias_sv, init_sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;
	SV *	alias_sv = ST(1)
;
	SV *	init_sv = ST(2)
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2200 "lib/Clownfish/CFC.xs"
    const char *alias = SvOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
    const char *init  = SvOK(init_sv)  ? SvPVutf8_nolen(init_sv)  : NULL;
    CFCPerlClass_bind_constructor(self, alias, init);
#line 5595 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_exclude_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_exclude_method)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, method");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;
	const char *	method = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2209 "lib/Clownfish/CFC.xs"
    CFCPerlClass_exclude_method(self, method);
#line 5628 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_exclude_constructor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_exclude_constructor)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2215 "lib/Clownfish/CFC.xs"
    CFCPerlClass_exclude_constructor(self);
#line 5659 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_append_xs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_append_xs)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, xs");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;
	const char *	xs = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2222 "lib/Clownfish/CFC.xs"
    CFCPerlClass_append_xs(self, xs);
#line 5692 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_method_bindings); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_method_bindings)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "unused, klass");
    {
	SV *	unused = ST(0)
;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2229 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    CFCPerlMethod **bound = CFCPerlClass_method_bindings(klass);
    RETVAL = S_array_of_cfcbase_to_av((CFCBase**)bound);
    FREEMEM(bound);
#line 5727 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_constructor_bindings); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_constructor_bindings)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "unused, klass");
    {
	SV *	unused = ST(0)
;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2240 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    CFCPerlConstructor **bound = CFCPerlClass_constructor_bindings(klass);
    RETVAL = S_array_of_cfcbase_to_av((CFCBase**)bound);
    FREEMEM(bound);
#line 5763 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_create_pod); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_create_pod)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCPerlClass *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2250 "lib/Clownfish/CFC.xs"
    char *pod = CFCPerlClass_create_pod(self);
    RETVAL = S_sv_eat_c_string(pod);
#line 5795 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2264 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 2: {
                const char *value = CFCPerlClass_get_class_name(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 4: {
                CFCClass *value = CFCPerlClass_get_client(self);
                retval = S_cfcbase_to_perlref(value);
            }
            break;
        case 6: {
                const char *value = CFCPerlClass_get_xs_code(self);
                retval = value
                         ? newSVpvn(value, strlen(value))
                         : newSV(0);
            }
            break;
        case 7: {
                CFCPerlPod *pod_spec = NULL;
                if (SvOK(ST(1))
                    && sv_derived_from(ST(1), "Clownfish::CFC::Binding::Perl::Pod")
                   ) {
                    IV objint = SvIV((SV*)SvRV(ST(1)));
                    pod_spec = INT2PTR(CFCPerlPod*, objint);
                }
                CFCPerlClass_set_pod_spec(self, pod_spec);
                break;
            }
        case 8: {
                CFCPerlPod *value = CFCPerlClass_get_pod_spec(self);
                retval = S_cfcbase_to_perlref(value);
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 5864 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_add_class_alias); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_add_class_alias)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, alias");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlClass *	self;
	const char *	alias = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2307 "lib/Clownfish/CFC.xs"
    CFCPerlClass_add_class_alias(self, alias);
#line 5897 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_get_class_aliases); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Class_get_class_aliases)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCPerlClass *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Class");
	}
;
#line 2313 "lib/Clownfish/CFC.xs"
    const char **aliases = CFCPerlClass_get_class_aliases(self);
    RETVAL = S_string_array_to_av(aliases);
#line 5928 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod_new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "unused");
    {
	SV *	unused = ST(0)
;
	SV *	RETVAL;
#line 2324 "lib/Clownfish/CFC.xs"
    CHY_UNUSED_VAR(unused);
    CFCPerlPod *self = CFCPerlPod_new();
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 5951 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__add_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__add_method)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, alias, method_sv, sample_sv, pod_sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlPod *	self;
	const char *	alias = (const char *)SvPV_nolen(ST(1))
;
	SV *	method_sv = ST(2)
;
	SV *	sample_sv = ST(3)
;
	SV *	pod_sv = ST(4)
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Pod")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlPod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Pod");
	}
;
#line 2338 "lib/Clownfish/CFC.xs"
    const char *method = SvPOK(method_sv) ? SvPVutf8_nolen(method_sv) : NULL;
    const char *sample = SvPOK(sample_sv) ? SvPVutf8_nolen(sample_sv) : NULL;
    const char *pod    = SvPOK(pod_sv)    ? SvPVutf8_nolen(pod_sv)    : NULL;
    CFCPerlPod_add_method(self, alias, method, sample, pod);
#line 5994 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__add_constructor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__add_constructor)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, alias_sv, func_sv, sample_sv, pod_sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlPod *	self;
	SV *	alias_sv = ST(1)
;
	SV *	func_sv = ST(2)
;
	SV *	sample_sv = ST(3)
;
	SV *	pod_sv = ST(4)
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Pod")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlPod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Pod");
	}
;
#line 2351 "lib/Clownfish/CFC.xs"
    const char *alias  = SvPOK(alias_sv)  ? SvPVutf8_nolen(alias_sv)  : NULL;
    const char *func   = SvPOK(func_sv)   ? SvPVutf8_nolen(func_sv)   : NULL;
    const char *sample = SvPOK(sample_sv) ? SvPVutf8_nolen(sample_sv) : NULL;
    const char *pod    = SvPOK(pod_sv)    ? SvPVutf8_nolen(pod_sv)    : NULL;
    CFCPerlPod_add_constructor(self, alias, func, sample, pod);
#line 6037 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod_methods_pod); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod_methods_pod)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCPerlPod *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Pod")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlPod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Pod");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2362 "lib/Clownfish/CFC.xs"
    char *methods_pod = CFCPerlPod_methods_pod(self, klass);
    RETVAL = S_sv_eat_c_string(methods_pod);
#line 6081 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod_constructors_pod); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod_constructors_pod)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, klass");
    {
	CFCPerlPod *	self;
	CFCClass *	klass;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Pod")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlPod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Pod");
	}
;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2371 "lib/Clownfish/CFC.xs"
    char *constructors_pod = CFCPerlPod_constructors_pod(self, klass);
    RETVAL = S_sv_eat_c_string(constructors_pod);
#line 6126 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get)
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1)
       croak_xs_usage(cv,  "self, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCPerlPod *	self;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Binding::Perl::Pod")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCPerlPod *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Binding::Perl::Pod");
	}
;
#line 2384 "lib/Clownfish/CFC.xs"
{
    START_SET_OR_GET_SWITCH
        case 1: {
                const char *val = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
                CFCPerlPod_set_synopsis(self, val);
            }
            break;
        case 2: {
                const char *value = CFCPerlPod_get_synopsis(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
        case 3: {
                const char *val = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
                CFCPerlPod_set_description(self, val);
            }
            break;
        case 4: {
                const char *value = CFCPerlPod_get_description(self);
                retval = newSVpvn(value, strlen(value));
            }
            break;
    END_SET_OR_GET_SWITCH
}
#line 6182 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__md_to_pod); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__md_to_pod)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "source, klass, header_level");
    {
	CFCClass *	klass;
	const char *	source = (const char *)SvPV_nolen(ST(0))
;
	int	header_level = (int)SvIV(ST(2))
;
	SV *	RETVAL;

	if (!SvOK(ST(1))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2416 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCPerlPod_md_to_pod(source, klass,
                                                    header_level));
#line 6217 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__gen_subroutine_pod); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__Pod__gen_subroutine_pod)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "func, alias, klass, code_sample, class_name, is_constructor");
    {
	CFCCallable *	func;
	const char *	alias = (const char *)SvPV_nolen(ST(1))
;
	CFCClass *	klass;
	const char *	code_sample = (const char *)SvPV_nolen(ST(3))
;
	const char *	class_name = (const char *)SvPV_nolen(ST(4))
;
	int	is_constructor = (int)SvIV(ST(5))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        func = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Callable")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		func = INT2PTR(CFCCallable *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Callable");
	}
;

	if (!SvOK(ST(2))) {
        klass = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::Class")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		klass = INT2PTR(CFCClass *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Class");
	}
;
#line 2429 "lib/Clownfish/CFC.xs"
    char *value = CFCPerlPod_gen_subroutine_pod(func, alias, klass,
                                                code_sample, class_name,
                                                is_constructor);
    RETVAL = S_sv_eat_c_string(value);
#line 6272 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__TypeMap_from_perl); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__TypeMap_from_perl)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "type, xs_var, label");
    {
	CFCType *	type;
	const char *	xs_var = (const char *)SvPV_nolen(ST(1))
;
	const char *	label = (const char *)SvPV_nolen(ST(2))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        type = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		type = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;
#line 2444 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCPerlTypeMap_from_perl(type, xs_var, label));
#line 6307 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__TypeMap_to_perl); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__TypeMap_to_perl)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "type, cf_var");
    {
	CFCType *	type;
	const char *	cf_var = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        type = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Type")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		type = INT2PTR(CFCType *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Type");
	}
;
#line 2452 "lib/Clownfish/CFC.xs"
    RETVAL = S_sv_eat_c_string(CFCPerlTypeMap_to_perl(type, cf_var));
#line 6340 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__TypeMap__write_xs_typemap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Binding__Perl__TypeMap__write_xs_typemap)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "hierarchy");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCHierarchy *	hierarchy;

	if (!SvOK(ST(0))) {
        hierarchy = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Model::Hierarchy")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		hierarchy = INT2PTR(CFCHierarchy *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Hierarchy");
	}
;
#line 2459 "lib/Clownfish/CFC.xs"
    CFCPerlTypeMap_write_xs_typemap(hierarchy);
#line 6372 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Parser_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Parser_new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "klass");
    {
	const char *	klass = (const char *)SvPV_nolen(ST(0))
;
	SV *	RETVAL;
#line 2468 "lib/Clownfish/CFC.xs"
    if (strcmp(klass, "Clownfish::CFC::Parser")) {
        croak("No subclassing allowed");
    }
    CFCParser *self = CFCParser_new();
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 6396 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Parser_parse); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Parser_parse)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, string");
    {
	CFCParser *	self;
	const char *	string = (const char *)SvPV_nolen(ST(1))
;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Parser")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParser *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Parser");
	}
;
#line 2481 "lib/Clownfish/CFC.xs"
    CFCBase *got = CFCParser_parse(self, string);
    RETVAL = S_cfcbase_to_perlref(got);
    CFCBase_decref((CFCBase*)got);
#line 6431 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Parser__parse_file); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Parser__parse_file)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, string, file_spec");
    {
	CFCParser *	self;
	const char *	string = (const char *)SvPV_nolen(ST(1))
;
	CFCFileSpec *	file_spec;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Parser")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParser *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Parser");
	}
;

	if (!SvOK(ST(2))) {
        file_spec = NULL;
    }
	else if (sv_derived_from(ST(2), "Clownfish::CFC::Model::FileSpec")) {
		IV objint = SvIV((SV*)SvRV(ST(2)));
		file_spec = INT2PTR(CFCFileSpec *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::FileSpec");
	}
;
#line 2492 "lib/Clownfish/CFC.xs"
    CFCFile *got = CFCParser_parse_file(self, string, file_spec);
    RETVAL = S_cfcbase_to_perlref(got);
    CFCBase_decref((CFCBase*)got);
#line 6479 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Parser_set_parcel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Parser_set_parcel)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, parcel");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParser *	self;
	CFCParcel *	parcel;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Parser")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParser *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Parser");
	}
;

	if (!SvOK(ST(1))) {
        parcel = NULL;
    }
	else if (sv_derived_from(ST(1), "Clownfish::CFC::Model::Parcel")) {
		IV objint = SvIV((SV*)SvRV(ST(1)));
		parcel = INT2PTR(CFCParcel *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Model::Parcel");
	}
;
#line 2502 "lib/Clownfish/CFC.xs"
    CFCParser_set_parcel(self, parcel);
#line 6524 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Parser_set_class_name); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Parser_set_class_name)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, class_name");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	CFCParser *	self;
	const char *	class_name = (const char *)SvPV_nolen(ST(1))
;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Parser")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParser *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Parser");
	}
;
#line 2509 "lib/Clownfish/CFC.xs"
    CFCParser_set_class_name(self, class_name);
#line 6557 "lib/Clownfish/CFC.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Clownfish__CFC__Parser_get_parcel); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Parser_get_parcel)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	CFCParser *	self;
	SV *	RETVAL;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Parser")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCParser *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Parser");
	}
;
#line 2515 "lib/Clownfish/CFC.xs"
    CFCParcel *parcel = CFCParser_get_parcel(self);
    RETVAL = S_cfcbase_to_perlref((CFCBase*)parcel);
#line 6588 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Test__new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Test__new)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "formatter_name");
    {
	const char *	formatter_name = (const char *)SvPV_nolen(ST(0))
;
	SV *	RETVAL;
#line 2526 "lib/Clownfish/CFC.xs"
    CFCTest *self = CFCTest_new(formatter_name);
    RETVAL = S_cfcbase_to_perlref(self);
    CFCBase_decref((CFCBase*)self);
#line 6610 "lib/Clownfish/CFC.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Clownfish__CFC__Test_run_batch); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Clownfish__CFC__Test_run_batch)
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "self, klass, test_files_dir = NULL");
    {
	CFCTest *	self;
	const char *	klass = (const char *)SvPV_nolen(ST(1))
;
	const char *	test_files_dir;
	int	RETVAL;
	dXSTARG;

	if (!SvOK(ST(0))) {
        self = NULL;
    }
	else if (sv_derived_from(ST(0), "Clownfish::CFC::Test")) {
		IV objint = SvIV((SV*)SvRV(ST(0)));
		self = INT2PTR(CFCTest *, objint);
	}
    else {
		croak("Not a Clownfish::CFC::Test");
	}
;

	if (items < 3)
	    test_files_dir = NULL;
	else {
	    test_files_dir = (const char *)SvPV_nolen(ST(2))
;
	}
#line 2537 "lib/Clownfish/CFC.xs"
    RETVAL = CFCTest_run_batch(self, klass, test_files_dir);
#line 6652 "lib/Clownfish/CFC.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}

#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_Clownfish__CFC); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Clownfish__CFC)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if PERL_VERSION_LE(5, 8, 999) /* PERL_VERSION_LT is 5.33+ */
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

        newXS_deffile("Clownfish::CFC::Base::DESTROY", XS_Clownfish__CFC__Base_DESTROY);
        newXS_deffile("Clownfish::CFC::Model::CBlock::_new", XS_Clownfish__CFC__Model__CBlock__new);
        cv = newXS_deffile("Clownfish::CFC::Model::CBlock::_set_or_get", XS_Clownfish__CFC__Model__CBlock__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::CBlock::get_contents", XS_Clownfish__CFC__Model__CBlock__set_or_get);
        XSANY.any_i32 = 2;
        newXS_deffile("Clownfish::CFC::Model::Class::_create", XS_Clownfish__CFC__Model__Class__create);
        newXS_deffile("Clownfish::CFC::Model::Class::fetch_singleton", XS_Clownfish__CFC__Model__Class_fetch_singleton);
        newXS_deffile("Clownfish::CFC::Model::Class::_clear_registry", XS_Clownfish__CFC__Model__Class__clear_registry);
        newXS_deffile("Clownfish::CFC::Model::Class::add_child", XS_Clownfish__CFC__Model__Class_add_child);
        newXS_deffile("Clownfish::CFC::Model::Class::add_member_var", XS_Clownfish__CFC__Model__Class_add_member_var);
        newXS_deffile("Clownfish::CFC::Model::Class::add_function", XS_Clownfish__CFC__Model__Class_add_function);
        newXS_deffile("Clownfish::CFC::Model::Class::add_method", XS_Clownfish__CFC__Model__Class_add_method);
        newXS_deffile("Clownfish::CFC::Model::Class::grow_tree", XS_Clownfish__CFC__Model__Class_grow_tree);
        newXS_deffile("Clownfish::CFC::Model::Class::add_inert_var", XS_Clownfish__CFC__Model__Class_add_inert_var);
        newXS_deffile("Clownfish::CFC::Model::Class::function", XS_Clownfish__CFC__Model__Class_function);
        newXS_deffile("Clownfish::CFC::Model::Class::method", XS_Clownfish__CFC__Model__Class_method);
        newXS_deffile("Clownfish::CFC::Model::Class::fresh_method", XS_Clownfish__CFC__Model__Class_fresh_method);
        newXS_deffile("Clownfish::CFC::Model::Class::resolve_types", XS_Clownfish__CFC__Model__Class_resolve_types);
        cv = newXS_deffile("Clownfish::CFC::Model::Class::_set_or_get", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::children", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 32;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::final", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 14;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::fresh_member_vars", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 46;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::fresh_methods", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 44;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::full_class_var", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 24;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::full_struct_sym", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 20;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::functions", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 34;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_docucomment", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 30;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_exposure", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_name", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_nickname", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_parent", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_parent_class_name", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_path_part", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::get_struct_sym", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 18;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::include_h", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 28;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::included", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 50;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::inert", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 16;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::inert_vars", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 40;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::member_vars", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 38;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::methods", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 36;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::privacy_symbol", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 48;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::set_parent", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 7;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::short_class_var", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 22;
        cv = newXS_deffile("Clownfish::CFC::Model::Class::tree_to_ladder", XS_Clownfish__CFC__Model__Class__set_or_get);
        XSANY.any_i32 = 42;
        newXS_deffile("Clownfish::CFC::Model::DocuComment::parse", XS_Clownfish__CFC__Model__DocuComment_parse);
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::_set_or_get", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::get_brief", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::get_description", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::get_long", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::get_param_docs", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::get_param_names", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::DocuComment::get_retval", XS_Clownfish__CFC__Model__DocuComment__set_or_get);
        XSANY.any_i32 = 12;
        newXS_deffile("Clownfish::CFC::Model::File::_new", XS_Clownfish__CFC__Model__File__new);
        newXS_deffile("Clownfish::CFC::Model::File::add_block", XS_Clownfish__CFC__Model__File_add_block);
        cv = newXS_deffile("Clownfish::CFC::Model::File::_set_or_get", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::File::blocks", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::File::classes", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 14;
        cv = newXS_deffile("Clownfish::CFC::Model::File::get_modified", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::File::get_parcel", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 20;
        cv = newXS_deffile("Clownfish::CFC::Model::File::get_path", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 22;
        cv = newXS_deffile("Clownfish::CFC::Model::File::get_path_part", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::File::get_source_dir", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 16;
        cv = newXS_deffile("Clownfish::CFC::Model::File::guard_close", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::File::guard_name", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::File::guard_start", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::File::included", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 18;
        cv = newXS_deffile("Clownfish::CFC::Model::File::set_modified", XS_Clownfish__CFC__Model__File__set_or_get);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Clownfish::CFC::Model::File::_gen_path", XS_Clownfish__CFC__Model__File__gen_path);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::File::c_path", XS_Clownfish__CFC__Model__File__gen_path);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Clownfish::CFC::Model::File::h_path", XS_Clownfish__CFC__Model__File__gen_path);
        XSANY.any_i32 = 2;
        newXS_deffile("Clownfish::CFC::Model::FileSpec::_new", XS_Clownfish__CFC__Model__FileSpec__new);
        cv = newXS_deffile("Clownfish::CFC::Model::FileSpec::_set_or_get", XS_Clownfish__CFC__Model__FileSpec__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::FileSpec::get_path_part", XS_Clownfish__CFC__Model__FileSpec__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::FileSpec::get_source_dir", XS_Clownfish__CFC__Model__FileSpec__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::FileSpec::included", XS_Clownfish__CFC__Model__FileSpec__set_or_get);
        XSANY.any_i32 = 6;
        newXS_deffile("Clownfish::CFC::Model::Function::_new", XS_Clownfish__CFC__Model__Function__new);
        newXS_deffile("Clownfish::CFC::Model::Function::resolve_types", XS_Clownfish__CFC__Model__Function_resolve_types);
        cv = newXS_deffile("Clownfish::CFC::Model::Function::_various_function_syms", XS_Clownfish__CFC__Model__Function__various_function_syms);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::full_func_sym", XS_Clownfish__CFC__Model__Function__various_function_syms);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::short_func_sym", XS_Clownfish__CFC__Model__Function__various_function_syms);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::_set_or_get", XS_Clownfish__CFC__Model__Function__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::get_docucomment", XS_Clownfish__CFC__Model__Function__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::get_param_list", XS_Clownfish__CFC__Model__Function__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::get_return_type", XS_Clownfish__CFC__Model__Function__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::inline", XS_Clownfish__CFC__Model__Function__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::Function::void", XS_Clownfish__CFC__Model__Function__set_or_get);
        XSANY.any_i32 = 10;
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::_new", XS_Clownfish__CFC__Model__Hierarchy__new);
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::add_source_dir", XS_Clownfish__CFC__Model__Hierarchy_add_source_dir);
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::add_include_dir", XS_Clownfish__CFC__Model__Hierarchy_add_include_dir);
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::build", XS_Clownfish__CFC__Model__Hierarchy_build);
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::read_host_data_json", XS_Clownfish__CFC__Model__Hierarchy_read_host_data_json);
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::propagate_modified", XS_Clownfish__CFC__Model__Hierarchy_propagate_modified);
        newXS_deffile("Clownfish::CFC::Model::Hierarchy::write_log", XS_Clownfish__CFC__Model__Hierarchy_write_log);
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::_set_or_get", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::files", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::get_dest", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::get_include_dest", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::get_include_dirs", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 14;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::get_source_dest", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::get_source_dirs", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::Hierarchy::ordered_classes", XS_Clownfish__CFC__Model__Hierarchy__set_or_get);
        XSANY.any_i32 = 10;
        newXS_deffile("Clownfish::CFC::Model::Method::_new", XS_Clownfish__CFC__Model__Method__new);
        newXS_deffile("Clownfish::CFC::Model::Method::compatible", XS_Clownfish__CFC__Model__Method_compatible);
        newXS_deffile("Clownfish::CFC::Model::Method::override", XS_Clownfish__CFC__Model__Method_override);
        newXS_deffile("Clownfish::CFC::Model::Method::finalize", XS_Clownfish__CFC__Model__Method_finalize);
        newXS_deffile("Clownfish::CFC::Model::Method::resolve_types", XS_Clownfish__CFC__Model__Method_resolve_types);
        newXS_deffile("Clownfish::CFC::Model::Method::exclude_from_host", XS_Clownfish__CFC__Model__Method_exclude_from_host);
        cv = newXS_deffile("Clownfish::CFC::Model::Method::_various_method_syms", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::full_method_sym", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::full_offset_sym", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 3;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::full_override_sym", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::full_typedef", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 5;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::short_method_sym", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::short_typedef", XS_Clownfish__CFC__Model__Method__various_method_syms);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::_set_or_get", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::abstract", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::excluded_from_host", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 22;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::final", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 16;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::get_host_alias", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 20;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::novel", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 14;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::self_type", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 18;
        cv = newXS_deffile("Clownfish::CFC::Model::Method::set_host_alias", XS_Clownfish__CFC__Model__Method__set_or_get);
        XSANY.any_i32 = 19;
        newXS_deffile("Clownfish::CFC::Model::ParamList::_new", XS_Clownfish__CFC__Model__ParamList__new);
        newXS_deffile("Clownfish::CFC::Model::ParamList::add_param", XS_Clownfish__CFC__Model__ParamList_add_param);
        newXS_deffile("Clownfish::CFC::Model::ParamList::resolve_types", XS_Clownfish__CFC__Model__ParamList_resolve_types);
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::_set_or_get", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::get_initial_values", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::get_variables", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::name_list", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::num_vars", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::to_c", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::ParamList::variadic", XS_Clownfish__CFC__Model__ParamList__set_or_get);
        XSANY.any_i32 = 6;
        newXS_deffile("Clownfish::CFC::Model::Parcel::_new", XS_Clownfish__CFC__Model__Parcel__new);
        newXS_deffile("Clownfish::CFC::Model::Parcel::_new_from_file", XS_Clownfish__CFC__Model__Parcel__new_from_file);
        newXS_deffile("Clownfish::CFC::Model::Parcel::_new_from_json", XS_Clownfish__CFC__Model__Parcel__new_from_json);
        newXS_deffile("Clownfish::CFC::Model::Parcel::fetch", XS_Clownfish__CFC__Model__Parcel_fetch);
        newXS_deffile("Clownfish::CFC::Model::Parcel::register", XS_Clownfish__CFC__Model__Parcel_register);
        newXS_deffile("Clownfish::CFC::Model::Parcel::equals", XS_Clownfish__CFC__Model__Parcel_equals);
        newXS_deffile("Clownfish::CFC::Model::Parcel::all_parcels", XS_Clownfish__CFC__Model__Parcel_all_parcels);
        newXS_deffile("Clownfish::CFC::Model::Parcel::add_inherited_parcel", XS_Clownfish__CFC__Model__Parcel_add_inherited_parcel);
        newXS_deffile("Clownfish::CFC::Model::Parcel::has_prereq", XS_Clownfish__CFC__Model__Parcel_has_prereq);
        newXS_deffile("Clownfish::CFC::Model::Parcel::add_struct_sym", XS_Clownfish__CFC__Model__Parcel_add_struct_sym);
        newXS_deffile("Clownfish::CFC::Model::Parcel::lookup_struct_sym", XS_Clownfish__CFC__Model__Parcel_lookup_struct_sym);
        newXS_deffile("Clownfish::CFC::Model::Parcel::reap_singletons", XS_Clownfish__CFC__Model__Parcel_reap_singletons);
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::_set_or_get", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_PREFIX", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_Prefix", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_name", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_nickname", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_prefix", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_prereqs", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 14;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_version", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::get_xs_module", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 24;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::included", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 16;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::inherited_parcels", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 22;
        cv = newXS_deffile("Clownfish::CFC::Model::Parcel::prereq_parcels", XS_Clownfish__CFC__Model__Parcel__set_or_get);
        XSANY.any_i32 = 20;
        newXS_deffile("Clownfish::CFC::Model::Prereq::_new", XS_Clownfish__CFC__Model__Prereq__new);
        cv = newXS_deffile("Clownfish::CFC::Model::Prereq::_set_or_get", XS_Clownfish__CFC__Model__Prereq__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Prereq::get_name", XS_Clownfish__CFC__Model__Prereq__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Prereq::get_version", XS_Clownfish__CFC__Model__Prereq__set_or_get);
        XSANY.any_i32 = 4;
        newXS_deffile("Clownfish::CFC::Model::Symbol::_new", XS_Clownfish__CFC__Model__Symbol__new);
        newXS_deffile("Clownfish::CFC::Model::Symbol::equals", XS_Clownfish__CFC__Model__Symbol_equals);
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::_various_syms", XS_Clownfish__CFC__Model__Symbol__various_syms);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::full_sym", XS_Clownfish__CFC__Model__Symbol__various_syms);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::short_sym", XS_Clownfish__CFC__Model__Symbol__various_syms);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::_set_or_get", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::get_exposure", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::get_name", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::local", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 24;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::parcel", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 22;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::private", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 20;
        cv = newXS_deffile("Clownfish::CFC::Model::Symbol::public", XS_Clownfish__CFC__Model__Symbol__set_or_get);
        XSANY.any_i32 = 18;
        newXS_deffile("Clownfish::CFC::Model::Type::_new", XS_Clownfish__CFC__Model__Type__new);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_integer", XS_Clownfish__CFC__Model__Type__new_integer);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_float", XS_Clownfish__CFC__Model__Type__new_float);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_object", XS_Clownfish__CFC__Model__Type__new_object);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_composite", XS_Clownfish__CFC__Model__Type__new_composite);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_void", XS_Clownfish__CFC__Model__Type__new_void);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_va_list", XS_Clownfish__CFC__Model__Type__new_va_list);
        newXS_deffile("Clownfish::CFC::Model::Type::_new_arbitrary", XS_Clownfish__CFC__Model__Type__new_arbitrary);
        newXS_deffile("Clownfish::CFC::Model::Type::equals", XS_Clownfish__CFC__Model__Type_equals);
        newXS_deffile("Clownfish::CFC::Model::Type::similar", XS_Clownfish__CFC__Model__Type_similar);
        newXS_deffile("Clownfish::CFC::Model::Type::CONST", XS_Clownfish__CFC__Model__Type_CONST);
        newXS_deffile("Clownfish::CFC::Model::Type::NULLABLE", XS_Clownfish__CFC__Model__Type_NULLABLE);
        newXS_deffile("Clownfish::CFC::Model::Type::INCREMENTED", XS_Clownfish__CFC__Model__Type_INCREMENTED);
        newXS_deffile("Clownfish::CFC::Model::Type::DECREMENTED", XS_Clownfish__CFC__Model__Type_DECREMENTED);
        newXS_deffile("Clownfish::CFC::Model::Type::VOID", XS_Clownfish__CFC__Model__Type_VOID);
        newXS_deffile("Clownfish::CFC::Model::Type::OBJECT", XS_Clownfish__CFC__Model__Type_OBJECT);
        newXS_deffile("Clownfish::CFC::Model::Type::PRIMITIVE", XS_Clownfish__CFC__Model__Type_PRIMITIVE);
        newXS_deffile("Clownfish::CFC::Model::Type::INTEGER", XS_Clownfish__CFC__Model__Type_INTEGER);
        newXS_deffile("Clownfish::CFC::Model::Type::FLOATING", XS_Clownfish__CFC__Model__Type_FLOATING);
        newXS_deffile("Clownfish::CFC::Model::Type::CFISH_STRING", XS_Clownfish__CFC__Model__Type_CFISH_STRING);
        newXS_deffile("Clownfish::CFC::Model::Type::VA_LIST", XS_Clownfish__CFC__Model__Type_VA_LIST);
        newXS_deffile("Clownfish::CFC::Model::Type::ARBITRARY", XS_Clownfish__CFC__Model__Type_ARBITRARY);
        newXS_deffile("Clownfish::CFC::Model::Type::COMPOSITE", XS_Clownfish__CFC__Model__Type_COMPOSITE);
        newXS_deffile("Clownfish::CFC::Model::Type::resolve", XS_Clownfish__CFC__Model__Type_resolve);
        cv = newXS_deffile("Clownfish::CFC::Model::Type::_set_or_get", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::cfish_string", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 24;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::const", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::decremented", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 36;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::get_array", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 38;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::get_indirection", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::get_parcel", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::get_specifier", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::get_width", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 32;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::incremented", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 34;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_arbitrary", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 28;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_composite", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 30;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_floating", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 22;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_integer", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 20;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_object", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 16;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_primitive", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 18;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_va_list", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 26;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::is_void", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 14;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::nullable", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::set_nullable", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 11;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::set_specifier", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Clownfish::CFC::Model::Type::to_c", XS_Clownfish__CFC__Model__Type__set_or_get);
        XSANY.any_i32 = 8;
        newXS_deffile("Clownfish::CFC::Util::trim_whitespace", XS_Clownfish__CFC__Util_trim_whitespace);
        newXS_deffile("Clownfish::CFC::Util::slurp_text", XS_Clownfish__CFC__Util_slurp_text);
        newXS_deffile("Clownfish::CFC::Util::current", XS_Clownfish__CFC__Util_current);
        newXS_deffile("Clownfish::CFC::Util::write_if_changed", XS_Clownfish__CFC__Util_write_if_changed);
        newXS_deffile("Clownfish::CFC::Util::is_dir", XS_Clownfish__CFC__Util_is_dir);
        newXS_deffile("Clownfish::CFC::Util::make_dir", XS_Clownfish__CFC__Util_make_dir);
        newXS_deffile("Clownfish::CFC::Util::make_path", XS_Clownfish__CFC__Util_make_path);
        newXS_deffile("Clownfish::CFC::Model::Variable::_new", XS_Clownfish__CFC__Model__Variable__new);
        newXS_deffile("Clownfish::CFC::Model::Variable::equals", XS_Clownfish__CFC__Model__Variable_equals);
        newXS_deffile("Clownfish::CFC::Model::Variable::resolve_type", XS_Clownfish__CFC__Model__Variable_resolve_type);
        newXS_deffile("Clownfish::CFC::Model::Variable::global_c", XS_Clownfish__CFC__Model__Variable_global_c);
        cv = newXS_deffile("Clownfish::CFC::Model::Variable::_set_or_get", XS_Clownfish__CFC__Model__Variable__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Variable::get_type", XS_Clownfish__CFC__Model__Variable__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Variable::local_c", XS_Clownfish__CFC__Model__Variable__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Model::Variable::local_declaration", XS_Clownfish__CFC__Model__Variable__set_or_get);
        XSANY.any_i32 = 8;
        newXS_deffile("Clownfish::CFC::Model::Version::_new", XS_Clownfish__CFC__Model__Version__new);
        cv = newXS_deffile("Clownfish::CFC::Model::Version::_set_or_get", XS_Clownfish__CFC__Model__Version__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Model::Version::get_major", XS_Clownfish__CFC__Model__Version__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Model::Version::get_vstring", XS_Clownfish__CFC__Model__Version__set_or_get);
        XSANY.any_i32 = 4;
        newXS_deffile("Clownfish::CFC::Model::Version::compare_to", XS_Clownfish__CFC__Model__Version_compare_to);
        newXS_deffile("Clownfish::CFC::Binding::Core::_new", XS_Clownfish__CFC__Binding__Core__new);
        newXS_deffile("Clownfish::CFC::Binding::Core::write_all_modified", XS_Clownfish__CFC__Binding__Core_write_all_modified);
        newXS_deffile("Clownfish::CFC::Binding::Core::copy_headers", XS_Clownfish__CFC__Binding__Core_copy_headers);
        newXS_deffile("Clownfish::CFC::Binding::Core::write_host_data_json", XS_Clownfish__CFC__Binding__Core_write_host_data_json);
        newXS_deffile("Clownfish::CFC::Binding::Core::Function::func_declaration", XS_Clownfish__CFC__Binding__Core__Function_func_declaration);
        newXS_deffile("Clownfish::CFC::Binding::Core::Method::abstract_method_def", XS_Clownfish__CFC__Binding__Core__Method_abstract_method_def);
        newXS_deffile("Clownfish::CFC::Binding::Core::Method::_method_def", XS_Clownfish__CFC__Binding__Core__Method__method_def);
        newXS_deffile("Clownfish::CFC::Binding::Core::Aliases::c_aliases", XS_Clownfish__CFC__Binding__Core__Aliases_c_aliases);
        newXS_deffile("Clownfish::CFC::Binding::Core::Class::_new", XS_Clownfish__CFC__Binding__Core__Class__new);
        newXS_deffile("Clownfish::CFC::Binding::Core::Class::to_c_data", XS_Clownfish__CFC__Binding__Core__Class_to_c_data);
        newXS_deffile("Clownfish::CFC::Binding::Core::Class::to_c_header", XS_Clownfish__CFC__Binding__Core__Class_to_c_header);
        newXS_deffile("Clownfish::CFC::Binding::Core::File::_write_h", XS_Clownfish__CFC__Binding__Core__File__write_h);
        newXS_deffile("Clownfish::CFC::Binding::Perl::_new", XS_Clownfish__CFC__Binding__Perl__new);
        newXS_deffile("Clownfish::CFC::Binding::Perl::write_pod", XS_Clownfish__CFC__Binding__Perl_write_pod);
        newXS_deffile("Clownfish::CFC::Binding::Perl::write_host_code", XS_Clownfish__CFC__Binding__Perl_write_host_code);
        newXS_deffile("Clownfish::CFC::Binding::Perl::write_hostdefs", XS_Clownfish__CFC__Binding__Perl_write_hostdefs);
        newXS_deffile("Clownfish::CFC::Binding::Perl::_write_bindings", XS_Clownfish__CFC__Binding__Perl__write_bindings);
        newXS_deffile("Clownfish::CFC::Binding::Perl::write_xs_typemap", XS_Clownfish__CFC__Binding__Perl_write_xs_typemap);
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::_set_or_get", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::c_name", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 10;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::c_name_list", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 12;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::get_class_name", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::get_param_list", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::perl_name", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::use_labeled_params", XS_Clownfish__CFC__Binding__Perl__Subroutine__set_or_get);
        XSANY.any_i32 = 4;
        newXS_deffile("Clownfish::CFC::Binding::Perl::Subroutine::build_param_specs", XS_Clownfish__CFC__Binding__Perl__Subroutine_build_param_specs);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Method::_new", XS_Clownfish__CFC__Binding__Perl__Method__new);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Method::xsub_def", XS_Clownfish__CFC__Binding__Perl__Method_xsub_def);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Constructor::_new", XS_Clownfish__CFC__Binding__Perl__Constructor__new);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Constructor::xsub_def", XS_Clownfish__CFC__Binding__Perl__Constructor_xsub_def);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::_new", XS_Clownfish__CFC__Binding__Perl__Class__new);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::register", XS_Clownfish__CFC__Binding__Perl__Class_register);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::singleton", XS_Clownfish__CFC__Binding__Perl__Class_singleton);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::registered", XS_Clownfish__CFC__Binding__Perl__Class_registered);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::_clear_registry", XS_Clownfish__CFC__Binding__Perl__Class__clear_registry);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::_bind_method", XS_Clownfish__CFC__Binding__Perl__Class__bind_method);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::_bind_constructor", XS_Clownfish__CFC__Binding__Perl__Class__bind_constructor);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::exclude_method", XS_Clownfish__CFC__Binding__Perl__Class_exclude_method);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::exclude_constructor", XS_Clownfish__CFC__Binding__Perl__Class_exclude_constructor);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::append_xs", XS_Clownfish__CFC__Binding__Perl__Class_append_xs);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::method_bindings", XS_Clownfish__CFC__Binding__Perl__Class_method_bindings);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::constructor_bindings", XS_Clownfish__CFC__Binding__Perl__Class_constructor_bindings);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::create_pod", XS_Clownfish__CFC__Binding__Perl__Class_create_pod);
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Class::_set_or_get", XS_Clownfish__CFC__Binding__Perl__Class__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Class::get_class_name", XS_Clownfish__CFC__Binding__Perl__Class__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Class::get_client", XS_Clownfish__CFC__Binding__Perl__Class__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Class::get_pod_spec", XS_Clownfish__CFC__Binding__Perl__Class__set_or_get);
        XSANY.any_i32 = 8;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Class::get_xs_code", XS_Clownfish__CFC__Binding__Perl__Class__set_or_get);
        XSANY.any_i32 = 6;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Class::set_pod_spec", XS_Clownfish__CFC__Binding__Perl__Class__set_or_get);
        XSANY.any_i32 = 7;
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::add_class_alias", XS_Clownfish__CFC__Binding__Perl__Class_add_class_alias);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Class::get_class_aliases", XS_Clownfish__CFC__Binding__Perl__Class_get_class_aliases);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::new", XS_Clownfish__CFC__Binding__Perl__Pod_new);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::_add_method", XS_Clownfish__CFC__Binding__Perl__Pod__add_method);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::_add_constructor", XS_Clownfish__CFC__Binding__Perl__Pod__add_constructor);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::methods_pod", XS_Clownfish__CFC__Binding__Perl__Pod_methods_pod);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::constructors_pod", XS_Clownfish__CFC__Binding__Perl__Pod_constructors_pod);
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::_set_or_get", XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::get_description", XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get);
        XSANY.any_i32 = 4;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::get_synopsis", XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::set_description", XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get);
        XSANY.any_i32 = 3;
        cv = newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::set_synopsis", XS_Clownfish__CFC__Binding__Perl__Pod__set_or_get);
        XSANY.any_i32 = 1;
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::_md_to_pod", XS_Clownfish__CFC__Binding__Perl__Pod__md_to_pod);
        newXS_deffile("Clownfish::CFC::Binding::Perl::Pod::_gen_subroutine_pod", XS_Clownfish__CFC__Binding__Perl__Pod__gen_subroutine_pod);
        newXS_deffile("Clownfish::CFC::Binding::Perl::TypeMap::from_perl", XS_Clownfish__CFC__Binding__Perl__TypeMap_from_perl);
        newXS_deffile("Clownfish::CFC::Binding::Perl::TypeMap::to_perl", XS_Clownfish__CFC__Binding__Perl__TypeMap_to_perl);
        newXS_deffile("Clownfish::CFC::Binding::Perl::TypeMap::_write_xs_typemap", XS_Clownfish__CFC__Binding__Perl__TypeMap__write_xs_typemap);
        newXS_deffile("Clownfish::CFC::Parser::new", XS_Clownfish__CFC__Parser_new);
        newXS_deffile("Clownfish::CFC::Parser::parse", XS_Clownfish__CFC__Parser_parse);
        newXS_deffile("Clownfish::CFC::Parser::_parse_file", XS_Clownfish__CFC__Parser__parse_file);
        newXS_deffile("Clownfish::CFC::Parser::set_parcel", XS_Clownfish__CFC__Parser_set_parcel);
        newXS_deffile("Clownfish::CFC::Parser::set_class_name", XS_Clownfish__CFC__Parser_set_class_name);
        newXS_deffile("Clownfish::CFC::Parser::get_parcel", XS_Clownfish__CFC__Parser_get_parcel);
        newXS_deffile("Clownfish::CFC::Test::_new", XS_Clownfish__CFC__Test__new);
        newXS_deffile("Clownfish::CFC::Test::run_batch", XS_Clownfish__CFC__Test_run_batch);
#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}

