// button_press 函數激活指定的推按鈕。
int button_press ( LPCSTR button );
// button_set 函數將按鈕狀態設置爲 ON 或 OFF。
int button_set ( LPCSTR button, int state );
// close_session 函數關閉所有打開的窗口並結束
// 當前的 Baan 會話。在 Baan 模板中創建的此函數
// 出現在腳本的 vuser_end 部分中。
int close_session();
// edit_get_text 函數返回在指定 edit 對象中
// 找到的所有文本。若要從特定塊中讀取文本，
// 請使用 edit_get_block。
int edit_get_text ( LPCSTR edit, char *out_string );
// edit_set 函數使用指定的字符串設置 edit 對象的
// 內容。該字符串將替換任何現有字符串。
int edit_set ( LPCSTR edit, LPCSTR text );
// edit_set_insert_pos 函數將光標放置
// 在 edit 對象內的指定位置。
int edit_set_insert_pos (LPCSTR edit, int row, int column );
// edit_set_selection 函數突出顯示指定文本。
int edit_set_selection ( LPCSTR edit, int start_row, int start_column, int end_row, int end_column );
// edit_type 函數將文本字符串輸入到 edit
// 對象中。該文本字符串不會替換現有字符串；
// 它替換的是位於當前光標位置的指定文本。
int edit_type ( LPCSTR edit, LPCSTR text );
// init_session 函數通過指定登錄數據和配置
// 信息打開 Baan 連接。此函數向 Baan 服務器
// 呈現包含在 Baan Configuration 部分中
// 的信息。
int init_session ( char * host, char * user, char *password, char *BSE, char *Bshell_name, char * settings );
// list_activate_item 函數雙擊列表中的項目。
// 項目可由其邏輯名稱指定。
int list_activate_item ( LPCSTR list, LPCSTR item );
// list_collapse_item 函數隱藏展開的 TreeView
// 列表中的子項，例如文件夾中的各個文件。
int list_collapse_item (LPCSTR list, LPCSTR item );
// list_expand_item 函數顯示展開的
// TreeView 列表中所隱藏的子項，例如
// 文件夾中的各個文件。
int list_expand_item (LPCSTR list, LPCSTR item );
// list_get_selected 函數返回列表中的選定
// 項目。它既查找標準列表，也查找多選項列表。
int list_get_selected (LPCSTR list, LPCSTR out_item, LPCSTR out_num );
// list_select_item 函數從列表中選擇項目
// （在項目上執行一次鼠標單擊）。項目可由
// 其名稱或數字索引指定。索引被指定爲一個
// 字符串，並前置有字符 #。列表中的第一個
// 項目編號爲 0。例如，列表中的第三個項目
// 將表示爲 "#2"。
int list_select_item ( LPCSTR list, LPCSTR item );
// menu_select_item 函數根據菜單
// 的邏輯名稱和項目名稱從菜單中選擇
// 項目。注意，菜單和項目表示爲單個
// 字符串，並使用分號分隔。
int menu_select_item ( LPCSTR menu_item );
// obj_get_info 函數檢索指定屬性的值，
// 並將其存儲在 out_value 中。
int obj_get_info ( LPCSTR object, LPCSTR property, char *out_value );
// obj_get_text 函數從指定的對象
// 或對象區域中讀取文本。
int obj_get_text (LPCSTR object, LPCSTR out_text );
// obj_mouse_click 函數在對象內的
// 指定座標處單擊鼠標。
int obj_mouse_click ( LPCSTR object, int x, int y, [mouse_button] );
// obj_mouse_dbl_click 函數在對象內的
// 指定座標處雙擊鼠標。
int obj_mouse_dbl_click ( LPCSTR object, int x, int y, [mouse_button] );
// obj_mouse_drag 函數在 GUI
// 對象中執行鼠標拖動操作。指定的
// 座標是相對於 GUI 對象（而非
// 屏幕）的左上角。
int obj_mouse_drag (LPCSTR object, int start_x, int start_y, int end_x, int end_y, [ ButtonT mouse_button] );
// obj_type 函數指定將 keyboard_input
// 發送到的目標對象。
int obj_type ( LPCSTR object, unsigned char keyboard_input, [unsigned char modifier ] );
// obj_wait_info 函數等待對象
// 屬性達到指定值，然後繼續
// 測試運行。如果未達到指定
// 值，則函數將一直等到時間
// 到期，然後再繼續測試。
int obj_wait_info (LPCSTR object, LPCSTR property, LPCSTR value, UINT time );
// scroll_drag_from_min 函數將滾動屏
// 移動到與最小位置相距指定距離的位置。
int scroll_drag_from_min ( LPCSTR object, [int orientation], int position );
// scroll_line 函數滾動指定行數。
// 此函數可用於滾動欄和滑塊對象。
int scroll_line ( LPCSTR scroll, [ScrollT orientation], int lines );
// scroll_page 函數將滾動屏移動指定頁數。
int scroll_page ( LPCSTR scroll, [ScrollT orientation], int pages );
// set_default_timeout 函數設置回放
// 期間 Baan Vuser 函數的超時期間段。
// 例如，當腳本執行 set_window 函數
// 時，如果窗口在指定超時時間段內沒有
// 出現，則會生成錯誤。
void set_default_timeout ( long time );
// set_exception 函數指定在發生異常時
// 應執行的操作。應指定要調用以處理異常
// 窗口的函數。
void set_exception ( LPCSTR title, long function );
// set_think_time 函數指定腳本執行
// 期間要使用的思考時間範圍。運行腳本
// 時，LoadRunner 使用指定範圍內的
// 隨機思考時間，並在每個操作完成後
// 暫停該思考時間長度。
void set_think_time ( USHORT start_range, USHORT end_range );
// set_window 函數將輸入定向到
// 當前應用程序窗口並在 GUI 圖中
// 設置對象標識範圍。
int set_window ( LPCSTR window [, int timeout ] );
// start_session 函數在 Baan
// 服務器上開始指定的會話。
int start_session ( LPCSTR session );
// static_get_text 函數返回在指定
// 靜態 text 對象中找到的所有文本。
int static_get_text ( LPCSTR static_obj, LPCSTR out_string );
// tab_select_item 函數選擇一個選項卡項目。
int tab_select_item ( LPCSTR tab, LPCSTR item );
// tbl_activate_cell 函數在指定表單元格中
// 按 Enter 鍵。如果指定了列名，LoadRunner
// 將直接從數據庫中獲取該名稱。
int tbl_activate_cell (LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_get_cell_data 函數根據
// 單元格包含的數據類型獲取表中
// 指定單元格的內容。如果指定了
// 列名，將從數據庫自身（而非應用
// 程序）中獲取該名稱。
int tbl_get_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR out_text );
// tbl_get_selected_cell 函數
// 檢索焦點所在的表單元格的行號和
// 列名。注意，列名取自數據庫自身，
// 而非應用程序。
int tbl_get_selected_cell (LPCSTR table, char *out_row, char *out_column );
// tbl_press_zoom_button 函數
// 激活指定表單元格的縮放窗口。
int tbl_press_zoom_button ( LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_set_cell_data 函數根據單元格
// 包含的數據類型使用指定數據設置單元格
// 的值。如果指定了列名，LoadRunner
// 將直接從數據庫中獲取該名稱。
int tbl_set_cell_data (LPCSTR table, LPCSTR row, LPCSTR column, LPCSTR data );
// tbl_set_selected_cell 函數將焦點
// 設置到表中的指定單元格上。指定列名時，
// LoadRunner 將直接從數據庫中獲取該名稱。
int tbl_set_selected_cell (LPCSTR table, LPCSTR row, LPCSTR column );
// tbl_set_selected_row 函數選擇表中的指定行。
int tbl_set_selected_row (LPCSTR table, LPCSTR row );
// tbl_set_selected_rows 函數選擇指定行範圍。
int tbl_set_selected_rows(LPCSTR table, LPCSTR from_row , LPCSTR to_row );
// tbl_wait_selected_cell 函數等待
// 表單元格顯示後，再繼續腳本執行。
int tbl_wait_selected_cell (LPCSTR table, char *row, char *column, UINT time );
// toolbar_button_press 函數激活工具欄中的按鈕。
int toolbar_button_press (LPCSTR toolbar, LPCSTR button );
// type 函數描述發送給用於測試
// 的應用程序的鍵盤輸入。
int type (LPCSTR keyboard_input );
// win_activate 函數通過向指定窗口
// 授予焦點並將其升到顯示器最上端，
// 使其成爲活動窗口（等價於單擊窗口
// 標題欄）。所有後續輸入都將提交給
// 此窗口。
int win_activate (LPCSTR window );
// win_close 函數關閉指定窗口。
int win_close ( LPCSTR window );
// win_get_info 函數檢索指定屬性的值
// 並將其存儲在 out_value 中。
int win_get_info ( LPCSTR window, LPCSTR property, char *out_value );
// win_get_text 函數從指定窗口或
// 窗口區域讀取文本。
int win_get_text ( LPCSTR window, LPCSTR out_text );
// win_max 函數將指定窗口
// 最大化以充滿整個屏幕。
int win_max (LPCSTR window );
// win_min 函數將指定窗口最小化爲圖標。
int win_min (LPCSTR window );
// win_mouse_click 函數在選中窗口
// 的指定座標處執行鼠標單擊操作。
int win_mouse_click (LPCSTR window, int x, int y, ButtonT button );
// win_mouse_dbl_click 函數在選中窗口
// 的指定座標處執行鼠標雙擊操作。
int win_mouse_dbl_click (LPCSTR window, int x, int y, ButtonT button );
// win_mouse_drag 函數在窗口內執行
// 鼠標拖動操作。注意，指定的座標是
// 相對於窗口（而非屏幕）的左上角。
int win_mouse_drag (LPCSTR window, int start_x, int start_y, int end_x, int end_y, ButtonT button );
// win_move 函數將窗口移動到新的絕對位置。
int win_move ( LPCSTR window, int x, int y );
// win_resize 函數更改窗口的位置。
int win_resize ( LPCSTR window, int width, int height );
// win_restore 函數將窗口從圖標化
// 或最大化狀態還原爲其原始大小。
int win_restore (LPCSTR window );
// win_wait_info 函數等待窗口
// 屬性達到指定值，然後繼續測試
// 運行。如果未達到指定值，則函數
// 將一直等到時間到期，然後再繼
// 續測試。
int win_wait_info (LPCSTR window, LPCSTR property, LPCSTR value, UINT time );
// win_type 函數指定 keyboard_input
// 將發送到的目標窗口。
int win_type (LPCSTR window, LPCSTR keyboard_input );
// ctrx_<obj>_get_info 函數系列將屬性
// 的值分配給值緩衝區。ctrx_obj_get_info
// 是一般函數，它可以適用於任何由錄製器
// 所標識爲對象的對象。
int ctrx_obj_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函數系列將屬性的值
// 分配給值緩衝區。ctrx_button_get_info
// 獲取命令按鈕的信息。
int ctrx_button_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函數系列將屬性的值
// 分配給值緩衝區。ctrx_edit_get_info
// 獲取文本框的信息。
int ctrx_edit_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_<obj>_get_info 函數系列將屬性的值
// 分配給值緩衝區。ctrx_list_get_info
// 獲取列表框的信息。
int ctrx_list_get_info( const char * window_name, long xpos, long ypos, eObjAttribute attribute, char *value, CTRX_LAST );
// ctrx_connect_server 將 Citrix 客戶端連接到 Citrix 服務器。
int ctrx_connect_server (char * server_name, char * user_name, char * password, char * domain);
// ctrx_disconnect_server 斷開客戶端與 Citrix 服務器的連接。
int ctrx_disconnect_server (char * server_name);
// ctrx_nfuse_connect 使用 NFUSE 應用
// 程序門戶建立與 Citrix 服務器的連接。在
// 定義 NFUSE 門戶的個性化規範的 ICA 文件
// 中找到的規範將從服務器上下載，在此之後
// 建立連接。
int ctrx_nfuse_connect(char * url);
// 使用 ctrx_get_bitmap_value
// 檢索位圖的哈希字符串值以用於您
// 的自定義同步函數中。位圖座標由
// 前四個參數指定。
int ctrx_get_bitmap_value (long x_start, long y_start, long width, long height, char * buffer);
// ctrx_get_text 將矩形中的文本分配到 text_buffer
// 中。隨後，文本可被用於關聯。
int ctrx_get_text( char *window_name, long xpos, long ypos, long width, long height, char * filename, char * text_buffer, CTRX_LAST );
// ctrx_get_text_location 在 xpos、
// ypos、width 和 height 指定區域中
// 搜索指定文本。如果找到字符串，當函數
// 返回後，xpos 和 ypos 即爲找到文本的
// 位置。如果未找到字符串，xpos 和 ypos
// 則爲零。
int ctrx_get_text_location( LPCSTR window_name, long *xpos, long *ypos, long *width, long *height, LPSTR text, long bMatchWholeWordOnly, LPCSTR filename, CTRX_LAST );
// ctrx_get_waiting_time 從運行時設置中獲取當前等待
// 時間，或者通過 ctrx_set_waiting_time 設置的值。
int ctrx_get_waiting_time ( long * time );
// 使用 ctrx_get_window_name 檢索
// 當前獲得焦點的窗口的名稱。
int ctrx_get_window_name (LPSTR buffer);
// 使用 ctrx_get_window_position
// 檢索名爲 title 變量值的窗口的位置。
// 如果 title 爲 NULL，則函數將檢索
// 當前擁有焦點的窗口的位置。
int ctrx_get_window_position (LPSTR title, long *xpos, long *ypos, long *width, long *height);
// ctrx_list_select_item 函數從列表中選擇項目。
// 它支持 ListBox 或 ComboBox 類的列表。
int ctrx_list_select_item(char * window_name, long xpos, long ypos, char * item, CTRX_LAST );
// ctrx_menu_select_item 突出顯示
// 菜單中的項目，但不激活它。
int ctrx_menu_select_item ( char * window_name, char * menu_path, CTRX_LAST) ;
// ctrx_mouse_click 等待窗口 window_name
// 出現，然後執行鼠標單擊操作。
int ctrx_mouse_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_click 等待窗口 window_name
// 出現，然後執行鼠標單擊操作。
int ctrx_obj_mouse_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_double_click 等待窗口 window_name
// 出現，然後執行鼠標雙擊操作。
int ctrx_mouse_double_click (long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_double_click 等待窗口 window_name
// 出現，然後執行鼠標雙擊操作。
int ctrx_obj_mouse_double_click (const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_down 等待窗口 window_name
// 出現，然後執行按下鼠標按鍵操作。
int ctrx_mouse_down(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_obj_mouse_down 等待窗口 window_name
// 出現，然後執行按下鼠標按鍵操作。
int ctrx_obj_mouse_down(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name);
// ctrx_mouse_up 等待窗口 window_name
// 出現，然後在指定位置執行釋放鼠標按鍵操作。
int ctrx_mouse_up(long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );
// ctrx_obj_mouse_up 等待窗口 window_name
// 出現，然後在指定位置執行釋放鼠標按鍵操作。
int ctrx_obj_mouse_up(const char * obj_desc, long x_pos, long y_pos, long mouse_button, long key_modifier, char * window_name );
// ctrx_set_window 是同步函數，它等待
// 窗口出現，然後 Vuser 纔在該窗口中模擬
// 任何鍵盤或鼠標活動。
int ctrx_set_window (char * window_name);
// ctrx_set_window_ex 是同步函數，它至多
// 等待 time 秒，若窗口出現，Vuser 將在該
// 窗口中模擬任何鍵盤或鼠標活動。
int ctrx_set_window_ex (char * window_name, long time);
// ctrx_key 模擬用戶在 Citrix 客戶端中
// 按下非字母數字鍵。
int ctrx_key (char * key, long int key_modifier);
// 函數 ctrx_type 模擬用戶鍵入字母數字字符。
int ctrx_type (char * data);
// ctrx_save_bitmap 將位圖保存爲文件。
// 該文件將保存在 Vuser 結果日誌目錄中。
int ctrx_save_bitmap( long x_start, long y_start, long width, long height, const char * file_name );
// ctrx_set_connect_opt 在建立 Citrix 客戶端
// 與 Citrix 服務器的連接之前設置連接選項，然後
// 執行與服務器的連接。
int ctrx_set_connect_opt (eConnectionOption option, char * value);
// ctrx_set_exception 定義當不規則
// 事件發生時要執行的操作。此事件必須
// 與名爲 window_title 的窗口（通常
// 爲彈出式對話框）的外觀相關聯。當窗口
// 出現時，將調用 handler 函數。
void ctrx_set_exception ( char * window_title, long handler, [void *context]);
// ctrx_set_waiting_time 更改
// 同步函數默認 60 秒的等待時間。
int ctrx_set_waiting_time (long time);
// ctrx_sync_on_bitmap 是同步函數，
// 它等待指定位圖出現，然後再繼續執行。
int ctrx_sync_on_bitmap (long x_start, long y_start, long width, long height, char * hash);
// ctrx_sync_on_bitmap_change 是同步
// 函數，它等待指定位圖改變，然後再繼續執行。
// 該函數通常用在窗口改變而窗口名稱保持
// 不變的情況下。如果窗口名稱改變，
// 則 ctrx_set_window 將被自動
// 生成。
int ctrx_sync_on_bitmap_change (long x_start, long y_start, long width, long height, <extra_args>, CTRX_LAST);
// ctrx_sync_on_obj_info 被調用時，執行將暫停，
// 直到指定對象的屬性具有指定的值。
int ctrx_sync_on_obj_info ( char * window_name, long xpos, long ypos, eObjAttribute attribute, char * value, <CTRX_LAST> );
// ctrx_sync_on_window 是同步函數，
// 它等待窗口被創建或變爲活動的。
int ctrx_sync_on_window (char * window_name, eWindowEvent event, long x_start, long y_start, long width, long height, char * filename, <CTRX_LAST>);
// ctrx_unset_window 是同步函數，它等待
// 窗口被關閉，然後腳本才繼續執行。
int ctrx_unset_window (char * window_name);
// ctrx_wait_for_event 是同步函數，
// 它等待事件發生。
int ctrx_wait_for_event (char * event);
// 如果窗口存在，ctrx_win_exist 返回 E_OK（零）。
// 在 window_name 中可以使用通配符 (*)。
int ctrx_win_exist (char * window_name, long waiting_time);
// 有關 memchr 的詳細信息，請參考 C 語言文檔。
void *memchr ( const void *s, int c, size_t n );
// 有關 memcmp 的詳細信息，請參考 C 語言文檔。
int memcmp ( const void *s1, const void *s2, size_t n );
// memcpy 函數從 src 緩衝區中將 n 個
// 字符複製到 dest 緩衝區。
void *memcpy ( void *dest, const void *src, size_t n );
// 函數 memmove（以及所有不返回 integer 類型
// 的函數）必須明確在 Vugen 腳本中聲明。
void *memmove ( void *dest, const void *src, size_t n );
// 有關 memset 的詳細信息，請參考 C 語言文檔。
void *memset ( void *buffer, int c, size_t n );
// 有關 getenv 的詳細信息，請參考 C 語言文檔。
char *getenv ( const char *varname );
// 有關 putenv 的詳細信息，請參考 C 語言文檔。
int putenv ( const char *envstring );
// 有關 system 的詳細信息，請參考 C 語言文檔。
int system ( const char *string );
// 有關 calloc 的詳細信息，請參考 C 語言文檔。
void *calloc ( size_t num elems, size_t elem_size );
// 有關 free 的詳細信息，請參考 C 語言文檔。
void free ( void *mem_address );
// 有關 malloc 的詳細信息，請參考 C 語言文檔。
void *malloc ( size_t num_bytes );
// 有關 realloc 的詳細信息，請參考 C 語言文檔。
void *realloc ( void *mem_address, size_t size );
// 有關 abs 的詳細信息，請參考 C 語言文檔。
int abs ( int n );
// 限制：cos 函數在 AIX 平臺中無法使用。
double cos ( double x );
// 函數 floor（以及所有不返回 int 值的函數）
// 必須明確在 Vugen 腳本中聲明。限制：此
// 函數在 AIX 平臺中無法使用。
double floor ( double x );
// 在調用 rand 前，請調用 srand 以
// 播種僞隨機數生成器
int rand ( void );
// 限制：sin 函數在 AIX 平臺中無法使用。
double sin ( double x );
// 函數 sqrt（以及所有不返回 int 值的
// 函數）必須明確在 Vugen 腳本中聲明。
// 限制：sqrt 函數在 AIX 平臺中
// 無法使用。
double sqrt ( double x );
// 在調用 rand 前，請調用 srand 以
// 播種僞隨機數生成器
int srand ( time );
// 有關 fclose 的詳細信息，請參考 C 語言文檔。
int fclose ( FILE *file_pointer );
// 請不要在腳本中包括操作系統頭文件（例如，stdio.h）。
// 但是，這樣將導致某些類型（包括 feof 使用的 FILE
// 類型）未經定義。這時，請使用 long 替代 FILE
// 類型。
int feof ( FILE *file_pointer );
// 有關 ferror 的詳細信息，請參考 C 語言文檔。
int ferror ( FILE *file_pointer );
// 請不要在腳本中包括操作系統頭文件（例如，
// stdio.h）。但是，這樣會導致某些類型
// （包括 fgetc 使用的 FILE 類型）未經定義。
// 這時，請使用 long 替代 FILE 類型。
int fgetc ( FILE *file_pointer );
// 請不要在腳本中包括操作系統頭文件（例如，
// stdio.h）。但是，這樣會導致某些類型
// （包括 fgets 使用的 FILE 類型）未經定義。
// 這時，請使用 long 替代 FILE 類型。
char *fgets ( char *string, int maxchar, FILE *file_pointer );
// 通過將 t 或 b 字符添加到 fopen 的 access_mode
// 參數，此訪問模式字符串還將用於指定打開文件的方式
// （文本還是二進制）。
FILE *fopen ( const char *filename, const char *access_mode );
// 有關 fprintf 的詳細信息，請參考 C 語言文檔。
int fprintf ( FILE *file_pointer, const char *format_string [, args ] );
// 請不要在腳本中包括操作系統頭文件（例如，
// stdio.h）。但是，這樣會導致某些類型
// （包括 fputc 使用的 FILE 類型）未經定義。
// 這時，請使用 long 替代 FILE 類型。
int fputc ( int c, FILE *file_pointer );
// 請不要在腳本中包括操作系統頭文件（例如，
// stdio.h）。但是，這樣會導致某些類型
// （包括 fread 使用的 FILE 類型）未經定義。
// 這時，請使用 long 替代 FILE 類型。
size_t fread ( void *buffer, size_t size, size_t count, FILE *file_pointer );
// 有關 fscanf 的詳細信息，請參考 C 語言文檔。
int fscanf ( FILE *file_pointer, const char *format string [, args] );
// 有關 fseek 的詳細信息，請參考 C 語言文檔。
int fseek ( FILE *file_pointer, long offset, int origin );
// 請不要在腳本中包括操作系統頭文件（例如，
// stdio.h）。但是，這樣會導致某些類型
// （包括 fwrite 使用的 FILE 類型）未經定義。
// 這時，請使用 long 替代 FILE 類型。
size_t fwrite ( const void *buffer, size_t size, size_t count, FILE *file_pointer );
// 有關 rewind 的詳細信息，請參考 C 語言文檔。
void rewind ( FILE *file_pointer );
// 有關 sprintf 的詳細信息，請參考 C 語言文檔。
int sprintf ( char *string, const char *format_string[, args] );
// 有關 sscanf 的詳細信息，請參考 C 語言文檔。
int sscanf ( const char *buffer, const char *format_string, args );
// 有關 chdir 的詳細信息，請參考 C 語言文檔。
int chdir ( const char *path );
// chdrive 將當前工作驅動器更改爲 drive（表示新驅動器
// 的 integer 類型值）。例如，1 = A、2 = B，依此類推。
int chdrive ( int drive );
// 有關 getcwd 的詳細信息，請參考 C 語言文檔。
char *getcwd ( char *path, int numchars );
// getdrive 函數返回表示驅動器字母
// 的 integer 類型值：1 = A、2 = B，依此類推。
int getdrive ( void );
// 有關 mkdir 的詳細信息，請參考 C 語言文檔。
int mkdir ( const char *path );
// 有關 remove 的詳細信息，請參考 C 語言文檔。
int remove ( const char *path );
// 有關 rmdir 的詳細信息，請參考 C 語言文檔。
int rmdir ( const char *path );
// 根據系統時鐘，time 函數返回從世界標準
// 時間 1970 年 1 月 1 日子夜 (00:00:00)
// 作爲開始所經過的秒數。返回值存儲在 timeptr
// 所給出的位置。如果 timeptr 爲 NULL，則
// 該值不會被存儲。
time_t time ( time_t *timeptr );
// 在 Unix 下，ctime 不是線程級安全函數。所以，請使用 ctime_r。
// 有關詳細信息，請參閱平臺相關文檔。
char *ctime ( const time_t *time );
// 有關 ftime 的詳細信息，請參考 C 語言文檔。
void ftime ( struct _timeb *time1 );
// 在 Unix 下，localtime 不是線程級安全函數。
// 所以，請使用 localtime_r。有關詳細信息，請
// 參閱平臺相關文檔。
struct tm *localtime ( const time_t *time );
// 在 Unix 下，gmtime 不是線程級安全函數。所以，請使用 gmtime_r。
// 有關詳細信息，請參閱平臺相關文檔。
struct tm *gmtime ( const time_t *time );
// 在 Unix 下，asctime 不是線程級安全函數。所以，請使用 asctime_r。
// 有關詳細信息，請參閱平臺相關文檔。
char *asctime ( const struct tm *time );
// 通過停止在第一個非數字字符上，atof 只
// 讀取字符串的初始位置。函數 atof（以及
// 所有不返回 integer 類型值的函數）
// 必須明確在 Vugen 腳本中聲明。
double atof ( const char *string );
// 通過停止在第一個非數字字符上，atoi 只
// 讀取字符串的初始位置。
int atoi ( const char *string );
// 通過停止在第一個非數字字符上，atol 只
// 讀取字符串的初始位置。函數 atol（以及
// 所有不返回 integer 類型值的函數）必須
// 明確在 Vugen 腳本中聲明。
long atol ( const char *string );
// itoa 將 value 的數字轉換爲以 radix 作爲
// 基數的字符串 str。通常，radix 是 10。
int itoa ( int value, char *str, int radix );
// 通過停止在第一個非數字字符上，strtol
// 只掃描字符串的初始位置。所有前置空格
// 都將被去除。endptr 指向停止掃描的字符。
// 函數 strtol（以及所有不返回 integer
// 類型值的函數）必須明確在 Vugen 腳本中
// 聲明。
long strtol ( const char *string, char **endptr, int radix );
// 有關 tolower 的詳細信息，請參考 C 語言文檔。
int tolower (int c);
// 有關 toupper 的詳細信息，請參考 C 語言文檔。
int toupper ( int c );
// 有關 isdigit 的詳細信息，請參考 C 語言文檔。
int isdigit ( int c );
// 函數 isalpha 檢查 c 的值是否
// 處於 A - Z 或 a - z 的範圍之內。
int isalpha ( int c );
// strcat 連接兩個字符串。
char *strcat ( char *to, const char *from );
// strchr 返回指向字符串中
// 第一個匹配字符的指針。
char *strchr ( const char *string, int c );
// strcmp 比較 string1 和 string2 以確定字母排序的次序。
int strcmp ( const char *string1, const char *string2 );
// strcpy 將一個字符串複製給另一個。
char *strcpy ( char *dest, const char *source );
// strdup 複製字符串的副本。
char *strdup ( const char *string );
// stricmp 對兩個字符串進行不區分大小寫的比較。
int stricmp ( const char *string1, const char *string2 );
// strlen 返回字符串的長度（以字節爲單位）。
size_t strlen ( const char *string );
// strlwr 將字符串轉換爲小寫。
char *strlwr ( char *string );
// strncat 將一個字符串的 n 個字符連接到另一字符串。
char *strncat ( char *to_string, const char *from_string, size_t n );
// strncmp 比較兩個字符串的前 n 個字符。
int strncmp ( const char *string1, const char *string2, size_t n );
// strncpy 將一個字符串的前 n 個字符複製到另一字符串。
char *strncpy ( char *dest, const char *source, size_t n );
// strnicmp 對兩個字符串的 n 個
// 字符進行不區分大小寫的比較，以
// 確定其字母排序的次序。
int strnicmp ( const char *string1, const char *string2, size_t num);
// strrchr 查找一個字符串中的最後一個匹配字符。
char *strrchr ( const char *string, int c );
// strset 使用指定字符填充字符串。
char *strset( char *string1, int character );
// strspn 返回指定字符串中包含另一
// 字符串起始字符的長度。
size_t *strspn ( const char *string, const char *skipset );
// strstr 返回一個字符串在另一字符串中第一次發生匹配的指針。
char *strstr ( const char *string1, const char *string2 );
// strtok 從由指定的字符分隔的字符串中返回標記。
// 注意，在 Vugen 文件中，需要明確聲明不返回
// integer 類型值的 C 函數。
char *strtok ( char *string, const char *delimiters );
// strupr 將字符串轉換爲大寫。
char *strupr ( char *string );
// lrc_CoCreateInstance 函數在本地系統或爲特定
// 對象創建的默認主機中創建該對象的單個未初始化實例
// 並返回未知接口，該接口可用於獲取其他接口。創建
// 該實例後，VuGen 調用 lrc_CoGetClassObject
// 以檢索接口。如果 COM 對象位於遠程計算機中，
// 將使用 lrc_CreateInstanceEx 取代
// lrc_CoCreateInstance。
HRESULT lrc_CoCreateInstance(GUID * pClsid, IUnknown * pUnkOuter, unsigned long dwClsContext, GUID * riid, LPVOID * ppv, BOOL __CheckResult);
// lrc_CreateInstanceEx 函數在指定的
// 遠程計算機上創建未初始化的對象，並且
// 可以返回任意數量的請求接口。
HRESULT lrc_CreateInstanceEx(char *clsidStr, Iunknown *pUnk, DWORD dwClsCtx, ...);
// lrc_CoGetClassObject 函數提取
// 指定類的類工廠。
void lrc_CoGetClassObject( REFCLSID rclsid, Long dwClsContext, COSERVERINFO * pServerInfo, REFIID riid, LPVOID * ppv);
// lrc_GUID 函數返回命名對象（例如
// COM 接口）的 GUID。VuGen 使用它
// 檢索標識符，該標識符用於檢索接口
// 標識符和用於 COM 通信的 COM 對象
// 的 PROGID。
GUID lrc_GUID(const char *str);
// lrc_GUID_by_ref 函數返回指向命名對象
// （例如 COM 接口）的 GUID 的指針。VuGen
// 使用它檢索標識符，該標識符用於檢索接口
// 標識符和用於 COM 通信的 COM 對象的
// PROGID。
GUID* lrc_GUID_by_ref(const char *str);
// lrc_DispMethod 函數使用 IDispatch:Invoke
// 方法調用接口的方法。lrc_DispMethod 調用
// 將 wflags 設置爲 DISPATCH_METHOD。
VARIANT lrc_DispMethod(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispMethod1 使用 IDispatch 接口調用
// （或獲取）同名的方法（或屬性）。lrc_DispMethod1
// 調用將 wflags 設置爲 DISPATCH_METHOD 和
// DISPATCH_PROPERTYGET。它可以用在方法與屬性
// 具有同一名稱的情況下。
VARIANT lrc_DispMethod1(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyGet 調用使用 IDispatch 接口
// 獲取屬性並將 wflags 設置爲 DISPATCH_PROPERTYGET。
VARIANT lrc_DispPropertyGet(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyPut 使用 IDispatch 接口設置屬性。
// 該調用將設置 DISPATCH_PROPERTYPUT 標誌。
void lrc_DispPropertyPut(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_DispPropertyPutRef 使用 IDispatch 接口根據
// 引用設置屬性，並設置 DISPATCH_PROPERTYPUTREF 標誌。
void lrc_DispPropertyPutRef(IDispatch * pDispatch, char *idName, unsigned long locale, ...);
// lrc_CreateVBCollection 函數創建填充安全
// 數組值的 Visual Basic (VB) Collection 對象，
// 並將集合接口指針返回到 pCollection 中。
// VB 集合是由 COM 實現爲接口的變量
// SafeArray。
HRESULT lrc_CreateVBCollection(SAFEARRAY *items, _Collection** pCollection);
// lrc_CoObject_from_variant 函數從變量中
// 提取 IUnknown 接口類型指針。
IUnknown* lrc_CoObject_from_variant(VARIANT var);
// lrc_DispObject_from_variant 函數從變量中
// 提取 IDispatch 接口類型指針。
IDispatch* lrc_DispObject_from_variant(VARIANT var);
// lrc_CoObject_by_ref_from_variant 函數從指向
// 變量的指針中提取 IUnknown 接口類型指針。
IUnknown* lrc_CoObject_by_ref_from_variant(VARIANT var);
// lrc_DispObject_by_ref_from_variant 函數從指向
// 變量的指針中提取 IDispatch 接口類型指針。
IDispatch* lrc_DispObject_by_ref_from_variant(VARIANT var);
// 輸入表示整數的字符串時，lrc_int 函數返回
// integer 類型值。此參數可以是文字字符串、
// 變量或參數。
int lrc_int(const char* str);
// 輸入表示整數的字符串時，lrc_int_by_ref
// 函數返回指向 integer 類型值的指針。此參數
// 可以是文字字符串、變量或
// 參數。
int* lrc_int_by_ref(const char* str);
// lrc_save_int 函數將 integer 值
// 保存在指定變量 name 下的字符串中，以便
// 您將其用於參數化。VuGen 將此函數生成
// 爲註釋掉的調用。如果要將此值用作參數，
// 可以更改 name 參數並取消調用的
// 註釋。
int lrc_save_int(const char* name, int val);
// lrc_save_int_by_ref 函數將 integer 值
// 保存在字符串中，並將 val 設置爲指向該字符串。
// VuGen 將此函數生成爲註釋掉的調用。如果要
// 將此值用作參數，可以更改 name 並取消調用
// 的註釋。
int lrc_save_int_by_ref(const char* name, int *val);
// lrc_get_bstr_length 返回 BSTR 類型字符
// 串的長度。BSTR 字符串可以包括 null。
int lrc_get_bstr_length(BSTR str);
// lrc_get_bstr_sub 從輸入字符串 str 的開始處
// 返回 size 個字符的子集。
BSTR lrc_get_bstr_sub(BSTR str, int size);
// lrc_print_bstr 將 BSTR 字符串輸出到
// 用於調試目的的標準輸出上。
int lrc_print_bstr(BSTR str);
// lrc_BSTR1 創建長度爲 len 的 BSTR 字符串，它可以包括 null。
BSTR lrc_BSTR1 (const char* str, long len);
// lrc_save_BSTR1 函數將 BSTR str 保
// 存到字符串 name 中。
int lrc_save_BSTR1 (const char* name, BSTR str);
// 輸入表示無符號整數的字符串時，lrc_uint 函數
// 返回無符號 integer 類型值。
unsigned int lrc_uint(const char* str);
// 輸入表示無符號整數的字符串時，lrc_uint_by_ref
// 函數返回指向無符號 integer 類型值的
// 指針。
unsigned int* lrc_uint_by_ref(const char* str);
// lrc_save_uint 函數將無符號 integer 值
// 保存在指定變量 name 下的字符串中，以便
// 您將其用於參數化。VuGen 將此函數生
// 成爲註釋掉的調用。如果要將此值用作
// 參數，可以更改 name 參數並取消調用的
// 註釋。
int lrc_save_uint(const char* name, unsigned int val);
// lrc_save_uint_by_ref 函數將
// 無符號 integer 類型值保存在字符串中，
// 並將 val 設置爲指向該字符串。VuGen 將此
// 函數生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 name 並取消調用的註釋。
int lrc_save_uint_by_ref(const char* name, unsigned int *val);
// 輸入表示 long 類型的字符串時，lrc_long 函數
// 返回長整型值。
long lrc_long(const char* str);
// 輸入表示 long 類型的字符串時，lrc_long_by_ref 函數
// 返回指向長整型值的指針。
long* lrc_long_by_ref(const char* str);
// lrc_save_long 函數將長整型值
// 保存在指定變量 name 下的字符串中，
// 以便您可以將其用於參數化。VuGen
// 將此函數生成爲註釋掉的調用。如果
// 要將此值用作參數，可以更改 name
// 並取消調用的註釋。
int lrc_save_long(const char* name, long val);
// lrc_save_long_by_ref 函數將長整型值保存在字符串中，
// 並將 val 設置爲指向該字符串。
int lrc_save_long_by_ref(const char* name, long *val);
// 輸入表示無符號 long 類型值的字符串時，
// lrc_ulong 函數返回無符號長整型值。
unsigned long lrc_ulong(const char* str);
// 輸入表示無符號 long 類型值的字符串時，
// lrc_ulong_by_ref 函數返回指向無符號長整型值
// 的指針。
unsigned long* lrc_ulong_by_ref(const char* str);
// lrc_save_ulong 函數將無符號
// 長整型值保存在指定變量 name 下
// 的字符串中，以便您可以將其用於參數化。
// VuGen 將此函數生成爲註釋掉的調用。
// 如果要將此值用作參數，可以更改 name
// 並取消調用的註釋。
int lrc_save_ulong(const char* name, unsigned long val);
// lrc_save_ulong_by_ref 函數將無符號長整型值保存爲字符串，
// 並將 val 設置爲指向該字符串。
int lrc_save_ulong_by_ref(const char* name, unsigned long *val);
// 輸入表示短整型值的字符串時，lrc_short 函數
// 返回短整型值。
short lrc_short(const char* str);
// 輸入表示短整型值的字符串時，lrc_short_by_ref 函數
// 返回指向短整型值的
// 指針。
short* lrc_short_by_ref(const char* str);
// lrc_save_short 函數將短整型值保存
// 在指定變量 name 下的字符串中，以便
// 您可以將其用於參數化。VuGen 將此
// 函數生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_short(const char* name, short val);
// lrc_save_short_by_ref 函數將短整型值保存在字符串中，
// 並將 val 設置爲指向該字符串。
int lrc_save_short_by_ref(const char* name, short *val);
// 輸入表示貨幣值的字符串時，lrc_currency 函
// 數返回貨幣值。
CY lrc_currency(const char* str);
// 輸入表示貨幣值的字符串時，
// lrc_currency_by_ref 函數返回指向
// 貨幣結構的指針。
CY* lrc_currency_by_ref(const char* str);
// lrc_save_currency 函數將貨幣 (CY) 值
// 保存在指定變量 name 下的字符串中，以便您
// 可以將其用於參數化。VuGen 將此函數
// 生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_currency(const char* name, CY val);
// lrc_save_currency_by_ref 函數將由“val”
// 指針引用的貨幣值保存到字符串參數中。
int lrc_save_currency_by_ref(const char* name, CY *val);
// 輸入表示 date 類型值的字符串時，
// lrc_date 函數返回 DATE 類型值。
DATE lrc_date(const char* str);
// 輸入表示 date 類型值的字符串時，lrc_date_by_ref 函數
// 返回指向 DATE 的指針。
DATE* lrc_date_by_ref(const char* str);
// lrc_save_date 函數將 date 類型值保存
// 爲字符串。VuGen 將此函數生成爲註釋掉的調用。
// 如果要將此值用作參數，可以更改 name 並取消
// 調用的註釋。
int lrc_save_date(const char* name, DATE val);
// lrc_save_date_by_ref 函數將 date 類型值保存爲字符串。
int lrc_save_date_by_ref(const char* name, DATE *val);
// 輸入包含“true”或“false”的字符串時，
// lrc_bool 函數返回 Boolean 類型值。
VARIANT_BOOL lrc_bool(const char* str);
// 輸入包含“true”或“false”的字符串時，
// lrc_bool_by_ref 函數返回指向 Boolean
// 類型值的指針。
VARIANT_BOOL* lrc_bool_by_ref(const char* str);
// lrc_save_bool 函數將 Boolean 類型值
// 保存爲字符串參數。VuGen 將此函數生成爲
// 註釋掉的調用。如果要將此值用作參數，可以
// 更改 name 並取消調用的註釋。
int lrc_save_bool(const char* name, VARIANT_BOOL val);
// lrc_save_bool_by_ref 函數將 Boolean 類型值
// 保存到字符串參數中。
int lrc_save_bool_by_ref(const char* name, VARIANT_BOOL *val);
// 輸入表示無符號短整型值的字符串時，
// lrc_ushort 函數返回無符號
// 短整型值。
unsigned short lrc_ushort(const char* str);
// 輸入表示無符號短整型值的字符串時，
// lrc_ushort_by_ref 函數返回指向無符號短整型值
// 的指針。
unsigned short* lrc_ushort_by_ref(const char* str);
// lrc_save_ushort 函數將無符號
// 短整型值保存在參數中。
int lrc_save_ushort(const char* name, unsigned short val);
// lrc_save_ushort_by_ref 函數將無符號短整型值
// 保存到參數中。
int lrc_save_ushort_by_ref(const char* name, unsigned short *val);
// 輸入包含浮點數的字符串時，
// lrc_float 函數返回浮點數。
float lrc_float(const char* str);
// 輸入包含浮點數的字符串時，
// lrc_float_by_ref 函數返回指向浮點數
// 的指針。
float* lrc_float_by_ref(const char* str);
// lrc_save_float 函數將浮點類型
// 浮點值保存在字符串參數中。VuGen 將此
// 函數生成爲註釋掉的調用。如果要使用
// 該參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_float(const char* name, float val);
// lrc_save_float_by_ref 函數將浮點
// 類型浮點值保存在字符串參數中。
int lrc_save_float_by_ref(const char* name, float *val);
// 輸入包含 double 類型值的字符串時，
// lrc_double 函數返回 double 類型值。
double lrc_double(const char* str);
// 輸入包含 double 類型值的字符串時，lrc_double_by_ref
// 函數返回指向 double 類型值的指針。
double* lrc_double_by_ref(const char* str);
// lrc_save_double 函數將雙精度浮點
// 類型值保存在字符串參數中。VuGen 將
// 此函數生成爲註釋掉的調用。如果要將
// 此值用作參數，可以更改 name 並取消
// 調用的註釋。
int lrc_save_double(const char* name, double val);
// lrc_save_double_by_ref 函數將雙精度浮點
// 類型值保存在字符串參數中。
int lrc_save_double_by_ref(const char* name, double *val);
// 輸入包含 dword 類型值的字符串時，lrc_dword 函數
// 返回雙字類型值。
DWORD lrc_dword(const char* str);
// lrc_save_dword 函數將雙字類型值
// 保存在字符串參數中。VuGen 將此函數
// 生成爲註釋掉的調用。如果要將此值用作
// 參數，可以更改 name 並取消調用的註釋。
int lrc_save_dword(const char* name, DWORD val);
// lrc_BSTR 函數將任何字符串轉換爲 BSTR。
BSTR lrc_BSTR(const char* str);
// lrc_save_BSTR 函數將 BSTR 值保存
// 爲字符串參數。VuGen 將此函數生成爲
// 註釋掉的調用。如果要將此值用作參數，
// 可以更改 name 並取消調用的註釋。
int lrc_save_BSTR(const char* name, BSTR val);
// lrc_ascii_BSTR 函數將字符串
// 轉換爲 ascii_BSTR。
BSTR lrc_ascii_BSTR(const char* str);
// lrc_ascii_BSTR_by_ref 函數將字符串轉換
// 爲 ascii_BSTR，並返回指向該 BSTR 的指針。
BSTR* lrc_ascii_BSTR_by_ref(const char* str);
// 當不再使用 COM 對象時，
// lrc_Release_Object 函數釋放該對象。
// 釋放對象後，對象的引用計數將減 1
// （例如，IUnknown_1 到 IUnknown_0）。
//
int lrc_Release_Object(const char* interface);
// lrc_save_ascii_BSTR 函數將 ascii BSTR 保存
// 到字符串參數中。VuGen 將此函數生成爲註釋掉的調用。
// 如果要將此值用作參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_ascii_BSTR(const char* name, BSTR val);
// lrc_save_ascii_BSTR_by_ref 函數將 ascii BSTR 保
// 存到字符串參數中。
int lrc_save_ascii_BSTR_by_ref(const char* name, BSTR *val);
// lrc_save_VARIANT 函數將任何數據類型的值
// 保存到字符串參數中。
int lrc_save_VARIANT(const char* name, VARIANT val);
// lrc_save_variant_<Type-Name> 函數系列
// 由 VuGen 生成，用於將指定的 <Type-Name>
// 變量保存爲字符串參數。VuGen 將這些代碼行
// 生成爲註釋掉的調用。如果要將此值用作參數，
// 可以更改 name 並取消調用的
// 註釋。
int lrc_save_variant_<Type-Name>(const char* name, VARIANT val);
// lrc_save_variant_short 將 short 變量類型值保存到字符串參數中。
int lrc_save_variant_short(const char* name, VARIANT val);
// lrc_save_variant_ushort 將 short 變量類型值保存到字符串參數中。
int lrc_save_variant_ushort(const char* name, VARIANT val);
// lrc_save_variant_char 將 short 變量類型值保存到字符串參數中。
int lrc_save_variant_char(const char* name, VARIANT val);
// lrc_save_variant_int 將 int 變量類型值保存到字符串參數中。
int lrc_save_variant_int(const char* name, VARIANT val);
// lrc_save_variant_uint 將無符號 integer 變量
// 類型值到字符串參數中。
int lrc_save_variant_uint(const char* name, VARIANT val);
// lrc_save_variant_ulong 將無符號 long 變量
// 類型值保存到字符串參數中。
int lrc_save_variant_ulong(const char* name, VARIANT val);
// lrc_save_variant_BYTE 將 BYTE 變量類型值保存到字符串參數中。
int lrc_save_variant_BYTE(const char* name, VARIANT val);
// lrc_save_variant_long 將 long 變量類型值保存到字符串參數中。
int lrc_save_variant_long(const char* name, VARIANT val);
// lrc_save_variant_float 將 float 變量類型值保存到字符串參數中。
int lrc_save_variant_float(const char* name, VARIANT val);
// lrc_save_variant_double 將 double 變量
// 類型值保存到字符串參數中。
int lrc_save_variant_double(const char* name, VARIANT val);
// lrc_save_variant_bool 將 boolean 變量類型值保存到字符串參數中。
int lrc_save_variant_bool(const char* name, VARIANT val);
// lrc_save_variant_scode 將 scode 變量類型值保存到字符串參數中。
int lrc_save_variant_scode(const char* name, VARIANT val);
// lrc_save_variant_currency 將 currency 變量
// 類型值保存到字符串參數中。
int lrc_save_variant_currency(const char* name, VARIANT val);
// lrc_save_variant_date 將 DATE 變量類型值保存到字符串參數中。
int lrc_save_variant_date(const char* name, VARIANT val);
// lrc_save_variant_BSTR 將 BSTR 變量類型值保存到字符串參數中。
int lrc_save_variant_BSTR(const char* name, VARIANT val);
// lrc_save_variant_<Type-Name>_by_ref 函數
// 系列由 VuGen 生成，以便將通過變量中的引用方式
// 存儲的、指定了 <Type-Name> 的變量保存爲字符串
// 參數。VuGen 將這些代碼行生成爲註釋掉的調用。
// 如果要將此值用作參數，可以更改 name 並取消調用的
// 註釋。
//
int lrc_save_variant_<Type-Name>_by_ref(const char* name, VARIANT val);
// lrc_save_variant_short_by_ref 將通過變量中
// 的引用方式存儲的值保存爲參數。
int lrc_save_variant_short_by_ref(const char* name, VARIANT val);
// lrc_save_variant_ushort_by_ref 將
// 通過變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_ushort_by_ref(const char* name, VARIANT val);
// lrc_save_variant_char_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_char_by_ref(const char* name, VARIANT val);
// lrc_save_variant_int_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_int_by_ref(const char* name, VARIANT val);
// lrc_save_variant_uint_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_uint_by_ref(const char* name, VARIANT val);
// lrc_save_variant_ulong_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_ulong_by_ref(const char* name, VARIANT val);
// lrc_save_variant_BYTE_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_BYTE_by_ref(const char* name, VARIANT val);
// lrc_save_variant_long_by_ref 將
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_long_by_ref(const char* name, VARIANT val);
// lrc_save_variant_float_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_float_by_ref(const char* name, VARIANT val);
// lrc_save_variant_double_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_double_by_ref(const char* name, VARIANT val);
// lrc_save_variant_bool_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_bool_by_ref(const char* name, VARIANT val);
// lrc_save_variant_scode_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_scode_by_ref(const char* name, VARIANT val);
// lrc_save_variant_currency_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_currency_by_ref(const char* name, VARIANT val);
// lrc_save_variant_date_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_date_by_ref(const char* name, VARIANT val);
// lrc_save_variant_BSTR_by_ref 將通過
// 變量中的引用方式存儲的值保存爲參數。
int lrc_save_variant_BSTR_by_ref(const char* name, VARIANT val);
// lrc_BYTE 函數將字符串轉換
// 爲無符號字符（字節）數值。
BYTE lrc_BYTE(const char* str);
// lrc_BYTE_by_ref 函數將字符串轉換
// 爲無符號字符（字節）數值，並返回指向該字節
// 的指針。
char * lrc_BYTE_by_ref(const char* str);
// lrc_save_BYTE 函數將 byte 類型值保存爲參數。
// VuGen 將此函數生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 param_name 並取消調用的
// 註釋。
int lrc_save_BYTE(const char* param_name, BYTE val);
// lrc_save_BYTE_by_ref 函數將 byte
// 類型值保存爲參數。VuGen 將此函數生成爲
// 註釋掉的調用。如果要將此值用作參數，可以
// 更改 param_name 並取消調用的註釋。
int lrc_save_BYTE_by_ref(const char* param_name, BYTE *val);
// 輸入表示超級整型值的字符串時，lrc_hyper 函
// 數返回超級（64 位）整型值。
hyper lrc_hyper(const char* str);
// 輸入表示超級整型值的字符串時，
// lrc_hyper_by_ref 函數返回指向
// 超級（64 位）整型值的指針。
hyper* lrc_hyper_by_ref(const char* str);
// lrc_save_hyper 函數將 64 位超級
// 整型值保存在字符串參數中。VuGen 將
// 此函數生成爲註釋掉的調用。如果要將
// 此值用作參數，可以更改 name 並取消
// 調用的註釋。
int lrc_save_hyper(const char* name, hyper val);
// lrc_save_hyper_by_ref 函數將 64 位
// 超級整型值保存到字符串參數中。
int lrc_save_hyper_by_ref(const char* name, hyper *val);
// 輸入表示無符號超級整型值的字符串時，
// lrc_uhyper 函數返回無符號超級
// （64 位）整型值。
uhyper lrc_uhyper(const char* str);
// 輸入表示無符號超級整型值的字符串時，
// lrc_uhyper_by_ref 函數返回指向
// 無符號超級（64 位）整型值。
uhyper* lrc_uhyper_by_ref(const char* str);
// lrc_save_uhyper 函數將無符號 64 位
// 超級整型值保存在字符串參數中。VuGen 將
// 此函數生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_uhyper(const char* name, uhyper val);
// lrc_save_uhyper_by_ref 函數將無符號
// 64 位超級整型值保存到字符串參數中。VuGen
// 將此函數生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_uhyper_by_ref(const char* name, uhyper *val);
// lrc_char 函數將包含 char 類型數值
// 的字符串轉換爲 char 變量。
char lrc_char(const char* str);
// lrc_char_by_ref 函數將包含 char 類型數值的
// 字符串轉換爲 char 變量。
char* lrc_char_by_ref(const char* str);
// lrc_save_char 函數將 char類型
// (0 - 127) 保存到字符串參數中。
// VuGen 將此函數生成爲註釋掉的調用。
// 如果要將此值用作參數，可以更改 name
// 並取消調用的註釋。
int lrc_save_char(const char* name, char val);
// lrc_save_char_by_ref 函數將 char 類型
// (0 - 127) 保存到字符串參數中。VuGen 將
// 此函數生成爲註釋掉的調用。如果要將此值
// 用作參數，可以更改 name 並取消調用的
// 註釋。
int lrc_save_char_by_ref(const char* name, char *val);
// lrc_variant_empty 函數返回空變量。
VARIANT lrc_variant_empty();
// lrc_variant_empty_by_variant 返回
// 包含對空變量引用的變量。
VARIANT lrc_variant_empty_by_variant();
// lrc_variant_null 函數返回 null 變量。
VARIANT lrc_variant_null();
// lrc_variant_null_by_variant 返回
// 包含對 null 變量引用的變量。
VARIANT lrc_variant_null_by_variant();
// lrc_variant_short 函數將字符串轉換爲
// 短整型值，並在變量中將其返回。
VARIANT lrc_variant_short(const char* str);
// lrc_variant_short_by_variant 函數將字符串
// 轉換爲短整型值，並返回包含對某變量（其中包含
// 該短整型值）引用的變量。
VARIANT lrc_variant_short_by_variant(const char* str);
// lrc_variant_ushort 函數將字符串轉換爲
// 無符號短整型值，並在變量中將其返回。
VARIANT lrc_variant_ushort(const char* str);
// lrc_variant_char 函數將字符串轉換爲
// char 類型值，並在變量中將其返回。
VARIANT lrc_variant_char(const char* str);
// lrc_variant_int 函數將字符串轉換爲整型
// 值，並在變量中將其返回。
VARIANT lrc_variant_int(const char* str);
// lrc_variant_uint 函數將字符串轉換爲
// 無符號整型值，並將其存儲在變量中返回。
VARIANT lrc_variant_uint(const char* str);
// lrc_variant_ulong 函數將字符串轉換爲
// 無符號長整型值，並將其存儲在變量中返回。
VARIANT lrc_variant_ulong(const char* str);
// lrc_variant_BYTE 函數將字符串轉換爲
// 無符號 char (byte) 類型值並存儲於變量中。
VARIANT lrc_variant_BYTE(const char* str);
// lrc_variant_BYTE_by_variant 函數將字符串
// 轉換爲無符號 char (byte) 類型值，並返回包含
// 對某變量（包含該 byte）引用的變量。
VARIANT lrc_variant_BYTE_by_variant(const char* str);
// lrc_variant_long 函數將字符串
// 轉換爲存儲於變量中的長整型值。
VARIANT lrc_variant_long(const char* str);
// lrc_variant_long_by_variant 函數將
// 字符串轉換爲存儲於變量中的長整型值，並且
// 返回包含對某變量（其中包含該長整型值）
// 引用的變量。
VARIANT lrc_variant_long_by_variant(const char* str);
// lrc_variant_float 函數將字符串轉換爲
// 存儲於變量中的浮點類型值。
VARIANT lrc_variant_float(const char* str);
// lrc_variant_float_by_variant 函數將
// 字符串轉換爲浮點類型值，並且返回包含對某
// 變量（其中包含該值）引用的變量。
VARIANT lrc_variant_float_by_variant(const char* str);
// lrc_variant_double 函數將字符串轉換爲
// 存儲於變量中的雙精度型浮點值。
VARIANT lrc_variant_double(const char* str);
// lrc_variant_double_by_variant 函數將
// 字符串轉換爲雙精度型值，並且返回包含對某變量
// （其中包含該值）引用的變量。
VARIANT lrc_variant_double_by_variant(const char* str);
// lrc_variant_bool 函數將包含“true”或“false”
// 的字符串轉換爲存儲於變量中的 Boolean 類型值。
VARIANT lrc_variant_bool(const char* str);
// lrc_variant_bool_by_variant 函數將
// 包含“true”或“false”的字符串轉換爲
// Boolean 值，並且返回包含對某變量（其中
// 包含該值）引用的變量。
VARIANT lrc_variant_bool_by_variant(const char* str);
// lrc_variant_scode 函數將包含系統錯誤代碼值的。
// 字符串轉換爲存儲於變量中的錯誤代碼
VARIANT lrc_variant_scode(const char* errcode);
// lrc_variant_scode_by_variant 函數將
// 包含系統錯誤代碼值的字符串轉換爲錯誤代碼，
// 並且返回包含對某變量（其中包含該值）引用
// 的變量。
VARIANT lrc_variant_scode_by_variant(const char* errcode);
// lrc_variant_currency 函數將包含貨幣值
// 的字符串轉換爲存儲於變量中的貨幣值。
VARIANT lrc_variant_currency(const char* str);
// lrc_variant_currency_by_variant 函數
// 將包含貨幣值的字符串轉換爲貨幣值，並且
// 返回包含對某變量（其中包含該值）引用的
// 變量。
VARIANT lrc_variant_currency_by_variant(const char* str);
// lrc_variant_date 函數將包含 date 類型值的
// 字符串轉換爲存儲於變量中的 date 類型值。
VARIANT lrc_variant_date(const char* str);
// lrc_variant_date_by_variant 函數將
// 包含 date 類型值的字符串轉換爲 date 類型值，
// 並且返回包含對某變量（其中包含該 date 類型值）
// 引用的變量。
VARIANT lrc_variant_date_by_variant(const char* str);
// lrc_variant_BSTR 函數將字符串轉換爲
// 存儲於變量中的 BSTR 類型值。
VARIANT lrc_variant_BSTR(const char* str);
// lrc_variant_BSTR_by_variant 函數將字符串
// 轉換爲 BSTR 值，並且返回包含對某變量（其中
// 包含該值）引用的變量。
VARIANT lrc_variant_BSTR_by_variant(const char* str);
// lrc_variant_ascii_BSTR 函數將字符串分配給
// 存儲於變量中的 ASCII BSTR 值
VARIANT lrc_variant_ascii_BSTR(const char* str);
// lrc_variant_CoObject 函數將 IUnknown 接口
// 指針分配給變量。
VARIANT lrc_variant_CoObject(IUnknown* pUnknown);
// lrc_variant_CoObject_by_variant 函數將
// IUnknown 接口指針分配給變量，並且返回
// 包含對某變量（其中包含 IUnknown 引用）
// 引用的變量。
VARIANT lrc_variant_CoObject_by_variant(IUnknown* pUnknown);
// lrc_variant_DispObject 函數將
// IDispatch 接口指針分配給變量。
VARIANT lrc_variant_DispObject(IDispatch* pDispatch);
// lrc_variant_DispObject_by_variant 函數
// 將 IDispatch 接口指針分配給變量，並且返回包含
// 對某變量（其中包含 IDispatch 引用）引用的
// 變量。
VARIANT lrc_variant_DispObject_by_variant(IDispatch* pDispatch);
// lrc_variant_short_by_ref 函數將字符串
// 分配給通過變量中的引用方式存儲的短整型值。
VARIANT lrc_variant_short_by_ref(const char* str);
// lrc_variant_ushort_by_ref 函數將字符串
// 分配給通過變量中的引用方式存儲的無符號短整型值。
VARIANT lrc_variant_ushort_by_ref(const char* str);
// lrc_variant_char_by_ref 函數將字符串分配
// 給通過變量中的引用方式存儲的 char 類型值。
VARIANT lrc_variant_char_by_ref(const char* str);
// lrc_variant_int_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的 integer 類型值。
VARIANT lrc_variant_int_by_ref(const char* str);
// lrc_variant_uint_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的無符號 integer 類型值。
VARIANT lrc_variant_uint_by_ref(const char* str);
// lrc_variant_ulong_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的長整型值。
VARIANT lrc_variant_ulong_by_ref(const char* str);
// lrc_variant_BYTE_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的 char (byte) 類型值。
VARIANT lrc_variant_BYTE_by_ref(const char* str);
// lrc_variant_long_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的長整型值。
VARIANT lrc_variant_long_by_ref(const char* str);
// lrc_variant_float_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的浮點型浮點值。
VARIANT lrc_variant_float_by_ref(const char* str);
// lrc_variant_double_by_ref 函數將字符串分配給
// 通過變量中的引用方式存儲的雙精度型值。
VARIANT lrc_variant_double_by_ref(const char* str);
// lrc_variant_bool_by_ref 函數將包含“true”
// 或“false”的字符串分配給通過變量中的
// 引用方式存儲的 Boolean 類型值。
VARIANT lrc_variant_bool_by_ref(const char* str);
// lrc_variant_scode_by_ref 函數將包含
// 系統錯誤代碼值的字符串分配給通過變量中的
// 引用方式存儲的錯誤代碼中。
VARIANT lrc_variant_scode_by_ref(const char* str);
// lrc_variant_currency_by_ref 函數將字符串
// 分配給通過變量中的引用方式存儲的貨幣類型值。
VARIANT lrc_variant_currency_by_ref(const char* str);
// lrc_variant_date_by_ref 函數將字符串
// 分配給通過變量中的引用方式存儲的 date 類型值。
VARIANT lrc_variant_date_by_ref(const char* str);
// lrc_variant_BSTR_by_ref 函數將字符串分配給的
// 通過變量中引用方式存儲的 BSTR 值。
VARIANT lrc_variant_BSTR_by_ref(const char* str);
// lrc_variant_ascii_BSTR_by_ref 函數將字符串
// 分配給通過變量中的引用方式存儲的 ascii BSTR 值。
VARIANT lrc_variant_ascii_BSTR_by_ref(const char* str);
// lrc_variant_CoObject_by_ref 函數將指針
// 分配給變量中的 IUnknown 接口。
VARIANT lrc_variant_CoObject_by_ref(IUnknown* pUnknown);
// lrc_variant_DispObject_by_ref 函數將指針
// 轉換爲變量中的 IDispatch 接口。
VARIANT lrc_variant_DispObject_by_ref(IDispatch* pDispatch);
// lrc_variant_variant_by_ref 函數創建包含現有
// 變量的新變量。
VARIANT lrc_variant_variant_by_ref(VARIANT * pVar);
// lrc_variant_from_variant_by_ref 函數從
// 另一個變量引用中獲取變量。
VARIANT lrc_variant_from_variant_by_ref(VARIANT var);
// Create<n>D<Type-Name>Array 函數系列
// 創建由 Type-name 指定的類型的 n 維數組。
// 對於每一維，該調用必須指定 lower_bound
// 和 upper_bound。
<Type-Name> Array Create<n>D<Type-Name>Array(int lower_bound,int upper_bound, int lower_bound, int upper_bound...);
// Destroy<Type-Name>Array 函數系列銷燬
// 由 Type-name 指定的類型的數組。對於在
// 腳本中（而非由 VuGen）創建的數組，可以使用
// 它們恢復內存。
void Destroy<Type-Name>Array(<Type-Name>Array Array);
// DestroyBoolArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyBoolArray(BoolArray Array);
// DestroyBstrArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyBstrArray(BstrArray Array);
// DestroyByteArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyByteArray(ByteArray Array);
// DestroyCharArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyCharArray(CharArray Array);
// DestroyCoObjectArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyCoObjectArray(CoObjectArray Array);
// DestroyCurrencyArray 釋放由數組佔用的內存。於
// 該函數用恢復由腳本爲數組分配的內存。
void DestroyCurrencyArray(CurrencyArray Array);
// DestroyDateArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyDateArray(CurrencyArray Array);
// DestroyDispObjectArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyDispObjectArray(DispObjectArray Array);
// DestroyDoubleArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyDoubleArray(DoubleArray Array);
// DestroyErrorArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyErrorArray(ErrorArray Array);
// DestroyFloatArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyFloatArray(FloatArray Array);
// DestroyIntArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyIntArray(IntArray Array);
// DestroyLongArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyLongArray(LongArray Array);
// DestroyShortArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyShortArray(ShortArray Array);
// DestroyUIntArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyUIntArray(UIntArray Array);
// DestroyULongArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyULongArray(ULongArray Array);
// DestroyUShortArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyUShortArray(UShortArray Array);
// DestroyVariantArray 釋放由數組佔用的內存。
// 該函數用於恢復由腳本爲數組分配的內存。
void DestroyVariantArray(VariantArray Array);
// GetBufferFrom<n>DByteArray 函數系列從 n 維
// byte 類型數組的最後一維中提取緩衝區。此函數
// 的返回值是一個指向 byte 類型的緩衝區的指針。
// 緩衝區的大小返回到 *plinesize 所指定的
// 地址中。
char * GetBufferFrom<n>DByteArray(ByteArray Array, int ind1...indn-1, size_t *pLineSize);
// Fill<n>DByteArray 函數系列將 n 維 byte 數組
// 的最後一維中填充緩衝區的內容。
char * Fill<n>DByteArray(ByteArray Array, int ind1...indn-1, const char* buffer, size_t buff_size);
// lrc_variant_<Type-Name>Array 函數系列將在
// Type-Name 中指定的類型的數組分配給變量。
VARIANT lrc_variant_<Type-Name>Array(<Type-Name>Array array);
// lrc_variant_BoolArray 將數組分配給變量。
VARIANT lrc_variant_BoolArray(BoolArray array);
// lrc_variant_BstrArray 將數組分配給變量。
VARIANT lrc_variant_BstrArray(BstrArray array);
// lrc_variant_ByteArray 將數組分配給變量。
VARIANT lrc_variant_ByteArray(ByteArray array);
// lrc_variant_CharArray 將數組分配給變量。
VARIANT lrc_variant_CharArray(CharArray array);
// lrc_variant_CoObjectArray 將數組分配給變量。
VARIANT lrc_variant_CoObjectArray(CoObjectArray array);
// lrc_variant_CurrencyArray 將數組分配給變量。
VARIANT lrc_variant_CurrencyArray(CurrencyArray array);
// lrc_variant_DateArray 將數組分配給變量。
VARIANT lrc_variant_DateArray(DateArray array);
// lrc_variant_DispObjectArray 將數組分配給變量。
VARIANT lrc_variant_DispObjectArray(DispObjectArray array);
// lrc_variant_DoubleArray 將數組分配給變量。
VARIANT lrc_variant_DoubleArray(DoubleArray array);
// lrc_variant_ErrorArray 將數組分配給變量。
VARIANT lrc_variant_ErrorArray(ErrorArray array);
// lrc_variant_FloatArray 將數組分配給變量。
VARIANT lrc_variant_FloatArray(FloatArray array);
// lrc_variant_IntArray 將數組分配給變量。
VARIANT lrc_variant_IntArray(IntArray array);
// lrc_variant_LongArray 將數組分配給變量。
VARIANT lrc_variant_LongArray(LongArray array);
// lrc_variant_ShortArray 將數組分配給變量。
VARIANT lrc_variant_ShortArray(ShortArray array);
// lrc_variant_UintArray 將數組分配給變量。
VARIANT lrc_variant_UintArray(UintArray array);
// lrc_variant_UlongArray 將數組分配給變量。
VARIANT lrc_variant_UlongArray(UlongArray array);
// lrc_variant_UshortArray 將數組分配給變量。
VARIANT lrc_variant_UshortArray(UshortArray array);
// lrc_variant_VariantArray 將數組分配給變量。
VARIANT lrc_variant_VariantArray(VariantArray array);
// lrc_variant_<Type-Name>Array_by_ref 函數系列
// 返回對由 Type-name 指定的類型的數組的引用。返回類型
// 爲變量。
VARIANT lrc_variant_<Type-Name>Array_by_ref( <Type-Name>Array array );
// lrc_variant_BoolArray_by_ref 返回對數組的引用
VARIANT lrc_variant_BoolArray_by_ref(BoolArray array);
// lrc_variant_BstrArray_by_ref 返回對數組的引用
VARIANT lrc_variant_BstrArray_by_ref(BstrArray array);
// lrc_variant_ByteArray_by_ref 返回對數組的引用
VARIANT lrc_variant_ByteArray_by_ref(ByteArray array);
// lrc_variant_CharArray_by_ref 返回對數組的引用
VARIANT lrc_variant_CharArray_by_ref(CharArray array);
// lrc_variant_CoObjectArray_by_ref 返回對數組的引用
VARIANT lrc_variant_CoObjectArray_by_ref(CoObjectArray array);
// lrc_variant_CurrencyArray_by_ref 返回對數組的引用
VARIANT lrc_variant_CurrencyArray_by_ref(CurrencyArray array);
// lrc_variant_DateArray_by_ref 返回對數組的引用
VARIANT lrc_variant_DateArray_by_ref(DateArray array);
// lrc_variant_DispObjectArray_by_ref 返回對數組的引用
VARIANT lrc_variant_DispObjectArray_by_ref(DispObjectArray array);
// lrc_variant_DoubleArray_by_ref 返回對數組的引用
VARIANT lrc_variant_DoubleArray_by_ref(DoubleArray array);
// lrc_variant_ErrorArray_by_ref 返回對數組的引用
VARIANT lrc_variant_ErrorArray_by_ref(ErrorArray array);
// lrc_variant_FloatArray_by_ref 返回對數組的引用
VARIANT lrc_variant_FloatArray_by_ref(FloatArray array);
// lrc_variant_IntArray_by_ref 返回對數組的引用
VARIANT lrc_variant_IntArray_by_ref(IntArray array);
// lrc_variant_LongArray_by_ref 返回對數組的引用
VARIANT lrc_variant_LongArray_by_ref(LongArray array);
// lrc_variant_ShortArray_by_ref 返回對數組的引用
VARIANT lrc_variant_ShortArray_by_ref(ShortArray array);
// lrc_variant_UintArray_by_ref 返回對數組的引用
VARIANT lrc_variant_UintArray_by_ref(UintArray array);
// lrc_variant_UlongArray_by_ref 返回對數組的引用
VARIANT lrc_variant_UlongArray_by_ref(UlongArray array);
// lrc_variant_UshortArray_by_ref 返回對數組的引用
VARIANT lrc_variant_UshortArray_by_ref(UshortArray array);
// lrc_variant_VariantArray_by_ref 返回對數組的引用
VARIANT lrc_variant_VariantArray_by_ref(VariantArray array);
// lrc_Get<Type-Name>ArrayFromVariant 函數系列從變量中
// 提取由 Type-name 指定的類型的數組。
<Type-Name> lrc_Get<Type-Name>ArrayFromVariant const VARIANT* var);
// lrc_GetBoolArrayFromVariant 從變量中提取數組。
VARIANT lrc_GetBoolArrayFromVariant(const VARIANT* var);
// lrc_GetBstrArrayFromVariant 從變量中提取數組。
VARIANT lrc_GetBstrArrayFromVariant(const VARIANT* var);
// lrc_GetByteArrayFromVariant 從變量中提取數組。
VARIANT lrc_GetByteArrayFromVariant(const VARIANT* var);
// lrc_GetCharArrayFromVariant 從變量中提取數
