mapilib.pm.c

这个是内存数据库的客户端

#define SWIG_prefix "MapiLibc::"

#ifdef __cplusplus
extern "C"
#endif
#ifndef PERL_OBJECT
#ifndef MULTIPLICITY
SWIGEXPORT(void) SWIG_init (CV* cv);
#else
SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
#endif
#else
SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
#endif


#define  SWIG_MemoryError    1
#define  SWIG_IOError        2
#define  SWIG_RuntimeError   3
#define  SWIG_IndexError     4
#define  SWIG_TypeError      5
#define  SWIG_DivisionByZero 6
#define  SWIG_OverflowError  7
#define  SWIG_SyntaxError    8
#define  SWIG_ValueError     9
#define  SWIG_SystemError   10
#define  SWIG_UnknownError  99


#define SWIG_exception(a,b)   SWIG_croak(b)


#include "clients_config.h"
#include <stream.h>
#include "Mapi.h"

Mapi mapi_mapi(char const *,int,char const *,char const *,char const *,char const *);
MapiMsg mapi_destroy(Mapi);
MapiMsg mapi_start_talking(Mapi);
Mapi mapi_connect(char const *,int,char const *,char const *,char const *,char const *);
Mapi mapi_connect_ssl(char const *,int,char const *,char const *,char const *,char const *);
MapiMsg mapi_disconnect(Mapi);
MapiMsg mapi_reconnect(Mapi);
MapiMsg mapi_ping(Mapi);
MapiMsg mapi_error(Mapi);
char *mapi_error_str(Mapi);
void mapi_noexplain(Mapi,char *);
MapiMsg mapi_explain(Mapi,FILE *);
MapiMsg mapi_explain_query(MapiHdl,FILE *);
MapiMsg mapi_explain_result(MapiHdl,FILE *);
MapiMsg mapi_output(Mapi,char *);
MapiMsg mapi_stream_into(Mapi,char *,char *);
MapiMsg mapi_profile(Mapi,int);
MapiMsg mapi_trace(Mapi,int);
int mapi_get_trace(Mapi);
MapiMsg mapi_trace_log(Mapi,char const *);
MapiMsg mapi_setAutocommit(Mapi,int);
char *mapi_result_error(MapiHdl);
MapiMsg mapi_next_result(MapiHdl);
MapiMsg mapi_needmore(MapiHdl);
int mapi_more_results(MapiHdl);
MapiHdl mapi_new_handle(Mapi);
MapiMsg mapi_close_handle(MapiHdl);
MapiHdl mapi_prepare(Mapi,char const *);
MapiMsg mapi_prepare_handle(MapiHdl,char const *);
MapiMsg mapi_virtual_result(MapiHdl,int,char const **,char const **,int const *,int,char const ***);
MapiMsg mapi_execute(MapiHdl);
MapiMsg mapi_execute_array(MapiHdl,char **);
MapiMsg mapi_fetch_reset(MapiHdl);
MapiMsg mapi_finish(MapiHdl);
MapiHdl mapi_prepare_array(Mapi,char const *,char **);
MapiHdl mapi_query(Mapi,char const *);
MapiMsg mapi_query_handle(MapiHdl,char const *);
MapiHdl mapi_query_prep(Mapi);
MapiMsg mapi_query_part(MapiHdl,char const *,size_t);
MapiMsg mapi_query_done(MapiHdl);
MapiHdl mapi_quick_query(Mapi,char const *,FILE *);
MapiHdl mapi_query_array(Mapi,char const *,char **);
MapiHdl mapi_quick_query_array(Mapi,char const *,char **,FILE *);
MapiHdl mapi_stream_query(Mapi,char const *,int);
MapiMsg mapi_cache_limit(Mapi,int);
MapiMsg mapi_cache_shuffle(MapiHdl,int);
MapiMsg mapi_cache_freeup(MapiHdl,int);
MapiMsg mapi_quick_response(MapiHdl,FILE *);
MapiMsg mapi_seek_row(MapiHdl,int,int);
MapiMsg mapi_timeout(Mapi,int);
int mapi_fetch_row(MapiHdl);
int mapi_fetch_all_rows(MapiHdl);
int mapi_get_field_count(MapiHdl);
int mapi_get_row_count(MapiHdl);
int mapi_rows_affected(MapiHdl);
char *mapi_fetch_field(MapiHdl,int);
char **mapi_fetch_field_array(MapiHdl);
char *mapi_fetch_line(MapiHdl);
char *mapi_get_lang(Mapi);
char *mapi_get_dbname(Mapi);
char *mapi_get_host(Mapi);
char *mapi_get_user(Mapi);
char *mapi_get_mapi_version(Mapi);
char *mapi_get_monet_version(Mapi);
int mapi_get_monet_versionId(Mapi);
char *mapi_get_motd(Mapi);
int mapi_is_connected(Mapi);
char *mapi_get_table(MapiHdl,int);
char *mapi_get_name(MapiHdl,int);
char *mapi_get_type(MapiHdl,int);
int mapi_get_len(MapiHdl,int);
int mapi_get_querytype(MapiHdl);
int mapi_get_tableid(MapiHdl);
MapiHdl mapi_get_active(Mapi);
#ifdef PERL_OBJECT
#define MAGIC_CLASS _wrap_MapiLib_var::
class _wrap_MapiLib_var : public CPerlObj {
public:
#else
#define MAGIC_CLASS
#endif
SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
    MAGIC_PPERL
    sv = sv; mg = mg;
    croak("Value is read-only.");
    return 0;
}


#ifdef PERL_OBJECT
};
#endif

#ifdef __cplusplus
extern "C" {
#endif
XS(_wrap_MapiDate_year_set) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        short arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: MapiDate_year_set(self,year);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiDate_year_set. Expected _p_MapiDate");
            }
        }
        arg2 = (short) SvIV(ST(1));
        if (arg1) (arg1)->year = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiDate_year_get) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        short result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: MapiDate_year_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiDate_year_get. Expected _p_MapiDate");
            }
        }
        result = (short) ((arg1)->year);
        
        ST(argvi) = sv_newmortal();
        sv_setiv(ST(argvi++), (IV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiDate_month_set) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        unsigned short arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: MapiDate_month_set(self,month);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiDate_month_set. Expected _p_MapiDate");
            }
        }
        arg2 = (unsigned short) SvUV(ST(1));
        if (arg1) (arg1)->month = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiDate_month_get) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        unsigned short result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: MapiDate_month_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiDate_month_get. Expected _p_MapiDate");
            }
        }
        result = (unsigned short) ((arg1)->month);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiDate_day_set) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        unsigned short arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: MapiDate_day_set(self,day);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiDate_day_set. Expected _p_MapiDate");
            }
        }
        arg2 = (unsigned short) SvUV(ST(1));
        if (arg1) (arg1)->day = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiDate_day_get) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        unsigned short result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: MapiDate_day_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiDate_day_get. Expected _p_MapiDate");
            }
        }
        result = (unsigned short) ((arg1)->day);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_new_MapiDate) {
    {
        MapiDate *result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 0) || (items > 0)) {
            SWIG_croak("Usage: new_MapiDate();");
        }
        result = (MapiDate *)(MapiDate *) calloc(1, sizeof(MapiDate));
        
        ST(argvi) = sv_newmortal();
        SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_MapiDate, SWIG_SHADOW|SWIG_OWNER);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_delete_MapiDate) {
    {
        MapiDate *arg1 = (MapiDate *) 0 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: delete_MapiDate(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiDate,0) < 0) {
                SWIG_croak("Type error in argument 1 of delete_MapiDate. Expected _p_MapiDate");
            }
        }
        free((char *) arg1);
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiTime_hour_set) {
    {
        MapiTime *arg1 = (MapiTime *) 0 ;
        unsigned short arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: MapiTime_hour_set(self,hour);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiTime,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiTime_hour_set. Expected _p_MapiTime");
            }
        }
        arg2 = (unsigned short) SvUV(ST(1));
        if (arg1) (arg1)->hour = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiTime_hour_get) {
    {
        MapiTime *arg1 = (MapiTime *) 0 ;
        unsigned short result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: MapiTime_hour_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiTime,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiTime_hour_get. Expected _p_MapiTime");
            }
        }
        result = (unsigned short) ((arg1)->hour);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiTime_minute_set) {
    {
        MapiTime *arg1 = (MapiTime *) 0 ;
        unsigned short arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: MapiTime_minute_set(self,minute);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiTime,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiTime_minute_set. Expected _p_MapiTime");
            }
        }
        arg2 = (unsigned short) SvUV(ST(1));
        if (arg1) (arg1)->minute = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiTime_minute_get) {
    {
        MapiTime *arg1 = (MapiTime *) 0 ;
        unsigned short result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: MapiTime_minute_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiTime,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiTime_minute_get. Expected _p_MapiTime");
            }
        }
        result = (unsigned short) ((arg1)->minute);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiTime_second_set) {
    {
        MapiTime *arg1 = (MapiTime *) 0 ;
        unsigned short arg2 ;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 2) || (items > 2)) {
            SWIG_croak("Usage: MapiTime_second_set(self,second);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiTime,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiTime_second_set. Expected _p_MapiTime");
            }
        }
        arg2 = (unsigned short) SvUV(ST(1));
        if (arg1) (arg1)->second = arg2;
        
        
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}


XS(_wrap_MapiTime_second_get) {
    {
        MapiTime *arg1 = (MapiTime *) 0 ;
        unsigned short result;
        int argvi = 0;
        dXSARGS;
        
        if ((items < 1) || (items > 1)) {
            SWIG_croak("Usage: MapiTime_second_get(self);");
        }
        {
            if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_MapiTime,0) < 0) {
                SWIG_croak("Type error in argument 1 of MapiTime_second_get. Expected _p_MapiTime");
            }
        }
        result = (unsigned short) ((arg1)->second);
        
        ST(argvi) = sv_newmortal();
        sv_setuv(ST(argvi++), (UV) result);
        XSRETURN(argvi);
        fail:
        ;
    }
    croak(Nullch);
}