/* Generated by G-Wrap: an experimental C->Guile wrapper engine */

#include <guile/gh.h>
#include <libguile.h>
#include <string.h>
#include <g-wrap-compatibility.h>

#include "gw-test-enumeration.h"
#include "g-wrap-test-c-code.h"
static SCM gw__enum__gw_test_enum__val_to_int_scm_func;
static SCM gw__enum__gw_test_enum__val_to_sym_scm_func;
enum GW__ErrorStatus
{
  GW__ERR_NONE,
  GW__ERR_MISC,
  GW__ERR_MEMORY,
  GW__ERR_RANGE,
  GW__ERR_TYPE,
  GW__ERR_ARGC,
  GW__ERR_ARG_RANGE,
  GW__ERR_ARG_TYPE
};
 
static void
gw__handle_wrapper_error(enum GW__ErrorStatus status,
                         const char *func_name,
                         unsigned int arg_pos,
                         const char *misc_msg,
                         SCM scm_data) __attribute__ ((noreturn));

static void
gw__handle_wrapper_error(enum GW__ErrorStatus status,
                         const char *func_name,
                         unsigned int arg_pos,
                         const char *misc_msg,
                         SCM scm_data)
{
  static SCM out_of_range_key = SCM_BOOL_F;
  static SCM wrong_type_key = SCM_BOOL_F;

  if(SCM_FALSEP(out_of_range_key))
    out_of_range_key = scm_permanent_object(scm_c_make_keyword("out-of-range"));
  if(SCM_FALSEP(wrong_type_key))
    wrong_type_key = scm_permanent_object(scm_c_make_keyword("wrong-type"));

  switch(status) {
  case GW__ERR_NONE:
    scm_misc_error(func_name,
                   "asked to handle error when there wasn't one",
                   SCM_EOL);
    break;
  case GW__ERR_MISC:
    /* scm_data is a list of format args for misc_msg */
    scm_misc_error(func_name, misc_msg, scm_data); break;
  case GW__ERR_MEMORY:
    scm_memory_error(func_name); break;
  case GW__ERR_RANGE:
    scm_error (out_of_range_key,
	       func_name,
	       "Out of range: ~S",
               scm_cons (scm_data, SCM_EOL),
	       SCM_BOOL_F);
    break;
  case GW__ERR_TYPE:
    scm_error(wrong_type_key,
              func_name,
              "Wrong type: ",
              scm_cons (scm_data, SCM_EOL),
              SCM_BOOL_F);
    break;
  case GW__ERR_ARGC:
    scm_wrong_num_args(scm_makfrom0str(func_name)); break;
  case GW__ERR_ARG_RANGE:
    /* scm_data is the bad arg */
    scm_out_of_range(func_name, scm_data); break;
  case GW__ERR_ARG_TYPE:
    /* scm_data is the bad arg */
    scm_wrong_type_arg(func_name, arg_pos, scm_data); break;
  default:
    scm_misc_error(func_name,
                   "asked to handle nonexistent gw:error type: ~S",
                   scm_cons(scm_long2num(status), SCM_EOL));    
    break;
  };
  exit(1);
}
static SCM
gw__enum__gw_test_enum__val_to_sym(SCM gw__scm_val, SCM gw__scm_show_all_p) {
  enum GWTestEnum gw__enum_val;
  SCM gw__scm_result;

  int gw__return_all_syms = SCM_NFALSEP(gw__scm_show_all_p);

  if(gw__return_all_syms) gw__scm_result = SCM_EOL;
  else gw__scm_result = SCM_BOOL_F;

  if(gh_symbol_p(gw__scm_val)) {
    SCM gw__scm_int_value = gh_call1(gw__enum__gw_test_enum__val_to_int_scm_func,
                                     gw__scm_val);
    if(SCM_FALSEP(gw__scm_int_value)) return SCM_EOL;
    if(!gw__return_all_syms) return gw__scm_val;
    gw__enum_val = gh_scm2long(gw__scm_int_value);
  } else {
    /* this better be an int */
    gw__enum_val = gh_scm2long(gw__scm_val);
  }

  
  if(gw__enum_val == GW_TEST_ENUM_TWO_MANY) {
    if(!gw__return_all_syms) return gh_symbol2scm("gw-test-enum-two-many");
    gw__scm_result =
      gh_cons(gh_symbol2scm("gw-test-enum-two-many"), gw__scm_result);
  }

  if(gw__enum_val == GW_TEST_ENUM_TWO_TOO) {
    if(!gw__return_all_syms) return gh_symbol2scm("gw-test-enum-two-too");
    gw__scm_result =
      gh_cons(gh_symbol2scm("gw-test-enum-two-too"), gw__scm_result);
  }

  if(gw__enum_val == GW_TEST_ENUM_TWO) {
    if(!gw__return_all_syms) return gh_symbol2scm("gw-test-enum-two");
    gw__scm_result =
      gh_cons(gh_symbol2scm("gw-test-enum-two"), gw__scm_result);
  }

  if(gw__enum_val == GW_TEST_ENUM_ONE) {
    if(!gw__return_all_syms) return gh_symbol2scm("gw-test-enum-one");
    gw__scm_result =
      gh_cons(gh_symbol2scm("gw-test-enum-one"), gw__scm_result);
  }

  if(gw__enum_val == GW_TEST_ENUM_ZERO) {
    if(!gw__return_all_syms) return gh_symbol2scm("gw-test-enum-zero");
    gw__scm_result =
      gh_cons(gh_symbol2scm("gw-test-enum-zero"), gw__scm_result);
  }

  
  return(gw__scm_result);
}

static SCM
gw__enum__gw_test_enum__val_to_int(SCM gw__scm_val) {
  char *gw__symstr = NULL;

  if(SCM_NFALSEP(scm_integer_p(gw__scm_val))) {
    SCM gw__scm_existing_sym = gh_call2(gw__enum__gw_test_enum__val_to_sym_scm_func,
                                        gw__scm_val,
                                        SCM_BOOL_F);
    if(SCM_FALSEP(gw__scm_existing_sym)) {
      return SCM_BOOL_F;
    } else {
      return gw__scm_val;
    }
  }

  gw__symstr = gh_symbol2newstr(gw__scm_val, NULL);

  
  if(strcmp(gw__symstr, "gw-test-enum-two-many") == 0) {
    free(gw__symstr);
    return gh_long2scm(GW_TEST_ENUM_TWO_MANY);
  }

  if(strcmp(gw__symstr, "gw-test-enum-two-too") == 0) {
    free(gw__symstr);
    return gh_long2scm(GW_TEST_ENUM_TWO_TOO);
  }

  if(strcmp(gw__symstr, "gw-test-enum-two") == 0) {
    free(gw__symstr);
    return gh_long2scm(GW_TEST_ENUM_TWO);
  }

  if(strcmp(gw__symstr, "gw-test-enum-one") == 0) {
    free(gw__symstr);
    return gh_long2scm(GW_TEST_ENUM_ONE);
  }

  if(strcmp(gw__symstr, "gw-test-enum-zero") == 0) {
    free(gw__symstr);
    return gh_long2scm(GW_TEST_ENUM_ZERO);
  }


  free(gw__symstr);
  return SCM_BOOL_F;
}
static char * gw__tmp7_gw_test_gw_enumeration_echo_namestr = "gw-test-gw-enumeration-echo";
static SCM gw__tmp6_gw_test_gw_enumeration_echo_wrapper  (SCM gw__scm_arg0 ) {
  SCM gw__scm_result = SCM_UNSPECIFIED;
  enum GW__ErrorStatus gw__error_status = GW__ERR_NONE;
  SCM gw__error_data = SCM_UNSPECIFIED;
  unsigned int gw__arg_pos = 0;
  const char *gw__error_misc_msg = NULL;
enum GWTestEnum gw__c_result;

enum GWTestEnum gw__c_arg0;
/* ARG 0 */
gw__arg_pos++;
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;

{
gw__scm_arg0 = gh_call1(gw__enum__gw_test_enum__val_to_int_scm_func, gw__scm_arg0);
if(SCM_FALSEP(scm_integer_p(gw__scm_arg0))){
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
else gw__c_arg0 = gh_scm2long(gw__scm_arg0);
if((gw__error_status == GW__ERR_TYPE)){
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
else if((gw__error_status == GW__ERR_RANGE)){
   gw__error_status = GW__ERR_ARG_RANGE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__post_call_arg_0;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_enumeration_echo (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result = gh_long2scm(gw__c_result);
}
}
  gw__post_call_arg_0:
  /* no post-call arg code requested! */
  { /* shut up warnings if no code */ int x = x; }
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp7_gw_test_gw_enumeration_echo_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
void
gw_init_wrapset_gw_test_enumeration() {
  static int gw_wrapset_initialized = 0;

  if(!gw_wrapset_initialized)
  {
    gh_eval_str("(use-modules (g-wrap runtime))");
    gh_eval_str("(gw:wrapset-register-runtime \"gw-test-enumeration\")");

gh_eval_str("(use-modules (g-wrap gw-standard))");
{
   enum GW__ErrorStatus gw__tmp8_status_var = GW__ERR_NONE;
   SCM gw__tmp10_err_data = SCM_UNSPECIFIED;
   char *gw__tmp9_err_misc_msg = NULL;
   (void) gw__tmp8_status_var;
   (void) gw__tmp10_err_data;
   (void) gw__tmp9_err_misc_msg;
}
{
   enum GW__ErrorStatus gw__tmp11_err_status = GW__ERR_NONE;
   SCM gw__tmp13_err_data = SCM_UNSPECIFIED;
   char *gw__tmp12_err_misc_msg = NULL;
   (void) gw__tmp11_err_status;
   (void) gw__tmp13_err_data;
   (void) gw__tmp12_err_misc_msg;

    gw__enum__gw_test_enum__val_to_int_scm_func =
      gh_new_procedure("gw:enum-<gw-test-enum>-val->int",
                       gw__enum__gw_test_enum__val_to_int,
                       1, 0, 0);
    gw__enum__gw_test_enum__val_to_sym_scm_func =
      gh_new_procedure("gw:enum-<gw-test-enum>-val->sym",
                       gw__enum__gw_test_enum__val_to_sym,
                       2, 0, 0);
if (gw__tmp11_err_status != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp11_err_status,
                            "gw_init_wrapset_gw_test_enumeration",
                            0,
                            gw__tmp12_err_misc_msg,
                            gw__tmp13_err_data);
}
{
   enum GW__ErrorStatus gw__tmp14_status_var = GW__ERR_NONE;
   SCM gw__tmp16_err_data = SCM_UNSPECIFIED;
   char *gw__tmp15_err_misc_msg = NULL;
   (void) gw__tmp14_status_var;
   (void) gw__tmp16_err_data;
   (void) gw__tmp15_err_misc_msg;
    gh_new_procedure(gw__tmp7_gw_test_gw_enumeration_echo_namestr,
                     (SCM (*) ()) gw__tmp6_gw_test_gw_enumeration_echo_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp14_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp14_status_var,
                            "gw_init_wrapset_gw_test_enumeration",
                            0,
                            gw__tmp15_err_misc_msg,
                            gw__tmp16_err_data);
}
    gw_wrapset_initialized = 1;
    (void) gw__handle_wrapper_error;
  }
}