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

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

#include "gw-test-standard.h"
#include <limits.h>
#include "g-wrap-test-c-code.h"
static SCM gw__tmp5_range_maxval_gw_unsigned_long_;
static SCM gw__tmp3_range_minval_gw_long_;
static SCM gw__tmp4_range_maxval_gw_long_;
static SCM gw__tmp2_range_maxval_gw_unsigned_int_;
static SCM gw__tmp0_range_minval_gw_int_;
static SCM gw__tmp1_range_maxval_gw_int_;
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 char * gw__tmp9_gw_test_gw_standard_no_op_namestr = "gw-test-gw-standard-no-op";
static SCM gw__tmp8_gw_test_gw_standard_no_op_wrapper  () {
  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;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw_test_gw_standard_no_op ();
SCM_ALLOW_INTS;
{
gw__scm_result = SCM_UNSPECIFIED;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp9_gw_test_gw_standard_no_op_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp11_gw_test_gw_standard_echo_scm_namestr = "gw-test-gw-standard-echo-scm";
static SCM gw__tmp10_gw_test_gw_standard_echo_scm_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;
SCM gw__c_result;

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

{
if (!(1)){
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
else {gw__c_arg0 = 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_standard_echo_scm (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result = 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__tmp11_gw_test_gw_standard_echo_scm_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp13_gw_test_gw_standard_echo_bool_namestr = "gw-test-gw-standard-echo-bool";
static SCM gw__tmp12_gw_test_gw_standard_echo_bool_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;
int gw__c_result;

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

{
if (!(1)){
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
else {gw__c_arg0= SCM_NFALSEP(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_standard_echo_bool (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result= (gw__c_result) ? SCM_BOOL_T : SCM_BOOL_F;
}
}
  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__tmp13_gw_test_gw_standard_echo_bool_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp15_gw_test_gw_standard_echo_char_namestr = "gw-test-gw-standard-echo-char";
static SCM gw__tmp14_gw_test_gw_standard_echo_char_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;
char gw__c_result;

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

{
if (!(SCM_NFALSEP(scm_char_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= SCM_CHAR(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_standard_echo_char (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result= SCM_MAKE_CHAR(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__tmp15_gw_test_gw_standard_echo_char_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp17_gw_test_gw_standard_get_int_min_namestr = "gw-test-gw-standard-get-int-min";
static SCM gw__tmp16_gw_test_gw_standard_get_int_min_wrapper  () {
  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;
SCM gw__c_result;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_standard_get_int_min ();
SCM_ALLOW_INTS;
{
gw__scm_result = gw__c_result;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp17_gw_test_gw_standard_get_int_min_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp19_gw_test_gw_standard_get_int_max_namestr = "gw-test-gw-standard-get-int-max";
static SCM gw__tmp18_gw_test_gw_standard_get_int_max_wrapper  () {
  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;
SCM gw__c_result;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_standard_get_int_max ();
SCM_ALLOW_INTS;
{
gw__scm_result = gw__c_result;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp19_gw_test_gw_standard_get_int_max_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp21_gw_test_gw_standard_get_uint_max_namestr = "gw-test-gw-standard-get-uint-max";
static SCM gw__tmp20_gw_test_gw_standard_get_uint_max_wrapper  () {
  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;
SCM gw__c_result;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_standard_get_uint_max ();
SCM_ALLOW_INTS;
{
gw__scm_result = gw__c_result;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp21_gw_test_gw_standard_get_uint_max_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp23_gw_test_gw_standard_get_long_min_namestr = "gw-test-gw-standard-get-long-min";
static SCM gw__tmp22_gw_test_gw_standard_get_long_min_wrapper  () {
  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;
SCM gw__c_result;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_standard_get_long_min ();
SCM_ALLOW_INTS;
{
gw__scm_result = gw__c_result;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp23_gw_test_gw_standard_get_long_min_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp25_gw_test_gw_standard_get_long_max_namestr = "gw-test-gw-standard-get-long-max";
static SCM gw__tmp24_gw_test_gw_standard_get_long_max_wrapper  () {
  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;
SCM gw__c_result;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_standard_get_long_max ();
SCM_ALLOW_INTS;
{
gw__scm_result = gw__c_result;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp25_gw_test_gw_standard_get_long_max_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp27_gw_test_gw_standard_get_ulong_max_namestr = "gw-test-gw-standard-get-ulong-max";
static SCM gw__tmp26_gw_test_gw_standard_get_ulong_max_wrapper  () {
  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;
SCM gw__c_result;

if (gw__error_status == GW__ERR_NONE)
{
  /* no pre-call result code requested! */
if (gw__error_status != GW__ERR_NONE) goto gw__wrapper_exit;
SCM_DEFER_INTS;
gw__c_result = gw_test_gw_standard_get_ulong_max ();
SCM_ALLOW_INTS;
{
gw__scm_result = gw__c_result;
}
}
 gw__wrapper_exit:
  if(gw__error_status != GW__ERR_NONE)
    gw__handle_wrapper_error(gw__error_status,
                             gw__tmp27_gw_test_gw_standard_get_ulong_max_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp29_gw_test_gw_standard_echo_float_namestr = "gw-test-gw-standard-echo-float";
static SCM gw__tmp28_gw_test_gw_standard_echo_float_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;
float gw__c_result;

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

{
if (!(SCM_NFALSEP(scm_number_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_scm2double(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_standard_echo_float (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result= gh_double2scm(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__tmp29_gw_test_gw_standard_echo_float_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp31_gw_test_gw_standard_echo_double_namestr = "gw-test-gw-standard-echo-double";
static SCM gw__tmp30_gw_test_gw_standard_echo_double_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;
double gw__c_result;

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

{
if (!(SCM_NFALSEP(scm_number_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_scm2double(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_standard_echo_double (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result= gh_double2scm(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__tmp31_gw_test_gw_standard_echo_double_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp33_gw_test_gw_standard_echo_int_namestr = "gw-test-gw-standard-echo-int";
static SCM gw__tmp32_gw_test_gw_standard_echo_int_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;
int gw__c_result;

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

{
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 if(SCM_FALSEP(scm_geq_p(gw__scm_arg0, gw__tmp0_range_minval_gw_int_))        || SCM_FALSEP(scm_leq_p(gw__scm_arg0, gw__tmp1_range_maxval_gw_int_))){
   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_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_standard_echo_int (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__tmp33_gw_test_gw_standard_echo_int_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp35_gw_test_gw_standard_echo_unsigned_int_namestr = "gw-test-gw-standard-echo-unsigned-int";
static SCM gw__tmp34_gw_test_gw_standard_echo_unsigned_int_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;
unsigned int gw__c_result;

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

{
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 if(SCM_NFALSEP(scm_negative_p(gw__scm_arg0))        || SCM_FALSEP(scm_leq_p(gw__scm_arg0, gw__tmp2_range_maxval_gw_unsigned_int_))){
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
else {gw__c_arg0= gh_scm2ulong(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_standard_echo_unsigned_int (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result= gh_ulong2scm(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__tmp35_gw_test_gw_standard_echo_unsigned_int_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp37_gw_test_gw_standard_echo_long_namestr = "gw-test-gw-standard-echo-long";
static SCM gw__tmp36_gw_test_gw_standard_echo_long_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;
long gw__c_result;

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

{
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 if(SCM_FALSEP(scm_geq_p(gw__scm_arg0, gw__tmp3_range_minval_gw_long_))        || SCM_FALSEP(scm_leq_p(gw__scm_arg0, gw__tmp4_range_maxval_gw_long_))){
   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_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_standard_echo_long (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__tmp37_gw_test_gw_standard_echo_long_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp39_gw_test_gw_standard_echo_unsigned_long_namestr = "gw-test-gw-standard-echo-unsigned-long";
static SCM gw__tmp38_gw_test_gw_standard_echo_unsigned_long_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;
unsigned long gw__c_result;

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

{
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 if(SCM_NFALSEP(scm_negative_p(gw__scm_arg0))        || SCM_FALSEP(scm_leq_p(gw__scm_arg0, gw__tmp5_range_maxval_gw_unsigned_long_))){
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
else {gw__c_arg0= gh_scm2ulong(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_standard_echo_unsigned_long (gw__c_arg0);
SCM_ALLOW_INTS;
{
gw__scm_result= gh_ulong2scm(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__tmp39_gw_test_gw_standard_echo_unsigned_long_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp41_gw_test_gw_standard_echo_mchars_caller_owned_namestr = "gw-test-gw-standard-echo-mchars-caller-owned";
static SCM gw__tmp40_gw_test_gw_standard_echo_mchars_caller_owned_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;
char * gw__c_result;

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

{
gw__c_arg0 = NULL;

if(SCM_FALSEP(gw__scm_arg0))
  gw__c_arg0 = NULL;
else if(SCM_STRINGP(gw__scm_arg0))
  gw__c_arg0 = gh_scm2newstr(gw__scm_arg0, NULL);
else
{
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
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_standard_echo_mchars_caller_owned (gw__c_arg0);
SCM_ALLOW_INTS;
{
  /* we coerce to (char *) here b/c broken guile 1.3.4 prototype */
if(gw__c_result == NULL) gw__scm_result = SCM_BOOL_F;
else gw__scm_result = gh_str02scm((char *) gw__c_result);
if(gw__c_result) free((void *) gw__c_result);
}
}
  gw__post_call_arg_0:
{
if(gw__c_arg0) free((void *) gw__c_arg0);
}
  { /* 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__tmp41_gw_test_gw_standard_echo_mchars_caller_owned_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp43_gw_test_gw_standard_echo_const_mchars_caller_owned_namestr = "gw-test-gw-standard-echo-const-mchars-caller-owned";
static SCM gw__tmp42_gw_test_gw_standard_echo_const_mchars_caller_owned_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;
const char * gw__c_result;

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

{
gw__c_arg0 = NULL;

if(SCM_FALSEP(gw__scm_arg0))
  gw__c_arg0 = NULL;
else if(SCM_STRINGP(gw__scm_arg0))
  gw__c_arg0 = gh_scm2newstr(gw__scm_arg0, NULL);
else
{
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
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_standard_echo_const_mchars_caller_owned (gw__c_arg0);
SCM_ALLOW_INTS;
{
  /* we coerce to (char *) here b/c broken guile 1.3.4 prototype */
if(gw__c_result == NULL) gw__scm_result = SCM_BOOL_F;
else gw__scm_result = gh_str02scm((char *) gw__c_result);
if(gw__c_result) free((void *) gw__c_result);
}
}
  gw__post_call_arg_0:
{
if(gw__c_arg0) free((void *) gw__c_arg0);
}
  { /* 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__tmp43_gw_test_gw_standard_echo_const_mchars_caller_owned_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp45_gw_test_gw_standard_echo_mchars_callee_owned_namestr = "gw-test-gw-standard-echo-mchars-callee-owned";
static SCM gw__tmp44_gw_test_gw_standard_echo_mchars_callee_owned_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;
char * gw__c_result;

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

{
gw__c_arg0 = NULL;

if(SCM_FALSEP(gw__scm_arg0))
  gw__c_arg0 = NULL;
else if(SCM_STRINGP(gw__scm_arg0))
  gw__c_arg0 = gh_scm2newstr(gw__scm_arg0, NULL);
else
{
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
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_standard_echo_mchars_callee_owned (gw__c_arg0);
SCM_ALLOW_INTS;
{
  /* we coerce to (char *) here b/c broken guile 1.3.4 prototype */
if(gw__c_result == NULL) gw__scm_result = SCM_BOOL_F;
else gw__scm_result = gh_str02scm((char *) gw__c_result);
}
}
  gw__post_call_arg_0:
{
}
  { /* 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__tmp45_gw_test_gw_standard_echo_mchars_callee_owned_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
static char * gw__tmp47_gw_test_gw_standard_echo_const_mchars_callee_owned_namestr = "gw-test-gw-standard-echo-const-mchars-callee-owned";
static SCM gw__tmp46_gw_test_gw_standard_echo_const_mchars_callee_owned_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;
const char * gw__c_result;

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

{
gw__c_arg0 = NULL;

if(SCM_FALSEP(gw__scm_arg0))
  gw__c_arg0 = NULL;
else if(SCM_STRINGP(gw__scm_arg0))
  gw__c_arg0 = gh_scm2newstr(gw__scm_arg0, NULL);
else
{
   gw__error_status = GW__ERR_ARG_TYPE;
    gw__error_data = gw__scm_arg0;
   goto gw__post_call_arg_0;
}
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_standard_echo_const_mchars_callee_owned (gw__c_arg0);
SCM_ALLOW_INTS;
{
  /* we coerce to (char *) here b/c broken guile 1.3.4 prototype */
if(gw__c_result == NULL) gw__scm_result = SCM_BOOL_F;
else gw__scm_result = gh_str02scm((char *) gw__c_result);
}
}
  gw__post_call_arg_0:
{
}
  { /* 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__tmp47_gw_test_gw_standard_echo_const_mchars_callee_owned_namestr,
                             gw__arg_pos,
                             gw__error_misc_msg,
                             gw__error_data);
  return gw__scm_result;
}
void
gw_init_wrapset_gw_test_standard() {
  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-standard\")");

gh_eval_str("(use-modules (g-wrap gw-standard))");
{
   enum GW__ErrorStatus gw__tmp48_status_var = GW__ERR_NONE;
   SCM gw__tmp50_err_data = SCM_UNSPECIFIED;
   char *gw__tmp49_err_misc_msg = NULL;
   (void) gw__tmp48_status_var;
   (void) gw__tmp50_err_data;
   (void) gw__tmp49_err_misc_msg;
}
{
   enum GW__ErrorStatus gw__tmp51_err_status = GW__ERR_NONE;
   SCM gw__tmp53_err_data = SCM_UNSPECIFIED;
   char *gw__tmp52_err_misc_msg = NULL;
   (void) gw__tmp51_err_status;
   (void) gw__tmp53_err_data;
   (void) gw__tmp52_err_misc_msg;
gw__tmp5_range_maxval_gw_unsigned_long_ = scm_ulong2num(ULONG_MAX);
scm_protect_object(gw__tmp5_range_maxval_gw_unsigned_long_);
if (gw__tmp51_err_status != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp51_err_status,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp52_err_misc_msg,
                            gw__tmp53_err_data);
gw__tmp3_range_minval_gw_long_ = scm_long2num(LONG_MIN);
scm_protect_object(gw__tmp3_range_minval_gw_long_);
gw__tmp4_range_maxval_gw_long_ = scm_long2num(LONG_MAX);
scm_protect_object(gw__tmp4_range_maxval_gw_long_);
if (gw__tmp51_err_status != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp51_err_status,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp52_err_misc_msg,
                            gw__tmp53_err_data);
gw__tmp2_range_maxval_gw_unsigned_int_ = scm_ulong2num(UINT_MAX);
scm_protect_object(gw__tmp2_range_maxval_gw_unsigned_int_);
if (gw__tmp51_err_status != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp51_err_status,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp52_err_misc_msg,
                            gw__tmp53_err_data);
gw__tmp0_range_minval_gw_int_ = scm_long2num(INT_MIN);
scm_protect_object(gw__tmp0_range_minval_gw_int_);
gw__tmp1_range_maxval_gw_int_ = scm_long2num(INT_MAX);
scm_protect_object(gw__tmp1_range_maxval_gw_int_);
if (gw__tmp51_err_status != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp51_err_status,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp52_err_misc_msg,
                            gw__tmp53_err_data);
}
{
   enum GW__ErrorStatus gw__tmp54_status_var = GW__ERR_NONE;
   SCM gw__tmp56_err_data = SCM_UNSPECIFIED;
   char *gw__tmp55_err_misc_msg = NULL;
   (void) gw__tmp54_status_var;
   (void) gw__tmp56_err_data;
   (void) gw__tmp55_err_misc_msg;
{
   SCM gw__tmp6_scm_wrapped_value;

gw__tmp6_scm_wrapped_value= gh_long2scm(GW_TEST_GW_STANDARD_FOO_VALUE);
if(!(gw__tmp54_status_var != GW__ERR_NONE))  gh_define("gw-test-gw-standard-foo-value",gw__tmp6_scm_wrapped_value);
}
if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
{
   SCM gw__tmp7_scm_wrapped_value;

  /* we coerce to (char *) here b/c broken guile 1.3.4 prototype */
if(GW_TEST_GW_STANDARD_BAR_VALUE == NULL) gw__tmp7_scm_wrapped_value = SCM_BOOL_F;
else gw__tmp7_scm_wrapped_value = gh_str02scm((char *) GW_TEST_GW_STANDARD_BAR_VALUE);
if(!(gw__tmp54_status_var != GW__ERR_NONE))  gh_define("gw-test-gw-standard-bar-value",gw__tmp7_scm_wrapped_value);
}
if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp9_gw_test_gw_standard_no_op_namestr,
                     (SCM (*) ()) gw__tmp8_gw_test_gw_standard_no_op_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp11_gw_test_gw_standard_echo_scm_namestr,
                     (SCM (*) ()) gw__tmp10_gw_test_gw_standard_echo_scm_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp13_gw_test_gw_standard_echo_bool_namestr,
                     (SCM (*) ()) gw__tmp12_gw_test_gw_standard_echo_bool_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp15_gw_test_gw_standard_echo_char_namestr,
                     (SCM (*) ()) gw__tmp14_gw_test_gw_standard_echo_char_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp17_gw_test_gw_standard_get_int_min_namestr,
                     (SCM (*) ()) gw__tmp16_gw_test_gw_standard_get_int_min_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp19_gw_test_gw_standard_get_int_max_namestr,
                     (SCM (*) ()) gw__tmp18_gw_test_gw_standard_get_int_max_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp21_gw_test_gw_standard_get_uint_max_namestr,
                     (SCM (*) ()) gw__tmp20_gw_test_gw_standard_get_uint_max_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp23_gw_test_gw_standard_get_long_min_namestr,
                     (SCM (*) ()) gw__tmp22_gw_test_gw_standard_get_long_min_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp25_gw_test_gw_standard_get_long_max_namestr,
                     (SCM (*) ()) gw__tmp24_gw_test_gw_standard_get_long_max_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp27_gw_test_gw_standard_get_ulong_max_namestr,
                     (SCM (*) ()) gw__tmp26_gw_test_gw_standard_get_ulong_max_wrapper,
                     0,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp29_gw_test_gw_standard_echo_float_namestr,
                     (SCM (*) ()) gw__tmp28_gw_test_gw_standard_echo_float_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp31_gw_test_gw_standard_echo_double_namestr,
                     (SCM (*) ()) gw__tmp30_gw_test_gw_standard_echo_double_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp33_gw_test_gw_standard_echo_int_namestr,
                     (SCM (*) ()) gw__tmp32_gw_test_gw_standard_echo_int_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp35_gw_test_gw_standard_echo_unsigned_int_namestr,
                     (SCM (*) ()) gw__tmp34_gw_test_gw_standard_echo_unsigned_int_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp37_gw_test_gw_standard_echo_long_namestr,
                     (SCM (*) ()) gw__tmp36_gw_test_gw_standard_echo_long_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp39_gw_test_gw_standard_echo_unsigned_long_namestr,
                     (SCM (*) ()) gw__tmp38_gw_test_gw_standard_echo_unsigned_long_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp41_gw_test_gw_standard_echo_mchars_caller_owned_namestr,
                     (SCM (*) ()) gw__tmp40_gw_test_gw_standard_echo_mchars_caller_owned_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp43_gw_test_gw_standard_echo_const_mchars_caller_owned_namestr,
                     (SCM (*) ()) gw__tmp42_gw_test_gw_standard_echo_const_mchars_caller_owned_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp45_gw_test_gw_standard_echo_mchars_callee_owned_namestr,
                     (SCM (*) ()) gw__tmp44_gw_test_gw_standard_echo_mchars_callee_owned_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
    gh_new_procedure(gw__tmp47_gw_test_gw_standard_echo_const_mchars_callee_owned_namestr,
                     (SCM (*) ()) gw__tmp46_gw_test_gw_standard_echo_const_mchars_callee_owned_wrapper,
                     1,
                     0,
                     0);

if (gw__tmp54_status_var != GW__ERR_NONE)  gw__handle_wrapper_error (gw__tmp54_status_var,
                            "gw_init_wrapset_gw_test_standard",
                            0,
                            gw__tmp55_err_misc_msg,
                            gw__tmp56_err_data);
}
    gw_wrapset_initialized = 1;
    (void) gw__handle_wrapper_error;
  }
}