aview-app 1.0.2

package/aardio/lib/tcc/.dll/RELICENSING

@@ -0,0 +1,60 @@
+
+ Relicensing TinyCC
+ ------------------
+
+ The authors listed below hereby confirm their agreement to relicense TinyCC
+ including their past contributions under the following terms:
+
+
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+
+
+ Author (name)              I agree (YES/NO)    Files/Features (optional)
+ ------------------------------------------------------------------------------
+ Adam Sampson               YES                 makefiles
+ Daniel Glöckner            NO                  arm-gen.c
+ Daniel Glöckner            YES                 not arm-gen.c
+ Edmund Grimley Evans       YES                 arm64
+ Fabrice Bellard            YES                 original author
+ Frédéric Féret             YES                 x86 64/16 bit asm
+ grischka                   YES                 tccpe.c
+ Henry Kroll                YES
+ Joe Soroka                 YES
+ Kirill Smelkov             YES
+ mingodad                   YES
+ Pip Cet                    YES
+ Shinichiro Hamaji          YES                 x86_64-gen.c
+ Vincent Lefèvre            YES
+ Thomas Preud'homme         YES                 arm-gen.c
+ Timo VJ Lähde (Timppa)     ?                   tiny_libmaker.c
+ TK                         ?                   tcccoff.c c67-gen.c
+ Urs Janssen                YES
+ waddlesplash               YES
+ Christian Jullien          YES                 Windows Cygwin build and tests
+
+
+ ------------------------------------------------------------------------------
+
+ Please add yourself to the list above (rsp. replace the question mark)
+ and (after fetching the latest version) commit to the "mob" branch with
+ commit message:
+
+     Relicensing TinyCC
+
+ Thanks.

package/aardio/lib/tcc/.dll/libtcc.h

@@ -0,0 +1,100 @@
+#ifndef LIBTCC_H
+#define LIBTCC_H
+
+#ifndef LIBTCCAPI
+# define LIBTCCAPI
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct TCCState;
+
+typedef struct TCCState TCCState;
+
+/* create a new TCC compilation context */
+LIBTCCAPI TCCState *tcc_new(void);
+
+/* free a TCC compilation context */
+LIBTCCAPI void tcc_delete(TCCState *s);
+
+/* set CONFIG_TCCDIR at runtime */
+LIBTCCAPI void tcc_set_lib_path(TCCState *s, const char *path);
+
+/* set error/warning display callback */
+LIBTCCAPI void tcc_set_error_func(TCCState *s, void *error_opaque,
+    void (*error_func)(void *opaque, const char *msg));
+
+/* set options as from command line (multiple supported) */
+LIBTCCAPI void tcc_set_options(TCCState *s, const char *str);
+
+/*****************************/
+/* preprocessor */
+
+/* add include path */
+LIBTCCAPI int tcc_add_include_path(TCCState *s, const char *pathname);
+
+/* add in system include path */
+LIBTCCAPI int tcc_add_sysinclude_path(TCCState *s, const char *pathname);
+
+/* define preprocessor symbol 'sym'. Can put optional value */
+LIBTCCAPI void tcc_define_symbol(TCCState *s, const char *sym, const char *value);
+
+/* undefine preprocess symbol 'sym' */
+LIBTCCAPI void tcc_undefine_symbol(TCCState *s, const char *sym);
+
+/*****************************/
+/* compiling */
+
+/* add a file (C file, dll, object, library, ld script). Return -1 if error. */
+LIBTCCAPI int tcc_add_file(TCCState *s, const char *filename);
+
+/* compile a string containing a C source. Return -1 if error. */
+LIBTCCAPI int tcc_compile_string(TCCState *s, const char *buf);
+
+/*****************************/
+/* linking commands */
+
+/* set output type. MUST BE CALLED before any compilation */
+LIBTCCAPI int tcc_set_output_type(TCCState *s, int output_type);
+#define TCC_OUTPUT_MEMORY   1 /* output will be run in memory (default) */
+#define TCC_OUTPUT_EXE      2 /* executable file */
+#define TCC_OUTPUT_DLL      3 /* dynamic library */
+#define TCC_OUTPUT_OBJ      4 /* object file */
+#define TCC_OUTPUT_PREPROCESS 5 /* only preprocess (used internally) */
+
+/* equivalent to -Lpath option */
+LIBTCCAPI int tcc_add_library_path(TCCState *s, const char *pathname);
+
+/* the library name is the same as the argument of the '-l' option */
+LIBTCCAPI int tcc_add_library(TCCState *s, const char *libraryname);
+
+/* add a symbol to the compiled program */
+LIBTCCAPI int tcc_add_symbol(TCCState *s, const char *name, const void *val);
+
+/* output an executable, library or object file. DO NOT call
+   tcc_relocate() before. */
+LIBTCCAPI int tcc_output_file(TCCState *s, const char *filename);
+
+/* link and run main() function and return its value. DO NOT call
+   tcc_relocate() before. */
+LIBTCCAPI int tcc_run(TCCState *s, int argc, char **argv);
+
+/* do all relocations (needed before using tcc_get_symbol()) */
+LIBTCCAPI int tcc_relocate(TCCState *s1, void *ptr);
+/* possible values for 'ptr':
+   - TCC_RELOCATE_AUTO : Allocate and manage memory internally
+   - NULL              : return required memory size for the step below
+   - memory address    : copy code to memory passed by the caller
+   returns -1 if error. */
+#define TCC_RELOCATE_AUTO (void*)1
+
+/* return symbol value or NULL if not found */
+LIBTCCAPI void *tcc_get_symbol(TCCState *s, const char *name);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/aardio/lib/tcc/_.aardio

@@ -0,0 +1,311 @@
+class tcc{
+	ctor(){ 
+		var state = _libtcc.tcc_newP();  
+		set_lib_path(state,fromto(_rootdir));  
+		set_output_type(state, 1/*_TCC_OUTPUT_MEMORY*/);  
+		add_library(state,"user32");
+		add_library(state,"kernel32");
+		add_library(state,"gdi32");
+
+		var errproc = function(opaque,msg){
+			msg = ..string.fromto(msg,0,65001);
+			this.err_msg = msg;
+			
+			if(this[["onError"]])
+				this.onError(msg);
+			else{
+				if( ..win && ..win.msgboxErr ) ..win.msgboxErr( msg,"tcc" )
+				elseif( ..console ) ..console.log( msg );
+				elseif(_STUDIO_INVOKED){
+					global.import("win");
+					..win.msgboxErr( msg,"TCC 编译器提示( 按 Ctrl + C 复制 )" );
+				}
+				else ..io.stderr.write(msg,'\n');
+			}
+		} 
+		this._errproc_c = ..raw.tocdecl(errproc,"int(pointer opaque,string msg )"); 
+		set_error_func(state,null,this._errproc_c)
+		
+		this.data = {};
+		this.pfun = {};
+		..table.gc(this,"close");
+	};
+	close  = function(){
+		if(state){
+			_libtcc.tcc_delete(state)
+			state = null;
+		}
+	};
+	addLibPath = function(path){
+		return add_library_path(state, fromto( ..io.fullpath(path) ) )!=-1;
+	};
+	addIncludePath = function(path){
+		return add_include_path(state, fromto( ..io.fullpath(path) ) )!=-1;
+	};
+	addSysIncludePath = function(path){
+		return add_sysinclude_path(state, fromto( ..io.fullpath(path) ) )!=-1;
+	};
+	setOptions = function(s,...){
+		set_options(state,fromto(s));
+		if(!...) return;
+		return this.setOptions(...);
+	}
+	define = function(name,value){
+		if(value)
+			define_symbol(state,fromto(name),fromto(value));
+		else
+			undefine_symbol(state,fromto(name));
+			
+		return this;
+	};
+	compile = function(code){
+		if (compile_string(state,code) != 0){
+			if( this[["onError"]] ) return false; 
+			error('compile error:'+ ( this.err_msg : "") , 2 ) 
+		}
+		return true;
+	};
+	compileEx = function(code){
+		return this.compile(code);
+	};
+	addFile = function(...){  
+		for(i,path in {...} )  {
+			if( add_file(state,fromto( ..io.fullpath(path) ) ) == -1){
+				error('Failed to add file:\n' + path,2); 
+			}
+		}
+		
+		return this;
+	};
+	addLib = function(...){ 
+		var args = type(...)=="table" ? ... : {...};
+		for(i,path in args ) { 
+			if( add_library(state,fromto(path) ) == -1){
+				error('Failed to add library:\n' + path,2); 
+			}
+		}
+		
+		return this;
+	};
+	loadDll = function(...){
+		return addLib(...)
+	};
+	setCdecl = function(func,name,proto){ 
+		var pfun = func;
+		if(type(func)==type.function){
+			pfun = ..raw.tocdecl(func,proto); 
+			this.pfun[name] = pfun 
+		}
+		add_symbol(state,fromto(name),pfun );
+	};
+	relocate = function(){
+		var size = relocate(state);
+		if (size == -1) return 1;
+		
+		var data = ..raw.malloc(size);
+		relocate(state, data);
+		..table.push(this.data,data);
+	};
+	getSymbol = function( name ){
+		if( ! (#this[["data"]]) ) 
+			this.relocate(); 
+			
+		return get_symbol( state,fromto(name) )
+	};
+	setSymbol = function(name,value){
+		add_symbol(state, fromto(name),fromto(value));
+	};
+	getCdecl = function(name,proto){
+		if( ! (#this[["data"]]) ) 
+			this.relocate(); 
+			
+		var func = get_symbol(state, fromto(name));
+		if (!func) return;
+		if(!proto)return _cdecl[func];
+		return _cdecl.api(func,proto,"cdecl"); 
+	};
+	run = function(...){ 
+		if( #(this[["data"]]) ){ 
+			error("调用 relocate() 函数以后不能再调用 run()函数",2);
+		}
+			
+		var argv = { ..io._exepath ;  ...};
+		for(k,v in ..table.eachArgs(argv) ){
+			argv[k] = v;
+		}
+		
+		return run( state,#argv,{pointer argv[]=argv } );
+	};
+	output = function(path,code){ 
+		var ext = ..string.right(path,4);
+		ext = ..string.lower(ext);
+		if( ..string.endWith(ext,".o") || ext == ".obj" ){
+			set_output_type(state, 4/*_TCC_OUTPUT_OBJ*/ ); 
+		}
+		elseif( ext == ".exe"  ){
+			set_output_type(state, 2/*_TCC_OUTPUT_EXE*/);  
+		}
+		elseif( ext == ".dll" ){
+			set_output_type(state, 0x3/*_TCC_OUTPUT_DLL*/); 
+		}     
+		
+		if( #(this[["data"]]) ){ 
+			error("调用 relocate() 函数以后不能再调用 output（）函数",2);
+		}
+			
+		if( code && ( !this.compile( code ) ) ){
+			return;
+		}
+		output_file(state,fromto(..io.fullpath(path)) );
+		set_output_type(state, 0x1/*_TCC_OUTPUT_MEMORY*/); 
+	};
+	enableIoPrintf = function(bufferSize){
+
+		if(!this[["_io_print"]]){
+		 
+			this._io_print = ..raw.tocdecl(function(str){
+				var hwnd = ::Kernel32.GetConsoleWindow(); 
+				if( ( !hwnd ) || ( !::User32.IsWindowVisible(hwnd) ) ) ..io.open(); 
+				..io.print(str);
+			},"void(string str)") 
+			add_symbol(state, "_aardio_print",this._io_print  );		
+			
+			define_symbol(state,"io_printf(...)",'
+			{
+				char buffer[' +(bufferSize:512) + '];
+				int sprintf(char *_Dest,const char *_Format,...);
+				sprintf(buffer,__VA_ARGS__);
+				
+				void _aardio_print(const char * u8);
+				_aardio_print(buffer);
+			}');	
+		}	
+	};
+	enableIoReopen = function(){}; //@Deprecated
+	@_meta;
+}
+
+namespace tcc{
+
+	_meta = {
+		_get = function(k){
+			return owner.getCdecl(k);//会导致自动调用 relocate,且不能再执行 run 等函数
+		}
+		_set = function(k,v){
+			if( k === "code" || k === "c" ) return owner.compile(v);
+			owner[[k]] = v;
+		}
+	}
+
+	_cdecl = ..raw.module("cdecl"); 
+	
+	_rootdir = ..io.appData("aardio/std/lib/tcc");
+	_libdir = ..io.appData("aardio/std/lib/tcc/lib" );
+	_includedir = ..io.appData("aardio/std/lib/tcc/include" ); 
+	if(!(..io.exist(_libdir) && ..io.exist(_includedir))){
+		import sevenZip.lzma.tar;
+		sevenZip.lzma.tar($"~\lib\tcc\.res.tar.lzma",..io.appData("aardio/std/lib/"))
+		//tcc\include\winapi\windows.h 取消 #include <winnls.h> 注释		
+	}
+
+	_libtcc = ..raw.loadDll($"~/lib/tcc/.dll/libtcc.dll","libtcc.dll","cdecl")
+	
+	set_options = _libtcc.api("tcc_set_options","int(POINTER state,str cmd)" )
+	set_error_func = _libtcc.api("tcc_set_error_func","void(POINTER state,pointer error_opaque,pointer error_func )" )
+	set_warning = _libtcc.api("tcc_warning","int(POINTER state,string warning_name, int value)" )
+	add_include_path = _libtcc.api("tcc_add_include_path","int(POINTER state,string pathname)" )
+	add_sysinclude_path = _libtcc.api("tcc_add_sysinclude_path","int(POINTER state,string pathname)" )
+	define_symbol = _libtcc.api("tcc_define_symbol","void(POINTER state,string sym,string value)" )
+	undefine_symbol = _libtcc.api("tcc_undefine_symbol","void(POINTER state,string sym)" )
+	add_file = _libtcc.api("tcc_add_file","int(POINTER state,string filename)" )
+	compile_string = _libtcc.api("tcc_compile_string","int(POINTER state,string buf)" )
+	set_output_type = _libtcc.api("tcc_set_output_type","int(POINTER state,int output_type)" )
+	add_library_path = _libtcc.api("tcc_add_library_path","int(POINTER state,string pathname)" )
+	add_library = _libtcc.api("tcc_add_library","int(POINTER state,string libraryname)" )
+	add_symbol = _libtcc.api("tcc_add_symbol","int(POINTER state,STRING name,point val)" ) 
+	output_file = _libtcc.api("tcc_output_file","int(POINTER state,string filename)" )
+	run = _libtcc.api("tcc_run","int(POINTER state,int argc,struct argv)" ) 
+	relocate = _libtcc.api("tcc_relocate","int(POINTER state,pointer ptr)" )
+	get_symbol = _libtcc.api("tcc_get_symbol","pointer(POINTER state,STRING name)" )
+	set_lib_path = _libtcc.api("tcc_set_lib_path","void(POINTER state,string path)" )
+	
+	fromto = ..string.fromto;
+	
+	build = function(path,code,...){
+		var libs = ... ? {...} : {"user32","kernel32","gdi32"}
+		if(code){
+			var c = ..tcc();
+			c.addLib(libs); 
+			c.define("NDEBUG","1");
+			c.output(path,code);
+			c.close();	
+		}
+		else {
+			return {
+				@{
+					_set = function(k,v){
+						if(k=="code"){
+							var c = ..tcc();
+							c.addLib(libs); 
+							c.define("NDEBUG","1");
+							c.output(path,v);
+							c.close();	
+						}
+					} 
+				}
+			}
+		} 
+	}
+}
+
+/**intellisense()
+tcc = TinyCC 扩展库（ 编译器版本 0.9.27 ）\n此扩展库体积很小，支持发布后生成独立 EXE，\nTinyCC 文档： http://bellard.org/tcc/tcc-doc.html \n完整头文件下载: http://download.savannah.gnu.org/releases/tinycc/winapi-full-for-0.9.27.zip
+tcc() = 创建TCC C语言编译器,\n!tcc.
+tcc._rootdir = TCC根目录,需要的DLL组件目录;
+tcc._libdir = 默认库目录
+tcc._includedir = 默认头文件目录 
+tcc.build( = 直接编译 C代码为执行文件
+tcc.build(.(path,code,->->->) = 直接编译 C代码为执行文件,\n必须使用 @path 指定输出的执行文件路径,\n可选用 @code 参数指定 C语言 源代码,\n如果没有指定 @code 参数，会返回一个对象,\n对返回对象的 code 属性赋值则会自动生成 DLL 文件,\n可选增加一个或多个参数指定要添加的库文件
+tcc.build() = !tccBuilder.
+!tccBuilder.code = @.code = /***\n#include <windows.h> \n__declspec(dllexport) int Add( int a,int b ) \n{     \n	return a + b;__/*如果调用 tcc.build 时没有指定 C代码 就可以在这里指定 C代码。 */\n} \n***/
+end intellisense**/  
+
+/**intellisense(!tcc)
+onError = @.onError = function(msg){
+	console.log( msg ) __/*编译警告或错误会触发此事件\n如果不定义此事件,aardio默认弹出对话框或使用控制台显示此信息*/
+}
+addSysIncludePath("__/*头文件目录*/") = 添加系统头文件目录
+addIncludePath("__/*头文件目录*/") = 添加头文件目录
+addLibPath("__/*库目录*/") = 添加库目录
+addLib(库文件) = @.addLib(\n 	"user32",\n	"kernel32",\n	"gdi32" __/*这几个库默认已添加,这里仅作演示\n静态库必须在"\lib\tcc\.res"目录下可找到 lib库名.a 文件\n动态库必须在"\lib\tcc\.res"目录下可找到 库名.def 文件,请到tcc官网下载def生成工具\n请到tcc官网下载def生成工具\n*/\n)
+addFile(.(path,->->->) = 添加 *.c 源码文件或 *.o, *.obj 文件\n\n此函数返回 tcc 对象自身
+output( = 输出文件
+output(.(path,code) = 输出文件,\n@path 参数指定 *.o, *.obj, *.dll 或 *.exe 等输出文件路径,\n@code 为可选参数,用于指定C源代码,建议用 UTF-8 编码
+define("NDEBUG__/*预处理器符号*/","1") = 定义预处理器符号,如果值为 null 则删除该定义.\n预处理器符号需要在添加或编译 C 源码前定义才会有效,\n如果定义 NDEBUG 为 1，则不编译 assert 函数并可输出较小文件\n此函数返回 tcc 对象自身
+compile(__/*C源码*/)  = 编译C源码,\n注意只有源码为UTF8编码,才能支持 L"UTF-16字面量" 的C语法\n出错则触发onError事件,如果未指定该事件则抛出异常
+setCdecl(函数,函数名,原型) = @.setCdecl(\n	function(){\n		__\n	},\n	"函数名",\n	"void()"\n)
+setCdecl(函数指针,函数名) = 直接将C函数指针传入tcc
+getCdecl("__/*函数名*/","void()") = 获取编译后的C函数\n可选用参数@2 指定函数原型,语法与声明API相同\n如果不指定函数原型,用法与不声明直接调用 API 相同,\n如果从未调用过 relocate 则自动调用.
+relocate() = 重定位\n此函数在调用getCdecl()前被自动调用.
+getSymbol(.("符号名") = 可使用此函数获取函数地址
+setSymbol(.("符号名",指针) = 可使用此函数添加函数指针
+close() = 关闭C语言解释器
+run() = 编译并执行int main() 入口函数.\n可添加任意多个字符串参数
+setOptions(.("-bt N") = 允许调试,生成的文件较大
+setOptions(.("-Wall") =  启用所有警告
+enableIoPrintf( = 在C 代码中添加 io_printf
+enableIoPrintf(.(bufferSize) = 在C 代码中添加 io_printf,\n可选用 @bufferSize 指定最大可输出的字节数,默认为512字节,\nio_printf 与C函数 printf 的用法相同,\n但 io_printf 会调用 aardio 的 io.print 函数输出字符串,\nio_printf 可更好地兼容 aardio 控制台以及 UTF-8 编码,\n注意只有通过 tcc 扩展库直接执行 C代码才能使用此函数
+code = @.code = /*** \n	#include <stdlib.h> \n	#include <windows.h>\n	\n	/*\n	DLL入口函数,该函数可以有也可以没有。\n	总之在DllMain最好不要调用API函数.\n	*/\n	int __stdcall DllMain(void * hinstDLL, unsigned long fdwReason, void * lpvReserved) {\n		if (fdwReason == 1/*DLL_PROCESS_ATTACH*/ ){ \n			\n		}\n		return 1;\n	}\n	\n	//导出变量	\n__declspec(dllexport) const wchar_t *hello_data = L"(UTF8字面量定义为UTF16字符串)";\n	\n	//DLL导出函数\n__declspec(dllexport) void helloW (const wchar_t * msg)\n	{\n		MessageBoxW (0, msg, hello_data, MB_ICONINFORMATION);__/*DLL导出函数*/\n	}\n***/
+addFile() = !tcc.
+addLib() = !tcc.
+define() = !tcc.
+? = 直接获取 C函数,\n相当于调用 getCdecl 且不指定参数原型,\n这种方法获取 C函数 同样会导致自动调用 relocate 函数,\n返回函数对象的调用规则与不声明调用API相同\n\n一、传入参数规则：\n1、null参数不可省略\n2、32位整数类型，小于32位的整数、以及枚举类型都可以直接在API参数中写数值。\n3、对于任何数值类型的指针（输出参数）一律使用结构体表示，例如double * v 表示为{ double v }\n4、数组使用结构体表示\n5、所有结构体传给API的都是指针地址，都是输出参数并增加返回值\n\n返回值默认为int类型\n不支持使用 API 尾标改变返回值类型
+end intellisense**/  
+
+/**intellisense()
+_TCC_OUTPUT_MEMORY=@1/*_TCC_OUTPUT_MEMORY*/
+_TCC_OUTPUT_EXE=@2/*_TCC_OUTPUT_EXE*/
+_TCC_OUTPUT_DLL=@3/*_TCC_OUTPUT_DLL*/
+_TCC_OUTPUT_OBJ=@4/*_TCC_OUTPUT_OBJ*/
+_TCC_OUTPUT_PREPROCESS=@5/*_TCC_OUTPUT_PREPROCESS*/
+end intellisense**/

package/aardio/lib/thread/apiHook.aardio

@@ -0,0 +1,109 @@
+//apiHook 函数钩子
+namespace thread {
+	
+	class apiHook {
+		ctor ( dllName, apiName,apiProto, callback,ownerTable) { 
+			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 && ( !tonumber(callback) )){   
+				error("参数@4必须指定钩子函数",2);
+			};
+			this.callback = callback;
+			
+			..table.gc( this,"unInstall" );
+		}
+		install = function () { 
+			var jmpOpCodeLen = 5;
+			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*/) 
+			
+			if( type(callback) == type.function ){
+				this.callback_c = ..thread.tostdcall(
+					function(...){  
+					
+						if(!owner.callApi){
+							owner.callApi = raw.main.api(owner.addrTrampoline, owner.apiProto);
+							owner.addrTrampoline = null;
+							owner.apiProto = null;
+						}
+						
+						return owner.callback(...);
+					} , apiProto,..table.mix( { 
+						callback = callback;
+						addrTrampoline = this.addrTrampoline;
+						apiProto = apiProto },ownerTable ) 
+					);
+				this.addrHookFunction = tonumber( ..raw.toPointer(this.callback_c) )
+			}
+			else {
+				this.addrHookFunction = tonumber(callback);
+				if( !this.addrHookFunction )
+					error("参数@4必须指定钩子函数",2);
+			}
+			 
+			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.addrHookFunction - (addrTargetFunction + jmpOpCodeLen);
+			} ) 
+			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 ); 
+			this.callback_c = null;
+		}
+	}	
+}
+
+namespace thread.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()")
+}
+
+/**intellisense()
+thread.apiHook = 多线程API函数钩子，多线程调用该API都会被拦截处理。\n仅拦截当前线程调用的钩子建议使用 raw.apiHook
+thread.apiHook("DLL","API名","函数原型",函数对象) = @.apiHook(\n	"user32.dll",\n	"MessageBoxW",\n	"int(int,ustring,ustring,int)", \n	function(hwnd,text,caption,flag){\n		owner.callApi(hwnd, text, "API Hook: " + caption, flag) \n		\n		__/*可选通过 owner.callApi 调用原始函数,\n结构体等回调时必须传为指针参数,\n可通过 raw.mixin 修改修结构而不改变指针地址,\n注意这是线程回调函数,库需要单独引入*/\n		return true;\n	}\n).install();
+thread.apiHook() = !thread_apihook. 
+!thread_apihook.install() = 安装钩子\n!thread_apihook.
+!thread_apihook.unInstall() = 卸载钩子
+end intellisense**/

package/aardio/lib/thread/atom.aardio

@@ -0,0 +1,27 @@
+//atom 本地原子量
+namespace thread.atom 
+
+AddAtom = ::Kernel32.api("AddAtom","word(string str)") 
+add = function(name){
+	if( type(name) != type.string || #name > 255 ){
+		error("参数必须是小于256字节的字符串",2)
+	}	
+	return AddAtom( name );
+}
+
+find = ::Kernel32.api("FindAtom","word(string str)") 
+delete = ::Kernel32.api("DeleteAtom","word(word)") 
+	
+GetAtomName = ::Kernel32.api("GetAtomName","INT(word atom,string &buf,int size)")   
+getName = function(atom){ 
+	var size,str = GetAtomName(atom,256,256)
+	if(size)
+		return ..string.left(str,size); 
+} 
+	 
+/**intellisense(thread.atom) 
+add("__") = 添加字符串到本地原子表\n字符串长度必须小于256字节\n返回原子数值
+find("__") = 在本地原子表查找字符串\n忽略大写小全串匹配\n返回原子数值
+delete(__/*原子值*/) = 减少原子引用计数\n当引用计数为0时删除原子
+getName(__/*原子值*/) = 返回原子字符串
+end intellisense**/

package/aardio/lib/thread/cmdline.aardio

@@ -0,0 +1,18 @@
+//cmdline 命令行参数
+import string.cmdline;
+namespace thread;
+
+class cmdline{
+	ctor(){{
+		var p = ::Kernel32.GetCommandLineP();
+		if(p){
+			p = ..raw.str(p,true);
+			this = ..string.cmdline.argv(p);
+		}
+	}}; 
+}
+
+/**intellisense()
+thread.cmdline() = 获取主进程启动命令行参数，\n并由 string.cmdline.argv 函数解析后返回数组。\n命令行解析规则请参考标准库中 string.cmdline 的源码。\n\n返回的数组对象也包含按下列规则解析的键值对:\n以斜杠或短横线开始的前导参数作为键（键名移除一个或多个相同的前导字符,区分大小写），\n如果前导参数包含等号,则以等号拆分为键值对,等号前后不应有空格,\n否则检查下一参数如果没有相同的首字符则设为此键对应的值，\n如果一个前导参数没有指定值,则默认值为空字符串（逻辑值为true）\n\n当前线程如果是主线程，请直接使用 _ARGV 。\n!threadCmdline.
+!threadCmdline.? = 请输入命令行参数中以斜杠或短横线开始的前导参数名
+end intellisense**/