aview-app 1.0.2

package/aardio/lib/golang/.res/aardio/jsonrpc/jsonrpc.go

@@ -0,0 +1,27 @@
+package jsonrpc
+
+import (
+    "net/rpc"
+    "net/rpc/jsonrpc"
+	"os" 
+)
+
+type JsonRpcConn struct{}
+
+func (s *JsonRpcConn) Read(p []byte) (int, error) {
+	return os.Stdin.Read(p)
+}
+
+func (s *JsonRpcConn) Write(p []byte) (int, error) {
+	return os.Stdout.Write(p)
+}
+
+func (s *JsonRpcConn) Close() error {
+	os.Stdin.Close()
+	os.Stdout.Close()
+	return nil
+}
+
+func Run(server *rpc.Server) {
+	server.ServeCodec( jsonrpc.NewServerCodec(new(JsonRpcConn)) )
+}

package/aardio/lib/golang/.res/aardio/jsonrpc/tcp/tcp.go

@@ -0,0 +1,28 @@
+package jsonrpc
+
+import (
+	"os"
+    "fmt"
+    "net"
+    "net/rpc"
+    "net/rpc/jsonrpc"
+)
+
+func Run(server *rpc.Server) { 
+ 
+    listener, e := net.Listen("tcp", "localhost:0")
+    if e != nil { 
+        fmt.Fprintf(os.Stderr,  e.Error() ) 
+        return
+    } else { 
+        fmt.Printf("%s\n", listener.Addr().String())
+    }
+ 
+    if conn, err := listener.Accept(); err != nil {
+        fmt.Fprintf(os.Stderr,  err.Error() ) 
+    } else {
+    	server.ServeCodec(jsonrpc.NewServerCodec(conn))
+    } 
+    
+    listener.Close()
+}

package/aardio/lib/golang/_.aardio

@@ -0,0 +1,234 @@
+import win;
+import process;
+import console;
+import zlib.httpFile;
+import win.path;
+import fsys.lnk;
+import fsys;
+import string.cmdline;
+
+assert(!golang,"请先引入 golang 库，然后再引入 golang 名字空间下的其他库。");
+
+class golang{
+	ctor(workDir,root){
+		 
+		this.installGo = function(version){
+			 
+			if(_WINXP){ version = "1.11" }	 
+			var ok,err = ..zlib.httpFile.download("https://golang.google.cn/dl/go"+(version:"1.19.5")
+				+( _WIN_64 ? ".windows-amd64.zip" : ".windows-386.zip" ) ,"正在下载Go编译器（Google服务器响应有点慢）"
+				,"~\lib\golang\.res","~\lib\golang\.res") 
+				
+			if( !ok  ){
+				..console.log(err);
+				..fsys.delete("~\lib\golang\.res\go")
+			} 
+		}
+		
+		if(!root){
+	
+			if( ..io.exist("~\lib\golang\.res\go\bin\go.exe") ){
+				root = ..io.fullpath("~\lib\golang\.res\go")
+			}
+			
+			if( ! ..io.exist(root) ){
+				root = ..string.getenv("GOROOT");
+				if( ! ..io.exist(root) ){
+					this.path = ..win.path.search("go.exe");
+					
+					if( this.path ){
+						root = ..fsys.getParentDir(this.path)
+						root = root ? ..fsys.getParentDir(root)
+						if(!root) this.path = null;
+					}
+				}
+			}
+			
+			if( ! ..io.exist(root) ){
+				if(..io.exist("C:\Go\bin\go.exe")){
+					root = "C:\Go"
+				}
+			} 
+			
+			if( ! ..io.exist(root) ){
+				if(!..io.exist("~\lib\golang\.res\go\bin\go.exe") ){
+					this.installGo();
+				}
+				
+				if(!..io.exist("~\lib\golang\.res\go\bin\go.exe") ){
+					error("未安装Go编译器",2);
+				}
+				
+				root = ..io.fullpath("~\lib\golang\.res\go")
+			}
+		}
+		
+		this.root = ..io.fullpath(root); 
+    	..string.setenv("GOROOT",this.root); 
+    	..string.setenv("GO111MODULE","auto");
+		..string.setenv("GOPROXY","https://goproxy.io,direct");
+		..string.setenv("CGO_ENABLED","1");
+    	..string.setenv("GOARCH","386");
+    	..string.setenv("GOOS","windows");
+     
+    	..string.save(..io.joinpath(this.root,"/src/aardio/aardio.go"),$"~\lib\golang\.res\aardio\aardio.go");
+    	..string.save(..io.joinpath(this.root,"/src/aardio/jsonrpc/jsonrpc.go"),$"~\lib\golang\.res\aardio\jsonrpc\jsonrpc.go");
+    	..string.save(..io.joinpath(this.root,"/src/aardio/jsonrpc/tcp/tcp.go"),$"~\lib\golang\.res\aardio\jsonrpc\tcp\tcp.go");
+    	
+    	..win.path.add( ..io.joinpath(this.root,"\bin") );
+    	..string.setenv("GOCACHE",..io.joinpath(this.root,"\.cache") );
+    	this.path = ..io.joinpath(this.root,"\bin\go.exe") 
+ 
+		this.environment = {};
+		this.workDir = workDir : ..io.fullpath("/");
+		..io.createDir(this.workDir)
+		
+		this.command = function(...){
+			..console.open() 
+			 
+			var prcs =  ..process( this.path, ..string.cmdline.arguments(...)
+				,{workDir=this.workDir;environment=this.environment} ); 
+				
+			prcs.wait();
+			prcs.free();
+		};
+		
+		this.command("version");
+	};
+	runCode = function(path,code,...){
+		..string.save(path,code)
+		return this.command("run",..io.localpath(path) : path,...);
+	};
+	run = function(path,...){
+		return this.command("run",..io.localpath(path) : path,...);
+	};
+	build = function(path,...){
+		if(this.main) ..string.save(path, this.main);  
+		
+		return this.command("build",..io.localpath(path) : path,...);
+	};
+	buildStrip = function(path,...){
+		if(this.main) ..string.save(path, this.main);  
+		
+		return this.command("build","-ldflags","-s -w",..io.localpath(path) : path,...);
+	};
+	addPath = function(path){
+		..win.path.add(path);
+	};
+	setProxy = function(proxy,git){
+		..table.mixin(this.environment,{
+			http_proxy=proxy;
+			https_proxy=proxy;
+		});
+		
+		if(git){
+			import process.git;
+			process.git(this.workDir).setHttpProxy(proxy)
+		}
+	};
+	enableCgo = function(){
+		import process.gcc;
+		process.gcc.check();
+		
+		..string.setenv("CGO_ENABLED","1");
+	};
+	buildShared = function(path,outpath,...){
+		this.enableCgo();
+		if(this.main) ..string.save(path, this.main);  
+		
+		if(!outpath){
+			if( ..string.endWith(path,".go",true)){
+				outpath = ..string.left(path,-4) + ".dll"
+			}
+			else {
+				outpath = path + ".dll"
+			} 
+		}
+		return this.command("build","-buildmode=c-shared"
+			,"-ldflags","-s -w" //-s 去掉符号表，-w是去掉DWARF调试信息，可减小生成文件体积
+			,"-o",..io.localpath(outpath) : outpath,..io.localpath(path) : path,...);
+	};
+	buildArchive = function(path,outpath,...){
+		if(this.main) ..string.save(path, this.main);  
+		
+		if(!outpath){
+			if( ..string.endWith(path,".go",true)){
+				outpath = ..string.left(path,-4) + ".dll"
+			}
+			else {
+				outpath = path + ".dll"
+			} 
+		}
+		return this.command("build","-buildmode=c-archive","-ldflags","-s -w","-o",..io.localpath(outpath) : outpath,..io.localpath(path) : path,...);
+	};
+	get = function(paths,...){
+		import process.git;
+		for item in ..string.lines(paths) { 
+			if(#item)this.command("get",item,...);
+		}					 
+	};
+	mod = function(...){
+		var args = ..string.cmdline.arguments(...);
+		..table.unshift(args,"mod");
+		
+		this.command(args);
+	};
+	install = function(path,...){
+		return this.command("install",..io.localpath(path) : path,...);
+	};
+	version = function(){
+		return this.command("version");
+	};
+	env = function(){
+		return this.command("env");
+	}; 
+}
+
+import golang.string;
+
+/**intellisense()
+golang = 调用 Go 编译器。\n调用 Go 编译后的执行程序并不需要此扩展库。\n\n此扩展库可自动下载配置 Go 编译器
+golang( = 创建 Go 编译器调用程序
+golang(.("Go项目目录","Go安装目录") = 创建 Go 编译器调用程序，所有参数可选。\nGo 项目目录默认为 aardio 应用程序根目录的 "/" 。\n如果不指定 Go 安装目录,自环境变量 GOROOT 中获取\n如果查找 Go 编译器失败会自动下载 Go 编译器
+golang.string() = 创建 Go 语言 string 对象,返回结构体,\n作为调用 Go函数的参数使用时,\nGo 语言的 API 参数类型必须声明为 *string 指针
+golang() = !golang.
+!golang.command(__) = 执行 go 命令,支持一个或多个命令参数
+!golang.run(__) = 执行 go run 命令,参数中指定要编译运行的代码
+!golang.runCode(.("代码路径","Go代码") = 保存 Go 代码并运行文件
+!golang.build(__) = 执行 go build 命令生成EXE文件,参数中指定要编译的代码文件\n可增加多个参数
+!golang.buildShared( = 执行 go build 命令生成DLL动态库。\n如果未找 gcc 到则自动安装 Mingw-w64
+!golang.enableCgo() = 启用 cgo ，依赖 gcc 。\n如果未找 gcc 到则自动安装 Mingw-w64
+!golang.buildShared(.("源文件文件路径","输出文件路径") = 执行 go build 命令生成 DLL 动态库,\n参数@1必须指定要编译的代码文件,可选指定输出 DLL 文件路径,\n可增加多个参数\n\n编译 DLL 需要依赖 GCC,请先调用 process.gcc.check\n\n注意每个Go导出函数前面都要加上 //export 要导出的函数名 
+!golang.buildArchive(.("源文件文件路径","输出文件路径") = 执行 go build -buildmode=c-archive命令
+!golang.buildStrip(__) = 执行 go build 命令生成体积较小的EXE文件,\n默认添加-ldflags "-s -w"参数移除调试信息\n文件参数中指定要编译的代码文件
+!golang.install(__) = 执行 go install 命令,参数中指定要编译安装的代码
+!golang.addPath(__) = 添加路径到 PATH 环境变量
+!golang.setProxy("代理服务器地址",是否设为GIT代理) = 设置代理服务器，\n参数 @1 示例: "socks5://127.0.0.1:10801"，\n设为 null 清除代理\n\n参数 @2 可省略，\n设为 true 则同时设置 GIT 的 HTTP / HTTPS 代理
+!golang.mod("init __/*模块名*/")= 执行 go mod 命令，\n参数可以是一个字符串，以空格分隔多个参数。\n也可传入多个参数，参数用法请参考 process 启动参数说明
+!golang.get(__) = 执行 go get 命令,安装远程代码包，\n可在参数 @1 中使用多行字符串指定多个远程包,\n需要先安装 GIT ，如果未安装就自动安装\n\n建议先调用 setProxy 函数设置代理。\n并调用 process.git 的 setHttpProxy 函数设置代理
+!golang.env() = 执行 go env 命令，显示环境变量
+!golang.version() = 执行 go version 命令，显示版本
+!golang.main = @.main = /**********\npackage main\n\nimport "C"  \nimport (\n	"aardio"\n	"fmt"\n)\n\n__/*如果在这里指定了 Go 码，\n则调用 build 前缀的函数将自动覆盖参数 @1 指定的 *.go 文件。*/\nfunc init() {}\n\nfunc main() {} \n**********/
+end intellisense**/
+
+/**details(必读)
+调用 Go 写的 DLL 请注意：
+
+1、 加载 Go 写的 DLL 然后迅速（几秒以内）退出，Go 程序可能会崩溃。
+这不是因为你写的代码有任何问题，而是 Go 需要额外启动运行时，无法应付这种快速退出的情况。
+这时在后面加一句 thread.delay(2000) 就可以解决。
+
+实际上除了写测试代码，一般也不会打开一个程序就在几秒内退出。
+所以稍加注意一下，避免这个问题并不难。
+
+只有 Go 写的 DLL 有这个问题，其他语言写的 DLL 没这种问题。
+
+2、在同一个进程内， Go 写的同一个 DLL 应当只加载一次。
+当然在 DLL 没有卸载前，反复调用 raw.loadDll() 只是增加引用计数，不会重复加载 DLL。
+
+如果多线程内存加载同一个 Go 写的 DLL 就会加载多个不同的副本。
+这时候务必在 raw.loadDll("go.dll","共享名称") 的第 2 个参数指定共享名称，以避免重复加载。
+
+3、要注意在 aardio 中 DLL 不应当作为线程参数传递，实际上也没必要这样做。
+只要用 raw.loadDll() 加载同名 DLL (或加载相同共享名称的内存 DLL) 是不会重复加载的。
+end details**/

package/aardio/lib/golang/string.aardio

@@ -0,0 +1,22 @@
+namespace golang{
+    
+    class string{
+    	ctor( str ){
+        	this.p = str;
+        	this.n = #str;
+    	};
+    	ptr p;
+    	addr n;
+    	@_meta;
+    }
+    
+    string._meta = {
+        _tostring = function(){
+        	return ..raw.tostring(owner.p,1,owner.n);
+        } 
+    }
+}
+
+/**intellisense()
+golang.string(__) = 创建Go字符串，\n参数可指定 buffer、string、null 类型的值\n可作为结构体参数用于获取 Go 字符串的值,\n获取到 Go 字符串以后，考虑 Go 会随时释放字符串,\n应当尽快使用 tostring 转换此结构体为 aardio 字符串\n不要保存或继续使用 Go 字符串指针
+end intellisense**/

package/aardio/lib/ide/command.aardio

@@ -0,0 +1,226 @@
+//command 进程命令
+import win.ui;
+import thread.table;
+namespace ide;
+
+class command{
+	ctor( winform,changeMsgFilter ){ 
+		if(!winform){
+			winform = ..win.form( {} );
+			winform.messageOnly();
+		}
+		this._form = winform;
+		this._commands = {};
+		
+		if( winform.onCopyData ){
+			error("目标窗口已指定onCopyData事件,不能创建进程命令管理器!",2)
+		}  
+		
+		if( changeMsgFilter && ChangeWindowMessageFilterEx ){
+			ChangeWindowMessageFilterEx( this._form.hwnd,0x4A/*_WM_COPYDATA*/,1/*_MSGFLT_ALLOW*/,{});
+		}
+		
+		winform.onCopyData = function(args){ 
+			if( type(args) !="table" ) return;
+			
+			var method = this._commands[args[1] ] 
+			if(type(method)=="function"){ 
+				var _,argc = ..table.range(args) 
+				var ret = invoke(method,this._commands, ..table.unpack( args,2,argc) );
+				if( ret !== null ) return pushReturnValue(ret);	
+			} 
+		}
+			
+		..table.gc(this,function(){
+			for(name in this._commands ){
+				 this[name] = null;
+			} 
+		});
+	}; 
+	@_meta;
+}
+ 
+import process.mutex;
+import fsys.mmap;
+namespace command {  
+	try{ ChangeWindowMessageFilterEx = ::User32.api( "ChangeWindowMessageFilterEx", "bool(addr hwnd,INT msg,INT flag,struct &chgFilter)"); }
+ 	
+	var mutex,mmap,__groupName__; 
+	
+	var joinTest = function(name,size){
+		if(!#name) name = "{B5B96695-F51A-4FCC-813E-9FA9A7A55500}";
+		
+		if( __groupName__  ) {
+			if( __groupName__ != name ) error("该线程已加入其他进程群组:" + __groupName__ + "\n不能再加入群组:" + name,2);
+			else{ return true;}
+		}
+		
+		mutex = ..process.mutex( name + ".mutex");
+		mmap = ..fsys.mmap( ,name + ".commands",size); 
+		
+		if(mutex && mmap){
+			__groupName__ = name;  
+			return true;
+		}
+	}
+	
+	join = function(name,size=0x100000){  
+		for(i=1;5;1){
+			if( joinTest(name,size) ){
+				return true;
+			}
+			sleep(200);
+		}
+		
+		var dbg = {
+			mutex = !!mutex;
+			mmap = !!mmap;
+			__groupName__ = __groupName__;
+			name = name;
+		}
+		var err = ..lasterr();
+		error( ..string.concat("注册进程群组时遇到错误"
+			,'\r\n',err," ->",..table.tostring(dbg)),2);
+	}
+	
+	pushReturnValue = function(v){
+		if(! mutex.waitOne() ) return;
+		
+		mmap.seek("set"); 
+		var commandTable  = mmap.readTable() : {};
+		if(!commandTable[-1])commandTable[-1] = {};
+		var ret = ..table.push(commandTable[-1],v);
+		mmap.seek("set"); 
+		mmap.writeTable(commandTable);  
+		mutex.release();
+		return ret;
+	}
+	
+	getReturnValue = function(idx){
+		if(! mutex.waitOne() ) return;
+		
+		mmap.seek("set"); 
+		var commandTable  = mmap.readTable() : {};
+		var ret;
+		if(commandTable[-1]){
+			ret = commandTable[-1][idx] ? ..table.remove(commandTable[-1],idx);
+		} 
+		mmap.seek("set"); 
+		mutex.release();
+		return ret;
+	}
+
+ 	_meta = {
+		_set = function(k,v){
+			if(!mutex) error("进程必须调用 ide.command.join() 函数初始化",2);
+			if( k == -1 ) error("命令名不能设置为保留值-1",2);
+			
+			if(! mutex.waitOne() ) return;
+			mmap.seek("set"); 
+			var commandTable  = mmap.readTable() : {};
+			if(!commandTable[k])commandTable[k] = {};
+			commandTable[k][owner._form.hwnd] = v?true:null;
+			mmap.seek("set"); 
+			mmap.writeTable(commandTable);  
+			owner._commands[k] = v;
+			mutex.release();
+		}
+	}; 
+	
+	sendPid = function(pidDst,method,...){
+		var subscribe;
+		
+		if(! mutex.waitOne() ) return;
+		mmap.seek("set"); 
+		subscribe = mmap.readTable()[[realName]];  
+		mmap.seek("set");
+		mutex.release();
+		
+		var ret,tid,pid;
+		var sendTable = {method;...};
+		for(hwnd in subscribe){ 
+			tid,pid = ..win.getThreadProcessId();
+			if(pid!=pidDst) continue;
+			ret = ..win.sendCopyData( hwnd,sendTable );
+			if( ret ) return getReturnValue( ret );
+		}
+		return; 	
+	}
+	
+	
+	send = function(hwnd,method,... ){  
+		if(!mutex) error("进程必须调用 ide.command.join() 函数初始化",2);
+		 
+ 		var t = type(hwnd); 
+		if( t == "string" ){
+			var realName = hwnd;
+			var sendTable = {realName;method;...};
+		 
+		 	var subscribe;
+		 	if(! mutex.waitOne() ) return;
+			mmap.seek("set"); 
+			subscribe = mmap.readTable()[[realName]];  
+			mmap.seek("set");
+			mutex.release();
+			
+			var ret;
+			for(hwnd in subscribe){ 
+				ret = ..win.sendCopyData( hwnd,sendTable );
+				if( ret ) return getReturnValue( ret );
+			}
+			return; 
+		}
+		elseif(t == "number" ){
+			var sendTable = {method;...}; 
+			var ret = ..win.sendCopyData( hwnd,sendTable )
+			if( ret ) return getReturnValue( ret );
+		}; 
+	};
+	
+	post = function( ...  ){
+		..thread.invoke( 
+			function(__groupName__,... ){
+				import ide.command;
+				ide.command.join(__groupName__)
+				ide.command.send( ... );
+			},__groupName__,... 
+		)
+	};
+	
+	self.invoke = function(...){
+		return ..thread.invokeAndWait( 
+			function(__groupName__,... ){
+				import ide.command;
+				ide.command.join(__groupName__)
+				return ide.command.send( ... );
+			},__groupName__,... 
+		)
+	}
+	
+	self@ = {
+		_get = function(k){
+			self[[k]] =  function(...){
+				return owner.send(k,...);
+			} 
+			
+			return self[[k]];
+		} 
+	} 
+}
+
+/**intellisense() 
+ide.command = 只允许在ide扩展库、以及IDE启动触发器init.aardio中使用\n用于避免在IDE中因为导入ide接口而无法支持 process.command
+ide.command.join(.("群组GUID") = 加入进程群组\n使用GUID区分不同的进程分组\n同一线程应当且必须在定义或发送进程命令前调用该函数一次,\n同一线程可多次调用该函数,但参数必须相同\n成功返回true
+ide.command.sendPid(.(目标进程ID,"命令函数名",其他参数) = 阻塞调用跨进程命令,\n可获取回调函数的数值返回值,默认返回null
+ide.command.post(.("命令函数名",其他参数) = 非阻塞调用跨进程命令,无返回值\n此函数需要创建线程调用send函数,不适合频繁调用\n异步命令如果尚未发出前,发送线程如果立即退出会导到命令发送失败
+ide.command.invoke(.("命令函数名",其他参数) = 非阻塞调用跨进程命令,支持返回值
+ide.command.send(.(窗口句柄,"命令函数名",其他参数) = 阻塞调用跨进程命令,\n可获取回调函数的数值返回值,默认返回null
+ide.command.send(.("命令函数名",其他参数) = 阻塞调用跨进程命令\n不指定窗口句柄,所有同名的进程命令函数都会被调用,\n可获取处理该命令的回调函数返回值,默认返回0
+ide.command.? = 可指定外部进程的命令函数名,并直接调用该函数，\n可获取外部进程中被调用函数的返回值
+ide.command(.(窗口对象,是否取消特权隔离) = 创建进程命令对象\n省略窗口参数则创建 message only window,\n该对象定义的成员函数,都可在其他进程中用 thread.command.post()调用
+ide.command() = !ide_command.
+!ide_command.自定义函数名 = @.命令函数 = function( ... ) {
+	__/*支持不定个数参数\n返回值可阻止命令继续传递*/
+}
+!ide_command._form = 窗体对象\n!winform.
+end intellisense**/

package/aardio/lib/ide/customCtrl.aardio

@@ -0,0 +1,9 @@
+//customCtrl 自定义控件
+namespace ide.customCtrl{
+	vlistview = "listview";
+	close = "plus";
+	ipaddress = "edit";
+	syslink = "static";
+}
+
+__IDE_CUSTOMCTRL = ide.customCtrl;

package/aardio/lib/ide/debug.aardio

@@ -0,0 +1,61 @@
+//debug 调试
+namespace ide.debug;
+
+onError = function(err,over){  
+	if(type(err) != type.string ) return; 
+	err = ..string.replace(err,'@\n{Error}:\n','\n');
+	err = ..string.replace(err,"\n----------------------\s*\n\s*",'\n'); 
+	err = ..string.replace('\n'+err,"\n\{?([\a\s]*?)\}?\:", {
+		["Near"] = '\n靠近:';
+		["Byte"] = '\n字节码:';
+		["Error"] = '\n错误:';
+		["File"] = '\n文件:';
+		["Line"] = '\n错误行号:';
+		["Field"] = '\n字段:';
+		["Failed"] = '\n失败操作:';
+		["Attempt to"] = '\n不支持此操作:';
+		["Kind"] = '\n定义类型:';
+		["Name"] = '\n名字:';
+		["Type"] = '\n类型:';
+		["Expected"] = '\n预期:';
+		["Got"] = '\n实际获取:';  
+		["Struct error"] = '\n结构体错误:'; 
+		["Match for"] = '\n匹配于:'; 
+		["Match line"] = '\n匹配行:'; 
+		["Expected size"] = '\n预期大小:'; 
+		["Bad argument"] = '\n错误参数:'; 
+		["Calling"] = '\n调用函数名:'; 
+		["Declare api"] = '\nAPI函数声明:'; 
+		["Data type error"] = '\n参数类型错误:'; 
+	} );
+	
+	err = ..string.replace(err,"<.*?>", {
+		["unexpected symbol"] = "<未知符号>";
+		["unexpected end"] = "<意外结束>";
+		["name"] = "<标识符>";
+	} );
+	err = ..string.trim(err);
+
+	import debug;
+	if(!over){
+		var traced = 0;
+		if( ..string.find(err,"\.aardio\:\d+\:\s*in function") ){
+			traced=1;
+		}
+		elseif( ..string.find(err,"\[string.+?\]\:\d+\:\s*in main chunk")  ){
+			traced=1;
+		}
+		elseif( ..string.find(err,"\[string.+?\]\:\d+\:\s*in function")  ){
+			traced=1;
+		}
+		elseif( ..string.find(err,"\[kernel\]\:\d+\:\s*in function")  ){
+			traced=1;
+		}
+	
+		if(!traced){
+			err = ..string.concat(err ,'\n---------------------------------------------------\n', (debug.traceback(,'调用栈:',3 )) )
+		}
+	}	
+	
+	return err;
+}