// button_press 函数激活指定的推按钮。
int button_press ( LPCSTR button );
// button_set 函数将按钮状态设置为 ON 或 OFF。
int button_set ( LPCSTR button, int state );
// close_session 函数关闭所有打开的窗口并结束
// 当前的 Baan 会话。在 Baan 模板中创建的此函数
// 出现在脚本的 vuser_end 部分中。
int close_session();
// edit_get_text 函数返回在指定 edit 对象中
// 找到的所有文本。若要从特定块中读取文本，
// 请使用 edit_get_block。
int edit_get_text ( LPCSTR edit, char *out_string );
// edit_set 函数使用指定的字符串设置 edit 对象的
// 内容。该字符串将替换任何现有字符串。
int edit_set ( LPCSTR edit, LPCSTR text );
// edit_set_insert_pos 函数将光标放置
// 在 edit 对象内的指定位置。
int edit_set_insert_pos (LPCSTR edit, int row, int column );
// edit_set_selection 函数突出显示指定文本。
int edit_set_selection ( LPCSTR edit, int start_row, int start_column, int end_row, int end_column );
// edit_type 函数将文本字符串输入到 edit
// 对象中。该文本字符串不会替换现有字符串；
// 它替换的是位于当前光标位置的指定文本。
int edit_type ( LPCSTR edit, LPCSTR text );
// init_session 函数通过指定登录数据和配置
// 信息打开 Baan 连接。此函数向 Baan 服务器
// 呈现包含在 Baan Configuration 部分中
// 的信息。
int init_session ( char * host, char * user, char *password, char *BSE, char *Bshell_name, char * settings );
// list_activate_item 函数双击列表中的项目。
// 项目可由其逻辑名称指定。
int list_activate_item ( LPCSTR list, LPCSTR item );
// list_collapse_item 函数隐藏展开的 TreeView
// 列表中的子项，例如文件夹中的各个文件。
int list_collapse_item (LPCSTR list, LPCSTR item );
// list_expand_item 函数显示展开的
// TreeView 列表中所隐藏的子项，例如
// 文件夹中的各个文件。
int list_expand_item (LPCSTR list, LPCSTR item );
// list_get_selected 函数返回列表中的选定
// 项目。它既查找标准列表，也查找多选项列表。
int list_get_selected (LPCSTR list, LPCSTR out_item, LPCSTR out_num );
// list_select_item 函数从列表中选择项目
// （在项目上执行一次鼠标单击）。项目可由
// 其名称或数字索引指定。索引被指定为一个
// 字符串，并前置有字符 #。列表中的第一个
// 项目编号为 0。例如，列表中的第三个项目
// 将表示为 "#2"。
int list_select_item ( LPCSTR list, LPCSTR item );
// menu_select_item 函数根据菜单
// 的逻辑名称和项目名称从菜单中选择
// 项目。注意，菜单和项目表示为单个
// 字符串，并使用分号分隔。
int menu_select_item ( LPCSTR menu_item );
// obj_get_info 函数检索指定属性的值，
// 并将其存储在 out_value 中。
int obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );
// obj_get_text 函数从指定的对象
// 或对象区域中读取文本。
int obj_get_text (LPCSTR object, LPCSTR out_text );
// obj_mouse_click 函数在对象内的
// 指定坐标处单击鼠标。
int obj_mouse_click ( LPCSTR object, int x, int y, [mouse_button] );
// obj_mouse_dbl_click 函数在对象内的
// 指定坐标处双击鼠标。
int obj_mouse_dbl_click ( LPCSTR object, int x, int y, [mouse_button] );
// obj_mouse_drag 函数在 GUI
// 对象中执行鼠标拖动操作。指定的
// 坐标是相对于 GUI 对象（而非
// 屏幕）的左上角。
int obj_mouse_drag (LPCSTR object, int start_x, int start_y, int end_x, int end_y, [ ButtonT mouse_button] );
// obj_type 函数指定将 keyboard_input
// 发送到的目标对象。
int obj_type ( LPCSTR object, unsigned char keyboard_input, [unsigned char modifier ] );
// obj_wait_info 函数等待对象
// 属性达到指定值，然后继续
// 测试运行。如果未达到指定
// 值，则函数将一直等到时间
// 到期，然后再继续测试。
int obj_wait_info (LPCSTR object, LPCSTR property, LPCSTR value, UINT time );
// scroll_drag_from_min 函数将滚动屏
// 移动到与最小位置相距指定距离的位置。
int scroll_drag_from_min ( LPCSTR object, [int orientation], int position );
// scroll_line 函数滚动指定行数。
// 此函数可用于滚动栏和滑块对象。
int scroll_line ( LPCSTR scroll, [ScrollT orientation], int lines );
// scroll_page 函数将滚动屏移动指定页数。
int scroll_page ( LPCSTR scroll, [ScrollT orientation], int pages );
// set_default_timeout 函数设置回放
// 期间 Baan Vuser 函数的超时期间段。
// 例如，当脚本执行 set_window 函数
// 时，如果窗口在指定超时时间段内没有
// 出现，则会生成错误。
void set_default_timeout ( long time );
// set_exception 函数指定在发生异常时
// 应执行的操作。应指定要调用以处理异常
// 窗口的函数。
void set_exception ( LPCSTR title, long function );
// set_think_time 函数指定脚本执行
// 期间要使用的思考时间范围。运行脚本
// 时，LoadRunner 使用指定范围内的
// 随机思考时间，并在每个操作完成后
// 暂停该思考时间长度。
void set_think_time ( USHORT start_range, USHORT end_range );
// set_window 函数将输入定向到
// 当前应用程序窗口并在 GUI 图中
// 设置对象标识范围。
int set_window ( LPCSTR window [, int timeout ] );
// start_session 函数在 Baan
// 服务器上开始指定的会话。
int start_session ( LPCSTR session );
// static_get_text 函数返回在指定
// 静态 text 对象中找到的所有文本。
int static_get_text ( LPCSTR static_obj, LPCSTR out_string );
// tab_select_item 函数选择一个选项卡项目。
int tab_select_item ( LPCSTR tab, LPCSTR item );
// tbl_activate_cell 函数在指定表单元格中
// 按 Enter 键。如果指定了列名，LoadRunner
// 将直接从数据库中获取该名称。
int tbl_activate_cell (LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_get_cell_data 函数根据
// 单元格包含的数据类型获取表中
// 指定单元格的内容。如果指定了
// 列名，将从数据库自身（而非应用
// 程序）中获取该名称。
int tbl_get_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR out_text );
// tbl_get_selected_cell 函数
// 检索焦点所在的表单元格的行号和
// 列名。注意，列名取自数据库自身，
// 而非应用程序。
int tbl_get_selected_cell (LPCSTR table, char *out_row, char *out_column );
// tbl_press_zoom_button 函数
// 激活指定表单元格的缩放窗口。
int tbl_press_zoom_button ( LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_set_cell_data 函数根据单元格
// 包含的数据类型使用指定数据设置单元格
// 的值。如果指定了列名，LoadRunner
// 将直接从数据库中获取该名称。
int tbl_set_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR data );
// tbl_set_selected_cell 函数将焦点
// 设置到表中的指定单元格上。指定列名时，
// LoadRunner 将直接从数据库中获取该名称。
int tbl_set_selected_cell (LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_set_selected_row 函数选择表中的指定行。
int tbl_set_selected_row (LPCSTR table, LPCSTR row );
// tbl_set_selected_rows 函数选择指定行范围。
int tbl_set_selected_rows(LPCSTR table, LPCSTR from_row , LPCSTR to_row );
// tbl_wait_selected_cell 函数等待
// 表单元格显示后，再继续脚本执行。
int tbl_wait_selected_cell (LPCSTR table, char *row, char *column, UINT time );
// toolbar_button_press 函数激活工具栏中的按钮。
int toolbar_button_press (LPCSTR toolbar, LPCSTR button );
// type 函数描述发送给用于测试
// 的应用程序的键盘输入。
int type (LPCSTR keyboard_input );
// win_activate 函数通过向指定窗口
// 授予焦点并将其升到显示器最上端，
// 使其成为活动窗口（等价于单击窗口
// 标题栏）。所有后续输入都将提交给
// 此窗口。
int win_activate (LPCSTR window );
// win_close 函数关闭指定窗口。
int win_close ( LPCSTR window );
// win_get_info 函数检索指定属性的值
// 并将其存储在 out_value 中。
int win_get_info ( LPCSTR window, LPCSTR property, char *out_value );
// win_get_text 函数从指定窗口或
// 窗口区域读取文本。
int win_get_text ( LPCSTR window, LPCSTR out_text );
// win_max 函数将指定窗口
// 最大化以充满整个屏幕。
int win_max (LPCSTR window );
// win_min 函数将指定窗口最小化为图标。
int win_min (LPCSTR window );
// win_mouse_click 函数在选中窗口
// 的指定坐标处执行鼠标单击操作。
int win_mouse_click (LPCSTR window, int x, int y, ButtonT button );
// win_mouse_dbl_click 函数在选中窗口
// 的指定坐标处执行鼠标双击操作。
int win_mouse_dbl_click (LPCSTR window, int x, int y, ButtonT button );
// win_mouse_drag 函数在窗口内执行
// 鼠标拖动操作。注意，指定的坐标是
// 相对于窗口（而非屏幕）的左上角。
int win_mouse_drag (LPCSTR window, int start_x, int start_y, int end_x, int end_y, ButtonT button );
// win_move 函数将窗口移动到新的绝对位置。
int win_move ( LPCSTR window, int x, int y );
// win_resize 函数更改窗口的位置。
int win_resize ( LPCSTR window, int width, int height );
// win_restore 函数将窗口从图标化
// 或最大化状态还原为其原始大小。
int win_restore (LPCSTR window );
// win_wait_info 函数等待窗口
// 属性达到指定值，然后继续测试
// 运行。如果未达到指定值，则函数
// 将一直等到时间到期，然后再继
// 续测试。
int win_wait_info (LPCSTR window, LPCSTR property, LPCSTR value, UINT time );
// win_type 函数指定 keyboard_input
// 将发送到的目标窗口。
int win_type (LPCSTR window, LPCSTR keyboard_input );
// ctrx_<obj>_get_info 函数系列将属性
// 的值分配给值缓冲区。ctrx_obj_get_info
// 是一般函数，它可以适用于任何由录制器
// 所标识为对象的对象。
int ctrx_obj_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函数系列将属性的值
// 分配给值缓冲区。ctrx_button_get_info
// 获取命令按钮的信息。
int ctrx_button_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函数系列将属性的值
// 分配给值缓冲区。ctrx_edit_get_info
// 获取文本框的信息。
int ctrx_edit_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函数系列将属性的值
// 分配给值缓冲区。ctrx_list_get_info
// 获取列表框的信息。
int ctrx_list_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_connect_server 将 Citrix 客户端连接到 Citrix 服务器。
int ctrx_connect_server (char * server_name, char * user_name, char * password, char * domain);
// ctrx_disconnect_server 断开客户端与 Citrix 服务器的连接。
int ctrx_disconnect_server (char * server_name);
// ctrx_nfuse_connect 使用 NFUSE 应用
// 程序门户建立与 Citrix 服务器的连接。在
// 定义 NFUSE 门户的个性化规范的 ICA 文件
// 中找到的规范将从服务器上下载，在此之后
// 建立连接。
int ctrx_nfuse_connect(char * url);
// 使用 ctrx_get_bitmap_value
// 检索位图的哈希字符串值以用于您
// 的自定义同步函数中。位图坐标由
// 前四个参数指定。
int ctrx_get_bitmap_value (long x_start, long y_start, long width, long height, char * buffer);
// ctrx_get_text 将矩形中的文本分配到 text_buffer
// 中。随后，文本可被用于关联。
int ctrx_get_text( char *window_name, long xpos, long ypos, long width, long height, char * filename, char * text_buffer, CTRX_LAST );
// ctrx_get_text_location 在 xpos、
// ypos、width 和 height 指定区域中
// 搜索指定文本。如果找到字符串，当函数
// 返回后，xpos 和 ypos 即为找到文本的
// 位置。如果未找到字符串，xpos 和 ypos
// 则为零。
int ctrx_get_text_location( LPCSTR window_name, long *xpos, long *ypos, long *width, long *height, LPSTR text, long bMatchWholeWordOnly, LPCSTR filename, CTRX_LAST );
// ctrx_get_waiting_time 从运行时设置中获取当前等待
// 时间，或者通过 ctrx_set_waiting_time 设置的值。
int ctrx_get_waiting_time ( long * time );
// 使用 ctrx_get_window_name 检索
// 当前获得焦点的窗口的名称。
int ctrx_get_window_name (LPSTR buffer);
// 使用 ctrx_get_window_position
// 检索名为 title 变量值的窗口的位置。
// 如果 title 为 NULL，则函数将检索
// 当前拥有焦点的窗口的位置。
int ctrx_get_window_position (LPSTR title, long *xpos, long *ypos, long *width, long *height);
// ctrx_list_select_item 函数从列表中选择项目。
// 它支持 ListBox 或 ComboBox 类的列表。
int ctrx_list_select_item(char * window_name, long xpos, long ypos, char * item, CTRX_LAST );
// ctrx_menu_select_item 突出显示
// 菜单中的项目，但不激活它。
int ctrx_menu_select_item ( char * window_name, char * menu_path, CTRX_LAST) ;
// ctrx_mouse_click 等待窗口 window_name
// 出现，然后执行鼠标单击操作。
int ctrx_mouse_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_click 等待窗口 window_name
// 出现，然后执行鼠标单击操作。
int ctrx_obj_mouse_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_double_click 等待窗口 window_name
// 出现，然后执行鼠标双击操作。
int ctrx_mouse_double_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_double_click 等待窗口 window_name
// 出现，然后执行鼠标双击操作。
int ctrx_obj_mouse_double_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_down 等待窗口 window_name
// 出现，然后执行按下鼠标按键操作。
int ctrx_mouse_down(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_down 等待窗口 window_name
// 出现，然后执行按下鼠标按键操作。
int ctrx_obj_mouse_down(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_up 等待窗口 window_name
// 出现，然后在指定位置执行释放鼠标按键操作。
int ctrx_mouse_up(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );
// ctrx_obj_mouse_up 等待窗口 window_name
// 出现，然后在指定位置执行释放鼠标按键操作。
int ctrx_obj_mouse_up(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );
// ctrx_set_window 是同步函数，它等待
// 窗口出现，然后 Vuser 才在该窗口中模拟
// 任何键盘或鼠标活动。
int ctrx_set_window (char * window_name);
// ctrx_set_window_ex 是同步函数，它至多
// 等待 time 秒，若窗口出现，Vuser 将在该
// 窗口中模拟任何键盘或鼠标活动。
int ctrx_set_window_ex (char * window_name, long time);
// ctrx_key 模拟用户在 Citrix 客户端中
// 按下非字母数字键。
int ctrx_key (char * key, long int key_modifier);
// 函数 ctrx_type 模拟用户键入字母数字字符。
int ctrx_type (char * data);
// ctrx_save_bitmap 将位图保存为文件。
// 该文件将保存在 Vuser 结果日志目录中。
int ctrx_save_bitmap( long x_start, long y_start, long width, long height, const char * file_name );
// ctrx_set_connect_opt 在建立 Citrix 客户端
// 与 Citrix 服务器的连接之前设置连接选项，然后
// 执行与服务器的连接。
int ctrx_set_connect_opt (eConnectionOption option, char * value);
// ctrx_set_exception 定义当不规则
// 事件发生时要执行的操作。此事件必须
// 与名为 window_title 的窗口（通常
// 为弹出式对话框）的外观相关联。当窗口
// 出现时，将调用 handler 函数。
void ctrx_set_exception ( char * window_title, long handler, [void *context]);
// ctrx_set_waiting_time 更改
// 同步函数默认 60 秒的等待时间。
int ctrx_set_waiting_time (long time);
// ctrx_sync_on_bitmap 是同步函数，
// 它等待指定位图出现，然后再继续执行。
int ctrx_sync_on_bitmap (long x_start, long y_start, long width, long height, char * hash);
// ctrx_sync_on_bitmap_change 是同步
// 函数，它等待指定位图改变，然后再继续执行。
// 该函数通常用在窗口改变而窗口名称保持
// 不变的情况下。如果窗口名称改变，
// 则 ctrx_set_window 将被自动
// 生成。
int ctrx_sync_on_bitmap_change (long x_start, long y_start, long width, long height, <extra_args>, CTRX_LAST);
// ctrx_sync_on_obj_info 被调用时，执行将暂停，
// 直到指定对象的属性具有指定的值。
int ctrx_sync_on_obj_info ( char * window_name, long xpos, long ypos, eObjAttribute attribute, char * value, <CTRX_LAST> );
// ctrx_sync_on_window 是同步函数，
// 它等待窗口被创建或变为活动的。
int ctrx_sync_on_window (char * window_name, eWindowEvent event, long x_start, long y_start, long width, long height, char * filename, <CTRX_LAST>);
// ctrx_unset_window 是同步函数，它等待
// 窗口被关闭，然后脚本才继续执行。
int ctrx_unset_window (char * window_name);
// ctrx_wait_for_event 是同步函数，
// 它等待事件发生。
int ctrx_wait_for_event (char * event);
// 如果窗口存在，ctrx_win_exist 返回 E_OK（零）。
// 在 window_name 中可以使用通配符 (*)。
int ctrx_win_exist (char * window_name, long waiting_time);
// 有关 memchr 的详细信息，请参考 C 语言文档。
void *memchr ( const void *s, int c, size_t n );
// 有关 memcmp 的详细信息，请参考 C 语言文档。
int memcmp ( const void *s1, const void *s2, size_t n );
// memcpy 函数从 src 缓冲区中将 n 个
// 字符复制到 dest 缓冲区。
void *memcpy ( void *dest, const void *src, size_t n );
// 函数 memmove（以及所有不返回 integer 类型
// 的函数）必须明确在 Vugen 脚本中声明。
void *memmove ( void *dest, const void *src, size_t n );
// 有关 memset 的详细信息，请参考 C 语言文档。
void *memset ( void *buffer, int c, size_t n );
// 有关 getenv 的详细信息，请参考 C 语言文档。
char *getenv ( const char *varname );
// 有关 putenv 的详细信息，请参考 C 语言文档。
int putenv ( const char *envstring );
// 有关 system 的详细信息，请参考 C 语言文档。
int system ( const char *string );
// 有关 calloc 的详细信息，请参考 C 语言文档。
void *calloc ( size_t num elems, size_t elem_size );
// 有关 free 的详细信息，请参考 C 语言文档。
void free ( void *mem_address );
// 有关 malloc 的详细信息，请参考 C 语言文档。
void *malloc ( size_t num_bytes );
// 有关 realloc 的详细信息，请参考 C 语言文档。
void *realloc ( void *mem_address, size_t size );
// 有关 abs 的详细信息，请参考 C 语言文档。
int abs ( int n );
// 限制：cos 函数在 AIX 平台中无法使用。
double cos ( double x );
// 函数 floor（以及所有不返回 int 值的函数）
// 必须明确在 Vugen 脚本中声明。限制：此
// 函数在 AIX 平台中无法使用。
double floor ( double x );
// 在调用 rand 前，请调用 srand 以
// 播种伪随机数生成器
int rand ( void );
// 限制：sin 函数在 AIX 平台中无法使用。
double sin ( double x );
// 函数 sqrt（以及所有不返回 int 值的
// 函数）必须明确在 Vugen 脚本中声明。
// 限制：sqrt 函数在 AIX 平台中
// 无法使用。
double sqrt ( double x );
// 在调用 rand 前，请调用 srand 以
// 播种伪随机数生成器
int srand ( time );
// 有关 fclose 的详细信息，请参考 C 语言文档。
int fclose ( FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件（例如，stdio.h）。
// 但是，这样将导致某些类型（包括 feof 使用的 FILE
// 类型）未经定义。这时，请使用 long 替代 FILE
// 类型。
int feof ( FILE *file_pointer );
// 有关 ferror 的详细信息，请参考 C 语言文档。
int ferror ( FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件（例如，
// stdio.h）。但是，这样会导致某些类型
// （包括 fgetc 使用的 FILE 类型）未经定义。
// 这时，请使用 long 替代 FILE 类型。
int fgetc ( FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件（例如，
// stdio.h）。但是，这样会导致某些类型
// （包括 fgets 使用的 FILE 类型）未经定义。
// 这时，请使用 long 替代 FILE 类型。
char *fgets ( char *string, int maxchar, FILE *file_pointer );
// 通过将 t 或 b 字符添加到 fopen 的 access_mode
// 参数，此访问模式字符串还将用于指定打开文件的方式
// （文本还是二进制）。
FILE *fopen ( const char *filename, const char *access_mode );
// 有关 fprintf 的详细信息，请参考 C 语言文档。
int fprintf ( FILE *file_pointer, const char *format_string [, args ] );
// 请不要在脚本中包括操作系统头文件（例如，
// stdio.h）。但是，这样会导致某些类型
// （包括 fputc 使用的 FILE 类型）未经定义。
// 这时，请使用 long 替代 FILE 类型。
int fputc ( int c, FILE *file_pointer );
// 请不要在脚本中包括操作系统头文件（例如，
// stdio.h）。但是，这样会导致某些类型
// （包括 fread 使用的 FILE 类型）未经定义。
// 这时，请使用 long 替代 FILE 类型。
size_t fread ( void *buffer, size_t size, size_t count, FILE *file_pointer );
// 有关 fscanf 的详细信息，请参考 C 语言文档。
int fscanf ( FILE *file_pointer, const char *format string [, args] );
// 有关 fseek 的详细信息，请参考 C 语言文档。
int fseek ( FILE *file_pointer, long offset, int origin );
// 请不要在脚本中包括操作系统头文件（例如，
// stdio.h）。但是，这样会导致某些类型
// （包括 fwrite 使用的 FILE 类型）未经定义。
// 这时，请使用 long 替代 FILE 类型。
size_t fwrite ( const void *buffer, size_t size, size_t count, FILE *file_pointer );
// 有关 rewind 的详细信息，请参考 C 语言文档。
void rewind ( FILE *file_pointer );
// 有关 sprintf 的详细信息，请参考 C 语言文档。
int sprintf ( char *string, const char *format_string[, args] );
// 有关 sscanf 的详细信息，请参考 C 语言文档。
int sscanf ( const char *buffer, const char *format_string, args );
// 有关 chdir 的详细信息，请参考 C 语言文档。
int chdir ( const char *path );
// chdrive 将当前工作驱动器更改为 drive（表示新驱动器
// 的 integer 类型值）。例如，1 = A、2 = B，依此类推。
int chdrive ( int drive );
// 有关 getcwd 的详细信息，请参考 C 语言文档。
char *getcwd ( char *path, int numchars );
// getdrive 函数返回表示驱动器字母
// 的 integer 类型值：1 = A、2 = B，依此类推。
int getdrive ( void );
// 有关 mkdir 的详细信息，请参考 C 语言文档。
int mkdir ( const char *path );
// 有关 remove 的详细信息，请参考 C 语言文档。
int remove ( const char *path );
// 有关 rmdir 的详细信息，请参考 C 语言文档。
int rmdir ( const char *path );
// 根据系统时钟，time 函数返回从世界标准
// 时间 1970 年 1 月 1 日子夜 (00:00:00)
// 作为开始所经过的秒数。返回值存储在 timeptr
// 所给出的位置。如果 timeptr 为 NULL，则
// 该值不会被存储。
time_t time ( time_t *timeptr );
// 在 Unix 下，ctime 不是线程级安全函数。所以，请使用 ctime_r。
// 有关详细信息，请参阅平台相关文档。
char *ctime ( const time_t *time );
// 有关 ftime 的详细信息，请参考 C 语言文档。
void ftime ( struct _timeb *time1 );
// 在 Unix 下，localtime 不是线程级安全函数。
// 所以，请使用 localtime_r。有关详细信息，请
// 参阅平台相关文档。
struct tm *localtime ( const time_t *time );
// 在 Unix 下，gmtime 不是线程级安全函数。所以，请使用 gmtime_r。
// 有关详细信息，请参阅平台相关文档。
struct tm *gmtime ( const time_t *time );
// 在 Unix 下，asctime 不是线程级安全函数。所以，请使用 asctime_r。
// 有关详细信息，请参阅平台相关文档。
char *asctime ( const struct tm *time );
// 通过停止在第一个非数字字符上，atof 只
// 读取字符串的初始位置。函数 atof（以及
// 所有不返回 integer 类型值的函数）
// 必须明确在 Vugen 脚本中声明。
double atof ( const char *string );
// 通过停止在第一个非数字字符上，atoi 只
// 读取字符串的初始位置。
int atoi ( const char *string );
// 通过停止在第一个非数字字符上，atol 只
// 读取字符串的初始位置。函数 atol（以及
// 所有不返回 integer 类型值的函数）必须
// 明确在 Vugen 脚本中声明。
long atol ( const char *string );
// itoa 将 value 的数字转换为以 radix 作为
// 基数的字符串 str。通常，radix 是 10。
int itoa ( int value, char *str, int radix );
// 通过停止在第一个非数字字符上，strtol
// 只扫描字符串的初始位置。所有前置空格
// 都将被去除。endptr 指向停止扫描的字符。
// 函数 strtol（以及所有不返回 integer
// 类型值的函数）必须明确在 Vugen 脚本中
// 声明。
long strtol ( const char *string, char **endptr, int radix );
// 有关 tolower 的详细信息，请参考 C 语言文档。
int tolower (int c);
// 有关 toupper 的详细信息，请参考 C 语言文档。
int toupper ( int c );
// 有关 isdigit 的详细信息，请参考 C 语言文档。
int isdigit ( int c );
// 函数 isalpha 检查 c 的值是否
// 处于 A - Z 或 a - z 的范围之内。
int isalpha ( int c );
// strcat 连接两个字符串。
char *strcat ( char *to, const char *from );
// strchr 返回指向字符串中
// 第一个匹配字符的指针。
char *strchr ( const char *string, int c );
// strcmp 比较 string1 和 string2 以确定字母排序的次序。
int strcmp ( const char *string1, const char *string2 );
// strcpy 将一个字符串复制给另一个。
char *strcpy ( char *dest, const char *source );
// strdup 复制字符串的副本。
char *strdup ( const char *string );
// stricmp 对两个字符串进行不区分大小写的比较。
int stricmp ( const char *string1, const char *string2 );
// strlen 返回字符串的长度（以字节为单位）。
size_t strlen ( const char *string );
// strlwr 将字符串转换为小写。
char *strlwr ( char *string );
// strncat 将一个字符串的 n 个字符连接到另一字符串。
char *strncat ( char *to_string, const char *from_string, size_t n );
// strncmp 比较两个字符串的前 n 个字符。
int strncmp ( const char *string1, const char *string2, size_t n );
// strncpy 将一个字符串的前 n 个字符复制到另一字符串。
char *strncpy ( char *dest, const char *source, size_t n );
// strnicmp 对两个字符串的 n 个
// 字符进行不区分大小写的比较，以
// 确定其字母排序的次序。
int strnicmp ( const char *string1, const char *string2, size_t num);
// strrchr 查找一个字符串中的最后一个匹配字符。
char *strrchr ( const char *string, int c );
// strset 使用指定字符填充字符串。
char *strset( char *string1, int character );
// strspn 返回指定字符串中包含另一
// 字符串起始字符的长度。
size_t *strspn ( const char *string, const char *skipset );
// strstr 返回一个字符串在另一字符串中第一次发生匹配的指针。
char *strstr ( const char *string1, const char *string2 );
// strtok 从由指定的字符分隔的字符串中返回标记。
// 注意，在 Vugen 文件中，需要明确声明不返回
// integer 类型值的 C 函数。
char *strtok ( char *string, const char *delimiters );
// strupr 将字符串转换为大写。
char *strupr ( char *string );
// lrc_CoCreateInstance 函数在本地系统或为特定
// 对象创建的默认主机中创建该对象的单个未初始化实例
// 并返回未知接口，该接口可用于获取其他接口。创建
// 该实例后，VuGen 调用 lrc_CoGetClassObject
// 以检索接口。如果 COM 对象位于远程计算机中，
// 将使用 lrc_CreateInstanceEx 取代
// lrc_CoCreateInstance。
HRESULT lrc_CoCreateInstance(GUID * pClsid, IUnknown * pUnkOuter, unsigned long dwClsContext, GUID * riid, LPVOID * ppv, BOOL __CheckResult);
// lrc_CreateInstanceEx 函数在指定的
// 远程计算机上创建未初始化的对象，并且
// 可以返回任意数量的请求接口。
HRESULT lrc_CreateInstanceEx(char *clsidStr, Iunknown *pUnk, DWORD dwClsCtx, ...);
// lrc_CoGetClassObject 函数提取
// 指定类的类工厂。
void lrc_CoGetClassObject( REFCLSID rclsid, Long dwClsContext, COSERVERINFO * pServerInfo, REFIID riid, LPVOID * ppv);
// lrc_GUID 函数返回命名对象（例如
// COM 接口）的 GUID。VuGen 使用它
// 检索标识符，该标识符用于检索接口
// 标识符和用于 COM 通信的 COM 对象
// 的 PROGID。
GUID lrc_GUID(const char *str);
// lrc_GUID_by_ref 函数返回指向命名对象
// （例如 COM 接口）的 GUID 的指针。VuGen
// 使用它检索标识符，该标识符用于检索接口
// 标识符和用于 COM 通信的 COM 对象的
// PROGID。
GUID* lrc_GUID_by_ref(const char *str);
// lrc_DispMethod 函数使用 IDispatch:Invoke
// 方法调用接口的方法。lrc_DispMethod 调用
// 将 wflags 设置为 DISPATCH_METHOD。
VARIANT lrc_DispMethod(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispMethod1 使用 IDispatch 接口调用
// （或获取）同名的方法（或属性）。lrc_DispMethod1
// 调用将 wflags 设置为 DISPATCH_METHOD 和
// DISPATCH_PROPERTYGET。它可以用在方法与属性
// 具有同一名称的情况下。
VARIANT lrc_DispMethod1(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyGet 调用使用 IDispatch 接口
// 获取属性并将 wflags 设置为 DISPATCH_PROPERTYGET。
VARIANT lrc_DispPropertyGet(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyPut 使用 IDispatch 接口设置属性。
// 该调用将设置 DISPATCH_PROPERTYPUT 标志。
void lrc_DispPropertyPut(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyPutRef 使用 IDispatch 接口根据
// 引用设置属性，并设置 DISPATCH_PROPERTYPUTREF 标志。
void lrc_DispPropertyPutRef(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_CreateVBCollection 函数创建填充安全
// 数组值的 Visual Basic (VB) Collection 对象，
// 并将集合接口指针返回到 pCollection 中。
// VB 集合是由 COM 实现为接口的变量
// SafeArray。
HRESULT lrc_CreateVBCollection(SAFEARRAY *items, _Collection** pCollection);
// lrc_CoObject_from_variant 函数从变量中
// 提取 IUnknown 接口类型指针。
IUnknown* lrc_CoObject_from_variant(VARIANT var);
// lrc_DispObject_from_variant 函数从变量中
// 提取 IDispatch 接口类型指针。
IDispatch* lrc_DispObject_from_variant(VARIANT var);
// lrc_CoObject_by_ref_from_variant 函数从指向
// 变量的指针中提取 IUnknown 接口类型指针。
IUnknown* lrc_CoObject_by_ref_from_variant(VARIANT var);
// lrc_DispObject_by_ref_from_variant 函数从指向
// 变量的指针中提取 IDispatch 接口类型指针。
IDispatch* lrc_DispObject_by_ref_from_variant(VARIANT var);
// 输入表示整数的字符串时，lrc_int 函数返回
// integer 类型值。此参数可以是文字字符串、
// 变量或参数。
int lrc_int(const char* str);
// 输入表示整数的字符串时，lrc_int_by_ref
// 函数返回指向 integer 类型值的指针。此参数
// 可以是文字字符串、变量或
// 参数。
int* lrc_int_by_ref(const char* str);
// lrc_save_int 函数将 integer 值
// 保存在指定变量 name 下的字符串中，以便
// 您将其用于参数化。VuGen 将此函数生成
// 为注释掉的调用。如果要将此值用作参数，
// 可以更改 name 参数并取消调用的
// 注释。
int lrc_save_int(const char* name, int val);
// lrc_save_int_by_ref 函数将 integer 值
// 保存在字符串中，并将 val 设置为指向该字符串。
// VuGen 将此函数生成为注释掉的调用。如果要
// 将此值用作参数，可以更改 name 并取消调用
// 的注释。
int lrc_save_int_by_ref(const char* name, int *val);
// lrc_get_bstr_length 返回 BSTR 类型字符
// 串的长度。BSTR 字符串可以包括 null。
int lrc_get_bstr_length(BSTR str);
// lrc_get_bstr_sub 从输入字符串 str 的开始处
// 返回 size 个字符的子集。
BSTR lrc_get_bstr_sub(BSTR str, int size);
// lrc_print_bstr 将 BSTR 字符串输出到
// 用于调试目的的标准输出上。
int lrc_print_bstr(BSTR str);
// lrc_BSTR1 创建长度为 len 的 BSTR 字符串，它可以包括 null。
BSTR lrc_BSTR1 (const char* str, long len);
// lrc_save_BSTR1 函数将 BSTR str 保
// 存到字符串 name 中。
int lrc_save_BSTR1 (const char* name, BSTR str);
// 输入表示无符号整数的字符串时，lrc_uint 函数
// 返回无符号 integer 类型值。
unsigned int lrc_uint(const char* str);
// 输入表示无符号整数的字符串时，lrc_uint_by_ref
// 函数返回指向无符号 integer 类型值的
// 指针。
unsigned int* lrc_uint_by_ref(const char* str);
// lrc_save_uint 函数将无符号 integer 值
// 保存在指定变量 name 下的字符串中，以便
// 您将其用于参数化。VuGen 将此函数生
// 成为注释掉的调用。如果要将此值用作
// 参数，可以更改 name 参数并取消调用的
// 注释。
int lrc_save_uint(const char* name, unsigned int val);
// 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 从变量中提取数
扫一扫
886
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
