// lrc_save_uint_by_ref函数将
//无符号integer类型值保存在字符串中，
//并将val设置为指向该字符串。VuGen将此
//函数生成为注释掉的调用。如果要将此值
//用作参数，可以更改name并取消调用的注释。
int lrc_save_uint_by_ref(const char* name, unsigned int *val);
//输入表示long类型的字符串时，lrc_long函数
//返回长整型值。
long lrc_long(const char* str);
//输入表示long类型的字符串时，lrc_long_by_ref函数
//返回指向长整型值的指针。
long* lrc_long_by_ref(const char* str);
// lrc_save_long函数将长整型值
//保存在指定变量name下的字符串中，
// 以便您可以将其用于参数化。VuGen
//将此函数生成为注释掉的调用。如果
//要将此值用作参数，可以更改name
//并取消调用的注释。
int lrc_save_long(const char* name, long val);
// lrc_save_long_by_ref函数将长整型值保存在字符串中，
//并将val设置为指向该字符串。
int lrc_save_long_by_ref(const char* name, long *val);
//输入表示无符号long类型值的字符串时，
// lrc_ulong函数返回无符号长整型值。
unsigned long lrc_ulong(const char* str);
//输入表示无符号long类型值的字符串时，
// lrc_ulong_by_ref函数返回指向无符号长整型值
//的指针。
unsigned long* lrc_ulong_by_ref(const char* str);
// lrc_save_ulong函数将无符号
//长整型值保存在指定变量name下
//的字符串中，以便您可以将其用于参数化。
// VuGen将此函数生成为注释掉的调用。
//如果要将此值用作参数，可以更改name
//并取消调用的注释。
int lrc_save_ulong(const char* name, unsigned long val);
// lrc_save_ulong_by_ref函数将无符号长整型值保存为字符串，
//并将val设置为指向该字符串。
int lrc_save_ulong_by_ref(const char* name, unsigned long *val);
//输入表示短整型值的字符串时，lrc_short函数
//返回短整型值。
short lrc_short(const char* str);
//输入表示短整型值的字符串时，lrc_short_by_ref函数
//返回指向短整型值的
//指针。
short* lrc_short_by_ref(const char* str);
// lrc_save_short函数将短整型值保存
//在指定变量name下的字符串中，以便
//您可以将其用于参数化。VuGen将此
//函数生成为注释掉的调用。如果要将此值
//用作参数，可以更改name并取消调用的
//注释。
int lrc_save_short(const char* name, short val);
// lrc_save_short_by_ref函数将短整型值保存在字符串中，
//并将val设置为指向该字符串。
int lrc_save_short_by_ref(const char* name, short *val);
//输入表示货币值的字符串时，lrc_currency函
//数返回货币值。
CY lrc_currency(const char* str);
//输入表示货币值的字符串时，
// lrc_currency_by_ref函数返回指向
//货币结构的指针。
CY* lrc_currency_by_ref(const char* str);
// lrc_save_currency函数将货币(CY)值
//保存在指定变量name下的字符串中，以便您
//可以将其用于参数化。VuGen将此函数
//生成为注释掉的调用。如果要将此值
//用作参数，可以更改name并取消调用的
//注释。
int lrc_save_currency(const char* name, CY val);
// lrc_save_currency_by_ref函数将由“val ”
//指针引用的货币值保存到字符串参数中。
int lrc_save_currency_by_ref(const char* name, CY *val);
//输入表示date类型值的字符串时，
// lrc_date函数返回DATE类型值。
DATE lrc_date(const char* str);
//输入表示date类型值的字符串时，lrc_date_by_ref函数
//返回指向DATE的指针。
DATE* lrc_date_by_ref(const char* str);
// lrc_save_date函数将date类型值保存
//为字符串。VuGen将此函数生成为注释掉的调用。
//如果要将此值用作参数，可以更改name并取消
//调用的注释。
int lrc_save_date(const char* name, DATE val);
// lrc_save_date_by_ref函数将date类型值保存为字符串。
int lrc_save_date_by_ref(const char* name, DATE *val);
//输入包含“true ”或“false ”的字符串时，
// lrc_bool函数返回Boolean类型值。
VARIANT_BOOL lrc_bool(const char* str);
//输入包含“true ”或“false ”的字符串时，
// lrc_bool_by_ref函数返回指向Boolean
//类型值的指针。
VARIANT_BOOL* lrc_bool_by_ref(const char* str);
// lrc_save_bool函数将Boolean类型值
//保存为字符串参数。VuGen将此函数生成为
//注释掉的调用。如果要将此值用作参数，可以
//更改name并取消调用的注释。
int lrc_save_bool(const char* name, VARIANT_BOOL val);
// lrc_save_bool_by_ref函数将Boolean类型值
//保存到字符串参数中。
int lrc_save_bool_by_ref(const char* name, VARIANT_BOOL *val);
//输入表示无符号短整型值的字符串时，
// lrc_ushort函数返回无符号
//短整型值。
unsigned short lrc_ushort(const char* str);
//输入表示无符号短整型值的字符串时，
// lrc_ushort_by_ref函数返回指向无符号短整型值
//的指针。
unsigned short* lrc_ushort_by_ref(const char* str);
// lrc_save_ushort函数将无符号
//短整型值保存在参数中。
int lrc_save_ushort(const char* name, unsigned short val);
// lrc_save_ushort_by_ref函数将无符号短整型值
//保存到参数中。
int lrc_save_ushort_by_ref(const char* name, unsigned short *val);
//输入包含浮点数的字符串时，
// lrc_float函数返回浮点数。
float lrc_float(const char* str);
//输入包含浮点数的字符串时，
// lrc_float_by_ref函数返回指向浮点数
//的指针。
float* lrc_float_by_ref(const char* str);
// lrc_save_float函数将浮点类型
//浮点值保存在字符串参数中。VuGen将此
//函数生成为注释掉的调用。如果要使用
//该参数，可以更改name并取消调用的
//注释。
int lrc_save_float(const char* name, float val);
// lrc_save_float_by_ref函数将浮点
//类型浮点值保存在字符串参数中。
int lrc_save_float_by_ref(const char* name, float *val);
//输入包含double类型值的字符串时，
// lrc_double函数返回double类型值。
double lrc_double(const char* str);
//输入包含double类型值的字符串时，lrc_double_by_ref
//函数返回指向double类型值的指针。
double* lrc_double_by_ref(const char* str);
// lrc_save_double函数将双精度浮点类型值保存在字符串参数中。VuGen将此函数生成为注释掉的调用。如果要将此值用作参数，可以更改name并取消调用的注释。
int lrc_save_double(const char* name, double val);
// lrc_save_double_by_ref函数将双精度浮点
//类型值保存在字符串参数中。
int lrc_save_double_by_ref(const char* name, double *val);
//输入包含dword类型值的字符串时，lrc_dword函数
//返回双字类型值。
DWORD lrc_dword(const char* str);
// lrc_save_dword函数将双字类型值
//保存在字符串参数中。VuGen将此函数
//生成为注释掉的调用。如果要将此值用作
//参数，可以更改name并取消调用的注释。
int lrc_save_dword(const char* name, DWORD val);
// lrc_BSTR函数将任何字符串转换为BSTR 。
BSTR lrc_BSTR(const char* str);
// lrc_save_BSTR函数将BSTR值保存
//为字符串参数。VuGen将此函数生成为
//注释掉的调用。如果要将此值用作参数，
//可以更改name并取消调用的注释。
int lrc_save_BSTR(const char* name, BSTR val);
// lrc_ascii_BSTR函数将字符串
//转换为ascii_BSTR 。
BSTR lrc_ascii_BSTR(const char* str);
// lrc_ascii_BSTR_by_ref函数将字符串转换
//为ascii_BSTR ，并返回指向该BSTR的指针。
BSTR* lrc_ascii_BSTR_by_ref(const char* str);
//当不再使用COM对象时，
// lrc_Release_Object函数释放该对象。
//释放对象后，对象的引用计数将减1
// （例如，IUnknown_1到IUnknown_0 ）。
//
int lrc_Release_Object(const char* interface);
// lrc_save_ascii_BSTR函数将ascii BSTR保存
//到字符串参数中。VuGen将此函数生成为注释掉的调用。
//如果要将此值用作参数，可以更改name并取消调用的
//注释。
int lrc_save_ascii_BSTR(const char* name, BSTR val);
// lrc_save_ascii_BSTR_by_ref函数将ascii BSTR保
//存到字符串参数中。
int lrc_save_ascii_BSTR_by_ref(const char* name, BSTR *val);
// lrc_save_VARIANT函数将任何数据类型的值
//保存到字符串参数中。
int lrc_save_VARIANT(const char* name, VARIANT val);
// lrc_save_variant_<Type-Name>函数系列
// 由VuGen生成，用于将指定的<Type-Name>
//变量保存为字符串参数。VuGen将这些代码行
//生成为注释掉的调用。如果要将此值用作参数，
//可以更改name并取消调用的
//注释。
int lrc_save_variant_<Type-Name>(const char* name, VARIANT val);
// lrc_save_variant_short将short变量类型值保存到字符串参数中。
int lrc_save_variant_short(const char* name, VARIANT val);
// lrc_save_variant_ushort将short变量类型值保存到字符串参数中。
int lrc_save_variant_ushort(const char* name, VARIANT val);
// lrc_save_variant_char将short变量类型值保存到字符串参数中。
int lrc_save_variant_char(const char* name, VARIANT val);
// lrc_save_variant_int将int变量类型值保存到字符串参数中。
int lrc_save_variant_int(const char* name, VARIANT val);
// lrc_save_variant_uint将无符号integer变量
//类型值到字符串参数中。
int lrc_save_variant_uint(const char* name, VARIANT val);
// lrc_save_variant_ulong将无符号long变量
//类型值保存到字符串参数中。
int lrc_save_variant_ulong(const char* name, VARIANT val);
// lrc_save_variant_BYTE将BYTE变量类型值保存到字符串参数中。
int lrc_save_variant_BYTE(const char* name, VARIANT val);
// lrc_save_variant_long将long变量类型值保存到字符串参数中。
int lrc_save_variant_long(const char* name, VARIANT val);
// lrc_save_variant_float将float变量类型值保存到字符串参数中。
int lrc_save_variant_float(const char* name, VARIANT val);
// lrc_save_variant_double将double变量
//类型值保存到字符串参数中。
int lrc_save_variant_double(const char* name, VARIANT val);
// lrc_save_variant_bool将boolean变量类型值保存到字符串参数中。
int lrc_save_variant_bool(const char* name, VARIANT val);
// lrc_save_variant_scode将scode变量类型值保存到字符串参数中。
int lrc_save_variant_scode(const char* name, VARIANT val);
// lrc_save_variant_currency将currency变量
//类型值保存到字符串参数中。
int lrc_save_variant_currency(const char* name, VARIANT val);
// lrc_save_variant_date将DATE变量类型值保存到字符串参数中。
int lrc_save_variant_date(const char* name, VARIANT val);
// lrc_save_variant_BSTR将BSTR变量类型值保存到字符串参数中。
int lrc_save_variant_BSTR(const char* name, VARIANT val);
// lrc_save_variant_<Type-Name>_by_ref函数
//系列由VuGen生成，以便将通过变量中的引用方式
//存储的、指定了<Type-Name>的变量保存为字符串
//参数。VuGen将这些代码行生成为注释掉的调用。
//如果要将此值用作参数，可以更改name并取消调用的
//注释。
//
int lrc_save_variant_<Type-Name>_by_ref(const char* name, VARIANT val);
// lrc_save_variant_short_by_ref将通过变量中
//的引用方式存储的值保存为参数。
int lrc_save_variant_short_by_ref(const char* name, VARIANT val);
// lrc_save_variant_ushort_by_ref将
//通过变量中的引用方式存储的值保存为参数。
int lrc_save_variant_ushort_by_ref(const char* name, VARIANT val);
// lrc_save_variant_char_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_char_by_ref(const char* name, VARIANT val);
// lrc_save_variant_int_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_int_by_ref(const char* name, VARIANT val);
// lrc_save_variant_uint_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_uint_by_ref(const char* name, VARIANT val);
// lrc_save_variant_ulong_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_ulong_by_ref(const char* name, VARIANT val);
// lrc_save_variant_BYTE_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_BYTE_by_ref(const char* name, VARIANT val);
// lrc_save_variant_long_by_ref将
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_long_by_ref(const char* name, VARIANT val);
// lrc_save_variant_float_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_float_by_ref(const char* name, VARIANT val);
// lrc_save_variant_double_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_double_by_ref(const char* name, VARIANT val);
// lrc_save_variant_bool_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_bool_by_ref(const char* name, VARIANT val);
// lrc_save_variant_scode_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_scode_by_ref(const char* name, VARIANT val);
// lrc_save_variant_currency_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_currency_by_ref(const char* name, VARIANT val);
// lrc_save_variant_date_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_date_by_ref(const char* name, VARIANT val);
// lrc_save_variant_BSTR_by_ref将通过
//变量中的引用方式存储的值保存为参数。
int lrc_save_variant_BSTR_by_ref(const char* name, VARIANT val);
// lrc_BYTE函数将字符串转换
//为无符号字符（字节）数值。
BYTE lrc_BYTE(const char* str);
// lrc_BYTE_by_ref函数将字符串转换
//为无符号字符（字节）数值，并返回指向该字节
//的指针。
char * lrc_BYTE_by_ref(const char* str);
// lrc_save_BYTE函数将byte类型值保存为参数。
// VuGen将此函数生成为注释掉的调用。如果要将此值
//用作参数，可以更改param_name并取消调用的
//注释。
int lrc_save_BYTE(const char* param_name, BYTE val);
// lrc_save_BYTE_by_ref函数将byte
//类型值保存为参数。VuGen将此函数生成为
//注释掉的调用。如果要将此值用作参数，可以
//更改param_name并取消调用的注释。
int lrc_save_BYTE_by_ref(const char* param_name, BYTE *val);
//输入表示超级整型值的字符串时，lrc_hyper函
//数返回超级（64位）整型值。
hyper lrc_hyper(const char* str);
//输入表示超级整型值的字符串时，
// lrc_hyper_by_ref函数返回指向
//超级（64位）整型值的指针。
hyper* lrc_hyper_by_ref(const char* str);
// lrc_save_hyper函数将64位超级
//整型值保存在字符串参数中。VuGen将
//此函数生成为注释掉的调用。如果要将
//此值用作参数，可以更改name并取消
//调用的注释。
int lrc_save_hyper(const char* name, hyper val);
// lrc_save_hyper_by_ref函数将64位
//超级整型值保存到字符串参数中。
int lrc_save_hyper_by_ref(const char* name, hyper *val);
//输入表示无符号超级整型值的字符串时，
// lrc_uhyper函数返回无符号超级
//（64位）整型值。
uhyper lrc_uhyper(const char* str);
//输入表示无符号超级整型值的字符串时，
// lrc_uhyper_by_ref函数返回指向
//无符号超级（64位）整型值。
uhyper* lrc_uhyper_by_ref(const char* str);
// lrc_save_uhyper函数将无符号64位
//超级整型值保存在字符串参数中。VuGen将
//此函数生成为注释掉的调用。如果要将此值
//用作参数，可以更改name并取消调用的
//注释。
int lrc_save_uhyper(const char* name, uhyper val);
// lrc_save_uhyper_by_ref函数将无符号
// 64位超级整型值保存到字符串参数中。VuGen
//将此函数生成为注释掉的调用。如果要将此值
//用作参数，可以更改name并取消调用的
//注释。
int lrc_save_uhyper_by_ref(const char* name, uhyper *val);
// lrc_char函数将包含char类型数值
//的字符串转换为char变量。
char lrc_char(const char* str);
// lrc_char_by_ref函数将包含char类型数值的
//字符串转换为char变量。
char* lrc_char_by_ref(const char* str);
// lrc_save_char函数将char 类型
// (0 - 127)保存到字符串参数中。
// VuGen将此函数生成为注释掉的调用。
//如果要将此值用作参数，可以更改name
//并取消调用的注释。
int lrc_save_char(const char* name, char val);
// lrc_save_char_by_ref函数将char类型
// (0 - 127)保存到字符串参数中。VuGen将此函数生成为注释掉的调用。如果要将此值
//用作参数，可以更改name并取消调用的
//注释。
int lrc_save_char_by_ref(const char* name, char *val);
// lrc_variant_empty函数返回空变量。
VARIANT lrc_variant_empty();
// lrc_variant_empty_by_variant返回
//包含对空变量引用的变量。
VARIANT lrc_variant_empty_by_variant();
// lrc_variant_null函数返回null变量。
VARIANT lrc_variant_null();
// lrc_variant_null_by_variant返回
//包含对null变量引用的变量。
VARIANT lrc_variant_null_by_variant();
// lrc_variant_short函数将字符串转换为
//短整型值，并在变量中将其返回。
VARIANT lrc_variant_short(const char* str);
// lrc_variant_short_by_variant函数将字符串
//转换为短整型值，并返回包含对某变量（其中包含
//该短整型值）引用的变量。
VARIANT lrc_variant_short_by_variant(const char* str);
// lrc_variant_ushort函数将字符串转换为
//无符号短整型值，并在变量中将其返回。
VARIANT lrc_variant_ushort(const char* str);
// lrc_variant_char函数将字符串转换为
// char类型值，并在变量中将其返回。
VARIANT lrc_variant_char(const char* str);
// lrc_variant_int函数将字符串转换为整型
//值，并在变量中将其返回。
VARIANT lrc_variant_int(const char* str);
// lrc_variant_uint函数将字符串转换为
//无符号整型值，并将其存储在变量中返回。
VARIANT lrc_variant_uint(const char* str);
// lrc_variant_ulong函数将字符串转换为
//无符号长整型值，并将其存储在变量中返回。
VARIANT lrc_variant_ulong(const char* str);
// lrc_variant_BYTE函数将字符串转换为
//无符号char (byte)类型值并存储于变量中。
VARIANT lrc_variant_BYTE(const char* str);
// lrc_variant_BYTE_by_variant函数将字符串
//转换为无符号char (byte)类型值，并返回包含
//对某变量（包含该byte ）引用的变量。
VARIANT lrc_variant_BYTE_by_variant(const char* str);
// lrc_variant_long函数将字符串
//转换为存储于变量中的长整型值。
VARIANT lrc_variant_long(const char* str);
// lrc_variant_long_by_variant函数将
//字符串转换为存储于变量中的长整型值，并且
//返回包含对某变量（其中包含该长整型值）
//引用的变量。
VARIANT lrc_variant_long_by_variant(const char* str);
// lrc_variant_float函数将字符串转换为
//存储于变量中的浮点类型值。
VARIANT lrc_variant_float(const char* str);
// lrc_variant_float_by_variant函数将
//字符串转换为浮点类型值，并且返回包含对某
//变量（其中包含该值）引用的变量。
VARIANT lrc_variant_float_by_variant(const char* str);
// lrc_variant_double函数将字符串转换为
//存储于变量中的双精度型浮点值。
VARIANT lrc_variant_double(const char* str);
// lrc_variant_double_by_variant函数将
//字符串转换为双精度型值，并且返回包含对某变量
//（其中包含该值）引用的变量。
VARIANT lrc_variant_double_by_variant(const char* str);
// lrc_variant_bool函数将包含“true ”或“false ”
//的字符串转换为存储于变量中的Boolean类型值。
VARIANT lrc_variant_bool(const char* str);
// lrc_variant_bool_by_variant函数将
//包含“true ”或“false ”的字符串转换为
// Boolean值，并且返回包含对某变量（其中
//包含该值）引用的变量。
VARIANT lrc_variant_bool_by_variant(const char* str);
// lrc_variant_scode函数将包含系统错误代码值的。
//字符串转换为存储于变量中的错误代码
VARIANT lrc_variant_scode(const char* errcode);
// lrc_variant_scode_by_variant函数将
//包含系统错误代码值的字符串转换为错误代码，
//并且返回包含对某变量（其中包含该值）引用
//的变量。
VARIANT lrc_variant_scode_by_variant(const char* errcode);
// lrc_variant_currency函数将包含货币值
//的字符串转换为存储于变量中的货币值。
VARIANT lrc_variant_currency(const char* str);
// lrc_variant_currency_by_variant函数
//将包含货币值的字符串转换为货币值，并且
//返回包含对某变量（其中包含该值）引用的
//变量。
VARIANT lrc_variant_currency_by_variant(const char* str);
// lrc_variant_date函数将包含date类型值的
//字符串转换为存储于变量中的date类型值。
VARIANT lrc_variant_date(const char* str);
// lrc_variant_date_by_variant函数将
//包含date类型值的字符串转换为date类型值，
//并且返回包含对某变量（其中包含该date类型值）
//引用的变量。
VARIANT lrc_variant_date_by_variant(const char* str);
// lrc_variant_BSTR函数将字符串转换为
//存储于变量中的BSTR类型值。
VARIANT lrc_variant_BSTR(const char* str);
// lrc_variant_BSTR_by_variant函数将字符串
//转换为BSTR值，并且返回包含对某变量（其中
//包含该值）引用的变量。
VARIANT lrc_variant_BSTR_by_variant(const char* str);
// lrc_variant_ascii_BSTR函数将字符串分配给
//存储于变量中的ASCII BSTR值
VARIANT lrc_variant_ascii_BSTR(const char* str);
// lrc_variant_CoObject函数将IUnknown接口
//指针分配给变量。
VARIANT lrc_variant_CoObject(IUnknown* pUnknown);
// lrc_variant_CoObject_by_variant函数将
// IUnknown接口指针分配给变量，并且返回
//包含对某变量（其中包含IUnknown引用）
//引用的变量。
VARIANT lrc_variant_CoObject_by_variant(IUnknown* pUnknown);
// lrc_variant_DispObject函数将
// IDispatch接口指针分配给变量。
VARIANT lrc_variant_DispObject(IDispatch* pDispatch);
// lrc_variant_DispObject_by_variant函数
//将IDispatch接口指针分配给变量，并且返回包含
//对某变量（其中包含IDispatch引用）引用的
//变量。
VARIANT lrc_variant_DispObject_by_variant(IDispatch* pDispatch);
// lrc_variant_short_by_ref函数将字符串
//分配给通过变量中的引用方式存储的短整型值。
VARIANT lrc_variant_short_by_ref(const char* str);
// lrc_variant_ushort_by_ref函数将字符串
//分配给通过变量中的引用方式存储的无符号短整型值。
VARIANT lrc_variant_ushort_by_ref(const char* str);
// lrc_variant_char_by_ref函数将字符串分配
//给通过变量中的引用方式存储的char类型值。
VARIANT lrc_variant_char_by_ref(const char* str);
// lrc_variant_int_by_ref函数将字符串分配给
//通过变量中的引用方式存储的integer类型值。
VARIANT lrc_variant_int_by_ref(const char* str);
// lrc_variant_uint_by_ref函数将字符串分配给
//通过变量中的引用方式存储的无符号integer类型值。
VARIANT lrc_variant_uint_by_ref(const char* str);
// lrc_variant_ulong_by_ref函数将字符串分配给
//通过变量中的引用方式存储的长整型值。
VARIANT lrc_variant_ulong_by_ref(const char* str);
// lrc_variant_BYTE_by_ref函数将字符串分配给
//通过变量中的引用方式存储的char (byte)类型值。
VARIANT lrc_variant_BYTE_by_ref(const char* str);
// lrc_variant_long_by_ref函数将字符串分配给
//通过变量中的引用方式存储的长整型值。
VARIANT lrc_variant_long_by_ref(const char* str);
// lrc_variant_float_by_ref函数将字符串分配给
//通过变量中的引用方式存储的浮点型浮点值。
VARIANT lrc_variant_float_by_ref(const char* str);
// lrc_variant_double_by_ref函数将字符串分配给
//通过变量中的引用方式存储的双精度型值。
VARIANT lrc_variant_double_by_ref(const char* str);
// lrc_variant_bool_by_ref函数将包含“true ”
//或“false ”的字符串分配给通过变量中的
//引用方式存储的Boolean类型值。
VARIANT lrc_variant_bool_by_ref(const char* str);
// lrc_variant_scode_by_ref函数将包含
//系统错误代码值的字符串分配给通过变量中的
//引用方式存储的错误代码中。
VARIANT lrc_variant_scode_by_ref(const char* str);
// lrc_variant_currency_by_ref函数将字符串
//分配给通过变量中的引用方式存储的货币类型值。
VARIANT lrc_variant_currency_by_ref(const char* str);
// lrc_variant_date_by_ref函数将字符串
//分配给通过变量中的引用方式存储的date类型值。
VARIANT lrc_variant_date_by_ref(const char* str);
// lrc_variant_BSTR_by_ref函数将字符串分配给的
//通过变量中引用方式存储的BSTR值。
VARIANT lrc_variant_BSTR_by_ref(const char* str);
// lrc_variant_ascii_BSTR_by_ref函数将字符串
//分配给通过变量中的引用方式存储的ascii BSTR值。
VARIANT lrc_variant_ascii_BSTR_by_ref(const char* str);
// lrc_variant_CoObject_by_ref函数将指针
//分配给变量中的IUnknown接口。
VARIANT lrc_variant_CoObject_by_ref(IUnknown* pUnknown);
// lrc_variant_DispObject_by_ref函数将指针
//转换为变量中的IDispatch接口。
VARIANT lrc_variant_DispObject_by_ref(IDispatch* pDispatch);
// lrc_variant_variant_by_ref函数创建包含现有
//变量的新变量。
VARIANT lrc_variant_variant_by_ref(VARIANT * pVar);
// lrc_variant_from_variant_by_ref函数从
//另一个变量引用中获取变量。
VARIANT lrc_variant_from_variant_by_ref(VARIANT var);
// Create<n>D<Type-Name>Array函数系列
//创建由Type-name指定的类型的n维数组。
//对于每一维，该调用必须指定lower_bound
//和upper_bound 。
<Type-Name> Array Create<n>D<Type-Name>Array(int lower_bound,int upper_bound, int
lower_bound, int upper_bound...);
// Destroy<Type-Name>Array函数系列销毁
// 由Type-name指定的类型的数组。对于在
//脚本中（而非由VuGen ）创建的数组，可以使用
//它们恢复内存。
void Destroy<Type-Name>Array(<Type-Name>Array Array);
// DestroyBoolArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyBoolArray(BoolArray Array);
// DestroyBstrArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyBstrArray(BstrArray Array);
// DestroyByteArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyByteArray(ByteArray Array);
// DestroyCharArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyCharArray(CharArray Array);
// DestroyCoObjectArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyCoObjectArray(CoObjectArray Array);
// DestroyCurrencyArray释放由数组占用的内存。于
//该函数用恢复由脚本为数组分配的内存。
void DestroyCurrencyArray(CurrencyArray Array);
// DestroyDateArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyDateArray(CurrencyArray Array);
// DestroyDispObjectArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyDispObjectArray(DispObjectArray Array);
// DestroyDoubleArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyDoubleArray(DoubleArray Array);
// DestroyErrorArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyErrorArray(ErrorArray Array);
// DestroyFloatArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyFloatArray(FloatArray Array);
// DestroyIntArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyIntArray(IntArray Array);
// DestroyLongArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyLongArray(LongArray Array);
// DestroyShortArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyShortArray(ShortArray Array);
// DestroyUIntArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyUIntArray(UIntArray Array);
// DestroyULongArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyULongArray(ULongArray Array);
// DestroyUShortArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyUShortArray(UShortArray Array);
// DestroyVariantArray释放由数组占用的内存。
//该函数用于恢复由脚本为数组分配的内存。
void DestroyVariantArray(VariantArray Array);
// GetBufferFrom<n>DByteArray函数系列从n维
// byte类型数组的最后一维中提取缓冲区。此函数
//的返回值是一个指向byte类型的缓冲区的指针。
//缓冲区的大小返回到*plinesize所指定的
//地址中。
char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);
// Fill<n>DByteArray函数系列将n维byte数组
//的最后一维中填充缓冲区的内容。
char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t
buff_size);
// lrc_variant_<Type-Name>Array函数系列将在
// Type-Name中指定的类型的数组分配给变量。
VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);
// lrc_variant_BoolArray将数组分配给变量。
VARIANT lrc_variant_BoolArray(BoolArray array);
// lrc_variant_BstrArray将数组分配给变量。
VARIANT lrc_variant_BstrArray(BstrArray array);
// lrc_variant_ByteArray将数组分配给变量。
VARIANT lrc_variant_ByteArray(ByteArray array);
// lrc_variant_CharArray将数组分配给变量。
VARIANT lrc_variant_CharArray(CharArray array);
// lrc_variant_CoObjectArray将数组分配给变量。
VARIANT lrc_variant_CoObjectArray(CoObjectArray array);
// lrc_variant_CurrencyArray将数组分配给变量。
VARIANT lrc_variant_CurrencyArray(CurrencyArray array);
// lrc_variant_DateArray将数组分配给变量。
VARIANT lrc_variant_DateArray(DateArray array);
// lrc_variant_DispObjectArray将数组分配给变量。
VARIANT lrc_variant_DispObjectArray(DispObjectArray array);
// lrc_variant_DoubleArray将数组分配给变量。
VARIANT lrc_variant_DoubleArray(DoubleArray array);
// lrc_variant_ErrorArray将数组分配给变量。
VARIANT lrc_variant_ErrorArray(ErrorArray array);
// lrc_variant_FloatArray将数组分配给变量。
VARIANT lrc_variant_FloatArray(FloatArray array);
// lrc_variant_IntArray将数组分配给变量。
VARIANT lrc_variant_IntArray(IntArray array);
// lrc_variant_LongArray将数组分配给变量。
VARIANT lrc_variant_LongArray(LongArray array);
// lrc_variant_ShortArray将数组分配给变量。
VARIANT lrc_variant_ShortArray(ShortArray array);
// lrc_variant_UintArray将数组分配给变量。
VARIANT lrc_variant_UintArray(UintArray array);
// lrc_variant_UlongArray将数组分配给变量。
VARIANT lrc_variant_UlongArray(UlongArray array);
// lrc_variant_UshortArray将数组分配给变量。
VARIANT lrc_variant_UshortArray(UshortArray array);
// lrc_variant_VariantArray将数组分配给变量。
VARIANT lrc_variant_VariantArray(VariantArray array);
// lrc_variant_<Type-Name>Array_by_ref函数系列返回对由Type-name指定的类型的数组的引用。返回类型
//为变量。
VARIANT lrc_variant_<Type-Name>Array_by_ref( <Type-Name>Array array );
// lrc_variant_BoolArray_by_ref返回对数组的引用
VARIANT lrc_variant_BoolArray_by_ref(BoolArray array);
// lrc_variant_BstrArray_by_ref返回对数组的引用
VARIANT lrc_variant_BstrArray_by_ref(BstrArray array);
// lrc_variant_ByteArray_by_ref返回对数组的引用
VARIANT lrc_variant_ByteArray_by_ref(ByteArray array);
// lrc_variant_CharArray_by_ref返回对数组的引用
VARIANT lrc_variant_CharArray_by_ref(CharArray array);
// lrc_variant_CoObjectArray_by_ref返回对数组的引用
VARIANT lrc_variant_CoObjectArray_by_ref(CoObjectArray array);
// lrc_variant_CurrencyArray_by_ref返回对数组的引用
VARIANT lrc_variant_CurrencyArray_by_ref(CurrencyArray array);
// lrc_variant_DateArray_by_ref返回对数组的引用
VARIANT lrc_variant_DateArray_by_ref(DateArray array);
// lrc_variant_DispObjectArray_by_ref返回对数组的引用
VARIANT lrc_variant_DispObjectArray_by_ref(DispObjectArray array);
// lrc_variant_DoubleArray_by_ref返回对数组的引用
VARIANT lrc_variant_DoubleArray_by_ref(DoubleArray array);
// lrc_variant_ErrorArray_by_ref返回对数组的引用
VARIANT lrc_variant_ErrorArray_by_ref(ErrorArray array);
// lrc_variant_FloatArray_by_ref返回对数组的引用
VARIANT lrc_variant_FloatArray_by_ref(FloatArray array);
// lrc_variant_IntArray_by_ref返回对数组的引用
VARIANT lrc_variant_IntArray_by_ref(IntArray array);
// lrc_variant_LongArray_by_ref返回对数组的引用
VARIANT lrc_variant_LongArray_by_ref(LongArray array);
// lrc_variant_ShortArray_by_ref返回对数组的引用
VARIANT lrc_variant_ShortArray_by_ref(ShortArray array);
// lrc_variant_UintArray_by_ref返回对数组的引用
VARIANT lrc_variant_UintArray_by_ref(UintArray array);
// lrc_variant_UlongArray_by_ref返回对数组的引用
VARIANT lrc_variant_UlongArray_by_ref(UlongArray array);
// lrc_variant_UshortArray_by_ref返回对数组的引用
VARIANT lrc_variant_UshortArray_by_ref(UshortArray array);
// lrc_variant_VariantArray_by_ref返回对数组的引用
VARIANT lrc_variant_VariantArray_by_ref(VariantArray array);
// lrc_Get<Type-Name>ArrayFromVariant函数系列从变量中
//提取由Type-name指定的类型的数组。
<Type-Name> lrc_Get<Type-Name>ArrayFromVariant const VARIANT* var);
// lrc_GetBoolArrayFromVariant从变量中提取数组。
VARIANT lrc_GetBoolArrayFromVariant(const VARIANT* var);
// lrc_GetBstrArrayFromVariant从变量中提取数组。
VARIANT lrc_GetBstrArrayFromVariant(const VARIANT* var);
// lrc_GetByteArrayFromVariant从变量中提取数组。
VARIANT lrc_GetByteArrayFromVariant(const VARIANT* var);
// lrc_GetCharArrayFromVariant从变量中提取数组。
VARIANT lrc_GetCharArrayFromVariant(const VARIANT* var);
// lrc_GetCoObjectArrayFromVariant从变量中提取数组。
VARIANT lrc_GetCoObjectArrayFromVariant(const VARIANT* var);
// lrc_GetCoInstanceArrayFromVariant从变量中提取数组。
VARIANT lrc_GetCoInstanceArrayFromVariant(const VARIANT* var);
// lrc_GetCurrencyArrayFromVariant从变量中提取数组。
VARIANT lrc_GetCurrencyArrayFromVariant(const VARIANT* var);
// lrc_GetDateArrayFromVariant从变量中提取数组。
VARIANT lrc_GetDateArrayFromVariant(const VARIANT* var);
// lrc_GetDispObjectArrayFromVariant从变量中提取数组。
VARIANT lrc_GetDispObjectArrayFromVariant(const VARIANT* var);
