51Testing软件测试论坛

标题: LoadRunner函数大全之中文解释 [打印本页]

作者: msnshow 时间: 2014-8-31 11:25
标题: LoadRunner函数大全之中文解释
本帖最后由 msnshow 于 2014-8-31 12:09 编辑

// 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  函数双击列表中的项目。

作者: msnshow 时间: 2014-8-31 11:26
//  项目可由其逻辑名称指定。
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  函数在对象内的
//  指定坐标处双击鼠标。

作者: msnshow 时间: 2014-8-31 11:26
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  函数指定脚本执行

作者: msnshow 时间: 2014-8-31 11:26
//  期间要使用的思考时间范围。运行脚本
//  时，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 );

作者: msnshow 时间: 2014-8-31 11:26
本帖最后由 msnshow 于 2014-8-31 12:10 编辑

// 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  函数从指定窗口或窗口区域读取文本。

作者: msnshow 时间: 2014-8-31 11:26
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 );

作者: msnshow 时间: 2014-8-31 11:27
// 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);

作者: msnshow 时间: 2014-8-31 11:27
// 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);

作者: msnshow 时间: 2014-8-31 11:27
// 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  客户端中
//  按下非字母数字键。

作者: msnshow 时间: 2014-8-31 11:27
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  是同步函数，

作者: msnshow 时间: 2014-8-31 11:27
//  它等待窗口被创建或变为活动的。
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 );

作者: msnshow 时间: 2014-8-31 11:27
//  有关  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

作者: msnshow 时间: 2014-8-31 11:28
//  类型。
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 );

作者: msnshow 时间: 2014-8-31 11:28
//  请不要在脚本中包括操作系统头文件（例如，
// 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 );

作者: msnshow 时间: 2014-8-31 11:28
//  在  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  指向停止扫描的字符。

作者: msnshow 时间: 2014-8-31 11:28
//  函数  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  个字符连接到另一字符串。

作者: msnshow 时间: 2014-8-31 11:28
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);

作者: msnshow 时间: 2014-8-31 11:28
// 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, ...);

作者: msnshow 时间: 2014-8-31 11:28
// 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  参数并取消调用的
//  注释。

作者: msnshow 时间: 2014-8-31 11:28
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);

作者: msnshow 时间: 2014-8-31 11:29
// 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);

作者: msnshow 时间: 2014-8-31 11:29
// 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 ”

作者: msnshow 时间: 2014-8-31 11:29
//  指针引用的货币值保存到字符串参数中。
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);

作者: msnshow 时间: 2014-8-31 11:30
//  输入表示无符号短整型值的字符串时，
// 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  并取消调用的注释。

作者: msnshow 时间: 2014-8-31 11:30
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  将此函数生成为注释掉的调用。

作者: msnshow 时间: 2014-8-31 11:30
//  如果要将此值用作参数，可以更改  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  变量类型值保存到字符串参数中。

作者: msnshow 时间: 2014-8-31 11:30
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  将通过
//  变量中的引用方式存储的值保存为参数。

作者: msnshow 时间: 2014-8-31 11:31
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  将通过
//  变量中的引用方式存储的值保存为参数。

作者: msnshow 时间: 2014-8-31 11:31
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  位

作者: msnshow 时间: 2014-8-31 11:31
//  超级整型值保存到字符串参数中。
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);

作者: msnshow 时间: 2014-8-31 11:31
// 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);

作者: msnshow 时间: 2014-8-31 11:31
// 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  值，并且返回包含对某变量（其中
//  包含该值）引用的变量。

作者: msnshow 时间: 2014-8-31 11:32
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  类型值。

作者: msnshow 时间: 2014-8-31 11:32
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);

作者: msnshow 时间: 2014-8-31 11:32
// 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);

作者: msnshow 时间: 2014-8-31 11:33
// 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);

作者: msnshow 时间: 2014-8-31 11:33
// DestroyUIntArray  释放由数组占用的内存。
//  该函数用于恢复由脚本为数组分配的内存。
void DestroyUIntArray(UIntArray Array);

// DestroyULongArray  释放由数组占用的内存。
//  该函数用于恢复由脚本为数组分配的内存。
void DestroyULongArray(ULongArray Array);

// DestroyUShortArray  释放由数组占用的内存。
//  该函数用于恢复由脚本为数组分配的内存。
void DestroyUShortArray(UShortArray Array);

// DestroyVariantArray  释放由数组占用的内存。
//  该函数用于恢复由脚本为数组分配的内存。
void DestroyVariantArray(VariantArray Array);

// GetBufferFrom<n>DByteArray  函数系列从  n  维
// byte  类型数组的最后一维中提取缓冲区。此函数
//  的返回值是一个指向  byte  类型的缓冲区的指针。
//  缓冲区的大小返回到  *plinesize  所指定的
//  地址中。
char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);

// Fill<n>DByteArray  函数系列将  n  维  byte  数组
//  的最后一维中填充缓冲区的内容。
char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t
buff_size);

// lrc_variant_<Type-Name>Array  函数系列将在
// Type-Name  中指定的类型的数组分配给变量。
VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);

// lrc_variant_BoolArray  将数组分配给变量。
VARIANT lrc_variant_BoolArray(BoolArray array);

// lrc_variant_BstrArray  将数组分配给变量。
VARIANT lrc_variant_BstrArray(BstrArray array);

// lrc_variant_ByteArray  将数组分配给变量。
VARIANT lrc_variant_ByteArray(ByteArray array);

// lrc_variant_CharArray  将数组分配给变量。
VARIANT lrc_variant_CharArray(CharArray array);

作者: msnshow 时间: 2014-8-31 11:33
// 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);

作者: msnshow 时间: 2014-8-31 11:33
// 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  返回对数组的引用

作者: msnshow 时间: 2014-8-31 11:33
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);

作者: msnshow 时间: 2014-8-31 11:34
// 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);

作者: msnshow 时间: 2014-8-31 11:34
// 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);

作者: msnshow 时间: 2014-8-31 11:34
// 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 ，则
//  函数将输出所有行

作者: msnshow 时间: 2014-8-31 11:34
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 );

作者: msnshow 时间: 2014-8-31 11:34
// 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  函数将带有

作者: msnshow 时间: 2014-8-31 11:34
//  显式长度的存储区域通过其描述符分配给
//  标量变量，并将变量绑定到占位符。
//  必要时，该值将被转换为变量的类型和
//  长度。该值可以包含嵌入的  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  字符。

作者: msnshow 时间: 2014-8-31 11:35
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  函数
//  关闭与数据库的指定连接。

作者: msnshow 时间: 2014-8-31 11:35
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  函数为数据库光标、
//  上下文或连接设置选项。

作者: msnshow 时间: 2014-8-31 11:35
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 );

作者: msnshow 时间: 2014-8-31 11:35
// 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 );

作者: msnshow 时间: 2014-8-31 11:35
// 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 );

作者: msnshow 时间: 2014-8-31 11:36
// 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 );

作者: msnshow 时间: 2014-8-31 11:36
// 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 );

作者: msnshow 时间: 2014-8-31 11:36
// 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 );

作者: msnshow 时间: 2014-8-31 11:36
// 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 );

//  在自动提取中，数据由  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 );

作者: msnshow 时间: 2014-8-31 11:37
// 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 );

作者: msnshow 时间: 2014-8-31 11:37
// 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  函数将字符串（通常
<0 ）
//  为  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  函数将变量

作者: msnshow 时间: 2014-8-31 11:37
//  或数组元素转换为可打印字符串。
//  在录制期间，将在脚本目录的  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);

作者: msnshow 时间: 2014-8-31 11:37
// 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);

作者: msnshow 时间: 2014-8-31 11:37
// 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);

作者: msnshow 时间: 2014-8-31 11:38
// 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  函数选择邮箱
// 以查看其邮件。调用此函数不会
//  修改邮箱状态（未读邮件数、邮件总数，
//  等等）。

作者: msnshow 时间: 2014-8-31 11:38
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  函数列出对客户端声明为订阅或活动的邮箱。
//  回复中包含名称属性、层次结构分隔符和
//  邮箱名称。

作者: msnshow 时间: 2014-8-31 11:38
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  函数更改与当前邮箱中的指定邮件相关的标志。
//  可以更改所有标志、在现有标志上添加
//  标志或删除标志。

作者: msnshow 时间: 2014-8-31 11:39
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);

作者: msnshow 时间: 2014-8-31 11:39
//  使用  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);

作者: msnshow 时间: 2014-8-31 11:39
// 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  会话

作者: msnshow 时间: 2014-8-31 11:39
//  属性的值作为  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  函数检索

作者: msnshow 时间: 2014-8-31 11:39
//  当前条目的属性值。既可以
//  指定属性的索引，也可以指定
//  属性的名称。默认情况下，
//  如果不指定任何值，函数将
//  返回第一个属性的值。可选的  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);

作者: msnshow 时间: 2014-8-31 11:40
// 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 。搜索范围可以是

作者: msnshow 时间: 2014-8-31 11:40
//  基础自身  (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 协议）执行登录。

作者: msnshow 时间: 2014-8-31 11:40
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  时（流传输尚未完成），播放器会话
//  才会处于活动状态。

作者: msnshow 时间: 2014-8-31 11:40
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);

作者: msnshow 时间: 2014-8-31 11:40
// 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( );

作者: msnshow 时间: 2014-8-31 11:41
// 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 );

作者: msnshow 时间: 2014-8-31 11:41
// 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  窗口中的“值列表”按钮，

作者: msnshow 时间: 2014-8-31 11:41
// 以便显示活动字段的值列表。
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);

作者: msnshow 时间: 2014-8-31 11:41
本帖最后由 msnshow 于 2014-8-31 12:12 编辑

// 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  函数输入一个字母来指明要从值列表中选择的项目的第一个字符。以指定字母开头的项目被选中。如果存在多个以该字母开头的项目，那么所有匹配的值都将显示在列表中，您需要从新列表中选择一个

作者: msnshow 时间: 2014-8-31 11:41
//  项目。
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 );

作者: msnshow 时间: 2014-8-31 11:41
// 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  函数向“响应”框中
//  的单元格中插入数据。应指定“响应”对象的名称、
//  单元格的名称以及数据。

作者: msnshow 时间: 2014-8-31 11:42
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  时，可能会出现这种情况。

作者: msnshow 时间: 2014-8-31 11:42
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  函数选择选项卡项目。

作者: msnshow 时间: 2014-8-31 11:42
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);

作者: msnshow 时间: 2014-8-31 11:42
// 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  服务器
//  检索邮件。您可以指定邮件范围或
//  所有邮件。默认情况下，它在检索邮件之后将其从服务器中删除。

作者: msnshow 时间: 2014-8-31 11:42
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 );

作者: msnshow 时间: 2014-8-31 11:42
// 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 );

作者: msnshow 时间: 2014-8-31 11:42
// 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  函数等待客户端
//  应用程序静默指定的时间。当终端仿真器
//  未接到任何字符时，认为客户端处于
//  静默状态。如果客户端应用程序
// 由于过了超时时间（以秒为单位）

作者: msnshow 时间: 2014-8-31 11:43
//  而未静默认指定的时间，该函数将
//  返回错误。
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  返回。

作者: msnshow 时间: 2014-8-31 11:43
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 );

作者: msnshow 时间: 2014-8-31 11:43
// 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 ”指定的网格单元格中单击。

作者: msnshow 时间: 2014-8-31 11:43
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 );

作者: msnshow 时间: 2014-8-31 11:43
// 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 );

作者: msnshow 时间: 2014-8-31 11:44
// 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  指定的行号。

作者: msnshow 时间: 2014-8-31 11:44
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 );

作者: msnshow 时间: 2014-8-31 11:44
// 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);

作者: msnshow 时间: 2014-8-31 11:44
// 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  模拟用户打开
//  菜单并选择菜单项目。

作者: msnshow 时间: 2014-8-31 11:44
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 );

作者: msnshow 时间: 2014-8-31 11:45
// 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 );

作者: msnshow 时间: 2014-8-31 11:45
// 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  指定的
//  表单元格中输入该值。

作者: msnshow 时间: 2014-8-31 11:45
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 );

// 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 );

作者: msnshow 时间: 2014-8-31 11:45
// 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 。

欢迎光临 51Testing软件测试论坛 (http://bbs.51testing.com/)