配置文件格式：关键字 等号 代码说明(不含等号作为注释行）。
^关键字：表示系统参数，请勿修改。
@代码说明：声明一个代码模板。在输入时自动删除模板中以 //开始的注释行
.代码说明: 表示名字空间重定向。
关键字中.为名字空间分隔符。或者将.前面的标点解析为名字空间分隔符，例如::.全局常量成员，
functionname(.(参数一,参数二)表示函数的形参说明。
使用__指示光标插入位置
------------------------------------------
^MAXTIER = 30
^IGNORECASE_NODE_KEY = 1

_STUDIO_INVOKED = 判断是否在快手开发环境中运行AAuto程序

intellisense代码模式 = @/*intellisense(__/*请输入名字空间*/)*/\n\n/*end intellisense*/\n
intellisense注释模式 = @/**intellisense(__/*请输入名字空间*/)\n\nend intellisense**/\n

this = 类对象内部指针
owner=  函数的当前操作对象\n1、拥有并调用当前函数的table对象\n元方法中的左操作数\n迭代器函数中的集合对象
global = 根名字空间
self = 当前名字空间

//基础函数
rget(2,__) = rget(2,函数() ) \n丢弃函数的第一个返回值
rget(-1,__) = rget(-1,函数() )  \n仅保留函数的最后一个返回值
rget(__, ) = 从参数1指定的位置，向右截取参数2的n个返回值
loadcode(__) = 参数可以是aau文件，或者aau代码，或者指定的loader函数
dumpcode(__) = 将函数输出为字节码）
assert(__) = 断言函数\n第一个参数为真则返回此参数\n否则将第二个参数作为异常抛出
assertf(__) = 反断言函数\n第一个参数为假则返回第二个参数)\n否则返回第一个参数并抛出异常
error("__") = 抛出一个错误
error("__",2) = 抛出一个错误、并指定调用级别。

eval("__") = 将字符串转换为代码执行，并返回一个或多个值
 
execute("color __/*输入颜色*/") = 两位0到F十六进制数,\n前面一位设置背景色,后面一位设置文字颜色
execute("title  __/*输入标题*/") = 自定义控制台窗口标题 
execute("pause") = 控制台输出按任意键继续

import = 导入外部名字空间

type.eq(__, ) = 比较两个对象类型是否相同
type.rget(__) = 调用type函数检测对象类型\n并返回最后一个类型描述
type.null = 空值：基本数据类型
type.pointer = 指针值：基本数据类型
type.boolean = 布尔值：基本数据类型
type.string = 字符串：基本数据类型 
type.number = 数值：基本数据类型
type.table = 表：基本数据类型
type.cdata = c对象：基本数据类型  
type.context = 协程：基本数据类型
type.function = 函数：基本数据类型 
type.class = 类：基本数据类型 
type.file = 扩展数据类型\n使用io.open打开的文件对象 
type(.(__需要返回数据类型的变量) = 检测数据类型，可返回多个值\n返回值1：基本数据类型\n返回值2:元表中_type中声明的类型,\n返回值3:如果是结构体返回结构体声明
 
//类型转换函数

tostring(__) =
topointer(__) =
tonumber(__) = 强制转换变量为数值类型，自动识别进制\n如果参数是一个字符串，tonumber同时返回数值在字符串中的长度。
tonumber(__,10) = 强制转换变量为数值类型\n参数二指定进制

sleep(__/*毫秒*/) = 延时(cpu休眠)  
execute("__") =  调用系统命令行,成功返回0

 
setlocale(."all","__ ") =  设置当前程序使用的本地化信息
setlocale(."collate","__") =  设置当前程序字符串比较使用的本地化信息
setlocale(."ctype","__" ) =  设置当前程序字符类别及转换使用的本地化信息
setlocale(."monetary","__" ) =  设置当前程序金融货币使用的本地化信息
setlocale(."numeric","__" ) = 设置当前程序使用的本地化信息,小数点后的位数
setlocale(."time","__" ) = 设置当前程序时间日期格式使用的本地化信息   
setprivilege('SeDebugPrivilege',true) = 提升进程权限
_CMDLINE = 获取命令行参数


//关键字
and =  逻辑与运算符
not =  逻辑非运算符
or = 逻辑或运算符

true =  逻辑值：真(true,所有非null、非零值) 
false = 逻辑值：假(false,null、零)
null = 空值
 


namespace = @namespace__{//定义变量的默认名字空间\n//使用..操作符访问顶层名字空间\n}\n 

//语句块
begin =  @begin\n    __/*语句块限定局部变量作用域*/\n\nend;\n 
end =  @end;//表示语句块结束
function = @function(__/*请输入函数形参*/){\n	\n}\n
function_begin_end = @function(__) begin//定义函数\n\nend;\n
class = @class __/*输入类名字*/{\n	ctor( /*输入构造函数所需要的参数*/ ){\n	\n	};\n	type=me;\n	/*对象的所有成员必须用分号分隔*/\n}\n

//条件语句 
if =  @if(__){    }//条件判断语句 
else =  @else {\n__\n}\n
elseif = @elseif(__){//否则判断条件\n\n\n}\n
select = @select(__) {//指定用于比较的选择表达式\n\ncase 2 {\n//..io.print("选择表达式的值为2")\n}\ncase 1,9,10 {\n//..io.print("选择表达式的值是1,9,10其中之一")\n}\ncase 10;20 {\n//..io.print("选择表达式的值在10到20的范围")\n}\ncase!=0 {\n//..io.print("选择表达式的值不等于0")\n}\nelse {\n//..io.print("选择表达式的值是其他值")\n}\n\n}

//循环语句
while = @while(__/*请在这里输入循环条件*/){//如果条件符合，则循环执行下面的代码\n\n\n}\n 
while_标记 = @while(__) { 标记://在循环语句块开始可以指定标记，以冒号结束。\n\n\n}\n 
do = @do{//首先无条件进入循环语句块并执行\n\n\n}while(__)//如果条件符合，继续执行循环语句块\n 
do_标记 = @do{标记://在循环语句块开始可以指定标记，以冒号结束。\n\n\n}while(__ )//如果条件符合，继续执行循环语句块\n 
do_while_false = @do{\n	__\n}//while(false)\n 
for = @for(i=1;__;1){\n	\n\n}\n 
forin = @for(k,v in __/*table对象、或迭代器*/){\n	\n\n}\n

//容错语句
trycatch = @try{\n__\n}\ncatch(e){\n\n\n}\n
try = @try{\n__\n}\n

//其他常用语句
var =  @var__ = ;//声明一个局部变量，作用域限制在当前语句块内部
return = @return __; //返回一个或多个值.
break =  @break __;//中断循环，或指定要中断的循环级别。 
continue = @continue __;//跳过本次循环并继续下一次，或指定要跳过的循环级别。
 

collectgarbage(."stop") = 禁用垃圾收集器
collectgarbage(."restart") = 重启垃圾收集器
collectgarbage(."count") = 查询内存占用(Kb)
collectgarbage(."steppause",1) = 垃圾收集中断量(1-100)
collectgarbage(."setstepmul",2) = 垃圾收集工作量(1-100)
collectgarbage(."collect") = 完全垃圾收集
collectgarbage(."step",1) = 垃圾收集
 
table = table表操作函数库
table.next(.(__tab) = 获取table的第一个键值对元素
table.next(.(__tab,key ) = 迭代获取table的下一个键值对元素
table.tostring(__) = 获取table的字符串表达式
table.concat(.(__tab,tab2 ) = 拼接多个table对象
table.insert(.(__要插入的表,要插入的值,要插入的位置 ) = 插入元素到指定位置
table.insert(.(__要插入的表,要插入的值 ) = 插入元素到table头部
table.remove(.(__要移除元素的表,位置 ) = 在表中指定位置移除元素
table.remove(.(__要移除元素的表 ) = 在table头部移除元素
table.push(.(__) = 在顺序数组尾部压入一个或多个元素，返回数组大小
table.push(.(__v1,v2,v3,...) = 在顺序数组尾部压入多个元素，返回数组大小
table.pop(__) = 在顺序数组尾部弹出一个或多个元素并作为返回值
table.sort(.( tab__) = 排序
table.sort(.( tab__, comProc ) = 排序,comProc指定用于比较元素大小的函数
table.reverse(__) =  table数组倒序排列。
table.range(__) =  返回table数组的最小索引，最大索引\nmin,max=table.range(tab);
table.unpack(__) =  返回表中所有的元素\na,b,c,d,e = table.unpack( tab );
table.left(.(__tab,len) = 返回table对象左侧开始返回指定个数的元素。
table.right(.(__tab,len) = 返回table对象右侧开始返回指定个数的元素。
table.copy(__) = 复制table对象
table.ctor(__) = 创建元表，类化table并使之拥有构造函数，并可通过调用构造函数复制新表。
table.count() = 获取table成员总数

string =  string字符串函数库 
string.cmp(.(字符串,字符串2,比较长度) =　比较字符串前n个字符串大小(不区分字母大小写)\n\n从第一个字符开始比较，不相等则立即返回,相等返回0\n比较长度是可选参数，默认为字符串长度
按指定长度比较两个字符串,忽略大小写.\n相等返回0\n 比较长度是可选参数,
string.load("__/*文件、资源文件路径*/") = 读取文件或exe内嵌资源文件
string.load(.("__","资源类型") = 读取文件或exe内嵌资源文件
string.load(.(__typeID,resID) = 读取文件或exe内嵌资源文件
string.load(.(__typeID,resID,dll句柄) = 读取文件或exe内嵌资源文件
string.save("__/*请输入文件路径*/", ) = 保存字符串到文件
string.repeat(.(n__) = 创建长度为n的字符串，默认填充\0
string.repeat(.(n__," ") = 将参数2重复n次并创建新的字符串返回。
string.repeat(.(n__,' ') = 将参数2重复n次并创建新的字符串返回。
string.split(.(str__,sep) = string.split(str,'A'); //按单个字符拆分\nstring.split(str,"abc")//按多个分隔符拆分\nstring.split(str,"<abc>")//将置于<>内的字符串作为一个独立的分隔标记拆分字符串
string.join(.(str__,sep) = 将字符串数组使用指定的分隔符合并为一个字符串
string.concat(.(str__,str2) = 拼接字符串\n允许参数中有null值\n所有参数为null或无参数时无返回值。
string.reverse(__) = 将字符串倒序排列
string.unpack(.(str__,i,j) = 取字符串的第i个到第j个字符的ascii码数值并返回。
string.unpack(.(str__,i) = 取字符串的第i个字符的ascii码数值。
string.pack(.(chr__,chr2) = 参数为零个或多个字符的ascii码数值\nstr = string.pack('A','B','C')\n也可以是一个包含字节码的数组，例如:\nstring.pack( {'A','B','C' } )
string.lower(__) = 字符串转换为小写
string.upper(__) =  字符串转换为大写
string.random(.(len__) = 生成随机字符串（字母、数字）
string.random(.(len__,"中文字符集") = 生成随机字符串，并指定随机字符集
string.random(.(str__,str2,str3) = 参数为多个字符串，函数随机返回其中一个字符串
string.sub(.(str__,i,j ) =  从字符串中截取位置i到j的字符串，如果i,j为负数则从右侧倒数计数
string.sub(.(str__,i ) =  从字符串中截取位置i开始的字符串，如果i为负数则从右侧倒数计数
string.left(.(str__,n ) =  从字符串左侧截取n个字符
string.right(.(str__,n ) =  从字符串右侧截取n个字符
string.trim(.(str__,' ') = 从字符串首尾清除指定的字符
string.trim(.(str__,"  ") = 从字符串首尾清除指定的多个字符
string.trim(.(str__) = 从字符串首尾清除所有空白字符
string.trimleft(.(str__,' ') = 从字符串首尾清除指定的字符
string.trimleft(.(str__,"  ") = 从字符串首尾清除指定的多个字符
string.trimleft(.(str__) = 从字符串首尾清除所有空白字符
string.trimright(.(str__,' ') = 从字符串首尾清除指定的字符
string.trimright(.(str__,"  ") = 从字符串首尾清除指定的多个字符
string.trimright(.(str__) = 从字符串首尾清除所有空白字符
string.format("__", ) = 第一个字符串参数内每个%符号后面是一个格式化表达式,每个格式化表达式按顺序对应后面的参数。
string.toUnicode(.(str__,codepage) = 将字符串转换从指定编码转换为unicode编码。
string.fromUnicode(.(str__,codepage) = 从unicode编码还原到指定编码。
string.toUnicode(.(str) = 将字符串转换从ANSI编码转换为unicode编码。
string.fromUnicode(.(str) = 从unicode编码还原到ANSI编码。
string.indexAny(.(str__,substr) = 查找substr位于str的位置。\nsubstr可以是数值字节码
string.indexAny(.(str__,substr,start) = 查找substr位于str的位置。\nsubstr可以是数值字节码
string.lastIndexAny(.(str__,substr) = 查找substr位于str的位置。\nsubstr可以是数值字节码
string.lastIndexAny(.(str__,substr,start) = 查找substr位于str的位置。\nsubstr可以是数值字节码
string.startWith(.(__,"开始串") = 判断substr是否位于str开始处。
string.endWith(.(__,"结束串") = 判断substr是否位于str结束处。 
string.startWith(.(__,"开始串",true) = 判断substr是否位于str开始处。\n忽略大小写
string.endWith(.(__,"结束串",true) = 判断substr是否位于str结束处。\n忽略大小写
string.find(.(str__,"pattern" ); = 使用模式pattern在字符串str中查找\ni,j = string.find(str,".+?\d" );\n如果有多个捕获分组，将附加为多个返回值。
string.find(.(str__,"pattern",pos ); = 使用模式pattern在字符串str中查找\ni,j = string.find(str,".+?\d" );\n如果有多个捕获分组，将附加为多个返回值。
string.replace(.(str__,"pattern",repl) = 使用模式pattern在字符串str中查找\n然后替换全部搜索到的字符串为repl
string.replace(.(str__,"pattern",repl,n) = 使用模式pattern在字符串str中查找并替换为repl，\n替换次数为n次
string.match(.(str__, pattern) = 第一个参数指定目标字符串，每二个参数指定查找模式串。\n返回找到的字符串或模式串中多个分组匹配的字符串。
string.str(__) = 转换为普通文本(不含\0)
string.gmatch  = @for m,m2,m3 in string.gmatch( __,".") { \n\n} 


raw = 
raw.loadDll("__") = 加载dll\n注意Dll变量名首字母应大写，例\nUser32 := raw.loadDll("User32.dll")\n所有API有关DLL、API函数名字约定首字母大写
raw.tostdcall(.(afunc__,"()") = 创建回调函数\n使用stdcall调用约定
raw.tocdecl(.(afunc__,"()") = 创建回调函数\n使用cdecl调用约定
raw.tostdcall(.(afunc__,"()",owner) = 创建回调函数\n使用stdcall调用约定
raw.tocdecl(.(afunc__,"()",owner) = 创建回调函数\n使用cdecl调用约定
raw.convert(.( from__, to) = API结构体类型转换函数\n将结构体struct_from转换为struct_to
raw.convert(.( from__, to,offset) = API结构体类型转换函数\n将结构体struct_from转换为struct_to
raw.sizeof(.(__ /*输入结构体或API数据类型*/ ) = 调用c语言中sizeof并返回API数据类型长度。
raw.remoteApi(__/*输入进程ID*/,"void()",) = 参数(进程ID,函数原型,CALL地址)
raw.remoteApi(__/*输入进程ID*/,"void()", ,"cdcel") = 参数(进程ID,函数原型,CALL地址,调用约定)
raw.remoteApi(__/*输入进程ID*/,"void()","dll","api") =  参数(进程ID,函数原型,加载DLL模块名,函数名)
raw.remoteApi(__/*输入进程ID*/,"void()","dll","api","cdcel,borland") =  参数(进程ID,函数原型,加载DLL模块名,函数名,调用约定)
raw.malloc(__) = 参数可以是一个结构体table，或者需要分配的内存大小\nraw.malloc分配的内存是可读写的自由存储区\n通常用来替代可能被外部API修改的普通指针参数（string、或pointer)\n不适用于输出参数(&标记的参数)、不适用于数组类型([]指定的类型)
raw.malloc(__,0) = 分配内存，并按第二个参数指定的值初始化内存数据\nraw.malloc分配的内存是可读写的自由存储区\n通常用来替代可能被外部API修改的普通指针参数（string、或pointer)\n不适用于输出参数(&标记的参数)、不适用于数组类型([]指定的类型)
raw.tostring(.(__ ) = 将结构体(table)、指针(pointer)、或raw.malloc分配的内存数据(cdata)转换为string对象
raw.tostring(.(__  , start,end) = 将结构体(table)、指针(pointer)、\n或raw.malloc分配的内存数据(cdata)转换为string对象\nstart指定开始位置，end指定结束位置
raw.toarray( __ ) = 创建API函数中的动态数组\n参数可以是一个指定长度的数值，也可以是一个AAuto table数组 
raw.toarray( __,"struct" ) = 创建API函数中的动态数组\n第一个参数可以是一个指定长度的数值，也可以是一个AAuto table数组\n第二个参数指定API数据类型
raw.toarray( __,"struct","array" ) = 创建API函数中的动态数组\n第一个参数可以是一个指定长度的数值，也可以是一个AAuto table数组\n第三个参数指定数组成员的字段名字
raw.closehandle(__) = 关闭句柄资源
!dll.api("__/*输入函数名字*/","void(void)" ) = 声明API函数,参数(函数名,函数原型,调用约定="stdcall")\n注意API函数变量名约定规范:首字母大写
!dll.api("__/*输入函数名字*/","void(void)" ,"cdcel,borland") = 声明API函数,参数(函数名,函数原型,调用约定="stdcall")\n注意API函数变量名约定规范:首字母大写
!dll.gethandle() = 返回模块句柄
?raw.loadDll = !dll.

com = @import com;\n//com库的函数名字一般首字母都是大写，\n//而AAuto函数首字母小写，注意区别
com.CreateEmbed(.(控制对象,窗体对象,progId) = 创建控件对象并嵌入web窗体\n控制对象应当是一个table对象\n创建成功在控制对象中添加成员_host,_object,_form
!embed._form = 容器窗口
!embed._object = 控件对象
!embed._host = 控件容器
!embed._host.close() = 关闭
?com.CreateEmbed = !embed.
com.AddConnection(.(com对象,事件接口) = 事件接口用com.ImplInterface创建
com.CreateEmbed(.(控制对象,窗体对象) = 创建web窗体
com.CreateObject("__") = 创建com.IDispatch对象
com.IsObject(__/*IDispatch对象*/) = 检测参数是否一个动态接口对象.
com.IsIUnknown(__/*IUnknown托管指针*/)  = 检测参数是否一个托管IUnknown指针
com.GetEnumerator(__) = 获取枚举对象。
com.boxpointer(__/*pointer指针*/) = 将pointer类型指针转换为com.IUnknown托管指针对象。
com.topointer(__/*com对象*/) =  转换为com.IUnknown指针(type.pointer类型)\n该指针必须显式调用com.Release释放。
com.GetObject("__") = 从已运行的实例获取com.IDispatch对象
com.each = @for index,obj in com.each(__) {\n\n} //迭代遍历com集合对象
com.GUID() = 创建GUID\n返回值与win.guid兼容\n请查看win.guid库中的类型定义
com.ShowHelp(__/*com对象*/) = 显示帮助
com.Connect(__/*com对象*/, table对象) = 将普通table注册为默认事件接口（IDispatch接口）\n如果需要显式指定接口类型请使用com.AddConnection。
com.ImplInterface(.(impl_table__) = 将table对象转换为IDispatch接口对象
com.ImplInterface(.(impl_table__,ProgID,interface_name ) = 使用一个table表实现dispinterface接口对象\n例如：com.ImplInterface( flash.callevent ,"ShockwaveFlash.ShockwaveFlash","_IShockwaveFlashEvents")
com.ImplInterfaceFromTypelib(.(impl_table,typelib_path,interface_name,coclass_name) = 使用类型库实现com接口
com.NewObject(.(impl_table,ProgID) = 创建com对象
com.NewControl(.(impl_table,ProgID) = 创建com对象 
com.ReleaseConnection(.(com对象, 事件接口, cookie) = 释放事件接口,cookie来自com.AddConnection的返回值\n即使不调用此函数，所有事件接口会自动释放
com.ReleaseConnection(.(com对象) = 释放默认事件接口\n指释放com.Connect挂接的事件\n即使不调用此函数，所有事件接口会自动释放
com.GetIUnknown(__/*com对象或pointer指针*/) = 获取com.IUnknown托管指针对象\n该对象可自动释放。
com.QueryObject(__/*IUnknown指针*/ )  = 查询IDispatch接口、并创建com.IDispatch对象
com.Release(__) = 释放com对象或IUnknown指针\n直接释放pointer类型指针时请严格遵守com引用计数规则 
com.DumpTypeInfo(__/*com对象*/) = 返回com对象类型信息，函数成员列表,例:\nio.print( com.DumpTypeInfo( comobj ) )
com.GetTypeInfo(__/*com对象*/) = 返回类型库

!typeinfo.GetTypeLib() = 返回类型库
!typeinfo.GetFuncDesc(__/*索引*/) = 返回函数描述
!typeinfo.GetVarDesc(__/*索引*/) = 返回值描述
!typeinfo.GetDocumentation() = 返回文档信息
!typeinfo.GetTypeAttr() = 返回类型属性
!typeinfo.GetImplType(__/*索引*/) = 返回实现接口
!typeinfo.GetImplTypeFlags(__/*索引*/) = 实现接口类型
?com.GetTypeInfo= !typeinfo.
!typelib.ShowHelp() = 显示帮助
!typelib.GetTypeInfo(__/*索引*/) = 返回类型信息
!typelib.GetTypeInfoCount() = 类型信息总数
!typelib.ExportConstants() = 导出常量
!typelib.ExportEnumerations() =  导出全部迭代器
!typelib.GetDocumentation() = 
?.GetTypeLib = !typelib.
!typeattr.Funcs = 函数总数
!typeattr.Vars = 属性值总数
!typeattr.typekind = 类型
!typeattr.ImplTypes = 实现接口总数
!typeattr.flags.cancreate = 
!typeattr.flags.dispatchable = 
!typeattr.flags.control = 
!typeattr.flags.appobject = 
!typeattr.flags.hidden = 
!typeattr.flags.oleautomation = 
!typeattr.GUID = GUID 
?.GetTypeAttr = !typeattr.

!file.write(__) = 写数据，支持一个或多个参数
!file.write(__, ) = 写数据，支持一个或多个参数

!file.read() = 从当前位置，向后读取下一行
!file.read("%s") = 从当前位置，向后读取下一行\n支持多参数
!file.read("%d") = 从当前位置，向后读取下一个数值\n支持多参数
!file.read(-1) = 向后读取到文件尾部\n负数表示从文件尾部倒计数位置\n支持多参数
!file.read(0) = 检测是否读取到文件尾
!file.read(__) = 正数参数表示从当前位置向后读取n个字节\n支持多参数

!file.readback() = 从当前位置，向前读取上一行  
!file.readback(-1) = 向前读取到文件头部\n负数表示从文件头部倒计数位置
!file.readback(0) = 检测是否读取到文件头
!file.readback(__) = 正数参数表示从当前位置向前读取n个字节

!file.seek("end") = 移动指针至结束处
!file.seek("end",__) = 移动至相对结束处的指定偏移量
!file.seek() = 得到当前位置
!file.seek("cur",__) = 移动至相对当前位置的指定偏移量
!file.seek("set") = 移动指针到开始
!file.seek("set",__) = 移动至相对开始处的指定偏移量
!file.reopen("__/*文件路径*/","w+") = 重定向文件流
!file.reopen("CON","__") = 重定向控制台文件流
!file.flush() = 输出缓冲区数据
!file.close() = 关闭文件流
!file.setvbuf("no") = 禁用缓冲
!file.setvbuf("full",__) = 完全缓冲
!file.setvbuf("line",) = 行缓冲
?io.open  = !file.
?io.popen  = !file.


io.lines = @for line in io.lines("\__/*请输入文件路径*/") { \n\n} //逐行迭代读取文件
io.popen("","w") = 创建一个进程打开目标程序并绑定目标进程输入流
io.popen("","r") = 创建一个进程打开目标程序并绑定目标进程输出流
io.popen("") = 等价于io.popen("","r")例：\nfile=io.popen("ipconfig /all")
io.open("__","r") =  以只读模式打开文件,文件必须存在\n加b为二进制，加t为文本模式(去除\r回车符)\n参数一可以是文件路径或文件句柄
io.open("__","r+") =  以可读写模式打开,文件必须存在\n加b为二进制，加t为文本模式(去除\r回车符)\n参数一可以是文件路径或文件句柄
io.open("__","w") =  以写模式打开文件,创建新文件清空原文件\n加b为二进制，加t为文本模式(去除\r回车符)\n参数一可以是文件路径或文件句柄
io.open("__","w+") =  读写模式打开,创建新文件清空原文件\n加b为二进制，加t为文本模式(去除\r回车符)\n参数一可以是文件路径或文件句柄
io.open("__","a") =  只写追加模式打开,创建新文件保留原文件\n加b为二进制，加t为文本模式(去除\r回车符)\n参数一可以是文件路径或文件句柄
io.open("__","a+") =  读写追加模式打开,创建新文件保留原文件\n加b为二进制，加t为文本模式(去除\r回车符)\n参数一可以是文件路径或文件句柄
io.open("","r+",_SH__) = 可选使用第三个参数指定共享模式 
io.open("") = 创建临时文件
io.open() = 打开控制台窗口
io.close() = 关闭控制台窗口
io.stderr = 标准错误输出\n!file.
io.stdin =  标准输入\n!file.
io.stdout = 标准输出\n!file.
io._exepath = 主程序文件路径
io._exedir = 主程序所在目录
io.localpath("__") = 如果是\或/开头表示的程序根目录下的相对路径,\n返回绝对路径,否则返回空值
io.fullpath("__") = 将相对路径转换为绝对路径;\n\开始表示AAuto执行程序根目录
io.remove("__") = 删除指定的文件\n成功返回true,失败返回null
io.rename("__","") = 重命名\n成功返回true,失败返回null 
io.tmpname() = 生成临时文件
io.fullpath("__") = 将相对路径转换为绝对路径;\n\开始表示AAuto执行程序根目录
io.remove("__") = 删除指定的文件\n成功返回true,失败返回null
io.rename("__","") = 重命名\n成功返回true,失败返回null 
io.tmpname() = 生成临时文件
io.splitpath(__) = 拆分文件路径为目录、文件名、后缀名、分区号等
io.print(.( __ , ... ) = 在控制台窗口以字符串形式输出变量的值 
io.print(."__") = 在控制台窗口输出信息 
io.exist(__) = 判断文件是否存在
io.exist(__,2) = 判断文件是否可写
io.exist(__,4) = 判断文件是否可读
io.exist(__,6) = 判断文件是否可读写
io.getText(__/*可选指定缓冲区大小*/) = 读取控制台文本


!filepath.dir = 目录
!filepath.file = 文件名（含后缀）
!filepath.name = 文件名
!filepath.ext = 文件后缀名\n包含后缀名前面的圆点，例如".aau"
!filepath.drive = 文件所在分区
?io.splitpath = !filepath.

!font.h = 以逻辑单位指定字体字符元(character cell)或字符的高度
!font.w = 以逻辑单位指定字体字符的平均宽度
!font.esc = 以十分之一度为单位指定每一行文本输出时相对于页面底端的角度
!font.ori = 以十分之一度为单位指定字符基线相对于页面底端的角度
!font.weight = 指定字体重量
!font.italic = 当lfItalic为TRUE时使用斜体
!font.underline = 当lfUnderline为TRUE时给字体添加下划线
!font.strike = 当lfStrikeOut为TRUE时给字体添加删除线
!font.charset = 指定字符集
!font.out = 指定输出精度
!font.clip = 指定剪辑精度
!font.quality = 定义输出质量
!font.family = 指定字体的字符间距和族
!font.name = 字体名称
?LOGFONT = !font.
?::LOGFONT = !font.
LOGFONT() = 创建字体对象 

math.abs(__/*输入数值*/) = 计算绝对值
math.acos(__/*输入数值*/) = 计算反余弦值
math.asin(__/*输入数值*/) = 计算反正弦值
math.atan(__/*输入数值*/) = 计算反正切值
math.atan2(.(x__,y) = x/y的反正切值
math.ceil(__/*输入数值*/) = 上取整为最接近的整数
math.floor(__/*输入数值*/) = 下取整为最接近的整数
math.cos(__/*输入数值*/) = 计算余弦值
math.deg(__/*输入弧度*/)= 弧度转换为角度
math.exp(__/*输入数值*/) = 计算以e为底x次方值
math.cosh(__/*输入数值*/) = 双曲线余弦函数
math.frexp(__/*输入数值*/)  = 把双精度数val分解为数字部分（尾数）和以2为底的指数n，即val=x*2n
math.ldexp(.(value__,n) = 计算value * 2的n次方
math.log10(__/*输入数值*/)= 计算以10为基数的对数
math.log(__/*输入数值*/) = 计算自然对数
math.max(__/*输入数值*/, ) = 返回两个整数中较大的一个
math.min(__/*输入数值*/, ) = 返回两个整数中较小的一个
math.random(.(x__, y) = 生成从x到y范围的随机数 
math.randomize() = 设置随机数发生器的种子
math.randomize(time.tick()) = 设置随机数发生器的种子
math.modf(__/*输入数值*/) =  把数拆分为整数、小数\n返回两个值。
math.pow(.(x__,y) = 返回x的y次幂 
math.rad(__/*输入角度*/) = 角度转换为弧度
math.sinh(__/*输入数值*/) = 正弦值(角度) 
math.sin(__/*输入数值*/) = 计算正弦值
math.sqrt(__/*输入数值*/) = 计算平方根
math.tanh(__/*输入数值*/) = 计算正切值(角度)
math.tan(__/*输入数值*/) = 计算正切值 
math.pi = 圆周与直径的比值常数 
math = 数学计算库 


time.now() = 获取当前时间
time.tick() = 获取系统启动时间(毫秒)
time.istime(__) = 判断对象是否datetime对象
time(.(__,"%Y/%m/%d %H:%M:%S") = 参数可以是时间数值、时间字符串、或其他datetime对象\n第二个参数指定格式化串,首字符为!表示GMT时间\n返回datetime对象
!time = class datetime{\nWORD year; //年\nWORD month; //月\nWORD dayofweek; //星期\nWORD day; //日期\nWORD hour; //小时\nWORD minute; //分钟\nWORD second; //秒\nWORD milliseconds; //这个字段正常情况下为0，只有在WINAPI函数中会起作用\nformat; //时间格式字符串\nisdst //是否夏令时\n}
!time.year= 年
!time.dayofweek = 星期
!time.day = 日
!time.month= 月
!time.hour= 小时
!time.minute= 分钟
!time.second= 秒
!time.milliseconds= 毫秒
!time.format = @.format="%Y年%m月%d日 %H时%M分%S秒";\n//指定格式化串,首字符为!表示GMT时间
!time.addmonth(__/*输入数值*/) = 增加月份数
!time.addday(__/*输入数值*/) = 增加天数
!time.addsecond(__/*输入数值*/) = 增加秒数
!time.addminute(__/*输入数值*/) = 增加分钟数
!time.addhour(__/*输入数值*/) = 增加小时数
!time.diffmonth(__/*指定datetime对象*/) = 计算两个time对象相差月份
!time.diffday(__/*指定datetime对象*/) = 计算两个time对象相差天数
!time.diffsecond(__/*指定datetime对象*/) = 计算两个time对象相差秒数
!time.diffminute(__/*指定datetime对象*/) = 计算两个time对象相差分钟数
!time.diffhour(__/*指定datetime对象*/) = 计算两个time对象相差小时数
?time = !time.
?time.now = !time.
 
thread.call("__/*请输入函数名字*/","owner", ) = 执行线程共享区函数\n线程安全 
thread.getMainId() = 返回当前线程ID
thread.getId() = 返回当前线程ID
thread.getHandle() = 返回当前线程伪句柄\n该句柄仅可在当前线程使用、可复制。
thread.create(__, ) = 创建线程，返回句柄、线程ID\n线程句柄不再使用时，应调用raw.closehandle()函数关闭。\n第一个参数是启动线程的函数,其余参数传递给线程函数。\n注意线程函数必须使用独立的闭包，import等语句应置于函数内部。
thread.stop(__/*退出代码*/) = 终止当前线程。
thread.set("标志键", ) = 写入一个值到进程共享内存区\n标志键可以是数值、字符串等常量、赋值为null则删除该共享键值对\n此函数禁止在任何元方法中使用。
thread.get("标志键") = 从进程共享内存区读取一个值\n此函数禁止在任何元方法中使用\n标志键可以是数值、字符串等常量\n此函数禁止在任何元方法中使用。
thread.lock("临界区名称") =  加锁\n用以避免多个线程同时执行加锁范围内的代码。
thread.unlock("临界区名称") = 解锁
thread.lock() =  加锁\n等效于thread.lock("default")
thread.unlock()  = 解锁\n等效于thread.unlock("default")
thread.create_suspended=true = 设置创建线程时是否暂停执行
thread.terminate(__/*线程句柄*/,0) = 强制终制线程，不推荐使用\n参数二设定返回值，可通过thread.getExitCode获取。
thread.resume(__/*线程句柄*/) = 继续执行
thread.suspend(__/*线程句柄*/) = 暂停执行
thread.getExitCode(__/*线程句柄*/) = 获取线程函数返回代码  

debug = 导入调试库\nimport debug;
debug.getnamespace =  
debug.getfunction =  
debug.getlocalvar =  
debug.setlocalvar =  
debug.getupvar =  
debug.setupvar =   
debug.hook(__/*可选参数：可在此输入协程对象*/)  = 创建调试钩子
!debughook.line = @.line=function(line){\nio.print( "line",line )\n}
!debughook.call = @.call=function(){\nio.print( "call" )\n}
!debughook.return = @.return=function(line){\nio.print( "return" )\n}
!debughook.tailreturn = @.tailreturn=function(line){\nio.print( "tailreturn" )\n}
?debug.hook = !debughook.

debug.queryinfo(2,"select source,function,upvars,name,currentline,activelines") = 查询调用椎栈信息\n参数一可以是函数名、或调用级别\n1表示当前函数,2表示调用当前函数的函数
debug.queryinfo(2,"select source") =  = 查询调用椎栈源码相关信息\n参数一可以是函数名、或调用级别\n1表示当前函数,2表示调用当前函数的函数
!debuginfo.source = 源码相关信息
!debuginfo.source.file = 文件名
!debuginfo.source.code = 源码
!debuginfo.source.src = 源码或文件名缩略信息
!debuginfo.source.beginline = 开始定义行
!debuginfo.source.endline = 结束;定义行
!debuginfo.source.kind = 类型\n"kernel"表示内核函数\n"function"\n表示普通函数\n"main"主函数\n"tail"尾调用
!debuginfo.name =  函数名字
!debuginfo.name_where =  global(全局变量)、\nself(当前名字空间成员变量)、\nvar(局部变量)、\nupvar(上层语句块局部闭包变量)
!debuginfo.activelines =  调用堆栈信息
!debuginfo.function =   
!debuginfo.upvars = 
!debuginfo.currentline =   
?debug.queryinfo = !debuginfo.