aview-app 1.0.2

package/aardio/lib/raw/apiHook.aardio

@@ -0,0 +1,122 @@
+//apiHook 函数钩子
+
+namespace raw {
+	
+	class apiHook {
+		ctor ( dllName, apiName,apiProto,callback ) { 
+			if( type(callback) == type.string ){
+				var tmp = apiProto;
+				apiProto = callback;
+				callback = tmp;
+			};
+			
+			this.apiProto = apiProto;
+			
+			try{
+				this.dll = ..raw.loadDll(dllName)
+				this.hModule = this.dll.gethandle();
+			} 
+			if (!this.hModule) {
+				error("找不到 " + dllName, 2);
+			} 
+			
+			this.pTargetFunction  = GetProcAddress(this.hModule, apiName);
+			if (!this.pTargetFunction ) {
+				this.pTargetFunction  = GetProcAddress(this.hModule, apiName + "A");
+			}
+			if (!this.pTargetFunction ) { 
+				error("找不到指定的函数!", 2);
+			}
+			
+			if( type(callback) == type.function ){
+				this.callback_c = ..raw.tostdcall(callback, apiProto,this);
+				this.addrHookFunction = getPointerAddress(this.callback_c) 
+			}
+			else {
+				this.addrHookFunction = tonumber(callback);
+				if( !this.addrHookFunction )
+					error("参数@4必须指定钩子函数",2);
+			}
+			 
+			..table.gc( this,"unInstall" );
+		}
+		install = function () { 
+			var jmpOpCodeLen = 5;
+			var threadCmpOpCodeLen = 20;
+			this.addrProtect = prcsHook.protect(tonumber(this.pTargetFunction), 0x40/*_PAGE_EXECUTE_READWRITE*/, jmpOpCodeLen * 2);
+			if (!this.addrProtect ) { 
+				error("修改内存属性失败!", 2);
+			}
+			 
+			var restoreOpCode = prcsHook.readString(tonumber(this.pTargetFunction),jmpOpCodeLen * 2);
+			this.restoreOpCodeSize,restoreOpCode = getHookSize(  restoreOpCode,jmpOpCodeLen ); 
+			
+			var addrTargetFunction = tonumber(this.pTargetFunction );
+			this.addrTrampoline = prcsHook.malloc( this.restoreOpCodeSize + jmpOpCodeLen,0x40/*_PAGE_EXECUTE_READWRITE*/) 
+			this.addrThreadCheck = prcsHook.malloc( threadCmpOpCodeLen + jmpOpCodeLen,0x40/*_PAGE_EXECUTE_READWRITE*/) 
+			
+			prcsHook.write( this.addrThreadCheck,
+				'\x50', //push eax
+				'\xB8', { addr getTid = getPointerAddress(GetCurrentThreadId) }, //mov eax,getTid
+				'\xFF\xD0', //call eax
+				'\x3D', {INT tid = ..thread.getId() }, //cmp eax,tid
+		 		'\x58', //pop eax
+				'\x0F\x84',{ 
+					addr hookFunc = this.addrHookFunction  - (this.addrThreadCheck + threadCmpOpCodeLen) 
+				}, //je hookFunc
+				'\xE9', {
+					addr orgFunc = this.addrTrampoline - (this.addrThreadCheck + threadCmpOpCodeLen + jmpOpCodeLen)
+				} //jmp orgFunc
+			) 
+			 
+			prcsHook.write( this.addrTrampoline,restoreOpCode, '\xE9'/*JMP*/, {
+				int jmpAddr = addrTargetFunction + this.restoreOpCodeSize - (this.addrTrampoline + this.restoreOpCodeSize + jmpOpCodeLen )
+			} )
+			
+			prcsHook.write( addrTargetFunction, '\xE9'/*JMP*/, {
+				int jmpAddr = this.addrThreadCheck - (addrTargetFunction + jmpOpCodeLen)
+			} )
+			 
+			this.callApi = ..raw.main.api(topointer(this.addrTrampoline), this.apiProto );
+			return this; 
+		}
+		unInstall = function () {  
+			if (! ( this.pTargetFunction && this.addrProtect ) ) {
+				return;
+			}
+			
+			prcsHook.writeString(tonumber(this.pTargetFunction),topointer(this.addrTrampoline) ,this.restoreOpCodeSize );
+			prcsHook.protect(tonumber(this.pTargetFunction),this.addrProtect, this.restoreOpCodeSize);
+			this.pTargetFunction = null; 
+			
+			prcsHook.mfree( this.addrTrampoline ); 
+			prcsHook.mfree(this.addrThreadCheck);
+		}
+	}	
+}
+
+namespace raw.apiHook {
+	import ..process;
+	import ..raw.asm.opCode;
+	getHookSize = ..raw.asm.opCode.getHookSize;
+	
+	prcsHook = ..process(); 
+	
+	GetProcAddress = ::Kernel32.api("GetProcAddress","pointer(pointer hModule,string lpProcName)");
+	GetCurrentThreadId = ::Kernel32.api( "GetCurrentThreadId", "INT()")
+	
+	getPointerAddress = function(p){
+		return ..raw.convert( { pointer arg = p }, { addr ret } ).ret;
+	} 
+}
+
+/**intellisense()
+raw.apiHook = 安装到当前线程的API函数钩子，不是来自当然线程的调用忽略。\n多线程钩子请使用 thread.apiHook
+raw.apiHook(DLL文件名,API函数名,函数原型,钩子函数) = @.apiHook(\n	"user32.dll",\n	"GetCursorPos",\n	"bool(pointer lpPoint )", \n	function( lpPoint ){\n		owner.callApi(lpPoint); \n		\n		raw.mixin( lpPoint,{\n				int x = 123; \n				int y = 456 \n		} );\n			\n		__/*可选通过 owner.callApi 调用原始函数,\n结构体等回调时必须传为指针参数,\n可通过 raw.mixin 修改修结构而不改变指针地址*/\n		return true;\n	}\n).install();
+raw.apiHook() = !raw_apihook.
+!raw_apihook.install() = 安装钩子\n!raw_apihook.
+!raw_apihook.unInstall() = 卸载钩子 
+getPointerAddress(.(指针) = 返回数值类型指针地址
+end intellisense**/
+
+//http://bbs.aardio.com/forum.php?mod=viewthread&tid=970

package/aardio/lib/raw/argsPointer/.res/argsPointer.def

@@ -0,0 +1,4 @@
+LIBRARY argsPointer.dll
+
+EXPORTS
+getArgsPointer

package/aardio/lib/raw/argsPointer/.res/build.aardio

@@ -0,0 +1,15 @@
+
+var codeUtf8 = /** 
+	#include <stdlib.h>  
+	__declspec(dllexport) void getArgsPointer(void *(__cdecl *callback) (int id,void ** ppStruct),int id,void * pStruct)
+    {
+    	void ** pp = (void **)&pStruct; 
+    	callback(id,pp); 
+    }
+**/
+ 
+import tcc; 
+vm = tcc();//创建TCC编译器 
+
+vm.output( "/argsPointer.dll", codeUtf8 ) //编译C源码,生成DLL
+vm.close(); //收工

package/aardio/lib/raw/argsPointer/_.aardio

@@ -0,0 +1,144 @@
+import util.registry;
+
+namespace raw;
+
+class argsPointer{
+	ctor( ... ){
+		var args = {...}
+		if(type(args[#args])=="function") {
+			var callback = ..table.pop(args)
+			if( (#args == 1) && (type(args[1])=="table") && #args[1] ) args = args[1]; 
+			
+			_dll.getArgsPointer(_callback
+				,_registry.reg({args,callback})
+				,..table.unpackArgs(args)
+				);
+			
+			return args;	 
+		}
+		else {
+			if( (#args == 1) && (type(args[1])=="table") && #args[1] ) args = args[1]; 
+			if(args@) error("参数数组不应指定元表",2);
+			
+			var structType = args[1][["_struct"]];
+			if(!structType){ error("参数必须指定结构体或结构体数组",2) } 
+			var sizeItem = ..raw.sizeof(args[1]);
+			
+			var structPtr = {}
+			for(i=1;#args;1){
+				if(args[i][["_struct"]]!=structType) error("数组中的结构体类型必须相同",2)
+				structPtr[i] = ..raw.realloc(sizeItem,,args[i])
+			}
+			
+			var structPtrArrayPtr = ..raw.realloc(sizeItem*#args,,{ptr items[]=structPtr}) 
+			
+			this = args;
+			this@ = {
+				_topointer = structPtrArrayPtr;
+				_get = {
+					freePtr = function(){
+						if(!structPtrArrayPtr) return this;
+						this.updateArray();
+						
+						for(i=1;#structPtr;1) structPtr[i] = ..raw.realloc(0,structPtr[i]);
+						structPtrArrayPtr = ..raw.realloc(0,structPtrArrayPtr);
+						return this;
+					};
+					updateArray = function(){
+						if(!structPtrArrayPtr) return this;
+						var c = ..raw.convert;
+						for(i=1;#structPtr;1)c(structPtr[i],args[i]);
+						return this;
+					};
+					updatePtr = function(){
+						if(!structPtrArrayPtr) return;
+						if(#args!=#structPtr) error("不允许改变数组长度",2);
+						
+						var c = ..raw.convert;
+						for(i=1;#args;1){
+							if(args[i][["_struct"]]!=structType) error("数组中的结构体类型必须相同",2);
+							c(args[i],structPtr[i]);
+						}
+						
+						return this;
+					};	
+				};
+				gcdata = ..gcdata(   
+					_gc = function(){ this.freePtr();} 
+				)
+			} 
+		}
+	};
+}
+
+namespace argsPointer{
+	_dll = ..raw.loadDll($"~\lib\raw\argsPointer\.res\argsPointer.dll","std.raw.argsPointer.dll","cdecl");
+	
+	_registry = ..util.registry();
+	_callback = ..raw.tocdecl( function(id,pArgs){
+		var d = _registry.unReg(id);
+		d[2](pArgs,d[1]); 
+	},"void(int id,ptr pArgs)")
+	
+	convert = function(ptr,len,template){
+		var t = type(template);
+		if(t=="class") template = template();
+		elseif(t=="string") return ..raw.convertArray(ptr,len,template);
+		if(!template[["_struct"]]) error("参数@3必须指定结构体或结构体类",2);
+		
+		var items = ..raw.convertArray(ptr,len);
+		var c = ..raw.convert;
+		for(k,v in items){
+			if(v) items[k] = c(v,{_struct=template._struct});
+		}
+		
+		return items;
+	}
+}
+
+/**intellisense()
+raw.argsPointer = 用于将 API 调用过程中的参数转为数组指针\n用法请参考：aardio 范例 -> aardio 语言 -> 语言扩展 -> 结构体二级指针\n\n注意普通结构体可以任意嵌套数组,与静态API函数兼容且用法更简洁,\n如无特殊原因,一般不必要用到 raw.argsPointer
+raw.argsPointer( = 用于将 API 调用过程中的参数转为数组指针,\n\n结构体在 API 调用参数中传址而非值,\n因此调用参数为结构体则转为结构体的二级指针。\n如果结构体用于表示静态类型数组,\n则转为二维数组指针
+raw.argsPointer(.(args->->->,callback) =  @args 可以是一个或多个用于调用 API 的参数,\n也可以是包含一个或多个调用参数的数组。\n此函数会使用 @args 参数调用一个中间 API 函数,\n并在该 API 中得到调用参数列表的指针地址,\n并将该指针作为第一个回调参数以回调 @callback 指定的函数,\n指针参数之后的第2个回调参数为实际调用参数的数组,\n注意在调用此函数结束后将释放参数指针,并返回新的参数值
+raw.argsPointer(.(structArgs,->->->) = @structArgs 可以是一个或多个用于调用 API 的结构体参数,\n也可以是包含一或多个结构体参数的数组,该数组不可指定元表。\n数组中的结构体必须为同一结构体类型,\n\n此函数返回传入参数的数组,\n返回数组已绑定内存指针,可作为 API 函数的指针参数使用,\n可使用 freePtr 函数释放绑定的内存指针,\n注意不要在 aardio 改变数组的长度或成员的结构体类型,\n有这些需求应当创建新的 raw.argsPointer 对象
+raw.argsPointer.convert( = 用于将参数列表指针转换回调用数组,\n此函数与 raw.convertArray 的主要区别是对结构体参数的处理,\n对于结构体数组会首先转换为指针数组,再将指针转换为结构体
+raw.argsPointer.convert(.(指针,数组长度,结构体) = 用于将参数列表指针转换回调用数组,\n参数@3可以指定结构体或结构体类,\n实际转换时参数@3仅是模板作用不会被修改,\n返回结构体数组
+raw.argsPointer() = !rawArgsPointerArgs.
+!rawArgsPointerArgs.updateArray() = 此函数返回对象自身,\n在返回之前自对象绑定的原始指针获取最新的数组值,\n创建 raw.argsPointer 对象时如未指定回调函数则此函数可用
+!rawArgsPointerArgs.updatePtr() = 此函数返回对象自身,可用于 API 函数的指针参数,\n在返回之前写入最新的数组值到指针绑定的内存,\n创建 raw.argsPointer 对象时如未指定回调函数则此函数可用
+!rawArgsPointerArgs.freePtr() = 释放对象绑定的内存指针,\n在返回之前自对象绑定的内存指针获取最新的数组值,\n创建 raw.argsPointer 对象时如未指定回调函数则此函数可用\n\n调用此函数释放以后对象仍然可以使用,但不能再作为 API 参数使用,\n即使没有主动调用此函数,在对象不再使用时仍然会被垃圾收集器自动释放
+end intellisense**/
+
+/**details(实现原理)
+aardio 中的对象比原生静态语言使用的原始数据要复杂得多，
+例如 aardio 结构体与静态语言的原始结构体在内存中的结构实际是不一样的。
+
+aardio 对象之所以能作为参数用于调用静态语言实现的 API 函数，
+是因为 aardio 在其中作了隐式的转换，打破了动/静态语言之间原本不可逾越的鸿沟。
+这很方便，但这种无感的自动转换也会让我们产生错觉,让我们忘记了 aardio 并不是 C/C++，
+也忘记了不可逾越的鸿沟仍然实际存在。
+
+这种鸿沟的存在有其必要性 —— 正如火车不能允许任意乘客在任意时间下地用双脚原生地奔跑。
+对于动态语言 —— 不能百分百完美地套用静态语言的写法和习惯，aardio 支持静态类型的目的
+也只是为了调用和利用静态语言的能力而并不是让自己变成静态语言。
+
+以结构体为例：
+
+1、aardio 结构体作为调用 API 的参数时会分配一块临时的内存,
+并将 aardio 结构体的值复制过去，然后将该内存的指针作为调用 API 的参数,
+在调用 API 结束后再将内存中新的值同步到 aardio 结构体，然后立即释放临时内存，
+释放临时内存是立即操作，而非等待垃圾回收器操作。
+
+raw.argsPointer 的回调用法就是基于这个原理,
+利用了一个中间 API 函数在被调用时回调 aardio 函数以拦截到原始参数指针。
+
+2、当以 aardio 结构体对象作为参数调用 raw.buffer,raw.realloc 等分配内存的函数时，
+也会将结构体的值复制过去，这时候 raw.buffer,raw.realloc 得到的原始指针里存储的就是
+原始结构体，所以这些指针可以直接用于 API 的原始数据类型指针 —— 而不再需要转换。
+使用 raw.convert() 函数 可以将指针指向的内存再次同步到 aardio 结构体。
+
+raw.argsPointer 的非回调用法就是基于这个原理，但简化了分配内存、同步数据的操作。
+
+注意普通结构体可以任意嵌套数组,与静态API函数兼容且用法更简洁,
+如无特殊原因,一般不必要用到 raw.argsPointer 。
+end details**/

package/aardio/lib/raw/asm/opCode.aardio

@@ -0,0 +1,101 @@
+namespace raw.asm.opCode;
+
+var tab_1 = { 
+2048;2048;2048;2048;4096;4096;0;0;2048;2048;2048;2048;4096;4096;0;16384;2048;2048;2048;2048;4096;4096;0;0;2048;2048;2048;2048;4096;
+4096;0;0;2048;2048;2048;2048;4096;4096;1;0;2048;2048;2048;2048;4096;4096;1;0;2048;2048;2048;2048;4096;4096;1;0;2048;2048;2048;2048;4096;
+4096;1;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;2048;2048;1;1;3;5;8;2056;16;2064;0;0;0;0;16;16;16;16;16;16;16;
+16;16;16;16;16;16;16;16;16;2064;2056;2064;2064;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;0;0;0;0;0;0;0;0;0;0;520;0;0;0;0;0;128;
+128;128;128;0;0;0;0;16;8;0;0;0;0;0;0;16;16;16;16;16;16;16;16;8;8;8;8;8;8;8;8;2064;2064;32;0;2048;2048;2056;2056;48;0;32;0;0;80;0;0;2048;2048;2048;2048;
+0;0;0;0;2048;2048;2048;2048;2048;2048;2048;2048;16;16;16;16;16;16;16;16;8;8;520;16;0;0;0;0;1;0;1;1;0;0;8192;8192;0;0;0;0;0;0;2048;2048 }
+
+var tab_0F = { 2048;2048;2048;2048;-1;-1;0;-1;0;0;0;0;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;
+-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;
+-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;8;8;8;8;8;8;8;8;8;8;8;8;8;8;8;8;
+2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;2048;0;0;0;2048;2064;2048;-1;-1;0;0;0;2048;2064;2048;-1;2048;2048;
+2048;2048;2048;2048;2048;2048;2048;-1;-1;2064;2048;2048;2048;2048;2048;2048;2048;-1;-1;-1;-1;-1;-1;0;0;0;0;0;0;0;0;-1;-1;-1;-1;-1;-1;-1;-1;-1;
+-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1;-1 }
+
+getHookSize = function(opCode,gt){
+	var nSize = 0;  
+    do{  
+        var nDisassemblerLen = getSize(opCode,nSize+1);
+        nSize = nDisassemblerLen + nSize; 
+    }  while(nSize < gt )
+    return nSize,..string.left(opCode,nSize);
+}
+
+getSize = function( opCode ,idxBegin = 1 ) {  
+    var f = 0; 
+    var mod=0; 
+    var rm=0; 
+    var b;
+
+	var idx = idxBegin;
+	do{ 
+    	b = opCode[idx];idx++; 
+    	f |= tab_1[b+1];
+	
+    	if (f&0x2000) 
+        	if (((opCode[idx])&0x38)==0) // ttt 
+            	f=0x800+0x1000;// TEST 
+        	else 
+            	f=0x800;// NOT,NEG,MUL,IMUL,DIV,IDIV
+	
+    	if (f&0x4000) { 
+        	b = opCode[idx];idx++;
+        	f = tab_0F[b+1]; 
+    	}
+	
+    	if (f==0xFFFFFFFF/*C_ERROR*/) {  
+        	return 0xFFFFFFFF/*C_ERROR*/; 
+    	}
+	
+    	if (f&1/*C_PREFIX*/)  { 
+        	f&=~1/*C_PREFIX*/; 
+       	continue;
+    	}
+	
+    	if (f&0x1000) if (b&0x1) f|=8; else f|=0x10;
+	
+    	if (f&0x800) { 
+        	b = opCode[idx];idx++;
+        	mod = b & 0xC0; 
+        	rm  = b & 0x7; 
+        	if (mod!=0xC0)  { 
+            	if (f&4) {
+                	if ((mod==0)&&(rm==0x6)) f|=0x100; 
+                	if (mod==0x40) f|=0x100; 
+                	if (mod==0x80) f|=0x100; 
+            	} 
+            	else   {
+                	if (mod==0x40) f|=0x100; 
+                	if (mod==0x80) f|=0x400; 
+                	if (rm==0x4) {
+                		rm = ( opCode[idx] ) & 0x7;
+                		idx++;
+                	}
+                	if ((rm==0x5)&&(mod==0)) f|=0x400; 
+            	} 
+        	} 
+    	}
+	
+    	if (f&0x80)  if (f&4) f|=0x100;  else f|=0x400; 
+    	if (f&8) if (f&2) f|=0x20; else f|=0x40;
+	
+    	if (f&0x100)  idx++; 
+    	if (f&0x100)  idx+=2; 
+    	if (f&0x400)  idx+=4;
+	
+    	if (f&0x10) idx++; 
+    	if (f&0x20) idx+=2; 
+    	if (f&0x40) idx+=4;
+	
+    	return idx - idxBegin;
+	} while(true) 
+
+}
+
+/**intellisense(raw.asm.opCode)
+getSize(.(指令串) = 返回指令长度,截取指令串
+end intellisense**/
+

package/aardio/lib/raw/cdeclParameter.aardio

@@ -0,0 +1,121 @@
+//cdeclParameter 结构化参数
+namespace raw;
+
+class cdeclParameter{
+	ctor(tableParameter){
+		this.tableParameter = tableParameter : {};  
+		this._cdcel_functions_cache = {}; 
+	};
+	pointer _getType = $( _getType,"string(string name)",this );
+	pointer _getFunction = $( _getFunction,"pointer(string funcName,string proto)",this );
+	pointer _setFunction = $( _setFunction,"pointer(string funcName,string proto,pointer addr)",this );	
+	pointer _getBinary = $( _getBinary,"pointer(string name,int &size)",this );	
+	pointer _setBinary = $( _setBinary,"void(string name,pointer value,int size)",this);
+	pointer _getString = $( _get,"string(string name)",this );	
+	pointer _setString = $( _set,"void(string name,string value)",this);
+ 	pointer _getNumber = $( _getNumber,"int(string name,double &value)" ,this);	
+	pointer _setNumber = $( _set,"void(string name,double value)",this);
+	pointer _getSize64 = $( _get,"LONG(string name)" ,this);	
+	pointer _setSize64 = $( _setSize64,"void(string name,INT a,INT b)",this); 
+	pointer _getPointer = $( _get,"pointer(string name)",this );	
+	pointer _setPointer = $( _set,"void(string name,pointer value)",this);
+	pointer _callString = $( _call,"int(string name,string arg)",this);
+	pointer _callNumber = $( _call,"int(string name,double arg)",this);
+	pointer _call = $( _call,"int(string name)",this);  
+	pointer _len = $( _len,"INT(string name)",this);
+	set = function(tableParameter){
+		this.tableParameter = tableParameter : {}; 
+	};
+	get = function(){
+		return this.tableParameter;
+	};
+}
+
+namespace cdeclParameter{
+	$ = ..raw.tocdecl;
+	
+	_getType = function(name){
+		var t = ..table.getByNamespace(name,owner.tableParameter);
+		if(  null !== t ){
+			return type(t);
+		}
+	};
+	_len = function(name,...){
+		return # ..table.getByNamespace(name,owner.tableParameter); 
+	};
+	_call = function(name,...){
+		var func,tab = ..table.getByNamespace(name,owner.tableParameter);
+		if(func){
+			return invoke( func,tab,...);
+		};
+	};
+	 
+	_getFunction  = function(funcName,proto){
+		var obj,parent = ..table.getByNamespace(funcName,owner.tableParameter)
+		if(type(obj)==type.function){  
+			if(!owner._cdcel_functions_cache[funcName])
+				owner._cdcel_functions_cache[funcName] = {};
+			if( ! owner._cdcel_functions_cache[funcName][proto] )
+				owner._cdcel_functions_cache[funcName][proto] = $( obj,proto,parent);  
+				 
+			return owner._cdcel_functions_cache[funcName][proto];
+		}
+	};
+	_setFunction  = function(funcName,proto,addr){ 
+		..table.setByNamespace(funcName,..raw.main.api(addr,proto,"cdecl" ),owner.tableParameter) 
+	};
+	_setSize64 = function(name,a,b){ 
+		..table.setByNamespace(name,..math.size64(a,b),owner.tableParameter) 
+	};
+	_getNumber = function(name){
+		return 0,..table.getByNamespace(name,owner.tableParameter);
+	};
+	_getBinary = function(name,size){ 
+		var s = ..table.getByNamespace(name,owner.tableParameter);
+		if( type(s) == type.string ){
+			return s,#s;
+		}
+	};	
+	_setBinary = function(name,value,size){ 
+		..table.setByNamespace(name,..raw.tostring(value,1,size),owner.tableParameter); 
+	}
+	_get = function(name){
+		return ..table.getByNamespace(name,owner.tableParameter);
+	};
+	_set = function(name,value){
+		..table.setByNamespace(name,value,owner.tableParameter); 
+	};
+}
+
+/**intellisense()
+raw.cdeclParameter = 结构化参数,仅适用于创建C/C++函数参数
+raw.cdeclParameter(绑定参数表) = 用于将aardio中的普通表对象转换为\n调用C/C++函数时可以用到的结构化参数.\n在API参数类型中相应参数应声明为struct类型
+raw.cdeclParameter() = !raw_cdeclParameter. 
+!raw_cdeclParameter.get() = 获取绑定的参数表.\nC函数所有读写字段的操作将作用到绑定参数表
+!raw_cdeclParameter.set() = 设置绑定的参数表.\n参数如果为空则创建空表作为参数表\nC函数所有读写字段的操作将作用到绑定参数表
+end intellisense**/
+
+/* 
+
+//在C语言中定义 raw.cdeclParameter 
+typedef struct{ 
+	const char *(__cdecl *getType) (const char * name);
+	void * (__cdecl *getFunction) (const char * name,const char *proto);
+	void (__cdecl *setFunction) (const char * name,const char *proto,void * addr); 
+	const char *(__cdecl *getBinary) (const char * name,unsigned int *size);
+	void (__cdecl *setBinary) (const char * name,char * value,unsigned int size);
+	const char *(__cdecl *getString) (const char * name);
+	void (__cdecl *setString) (const char * name,const char * value);
+	void (__cdecl *getNumber) (const char * name,double * value);
+	void (__cdecl *setNumber) (const char * name,double value);
+	unsigned long long (__cdecl *getSize64) (const char * name);
+	void (__cdecl *setSize64) (const char * name,unsigned long long value);
+	void * (__cdecl *getPointer) (const char * name);
+	void (__cdecl *setPointer) (const char * name,void * value);
+	int (__cdecl *callString) (const char * name,const char * arg);
+	int (__cdecl *callNumber) (const char * name,double arg);
+	int (__cdecl *call) (const char * name);
+	unsigned int(__cdecl *len)(const char * name);
+} aau_cdeclParameter;
+
+*/

package/aardio/lib/raw/fasm/.res/LICENSE.TXT

@@ -0,0 +1,37 @@
+
+flat assembler  version 1.71
+Copyright (c) 1999-2013, Tomasz Grysztar.
+All rights reserved.
+
+This program is free for commercial and non-commercial use as long as
+the following conditions are adhered to.
+
+Copyright remains Tomasz Grysztar, and as such any Copyright notices
+in the code are not to be removed.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The licence and distribution terms for any publically available
+version or derivative of this code cannot be changed. i.e. this code
+cannot simply be copied and put under another distribution licence
+(including the GNU Public Licence).