LoadRunner 函数大全之中文解释

LoadRunner 函数大全之中文解释

// sapgui_table_set_column_selected 模拟用户

// 单击表中的列标题。

int sapgui_table_set_column_selected(const char *description, const char *tableID, const char

*column, const char *isSelected, [args,] LAST );

// sapgui_table_set_column_width 模拟用户

// 拖动表中列标题的边缘。

int sapgui_table_set_column_width ( const char *description, const char *tableID, const char

*column, const char *width, [args,] LAST );

// sapgui_table_set_focus 模拟用户在由

// row 和 column 指定的表单元格中单击。

int sapgui_table_set_focus (const char *description, const char *tableID, const char *row, const

char *column, const char *newValue, [args,] LAST );

// sapgui_table_set_password 在表单元格密码字段中

// 设置密码。

int sapgui_table_set_password(const char *description, const char *tableID, const char *row,

const char *column, const char *password, [args,] LAST );

// sapgui_table_set_row_selected 设置表中行的

// 选中状态。如果 isSelected 为“True”，

// 则行号为 row 的行处于选中状态。如果 isSelected

// 为“False”，则该行处于未选中状态。

int sapgui_table_set_row_selected(const char *tableID, const char *row, const char *isSelected,

[args,] LAST );

// sapgui_table_set_text 在由 row 和 column 指定的

// 单元格中输入字符串文本。

int sapgui_table_set_text(const char *description, const char *tableID, const char *row, const char

*column, const char *text, [args,] LAST );

// sapgui_text_edit_scroll_to_line 模拟用户滚动，

// 直到指定行可见。但不选中该行。

int sapgui_text_edit_scroll_to_line( const char *description, const char *textEditID, const char

*lineNumber, [args,] LAST );

// sapgui_text_edit_set_selection_indexes 设置

// 选择的可视文本范围。参数 start 和 end 都是基于

// 零的字符索引。参数 start 对应

// 所选内容的开始位置，而参数 end 是

// 所选内容之后第一个字符的位置。

int sapgui_text_edit_set_selection_indexes( const char *description, const char *textEditID, const

char *startNumber, const char *endNumber, [args,] LAST );

// sapgui_text_edit_set_unprotected_text_part

// 通过基于零的索引将 text 的内容分配给未受保护的

// 文本部分，即 part。

int sapgui_text_edit_set_unprotected_text_part( const char *description, const char *textEditID,

const char *part, const char *text, [args,] LAST );

// sapgui_text_edit_get_first_visible_line 将在控件

// 顶部边框可见的第一行的编号

// 分配给 outParamName。行从 1 开始编号。

int sapgui_text_edit_get_first_visible_line( const char *description, const char *textEditID, const

char *outParamName, [args,] LAST );

// sapgui_text_edit_get_selection_index_start 将

// 选定范围开始位置的基于零的字符索引

// 分配给参数 outParamName。

int sapgui_text_edit_get_selection_index_start( const char *description, const char *textEditID,

const char *outParamName, [args,] LAST );

// sapgui_text_edit_get_selection_index_end 将

// 选定范围结束位置的基于零的字符索引

// 分配给参数 outParamName。这是所选内容之后第一个字符的

// 位置。

int sapgui_text_edit_get_selection_index_end( const char *description, const char *textEditID,

const char *outParamName, [args,] LAST );

// sapgui_text_edit_get_number_of_unprotected_text_parts 将

// 未受保护文本部分的编号分配给 outParamName。

int sapgui_text_edit_get_number_of_unprotected_text_parts( const char *description, const char

*textEditID, const char *outParamName, [args,] LAST );

// sapgui_text_edit_double_click 模拟鼠标双击。

// 要设置所选内容，请在 sapgui_text_edit_double_click 之前

// 调用 sapgui_text_edit_set_selection_indexes。

int sapgui_text_edit_double_click( const char *description, const char *textEditID, [args,]

LAST );

// sapgui_text_edit_single_file_dropped 模拟

// 将 fileName 拖放到文本编辑控件中。

int sapgui_text_edit_single_file_dropped( const char *description, const char *textEditID, const

char * fileName, [args,] LAST );

// sapgui_text_edit_multiple_files_dropped 模拟

// 将 listOfFiles 中的文件

// 拖放到文本编辑控件中。

int sapgui_text_edit_multiple_files_dropped( const char *description, const char *textEditID,

listOfFiles, [args,] LAST );

// sapgui_text_edit_press_F1 调用

// 在应用程序中针对文本编辑控件定义的

// 上下文相关帮助。如果未定义帮助，

// 则 sapgui_text_edit_press_F1 不起作用。

int sapgui_text_edit_press_F1( const char *description, const char *textEditID, [args,] LAST );

// sapgui_text_edit_press_F4 调用

// 应用程序中针对文本编辑控件定义的选项列表。如果未

// 定义选项，则 sapgui_text_edit_press_F4 不起作用。

int sapgui_text_edit_press_F4( const char *description, const char *textEditID, [args,] LAST );

// sapgui_text_edit_open_context_menu 打开

// 应用程序中针对文本编辑控件定义的

// 快捷菜单。如果未定义菜单，则 sapgui_text_edit_open_context_menu

// 不起作用。

int sapgui_text_edit_open_context_menu( const char *description, const char *textEditID, [args,]

LAST );

// sapgui_text_edit_select_context_menu 选中

// 由 menuId 指定的快捷菜单项。

// menuId 是项目的函数代码。

int sapgui_text_edit_select_context_menu( const char *description, const char *textEditID, const

char *menuId, [args,] LAST );

// sapgui_text_edit_modified_status_changed 设置

// 文本编辑控件的已修改状态。

// 其值可以是“True”，也可以是“False”。

int sapgui_text_edit_modified_status_changed( const char *description, const char *textEditID,

const char *value, [args,] LAST );

// sapgui_toolbar_press_button 模拟在工具栏按钮上进行单击操作。

int sapgui_toolbar_press_button( const char * description, const char * toolbarID, const char *

buttonID, [args,] LAST );

// sapgui_toolbar_press_context_button 模拟

// 用户按工具栏上下文按钮。

int sapgui_toolbar_press_context_button(const char * description, const char * toolbarID, const

char * buttonID, [args,] LAST );

// sapgui_toolbar_select_menu_item 模拟

// 用户选择工具栏菜单项。

int sapgui_toolbar_select_menu_item( const char * description, const char * toolbarID, const char

* menuID, [args,] LAST );

// sapgui_toolbar_select_menu_item_by_text 模拟

// 用户选择工具栏菜单项。

int sapgui_toolbar_select_menu_item_by_text( const char * description, const char * toolbarID,

const char * menuItem, [args,] LAST );

// sapgui_toolbar_select_context_menu_item 模拟

// 用户选择上下文菜单项。

int sapgui_toolbar_select_context_menu_item( const char * description, const char * toolbarID,

const char * menuID, [args,] LAST );

// sapgui_toolbar_select_context_menu_item_by_text

// 模拟用户选择上下文菜单项。

int sapgui_toolbar_select_context_menu_item_by_text( const char * description, const char *

toolbarID, const char * menuItem, [args,] LAST );

// sapgui_tree_click_link 模拟用户单击树中的链接。

int sapgui_tree_click_link(const char *description, const char *treeID, const char *nodeKey, const

char *itemName, [args,] LAST ) ;

// sapgui_tree_collapse_node 模拟用户单击

// “-”符号以折叠节点。调用 sapgui_tree_collapse_node 之后，

// “-”符号将替换为“+”符号，

// 而且子节点不可见。

int sapgui_tree_collapse_node(const char *description, const char *treeID, const char *nodeKey,

[args,] LAST ) ;

// sapgui_tree_double_click_item 模拟用户

// 双击树中的某一项。如果该项是一个链接，

// 则打开其目标；如果是命令，则执行该命令。

int sapgui_tree_double_click_item(const char *description, const char *treeID, const char

*nodeKey, const char *itemName, [args,] LAST ) ;

// sapgui_tree_double_click_node 模拟

// 用户双击树中的某个节点。

int sapgui_tree_double_click_node(const char *description, const char *treeID, const char

*nodeKey, [args,] LAST );

// sapgui_tree_expand_node 模拟用户通过单击“+”符号

// 展开一个节点。调用 sapgui_tree_expand_node 之后，

// “+”符号将替换为“-”符号，

// 而且子节点可见。

int sapgui_tree_expand_node(const char *description, const char *treeID, const char *nodeKey,

[args,] LAST ) ;

// sapgui_tree_get_item_text 数据检索函数

// 将树中某一项的文本属性放到 outParamName 中。

int sapgui_tree_get_item_text(const char *description, const char *treeID, const char *nodeKey,

const char *itemName, const char *outParamName, [args,] LAST ) ;

// sapgui_tree_get_node_text 数据检索函数

// 将节点文本放到 outParamName 中。

int sapgui_tree_get_node_text(const char *description, const char *treeID, const char *nodeKey,

const char *outParamName, [args,] LAST ) ;

// sapgui_tree_is_checkbox_selected 验证函数

// 适用于树控件中的复选框。如果复选框处于选中状态，

// 则返回 True，如果复选框处于清除状态，则返回 False。

int sapgui_tree_is_checkbox_selected(const char *description, const char *treeID, const char

*nodeKey, const char *itemName, [args,] LAST ) ;

// sapgui_tree_open_default_context_menu 打开

// 树的默认上下文相关菜单。

int sapgui_tree_open_default_context_menu(const char *description, const char *treeID, [args,]

LAST ) ;

// sapgui_tree_open_header_context_menu 模拟用户

// 右键单击树标题以打开上下文相关菜单。

int sapgui_tree_open_header_context_menu(const char *description, const char *treeID, const

char *headerName, [args,] LAST ) ;

// sapgui_tree_open_item_context_menu 模拟用户

// 右键单击树项以打开上下文相关菜单。

int sapgui_tree_open_item_context_menu(const char *description, const char *treeID, const char

*nodeKey, const char *itemName, [args,] LAST ) ;

// sapgui_tree_open_node_context_menu 模拟用户

// 右键单击树节点以打开上下文相关菜单。

int sapgui_tree_open_node_context_menu(const char *description, const char *treeID, const char

*nodeKey, [args,] LAST ) ;

// sapgui_tree_press_button 模拟用户单击树中的按钮。

int sapgui_tree_press_button(const char *description, const char *treeID, const char *nodeKey,

const char *itemName, [args,] LAST );

// sapgui_tree_press_header 模拟用户

// 单击树中的列标题。

int sapgui_tree_press_header(const char *description, const char *treeID, const char *headerName,

[args,] LAST ) ;

// sapgui_tree_press_key 模拟用户在

// 树具有焦点时按键盘。

int sapgui_tree_press_key(const char *description, const char *treeID, const char *key, [args,]

LAST );

// sapgui_tree_scroll_to_item 与

// sapgui_tree_select_item 自动录制为一对。它模拟

// 使用滚动条，以便 itemName 可见。

int sapgui_tree_scroll_to_item(const char *description, const char *treeID, const char *nodeKey,

const char *itemName, [args,] LAST ) ;

// sapgui_tree_scroll_to_node 滚动树，以便

// topNode 成为窗格顶端

// 的第一个可见节点。但不选中该节点。

int sapgui_tree_scroll_to_node(const char *description, const char *treeID, const char *topNode,

[args,] LAST );

// sapgui_tree_select_column 模拟用户

// 使用鼠标选择树列。

int sapgui_tree_select_column(const char *description, const char *treeID, const char

*columnName, [args,] LAST ) ;

// sapgui_tree_select_context_menu 从树控件的

// 快捷菜单中选择一项。

int sapgui_tree_select_context_menu ( const char *description, const char *treeID, const char

*value, [args,] LAST );

// sapgui_tree_select_item 适用于树控件中

// 任何可选项。它模拟用户单击

// itemName 项以便选中该项。如果在调用 sapgui_tree_select_item 时

// 该项在树窗格中不可见，

// 则滚动树以使该项可见。

int sapgui_tree_select_item(const char *description, const char *treeID, const char *nodeKey,

const char *itemName, [args,] LAST ) ;

// sapgui_tree_select_node 模拟用户单击

// MultipleNodeSelection 树中的节点。调用

// sapgui_tree_select_node 会将节点 nodeKey

// 添加到选定节点的集合。

int sapgui_tree_select_node(const char *description, const char *treeID, const char *nodeKey,

[args,] LAST ) ;

// sapgui_tree_set_checkbox 适用于树控件中的

// 复选框。如果该值为“True”，则选中复选框；

// 如果该值为“False”，则清除复选框。

int sapgui_tree_set_checkbox(const char *description, const char *treeID, const char *nodeKey,

const char *itemName, const char *value, [args,] LAST );

// sapgui_tree_set_column_order 设置树中

// 列的顺序。新顺序由列在列列表中

// 的位置来确定。

int sapgui_tree_set_column_order(const char *description, const char *treeID, const char

*columns, [args,] LAST ) ;

// sapgui_tree_set_column_width 将 columnName 的宽度设置为 width。

int sapgui_tree_set_column_width(const char *description, const char *treeID, const char

*columnName, const char *width, [args,] LAST ) ;

// sapgui_tree_set_hierarchy_header_width 将

// 树视图中标题的宽度更改为 width。

int sapgui_tree_set_hierarchy_header_width(const char *description, const char *treeID, const

char *width, [args,] LAST );

// sapgui_tree_set_selected_node 模拟用户单击

// SingleNodeSelection 树中的节点。调用

// sapgui_tree_set_selected_node 将取消选中

// 先前选中的节点，并选中节点 nodeKey。

int sapgui_tree_set_selected_node(const char *description, const char *treeID, const char

*nodeKey, [args,] LAST );

// sapgui_tree_unselect_all 取消选中树中

// 所有选中的项，而不选中其他项。

int sapgui_tree_unselect_all(const char *description, const char *treeID, [args,] LAST) ;

// sapgui_tree_unselect_column 取消选中树列。

int sapgui_tree_unselect_column(const char *description, const char *treeID, const char

*columnName, [args,] LAST ) ;

// sapgui_tree_unselect_node 取消选中树节点。

int sapgui_tree_unselect_node(const char *description, const char *treeID, const char *nodeKey,

[args,] LAST ) ;

// sapgui_window_close 关闭 SAP GUI 应用程序。

int sapgui_window_close( LAST);

// sapgui_window_maximize 将窗口设置为全屏大小。

int sapgui_window_maximize( LAST);

// sapgui_window_resize 将活动窗口调整为 width 和 height 大小。

int sapgui_window_resize( const char *width, const char *height, [args,] LAST );

// sapgui_window_restore 将窗口还原为非最大化状态。

int sapgui_window_restore( LAST);

// sapgui_window_scroll_to_row 滚动到某一窗口行，但

// 不在该行上设置焦点，也不针对该行执行任何操作

int sapgui_window_scroll_to_row( const char * newPosition, [args,] LAST );

// sapgui_apogrid_clear_selection 取消选中

// APO 网格中当前选中的区域。

int sapgui_apogrid_clear_selection ( const char *description, const char *gridID, [args,] LAST ) ;

// sapgui_apogrid_deselect_cell 取消选中 APO 网格中

// 由“row”和“column”指定的单元格。

int sapgui_apogrid_deselect_cell ( const char *description, const char *gridID, const char *row,

const char *column, [args,] LAST ) ;

// sapgui_apogrid_deselect_column 取消选中 APO 网格中的

// 指定列。

int sapgui_apogrid_deselect_column ( const char *description, const char *gridID, const char

*column, [args], LAST ) ;

// sapgui_apogrid_deselect_row 取消选中 APO 网格中的指定行。

int sapgui_apogrid_deselect_row ( const char *description, const char *gridID, const char *row,

[args,] LAST ) ;

// sapgui_apogrid_double_click 模拟用户

// 双击 APO 网格中的单元格。

int sapgui_apogrid_double_click ( const char *description, const char *gridID, const char *row,

const char *column, [args,] LAST ) ;

// sapgui_apogrid_get_cell_data 将 APO 网格中

// 某单元格的数据分配给参数 outParamName。

// 数据始终以字符串形式保存。

int sapgui_apogrid_get_cell_data ( const char *description, const char *gridID, const char *row,

const char *column, const char *outParamName, [args,] LAST ) ;

// sapgui_apogrid_get_cell_format 将 APO 网格中

// 某单元格的格式描述分配给参数 outParamName。

int sapgui_apogrid_get_cell_format ( const char *description, const char *gridID, const char *row,

const char *column, const char *outParamName, [args,] LAST ) ;

// sapgui_apogrid_get_cell_tooltip 将 APO 网格中

// 某单元格的工具提示分配给参数 outParamName。

int sapgui_apogrid_get_cell_tooltip ( const char *description, const char *gridID, const char *row,

const char *column, const char *outParamName, [args,] LAST ) ;

// sapgui_apogrid_is_cell_changeable 返回一个值，指明

// 用户是否可以修改 APO 网格中某单元格的值。

int sapgui_apogrid_is_cell_changeable ( const char *description, const char *gridID, const char

*row, const char *column, [args,] LAST ) ;

// sapgui_apogrid_open_cell_context_menu 打开 APO 网格中

// 某单元格的上下文菜单。

int sapgui_apogrid_open_cell_context_menu ( const char *description, const char *gridID, const

char *row, const char *column, [args,] LAST ) ;

// sapgui_apogrid_press_ENTER 模拟用户在 APO 网格中按 Enter 键。

int sapgui_apogrid_press_ENTER ( const char *description, const char *gridID, [args,] LAST ) ;

// sapgui_apogrid_scroll_to_column 模拟

// 用户滚动到 APO 网格中的某列。

// 该函数不选中该列。

int sapgui_apogrid_scroll_to_column ( const char *description, const char *gridID, const char

*column, [args,] LAST ) ;

// sapgui_apogrid_scroll_to_row 模拟用户

// 滚动到 APO 网格中的某行。该函数不选中该行。

int sapgui_apogrid_scroll_to_row ( const char *description, const char *gridID, const char *row,

[args,] LAST ) ;

// sapgui_apogrid_select_all 全选 APO 网格中的单元格。

int sapgui_apogrid_select_all ( const char *description, const char *gridID, [args,] LAST ) ;

// sapgui_apogrid_select_cell 选中 APO 网格中的一个单元格。

int sapgui_apogrid_select_cell ( const char *description, const char *gridID, const char *row,

const char *column, [args,] LAST ) ;

// sapgui_apogrid_select_column 选中 APO 网格中的一列。

int sapgui_apogrid_select_column ( const char *description, const char *gridID, const char

*column, [args,] LAST) ;

// sapgui_apogrid_select_context_menu_item 选中 APO 网格的

// 上下文菜单中的一项。

int sapgui_apogrid_select_context_menu_item ( const char *description, const char *gridID, const

char *value, [args,] LAST ) ;

// sapgui_apogrid_select_row 选中 APO 网格中的一行。

int sapgui_apogrid_select_row ( const char *description, const char *gridID, const char *row,

[args,] LAST ) ;

// sapgui_apogrid_set_cell_data 将 newValue

// 分配给 APO 网格中某单元格的内容。

int sapgui_apogrid_set_cell_data ( const char *description, const char *gridID, const char *row,

const char *column, const char *newValue, [args,] LAST ) ;

// smtp_abort_mail 取消当前的邮件事务。

// 废弃所有已存储的发件人、收件人和邮件数据。

// 清除所有缓冲区和状态表。

int smtp_abort_mail( );

// smtp_abort_mail_ex 针对特定会话取消

// 当前邮件事务。废弃所有

// 已存储的发件人、收件人和邮件数据。

// 清除所有缓冲区和状态表。

int smtp_abort_mail_ex( SMTP *ppsmtp);

// smtp_free 函数释放 SMTP 服务器

// 并取消所有挂起命令。

void smtp_free( );

// smtp_free_ex 函数释放 SMTP 服务器

// 并取消所有挂起命令。

void smtp_free_ex (SMTP *ppsmtp);

// smtp_logon 函数登录到 SMTP 服务器。

// 它使用 FTP 协议所用的格式。

int smtp_logon (char *transaction, char *url, [ char *CommonName, char *LogonUser, char

*LogonPass,] LAST);

// smtp_logon_ex 函数针对特定会话

// 登录到 SMTP 服务器。

int smtp_logon_ex ( SMTP *ppsmtp, char *transaction, char *url, [ char *CommonName, char

*LogonUser, char *LogonPass,] LAST );

// smtp_logout 函数从 SMTP 服务器注销。

int smtp_logout( );

// smtp_logout_ex 函数针对特定会话

// 从 SMTP 服务器注销。

int smtp_logout_ex (SMTP *ppsmtp);

// smtp_send_mail 函数使用 SMTP 服务器发送一封邮件。

int smtp_send_mail (char *transaction, char *RecipientTo, [char *RecipientCC,] [char

*RecipientBCC,] char *Subject, [char *From,][char * ContentType, <char * charset,>] char

*MAILOPTIONS, char *MAILDATA, LAST);

// smtp_send_mail_ex 函数针对指定会话

// 使用 SMTP 服务器发送一封邮件。

int smtp_send_mail_ex (SMTP *ppsmtp, char *transaction, char *RecipientTo, [char

*RecipientCC,] [char *RecipientBCC,] char *Subject,[char *From,] [char * ContentType, < char *

charset,>] char *MAILOPTIONS, char *MAILDATA, LAST);

// smtp_translate 函数为 SMTP 服务器

// 转换消息。应指定源文件和目标文件、

// 内容标题和编码类型。

int smtp_translate (char *filename, char *content_header, ENCODING_TYPE encoding, char

*output_filename);

// smtp_translate_ex 函数为 SMTP 服务器

// 转换消息。应指定源文件和目标文件、

// 内容标题和编码类型。

int smtp_translate_ex (SMTP *ppsmtp, char *filename, char *content_header,

ENCODING_TYPE encoding, char *output_filename);

// lrt_abort_on_error 函数

// 在上一个 Tuxedo 函数产生错误时

// 中止当前事务。这意味着事务异常

// 结束。将撤消事务执行过程中

// 对资源所做的所有更改。

void lrt_abort_on_error ( );

// lrt_ClarifyCorrelate 在使用 Clarify CRM 应用程序时

// 由 Vugen 自动生成，

// 并将返回的数据

// 保存在对数据库的 DB_OBJNUM 或 DB_OBJIDS 调用

// 的回复缓冲区中。该数据用于关联。

void lrt_ClarifyCorrelate (void *buf, int occurrence, char *param);

// lrt_display_buffer 函数将有关缓冲区的

// 信息存储到输出文件 section_name.out 中。

// 该文件包含每个

// 发送缓冲区和回复缓冲区的缓冲区描述。该信息

// 以以下格式显示：

int lrt_display_buffer (const char* bufferName, const char* bufferPtr, long actualLen,

long expectedLen );

// lrt_Fadd[32]_fld 函数将新字段

// 添加到 FML 缓冲区。必须将 FML 字段的名称或其字段 ID

// 指定为第二个参数。

// 必须在第三个参数中指定新

// FML fielFML 缓冲区的值。字段长度是可选的。

// 只需将 FML 字段的类型指定为

// CARRAY（二进制数据）。其他字段的长度

// 由字段类型和值来确定。

int lrt_Fadd[]_fld ( FBFR[] *fbfr, "name=fldname" | "id=idval", "value=fldvalue" [, "len=8"],

LRT_END_OF_PARAMS );

// lrt_Finitialize[32] 函数初始化

// 某个现有的 FML 缓冲区。该函数替代

// Tuxedo 函数 Finit 和 Fsizeof 的使用。

int lrt_Finitialize[] ( FBFR[] *fbfr );

// lrt_Fname[32] 函数提供从字段标识符

// 到其字段名的运行时转换。

char * lrt_Fname[] ( FLDID[] fieldid );

// lrt_Fstrerror[32] 函数检索

// 与 FML 错误代码对应的错误消息字符串。

char *lrt_Fstrerror[] ( int err );

// lrt_getFerror[32] 函数检索上次失败的

// FML 操作的错误代码。在多任务

// 环境中，该函数用于为每个任务

// 提供一个独立的错误状态，而不

// 依赖于全局错误变量 (Ferrno)。

int lrt_getFerror[] ( void );

// lrt_gettperrno 函数检索

// 上次失败事务的错误代码。在多任务

// 环境中，该函数用于为每个任务

// 提供一个独立的错误状态，而不

// 依赖于全局错误变量 (tperrno)。

int lrt_gettperrno ( void );

// lrt_gettpurcode 函数检索最后

// 一次调用 lrt_tpgetrply、lrt_tpcall、

// lrt_tprecv 或 lrt_tpdequeue 时设置的

// 全局应用程序返回代码变量 (tpurcode)。如果指定，

// tpurcode 还将包含使用 lrt_tpenqueue

// 发送的“user-return code”的值。

long lrt_gettpurcode ( void );

// lrt_InterateIDCals 在使用 Clarify CRM 应用程序时

// 由 Vugen 自动生成，并将返回的数据保存在

// 对数据库的 AS_EXESVC 调用

// 的回复缓冲区中。该数据用于关联。

void lrt_InterateIDCals (void *buf, int occurrence, char *param);

// lrt_memcpy 函数将指定的字节数

// 从源复制到目标。在复制到目标

// 之前，源保存在一个参数中

// 。该函数与

// C 函数 (memcpy) 功能相同。如果在用户计算机上

// 找不到 C 函数 (memcpy)，

// 则提供 lrt_memcpy 函数。由于我们使用 C 解释器，

// 因此不能假定在每台用户计算机上

// 都可以找到标准 C 库。

void lrt_memcpy ( void *dest, const void *source, unsigned long count );

// lrt_save_fld_val 函数将 FML 缓冲区的

// 当前值保存到 paramName 指定的参数中。

// 该函数用于关联脚本中的

// 查询。并不使用查询期间实际获取的

// 结果，而是用一个参数来代替

// 该常量值。之后，同一个脚本中的其他数据库语句

// 可以使用该参数。

int lrt_save_fld_val ( FBFR *fbfr, char *name, FLDOCC occ, char *paramName );

// lrt_save32_fld_val 函数将 FML32 缓冲区的

// 当前值保存到 paramName 指定的参数中。

// 该函数用于关联脚本中的

// 查询。并不使用查询期间实际获取的

// 结果，而是用一个参数来代替

// 该常量值。之后，同一个脚本中的其他数据库语句

// 可以使用该参数。

int lrt_save32_fld_val ( FBFR32 *fbfr, char *name, FLDOCC32 occ, char *paramName );

// lrt_save_parm 函数将字符数组的一部分

// 保存到 parm_name 指定的参数中。该函数

// 保存 parm_len 指定的字符数，

// 从 offset 指定的偏移量开始。

int lrt_save_parm ( char *buffer, int offset, int parm_len, char *parm_name );

// lrt_set_carray_error_list 函数设置

// 可用于 CARRAY 回复缓冲区的错误消息

// 列表。使用该函数之前，应在 CARRAY_ERROR_INFO 结构中

// 定义错误消息。

void lrt_set_carray_error_list (CARRAY_ERROR_INFO *newcarrayErrors);

// lrt_set_env_list 函数设置之后可以由 lrt_tuxputenv 设置

// 的变量列表。在调用 lrt_set_env_list

// 之后，可以设置 allowedEnv 列表

// 中的环境变量。

void lrt_set_env_list ( char **allowedEnv );

// lrt_strcpy 函数将指定的字符串从

// 源复制到目标。在复制到

// 目标之前，源保存在一个参数中。该

// 函数与 C 函数 (strcpy) 功能相同。

void lrt_strcpy ( char *destString, const char *sourceString );

// lrt_tpabort 函数中止当前的 Tuxedo

// 或 System/T 事务。这意味着事务的

// 异常结束。将撤消事务执行过程中

// 对资源所做的所有更改。lrt_tpabort

// 只能由事务的发起者调用。

int lrt_tpabort ( long flags );

// lrt_tpacall 函数将请求消息发送给

// 指定的服务。这是可以以简要模式打印调试信息的

// 少数几个函数之一。

int lrt_tpacall ( char *svc, char *data, long len, long flags );

// lrt_tpalloc 函数分配新缓冲区，并

// 返回一个指向指定类型缓冲区的指针。由于

// 一些缓冲区类型在使用前

// 需要初始化，因此 lrt_tpalloc 会在分配之后，返回之前

// 初始化缓冲区。

char *lrt_tpalloc ( char *type, char *subtype, long size );

// lrt_tpbegin 函数开始一个 System/T 事务。

// System/T 中的事务是没有完全成功或根本没有生效的

// 工作的一个逻辑单元。

// 此类事务允许由多个进程执行工作，

// 而在不同的站点这些进程可能被视为

// 单一的工作单元。事务的发起者可以

// 可以使用 lrt_tpabort 或 lrt_tpcommit

// 结束事务。

int lrt_tpbegin(unsigned long timeout, long flags);

// lrt_tpbroadcast 函数允许客户端或服务器

// 将未经请求的消息发送到系统中已注册的客户端。

int lrt_tpbroadcast ( char *lmid, char *username, char *cltname, char * data, long len, long flags );

// lrt_tpcall 函数发送服务请求并等待其回复。

int lrt_tpcall ( char *svc, char *idata, long ilen, char **odata, long *olen, long flags );

// lrt_tpcancel 函数取消调用描述符。

// 在 lrt_tpcancel 之后，调用描述符 cd 不再

// 有效，并将忽略对 cd 的任何回复。任何

// 取消与事务关联的调用描述符的尝试

// 都会产生错误。

int lrt_tpcancel ( int cd );

// lrt_tpchkauth 函数检查应用程序配置

// 是否要求身份验证。这通常由应用程序客户端

// 在调用 lrt_tpinitialize 之前使用，

// 以确定是否要求输入密码。

int lrt_tpchkauth ( );

// lrt_tpchkunsol 函数通过检查来确定

// Tuxedo 客户端是否接收到任何未经请求的消息。

int lrt_tpchkunsol ( void );

// lrt_tpcommit 函数提交当前的 System/T 事务。

int lrt_tpcommit ( long flags );

// lrt_tpconnect 函数建立一个半双工

// 会话式服务连接。

int lrt_tpconnect ( char *svc, char *data, long len, long flags );

// lrt_tpdequeue 函数获取用于处理的消息，

// 并将其从队列中删除。默认情况下，获取的是队列

// 顶端的消息。要请求一条特定的

// 消息，请在 ctl 中指定消息标识符。

int lrt_tpdequeue ( char *qspace, char *qname, TPQCTL *ctl, char **data, long *len, long flags );

// lrt_tpdiscon 函数断开会话式

// 服务连接。该函数只能由

// 会话的发起者调用。调用

// 该函数之后，您将再也无法在

// 该连接上进行发送或接收。

int lrt_tpdiscon ( int cd );

// lrt_tpenqueue 函数存储要在 qname 指定的队列上

// 处理的消息。

int lrt_tpenqueue ( char *qspace, char *qname, TPQCTL *ctl, char *data, long len, long flags );

// lrt_tpfree 函数释放先前由

// lrt_tpalloc 或 lrt_tprealloc 获取的缓冲区。

void lrt_tpfree ( char *ptr );

// lrt_tpgetlev 函数检查事务是否正在执行。

int lrt_tpgetlev ( ) ;

// lrt_tpgetrply 函数返回上次所发送请求的回复。

int lrt_tpgetrply ( int *cd, char **data, long *len, long flags );

// lrt_tpgprio 函数返回上次发送或接收

// 的请求的优先级。优先级范围

// 从 1 到 100，最高优先级为 100。

int lrt_tpgprio ( );

// lrt_tpinitialize 函数使客户端可以加入 System/T

// 应用程序。该函数将替换 TVG_tpinit 函数。

int lrt_tpinitialize (["usrname=value",] ["cltname=value", ] ["passwd=value", ] [grpname=value,]

[flags= value, ] [datalen=value, ] [data=value, ] LRT_END_OF_PARAMS );

// lrt_tprealloc 函数更改类型化缓冲区的大小。

char * lrt_tprealloc ( char *ptr, long size );

// lrt_tprecv 函数通过打开的连接接收

// 发自另一个程序的数据。它

// 与 lrt_tpsend 结合使用，

// 且只能由对该连接没有控制权的

// 程序发出。该函数可以以简要

// 模式打印调试信息。

int lrt_tprecv ( int cd, char **data, long *len, long flags, long *revent );

// lrt_tpresume 函数继续执行全局事务。它

// 与 lrt_tpsuspend 语句结合使用。

int lrt_tpresume ( TPTRANID *tranid, long flags );

// lrt_tpscmt 函数与 lrt_tpcommit 结合使用，

// 设置 lrt_tpcommit 应在何时返回。

int lrt_tpscmt ( long flags );

// lrt_tpsend 函数通过打开的连接

// 将消息发送到另一个程序。调用方

// 必须拥有连接控制权。它与

// lrt_tprecv 结合使用。该函数可以以

// 简要模式打印调试信息。

int lrt_tpsend ( int cd, char *data, long len, long flags, long *revent );

// lrt_tpsetunsol 函数

// 设置在接收到未经请求的消息时调用的回调过程。

// 回调过程必须在外部 DLL 中定义，

// 并具有以下原型：

void *lrt_tpsetunsol ( void *func );

// lrt_tpsprio 函数设置下一个

// 发送或转发请求的优先级。

int lrt_tpsprio ( int prio, long flags );

// lrt_tpstrerror 函数检索 System/T 错误

// 的错误消息字符串。

char *lrt_tpstrerror ( int err );

// lrt_tpsuspend 函数挂起全局事务。

// 它与 lrt_tpresume 语句结合使用。

int lrt_tpsuspend ( TPTRANID *tranid, long flags );

// lrt_tpterm 函数从 System/T 应用程序中

// 删除客户端。如果客户端处于事务

// 模式，则回滚该事务。

int lrt_tpterm ( );

// lrt_tptypes 函数确定有关类型化缓冲区的信息。

long lrt_tptypes ( char *ptr, char *type, char *subtype );

// lrt_tuxgetenv 函数在环境列表中搜索与环境名称

// 相对应的值

// 。在通常没有环境变量的平台上，

// 该函数对不同平台间环境值的

// 可移植性非常有用。

char *lrt_tuxgetenv ( char *name );

// lrt_tuxputenv 函数更改现有

// 环境变量的值，或者新建一个变量。

// 使用 lrt_set_env_list 确定

// 可以设置的变量。在通常没有环境变量的平台上，

// 该函数对不同平台间环境值的

// 可移植性非常有用。默认

// 情况下，lrt_tuxputenv 只允许更改 WSNADDR，

// 使用 lrt_set_env_list 时除外。

int lrt_tuxputenv (char *string);

// lrt_tuxreadenv 函数读取包含

// 环境变量的文件，并将其添加到环境中。

// 在通常没有环境变量的平台上，

// 该函数对不同平台间环境值的

// 可移植性非常有用。

int lrt_tuxreadenv ( char *file, char *label );

// lrt_tx_begin 函数开始一个全局事务。

int lrt_tx_begin ( );

// lrt_tx_close 函数关闭一组资源管理器。

// 该函数与 lrt_tx_open 结合使用。

int lrt_tx_close ( );

// lrt_tx_commit 函数提交一个全局事务。

int lrt_tx_commit ( );

// lrt_tx_info 函数返回全局事务信息。

int lrt_tx_info ( TXINFO *info );

// lrt_tx_open 函数打开一组资源管理器。

// 该函数与 lrt_tx_close 结合使用。

int lrt_tx_open ( );

// lrt_tx_rollback 函数回滚一个全局事务。

int lrt_tx_rollback ( );

// lrt_tx_set_commit_return 函数将 commit_return

// 特征设置为 when_return 中指定的值。

int lrt_tx_set_commit_return ( COMMIT_RETURN when_return );

// lrt_tx_set_transaction_control 函数将 transaction_control

// 特征设置为 control 中指定的值。

int lrt_tx_set_transaction_control ( TRANSACTION_CONTROL control );

// lrt_tx_set_transaction_timeout 函数将 transaction_timeout

// 特征设置为 timeout 中指定的值。

int lrt_tx_set_transaction_timeout ( TRANSACTION_TIMEOUT timeout );

// lr_advance_param 函数使脚本使用

// 参数的下一个可用值。如果要

// 运行多次循环，可以在

// 参数属性中指定自动前进到

// 每次循环的下一个值。在某次循环中使用该函数

// 可前进到下一个值。

int lr_advance_param ( const char * param);

// lr_abort 函数中止脚本

// 的执行。它停止 Actions 部分的执行，

// 执行 vuser_end 部分，然后

// 结束该执行。当因特定的错误情况

// 需要手动中止运行时，

// 该函数非常有用。使用该函数

// 结束运行时，状态为“停止”。

void lr_abort( );

// lr_continue_on_error 函数指定如何

// 处理错误。如果发生错误，可以选择

// 继续运行，或者中止运行执行。

void lr_continue_on_error ( int value );

// lr_convert_string_encoding 在下列编码

// 之间转换字符串编码：系统区域设置、Unicode 和 UTF-8。

// 该函数将结果字符串（包括其终止

// 结果字符串 NULL）保存在参数 paramName 中。

int lr_convert_string_encoding ( const char *sourceString, const char *fromEncoding, const char

*toEncoding, const char *paramName);

// lr_debug_message 函数在指定的消息级别

// 处于活动状态时发送一条调试消息。如果指定的

// 消息级别未处于活动状态，则不发出消息。

// 您可以从用户界面

// 或者使用 lr_set_debug_message，将处于活动状态的消息级别

// 设置为 MSG_CLASS_BRIEF_LOG 或 MSG_CLASS_EXTENDED_LOG。要确定当前级

别，

// 请使用 lr_get_debug_message。

int lr_debug_message (unsigned int message_level, const char * format, ... );

// lr_decrypt 函数对已编码的字符串进行解密。

// 该函数在录制过程中生成，以便

// 对密码进行编码。VuGen 录制实际的密码，

// 但在 lr_decrypt function 函数中

// 显示密码的编码版本。

char * lr_decrypt (const char *EncodedString);

// lr_disable_ip_spoofing 在脚本运行过程中禁用 IP 欺骗。

int lr_disable_ip_spoofing ( );

// lr_enable_ip_spoofing 在脚本运行过程中启用 IP 欺骗。

int lr_enable_ip_spoofing ( );

// lr_end_sub_transaction 函数标记

// 子事务的结束。要标记子事务的

// 开始，请使用 lr_start_sub_transaction

// 函数。应紧接子事务步骤前后

// 插入这些函数。

int lr_end_sub_transaction (const char * sub_transaction, int status );

// lr_end_transaction 函数标记事务的

// 结束，并录制执行事务

// 所用的时间量。要指明希望分析的事务，

// 请在事务之前放置 lr_start_transaction

// 函数，并在事务之后

// 放置 lr_end_transaction 函数。

int lr_end_transaction (const char * transaction_name, int status ) ;

// lr_end_transaction_instance 函数标记

// 事务实例的结束，并录制

// 执行事务所用的时间量。要指明

// 希望分析的事务实例，请在

// 事务之前放置 lr_start_transaction_instance 函数，

// 并在事务之后

// 放置 lr_end_transaction_instance 函数。

int lr_end_transaction_instance (long parent_handle, int status );

// lr_end_timer 停止在调用 lr_start_timer 时开始计时的

// 计时器。它以秒为单位返回已用时间。

// 分辨率取决于运行时环境。

// 最大分辨率为一微秒。

double lr_end_timer (merc_timer_handle_t timer);

// lr_eval_string 函数在评估任何嵌入的参数之后

// 返回输入字符串。如果字符串

// 实参 (argument) 只包含一个形参 (parameter)，该函数

// 返回形参的当前值。

char * lr_eval_string (const char * instring );

// lr_eval_string_ext 函数通过将参数替换为

// 字符串值来评估 in_str。

// 它创建包含扩展字符串的缓冲区，

// 并将 out_str 设置为指向该缓冲区。它还

// 将缓冲区的长度分配给 out_len。

int lr_eval_string_ext (const char * in_string, unsigned long const in_len, char ** const out_str,

unsigned long * const out_len, unsigned long const options, const char *file, long const line );

// lr_eval_string_ext_free 函数释放

// lr_eval_string_ext 分配的内存。

void lr_eval_string_ext_free (const char **param);

// lr_error_message 函数将错误消息发送到

// 输出窗口和 Vuser 日志文件。要发送

// 不是特定错误消息的特殊通知，

// 请使用 lr_output_message。

int lr_error_message (const char * format, exp1, exp2,...expn. );

// 使用 lr_exit 函数可在执行过程中

// 退出脚本运行。

void lr_exit (int continuation_option, int exit_status);

// lr_fail_trans_with_error 函数使用

// lr_end_transaction 语句中的 LR_AUTO，将所有

// 打开事务的默认退出状态设置为 LR_FAIL，

// 并发送错误消息。

int lr_fail_trans_with_error (const char * format, exp1, exp2,...expn.);

// lr_get_attrib_double 函数返回

// 命令行参数的值，其类型为

// 双精度浮点型。应将命令行参数的名称

// 放置在函数的实参 (argument) 字段，lr_get_attrib_double 将返回

// 该参数的值。

double lr_get_attrib_double (const char * parameter);

// lr_get_attrib_long 函数返回

// 命令行参数的值，其类型为长整型。

// 应将命令行参数名称放置在

// 函数的实参 (argument) 字段，lr_get_attrib_long

// 将返回该参数的值。

long lr_get_attrib_long (const char * parameter);

// lr_get_attrib_string 函数返回命令行

// 参数字符串。应将参数名称放置在函数的

// argument 字段，lr_get_attrib_string 将返回

// 与该参数关联的字符串值。

char * lr_get_attrib_string (const char * argument);

// lr_get_debug_message 函数返回当前的

// 日志运行时设置。该设置确定

// 发送到输出端的信息。日志设置是

// 使用运行时设置对话框或通过使用

// lr_set_debug_message 函数指定的。

unsigned int lr_get_debug_message ( );

// lr_get_host_name 函数返回

// 执行脚本的计算机的名称。

char * lr_get_host_name ( );

// lr_get_vuser_ip 函数返回 Vuser 的

// IP 地址。执行 IP 欺骗时，每个 Vuser 都

// 可以使用不同的地址。使用该函数可以确定

// 当前 Vuser 的 IP 地址。

char * lr_get_vuser_ip( );

// lr_get_master_host_name 函数返回运行

// 控制器或优化模块控制台的计算机的名称。

char * lr_get_master_host_name ( );

// lr_get_transaction_duration 函数返回

// 到该点为止指定事务的持续时间（秒）

// 。使用该函数可确定

// 事务结束前的总

// 事务时间。lr_get_transaction_duration 只针对打开事务返回

// 大于零的值。

double lr_get_transaction_duration (const char * transaction);

// lr_get_transaction_status 返回事务的

// 当前状态。不能在 lr_end_transaction 之后

// 调用 lr_get_transaction_status。由于 lr_get_transaction_status

// 只能返回打开事务的状态，因此

// 无法报告最终的事务状态。

int lr_get_transaction_status ( const char *transaction_name ) ;

// lr_get_trans_instance_status 返回事务实例的

// 当前状态。不能在 lr_end_transaction_instance 之后

// 调用 lr_get_trans_instance_status。它

// 无法报告最终的事务实例状态。

int lr_get_trans_instance_status ( long transaction_handle ) ;

// lr_get_trans_instance_duration 函数返回

// 到该点为止打开事务实例的持续

// 时间（秒）。使用该函数可确定事务结束前

// 的总事务时间。

double lr_get_trans_instance_duration (long trans_handle);

// lr_get_transaction_think_time 函数返回

// 到该点为止指定事务的

// 思考时间。它只针对打开事务返回

// 大于零的值。

double lr_get_transaction_think_time (const char * transaction);

// lr_get_trans_instance_think_time 函数返回

// 到该点为止指定事务的思考时间。

double lr_get_trans_instance_think_time (long trans_handle);

// lr_get_transaction_wasted_time 函数返回

// 到该点为止指定事务的浪费时间（秒）。

double lr_get_transaction_wasted_time (const char * transaction);

// lr_get_trans_instance_wasted_time 函数返回

// 到该点为止指定事务的浪费时间。

double lr_get_trans_instance_wasted_time (long trans_handle);

// lr_load_dll 函数加载 DLL (Windows)

// 或共享对象 (UNIX)，使您可以在

// 使用 C 解释器回放时调用外部函数。加载

// DLL 之后，您就可以调用 DLL 中定义的

// 任何函数，而不必声明。

int lr_load_dll (const char *library_name );

// lr_log_message 函数将消息发送到

// Vuser 或代理日志文件（取决于应用程序），

// 而不是发送到输出窗口。通过向日志文件发送错误消息或

// 其他信息性消息，可以将

// 该函数用于调试。

int lr_log_message (const char * format, exp1, exp2,...expn.);

// lr_message 函数将消息发送到日志文件和

// 输出窗口。在 VuGen 中运行时，输出文件为 output.txt。

int lr_message (const char * format, exp1, exp2,...expn.);

// lr_output_message 函数将带有脚本部分和行号的消息

// 发送到输出窗口和日志文件。

int lr_output_message (const char * format, exp1, exp2,...expn.);

// lr_next_row 函数获取指定文件中参数的

// 下一个可用行的值。如果

// 要运行多次循环，可以在参数

// 属性中指定前进到每次循环

// 的下一行。在特定循环中使用

// 该函数，可以前进到下一组值。

int lr_next_row ( const char * dat_file );

// lr_param_increment 函数检索

// source_param 的值，并以 1 为单位递增其值，

// 然后将递增后的值作为 null 终止字符串

// 存储在 destination_param 中。

int lr_param_increment (const char * destination_param, const char * source_param);

// lr_peek_events 函数用于在脚本执行期间

// 的特定时刻接收事件。应将该函数

// 插入到 Vuser 程序中希望 Vuser 暂停的

// 位置。如果脚本中不

// 包含 lr_peek_events 函数，您将无法

// 暂停 Vuser。

void lr_peek_events ( );

// lr_rendezvous_ex 函数在 Vuser 脚本中创建

// 一个集合点。执行该语句时，

// Vuser 程序会停止并等待 LoadRunner 赋予

// 权限以便继续。

int lr_rendezvous_ex (const char * rendezvous_name);

// lr_rendezvous 函数在 Vuser 脚本中

// 创建一个集合点。执行该语句时，

// Vuser 程序会停止并等待 LoadRunner 赋予

// 权限以便继续。

int lr_rendezvous (const char * rendezvous_name);

// lr_resume_transaction 函数继续执行

// 被 lr_stop_transaction 挂起的脚本中

// 事务数据的报告。调用 lr_stop_transaction 之后，

// “get”事务函数返回的统计信息

// 只反映该调用之前的数据，

// 直到调用此函数。

void lr_resume_transaction (const char * transaction_name);

// lr_resume_transaction_instance 函数可以继续报告由

// lr_stop_transaction_instance 挂起的脚本中的

// 事务数据。

// 调用 lr_stop_transaction_instance 后，

// “get”事务函数返回的统计信息

// 只反映该调用之前的数据，直到调用

// 此函数。

void lr_resume_transaction_instance ( long trans_handle );

// lr_save_datetime 函数将当前日期

// 和时间，或具有指定偏移的日期和时间

// 保存在参数中。如果达到 MAX_DATETIME_LEN 个字符，

// 结果字符串将截断。

void lr_save_datetime(const char *format, int offset, const char *name);

// lr_save_searched_string 函数在字符串

// 或字符数组缓冲区中搜索字符串 search_string，

// 并找到 search_string 第 n 次出现的位置，其中

// n 为 occurrence 加 1。要保存的子字符串

// 从 search_string 第 n 次出现位置的末尾偏移 offset 处开始，

// 长度为 string_len。

int lr_save_searched_string (const char *buffer, long buf_size, unsigned int occurrence, const char

*search_string, int offset, unsigned int string_len, const char *parm_name );

// lr_save_string 函数将指定的以 null 终止的

// 字符串赋给参数。该函数可用于关联

// 查询。要确定参数值，请使用

// 函数 lr_eval_string。

int lr_save_string (const char *param_value, const char *param_name);

// lr_save_var function 函数将指定的变长

// 字符串赋给参数。该函数可用于

// 关联查询。要确定参数值，

// 请使用函数 lr_eval_string。

int lr_save_var (const char * param_value, unsigned long const value_len, unsigned long const

options, const char * param_name);

// lr_set_debug_message 函数设置脚本

// 执行的调试消息级别 message_lvl。通过设置

// 消息级别，可以确定发送哪些

// 信息。启用设置的方法是将 LR_SWITCH_ON 作为 on_off 传递，

// 禁用设置的方法是传递 LR_SWITCH_OFF。

int lr_set_debug_message (unsigned int message_level, unsigned int on_off);

// lr_set_transaction 函数用于在一次调用中

// 创建事务、其持续时间及

// 状态。如果要在事务中捕获的

// 业务流程不由顺序步骤组成，

// 或者是否要创建事务视

// 只有在测试过程中才可知的条件而定，

// 请使用该函数。

int lr_set_transaction(const char *name, double duration, int status);

// lr_set_transaction_instance_status 函数使用

// 事务句柄为 trans_handle 设置打开事务的

// 状态。该句柄由

// lr_start_transaction_instance 返回。

int lr_set_transaction_instance_status (int status, long trans_handle);

// lr_set_transaction_status 函数设置

// 那些在其 lr_end_transaction 语句中包含 LR_AUTO 的

// 当前打开事务的状态。

int lr_set_transaction_status (int status);

// lr_set_transaction_status_by_name 函数使用

// 名称 trans_name 设置打开事务的

// 默认状态。该事务的 lr_end_transaction

// 语句必须使用自动状态分配，方法是

// 将 LR_AUTO 作为其 status 参数传递。

int lr_set_transaction_status_by_name (int status, const char *trans_name);

// lr_start_transaction 函数标记

// 事务的开始。要指明要分析的

// 事务，请使用函数 lr_start_transaction 和

// lr_end_transaction。应紧接事务前后

// 插入这些函数。

int lr_start_transaction ( const char * transaction_name );

// lr_start_transaction_instance 函数标记

// 事务实例的开始。事务

// 实例是名为 transaction_name 的事务的一次

// 发生。实例由它们的句柄

// 标识，句柄使它们区别于

// 同一事务的其他实例。

long lr_start_transaction_instance ( const char * transaction_name, long handle);

// lr_start_sub_transaction 函数标记

// 子事务的开始。要标记子事务

// 的结束，请使用 lr_end_sub_transaction。

// 请紧接子事务操作前后

// 插入这些函数。

int lr_start_sub_transaction (const char * sub_transaction, const char * parent_transaction);

// 调用 lr_stop_transaction 后，

// “get”事务函数返回的统计信息只反映

// 该调用之前的数据，直到调用 lr_resume_transaction

// 。指定的事务必须已

// 使用 lr_start_transaction 打开。

double lr_stop_transaction (const char * transaction_name);

// 调用 lr_stop_transaction_instance 后，

// “get”事务函数返回的统计信息

// 只反映该调用之前的数据，直到调用 lr_resume_transaction_instance

// 。指定的事务实例

// 必须已使用 lr_start_transaction_instance 打开。

double lr_stop_transaction_instance (long parent_handle);

// 通过 lr_think_time 可以在运行期间暂停测试

// 执行。这对于模拟思考时间非常有用，

// 思考时间是真实用户在操作之间停下来思考的时间。

void lr_think_time (double time);

// 通过函数 lr_user_data_point，可以记录

// 自己的数据以进行分析。每次要记录一个点

// 时，请使用该函数记录采样名称和

// 值。将自动记录采样的时间。

// 执行后，可以使用用户定义的数据

// 点图形来分析结果。

int lr_user_data_point (const char * sample_name, double value);

// 除附加参数 log_flag 之外，函数 lr_user_data_point_ex

// 与 lr_user_data_point 相同。

int lr_user_data_point_ex ( const char *sample_name, double value, int log_flag);

// 除参数 transaction_handle（通过该参数可以

// 将数据点与某个特定事务实例关联起来）之外，

// 函数 lr_user_data_point_instance

// 与 lr_user_data_point 相似。

long lr_user_data_point_instance (const char * sample_name, double value, long

transaction_handle);

// 除附加参数函数 log_flag 之外，函数

// lr_user_data_point_instance_ex 与

// lr_user_data_point_instance 相同。

long lr_user_data_point_instance_ex (const char*sample_name, double value, long

transaction_handle, int log_flag);

// lr_vuser_status_message 函数向控制器

// 或优化模块控制台的 Vuser 窗口的“状态”区域

// 发送字符串。它还将该字符串

// 发送到 Vuser 日志。从 VuGen 运行时，

// 消息被发送到 output.txt。

int lr_vuser_status_message (const char * format);

// 通过 lr_wasted_time 可以从所有打开事务中

// 减去在偶然或次要的操作上浪费的时间。

void lr_wasted_time (long time);

// lr_whoami 函数获取关于 Vuser 的信息。

void lr_whoami (int *vuser_id, char **sgroup, int *scid);

// radius_account 模拟 RAS 或 NAS 服务器，该服务器

// 向 RADIUS 服务器发送记帐信息。

// 请将其插入在 radius_authenticate 调用之后、

// WAP 会话之前或过程中。

int radius_account(const char *AccountName, const char *Action, <List of Arguments>, LAST);

// radius_authenticate 模拟 RAS 或 NAS 服务器，该服务器

// 在允许用户访问 WAP 网关之前，

// 向 RADIUS 服务器发送用户的身份验证信息。

// 请将其插入在调用 wap_connect 之前。

int radius_authenticate(<List of Arguments>, LAST);

// radius_get_last_error 返回最近的 RADIUS

// 函数调用的错误代码。

int radius_get_last_error ();

// radius_set_timeout 为函数 radius_authenticate

// 和 radius_account functions 设置连接超时值。它

// 会覆盖 RADIUS 运行时设置中的超时值

// 设置。参数 Timeout 是以秒为单位的超时值

// 的字符串表示。例如“5”。

int radius_set_timeout (const char *Timeout);

// wap_add_const_header 函数向常量头列表中

// 添加一个头。当建立 CO 类型的连接时，这些头

// 被传送至网关。

int wap_add_const_header ( const char *mpszHeader, const char *mpszValue );

// wap_bearer_down 可以断开与承载网络的连接。

// 载体是 WAP 网络的最底层服务。

// 有关详细信息，请参阅 wap_bearer_up。

int wap_bearer_down();

// wap_bearer_up 可以连接到承载网络。承

// 载体是 WAP 网络的最底层服务。

// 当测试只包括 SMS 消息时该函数非常有用，

// 使您不必使用 wap_connect 连接至

// WAP 网关。

int wap_bearer_up();

// wap_connect 函数可以连接至 WAP 网关，网关的

// IP 地址和端口在运行时设置中指定。

int wap_connect ( );

// wap_disconnect 函数可以断开与 WAP 网关的连接。

// 连接是通过调用 wap_connect 或 web_url 打开的。

int wap_disconnect ( );

// wap_format_si_msg 函数可以格式化 SI 类型的消息。

int wap_format_si_msg (const char * mpszURL, const char * Slid, const char * mpszCreated,

const char * mpszExpires, const char * mpszAction, const char * mpszUserMsg, char *

mpsfOutputMsg, unsigned int miOutputMsglen );

// wap_format_sl_msg 函数可以格式化 SL 类型的消息。

int wap_format_sl_msg (const char * mpszURL, const char * mpszAction, char *

mpsfOutputMsg, unsigned int miOutputMsglen );

// wap_mms_msg_decode 函数可以将字符串转换为

// MMS 消息对象。通常，该字符串

// 是接收到的 HTTP 消息的正文。

int wap_mms_msg_decode(void **MMSObject, const char *ParamName);

// wap_mms_msg_encode 函数可以将

// wap_mms_msg_create 创建的 MMS 消息对象 (MMSObject)

// 转换为字符串，该字符串随后可用于 Web 操作函数。

// 该方法不同于使用 wap_mms_msg_submit

// 或 as_wap.h 头文件中的其他宏，后者

// 直接接受 MMS 消息对象。

int wap_mms_msg_encode(void *MMSObject, const char *ParamName);

// wap_mms_msg_get_field 从 MMSObject 中

// 检索指定字段 FieldName 的值，

// 并将其存储在参数 ParamName 中。

int wap_mms_msg_get_field(void *MMSObject, const char *FieldName, const char

*ParamName);

// wap_mms_msg_get_multipart_entry 从 MMSObject

// 中的多部分项 EntryNumber 中

// 检索指定字段 FieldName 的值，

// 并将其存储在参数 ParamName 中。

int wap_mms_msg_get_multipart_entry(void *MMSObject, unsigned int EntryNumber, const

char *FieldName, const char *ParamName);

// wap_mms_msg_number_multipart_entries 可以检索

// MMSObject 中多部分项的数目。

int wap_mms_msg_number_multipart_entries(void *MMSObject, unsigned int

*NumberOfEntries);

// wap_pi_push_submit 函数可以向 PPG 提交一个“推”消息。

int wap_pi_push_submit(const char * mpszName, const char * mpszURL, const char *

mpszPushID, const char * mpszClientAddress, const char * mpszDeliverBefore, const char *

mpszDeliverAfter, const char * mpszMsgSource, const char * mpszMsgType, const char *

mpszMsgContent);

// wap_pi_push_submit_ex 函数可以向 PPG 提交一个“推”消息。

int wap_pi_push_submit_ex(const char * mpszName, const char * mpszURL, const char *

mpszPushID, const char * mpszClientAddress, const char * mpszDeliverBefore, const char *

mpszDeliverAfter, const char * mpszMsgSource, const char * mpszMsgType, const char *

mpszMsgContent [, CustomAttributes]);

// wap_pi_push_cancel 函数可以取消一个发送到 PPG 的消息。

int wap_pi_push_cancel(const char * mpszName, const char * mpszURL, const char *

mpszPushID, const char * mpszClientAddress);

// wap_radius_connection 已过时。请使用

// radius_authenticate 和 radius_account。

int wap_radius_connection (const char * mpszAction, <List of Arguments>, LAST);

// wap_set_bearer 函数可以设置用于重放

// UDP 或 CIMD2 (SMS) 的载体类型。脚本使用该

// 载体类型，直到脚本结束或

// 再一次调用函数 wap_set_bearer 进行设置。

int wap_set_bearer ( const char *mpszBearer );

// wap_set_capability 函数可以设置网关连接的

// 客户端容量。建立网关连接时，

// 将对这些容量进行协商。

int wap_set_capability ( const char *mpszCap );

// wap_set_connection_mode 函数可以设置会话的连接

// 模式和安全级别。需要指明

// 连接的连接模式类型

// 和安全级别。该函数只对以后的

// 连接有效。如果连接已经建立，

// 则忽略该函数。

int wap_set_connection_mode( const char * ConnectionMode,

const char * SecurityLevel);

// wap_set_connection_options 可以设置：IP 地址和端口

// （通过它们与网关通信）、连接

// 模式、安全级别和载体类型

int wap_set_connection_options( const char *argument_list, ..., LAST);

// wap_set_gateway 函数可以设置 IP 地址和

// 端口，通过它们可以与网关通信。

int wap_set_gateway( const char * GateWayIP, const char * GateWayPort );

// wap_set_sms_user 可以设置 SMS 载体

// 的登录信息。可以在“运行时设置”的

// “网关”选项卡中设置载体的端口和

// 登录信息。该函数必须位于 wap_connect

// 或第一个 web_url 函数之前。

int wap_set_sms_user (const char *argument_list, ..., LAST);

// wap_wait_for_push 函数等待一个“推”消息

// 到达。如果超时前有消息到达，

// 则解析该消息，以确定其类型和

// 消息属性的值。如果解析成功，

// 客户端会发出一个“拉”消息，以检索

// 相关数据。通过配置运行时设置，可以禁用“拉”事件，

// 指明不检索消息

// 数据。在文件 default.cfg 中找到

// WAP 部分。将标志 PushRetrieveMsg 设置为

// 1 可以检索消息（默认），设置为 0 可以

// 禁止消息。

int wap_wait_for_push ( );

// wap_mms_msg_destroy 函数可以销毁

// 使用 wap_mms_msg_create 或 wap_mms_msg_decode 创建的消息。

// 请在已确认消息后将该函数放置在

// 脚本末尾。如果会话结束时

// 不销毁 MMS 消息，它将使用额外

// 资源并影响性能。

int wap_mms_msg_destroy (void * MMSObject );

// wap_mms_msg_create 函数可以创建消息。

// 请在建立与服务器的连接后

// 将该函数放置在脚本开头。

// 在会话结束时，请使用函数 wap_mms_msg_destroy

// 销毁该消息。

int wap_mms_msg_create (void **MMSObject );

// wap_mms_msg_add_field 函数可以向 MMS 消息添加消息字段，

// 添加的内容包括字段名和值。可以

// 在脚本中多次使用该函数。

int wap_mms_msg_add_field (void * MMSObject, const char * FieldName,

const char * FieldValue );

// wap_mms_msg_add_multipart_entry 函数可以向 MMS 消息

// 添加多部分项。项

// 可以是字符串（在最后一个参数中指定），

// 也可以是外部文件。可以在脚本中

// 多次使用该函数。

int wap_mms_msg_add_multipart_entry (void ** MMSObject,

const char *DataSource, const

char * ContentType,

const char *Headers, const char * Data );

// wap_mms_msg_retrieve 函数可以向 MMS 中心

// 发送请求，以获得 URL 处的消息。MMS

// 中心将消息写入 Message。它作为

// 文件 as_wap.h 中的一个宏实现。

void wap_mms_msg_retrieve (Name, URL, Message);

// wap_mms_msg_retrieve_by_push 函数等待

// “推”消息到达。收到

// 该消息后，客户端将发出一个“拉”消息，

// 以检索相关数据。

void wap_mms_msg_retrieve_by_push (Message);

// wap_mms_msg_submit 函数可以向 MMS 服务器

// 发送消息 MMSMessage。它作为

// 文件 as_wap.h 中的一个宏实现。

void wap_mms_msg_submit (Name, URL, Message);

// wap_mms_msg_submit 函数使用指定的内容类型

// 向 MMS 服务器发送消息 MMSMessage。它作为

// 文件 as_wap.h 中的一个宏实现。

void wap_mms_msg_submit_enc (Name, URL, Message, EncodingType );

// wap_mms_msg_submit_and_receive_enc 函数使用指定的

// 内容类型向 MMS 服务器发送消息 Message，

// 并在返回前同步接收响应

// ReceivedMMS。它作为

// 文件 as_wap.h 中的一个宏实现。

void wap_mms_msg_submit_and_receive_enc (Name, URL, Message, ReceivedMMS,

EncodingType );

// wap_mms_msg_submit_and_receive 函数向 MMS 服务器

// 发送消息 Message，并在返回前

// 同步接收响应 ReceivedMMS。

// 它作为文件 as_wap.h 中的一个宏实现。

void wap_mms_msg_submit_and_receive(Name, URL, Message, ReceivedMMS);

// wap_push_msg_get_field 从最近收到的

// “推”消息中检索字段 FieldName 的值。

// 检索到的值存储在参数 ParamName 中。

int wap_push_msg_get_field(const char *FieldName, const char *ParamName);

// wap_send_sms 函数向指定地址发送一个 SMS

// 类型的消息。

int wap_send_sms (const char * List of Arguments, LAST);

// web_add_auto_header 函数是一个服务函数，

// 它向所有后续 HTTP 请求添加头。

int web_add_auto_header (const char *Header, const char *Content );

// web_add_cookie 函数可以添加新的 Cookie。如果

// 名称和路径与现有 Cookie 匹配，则现有

// Cookie 被新 Cookie 覆盖。如果已过“过期”

// 日期，则删除该 Cookie。

int web_add_cookie (const char *Cookie);

// web_add_filter 指定下载下一个操作函数中的内容时

// 要使用的筛选器。

// 筛选器将包含或排除含有匹配条件的 URL，

// 视传递到该函数的 Action 属性

// 而定。默认

// 操作为“Action=Exclude”。

int web_add_filter ( [Action,]< List of Attributes >, LAST ) ;

// web_add_auto_filter 指定下载随后发生的操作函数的内容

// 时要使用的筛选器。

// 调用 web_remove_auto_filter 后，将禁用

// 该筛选器。筛选器将包含或排除含有匹配条件的 URL，

// 视传递到该函数的 Action 属性

// 而定。默认

// 操作为“Action=Exclude”。

int web_add_auto_filter ( [Action,]< List of Attributes >, LAST);

// web_remove_auto_filter 函数可以禁用

// 上次调用 web_add_auto_filter 时的筛选器设置。

int web_remove_auto_filter ( char *Id, LAST );

// web_add_header 函数是一个服务函数，

// 它向下一个 HTTP 请求添加用户定义的头。

int web_add_header (const char *Header, const char *Content );

// web_cache_cleanup 函数是一个服务函数，

// 它清除缓存模拟程序中的内容。

// 如果在“浏览器模拟”选项卡上启用运行时

// 设置选项“每次循环时模拟一个新用户”，

// 则该函数会在每次循环开始时

// 自动调用。

int web_cache_cleanup();

// web_cleanup_auto_headers 函数是一个

// 服务函数，它会禁止向后续 HTTP 请求

// 添加用户定义的头。

int web_cleanup_auto_headers ( );

// web_cleanup_cookies 函数删除脚本使用的

// 所有当前存储的 Cookie。

int web_cleanup_cookies ( );

// web_concurrent_end 函数可以标记

// 并发组的结束，并开始并发执行所有注册

// 为并发的函数（位于函数

// web_concurrent_start 和

// web_concurrent_end 之间的函数）。

// 单击“并发函数”，以查看并发组中可能

// 包含的函数的列表。

int web_concurrent_end ( reserved );

// web_concurrent_start 函数可以

// 标记并发组的开始。组中的所有函数

// 均并发执行。组的结束由函数

// web_concurrent_end 标记。在并发组

// 中可以包含操作函数和几个服务函数。

// 单击“并发函数”，以查看并发组中可能

// 包含的函数的列表。

//

int web_concurrent_start ( [char * ConcurrentGroupName,] NULL );

// web_convert_param 函数将 HTML 文本

// 转换为纯文本或 URL，或将纯文本转换为 URL。

int web_convert_param (const char *ParamName, [char *SourceString] char *SourceEncoding,

char *TargetEncoding, LAST);

// web_create_html_param 函数是一个服务

// 函数，用于在 Web 脚本中关联 HTML 语句。

// 函数 web_create_html_param

// 检索重放期间生成的动态信息，然后将

// 第一次出现的动态信息保存在某个

// 参数中。

int web_create_html_param (const char *ParamName, const char *LeftBoundary, const char

*RightBoundary );

// web_create_html_param_ex 函数是一个服务

// 函数，用于在 Web 脚本中关联 HTML 语句。

// 函数 web_create_html_param_ex 检索重放

// 期间生成的动态信息，然后将该动态信息保存在

// 某个参数中。

int web_create_html_param_ex (const char *ParamName, const char *LeftBoundary, const char

*RightBoundary, const char *Instance );

// web_custom_request 函数是一个操作函数，

// 通过它可以使用任意方法创建自定义 HTTP 请求

// 或创建正文。默认情况下，VuGen 只为无法

// 用其他 Web 函数解释的请求生成该函数。

//

int web_custom_request (const char *RequestName, <List of Attributes>, [EXTRARES, <List of

Resource Attributes>,] LAST );

// web_disable_keep_alive 函数是一个服务

// 函数，它禁用 Keep–Alive HTTP 连接。

// 默认情况下，KeepAlive 设置处于启用状态。

int web_disable_keep_alive ( );

// web_dump_cache 保存浏览器缓存。它与

// web_load_cache 一起使用，以实现 Vuser

// 持续缓存。脚本始终使用相同的初始缓存运行。

int web_dump_cache ( const char *Name, const char * fileName, [ const char * Replace], LAST );

// web_enable_keep_alive 函数是一个服务

// 函数，它启用 Keep–Alive HTTP 连接。

int web_enable_keep_alive ( );

// web_find 函数在 HTML 页中搜索指定的文本字符串。

int web_find (const char *StepName, <Attributes and Specifications list>, char *searchstring,

LAST );

// web_get_int_property 函数返回

// 关于上一个 HTTP 请求的指定信息。

int web_get_int_property (const int HttpInfoType);

// web_global_verification 函数注册

// 一个请求，以在所有后续操作函数返回的

// 网页中搜索指定的文本字符串。这与函数

// web_reg_find 不同，后者只为下一个

// 操作函数注册请求。可以搜索页面的正文、

// 头、HTML 代码或全部内容。

//

int web_global_verification (<List of Attributes>, LAST );

// 操作函数 web_image 模拟

// 鼠标单击由属性定义的图像。

// 该函数只能在上一个操作

// 的上下文中执行。

int web_image (const char *StepName, <List of Attributes>, [EXTRARES, <List of Resource

Attributes>,] LAST );

// web_image_check 函数可以验证 HTML 页中

// 包含指定图像。

int web_image_check(const char *CheckName, <List of Attributes>, <"Alt=alt"|| "Src=src">,

LAST );

// web_link 函数是一个操作函数，

// 它模拟鼠标单击由属性定义的

// 链接。web_link 只能在上一个

// 操作的上下文中执行。

int web_link (const char *StepName, <List of Attributes>, [EXTRARES, <List of Resource

Attributes>,] LAST );

// web_remove_cookie 函数从一个对 Vuser

// 可用的 Cookie 列表中删除一个 Cookie。该函数

// 指定要删除的 Cookie 的名称。

int web_remove_cookie (const char *Cookie);

// web_load_cache 可以从文件中还原浏览器

// 缓存。它与 web_dump_cache 一起

// 使用，以实现 Vuser 持续缓存。脚本

// 始终使用相同的初始缓存运行。

int web_load_cache ( const char *Name, const char * fileName, LAST );

// web_reg_add_cookie 函数注册一个搜索，

// 在下一个操作函数（如 web_url）检索到的网页上

// 搜索一个文本字符串。如果

// 找到了字符串，将添加 Cookie。

int web_reg_add_cookie(const char * cookie, const char * searchstring, LAST );

// web_reg_find 函数注册一个请求，以

// 在下一个操作函数（如 web_url）检索到

// 的网页上搜索一个文本字符串。

int web_reg_find (const char *attribute_list, LAST);

// web_reg_save_param 是一个注册类型

// 的函数。它注册一个请求，以在检索到的

// 网页中查找并保存一个文本字符串。只有

// 在执行了下一个操作函数（如 web_url）后

// 才会执行该操作。

int web_reg_save_param (const char *ParamName, <List of Attributes>, LAST);

// web_remove_auto_header 函数是一个服务

// 函数，它停止向后续 HTTP 请求添加特定的用户

// 定义头。该函数将取消由 web_add_auto_header

// 启动的指定头的自动头生成。

//

int web_remove_auto_header (const char *Header, char *Implicit, LAST);

// web_revert_auto_header 函数是一个服务

// 函数，它停止向后续 HTTP 请求添加特定的用户

// 定义头。该函数将取消由 web_add_auto_header

// 启动的指定头的自动头生成。它不断生成隐性头，

// 如同不曾调用过函数 web_add_auto_header

// 或 web_remove_auto_header 一样。

int web_revert_auto_header (char *Header);

// web_report_data_point 函数在脚本中

// 定义要包括在测试结果中的数据点。最常见的

// 数据点是步骤超时，它表明上一个步骤是否超时。

//

int web_report_data_point ( const char * EventType, const char * EventName , const char *

DataPointName , LAST );

// web_save_header 函数将所有随后

// 发生的操作函数的主 URL 的请求和

// 响应头保存在参数 param 中。每个头由

// “\r\n”（或仅“\n”）分隔。每个新的

// 请求头将替换参数的当前值。

int web_save_header (const char *type, const char *param );

// web_save_param_length 创建名为

// “<Param>_Length”的新参数（如果尚无该参数），

// 并将 Param 的长度保存在参数“<Param>_Length”

// 中。该长度采用十六进制格式。

int web_save_param_length( const char *Param, LAST );

// web_save_timestamp_param 保存当前

// 时间戳。在某些应用中，VuGen 用一个参数

// 替换脚本中的所有非空时间戳。为了保存

// 该参数的值，VuGen 自动生成对

// web_save_timestamp_param 的调用。

// 保存的值是自 1970 年 1 月 1 日午夜

// 开始的毫秒数。

int web_save_timestamp_param( const char * tmstampParam, LAST );

// web_set_certificate 指定一个证书在

// 证书列表中的编号。然后，只要某个安全的

// Web 服务器需要客户端提供证书，就使用

// 指定的证书。

int web_set_certificate (const char *CertificateNumber);

// web_set_certificate_ex 设置证书

// 和关键文件属性，如位置、类型和密码。

// 该信息用于需要证书的 HTTPS 请求。

// 所有参数都是以 null 终止的字符串。

// 关键字不区分大小写；但属于关键字

// 的值是区分大小写的。关键字

//

// 值的开头和末尾不允许出现

// 空格。注意，只有使用 Internet Explorer

// 时才录制该函数。

int web_set_certificate_ex (const char *option_list, LAST);

// web_set_connections_limit 函数是

// 一个服务函数，它设置脚本执行期间可以行

// 同时运的最大请求数。

// 在加载页面资源或加载框架集页面

// 中的框架等情形下，会发出

// 多个请求。任何 Vuser 的默认限制为

// 可以同时发出四个请求。

int web_set_connections_limit (const char *Limit );

// web_set_max_html_param_len 函数是

// 一个服务函数，用于关联 HTML 语句。

// 仅当启用“在录制过程中关联”时

// 才录制该函数（请参阅 VuGen 的录制选项）。

int web_set_max_html_param_len (const char *length );

// web_set_max_retries 函数设置操作的

// 最大重试次数。当发生错误时，对于 HTTP

// 响应消息 500-599 和网络 API 错误

// （HttpSendRequest 等），会尝试进行

// 重试。对于超时或函数参数错误，不尝试

// 进行重试。

int web_set_max_retries (const char *MaxRetries );

// web_set_option 函数设置 Web 选项。

// 它是一个服务函数，影响其后的所有函数，

// 直到指定了新值。vuser_init 部分

// 结束运行时，将保存当前选项值。

// 在每次循环开始之前，这些值将还原为

// 保存的值。

int web_set_option (const char *OptionID, const char * OptionValue, LAST );

// web_set_proxy 函数是一个服务函数，

// 它指定将所有后续 HTTP 请求定向

// 到指定的代理服务器。要直接向服务器

// 提交 HTTP 请求（即不使用代理

// 服务器），请使用函数 web_set_proxy

// 传递一个空字符串 ("") 作为参数。

int web_set_proxy (const char *proxy_host:port );

// web_set_proxy_bypass 函数是一个服务函数，

// 它指定要直接访问的 URL 的列表，该访问会避开

// 代理服务器。可以在避开的 URL 列表中包含 <local>，

// 以使所有本地主机（如 Intranet 服务器）

// 都避开代理服务器。

int web_set_proxy_bypass (const char *bypass1..n );

// web_set_proxy_bypass_local 函数是

// 一个服务函数，它指定代理服务器是否应

// 避开本地 (Intranet) 地址。该函数会覆盖

// 运行时设置代理选项“对本地 (intranet)

// 地址不使用代理服务器”。如果代理避开

// 字符串包含 <local>，则该函数

// 和 UI 复选框都将没有以下效果：将

// 始终避开本地地址。

int web_set_proxy_bypass_local ( const char *no_local );

// web_set_secure_proxy 函数是一个服务函数，

// 它指定将所有后续 HTTPS 请求

// 定向到指定的安全代理服务器。

int web_set_secure_proxy (const char *secure_proxy_host_port );

// web_set_sockets_option 函数配置

// 客户端上的套接字选项。对于启用或禁用

// 某项功能（如 TRACE_SSL_IO）的选项，

// 请指定“1”以启用，指定“0”以禁用。

// 以下列表显示了支持的选项：

int web_set_sockets_option( const char *option, const char * value );

// web_set_timeout 函数是一个服务函数，它

// 指定 CONNECT、RECEIVE 或 STEP 操作完成

// 之前等待的最长时间。

int web_set_timeout (const char *Action, const char *TimeOut );

// web_set_user 函数是一个服务函数，它

// 指定 Web 服务器或代理服务器的登录字符串

// 和密码。如果多个代理服务器需要身份验证，

// 可以多次调用该函数。web_set_user

// 会覆盖运行时代理身份验证的用户名和密码

// 设置。

int web_set_user (const char *username, const char *password, const char *host:port );

// web_sjis_to_euc_param 函数将一个 SJIS 编码的

// 以 null 终止的字符串转换为 EUC 编码的字符串，并将它

// 赋给参数。可以使用函数 lr_eval_string

// 确定参数的值。

int web_sjis_to_euc_param (LPCSTR param_name, LPCSTR param_value_in_SJIS);

// web_submit_data 函数是一个操作函数，

// 它执行“无条件的”或“无上下文的”表单

// 提交。通过它可以生成 GET 和 POST

// 请求，如同由 HTML 表单生成的请求。执行该请求

// 不需要有表单上下文。

int web_submit_data ( const char *StepName, <List of Attributes>, ITEMDATA, <List of data>,

 [ EXTRARES, <List of Resource Attributes>,] LAST );

// web_submit_form 函数是一个操作函数，它

// 可以提交表单。函数 web_submit_form 只能在上一

// 操作的上下文中执行。

int web_submit_form (const char *StepName, <List of Attributes>, <List of Hidden Fields>,

ITEMDATA, <List of Data Fields>, [ EXTRARES, <List of Resource Attributes>,] LAST );

// 通过 web_switch_net_layer 函数，可以在

// 要重放的网络层间切换。通过它可以在同一

// 脚本中混用直接的 HTTP 和 WSP 调用。目前，

// 该函数只影响 WAP Vuser。

int web_switch_net_layer (const char *NetName);

// web_url 函数是一个操作函数，它可以加载

// 指定的网页（GET 请求）。函数 web_url

// 可以加载 URL 属性指定的 URL。函数 web_url

// 不需要上下文。

int web_url (const char *Name, const char * url, <List of Attributes>, [EXTRARES, <List of

Resource Attributes>,] LAST );

// web_browser 操作函数直接在打开的

// 浏览器上执行操作。

int web_browser (const char *stepName, [const char *snapShot,] [DESCRIPTION, const char

*browser,] ACTION, const char *userAction, LAST );

// web_button 操作函数模拟用户单击按钮。

int web_button (const char *stepName, [const char *snapShot,] DESCRIPTION, [const char

*type,] [const char *tag,] [const char *arg1, … const char *argn,] LAST );

// web_check_box 操作函数选择或清除

// 复选框。如果 setOnOff 为“Set=ON”，则选中复选框。

// 如果 setOnOff 为“Set=OFF”，则清除复选框。

int web_check_box (const char *stepName, [const char *snapShot,] DESCRIPTION, const char

*arg1, … const char *argn, ACTION, const char *setOnOff, LAST );

// web_edit_field 函数在文本或密码输入元素

// 中输入 setValue。

int web_edit_field (const char *stepName, [const char *snapShot,] DESCRIPTION, [const char

*type,] [const char *arg1, … const char *argn,] ACTION, const char *setValue, LAST );

// 永远不录制 web_eval_java_script。

// 可以在脚本中添加该函数，以处理没有

// 标准解决方案的情况。该函数有三种

// 用法，语法各不相同。请勿混淆不同语法

// 的参数。请勿在语法 1 或语法 2 中使用

// PrintProperties，勿在语法 2 或语法 3

// 中使用 script，以及勿在语法 1 或语法 3 中使用

// Expression 和 SaveExpressionResult。

int web_eval_java_script ( const char *stepName, const char *script, [DESCRIPTION, const char

*arg1, …, const char *argn,] LAST );

// web_file 在形如 <INPUT TYPE=FILE NAME=”Name”>

// 的元素中输入文件名 SetPath。

int web_file ( const char *StepName, DESCRIPTION, [<List of attributes>], ACTION, const char

* SetPath, LAST );

// web_image_link 操作函数模拟用户

// 单击图像（该图像是超文本链接）。

int web_image_link (const char *stepName, [const char *snapShot,] DESCRIPTION, const char

*arg1, … const char *argn, [ACTION, const char *clickCoordinates,] LAST );

// web_image_submit 操作函数模拟用户

// 单击类型为“image”的输入元素。

int web_image_submit (const char *stepName, [const char *snapShot,] DESCRIPTION, const

char *arg1, … const char *argn, ACTION, const char *clickCoordinates, LAST );

// web_list 函数模拟用户在列表框

// 中选择一项。选择项可以通过

// 选择项的文本或其位置识别。

// 第一个选项的位置为 1。

int web_list (const char *stepName, [const char *snapShot,] DESCRIPTION, const char *type,

[const char *arg1, … const char *argn,] ACTION, const char *selectAction, [const char

*ordinalSelectAction,] LAST );

// web_map_area 函数可以激活客户端映射的一个

// 区域。无论该区域如何激活，都将录制该函数。通常，

// 用户单击一个区域会激活该区域。

int web_map_area (const char *stepName, [const char *snapShot,] DESCRIPTION, const char

*mapName, const char *arg1, … const char *argn, LAST );

// web_radio_group 操作函数模拟用户

// 在单选按钮组中选择一个按钮。

int web_radio_group (const char *stepName, [const char *snapShot,] DESCRIPTION, const char

*name, const char *arg1, … const char *argn, ACTION, const char *selection, LAST );

// web_reg_dialog 服务函数可以注册

// Java 脚本使用的信息。

int web_reg_dialog (DESCRIPTION, const char *type, [const char *message,][const char

*browser,] ACTION, const char *userAction, LAST );

// web_static_image 模拟用户单击图像。

// 如果 IMG 元素被具有 HREF 属性的 <A> 元素

// 围起，则它是一个链接，该函数无效。在这种

// 情况下，请使用 web_image_link。

int web_static_image ( const char *StepName, DESCRIPTION, <List of attributes>, LAST );

// web_text_area 操作函数在文本区域中输入 setText。

int web_text_area (const char *stepName, [const char *snapShot,] DESCRIPTION, const char

*arg1, … const char *argn, ACTION, const char *setText, LAST );

// web_text_link 操作函数模拟

// 用户单击超文本链接。

int web_text_link (const char *stepName, [const char *snapShot,] DESCRIPTION, [const char

*text, ][const char *arg1, … const char *argn,] LAST );

// lrs_accept_connection 函数从

// old_socket 上的挂起连接队列中

// 取出第一个连接，使用相同属性创建

// 新的套接字。原来的套接字对于其他

// 连接仍然可用。

int lrs_accept_connection ( char *old_socket, char *new_socket );

// lrs_ascii_to_ebcdic 函数可以将二进制

// 缓冲区数据从 ASCII 格式转换为 EBCDIC 格式。

// 转换后的缓冲区以 EBCDIC 格式存储在内部缓冲区

// （用户缓冲区）中。要检索缓冲区的内容，请使用

// lrs_get_user_buffer。要确定缓冲区大小，

// 请使用 lrs_get_user_buffer_size。

char *lrs_ascii_to_ebcdic ( char *s_desc, char *buff, long length );

// lrs_cleanup 函数终止使用 Windows

// Sockets DLL（类似于 WSACleanup）

// 和系统资源，如释放文件描述符。请检查

// 返回代码，以验证清理成功。

int lrs_cleanup ( );

// lrs_close_socket 函数释放指定的

// 套接字描述符，以关闭套接字。再次引用

// 该套接字将会导致错误 WSAENOTSOCK。

// 如果这是对基础套接字的最后一次引用，

// 将丢弃相关的命名信息和队列数据。

// 注意，对于 TCP 套接字，函数

// lrs_close_socket 会将所有尚未发送

// 的数据发送出去。

int lrs_close_socket ( char *s_desc );

// lrs_create_socket 函数初始化一个套接字。

// 它执行 socket 命令，打开新的套接字。

// 如果提供了 LocalHost 参数，它会执行

// bind 命令，以命名该套接字。如果提供了 peer 参数，

// 它会执行 connect 命令，以建立与对等端的

// 连接。如果提供了 backlog 参数，它

// 会执行 listen 命令侦听该套接字。

int lrs_create_socket ( char *s_desc, char *type, [ char* LocalHost,] [char* peer,] [char *backlog,]

LrsLastArg );

// lrs_decimal_to_hex_string 函数可以将整数

// 转换为十六进制字符串。例如，如果字符串为

// 4，则该函数将它转换为 \x04。

char* lrs_decimal_to_hex_string( char* s_desc, char* buf, long length);

// lrs_disable_socket 函数禁止套接字的一项

// 操作。可以禁止所有的发送和/或接收操作。

int lrs_disable_socket ( char *s_desc, int operation );

// lrs_ebcdic_to_ascii 函数将二进制缓冲区

// 数据从 EBCDIC 格式转换为 ASCII 格式。转换后

// 的缓冲区以 ASCII 格式存储在内部缓冲区

// （用户缓冲区）中。要检索缓冲区的内容，

// 请使用 lrs_get_user_buffer。要确定缓冲区

// 的大小，请使用 lrs_get_user_buffer_size。

char *lrs_ebcdic_to_ascii ( char *s_desc, char *buff, long length );

// lrs_exclude_socket 函数排除指定

// 套接字的所有操作。脚本中从该函数开始

// 向后的所有使用该指定套接字的函数都

// 将被忽略。建议将该函数放在脚本的

// vuser_init 部分。排除对脚本所有

// 部分中的套接字函数都有效。

//

int lrs_exclude_socket ( char *s_desc );

// lrs_free_buffer 函数释放为指定缓冲区分配的

// 内存。内存是在调用函数 lrs_get_buffer_by_name

// 或 lrs_get_last_received_buffer 时

// 分配的。

int lrs_free_buffer ( char *buffer );

// 对于指定的缓冲区描述符，函数

// lrs_get_buffer_by_name 获取

// 二进制缓冲区以及数据二进制表示的长度。

// 注意，数据缓冲区不是以 NULL 终止的。

int lrs_get_buffer_by_name ( char *buf_desc, char **data, int *size );

// lrs_get_last_received_buffer 函数获取

// 套接字上最后收到的缓冲区及其大小。注意，该

// 函数返回数据二进制表示的长度。数据缓冲区

// 不是以 NULL 终止的。

int lrs_get_last_received_buffer ( char *s_desc, char **data, int *size );

// lrs_get_last_received_buffer_size 函数

// 获取套接字 s_desc 上最后收到的缓冲区的

// 大小。注意，该函数返回数据二进制表示的

// 长度。

int lrs_get_last_received_buffer_size ( char *s_desc );

// lrs_get_received_buffer 函数检索

// 最后一次调用 lrs_receive、lrs_receive_ex

// 或 lrs_length_receive 收到的缓冲区的全部

// 或其一部分。请指定要检索的数据的

// 偏移量和长度。

char *lrs_get_received_buffer ( char *s_desc, int offset, int length, char *encoding );

// lrs_get_static_buffer 函数检索

// 来自数据文件的静态缓冲区或其一部分。

// 请指定缓冲区及要检索的数据的偏移量

// 和长度。该缓冲区在发生任何参数替换后

// 返回。

char *lrs_get_static_buffer ( char *s_desc, char *buffer, int offset, int length, char *encoding );

// lrs_get_socket_attrib 函数检索

// 指定的套接字属性。通过它可以获取有关

// 套接字的信息。只能从绑定或连接到某个

// 套接字的套接字检索属性。要将一个套接字

// 绑定到现有套接字，请使用 lrs_create_socket(…LocalPort=…)。

// 要连接到一个套接字，请使用 lrs_create_socket(…RemoteHost=…)。

char *lrs_get_socket_attrib ( char *s_desc , int attribute );

// lrs_get_socket_handler 函数检索指定

// 套接字的套接字句柄。检索到套接字句柄后，

// 可以在后续函数中使用。

int lrs_get_socket_handler ( char *s_desc );

// lrs_get_user_buffer 函数检索指定套接字的

// 用户数据缓冲区的内容。

char *lrs_get_user_buffer ( char *s_desc );

// lrs_get_user_buffer_size 函数检索指定套接字的

// 用户数据缓冲区的大小。

long lrs_get_user_buffer_size ( char *s_desc );

// lrs_hex_string_to_int 将一个

// 十六进制字符串转换为整数。请指定

// 指向包含要转换字符串的缓冲区的指针

// 及要转换字符串的长度。该函数将转换

// 字符串并赋值给整型引用。

int lrs_hex_string_to_int ( char* buff, long length, int* mpiOutput );

// lrs_length_receive 函数将指定长度的

// 数据从 sock_descriptor 读入缓冲区。

// 长度位于接收到的缓冲区自身内部。用户

// 必须知道该长度值位于缓冲区内何处

// （除非选择了 RecieveOption_None

// 选项），其位置通过参数 location_option

// 和 locators 指定。lrs_length_receive

// 首先获得长度值（下面称为 length），

// 再将 length 个字符从 socket_descriptor

// 读入缓冲区。

int lrs_length_receive(char *socket_descriptor, char *buffer, int location_option, [char* locators],

[char* additional_params], LrsLastArg );

// lrs_length_send 函数将指定

// 长度的数据从 sock_descriptor 于

// 写入 buffer。它用发送参数化数据，

// 每次调用该函数时数据的长度可以

// 不同。使用 lrs_length_send 可以

// 不必每次计算长度，因为 Vugen

// 自动将正确的数据长度写入由参数

// locator 和 location_option

// 指定的字段。

int lrs_length_send(char *socket_descriptor, char *buffer, int location_option, [char* locators],

[char* additional_params], LrsLastArg );

// lrs_receive 函数从数据报或流式套接字

// 读取输入数据。如果套接字上没有输入

// 数据，lrs_receive 将等待数据到达，

// 除非套接字是非分块套接字。

int lrs_receive ( char *s_desc, char *bufindex, [char *flags], LrsLastArg );

// lrs_receive_ex 函数从数据报或

// 流式套接字的输入数据中读取指定数目

// 的字节。除了可以指定要接收字节

// 数的功能外，它与函数 lrs_receive

// 等价。

int lrs_receive_ex ( char *s_desc, char *bufindex, [char *flags,] [char *size,]

[char

*terminator,] [char *mismatch,] [char *RecordingSize,]

LrsLastArg );

// lrs_save_param 函数将数据从缓冲区保存

// 到参数中。该函数用于关联或链接脚本中的

// 语句。

int lrs_save_param ( char *s_desc,char *buf_desc, char *param_name, int offset, int param_len);

// lrs_save_param_ex 函数将缓冲区或

// 缓冲区的一部分保存到参数中。参数 type

// 指定要保存的缓冲区数据的类型：用户缓冲区、

// 录制缓冲区或最后接收的缓冲区。该函数

// 会覆盖用户数据区。

int lrs_save_param_ex ( char *s_desc, char *type, char *buff, int offset, int length, char *encoding,

char *param );

// lrs_save_searched_string 函数将

// 缓冲区的一部分保存到参数中。该函数用于

// 关联或链接脚本中的语句。该函数扩展了

// lrs_save_param 的功能。

int lrs_save_searched_string (char* s_desc, char* buf_desc, char* param_name, char*

left_boundary, char* right_boundary, int ordinal, int offset, int param_len );

// lrs_send 函数将输出数据写到已

// 连接的数据报或流式套接字。如果不能

// 成功发送缓冲区中的所有数据，将重复

// 尝试，直到发送超时。如果无法为数据

// 找到可写的套接字，该函数将不断查找

// 套接字，直到发送超时。默认情况下，

// 发送超时值为 10 秒。可以使用

// lrs_set_send_timeout 修改超时值。

// 注意，lrs_send 成功完成并不表示

// 数据已成功传递。

int lrs_send ( char *s_desc, char *buf_desc, [char *target], [char *flags,] LrsLastArg );

// lrs_set_accept_timeout 函数设置

// 服务器在检测到可读套接字 (select)

// 并完成关联 (accept) 之前等待的时间。

// 如果套接字当前正在侦听，并且

// 收到了传入的连接请求，它将被标记为

// 可读。一旦套接字被标记为可读，

// 就可以保证完成 accept，不会阻塞。

// 可以为超时值指定秒数和毫秒

// 数。如果套接字在超时时间间隔内

// 未被接受，则脚本执行将终止。

// 默认的超时值为 10 秒。如果您发现

// 默认时间不够，请做相应

// 修改。

void lrs_set_accept_timeout ( long seconds, long u_sec );

// lrs_set_connect_timeout 函数设置连接

// 到套接字的超时值。请将这个可编程（非录制）

// 的函数插到连接命令 lrs_create_socket

// 之前。

void lrs_set_connect_timeout ( long seconds, long u_sec );

// lrs_set_receive_option 函数为

// lrs_receive 设置套接字接收选项。Option

// 指明在出现不匹配或检测到终止字符串时，

// 停止接收套接字信息。注意，该选项不会应用

// 于通过 lrs_receive_ex 进行的任何接收

// 操作。该函数设置的选项应用于该函数之后

// 出现的所有 lrs_receive，除非该选项被某个

// 后续 lrs_set_receive_option 调用重置。

int lrs_set_receive_option ( int option, int value, [char * terminator] );

// lrs_set_recv_timeout 函数设置 Vugen 从套接字

// 接收到期望数据之前等待的时间段。

void lrs_set_recv_timeout ( long sec, long u_sec );

// lrs_set_recv_timeout2 函数设置在套接字

// 上接收数据的超时限制。当 lrs_receive 接收

// 到数据缓冲区后，它将其大小与期望数据进行

// 比较。如果缓冲区大小不匹配，它将执行

// 更多的循环，重新读取输入套接字数据，

// 直到达到限制值 timeout2。可以在

// 完整日志跟踪中查看这些循环。

void lrs_set_recv_timeout2( long sec, long u_sec );

// lrs_set_send_buffer 函数指定下次调用

// lrs_send 时要发送的缓冲区。将发送

// lrs_set_send_buffer 中指定的缓冲区，

// 而不是函数 lrs_send 中指定的缓冲区。

int lrs_set_send_buffer ( char *s_desc, char *buffer, int size );

// lrs_set_send_timeout 函数设置向可写

// 套接字发送数据的超时值。可以为超时值指定

// 秒数和毫秒数。

void lrs_set_send_timeout ( long sec, long u_sec );

// lrs_set_socket_handler 函数为指定

// 套接字设置套接字句柄。

int lrs_set_socket_handler ( char *s_desc, int handler );

// lrs_set_socket_options 函数为指定

// 缓冲区设置一个选项。

int lrs_set_socket_options ( char *s_desc, int option, char *option_value );

// lrs_startup 函数初始化 Windows

// Sockets DLL。它指定可用于本应用的最高

// Windows Sockets 版本。该函数

// 必须在所有其他 LRS 函数之前执行。

// 通常，它出现于脚本的 vuser_init

// 部分。如果该函数失败，执行

// 将立即终止。

int lrs_startup ( int version );

// soap_request 函数执行一个 SOAP

// 请求。它向指定的 URL 发送 SOAP 包，

// 并接收服务器响应。

int soap_request (const char *StepName, URL, <XMLEnvelope>, LAST]);

// web_service_call 函数调用 Web 服务。

int web_service_call (const char *StepName, URL, <List of specifications>,

[BEGIN_ARGUMENTS, Arguments, END_ARGUMENTS,] [BEGIN_RESULT, Results,

END_RESULT] LAST );

// lr_xml_get_values 函数在 XML

// 输入字符串 XML 中查询匹配查询条件的值。

int lr_xml_get_values ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// lr_xml_set_values 函数在 XML

// 输入字符串 XML 中查询匹配查询条件的值，

// 并将 Value 或 ValueParam 设置为

// 查询匹配的元素的值。

int lr_xml_set_values ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// lr_xml_extract 函数查询 XML 输入字符串

// XML，并提取 XML 树中匹配查询条件

// 的片段。输出参数 XMLFragmentParam

// 包含提取的片段。

int lr_xml_extract ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// lr_xml_delete 函数在 XML 输入字符串

// XML 中进行查询，并删除与查询条件匹配

// 的 XML 树片段。可以通过在 XML 查询

// 中指定元素名称或其属性来删除

// 元素。输出参数 ResultParam 包含

// 删除后经修改的 XML 字符串（使用

// 源文档编码）。

int lr_xml_delete ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// lr_xml_replace 函数在 XML 输入字符串

// XML 中查询与查询条件匹配的值，并

// 用 XmlFragment 或 XmlFragmentParam

// 将它们替换为与查询匹配的元素的值。

// 可以通过在 XML 查询中指定元素名称

// 或属性来替换元素。结果字符串

// 放在 ResultParam 中（使用源文档

// 编码）。

int lr_xml_replace ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// lr_xml_insert 函数在 XML 输入字符串

// XML 中查询与查询条件匹配的值。然后，它在

// 查询返回的 XML 字符串中的一个或多个位置

// 处插入 XmlFragment 或 XmlFragmentParam。

int lr_xml_insert ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// lr_xml_find 函数在 XML 输入字符串 XML 中

// 查询与条件（Value 或 ValueParam）查询的值，

// 并返回出现次数。如果 SelectAll 为“no”，

// 则 lr_xml_find 返回 1 或 0。

int lr_xml_find ( <List of specifications> [, <List of optional specifications> ] [, LAST]);

// 函数 lr_xml_transform 使用样式表

// 中的可扩展样式表语言 (XSL) 规范转换

// XML 输入字符串 XML，并将作为结果产生

// 的格式化数据保存在 ResultParam 中

// （使用源文档编码）。

int lr_xml_transform ( <List of specifications> ]);

LoadRunner 函数大全之中文解释

// 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-, size_t *pLineSize);

// Fill<n>DByteArray 函数系列将 n 维 byte 数组

// 的最后一维中填充缓冲区的内容。

char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-, 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);

// lrc_GetDoubleArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetDoubleArrayFromVariant(const VARIANT* var);

// lrc_GetErrorArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetErrorArrayFromVariant(const VARIANT* var);

// lrc_GetFloatArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetFloatArrayFromVariant(const VARIANT* var);

// lrc_GetIntArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetIntArrayFromVariant(const VARIANT* var);

// lrc_GetLongArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetLongArrayFromVariant(const VARIANT* var);

// lrc_GetShortArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetShortArrayFromVariant(const VARIANT* var);

// lrc_GetUintArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetUintArrayFromVariant(const VARIANT* var);

// lrc_GetUlongArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetUlongArrayFromVariant(const VARIANT* var);

// lrc_GetUshortArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetUshortArrayFromVariant(const VARIANT* var);

// lrc_GetVariantArrayFromVariant 从变量中提取数组。

VARIANT lrc_GetVariantArrayFromVariant(const VARIANT* var);

// lrc_Get<Type-Name>Array_by_refFromVariant

// 函数系列从变量中的指针引用提取在 Type-Name 中

// 指定的类型的数组。

<Type-Name> lrc_Get<Type-Name>Array_by_refFromVariant const VARIANT* var);

// lrc_GetShortArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetShortArray_by_refFromVariant(const VARIANT* var);

// lrc_GetUshortArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetUshortArray_by_refFromVariant(const VARIANT* var);

// lrc_GetCharArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetCharArray_by_refFromVariant(const VARIANT* var);

// lrc_GetIntArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetIntArray_by_refFromVariant(const VARIANT* var);

// lrc_GetUintArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetUintArray_by_refFromVariant(const VARIANT* var);

// lrc_GetUlongArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetUlongArray_by_refFromVariant(const VARIANT* var);

// lrc_GetByteArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetByteArray_by_refFromVariant(const VARIANT* var);

// lrc_GetLongArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetLongArray_by_refFromVariant(const VARIANT* var);

// lrc_GetFloatArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetFloatArray_by_refFromVariant(const VARIANT* var);

// lrc_GetDoubleArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetDoubleArray_by_refFromVariant(const VARIANT* var);

// lrc_GetBoolArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetBoolArray_by_refFromVariant(const VARIANT* var);

// lrc_GetScodeArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetScodeArray_by_refFromVariant(const VARIANT* var);

// lrc_GetCurrencyArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetCurrencyArray_by_refFromVariant(const VARIANT* var);

// lrc_GetDateArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetDateArray_by_refFromVariant(const VARIANT* var);

// lrc_GetBstrArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetBstrArray_by_refFromVariant(const VARIANT* var);

// lrc_GetCoObjectArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetCoObjectArray_by_refFromVariant(const VARIANT* var);

// lrc_GetDispObjectArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetDispObjectArray_by_refFromVariant(DispObjectArray array);

// lrc_GetVariantArray_by_refFromVariant 从变量中的

// 指针引用提取数组。

VARIANT lrc_GetVariantArray_by_refFromVariant(DispObjectArray array);

// GetElementFrom<n>D<Type-Name>Array

// 函数系列从 SafeArray 中检索指定类型的元素。

// 返回变量的类型是实际语言类型（如无符号长整型），

// 而非 lrc 类型（例如，ulong 类型）。

// VuGen 将这些调用生成为注释掉的代码，

// 您可以使用它们存储参数化变量。若要使用

// 这些调用，请取消它们的注释并将函数

// 返回值分配给适当类型的变量。

<Actual Type-Name> GetElementFrom<n>D<Type-Name>Array(<Type-Name>Array Array, int

index1,..., indexn);

// PutElementIn<n>D<Type-Name>Array 函数

// 系列将给定类型的值存储于在 Type-Name 中

// 给出的 lrc 类型的数组中。

void PutElementIn<n>D<Type-Name>Array(<Type-Name>Array array, int index1,...int indexn,

<Actual Type-Name> Value);

// lrc_FetchRecordset 函数将指针在记录集中

// 向前或向后移动到当前记录。

void lrc_FetchRecordset(recordset15* recordset,

int steps);

// lrc_print_recordset 函数输出由 NumberOfRows

// 指示的行数。如果 NumberOfRows 等于 -1，则

// 函数将输出所有行。

void lrc_print_recordset (Recordset15* recordset, long NumberOfRows);

// lrc_print_variant 函数输出变量。

// 如果变量包含数组或记录，则只输出

// 内容的类型。

void lrc_print_variant (Variant var);

// lrc_save_rs_param 函数将指定字段

// 的值保存到 ADO 记录集的记录中。

void lrc_save_rs_param(Recordset15* recordset, int row, short col, void* reserved,

char*param_name);

// lrc_RecordsetWrite 函数更新 ADO

// 记录集中的字段。首先，它将指针在记录

// 集中移动指定步数。然后，它将值写入当前

// 记录中。此函数可以表示用户对网格中项目

// 的更改。

void lrc_RecordsetWrite(Recordset15* recordset, VARIANT vIndex, VARIANT vValue, long

steps);

// lrc_<type>_by_ref 函数将指针的内存分配给

// 类型 <type> 的变量，并使用 str 中包含的值

// 对其进行初始化。

int * lrc_<type>_by_ref(const char* str);

// lrc_FetchRecordsetUntilEOF 函数将指针

// 在记录中移动，直到移动到记录集的末尾。

void lrc_FetchRecordsetUntilEOF(Recordset15* recordset);

// lrc_RecordsetAddColumn 函数将新列添加

// 到记录集中。它类似于 Append ADO 方法。

void lrc_RecordsetAddColumn(Recordset15* recordset, BSTR name, int type,

long

size, int attribute);

// lrc_RecordsetDeleteColumn 函数从记录集中删除列。

// 它类似于 Delete ADO 方法。

void lrc_RecordsetDeleteColumn(Recordset15* recordset, VARIANT index);

// lrd_alloc_connection 函数分配 LRD_CONNECTION

// 结构。在 lrd_free_connection 释放该结构之前，它是

// 有效的。

LRDRET lrd_alloc_connection ( LRD_CONNECTION **mpptConnection, unsigned int

muiDBType, LRD_CONTEXT *mptContext, long mliOption, int miDBErrorSeverity );

// lrd_assign 函数将 null 终止字符串

// （文字或存储区域）通过其描述符分配给变量。

// 必要时，字符串将被转换为变量的

// 数据类型和长度。若要在字符串中包含

// null 字符 ('\0')，或者如果字符串不是

// null 终止的，请使用 lrd_assign_ext 或

// lrd_assign_literal。只能通过

// 指定 NULL 或 0（不带引号），才能为 lrd_assign

// 分配 NULL 值。

LRDRET lrd_assign ( LRD_VAR_DESC *mptVarDesc, char *mpcValStr, char *mpszValStrFmt,

unsigned long muliIndex, long mliOffset );

// lrd_assign_ext 将带有显式长度的

// 存储区域值通过其描述符分配给变量。

// 必要时，该值将被转换为变量的数据类型

// 和长度。该值可以包含嵌入的 null 字符

// ('\0')。也可以通过使用 NULL 或 0（不带引号）

// 指定 NULL 值。

LRDRET lrd_assign_ext ( LRD_VAR_DESC *mptVarDesc, char *mpcValStr, long mliValStrLen,

char *mpszValStrFmt, unsigned long muliIndex, long mliOffset );

// lrd_assign_literal 函数将由引号

// 括起的文字字符串值通过其描述符分配给变量

// （标量或数组）。必要时，该值将被转换为

// 变量的数据类型和长度。该值可以

// 包含嵌入的 null 字符 ('\0')。也可以

// 通过使用 NULL 或 0（不带引号）指定

// NULL 值。字符串的长度由 (sizeof(string) -1)

// 确定。

LRDRET lrd_assign_literal ( LRD_VAR_DESC *mptVarDesc, char *mpcValStr, char

*mpszValStrFmt, unsigned long muliIndex, long mliOffset );

// lrd_assign_bind 函数将 null 终止

// 字符串值分配给标量变量并将变量绑定到

// 占位符。如果字符串不是 null 终止的，请使用

// lrd_assign_bind_ext 或 lrd_assign_bind_literal。

// 此函数将执行 lrd_assign 和 lrd_bind_placeholder

// 函数，但它被限定为标量型

// 变量。

LRDRET lrd_assign_bind ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, char

*mpcValStr, LRD_VAR_DESC *mptVarDesc, char *mpszValStrFmt, unsigned long muliOption,

int miDBErrorSeverity );

// lrd_assign_bind_ext 函数将带有

// 显式长度的存储区域通过其描述符分配给

// 标量变量，并将变量绑定到占位符。

// 必要时，该值将被转换为变量的类型和

// 长度。该值可以包含嵌入的 null 字符 ('\0')。

// 也可以通过使用 NULL 或 0（不带引号）

// 指定 NULL 值。此函数执行 lrd_assign_ext

// 和 lrd_bind_placeholder

// 函数，但它被限定为标量型

// 变量。

LRDRET lrd_assign_bind_ext ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, char

*mpcValStr, long mliValStrLen, LRD_VAR_DESC *mptVarDesc, char *mpszValStrFmt,

unsigned long muliOption, int miDBErrorSeverity );

// lrd_assign_bind_literal 函数将

// 由引号括起的文字字符串值通过其描述符

// 分配给标量变量，然后将变量绑定到 SQL 语句

// 文本中的占位符。必要时，该值将被转换

// 为变量的类型和长度。该值可以包含嵌入

// 的 null 字符 ('\0')。也可以通过

// 使用 NULL 或 0（不带

// 引号）指定 NULL

// 值。

LRDRET lrd_assign_bind_literal ( LRD_CURSOR *mptCursor, char *mpszPlaceholder, char

*mpcValStr, LRD_VAR_DESC *mptVarDesc, char *mpszValStrFmt, unsigned long muliOption,

int miDBErrorSeverity );

// lrd_attr_set 函数设置 LRDDBI 句柄

// 的属性。在使用 lrd_handle_alloc 调用此

// 函数前必须显式分配句柄。只有 Oracle 8.0 和

// 更高版本才支持此函数。

LRDRET lrd_attr_set ( void *mpvLRDDBIHandleTarget, long mliAttrType, void *mpvValue,

long mliValueLen, int miDBErrorSeverity );

// lrd_attr_set_from_handle 函数设

// 置 LRDDBI 句柄的属性。在使用 lrd_handle_alloc

// 调用此函数前必须显式分配句柄。

// 只有 Oracle 8.0 和更高版本才支持

// 此函数。

LRDRET lrd_attr_set_from_handle ( void *mpvLRDDBIHandleTarget, long mliAttrType, void

*mpvValue, long mliValueLen, int miDBErrorSeverity );

// lrd_attr_set_literal 函数设置

// LRDDBI 句柄的属性。此函数使用文字

// 字符串指定属性，从而允许其包含 NULL 字符。

LRDRET lrd_attr_set_literal ( void *mpvLRDDBIHandleTarget, long mliAttrType, void

**mppvValue, int miDBErrorSeverity );

// lrd_bind_col 函数将主机变量绑定到输出列。

// VuGen 为结果集中的所有列生成 lrd_bind_col

// 语句。

LRDRET lrd_bind_col ( LRD_CURSOR *mptCursor, int muiColNum, LRD_VAR_DESC

*mptVarDesc, long mliOption, int miDBErrorSeverity );

// lrd_bind_cols 函数将主机变量绑定

// 到输出列。VuGen 为结果集中的所有列

// 生成 lrd_bind_col 语句。

LRDRET lrd_bind_cols ( LRD_CURSOR *mptCursor, LRD_BIND_COL_INFO

*mptBindColInfo, int miDBErrorSeverity );

// lrd_bind_cursor 将光标绑定到

// SQL 语句文本中的占位符。此函数

// 要与包含 PL/SQL 命令的语句配合使用。

LRDRET lrd_bind_cursor( LRD_CURSOR *mptCursor, char *mpszPlaceholder, unsigned long

muliOption, LRD_CURSOR **mpptBoundCursor, int miDBErrorSeverity );

// lrd_bind_placeholder 函数将

// 主机变量或数组绑定到占位符。此函数

// 要与 lrd_assign 配合使用。

LRDRET lrd_bind_placeholder ( LRD_CURSOR *mptCursor, char *mpszPlaceholder,

LRD_VAR_DESC *mptVarDesc, unsigned long muliOption, int miDBErrorSeverity );

// lrd_cancel 函数取消提交给数据库

// 服务器的前一语句或信息。在 Oracle

// 中，lrd_cancel 通知服务器取消查询并

// 释放与光标相关的所有资源。如果只需要

// 多行查询的第一行，此函数是非常有用的。

// 可以在 lrd_fetch 之后调用 lrd_cancel

// 以通知服务器不需要执行其他提取

// 操作。

LRDRET lrd_cancel ( LRD_CONNECTION *mptConnection, LRD_CURSOR *mptCursor, long

mliOption, int miDBErrorSeverity );

// lrd_close_all_cursors 函数关闭

// 用于指定连接的所有打开的光标。

LRDRET lrd_close_all_cursors ( LRD_CONNECTION *mptConnection );

// lrd_close_connection 函数

// 关闭与数据库的指定连接。

LRDRET lrd_close_connection ( LRD_CONNECTION **mpptConnection, long mliOption, int

miDBErrorSeverity );

// lrd_close_context 函数关闭 ctlib 函数的上下文。

LRDRET lrd_close_context ( LRD_CONTEXT **mpptContext, long mliOption, int

miDBErrorSeverity );

// lrd_close_cursor 函数关闭指定

// 数据库光标。关闭光标后，则无法再使用

// 该光标执行 SQL 语句。

LRDRET lrd_close_cursor ( LRD_CURSOR **mpptCursor, int miDBErrorSeverity );

// lrd_col_data 函数设置指向

// 特定列的数据的指针。

// 此函数访问数据，但不执行绑定操作。

// 注意，若要引用数据（通过指针），必须将其

// 转换为相应类型。lrd_col_data 只出现

// 在 Vuser 脚本目录的 print.inl 文件中。

LRDRET lrd_col_data ( LRD_CURSOR *mptCursor, unsigned int muiColNum, long mliOffset,

LRD_VAR_DESC *mptVarDesc, unsigned long *mpuliFetchedLen, int miDBErrorSeverity );

// lrd_commit 函数提交当

// 前数据库事务。提交事务后，

// 不能执行回滚。

LRDRET lrd_commit ( LRD_CONTEXT *mptContext, LRD_CONNECTION *mptConnection,

int miDBErrorSeverity );

// lrd_ctlib_cursor 函数指定要初始化

// 的 CtLib 光标命令。此函数指定命令

// 类型及其适用选项。

LRDRET lrd_ctlib_cursor ( LRD_CURSOR *mptCursor, char *mpcName, long mliNameLen,

char *mpcText, long mliTextLen, LRDOS_INT4 mjCmdType, LRDOS_INT4 mjCmdOption, int

miDBErrorSeverity );

// lrd_data_info 函数基于请求

// 规范获取 I/O 描述符信息。

// 请求规范字符串是 null 终止的字符串，

// 其中包含由分号分隔的 <keyword>=<value>

// 规范对。

LRDRET lrd_data_info ( LRD_CURSOR *mptCursor, unsigned int muiColNum, unsigned long

muliIODescNum, char *mpszReqSpec, int miDBErrorSeverity );

// lrd_db_option 函数为数据库光标、

// 上下文或连接设置选项。

LRDRET lrd_db_option ( void *mpvTargetObject, unsigned long muliOption, void

*mpvOptionValue, int miDBErrorSeverity );

// lrd_dynamic 函数指定要处理的动态 SQL 语句。

LRDRET lrd_dynamic ( LRD_CURSOR *mptCursor, char *mpcID, long mliIDLen, char

*mpcText, long mliTextLen, LRDOS_INT4 mjCmdType, int miDBErrorSeverity );

// lrd_end 函数关闭 VuGen 环境

// 并清除所有打开的结构和指针。此函数

// 在 Vuser 脚本中只被调用一次。

LRDRET lrd_end ( void *mpvEndParams );

// lrd_env_init 函数分配并

// 初始化 LRDBI 环境句柄。

// 如果被指向的指针是 NULL，则将分配

// 新的 LRDDBI 环境句柄。如果该值不是 NULL，

// 且被指向的 LRDDBI 句柄具有要求

// 的属性，则不会分配新的 LRDDBI 句柄，

// 并且函数将成功返回。否则将

// 返回 LRDRET_E_EXISTING_HANDLE_ERROR。

LRDRET lrd_env_init ( unsigned int muiDBType, void **mppvLRDDBIHandleEnv, unsigned

long muliMode, int miDBErrorSeverity );

// lrd_exec 函数执行 lrd_stmt 设置的 SQL 语句。

LRDRET lrd_exec ( LRD_CURSOR *mptCursor, unsigned long muliTotalRows, unsigned long

muliSkipRows, unsigned long *mpuliRowsProcessed, long mliOption, int miDBErrorSeverity );

// lrd_fetch 函数从结果集中提取后续若干行。

// 在录制的脚本中，结果集中的行数是参数

// mliRequestedRows 的绝对值。例如，

// 如果 lrd_fetch 的第二个参数是 -14，

// 则检索了十四行数据。

//

LRDRET lrd_fetch ( LRD_CURSOR *mptCursor, long mliRequestedRows, long

mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF

mpfjPrintRow, int miDBErrorSeverity );

// lrd_fetchx 函数使用扩展

// 提取 (SQLExtendedFtech) 从结果集

// 中提取后续若干行。在录制的脚本中，

// 结果集中的行数是参数 mliRequestedRows

// 的绝对值。例如，如果 lrd_fetchx 的第二个

// 参数是 -14，则检索了十四行数据。

LRDRET lrd_fetchx ( LRD_CURSOR *mptCursor, long mliRequestedRows, long

mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF

mpfjPrintRow, long mliOption, int miDBErrorSeverity );

// lrd_fetch_adv 使用 ODBC 扩展

// 提取 (SQLExtendedFtech) 从结果集

// 中提取多行。在录制的脚本中，

// 结果集中的行数是参数 mliRequestedRows 的

// 绝对值。

LRDRET lrd_fetch_adv( LRD_CURSOR *mptCursor, long mliRequestedRows,

long

mliRowsBatchSize, unsigned long *mpuliFetchedRows,

LRD_PRINT_ROW_TYPEDEF

mpfjPrintRow, long mliOption,

int miDBErrorSeverity, long mlilFetchOffset,

unsigned

short musOrientation);

// lrd_free_connection 释放 lrd_alloc_connection

// 创建的 LRD_CONNECTION 结构。

LRDRET lrd_free_connection ( LRD_CONNECTION **mpptConnection, long mliOption, int

miDBErrorSeverity );

// lrd_handle_alloc 函数分配并初始化

// LRDBI 句柄。注意，在调用此函数前必须

// 显式地（使用 lrd_handle_alloc）或

// 隐式地（使用 lrd_logon）分配父句柄。

LRDRET lrd_handle_alloc ( unsigned int muiDBType, void *mpvLRDDBIHandleParent, long

mliDBHandleType, void **mppvLRDDBIHandle, int miDBErrorSeverity );

// lrd_handle_free 函数显式地释放

// LRDDDBI 句柄。注意，句柄必须已被

// 显式地（使用 lrd_handle_alloc）

// 或隐式地（使用 lrd_logon）分配。只有

// Oracle 8.0 和更高版本才支持此函数。

LRDRET lrd_handle_free ( void **mppvLRDDBIHandle, int miDBErrorSeverity);

// lrd_init 函数设置包含 LRD 环境

// 初始化信息的 LRD_INIT_INFO 结构。

// 此函数在脚本中只被调用一次，并且要

// 置于所有其他 LRD 函数调用之前。

LRDRET lrd_init ( LRD_INIT_INFO *mptInitInfo, LRD_DEFAULT_DB_VERSION

*mpatDefaultDBVersion );

// lrd_initialize_db 函数初始化数据库

// 进程环境。注意，内存回调函数是

// 不受支持的。

LRDRET lrd_initialize_db( unsigned int muiDBType, long mliMode, int miDBErrorSeverity );

// lrd_logoff 函数终止由 lrd_logon 或

// lrd_logon_ext 启动的简单数据库会话。

LRDRET lrd_logoff ( void *mppvLRDDBIHandleSvcCtx, int miDBErrorSeverity );

// lrd_logon 函数创建简单登录会话，

// 其中的用户名、密码和数据库服务器

// 标识字符串都是 null 终止字符串。

// 只有 Oracle 8.0 和更高版本才支持此函数。

LRDRET lrd_logon (void *mpvLRDDBIHandleEnv, void **mppvLRDDBIHandleSvcCtx, char

*mpcUserName, char *mpcPassword, char *mpcServerID, int miDBErrorSeverity);

// lrd_logon_ext 函数通过显式指定

// 长度的用户名、密码和数据库

// 服务器标识字符串创建简单数据库会话。

// 只有 Oracle 8.0 和更高版本

// 才支持此函数。

LRDRET lrd_logon_ext (void const *mpvLRDDBIHandleEnv, void

**mppvLRDDBIHandleSvcCtx, char *mpcUserName, long mliUserNameLen, char

*mpcPassword, long mliPasswordLen, char *mpcServerID, long mliServerIDLen, int

miDBErrorSeverity );

// lrd_msg 函数允许您向日志文件

// output.txt 发送数据库消息。只有

// 当指定消息的类匹配 Log 运行时设置中的

// 设置时，消息才发送给日志文件。例如，

// 如果在运行时设置中选择“Brief Log”，

// 则只有分配给 brief 类的调式消息才会

// 出现。

LRDRET lrd_msg ( int miMsgClass, char *mpszMsg );

// 函数 lrd_oci8_to_oci7 将现有 Oracle OCI 8

// 连接 mpptConnectionconverts 转换为 Oracle

// OCI 7 连接。脚本将使用 OCI 7 连接通过执行

// OCI 7 和 OCI 8 操作来继续运行。此函数修改现有

// 连接 mpptConnection 并且不创建任何与数据库的

// 新的连接。

//

LRDRET lrd_oci8_to_oci7 ( void* mpvLRDDBIHandleSvcCtx, LRD_CONNECTION**

mpptConnection, int miDBErrorSeverity );

// lrd_open_connection 函数设置 LRD_CONNECTION

// 结构。在使用 lrd_close_connection 释放该结构之前，

// 它是有效的。

LRDRET lrd_open_connection ( LRD_CONNECTION **mpptConnection, unsigned int

muiDBType, char *mpszUser, char *mpszPassword, char *mpszServer, char *mpszExtConnectStr,

LRD_CONTEXT *mptContext, long mliOption, int miDBErrorSeverity );

// lrd_open_context 函数打开 ctlib 函数的上下文。

LRDRET lrd_open_context ( LRD_CONTEXT **mpptContext, unsigned int muiDBType, long

mliLibVersionBehavior, unsigned int muiOption, int miDBErrorSeverity );

// lrd_open_cursor 函数通过设置 LRD_CURSOR

// 结构打开光标。您可以使用单个光标执行后续 SQL

// 语句。在使用 lrd_close_cursor 释放该结构之前，

// 它是有效的。

LRDRET lrd_open_cursor ( LRD_CURSOR **mpptCursor, LRD_CONNECTION

*mptConnection, int miDBErrorSeverity );

// lrd_option 函数将值分配给 LRD

// 选项 (LRD_OPTION_) 之一。

LRDRET lrd_option ( unsigned long muliOption, void *mpvOptionValue );

// lrd_ora8_attr_set 函数设置 LRDDBI 句柄

// 的属性。在使用 lrd_handle_alloc 调用此

// 函数前必须显式分配句柄。只有 Oracle 8.0 和

// 更高版本才支持此函数。

LRDRET lrd_ora8_attr_set ( void *mpvLRDDBIHandleTarget, long mliAttrType, void

*mpvValue, long mliValueLen, int miDBErrorSeverity );

// lrd_ora8_attr_set_from_handle 函数设置

// LRDDBI 句柄的属性。在使用 lrd_handle_alloc

// 调用此函数之前，必须显式地分配句柄。

// 只有 Oracle 8.0 和更高版本才支持此函数。

//

LRDRET lrd_ora8_attr_set_from_handle ( void *mpvLRDDBIHandleTarget, long mliAttrType,

void *mpvValue, long mliValueLen, int miDBErrorSeverity );

// lrd_ora8_attr_set_literal 函数

// 设置 LRDDBI 句柄的属性。此函数使用

// 文本字符串指定属性，从而允许其包含 NULL

// 字符。

LRDRET lrd_ora8_attr_set_literal ( void *mpvLRDDBIHandleTarget, long mliAttrType, void

*mpvValue, int miDBErrorSeverity );

// lrd_ora8_bind_col 函数将主机变量

// 绑定到输出列。VuGen 为结果集中的所有列生成

// lrd_ora8_bind_col 语句。

LRDRET lrd_ora8_bind_col (void *mpvLRDDBIHandleStmt, void

**mppvLRDDBIHandleDefine, int muiColNum, LRD_VAR_DESC *mptVarDesc, long mliMode,

int miDBErrorSeverity );

// lrd_ora8_bind_placeholder 函数将

// 主机变量或数组绑定到占位符。此函数要

// 与 lrd_assign 配合使用。

LRDRET lrd_ora8_bind_placeholder (void *mpvLRDDBIHandleStmt, void

**mppvLRDDBIHandleBind, char *mpszPlaceholder, LRD_VAR_DESC *mptVarDesc, unsigned

long muliOption, long mliMode, int miDBErrorSeverity );

// lrd_ora8_commit 函数从 Oracle 8.x 客户端

// 的上一保存点提交当前数据库事务。

LRDRET lrd_ora8_commit ( void *ServiceContextHandle, long Mode, int ErrorSeverity );

// lrd_ora8_exec 函数执行 lrd_stmt 设置

// 的 SQL 语句。此函数重置由 lrd_ora8_stmt 设置

// 的 SQL 语句内容；在每个 lrd_ora8_exec 函数

// 调用之后，您必须提供新的语句（并可选择

// 绑定参数）。

LRDRET lrd_ora8_exec ( void *mpvLRDDBIHandleSvcCtx, char *mpvLRDDBIHandleStmt,

unsigned long muliTotalRows, unsigned long muliSkipRows, unsigned long

*mpuliRowsProcessed, LRD_ORA8_PRINT_ROW_TYPEDEF mpfjPrintRow, void *Reserved1,

void *Reserved2, long mliMode, int miDBErrorSeverity );

// lrd_ora8_fetch 函数从结果集中

// 提取后续若干行。在录制的脚本中，结果集

// 中的行数是参数 mliRequestedRows 的

// 绝对值。例如，如果 lrd_ora8_fetch 的

// 第二个参数是 -14，则检索了十四

// 行数据。

LRDRET lrd_ora8_fetch (void *mpvLRDDBIHandleStmt, long mliRequestedRows, long

mliRowsBatchSize, unsigned long *mpuliFetchedRows, LRD_PRINT_ROW_TYPEDEF

mpfjPrintRow, long mliOrientation, long mliMode, int miDBErrorSeverity );

// lrd_ora8_handle_alloc 函数分配

// 并初始化 LRDBI 句柄。句柄类型只由

// 限定符指定。限定符是 LRD_HTYPE_ORACLE_ 字符串

// 的唯一后缀。例如，在 LRD_HTYPE_ORACLE_SESSION 中，

// 限定符是“SESSION”。

LRDRET lrd_ora8_handle_alloc ( void const * mpvParentHandle, long const mliDBHandleType,

void * * const mppvLRDDBIHandle, int const miDBErrorSeverity );

// lrd_ora8_lob_read 函数在大对象

// (LOB) 描述符已从数据库中提取后，从该

// 描述符中读取字符。注意，lrd_ora8_lob_read

// 读取的字符无法被访问。此函数用于增加

// Oracle 服务器的负载并模拟现实的服务器

// 活动。

LRDRET lrd_ora8_lob_read ( void * const mpvLRDDBIHandleSvcCtx, void * const

mpvLRDDBIHandleLob, unsigned long const mjAmtToRead, unsigned long * const

mpjAmtRead, unsigned long const mjOffset, unsigned long const mjBufl, unsigned short const

mjCsid, unsigned char const mjCsfrm, int const miDBErrorSeverity);

// lrd_ora8_rollback 函数将当前数据库事务回

// 滚到 Oracle 8.x 客户端的上一保存点。

LRDRET lrd_ora8_rollback ( void *const ServiceContextHandle, long const Mode, int const

ErrorSeverity );

// lrd_ora8_save_col 函数保存指定

// 表单元格的动态值并将其分配给参数。

// 在 Vuser 脚本中，此函数用于关联

// 语句和其他 SQL 语句。不使用在查询

// 期间提取的实际结果，而是使用参数

// 替换常量值。然后，此参数可由同一

// 脚本中的其他数据库语句使用。注意，

// lrd_ora8_save_col 总是置于

// lrd_ora8_fetch 语句之前。

LRDRET lrd_ora8_save_col (void *mpvLRDDBIHandleStmt, unsigned int muiColNum, long

mliRowNum, unsigned long muliOption, char *mpszParamName );

// lrd_ora8_stmt 函数准备用于执行的 SQL

// 或 PL/SQL 语句。语句的文本是 null 终止

// 字符串，在该字符串中没有任何 null 字符。

// （对于包含 null 字符的字符串，请使用

// lrd_ora8_stmt_literal 或 lrd_ora8_stmt_ext。）

LRDRET lrd_ora8_stmt (void *mpvLRDDBIHandleStmt, char *mpcStmtText, long mliLanguage,

long mliMode, int miDBErrorSeverity );

// lrd_ora8_stmt_ext 函数准备

// 用于执行的 SQL 或 PL/SQL 语句。

// 语句文本是由地址和显式长度指定的。

// 文本可以包含 null 字符，并且应该

// 由 null 字符终止。lrd_ora8_stmt_ext

// 可用于可能包含嵌入 null 字符的动态

// 构造存储区域。

LRDRET lrd_ora8_stmt_ext (void *mpvLRDDBIHandleStmt, char *mpcStmtText, long

mliStmtTextLen, long mliLanguage, long mliMode, int miDBErrorSeverity );

// lrd_ora8_stmt_literal 函数准备

// 用于执行的文字 SQL 或 PL/SQL 语句。

// lrd_ora8_stmt_ext 可用于包含

// 嵌入 null 字符的字符串常量。语句的

// 长度由公式 sizeof()-1 确定。

LRDRET lrd_ora8_stmt_literal (void *mpvLRDDBIHandleStmt, char *mpcStmtText, long

mliLanguage, long mliMode, int miDBErrorSeverity );

LoadRunner 函数大全之中文解释

// 在自动提取中，数据由 exec 命令提取，

// 所以组合提取与输出的 lrd_fetch 是

// 不适用的。lrd_print 使用指向

// bympfjPrintRow 的函数输出行。

LRDRET lrd_print ( LRD_CURSOR *mptCursor mptCursor, LRD_PRINT_ROW_TYPEDEF

mpfjPrintRow );

// lrd_reset_rows 函数为使用 ODBC SqlSetPos 函数

// 的 UPDATE 操作准备可供提取的行。

LRDRET lrd_reset_rows ( LRD_CURSOR *mptCursor, long mliRowIndex );

// lrd_result_set 函数准备用于

// 通过光标输出字符串（通常为 SQL 语句）

// 的下一结果集。对于 CtLib，它发出 ct_result

// 命令，并且在 ODBC 中它运行用于当前数据库

// 语句的 SqlMoreResults。

LRDRET lrd_result_set (LRD_CURSOR *mptCursor, long mliOpt1, long mliOpt2, int

miDBErrorSeverity );

// lrd_result_set_ext 函数准备

// 用于通过光标输出字符串（通常为 SQL 语句）

// 的下一结果集。它发出用于当前数据库

// 语句的 ct_result。

LRDRET lrd_result_set_ext ( LRD_CURSOR *mptCursor, long mliOpt1, long mliOpt2, long

*mpliReturnCode, long *mpliResultType, int miDBErrorSeverity );

// lrd_rollback 函数将当前数据库

// 事务回滚到上一保存点。

LRDRET lrd_rollback ( LRD_CONTEXT *mptContext, LRD_CONNECTION *mptConnection,

int miDBErrorSeverity );

// lrd_row_count 函数返回

// 受到 UPDATE、DELETE 或 INSERT 语句影响的行数。

// 只有 ODBC 和 DB2 Vuser 才支持它。

LRDRET lrd_row_count ( LRD_CURSOR * mptCursor, long * mpliRowCount, int

miDBErrorSeverity );

// lrd_save_col 函数保存指定

// 表单元格的动态值并将其分配给某

// 参数。在 Vuser 脚本中，此函数

// 用于关联语句和其他 SQL 语句。不

// 使用在查询期间提取的实际结果，而是

// 使用参数替换常量值。然后，此参数

// 可由同一脚本中的其他数据库

// 语句使用。注意，lrd_save_col 总是

// 置于 lrd_fetch 语句之前。

LRDRET lrd_save_col ( LRD_CURSOR *mptCursor, unsigned int muiColNum, long

mliRowNum, unsigned long muliOption, char *mpszParamName );

// lrd_save_last_rowid 函数将当前结果集

// 最后一行的 rowid 保存到参数中。最后的 rowid 值

// 可用在该脚本的稍后位置。

LRDRET lrd_save_last_rowid ( LRD_CURSOR *mptCursor, char *mpszParamName );

// lrd_save_ret_param 函数将存储

// 过程的返回参数的值保存到参数中。

// 如果函数无法检索返回参数，该

// 参数将标记为未初始化。此函数用于关联

// 数据库语句。

LRDRET lrd_save_ret_param ( LRD_CURSOR *mptCursor, unsigned int muiRetParamNum,

unsigned long muliOption, char *mpszParamName );

// lrd_save_value 函数保存占位符

// 描述符的动态值。此函数

// 用于设置输出占位符（例如，Oracle 中

// 的某些存储过程）的关联数据库语句。

// 在同一脚本中，此动态保存的值

// 可由其他数据库语句使用。注意，lrd_save_value 总是

// 跟随在 lrd_exec 语句之后。

LRDRET lrd_save_value ( LRD_VAR_DESC *mptVarDesc, unsigned long muIiIndex, unsigned

long muliOption, char *mpszParamName );

// lrd_send_data 函数将某数据块

// 发送给服务器。数据的位置由

// 请求规范字符串 mpszReqSpec 指定。

// 此 null 终止字符串包含关键字及其值的列表。

LRDRET lrd_send_data ( LRD_CURSOR *mptCursor, unsigned int muiUnused, unsigned long

muliIODescNum, char *mpszReqSpec, LRD_VAR_DESC *mptVarDesc, int

miDBErrorSeverity );

// lrd_server_detach 函数删除

// 用于数据库操作的数据源的访问路径。只有 Oracle 8.0 和

// 更高版本才支持此函数。

LRDRET lrd_server_detach ( void const * mpvLRDDBIHandleServer, long const mliMode, int

const miDBErrorSeverity );

// lrd_session_begin 函数启动

// 服务器的用户会话。只有 Oracle 8.0 和

// 更高版本才支持此函数。

LRDRET lrd_session_begin ( void *mpvLRDDBIHandleSvcCtx, void

*mpvLRDDBIHandleSession, unsigned long muliCredentials, long mliMode, int

miDBErrorSeverity );

// lrd_session_end 函数结束服务器的用户会话。

// 只有 Oracle 8.0 和更高版本才支持此函数。

LRDRET lrd_session_end ( void const *mpvLRDDBIHandleSvcCtx, void const

*mpvLRDDBIHandleSession, long const mliMode, int const miDBErrorSeverity );

// lrd_siebel_incr 函数按指定

// 值递增字符串（由数值表示）。在该函数

// 递增字符串后，它将字符串写回到原

// 内存位置。表示字符串的数值

// 以 36 为基。Siebel 使用以 36 为基的

// 算法，使用从 0 到 9 的数字或

// 从 A 到 Z 的字母（对应于 10 到 35）表示

// 数值。

LRDRET lrd_siebel_incr (char *string, int increment );

// lrd_siebel_str2num 用于自动的 Siebel 关联。

LRDRET lrd_siebel_str2num (const char *szString);

// {0>The lrd_stmt function associates a character string<}72{>?lrd_stmt 函数将字符串（通常

<）

// 为 SQL 语句}与光标相关联。如果一个 lrd_stmt 函数

// 之后跟随有另一个（两者之间没有 lrd_exec），

// 则这些字符串将被连接。

// 注意，单个光标可以支持多个连续

// 的 SQL 语句。虽然可以将 SQL 语句

// 文本拆分为若干个段，但无法拆分

// 占位符标识符。

LRDRET lrd_stmt (LRD_CURSOR *mptCursor, char *mpcText, long mliTextLen,

LRDOS_INT4 mjOpt1, LRDOS_INT4 mjOpt2, int miDBErrorSeverity );

// lrd_to_printable 函数将变量

// 或数组元素转换为可打印字符串。

// 在录制期间，将在脚本目录的 print.inl 文件

// 中生成此函数。它提供了有关如何在 VuGen 的

// 网格中显示结果的信息。

LRDRET lrd_to_printable ( LRD_VAR_DESC *mptVarDesc, unsigned long muliIndex, char

*mpszOutputStr, unsigned long muliOutputStrSize, char *mpszOutputStrFmt );

// SiebelPreSave_x 函数指示，

// 在对 2 层 Siebel 调用 lrd_fetch 或 lrd_ora8_fetch 之前，

// 需要为自动关联保存哪些 Siebel 参数。

int SiebelPreSave_x(void);

// SiebelPostSave_x 函数在对 2 层

// Siebel 调用 lrd_fetch 或 lrd_ora8_fetch 之后

// 保存以后的 Siebel 参数的值。

int SiebelPostSave_x(void);

// ms_dns_query 函数使用

// 域名服务 (DNS) 解析指定主机名的 IP 地址。

// 此函数不会自动将域添加到主机名（需要您显式

// 包含该域）。

char * ms_dns_query( char *transaction, char *dnsserver, [char *query_host,] [char

*local_address,] LAST );

// ms_dns_nextresult 函数在 IP 地址列表

// （由 ms_dns_query 返回）中查询下一个 IP 地址。

char* ms_dns_nextresult (char *ipaddresslist);

// ftp_delete 函数从 FTP 服务器中删除文件。

int ftp_delete (char *transaction, char *item_list, LAST);

// ftp_delete_ex 函数针对指定会话

// 从 FTP 服务器中删除文件。

int ftp_delete_ex (FTP *ppftp, char *transaction, char *item_list, LAST);

// ftp_dir 函数在 FTP 服务器上运行 dir 命令。

int ftp_dir (char *transaction, char *item_list, LAST);

// ftp_dir_ex 函数针对指定会话在 FTP

// 服务器上运行 dir 命令。

int ftp_dir_ex (FTP *ppftp, char *transaction, <List of Attributes>, LAST);

// ftp_get 函数在 FTP 服务器上设置工作目录。

int ftp_get (char *transaction, char *item_list, LAST);

// ftp_get_last_download_details 获取

// 上次下载的统计信息。它以毫秒

// 为单位将总计下载持续时间分配给 pDuration 指向

// 的长整型变量。此持续时间包括实际传输时间和

// 连接开销。

int ftp_get_last_download_details ( unsigned long * pByteCount, unsigned long *pDuration);

// ftp_get_last_download_details_ex 获取

// 会话中上次下载的统计信息。

// 它以毫秒为单位将总计下载持续时间

// 分配给 pDuration 指向的长整型变量。

// 此持续时间包括实际传输时间和连接开销。

int ftp_get_last_download_details_ex (FTP *ppFtp, unsigned long * pByteCount, unsigned long *

pDuration);

// ftp_get_ex 函数针对指定会话在 FTP 服务器

// 上设置工作目录。

int ftp_get_ex (FTP *ppftp, char *transaction, char *item_list, LAST);

// ftp_get_last_error 函数返回 FTP 会话

// 期间发生的最后一次错误。

char * ftp_get_last_error (FTP *ppftp);

// ftp_get_last_error_id 函数

// 返回在指定 FTP 会话期间发生的

// 最后一次错误的 ID 编号。

int ftp_get_last_error_id (FTP *ppftp);

// ftp_get_last_handshake_duration 以毫秒为单位返回最后一次

// 连接创建的持续时间。

double ftp_get_last_handshake_duration ();

// ftp_get_last_handshake_duration_ex 以毫秒为单位返回会话中

// 最后一次连接创建的持续时间。

double ftp_get_last_handshake_duration_ex (FTP *ppFtp);

// ftp_get_last_transfer_duration 以毫秒

// 为单位返回最后一次 get 命令的净传输时间。

// 净传输持续时间不包括连接开销。

double ftp_get_last_transfer_duration ();

// ftp_get_last_transfer_duration_ex 以

// 毫秒为单位返回此会话最后一次 get 命令

// 的净传输时间。净传输持续时间不包括

// 连接开销。

double ftp_get_last_transfer_duration_ex (FTP *ppftp);

// ftp_logon 函数执行登录到 FTP 服务器的操作。

int ftp_logon ( char *transaction, char *url, LAST);

// ftp_logon_ex 函数针对特定会话登录到 FTP 服务器。

int ftp_logon_ex (FTP *ppftp, char *transaction, char *url, LAST);

// ftp_logon 函数执行从 FTP 服务器注销的操作。

int ftp_logout ( );

// ftp_logout_ex 函数针对特定会话

// 从 FTP 服务器注销。

int ftp_logout_ex (FTP *ppftp);

// ftp_mkdir 函数在 FTP 服务器上设置工作目录。

int ftp_mkdir(char *transaction, char * path);

// ftp_mkdir_ex 函数针对指定会话

// 在 FTP 服务器上设置工作目录。

int ftp_mkdir_ex(FTP *ppftp, char *transaction, char * path);

// ftp_put 函数在 FTP 服务器上设置工作目录。

int ftp_put ( char *transaction, char *item_list, LAST);

// ftp_put_ex 函数针对指定会话

// 在 FTP 服务器上设置工作目录。

int ftp_put_ex (FTP *ppftp, char *transaction, char *item_list, LAST);

// ftp_rendir 函数重命名 FTP 服务器上的文件或目录。

int ftp_rendir (char *transaction, <item list>, LAST);

// 在下列示例中，ftp_rendir_ex 函数针对指定会话

// 重命名 FTP 服务器上的文件或目录。

int ftp_rendir_ex (FTP *ppftp, char *transaction, ITEM LIST, LAST);

// ftp_rmdir 函数重命名 FTP 服务器上的目录。

int ftp_rmdir (const char *transaction, const char * path);

// ftp_rmdir_ex 函数针对指定会话

// 删除 FTP 服务器上的目录。

int ftp_rmdir_ex (FTP *ppftp, const char *transaction, const char *path);

// imap_logon 函数通过身份验证信息（使用纯文本用户名和密码）

// 登录到 IMAP 服务器。

int imap_logon(char *transaction, char *url, char *certificate, char *key, char *password, LAST);

// imap_logon_ex 函数针对特定会话

// 登录到 MS Exchange 服务器。它使用

// 简单 IMAP（MS Exchange 协议）执行登录。

int imap_logon_ex(IMAP *ppimap, char *transaction, char *url, char *certificate, char *key, char

*password, LAST);

// imap_logout 函数从 IMAP 服务器注销。

int imap_logout( );

// imap_logout_ex 函数针对特定会话

// 从 IMAP 服务器注销。

int imap_logout_ex(IMAP *ppimap);

// imap_free_ex 函数释放 IMAP 会话描述符。

// 在从 IMAP 服务器注销后调用此函数。

int imap_free_ex(IMAP *ppimap);

// imap_get_result 函数获取 IMAP 服

// 务器返回代码。使用此函数可确定

// 由 IMAP 服务器发出的有关以前的 IMAP 函数的精确错误

// 代码。

int imap_get_result( );

// imap_get_result_ex 函数获取

// 指定服务器会话的 IMAP 服务器返回代码。

// 使用此函数可确定由 IMAP 服务器发出的有关以前的 IMAP 函数

// 的错误代码。

int imap_get_result_ex(IMAP *ppimap);

// imap_select 函数选择

// 邮箱以访问其邮件。调用此函数

// 将修改邮箱状态（未读邮件数、邮件

// 总数，等等）。若要检索邮箱属性，请调用

// imap_get_attribute_int。

int imap_select(char *transaction, char *mailbox, LAST);

// imap_select_ex 函数选择邮箱

// 以访问其邮件。调用此函数将修改

// 邮箱状态（未读邮件数、邮件总数，

// 等等）。若要检索邮箱属性，

// 请调用 imap_get_attribute_int_ex。

int imap_select_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_examine 函数选择邮箱

// 以查看其邮件。调用此函数不会

// 修改邮箱状态（未读邮件数、邮件总数，

// 等等）。

int imap_examine (char *transaction, char *mailbox, LAST);

// imap_examine_ex 函数选择

// 邮箱以查看其邮件。调用

// 此函数不会修改邮箱状态

// （未读邮件数、邮件总数，等等）。

int imap_examine_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_status 函数请求指定

// 邮箱的状态。它既不更改当前

// 选中邮箱，也不影响查询邮箱中任何

// 邮件的状态。请求这些状态

// 后，请使用 imap_get_attribute_int 获取

// 状态值。

int imap_status (char *transaction, char *mailbox, char *item, LAST);

// imap_status_ex 函数请求

// 指定邮箱的状态。它既不

// 更改当前选中邮箱，也不影响查询

// 邮箱中任何邮件的状态。请求

// 这些状态后，可使用 imap_get_attribute_int_ex 读取

// 状态值。

int imap_status_ex (IMAP *ppimap, char *transaction, char *mailbox, char *item, LAST);

// imap_list_mailboxes 函数列出

// 客户端可使用的邮箱。回复中包含名称属性、

// 层次结构分隔符和邮箱名称。

int imap_list_mailboxes(char *transaction, char *reference, char *name, LAST);

// imap_list_mailboxes_ex 函数列出

// 客户端可使用的邮箱。回复中包含名称属性、

// 层次结构分隔符和邮箱名称。

int imap_list_mailboxes_ex (IMAP *ppimap, char *transaction, char *reference, char *name,

LAST);

// imap_list_subscriptions 函数列出

// 对客户端声明为订阅或活动的邮箱。

// 回复中包含名称属性、层次结构分隔符和

// 邮箱名称。

int imap_list_subscriptions (char *transaction, char *reference, char *name, LAST);

// imap_list_subscriptions_ex 函数

// 列出对客户端声明为订阅或活动的邮箱。

// 回复中包含名称属性、层次结构分隔符和

// 邮箱名称。

int imap_list_subscriptions_ex (IMAP *ppimap, char *transaction, char *reference, char *name,

LAST);

// imap_subscribe 函数将指定

// 邮箱设置为订阅或活动的。若要检索具有订阅

// 的邮箱列表，请调用 imap_list_subscriptions。

int imap_subscribe(char *transaction, char *mailbox, LAST);

// imap_subscribe_ex 函数将指定

// 邮箱设置为订阅或活动的。若要

// 检索具有订阅的邮箱列表，请调用

// imap_list_subscriptions_ex。

int imap_subscribe_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_unsubscribe 函数取消

// 对指定邮箱的订阅。取消订阅

// 命令将从服务器的“活动”或“订阅”

// 邮箱集中删除指定邮箱名称。

int imap_unsubscribe(char *transaction, char *mailbox, LAST);

// imap_unsubscribe_ex 函数取消

// 对指定邮箱的订阅。取消订阅

// 命令将从服务器的“活动”或“订阅”邮箱

// 集中删除指定邮箱名称。

int imap_unsubscribe_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_expunge 函数使用指定

// 函数删除 IMAP 服务器上的邮件。

int imap_expunge(char *transaction, char *method, [char *message,] LAST);

// imap_expunge_ex 函数针对特定会话

// 从 IMAP 服务器上永久删除邮件。

int imap_expunge_ex(IMAP *ppimap, char *transaction, char *method, [char *message,] LAST);

// imap_store 函数更改与当前

// 邮箱中的指定邮件相关的标志。

// 可以更改所有标志、在现有标志上添加

// 标志或删除标志。

int imap_store(char *transaction, char *method, char *message, char *action, ENDITEM, LAST);

// imap_store_ex 函数更改

// 与当前邮箱中的指定邮件相关的标志。

// 可以更改所有标志、在现有标志上

// 添加标志或删除标志。

int imap_store_ex (IMAP *ppimap, char *transaction, char *method, char *message, char *action,

ENDITEM, LAST);

// imap_copy 函数将消息

// 从当前邮箱复制到另一邮箱中。

// 可以指定复制单个邮件或某个范围的邮件。

// 如果目标邮箱不存在，服务器将返回错误。

int imap_copy(char *transaction, char *message, char *mailbox, ENDITEM, LAST);

// imap_copy_ex 函数将消息从

// 当前邮箱复制到另一邮箱中。可以指定

// 复制单个邮件或某个范围的邮件。如果目标

// 邮箱不存在，服务器将返回错误。

int imap_copy_ex (IMAP *ppimap, char *transaction, char *message, char *mailbox, ENDITEM,

LAST);

// imap_fetch 函数针对特定会话

// 检索与邮箱邮件相关联的数据。

// 可以请求任何邮件数据值，

// 包括标志、标题和邮件 ID。

int imap_fetch (char *transaction, char *mode, char *message, ENDITEM, LAST);

// imap_fetch_ex 函数针对特定会话

// 检索与邮箱邮件相关联的数据。

// 可以请求任何邮件数据值，包括标志、

// 标题和邮件 ID。

int imap_fetch_ex (IMAP *ppimap, char *transaction, char *mode, char *message, char *saveto,

ENDITEM, LAST);

// imap_search 函数搜索

// 邮箱以查找与搜索标准匹配的邮件。

// 搜索标准可以由一个或多个搜索项组成。

int imap_search (char *transaction, char *key, char *param, char * saveto, ENDITEM, LAST);

// imap_search_ex 函数搜索邮箱

// 以查找与搜索标准匹配的邮件。搜索标准

// 可以由一个或多个搜索项组成。

int imap_search_ex (IMAP *ppimap, char *transaction, char *key, char *param, ENDITEM,

LAST);

// 使用 imap_set_max_param_len 设置

// 用于将邮件作为参数存储的缓冲区的

// 最大大小。该函数要在将邮件保存到参数的函数

// （imap_fetch 和 imap_search）之前被调用。

int imap_set_max_param_len ( char *size );

// 使用 imap_set_max_param_len_ex 设置用于

// 将邮件作为参数存储的缓冲区的最大大小。

// 该函数要在将邮件保存到参数

// 的函数（imap_fetch 和 imap_search）之前被调用。

int imap_set_max_param_len_ex ( IMAP *ppimap, char *size );

// imap_append 函数将文本表达式

// 作为新邮件追加到指定邮箱的末尾。

int imap_append (char *transaction, char *message, char *flag, char *mailbox, ENDITEM,

LAST);

// imap_append_ex 函数将文本表达式

// 作为新邮件追加到指定邮箱的末尾。

int imap_append_ex (IMAP *ppimap, char *transaction, char *message, char *flag, char *mailbox,

ENDITEM, LAST);

// imap_create 函数创建新的邮箱。

int imap_create(char *transaction, char *mailbox, LAST);

// imap_create_ex 函数针对特定会话创建新邮箱。

int imap_create_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_delete 函数删除现有邮箱。

int imap_delete(char *transaction, char *mailbox, LAST);

// imap_delete_ex 函数针对特定会话

// 删除现有邮箱。

int imap_delete_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_noop 函数在邮箱上执行 noop 操作。

// 这对于测试网络非常有用。

int imap_noop(char *transaction);

// imap_noop_ex 函数在指定 IMAP 会话

// 的邮箱上执行 noop 操作。

// 这对于测试网络非常有用。

int imap_noop_ex (IMAP *ppimap, char *transaction);

// imap_check 函数在当前

// 邮箱中请求检查点。检查点涉及任何依赖于

// 实现并适用于邮箱内部的内务管理。

int imap_check (char *transaction);

// imap_check_ex 函数在指定 IMAP 会话

// 的当前邮箱中请求检查点。检查点

// 涉及任何依赖于实现并适用于邮箱内部的

// 内务管理。

int imap_check_ex (IMAP *ppimap, char *transaction);

// imap_close 函数将设置

// 有 \Deleted 标记的所有邮件从

// 当前邮箱中永远删除。它将邮件从

// 选中状态返回到身份验证状态。

// 当前选中邮箱将关闭。

int imap_close(char *transaction, char *mailbox, LAST);

// imap_close_ex 函数针对特定会话将

// 设置有 \Deleted 标记的所有邮件

// 从当前邮箱中永久删除。

// 它将邮件从选中状态返回到身份验证状态。

// 当前选中的邮箱将被关闭。

int imap_close_ex (IMAP *ppimap, char *transaction, char *mailbox, LAST);

// imap_custom_request 函数执行

// 自定义的 IMAP 请求。此函数对于

// 处理未包含在 IMAP4rev1 协议规范中、特定

// 于 IMAP 服务器的扩展非常有用。

int imap_custom_request (char *transaction, char *operation, char *arguments );

// imap_custom_request_ex 函数针对特定会话

// 执行自定义的 IMAP 请求。此函数对于

// 处理未包含在 IMAP4rev1 协议规范中、特定

// 于 IMAP 服务器的扩展非常有用。

int imap_custom_request_ex (IMAP *ppimap, char *transaction, char *operation, char

*arguments);

// imap_get_attribute_int 函数将 IMAP 会话

// 属性的值作为 integer 类型值返回。

int imap_get_attribute_int(char *property);

// imap_get_attribute_int_ex 函数针对特定会话将 IMAP 属性的

// 值作为 integer 类型值返回。

int imap_get_attribute_int_ex(IMAP *ppimap, char *attribute);

// imap_get_attribute_sz 函数将 IMAP 会话

// 属性的值作为字符串返回。

char *imap_get_attribute_sz(char *property);

// imap_get_attribute_sz_ex 函数针对特定会话

// 将 IMAP 属性的值作为字符串返回。

char *imap_get_attribute_sz_ex(IMAP *ppimap, char *attribute);

// mldap_add 函数向 LDAP 目录中添加条目。

int mldap_add (char *transaction, char *dn, <List of Attributes>, LAST);

// mldap_add_ex 函数针对特定会话

// 向 LDAP 目录中添加条目。

int mldap_add_ex (MLDAP *pldap, char *transaction, char *dn, <List of Attributes>, LAST);

// mldap_delete 函数删除条目或条目的属性。

// 如果指定条目名称，该条目将被删除。

// 如果指定属性名称，则只有该属性

// 被删除。

int mldap_delete (char *transaction, char *dn, LAST);

// mldap_delete_ex 函数针对指定会话

// 从 LDAP 服务器删除文件。

int mldap_delete_ex (MLDAP *pldap, char *transaction, char *dn, LAST);

// mldap_get_attrib_name 函数检索

// 指定属性索引的属性名。可以选择

// 将此名称保存为参数。

char * mldap_get_attrib_name (char *transaction, char *index, [char *param,] LAST);

// mldap_get_attrib_name_ex 函数检索

// 指定会话的指定索引的属性名。

// 可以选择将此名称保存为参数。

char * mldap_get_attrib_name_ex (MLDAP *pldap, char *transaction, char *index, [char

*param,] LAST);

// mldap_get_attrib_value 函数检索

// 当前条目的属性值。既可以

// 指定属性的索引，也可以指定

// 属性的名称。默认情况下，

// 如果不指定任何值，函数将

// 返回第一个属性的值。可选的 offset 参数允

// 许您获取第一个属性之外的其他属性的值。

// 例如，如果属性具有多个值，offset 为 0 将返回第一个值，

// offset 为 1 将返回第二个值，依此类推。

char * mldap_get_attrib_value (char *transaction, char *name, char *index, [char *offset,] [char

*param,] LAST);

// mldap_get_attrib_value_ex 函数检索

// 指定会话指定属性的值。既可以指定

// 属性的索引，也可以指定属性的名称。

// 默认情况下，如果不指定任何值，函数将返回

// 第一个属性的值。可选的 offset 参数

// 允许您获取第一个属性之外的其他属性

// 的值。例如，如果属性具有多个值，

// offset 为 0 将返回第一个值，offset 为 1 将返回第二个值，

// 依此类推。

// 1 would return the second, etc.

char * mldap_get_attrib_value_ex (MLDAP *pldap, char *transaction, char *name, char *index,

[char *offset,] [char *param,] LAST);

// mldap_get_next_entry 函数显示作为

// 搜索结果的下一条目。对于异步搜索，

// 此函数检索并显示条目；对于同步搜索，

// 它只显示下一条目。函数返回 DN 条目的名称，

// 但您也可以命令该函数将其

// 保存为参数。如果没有其他条目，或者如果在检索

// 项目时发生错误，函数将

// 返回 NULL。

char * mldap_get_next_entry (char *transaction, [char *timeout,] [char *param,] LAST);

// mldap_get_next_entry_ex 函数显示

// 作为指定会话的搜索结果的下一

// 条目。对于异步搜索，此函数检索

// 并显示条目；对于同步搜索，它只显示

// 下一条目。函数返回 DN 条目的名称，

// 但您也可以命令该函数将其保存为参数。

// 如果没有其他条目，或者如果

// 在检索项目时发生错误，函数将

// 返回 NULL。

char * mldap_get_next_entry_ex (MLDAP *pldap, char *transaction, [char *timeout,] [char

*param,] LAST);

// mldap_logon 函数执行登录到 LDAP 服务器的操作。

int mldap_logon (char *transaction, char *url, LAST);

// mldap_logon_ex 函数针对特定会话登录

// 到 LDAP 服务器。

int mldap_logon_ex (MLDAP *pldap, char *transaction, char *url, LAST);

// mldap_logoff 函数执行从 LDAP 服务器注销的操作。

int mldap_logoff ( );

// mldap_logoff_ex 函数针对特定会话

// 从 LDAP 服务器注销。

int mldap_logoff_ex (MLDAP *pldap);

// mldap_modify 函数更改 LDAP 条目

// 属性的值。每个函数只能修改一个条目。

// 若要修改另一个条目的属性，请使用

// 另一个 mldap_modify 函数。

int mldap_modify (char *transaction, char *dn, <List of Attributes>, LAST);

// mldap_modify_ex 函数针对特定会话

// 向 LDAP 目录中添加条目。

int mldap_modify_ex (MLDAP *pldap, char *transaction, char *dn, <List of Attributes>, LAST);

// mldap_rename 函数替换 LDAP 服务器上的 DN

// 项。您可以替换一个或多个属性类型。例如，

// 如果某雇员更改了名称，您可以更改

// 其 CN 属性。如果某雇员换到了其他部门，

// 您可以更改其 OU 属性。

int mldap_rename (char *transaction, char *dn, char *NewDn, LAST);

// mldap_rename_ex 函数针对特定会话替换 LDAP 服务器上

// 的 DN 项。您可以替换

// 一个或多个属性类型。例如，某雇员

// 更改了名称，您可以更改其 CN 属性。

// 如果某雇员换到了其他部门，您可以

// 更改其 OU 属性。

int mldap_rename_ex (MLDAP *pldap, char *transaction, char *dn, char *NewDn, LAST);

// mldap_search 函数在 LDAP 中搜索

// 特定属性。您指明 VuGen 用作搜索

// 基础的 DN。搜索范围可以是

// 基础自身 (base)、基础下一级 (Onelevel) 或

// 基础下的所有级别 (subtree)。您可以

// 指定属性及其值，还可以指定通配符。

// 如果使用通配符，VuGen 将返回指定属性

// 的所有值。

int mldap_search (char *transaction, char *base, char *scope, char *filter, [char *timeout,] [char

*mode,] [const char *SaveAsParam,][const char *Attrs,] LAST);

// mldap_search_ex 函数在 LDAP 中搜索

// 特定属性。您指明 VuGen 用作搜索

// 基础的 DN。搜索范围可以是

// 基础自身 (base)、基础下一级 (Onelevel) 或

// 基础下的所有级别 (subtree)。您可以

// 指定属性及其值，还可以指定通配符。

// 如果使用通配符，VuGen 将返回指定属性

// 的所有值。

int mldap_search_ex (MLDAP *pldap, const char *transaction, const char *base, const char

*scope, const char *filter, [const char *timeout,] [const char *mode,][const char

*SaveAsParam,][const char *Attrs,] LAST);

// mapi_delete_mail 函数删除 MS Exchange 服务器上

// 的当前或选定的电子邮件项。

int mapi_delete_mail(char *transaction, [char *ID,] LAST);

// mapi_delete_mail_ex 函数针对特定会话删除

// MS Exchange 服务器上的邮件。

int mapi_delete_mail_ex(MAPI *ppmapi, char *transaction, [char *ID,] LAST);

// mapi_get_property_sz 函数针对特定会话

// 为 MAPI 属性的值分配缓冲区，并

// 返回指向缓冲区的值。

char* mapi_get_property_sz(char *property);

// mapi_get_property_sz_ex 函数针对特定会话

// 为 MAPI 属性的值分配缓冲区，并

// 返回指向缓冲区的值。

char *mapi_get_property_sz_ex(MAPI *ppmapi, char *property);

// mapi_logon 函数使用简单 MAPI（一种

// MS Exchange 协议)登录到 MS Exchange 服务器。

int mapi_logon(char *transaction, char *profilename, char *profilepass, NULL);

// mapi_logon_ex 针对特定会话登录到

// MS Exchange 服务器。它使用简单 MAPI（一种 MS Exchange

// 协议）执行登录。

int mapi_logon_ex (MAPI *ppmapi, char *transaction, char *profilename, char *profilepass,

NULL);

// mapi_logout 函数从 MS Exchange 服务器注销。

int mapi_logout( );

// mapi_logout_ex 函数针对特定函数

// 从 MAPI 服务器注销。

int mapi_logout_ex(MAPI *ppmapi);

// mapi_read_next_mail 函数使用 MAPI 服务器读取

// 邮件。使用 Peek 选项，可以控制

// 是否将邮件标记为“已读”或“未读”。

int mapi_read_next_mail(char *transaction, char *Show, [char *options,] LAST);

// mapi_read_next_mail_ex 函数针对

// 指定会话读取邮箱中的下一封邮件

// 消息。使用 Peek 选项，可以控制是否

// 将邮件标记为“已读”或“未读”。

int mapi_read_next_mail_ex( MAPI *ppmapi, char *transaction, char *Show, [char *Peek,] [char

*Type,] [char *Save,] [char *MessageId,] LAST );

// mapi_send_mail 函数使用 MAPI 服务器发送邮件消息。

int mapi_send_mail(char *transaction, char *To, [char *CC,] [char *BCC,] [char *Subject,] [char

*Type,] [char *Body,] [ATTACHMENTS,] LAST);

// mapi_send_mail_ex 函数针对指定会话

// 使用 MAPI 服务器发送邮件消息。

int mapi_send_mail_ex(MAPI *ppmapi, char *transaction, char *To, [char *CC,] [char *BCC,]

[char *Subject,] [char *Type,] [char *Body,] [ATTACHMENTS,] LAST);

// mapi_set_property_sz 函数设置 MAPI 会话属性值。

void mapi_set_property_sz(char *property, char *value );

// mapi_set_property_sz_ex 函数针对特定会话

// 设置 MAPI 会话属性值。

void mapi_set_property_sz_ex(MAPI *ppmapi, char *property, char *value);

// mms_close 函数关闭现有媒体播放器

// 会话。此函数仅对活动的播放器会话

// 有效。只有使用持续时间标记，而非 –1（无穷）

// 调用 mms_play 时（流传输尚未完成），播放器会话

// 才会处于活动状态。

int mms_close( );

// mms_close_ex 函数关闭指定的媒体

// 播放器会话。此函数仅对活动播放器

// 会话有效。只有使用持续时间标记，

// 而非 –1（无穷）调用 mms_play 时（流传输尚未完成），

// 播放器会话才会处于活动

// 状态。

int mms_close_ex(MMS *ppmms);

// mms_get_property 函数检索当前

// 媒体剪辑的属性。

double mms_get_property(int property);

// mms_get_property_ex 函数检索当前

// 媒体剪辑的属性。用于特定会话。

double mms_get_property_ex (MMS *ppmms, int property);

// mms_set_property 函数设置媒体播放器剪辑属性。

int mms_set_property(int property, char *value);

// mms_set_property_ex 函数针对特定会话

// 设置媒体剪辑属性。

int mms_set_property_ex(MMS *ppmms, int property, char *value);

// mms_isactive 函数检查 Media Player 是否处于

// 活动状态。它验证 Media Player 是否已打开

// 以及是否正在传入或传出数据。

int mms_isactive( );

// mms_isactive_ex 函数检查 Media Player

// 是否处于活动状态。它针对指定会话验证

// 是否打开了 Media Player，以及

// 是否正在传入或传出数据。

int mms_isactive_ex(MMS *ppmms);

// mms_pause 函数暂停媒体播放器剪辑。只有播放持续时间不为负值时，此函数

// 才起作用。

int mms_pause( );

// mms_pause_ex 函数针对指定会话

// 暂停媒体播放器剪辑。只有播放持续时间不为负值时，此函数

// 才起作用。

int mms_pause_ex(MMS *ppmms);

// mms_play 函数播放媒体播放器剪辑。如果只

// 希望连接到剪辑并手动控制它，请指定持续时间为

// 0，后面再跟所需的函数。

int mms_play(char *transaction, char *URL, [char *duration,] [char *starttime,] LAST);

// mms_play_ex 函数针对指定会话

// 播放媒体播放器剪辑。

int mms_play_ex(MMS *ppmms, char *transaction, char *URL, [char *duration,] [char

*starttime,] LAST);

// 在使用 mms_pause 暂停播放媒体剪辑后，

// mms_resume 函数继续播放。只有播放持续时间

// 不为负值时，此函数才起作用。

int mms_resume( DWORD resumetime, DWORD duration);

// 在指定会话中，在使用 mms_pause 暂停播放

// 媒体剪辑后，mms_resume_ex 函数继续

// 播放。只有播放持续时间不为负值时，此函数

// 才起作用。

int mms_resume_ex( MMS *ppmms, DWORD resumetime, DWORD duration);

// mms_sampling 函数通过收集指定

// 持续时间内的统计信息来采样播放媒体剪辑。

// 只有播放持续时间为无限（mms_play 中的

// 持续时间值设为 0）时，此函数才起作用。

int mms_sampling(DWORD duration);

// mms_sampling_ex 函数通过收集

// 指定持续时间内的统计信息来获取

// Media Player 会话采样。只有播放持续时间为无限

// （mms_play_ex 中的持续时间值设为 0）时，

// 此函数才起作用。

int mms_sampling_ex(MMS *ppmms, DWORD duration);

// mms_set_timeout 函数设置用于

// 打开或关闭剪辑的 Media Player 超时值。

int mms_set_timeout (int type, int value);

// mms_set_timeout_ex 函数针对特定会话、设置用于

// 打开或关闭剪辑的 Media Player 超时值。

int mms_set_timeout_ex (MMS *ppmms, int type, int value);

// mms_stop 函数停止播放 Media Player

// 剪辑。只有播放持续时间为无限（mms_play 中的

// 持续时间值设为 0）时，此函数才起作用。

int mms_stop( );

// mms_stop_ex 函数针对特定会话

// 停止播放媒体播放器剪辑。只有播放持续时间为无限

// （mms_play_ex 中的持续时间值设为 0）时，

// 此函数才起作用。

int mms_stop_ex(MMS *ppmms);

// nca_button_double_press 函数两次按指定的

// 推按钮。

int nca_button_double_press (LPCSTR name);

// nca_button_press 函数激活指定的推按钮。

int nca_button_press ( LPCSTR button );

// nca_button_set 函数将按钮状态设置为 ON

// 或 OFF。TOGGLE 选项反转当前状态。

int nca_button_set ( LPCSTR button, int istate );

// nca_combo_select_item 函数选择组合框中的项目。

int nca_combo_select_item (LPCSTR name, LPCSTR item_name);

// nca_combo_set_item 函数将 item_name 写入组合框名称。

int nca_combo_set_item ( LPCSTR name, LPCSTR item_name );

// nca_connect_server 函数使用指定的主机、端口号和模块

// 连接到 Oracle NCA 数据库服务器。

int nca_connect_server (LPCSTR host, LPCSTR port, LPCSTR command_line);

// nca_console_get_text 函数检索

// Oracle NCA 控制台消息。

int nca_console_get_text (char *text);

// nca_edit_box_press 函数在编辑框消息上按下。

int nca_edit_box_press (LPCSTR name);

// nca_edit_click 函数在指定编辑对象内单击，

// 以便将光标放置在框中。一旦

// 光标位于框中，用户就可以键入值

// 或从值列表中选择一个值。

int nca_edit_click ( LPCSTR edit );

// nca_edit_get_text 函数返回在

// 指定的编辑对象中找到的所有文本。

int nca_edit_get_text ( LPCSTR edit, char *out_string );

// nca_edit_press 函数激活编辑字段中的

// “浏览”按钮。这将打开可用值列表。

int nca_edit_press ( LPCSTR edit );

// nca_edit_set 函数将编辑对象的内容设置为

// 指定的字符串。它将替换现有字符串。

int nca_edit_set ( LPCSTR edit, LPCSTR text );

// nca_flex_click_cell 函数在 Flexfield 窗口中的

// 指定表单元格中单击。

int nca_flex_click_cell ( LPCSTR name, LPCSTR row, LPCSTR column);

// nca_flex_get_cell_data 函数获取 Flexfield 中指定单元格

// 的内容，并将其存储在变量中。

int nca_flex_get_cell_data(LPCSTR name, LPCSTR row, LPCSTR column, LPSTR data);

// nca_flex_get_column_name 函数获取 Flexfield 窗口中

// 某列的名称。此函数将列名写入

// 输出参数 column_name。

int nca_flex_get_column_name ( LPCSTR window_name, int column, LPCSTR column_name );

// nca_flex_get_row_name 函数获取 Flexfield 窗口中

// 某行的名称。此函数将行名写入

// 输出参数 row_name。

int nca_flex_get_row_name ( LPCSTR window_name, int row, LPCSTR row_name );

// nca_flex_press_clear 函数按

// 指定 Flexfield 窗口中的“清除”按钮。

int nca_flex_press_clear (LPCSTR name );

// nca_flex_press_find 函数按

// 指定 Flexfield 窗口中的“查找”按钮。

int nca_flex_press_find ( LPCSTR name );

// nca_flex_press_help 函数按指定

// Flexfield 窗口中的“帮助”按钮（问号）。

int nca_flex_press_help ( LPCSTR name );

// nca_flex_press_lov 函数单击

// 指定 Flexfield 窗口中的“值列表”按钮，

--------------------------------------------------------------------------------

Page 

阿祖总结－Zu.Stone@QQ.com

// 以便显示活动字段的值列表。

int nca_flex_press_lov( LPCSTR name, LPCSTR row, LPCSTR column );

// nca_flex_press_ok 函数按指定

// Flexfield 窗口中的“确定”按钮。

int nca_flex_press_ok ( LPCSTR name );

// nca_flex_set_cell_data 函数设置指定

// Flexfield 窗口中的单元格数据。

int nca_flex_set_cell_data ( LPCSTR name, LPCSTR row, LPCSTR column, LPCSTR data );

// nca_flex_set_cell_data_press_ok 函数在手动

// 向 Flexfield 中输入（而不是从值列表中

// 选择）数据之后按 Flexfield 窗口中的

// “确定”按钮。

int nca_flex_set_cell_data_press_ok ( LPCSTR name, LPCSTR row, LPCSTR column, LPCSTR

data );

// exit_oracle_application 函数断开与

// Oracle NCA 数据库服务器的连接，并退出应用程序。

int exit_oracle_application( );

// nca_get_top_window 函数将顶部窗口的名称分配给

// 由 winName 指向的用户分配的缓冲区。

int nca_get_top_window ( char *winName);

// nca_java_action 函数使用指定参数

// 在 Java 对象上执行事件。

int nca_java_action(LPCSTR name, LPCSTR event, LPCSTR arglist);

// 使用 nca_java_delete_name 可以删除用于存储属性的内存

// （这些属性是录制 Java 对象时由 Vugen

// 保存的）。只有在 nca_java_set_option 中启用了

// JAVA_SAVE_PROP 选项，Vugen 才会保存 Java 对象。。

int nca_java_delete_name(LPCSTR name, LPCSTR property_name);

// nca_java_get_value 函数检索指定

// Java 对象的值。

int nca_java_get_value(LPCSTR name, char *value );

// nca_java_get_value_ex 检索 Java 对象内指定

// 属性 property_name 的值。

int nca_java_get_value_ex (LPCSTR name, LPCSTR property_name, LPSTR property_value);

// nca_java_set_option 函数在录制 Java 对象时设置选项。

int nca_java_set_option(int option, < option value > );

// nca_java_set_reply_property 函数设置

// 指定的 Java 回复属性。

void nca_java_set_reply_property (void * ReplyPropList);

// nca_list_activate_item 函数双击列表中的

// 项目。项目通过其逻辑名称指定。

int nca_list_activate_item ( LPCSTR list, LPCSTR item );

// nca_list_get_text 从列表中检索选定项目并放到 value 中。

int nca_list_get_text( LPCSTR name, char *value );

// nca_list_select_item 函数从列表中

// 选择项目（在项目上执行一次鼠标单击）。

// 项目通过其名称指定。

int nca_list_select_item ( LPCSTR list, LPCSTR item );

// nca_list_select_index_item 函数从列表中

// 选择项目（在项目上执行一次鼠标单击）。该项目

// 通过其数字索引指明。该索引被指定为

// 字符串，起始值为 0。

int nca_list_select_index_item ( LPCSTR list, int index );

// nca_logon_connect 函数执行到 Oracle NCA

// 数据库的登录。它使用指定的用户名和密码

// 连接到数据库。

int nca_logon_connect (LPCSTR connection_name, LPCSTR username, LPCSTR password,

LPCSTR database);

// nca_logon_cancel 函数取消与 Oracle NCA

// 数据库的连接。连接名称通过

// nca_logon_connect 的 connection_name

// 参数设置。但是，此函数并不断开与服务器

// 的连接。

int nca_logon_cancel (LPCSTR name);

// nca_lov_auto_select 函数输入一个字母

// 来指明要从值列表中选择的项目的第一个

// 字符。以指定字母开头的项目

// 被选中。如果存在多个以该字母

// 开头的项目，那么所有匹配的值都将显示在列表中，

// 您需要从新列表中选择一个

// 项目。

int nca_lov_auto_select ( LPCSTR name, char selection );

// nca_lov_find_value 函数查找对象的

// 值列表。当您单击“值列表”窗口中的“查找”

// 按钮时，将录制此函数。

int nca_lov_find_value ( LPCSTR name, LPCSTR value );

// nca_lov_get_item_name 函数在值列表中检索

// 某项目的名称，并将其写入该函数

// 的 value 参数。调用该函数之前，必须为值分配足够的

// 内存空间。

int nca_lov_get_item_name ( LPCSTR name, int item_index, char *value);

// nca_lov_retrieve_items 函数基于指定的

// 范围，从值列表中检索项目。该范围

// 通过函数的参数 first_item 和 last_item

// 指定，其中“1”表示第一个项目。

int nca_lov_retrieve_items ( LPCSTR name, int first_item, int last_item );

// nca_lov_select_index_item 函数使用项目的索引编号

// 从值列表中选择项目。

int nca_lov_select_index_item ( LPCSTR name, int index );

// nca_lov_select_item 函数从值列表中选择项目。

int nca_lov_select_item ( LPCSTR name, LPCSTR item );

// nca_lov_select_random_item 函数从值列表中

// 选择随机项目。第二个参数是

// 输出参数，用于指明随机选择时

// 选择的是哪个值。

int nca_lov_select_random_item ( LPCSTR name, char *item );

// nca_menu_select_item 函数根据

// 菜单的逻辑名称和项目的名称从菜单中选择

// 项目。注意，菜单和项目表示分别表示为

// 单个字符串，并使用分号分隔。

int nca_menu_select_item ( LPCSTR window, LPCSTR menu;item );

// nca_message_box_press 函数按

// 消息窗口中的指定按钮。该按钮通过其索引指定，

// 通常是从左到右

// 的按钮顺序。例如，如果消息框包含

// 三个按钮：“是”、“否”和“取消”，那么相应的

// 索引可能为 1、2 和 3。

int nca_message_box_press ( LPCSTR name, int button );

// nca_obj_get_info 函数检索指定属性的值，

// 并存储在 out_value 中。

int nca_obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );

// nca_obj_mouse_click 函数在

// 对象内的指定坐标处单击鼠标。

int nca_obj_mouse_click ( LPCSTR object, int x, int y, unsigned char modifier);

// nca_obj_mouse_dbl_click 函数在

// 对象内的指定坐标处双击鼠标。

int nca_obj_mouse_dbl_click ( LPCSTR object, int x, int y, unsigned char modifier);

// nca_obj_status 函数返回指定对象的状态。

int nca_obj_status ( LPCSTR name );

// nca_obj_type 函数指定 keyboard_input 将

// 发送到的对象。此函数录制

// 特殊字符，如 Tab 键、功能键以及

// 快捷键组合。

int nca_obj_type ( LPCSTR object, unsigned char keyboard_input, unsigned char modifier);

// nca_popup_message_press 函数按

// 消息窗口中的指定按钮。

int nca_popup_message_press ( LPCSTR name, LPCSTR button );

// nca_response_get_cell_data 函数从“响应”框

// 中的单元格中检索数据。应指定“响应”对象

// 的名称和字段的名称。

int nca_response_get_cell_data ( const char *name, const char * rowname, char * data);

// nca_response_press_lov 函数单击“响应”框

// 中的下拉箭头。

int nca_response_press_lov(LPCSTR name, LPCSTR field);

// nca_response_press_ok 函数按指定响应框

// 中的“确定”

int nca_response_press_ok (LPCSTR name);

// nca_response_set_cell_data 函数向“响应”框中

// 的单元格中插入数据。应指定“响应”对象的名称、

// 单元格的名称以及数据。

int nca_response_set_cell_data (LPCSTR name, LPCSTR cell, LPCSTR data);

// nca_response_set_data 函数向“响应”框中

// 插入数据。应指定“响应”对象的名称

// 和数据。

int nca_response_set_data (LPCSTR name, LPCSTR data);

// nca_scroll_drag_from_min 函数从最小位置

// 滚动到指定距离。

int nca_scroll_drag_from_min ( LPCSTR object, int position );

// nca_scroll_line 函数滚动指定的

// 行数。此函数可用于

// 滚动栏和滑块对象。

int nca_scroll_line ( LPCSTR scroll, int lines );

// nca_scroll_page 函数滚动指定的

// 页数。此函数可用于

// 滚动栏和滑块对象。

int nca_scroll_page ( LPCSTR scroll, int pages );

// Vugen 将 nca_set_connect_opt 插入到 nca_connect_server 的前面，

// 这样就能识别为服务器连接

// 录制的值将不同于默认值。

// 保存录制的值将确保与服务器

// 的连接与录制脚本期间的服务器连接完全

// 相同。

int nca_set_connect_opt (eConnectionOption option, ...);

// nca_set_custom_dbtrace 设置在应用程序中

// 启用 DB 跟踪的自定义函数。如果使用

// 内置机制无法启用 DB 跟踪，可能需要

// nca_set_custom_dbtrace 和 nca_set_dbtrace_file_index。

// 当自定义应用程序包含非标准 UI 时，可能

// 会出现这种情况。nca_set_custom_dbtrace

// 设置在应用程序中启用 DB 跟踪的

// 自定义函数。

void nca_set_custom_dbtrace(long function);

// nca_set_dbtrace_file_index 标识跟踪文件，以便

// 以后供控制器和分析使用。如果使用

// 内置机制无法启用 DB 跟踪，可能需要

// nca_set_dbtrace_file_index 和 nca_set_custom_dbtrace。当

// 自定义应用程序包含非标准 UI 时，可能会出现

// 这种情况。

void nca_set_dbtrace_file_index(LPCSTR fileindex);

// nca_set_exception 函数指定在出现

// 异常时应执行的操作。应指定要调用以处理

// 异常窗口的函数。

void nca_set_exception (LPCSTR title, long function, [void *this_context]);

// 当显示了“启用诊断”窗口而且其中的密码

// 不同于默认值“apps”时，使用

// nca_set_diagnostics_password。必须在

// nca_connect_server 的后面添加此函数调用。

void nca_set_diagnostics_password( LPCSTR password );

// nca_set_iteration_offset 函数设置对象

// ID 编号的偏移值。在 Oracle NCA 脚本

// 常规录制中，VuGen 会录制每个

// 对象的名称。（在起始页中设置 record=names）。

// 如果您的版本不支持 record=names

// 标记，VuGen 将为每个对象生成一个新 ID 编号。

// 运行脚本的多次循环时，对象在

// 每次打开都将生成新的 ID 编号。

// 因此，当您回放脚本时，特殊对象

// 的 ID 编号将与首次循环之后

// 同一对象的 ID 不匹配，从而导致测试

// 失败。

void nca_set_iteration_offset (int offset);

// nca_set_server_response_time 函数为 Oracle NCA

// 服务器指定响应超时值。这是用户

// 向服务器发送请求之后继续停留在

// 侦听状态的时间。

void nca_set_server_response_time(int time);

// nca_set_think_time 函数指定脚本

// 执行期间使用的思考时间范围。测试使用指定时间

// 范围内的随机思考时间，并在每次操作之后暂停该

// 思考时间长度。

void nca_set_think_time ( DWORD start_range, DWORD end_range );

// nca_set_window 函数指明活动窗口的名称。

int nca_set_window ( LPCSTR window);

// nca_tab_select_item 函数选择选项卡项目。

int nca_tab_select_item ( LPCSTR tab, LPCSTR item );

// nca_tree_activate_item 函数激活

// Oracle NCA 树中的指定项目。

int nca_tree_activate_item (LPCSTR name, LPCSTR item);

// nca_tree_select_item 函数选择

// Oracle NCA 树中的指定项目。

int nca_tree_select_item (LPCSTR name, LPCSTR item);

// nca_tree_expand_item 函数展开 Oracle NCA 树中的节点。

int nca_tree_expand_item (LPCSTR name, LPCSTR item);

// nca_tree_collapse_item 函数折叠

// Oracle NCA 树中的节点。

int nca_tree_collapse_item (LPCSTR name, LPCSTR item);

// nca_win_close 函数关闭指定窗口。

int nca_win_close ( LPCSTR window );

// nca_win_get_info 函数检索指定属性的值，

// 并存储在 out_value 中。

int nca_win_get_info ( LPCSTR window, LPCSTR property, char *out_value );

// nca_win_move 将某窗口移到一个新的绝对位置。

int nca_win_move ( LPCSTR window, int x, int y );

// nca_win_resize 函数更改窗口的位置。

int nca_win_resize ( LPCSTR window, int width, int height );

// pop3_command 函数向 POP3 服务器发送

// 命令。服务器返回命令结果。

// 例如，如果发送命令“UIDL 1”，服务器将返回

// 第一封邮件的唯一 ID。

long pop3_command(char *transaction, char *command, [char *command,] [char

*save_to_param,] LAST);

// pop3_command_ex 函数针对特定会话

// 向 POP3 服务器发送命令。服务器

// 返回命令结果。例如，如果

// 发送命令“UIDL 1”，服务器将返回

// 第一封邮件的唯一 ID。

long pop3_command_ex (POP3 *pppop3, char *transaction, char *command, [char *command,]

LAST);

// pop3_delete 函数删除 POP3 服务器上的邮件。

long pop3_delete(char *transaction, char *deleteList, [char *save_to_param,] LAST);

// pop3_delete_ex 函数针对特定会话

// 删除 POP3 服务器上的邮件。

long pop3_delete_ex(POP3 *pppop3, char *transaction, char *deleteList, LAST);

// pop3_logon 函数登录到 POP3 服务器。

// 它使用 FTP 协议使用的格式。

int pop3_logon (char *transaction, char *url, LAST);

// pop3_logon_ex 函数针对特定会话登录

// 到 POP3 服务器。它使用 FTP 协议使用的格式。

int pop3_logon_ex (POP3 *pppop3, char *transaction, char *url, LAST);

// pop3_logoff 函数从 POP3 服务器注销。

long pop3_logoff( );

// pop3_logoff_ex 函数针对特定会话

// 从 POP3 服务器注销。

long pop3_logoff_ex(POP3 *pppop3);

// pop3_free 函数释放 POP3 服务器并取消

// 所有挂起的命令。

void pop3_free( );

// pop3_free_ex 函数针对特定会话释放 POP3

// 服务器，并取消所有挂起的命令。

void pop3_free_ex(POP3 *pppop3);

// pop3_list 函数列出 POP3

// 服务器上的邮件。它返回该服务器上

// 存在的邮件总数。

long pop3_list(char *transaction, [char *save_to_param,] LAST);

// pop3_list_ex 函数针对特定会话

// 列出 POP3 服务器上的邮件。它返回该服务器上

// 存在的邮件总数。

long pop3_list_ex (POP3 *pppop3, char *transaction, LAST);

// pop3_retrieve 函数从 POP3 服务器

// 检索邮件。您可以指定邮件范围或

// 所有邮件。默认情况下，它在检索邮件之后

// 将其从服务器中删除。

long pop3_retrieve(char *transaction, char *retrieveList, < Options, > LAST);

// pop3_retrieve_ex 函数从 POP3 服务器

// 检索邮件。您可以指定邮件范围或

// 所有邮件。默认情况下，它在检索邮件之后

// 将其从服务器中删除。

long pop3_retrieve_ex(POP3 *pppop3, char *transaction, char *retrieveList, char * deleteFlag,

[<Options>,] LAST);

// lreal_clip_size 函数返回当前与

// 播放器关联的剪辑的大小，单位为毫秒。

unsigned long lreal_clip_size(int miPlayerID);

// lreal_close_player 函数关闭

// RealPlayer 的指定示例。

int lreal_close_player ( int miplayerID );

// lreal_current_time 用于查明剪辑已运行

// 多长时间。返回的时间以毫秒为单位。

unsigned long lreal_current_time( int miplayerID );

// lreal_get_property 获取播放器的属性。

int lreal_get_property ( int miPlayerID, unsigned int miProperty );

// lreal_open_player 函数创建新的 RealPlayer 实例。

int lreal_open_player ( int miplayerID );

// lreal_open_url 函数将 URL 与

// RealPlayer 实例相关联。使用 lreal_play 向

// 实例发出命令让其播放时，将显示此处

// 指定的 szURL。

int lreal_open_url ( int miplayerID, LPSTR szURL );

// lreal_pause 函数将 RealPlayer 实例

// 暂停一段指定的时间（单位为毫秒）。此函数

// 模拟 RealPlayer 的“播放”菜单中的“暂停”命令。

int lreal_pause ( int miplayerID, unsigned long mulPauseTime );

// lreal_play 函数播放 RealPlayer 剪辑

// 一段指定的时间（单位为毫秒）。此函数

// 模拟 RealPlayer 的“播放”菜单中的“播放”命令。

int lreal_play ( int miplayerID, long mulTimeToPlay );

// lreal_seek 函数搜寻当前剪辑中的

// 指定位置。此函数模拟 RealPlayer 的

// “播放”菜单中的“搜寻至位置”命令。注意，

// 您必须输入以毫秒为单位的时间。

int lreal_seek ( int miplayerID, unsigned long mulTimeToSeek );

// lreal_stop 函数停止播放 RealPlayer 实例。此

// 函数模拟 RealPlayer 的“播放”菜单中的“停止”命令。

int lreal_stop ( int miplayerID);

// TE_connect 函数在您录制与主机

// 的连接时由 VuGen 生成。使用 com_string 的

// 内容连接到主机。

int TE_connect ( const char *com_string, unsigned int timeout );

// TE_find_text 搜索与通过 col1,

// row1, col2, row2 定义的矩形中的模式匹配的

// 文本。与模式匹配的文本将返回给

// match，实际的行与列位置将返回给

// retcol 和 retrow。搜索从矩形

// 左上角开始。

int TE_find_text ( const char *pattern, int col1, int row1, int col2, int row2, int *retcol, int *retrow,

char *match );

// TE_get_cursor_pos 返回当前鼠标在终端仿真器

// 屏幕上的位置的坐标。

int TE_get_cursor_pos ( int *col, int *row );

// TE_get_line_attribute 检查终端屏幕中

// 一行文本的格式。行中的第一个字符

// 由 col, row 定义。行中最后一个

// 字符的列坐标由 Width

// 指定。该函数将每个字符的字符格式存储在

// 缓冲区 buf 中。

char * TE_get_line_attribute ( int col, int row, int width, char *buf );

// TE_get_text_line 将一行文本从终端屏幕复制到

// 缓冲区。行中的第一个字符

// 由 col, row 定义。行中最后一个

// 字符的列坐标由 Width

// 指定。如果该行包含制表符或空格，将返回相同

// 数目的空格。

char * TE_get_text_line ( int col, int row, int width, char *text );

// TE_getvar 函数返回 RTE 系统变量的值。

int TE_getvar ( int var );

// TE_set_cursor_pos 将鼠标位置设置为 col, row。

int TE_set_cursor_pos( int col, int row );

// TE_setvar 函数设置 RTE 系统变量。

int TE_setvar ( int var, int val );

// TE_perror 将 TE_errno 的当前值转换为

// 相应的错误字符串，设置字符串格式，并将其发送到

// Topaz 代理日志或 LoadRunner 输出窗口。

void TE_perror ( char *prefix );

// TE_sperror 将 TE_errno 的当前值转换为

// 相应的错误字符串。

char *TE_sperror ();

// TE_type 函数描述发送到

// 终端仿真器的键盘输入。

int TE_type ( const char *string );

// TE_unlock_keyboard 用于在因为

// 出现错误消息而导致大型机终端的键盘

// 被锁定之后解除锁定。TE_unlock_keyboard 等价于

// 按 F3 键。

int TE_unlock_keyboard ( void );

// TE_typing_style 函数确定键入的

// 字符串如何提交给在终端仿真器上运行的

// 客户端应用程序。如果选择 FAST，

// 将把字符作为单个字符串发送。

// 此输入方式不需要参数。

int TE_typing_style ( const char *style );

// 回放期间，TE_wait_cursor 等待鼠标出现在

// 终端窗口中的指定位置。

int TE_wait_cursor ( int col, int row, int stable, int timeout );

// TE_wait_silent 函数等待客户端

// 应用程序静默指定的时间。当终端仿真器

// 未接到任何字符时，认为客户端处于

// 静默状态。如果客户端应用程序

// 由于过了超时时间（以秒为单位）

// 而未静默认指定的时间，该函数将

// 返回错误。

int TE_wait_silent ( int sec, int milli, int timeout );

// 执行期间，TE_wait_sync 函数暂停

// 脚本执行，并等待“X SYSTEM”消息

// 从屏幕上消失之后再继续。出现

// “X SYSTEM”消息表示系统处于“内部输入”

// 模式。

int TE_wait_sync (void);

// 您可以指示 VuGen 录制每次

// 进入 X SYSTEM 模式时系统停留在 X SYSTEM

// 模式的时间。要这样做，VuGen 在每个 TE_wait_sync 函数之后插入

// TE_wait_sync_transaction 函数。

int TE_wait_sync_transaction (char *transaction_name );

// TE_wait_text 函数等待与通过 col1,

// row1, col2, row2 定义的矩形中

// 的模式匹配的文本。与模式

// 匹配的文本将返回给 match，实际的

// 行和列位置返回给 retcol 和

// retrow。如果模式超时时间已过而未

// 显示模式，该函数将返回错误

// 代码。如果模式已显示在屏幕上，

// 该函数将立即返回。

int TE_wait_text ( const char *pattern, int timeout [, int col1, int row1, int col2, int row2, int

*retcol, int *retrow, char *match ] );

// TE_run_script_command 执行 PSL 命令。

int TE_run_script_command ( const char *command );

// TE_run_script_file 运行 PSL 脚本文件。

int TE_run_script_file ( const char *filename );

// sapgui_active_object_from_parent_method 函数

// 使用 ID 编号 control_id 从大的

// 父级对象中选择对象。嵌入的

// 对象由方法 method_name 返回。

int sapgui_active_object_from_parent_method ( const char *control_id, const char *method_name,

char *arg1, ..., char *argn, [optionArguments,] LAST );

// sapgui_active_object_from_parent_property 函数

// 使用 ID 编号 control_id 从大的

// 父级对象中选择对象。嵌入的

// 对象由属性 property_name 返回。

int sapgui_active_object_from_parent_property (const char *control_id, const char

*property_name, [args,] LAST);

// sapgui_calendar_focus_date 将焦点置于

// 日历中的日期上。从日历中选择

// 日期时，将自动录制此函数。

// 但是，实际返回日期的函数是

// sapgui_calendar_select_interval。

int sapgui_calendar_focus_date(const char *description, const char *calendarID, const char *date,

[args,] LAST ) ;

// sapgui_calendar_scroll_to_date 模拟使用

// 滚动栏使日期可见的操作。它不是通过

// 将焦点置于日期上来选择日期。

int sapgui_calendar_scroll_to_date(const char *description, const char *calendarID, const char

*date, [args,] LAST ) ;

// sapgui_calendar_select_interval 从日历中

// 将日期间隔返回给调用日历

// 弹出框时焦点所在的控件。它等价于

// 在不显示日历的情况下，将控件文本

// 设置为日期字符串。

int sapgui_calendar_select_interval(const char *description, const char *calendarID, const char

*interval, [args,] LAST ) ;

// sapgui_call_method 函数使用 SAP 标识符

// control_id 来标识 SAP 对象，并调用

// 对象的方法 method_name。它向方法传递

// 实际参数 arg1...argn。

int sapgui_call_method ( const char *control_id, const char *method_name, void *arg1, ..., void

*argn, [optionalArguments] LAST );

// sapgui_call_method_of_active_object 函数调用

// 通过 sapgui_active_object_from_parent_method

// 或 sapgui_active_object_from_parent_property

// 选择的当前活动对象的方法 method_name。

int sapgui_call_method_of_active_object ( const char *method_name, char *arg1, [args,] char

*argn, [optionalArguments,] LAST );

// sapgui_create_new_session 创建一个新会话。它等价于

// 从“系统”菜单中选择“创建会话”。

int sapgui_create_new_session([optionalArgs,] LAST );

// sapgui_get_active_window_title 数据检索函数

// 获取当前 SAP 会话中活动窗口的名称，

// 并保存到 output_param_name 中。

int sapgui_get_active_window_title (const char *output_param_name, [args,] LAST);

// sapgui_get_ok_code 数据检索函数获取

// “命令”字段的文本。“命令”字段是主窗口中

// 第一个工具栏左边的框。

int sapgui_get_ok_code( const char *outParamName, [args,] LAST);

// sapgui_get_property 数据检索函数获取

// ID 编号为 control_id 的 SAP 对象中

// 指定属性 property_name 的值。

// 该值保存在 output_param_name 中。

int sapgui_get_property ( const char *control_id, const char *property_name, char

*output_param_name, [args,] LAST);

// sapgui_get_property_of_active_object 数据检索

// 函数从当前活动对象中检索

// 指定属性 property_name 的值。

// 该值保存在 output_param_name 中。

int sapgui_get_property_of_active_object ( const char *property_name, const char

*output_param_name, [args,] LAST );

// sapgui_get_text 数据检索函数

// 获取任意可视屏幕对象的文本属性，

// 并保存到参数 outParamName 中。

int sapgui_get_text(const char *description, const char *controlID, const char *outParamName,

[args,] LAST);

// sapgui_grid_fill_data 在网格中输入表格数据

// 参数。当您在网格中输入数据并按 Enter 时，

// 录制此函数。表格参数 paramName 是

// 自动创建的。录制之后，可以在 VuGen 中编辑此表格参数，

// 以便更改数据。

int sapgui_grid_fill_data( const char *description, const char *gridID, const char *paramName,

[args,] LAST );

// sapgui_grid_clear_selection 取消选择已在网格控件中

// 选定的所有单元格、行和列。

int sapgui_grid_clear_selection(const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_click 模拟用户在通过“row”或

// “column”指定的网格单元格中单击。

int sapgui_grid_click(const char *description, const char *gridID, const char *row, const char

*column, [args,] LAST );

// sapgui_grid_click_current_cell 模拟用户

// 在当前选定的单元格中单击。

int sapgui_grid_click_current_cell(const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_deselect_column 取消选择某列。

int sapgui_grid_deselect_column(const char *description, const char *gridID, const char* column,

[args,] LAST );

// sapgui_grid_double_click 模拟用户在

// 网格中的单元格中双击。

int sapgui_grid_double_click(const char *description, const char *gridID, const char *row, const

char *column, [args,] LAST );

// sapgui_grid_double_click_current_cell 模拟用户在

// 当前选定的单元格中双击。

int sapgui_grid_double_click_current_cell(const char *description, const char *gridID, [args,]

LAST );

// sapgui_grid_get_cell_data 数据检索函数

// 获取网格单元格中的数据，并保存到 outParamName 中。

int sapgui_grid_get_cell_data(const char *description, const char *gridID, const char *row, const

char *column, const char *outParamName, [args,] LAST );

// sapgui_grid_get_columns_count 数据检索

// 函数获取网格中的列数。

int sapgui_grid_get_columns_count(const char *description, const char *gridID, const char

*outParamName, [args,] LAST );

// sapgui_grid_get_current_cell_column 数据

// 检索函数获取当前活动单元格的列标识符，

// 并保存到 outparamName 中。

int sapgui_grid_get_current_cell_column(const char *description, const char *gridID, const char

*outParamName, [args,] LAST );

// sapgui_grid_get_current_cell_row 数据

// 检索函数获取当前活动单元格的行号，

// 并保存到 outparamName 中。

int sapgui_grid_get_current_cell_row(const char *description, const char *gridID, const char

*outParamName, [args,] LAST );

// sapgui_grid_get_rows_count 数据检索

// 函数获取网格中的行数。

int sapgui_grid_get_rows_count(const char *description, const char *gridID, const char

*outParamName, [args,] LAST );

// sapgui_grid_is_checkbox_selected 验证

// 函数在复选框被选中时返回 true，

// 在复选框未被选中时返回 false。

int sapgui_grid_is_checkbox_selected(const char *description, const char *gridID, const char

*row, const char *column, [args,] LAST );

// sapgui_grid_open_context_menu 模拟用户

// 在网格中右键单击以便打开上下文菜单。

int sapgui_grid_open_context_menu(const char *description, const char *gridID, [args,]

LAST );

// sapgui_grid_press_button 函数单击网格单元格中的按钮。

int sapgui_grid_press_button(const char *description, const char *gridID, const char *row, const

char *column, [args,] LAST );

// sapgui_grid_press_button_current_cell 模拟用户

// 单击当前活动的网格单元格中的按钮。

int sapgui_grid_press_button_current_cell(const char *description, const char *gridID, [args,]

LAST );

// sapgui_grid_press_column_header 模拟用户

// 单击网格控件中的列标题。

int sapgui_grid_press_column_header(const char *description, const char *gridID, const char

*column, [args,] LAST );

// sapgui_grid_press_ENTER 模拟用户

// 在网格处于活动状态时按 Enter 键。

int sapgui_grid_press_ENTER (const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_press_F1 模拟用户

// 在网格处于活动状态时按 F1 键。其结果是

// 显示上下文相关帮助。

int sapgui_grid_press_F1 (const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_press_F4 模拟用户在网格处于

// 活动状态时按 F4 键。其结果通常是

// 显示活动字段可能的选项。

int sapgui_grid_press_F4 (const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_press_toolbar_button 模拟

// 用户单击网格工具栏按钮。

int sapgui_grid_press_toolbar_button(const char *description, const char *gridID, const char

*buttonID, [args,] LAST );

// sapgui_grid_press_toolbar_context_button 模拟用户

// 通过单击上下文按钮打开选项列表。

int sapgui_grid_press_toolbar_context_button(const char *description, const char *gridID, const

char *buttonID, [args,] LAST );

// sapgui_grid_press_total_row 函数按

// 网格单元格中的总计行按钮。如果总计

// 行被精简了，该函数将展开它。如果总计行

// 已展开，该函数将精简它。

int sapgui_grid_press_total_row(const char *description, const char *gridID, const char *row,

const char *column, [args,] LAST );

// sapgui_grid_press_total_row_current_cell 函数按

// 当前活动网格单元格中的总计行按钮。

// 如果总计行被精简了，该函数将展开它。

// 如果总计行已展开，该函数将精简它。

int sapgui_grid_press_total_row_current_cell(const char *description, const char *gridID, [args,]

LAST );

// sapgui_grid_scroll_to_row 滚动到网格中的指定行，

// 从而使其可见。它不会选择行。

int sapgui_grid_scroll_to_row(const char *description, const char *gridID, const char *row, [args,]

LAST ) ;

// sapgui_grid_select_all 选择网格控件中的所有单元格。

int sapgui_grid_select_all(const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_select_cell 选择网格控件中的单个单元格。

int sapgui_grid_select_cell(const char *description, const char *gridID, const char *row, const

char *column, [args,] LAST );

// sapgui_grid_select_cell_column 选择与当前选择

// 位于同一行但位于不同列的单元格。

// 它在同一行中向左或向右移动选择，以便移动到

// 由参数 column 指定的列号。

int sapgui_grid_select_cell_column(const char *description, const char *gridID, const char

*column, [args,] LAST );

// sapgui_grid_select_cell_row 选择与当前选择

// 位于同一列但位于不同行的单元格。

// 它在同一列中向上或向下移动选择，以便移动到

// 由参数 row 指定的行号。

int sapgui_grid_select_cell_row(const char *description, const char *gridID, const char *row,

[args,] LAST );

// sapgui_grid_select_cells 函数选择

// 网格中的单元格。单元格列表以

// “LAST”或“BEGIN_OPTIONAL”结束。

int sapgui_grid_select_cells(const char *description, const char *gridID, const char *cell1 ,...,

celln, [args,] LAST );

// sapgui_grid_select_column 选择网格控件中的一列。

int sapgui_grid_select_column ( const char *description, const char *gridID, const char* column,

[optionalArgs,] LAST );

// sapgui_grid_select_columns 选择网格控件中的

// 一列或多列。这些列不必相邻，

// 也不必按照网格中的显示顺序传递给

// 函数。

int sapgui_grid_select_columns(const char *description, const char *gridID, char *arg1, ..., char

*argn, [optionalArgs,] LAST);

// sapgui_grid_select_context_menu 模拟用户

// 从上下文菜单中选择选项。

int sapgui_grid_select_context_menu(const char *description, const char *gridID, const char

*functionCode, [args,] LAST );

// sapgui_grid_select_rows 选择网格单元格中的一行或多行。

int sapgui_grid_select_rows(const char *description, const char *gridID, const char *rows, [args,]

LAST );

// sapgui_grid_select_toolbar_menu 模拟用户

// 从网格工具栏菜单中选择选项。

int sapgui_grid_select_toolbar_menu(const char *description, const char *gridID, const char

*functionCode, [args,] LAST );

// sapgui_grid_selection_changed 验证函数

// 返回选择是否已发生更改。

int sapgui_grid_selection_changed(const char *description, const char *gridID, [args,] LAST );

// sapgui_grid_set_cell_data 在网格单元格中插入数据。字符串

// newValue 被写入位于 row 和 column 的单元格中。

int sapgui_grid_set_cell_data(const char *description, const char *gridID, const char *row, const

char *column, const char *newValue, [args,] LAST );

// sapgui_grid_set_checkbox 函数选择或清除网格复选框。

int sapgui_grid_set_checkbox(const char *description, const char *gridID, const char *row, const

char *column, const char *newValue, [args,] LAST );

// sapgui_grid_set_column_order 模拟用户

// 将列拖动到网格中的新位置。

int sapgui_grid_set_column_order(const char *description, const char *gridID, const char *row,

const char *columns, [args,] LAST );

// sapgui_grid_set_column_width 模拟用户

// 拖动列边框以便设置新宽度。

int sapgui_grid_set_column_width(const char *description, const char *gridID, const char*

column, const char* width, [args,] LAST);

// sapgui_htmlviewer_send_event 发送 HTML 事件。

int sapgui_htmlviewer_send_event(const char *htmlViewerID, const char *frame, const char

*data, const char *url, [args,] LAST ) ;

// sapgui_is_checkbox_selected 验证函数返回

// 复选框的状态。如果复选框被选中，该函数返回 True。

// 如果复选框未被选中，该函数返回 False。

int sapgui_is_checkbox_selected(const char *description, const char *checkBoxID, [args,]

LAST );

// sapgui_is_object_available 验证函数检查

// 指定对象是否可用在函数中。

int sapgui_is_object_available (const char *object_name, [args,] LAST);

// sapgui_is_object_changeable 验证函数返回

// 组件是否可被修改。如果组件既未被禁用，也不是只读，

// 则可被修改。

int sapgui_is_object_changeable(const char *controlID, [args,] LAST);

// sapgui_is_radio_button_selected 验证函数

// 返回单选按钮是否已被选中。

int sapgui_is_radio_button_selected(const char *description, const char *buttonID,[args,]

LAST );

// sapgui_is_tab_selected 验证函数返回一个布尔值，

// 指明当前是否选择了选项卡 tabID。

int sapgui_is_tab_selected(const char *description, const char *tabID, [args,] LAST);

// sapgui_logon 登录到 SAP 服务器。

int sapgui_logon ( const char *user_name, const char *password, const char *client_num, const

char *language, [args,] LAST );

// sapgui_open_connection 函数打开

// 由 connection_name 定义的连接。如果在

// 现有的 SAP 客户端定义中未找到

// connection_name，该函数将试图连接到

// 使用该名称的服务器。

int sapgui_open_connection (const char *connection_name, const char *connection_id, [args,]

LAST );

// sapgui_open_connection_ex 函数打开

// 与由 connection_string 定义的服务器的连接。此函数

// 设置输出参数 connection_id。此参数用在

// sapgui_select_active_connection 中。

int sapgui_open_connection_ex (const char *connection_string, const char *connection_name,

const char *connection_id, [args,] LAST );

// sapgui_press_button 模拟用户单击按钮 buttonID。

int sapgui_press_button( const char *description, const char *buttonID, [args,] LAST );

// sapgui_select_active_connection 指定一个打开的服务器连接

// 作为工作连接。

int sapgui_select_active_connection(const char *connectionID);

// sapgui_select_active_session 从打开的会话集合中

// 选择当前工作会话。

int sapgui_select_active_session(const char *sessionID);

// 录制时，只要您在不属于前一活动

// 窗口的控件上执行操作，就会自动

// 生成 sapgui_select_active_window

// 语句。随后的所有操作都将在此

// 窗口上执行，直到调用下一个 sapgui_select_active_window

// 语句。

int sapgui_select_active_window ( const char *window_id );

// sapgui_select_combobox_entry 从组合框中选择项目 entryKey。

int sapgui_select_combobox_entry(const char *description, const char *objectID, const char

*entryKey, [args,] LAST );

// sapgui_select_menu 模拟用户打开

// 菜单并选择菜单项目。

int sapgui_select_menu(const char *description, const char *menuID, [args,] LAST );

// sapgui_select_radio_button 从组中选择一个单选按钮，

// 并清除该组中的所有其他按钮。

int sapgui_select_radio_button(const char *description, const char *buttonID, [args,] LAST );

// sapgui_select_tab 激活一个选项卡页。它

// 模拟用户单击选项卡 tabID。

int sapgui_select_tab(const char *description, const char *tabID, [args,] LAST );

// sapgui_send_vkey 函数通过发送

// 虚拟键来模拟键盘。

int sapgui_send_vkey(const char *key, [args,] LAST );

// 如果 isSelected 为“True”，那么 sapgui_set_checkbox 将选中

// 复选框。如果 isSelected 为“False”，将清除该复选框。

int sapgui_set_checkbox(const char *description, const char *isSelected, const char *checkBoxID,

[args,] LAST );

// sapgui_set_collection_property 函数使用组成

// GuiCollection 对象的字符串列表项目 arg1...argn

// 设置指定的属性 property_name。

int sapgui_set_collection_property ( const char *control_id, const char *property_name, char

*arg1, ..., char *argn, [optionalArgs,] LAST );

// sapgui_set_focus 将焦点置于对象 controlID 上。

int sapgui_set_focus(const char *controlID, [args,] LAST );

// sapgui_set_ok_code 在“命令”字段中输入文本。

// “命令”字段是主窗口中第一个工具栏

// 左边的框。文本必须是 SAP 命令。

int sapgui_set_ok_code(const char *text, [args,] LAST );

// sapgui_set_password 在“密码”文本框中输入

// 密码。录制函数时，密码文本被

// 隐藏。要回放脚本，请编辑函数并输入

// 密码。

int sapgui_set_password(const char *description, const char *password, const char *controlID,

[args,] LAST );

// sapgui_set_property 函数使用 ID 编号为

// control_id 的 SAP 对象中的值 new_value 设置

// 指定属性 property_name。

int sapgui_set_property ( const char *control_id, const char *property_name, const char

*new_value, [args,] LAST );

// sapgui_set_property_of_active_object 函数使用

// 值 new_value 设置当前活动对象的指定

// 属性 property_name。当前对象通过

// sapgui_active_object_from_parent_method 或

// sapgui_active_object_from_parent_property 选择。

int sapgui_set_property_of_active_object ( const char *property_name, const char *new_value,

[args,] LAST );

// sapgui_set_text 将 text 参数的值写入

// 控件。如果 text 为文字，请将它放置在引号中：

// “The text to enter”。如果 text 是文件，

// 语法为 “file=filename.ext”。引号是语法的

// 组成部分。文件必须位于

// script 文件夹中。不能使用路径。

int sapgui_set_text(const char *description, const char *text, const char *controlID, [args,]

LAST );

// sapgui_status_bar_get_param 数据检索函数

// 从状态栏获取位置 paramIndex 中的参数，

// 并将其存储在参数 outputParamName 中。

int sapgui_status_bar_get_param(const char *paramIndex, const char *outputParamName, [args,]

LAST );

// sapgui_status_bar_get_text 数据检索函数

// 从状态栏获取文本，并将其存储在参数

// outputParamName 中。将检索用户看到的整个文本，

// 包括固定文本和参数。

int sapgui_status_bar_get_text(const char *outputParamName, [args,] LAST );

// 成功调用 sapgui_status_bar_get_type 后，outputParamName 的值

// 为以下文字字符串之一

// ：“Success”、“Warning”或“Error”。该函数

// 用于测试上一操作的结果。

int sapgui_status_bar_get_type(const char *outputParamName, [args,] LAST );

// 当您在表中输入数据并按 Enter 键时录制 sapgui_table_fill_data

// 。将自动创建表参数 paramName

// 。录制后可以在 VuGen 中编辑表参数

// 以便更改数据。

int sapgui_table_fill_data(const char *description, const char *tableID, const char *paramName,

[args,] LAST );

// sapgui_table_get_column_width 数据检索函数

// 将列的宽度放到参数 paramName 中。

int sapgui_table_get_column_width(const char *description, const char *tableID, const char

*column, const char *paramName, [args,] LAST );

// sapgui_table_get_text 数据检索函数将由

// row 和 column 指定的单元格中的文本放到参数 paramName 中。

int sapgui_table_get_text(const char *description, const char *tableID, const char *row, const char

*column, const char *paramName, [args,] LAST );

// 如果选中列，则 sapgui_table_is_column_selected 返回 True。

int sapgui_table_is_column_selected ( char * tableID, char * column, [args,] LAST );

// sapgui_table_is_checkbox_selected 验证函数

// 适用于表控件中的复选框。

// 它返回是选中还是清除了该复选框。

int sapgui_table_is_checkbox_selected(const char *description, const char *tableID, const char

*row, const char *column, [args,] LAST );

// 如果选中表中的单选按钮，

// 则 sapgui_table_is_radio_button_selected 验证函数返回 True。

int sapgui_table_is_radio_button_selected(const char *description, const char *tableID, const char

*row, const char *column, [args,] LAST );

// sapgui_table_is_row_selected 验证函数

// 适用于表控件中的行。

// 它返回行是否被选中。

int sapgui_table_is_row_selected(const char *tableID, const char *row, [args,] LAST );

// sapgui_table_press_button 适用于表单元格中的

// 按钮控件。它模拟用户单击由 row 和 column 指定的

// 单元格中的按钮。

int sapgui_table_press_button(const char *description, const char *tableID, const char *row, const

char *column, [args,] LAST );

// sapgui_table_reorder 对表中的列进行重新排序。

// order 参数是新顺序中

// 列的原有位置。使用空格来分隔列编号

// 。例如，“0 1 3 2”会将第 4 列

// （列 3）移动到第 3 个位置。

int sapgui_table_reorder ( const char *description, const char *tableID, const char *order, [args,]

LAST );

// sapgui_table_select_combobox_entry 从组合框中

// 选择项目 entryKey，并在由 row 和 column 指定的

// 表单元格中输入该值。

int sapgui_table_select_combobox_entry (const char *description, const char *tableID, const char

*row, const char *column, const char *entryKey, [args,] LAST );

// sapgui_table_select_radio_button 适用于表单元格中的

// 单选按钮控件。它模拟用户选中由 row 和 column 指定

// 的单元格中的按钮。

int sapgui_table_select_radio_button(const char *description, const char *tableID, const char *row,

const char *column, [args,] LAST );

// sapgui_table_set_checkbox 设置表中复选框

// 的状态。如果 newValue 为“True”，则该复选框处于选中状态。

// 如果 newValue 为“False”，则该复选框处于清除状态。

int sapgui_table_set_checkbox(const char *description, const char *tableID, const char *row,

const char *column, const char *newValue, [args,] LAST );