aview-app 1.0.2

package/aardio/lib/thread/works.aardio

@@ -0,0 +1,198 @@
+//works 任务分派
+import win.guid;
+import thread.table;
+import thread.semaphore;
+
+namespace thread
+
+class works{
+	ctor( limit,func,waitTime,fInit,...){
+		this._guid = tostring(..win.guid.create());
+		this._thrdWorking = ..thread.var(this._guid + "$working",0) ;
+		this._thrdArguments = ..thread.table( this._guid + "$arguments",0); 
+		this._thrdResults = ..thread.table( this._guid + "$result",0);   
+		this._thrdSign = ..thread.var(this._guid + "$sign",true); 
+		this._semaphore = ..thread.semaphore(,limit);
+
+		var threads = {} 
+		for(i=1;limit;1){
+			var thrd = {}
+			thrd.handle,thrd.id = ..thread.create(
+				function(semaphore,func,fInit,waitTime,thrdSign,thrdWorking,thrdArguments,thrdResults,...){ 
+					if(fInit) fInit(...);
+					while( thrdSign.get() ){ 
+						if( thrdArguments.len() > 0 ){
+							var arg = thrdArguments.remove() 
+							if(arg!==null){  
+								thrdWorking.add(1);
+								var ret = func(arg,...);
+								if(ret!==null) thrdResults.insert( ret ); 
+								thrdWorking.add(-1);
+								semaphore.release();
+							}
+						}
+						else {
+							sleep(waitTime);
+						} 
+					}  
+				},this._semaphore,func,fInit,waitTime : 500 
+					,this._thrdSign,this._thrdWorking,this._thrdArguments,this._thrdResults
+					,...
+			)
+			..table.push(threads,thrd);
+		
+		} 
+		..table.gc(this,"quit");
+	};
+	each = function(){
+		this.suspend()
+		return function(k){
+			return this._thrdArguments.next(k);
+		},function(){
+			this.resume();
+		} ;
+	};
+	update = function(idx,args){
+		this._thrdArguments.set(idx,args);
+	};
+	push = function(...){
+		if( #threads ) { 
+			if( this._semaphore.waitOne() ){
+				this._thrdArguments.push(...);	
+			} 
+		}
+	};
+	peek = function(n){ 
+		return this._thrdResults.len()
+	};
+	pop = function(n){ 
+		if(this._thrdResults.len()){
+			return this._thrdResults.pop(n)	 
+		}
+	};
+	getHandleById = function(id){
+		var handles ={}
+		for(slot,thrd in threads){
+			if( thrd.id = id) return thrd.handle; 
+		} 
+	};
+	getHandles = function(){
+		var handles ={}
+		for(slot,thrd in threads){
+			..table.push( handles,thrd.handle ) //support push null   
+		} 
+		return handles;	
+	};
+	suspend = function(id){
+		if( id ){ 
+			var handle = this.getHandleById(id) ;
+			return handle ? ..thread.suspend( handle )
+		}
+		
+		var handles = this.getHandles();
+		for(i,hdle in handles){ 
+			..thread.suspend(hdle)
+		} 
+	}; 
+	resume = function(id){
+		if( id ){ 
+			var handle = this.getHandleById(id) ;
+			return handle ? ..thread.resume( handle )
+		}
+		
+		var handles = this.getHandles();
+		for(i,hdle in handles){ 
+			..thread.resume(hdle)
+		} 	
+	};
+	clear = function(){
+		this._thrdArguments.clear();
+		
+		var delay = ..win[["ui"]] ?  ..win[["delay"]] : sleep
+		delay(100);  
+		while( this._thrdWorking.get() > 0 ) { 
+			delay( 100  )
+		} 
+		this._thrdWorking.set(0);
+		this._thrdResults.clear();
+	};
+	quit = function(){ 
+		if( #threads ){ 
+			var delay = ..win[["ui"]] ?  ..win[["delay"]] : sleep
+			var handles = this.getHandles(); 
+			for(i=1;#handles){ 
+				..raw.closehandle(handles[i])
+			} 
+			threads = {};
+			this._thrdSign.set(null)
+ 
+			delay(100);  
+			while( this._thrdWorking.get() > 0 ) { 
+				delay( 100  )
+			} 
+			this._thrdWorking.set(0);
+			this._thrdArguments.clear();
+			this._thrdResults.clear();
+		}
+	};
+	queueCount = function(){
+		return this._thrdArguments.len();
+	};
+	busy = function(){
+		return ( this._thrdArguments.len() > 0 ||  this._thrdWorking.get()  )
+	};
+	finished = function(){
+		return !this.busy() && !this._thrdResults.len()
+	};
+	wait = function(f){ 
+		var r;
+		var delay = ..win[["ui"]] ?  ..win[["delay"]] : sleep;
+		while( this.busy() ) { 
+			if( ! delay( 100  ) ){
+				return;
+			}
+			if( f ){
+				r = this.pop(1);
+				if(r!==null)f(r);
+			}
+		}
+		
+		if(f){
+			r = this.pop(1);
+			while( (r!==null) && delay(10) ){
+				f(r);
+				r = this.pop(1);
+			} 
+		}
+		return true; 
+	};
+	waitClose = function(f){
+		var r = this.wait(f);
+		this.quit();
+		return r;
+	}; 
+}  
+
+
+/**intellisense()
+thread.works = 线程工作项管理
+thread.works(线程数,工作函数,等待延时,初始化函数,->->->) = @.works( 20,\n	function(arguments,...) {\n		__/*arguments为线程任务传递的参数,\n其他参数为创建thread.work时的附加参数,\n这些附加参数也会传递给初始化函数*/\n		return "返回值"\n	} \n);
+thread.works() = !thread_work.
+!thread_work.queueCount() = 排队等候执行的任务数目
+!thread_work.clear() = 清空已添加的任务
+!thread_work.push(__) = 添加调用实参到任务列表尾部\n可使用table对象传递多个参数给任务函数\n工作函数将自动获取参数并执行任务,\n此函数会等待空闲线程,等待时界面线程仍然可以处理窗口消息
+!thread_work.pop(__) = 弹出工作函数完成任务后的返回值，\n注意如果线程返回的是null将被忽略
+!thread_work.peek() = 是否有线程完成了新的任务并返回了新的值，\n注意如果线程返回的是null将被忽略
+!thread_work.quit() =  通知所有线程退出\n并等待线程关闭
+!thread_work.wait() =  等待所有任务完成,\n可指定一个回调函数作为参数接收工作项返回值\n\n建议在界面线程使用定时器替代此函数
+!thread_work.waitClose() =  等待所有任务完成\n通知所有线程退出,并等待所有线程关闭.\n可指定一个回调函数作为参数接收工作项返回值\n\n建议在界面线程使用定时器替代此函数
+!thread_work.busy() = 是否有未完成任务
+!thread_work.finished() = 是否有未完成任务或未读取的任务返回值
+!thread_work.suspend() = 所有线程暂停\n可选在参数中指定线程ID\n注意线程是否正在使用互斥锁
+!thread_work.resume() = 所有线程继续执行\n可选在参数中指定线程ID
+!thread_work.getHandleById(.(线程ID) = 使用线程ID返回线程句柄\n不可关闭该句柄
+!thread_work.update(.(索引,参数) = 更新任务参数\该函数只能在each循环内部使用
+!thread_work.each = @for( idx,args in ??.each() ){
+	__/*遍历所有待执行任务,\n该函数会暂停所有任务*/
+}
+end intellisense**/

package/aardio/lib/time/ntp.aardio

@@ -0,0 +1,160 @@
+//ntp 网络时间同步
+import time.performance;
+import wsock.udp.client;
+import util.metaProperty;
+
+namespace time.ntp;
+
+class NtpTime {
+    ctor(){
+		this = {
+			INT seconds;
+			INT fraction;  
+			@_metaProperty
+		}
+		
+		this.time = ..time(,"!%c");
+    } 
+}
+
+NtpTime._metaProperty = ..util.metaProperty( 
+	time = {
+		_get = function(){  
+			if( owner.seconds === null ) return;
+			var tm = ..time( ..wsock.htonl(owner.seconds) - 2208988800/*1900~1970*/,"!%c" ); 
+			if(!tm) return;
+			tm.milliseconds = ..wsock.htonl(owner.fraction) / 4294967.296/* (2**32/1000) */; 
+			return tm;
+		}
+		_set = function( value ){
+			if(!..time.istime(value)) error("属性值不是time对象",2);
+			owner.fraction = ..wsock.ntohl( value.milliseconds * 4294967.296/* (2**32/1000) */ ); 
+			owner.seconds = ..wsock.ntohl( tonumber(value) + 2208988800/*1900~1970*/ ); 
+		} 	
+	}; 
+	size64 = function(){
+		return ..math.size64(owner.fraction,owner.seconds);
+	};
+	_tostring = function(){
+		return tostring(owner.time)
+	};
+)
+
+var NtpTime = NtpTime;
+class NTPData {
+    BYTE header = 2#00011011;
+    BYTE stratum = 1; 
+    BYTE poll = 1;  
+    BYTE precision = 1; 
+    INT rootDelay;
+    INT rootDispersion;
+    INT referenceIdentifier; 
+    struct referenceTimestamp = NtpTime();
+    struct originateTimestamp = NtpTime();
+    struct receiveTimestamp = NtpTime();
+    struct transmitTimestamp = NtpTime(); 
+}
+
+getData = function(server,port,timeout,sendData){
+	var udpClient = ..wsock.udp.client(); 
+	if(!server){
+		server = {"time1.aliyun.com";"time1.cloud.tencent.com";"time.apple.com"}
+	}
+	
+	var data = NTPData(); 
+	if(type(server)===type.table){
+		udpClient.setTimeouts( timeout : 2000,timeout : 2000);
+		
+		var connected;
+		for(i=1;#server;1){ 
+			if( udpClient.connect(server[i],port : 123) ){
+				data.server = server[i];
+				connected = true; 
+				break ;
+			}
+		}
+		
+		if(!connected){
+			return;
+		}
+	}
+	else {
+		data.server = server;
+		udpClient.setTimeouts( timeout : 3000,timeout : 3000);
+		if( !udpClient.connect(server,port : 123) ){ 
+			return null,..wsock.err.lasterr();
+		}
+	}
+	
+	if(sendData) ..table.assign( data,sendData);
+	
+	var tick = ..time.performance.tick(); 
+	if( !udpClient.sendto( ..string.concat(..raw.tostring(data),data[["authenticator"]]) ) ){
+		return null,wsock.err.lasterr();
+	} 
+	
+	var recvbuf = udpClient.recvfrom()
+	if( !recvbuf ){
+		return null,..wsock.err.lasterr();
+	}
+	udpClient.close();
+	
+	..raw.convert(recvbuf,data);
+	var r = data.receiveTimestamp.time;
+	var t = data.transmitTimestamp.time;
+	if(!(r&&t)) return null;
+	
+	var c = (tonumber(t) - tonumber(r))*1000 + ( t.milliseconds - r.milliseconds); 
+	data.delayMilliseconds = ( ..time.performance.tick() - tick - c ) / 2;
+	
+	var s,ms = ..math.modf( ( (data.delayMilliseconds + t.milliseconds) / 1000)  ); 
+	t.milliseconds = 0;
+	data.time = t.addsecond( s );
+	data.time.milliseconds = ms * 1000;
+	
+	if(data.time.year < 2019){
+		var sec = tonumber( ..time.iso8601("2036-02-07 06:28:15") )
+		data.time.addsecond(sec);
+	}
+	return data;
+}
+
+setprivilege('SeSystemtimePrivilege',true)
+updateSystemTime = function(tm){
+    if(tm){ return ::Kernel32.SetSystemTime(tm.utc()) }
+
+	var data = getData();
+	if(data && data.time ){
+		::Kernel32.SetSystemTime(data.time);
+		data.time.$updateDefault = data.time.update;
+		data.time.update = function() { owner.$updateDefault();updateSystemTime(owner) }
+		return data.time;
+	}
+}
+
+/**intellisense(time.ntp)
+getData(.("ntp服务器",端口,超时) = 除参数@1之外所有参数可选\n参数@1也可以用一个数组指定多个服务器,\n因为网络的不稳定性,该函数可能失败返回null
+getData() = !wsockNtpData.
+updateSystemTime() = 使用NTP服务器获取的时间校正系统时间,\n可选在参数中使用time对象指定要设置的时间\n需要以管理员权限启动当前进程,\n!time.
+end intellisense**/
+
+/**intellisense(!wsockNtpData)
+time = 报文返回后计算出的当前时间\n!time.
+header = 报文头
+stratum = 时钟的层数，定义了时钟的准确度。层数为1的时钟准确度最高，从1到16依次递减
+poll = 轮询时间，即发送报文的最小间隔时间 
+precision = 时钟的精度 
+rootDelay = 到主参考时钟的总往返延迟时间
+rootDispersion = 本地时钟相对于主参考时钟的最大误差
+referenceIdentifier = 参考时钟源的标识
+referenceTimestamp = 最后一次更新的时间
+originateTimestamp = 客户端报文发送时间
+receiveTimestamp = NTP服务器接收报文时间
+transmitTimestamp = NTP服务器报文发送时间
+delayMilliseconds = 服务端到客户端延时值\n毫秒
+referenceIdentifier.time = !time.
+referenceTimestamp.time = !time.
+originateTimestamp.time = !time.
+receiveTimestamp.time = !time.
+transmitTimestamp.time = !time.
+end intellisense**/

package/aardio/lib/time/ole.aardio

@@ -0,0 +1,179 @@
+//ole 时间对象
+import sys.locale.abbrevNames;
+
+namespace time;
+
+class ole {
+    ctor( value, ... ) {
+        var tm;   
+        if(type(value)==type.number){  
+        	tm = ..time( , ... );
+            if(! VariantTimeToSystemTime( value ,tm)  ) return;
+        }
+        elseif( ..time.istime(value) ){
+            tm = ..time( , ... );
+            ..table.assign(tm,value)
+            var format,locale = ...;
+            if(format!==null) tm.format=format;
+            if(locale!==null) tm.locale=locale;
+        };
+        else {
+        	tm = ..time( value, ... )
+        	var re,n = SystemTimeToVariantTime(tm,0)
+        	VariantTimeToSystemTime(n,tm) 
+        }
+        
+        ..table.assign(this,tm);
+        this.dayofyear = null;
+    }; 
+    
+    @_meta
+}
+ 
+namespace ole{
+ 
+	_meta = {  
+		_type = "time.ole.datetime";
+		_eq = function(b) {
+			return tonumber(owner) == tonumber(b)
+		};  
+    	_le = function(b) {
+			return tonumber(owner) <= tonumber(b)
+		} ; 
+		_lt = function(b) { 
+			return tonumber(owner) < tonumber(b)
+		};
+		addday = function(span){
+			return owner._fromnumber( tonumber(owner)+span )
+		} 
+		addhour = function(span){
+			return owner._fromnumber( ( tonumber(owner)*24 + span)/24 )
+		} 
+		addminute = function(span){
+			return owner._fromnumber( ( tonumber(owner)*1440 + span)/1440 )
+		} 
+		addsecond = function(span){
+			return owner._fromnumber( ( tonumber(owner)*86400 + span)/86400 )
+		}
+		update = function(){
+			return owner._fromnumber(   tonumber(owner) );
+		}
+		diffhour  = function(tm2){
+			return (tonumber(owner) -tonumber(tm2))  /24
+		} 
+		diffminute = function(tm2){
+			return (tonumber(owner) -tonumber(tm2)) /1440
+		} 
+		diffsecond= function(tm2){
+		   return (tonumber(owner) -tonumber(tm2))  /86400
+		}
+		diffday = function(tm2){
+			return (tonumber(owner) -tonumber(tm2))  
+		}
+		_fromnumber = function(n){
+			VariantTimeToSystemTime(n,owner);
+			return owner;
+		};
+		_tonumber = function(){
+			var tm = owner.local(true) : owner;
+        	var re,n = SystemTimeToVariantTime(tm,0)
+        	return n;
+    	};
+    	systemFormat = function(format,locale){
+    		if(!locale) locale = owner.locale;
+    		locale = locale ? ..sys.locale.abbrevNames[locale] : 0x0800 ;
+    		format = owner.toSystemFormat(format);
+    		
+    		var size = ::Kernel32.GetDateFormatW(locale,flags,owner,format,null,0);
+    		if( size > 0){
+    			var buf = ..raw.buffer((size-1)*2);
+    			if( ::Kernel32.GetDateFormatW(Locale,flags,owner,format,buf,size) )
+    				format = buf;
+    		}
+
+    		size = ::Kernel32.GetTimeFormatW(locale,flags,owner,format,null,0);
+    		if( size > 0){
+    			var buf = ..raw.buffer((size-1)*2);
+    			if( ::Kernel32.GetTimeFormatW(locale,flags,owner,format,buf,size) )
+    				return ..string.fromUnicode(buf);
+    		}
+    	};
+    	toSystemFormat = function(format){
+    		var f =..string.replace(format : owner.format,"\%(\w)",{
+				d ="dd";B ="MMMM";b ="MMM";m = "MM";y = "yy";Y = "yyyy";H = "HH";I = "hh";M = "mm";S = "ss";p = "tt";
+			});
+			if(f[1]=='!'#) f = ..string.right(f,-2);
+			return f;
+    	};
+    	_tostring = function(format,locale){
+    		return owner.systemFormat(format,locale);
+    	}; 
+    	_serialize = function(kernelCall){
+    		if(kernelCall){
+    			return ..string.format(`global.import('time.ole') : ..time.ole(%s,"%s")`,tonumber(owner), owner.format); 	
+    		}
+    		else {
+    			return ..string.format(`..time.ole(%s,"%s")`,tonumber(owner), owner.format); 
+    		}
+    	}
+	} 
+	 
+	..table.mix(_meta,{ _get =  _meta},..time._meta);
+	
+	now = function(){
+		return ..time.ole();
+	}
+	
+    ::OleAut32 := ..raw.loadDll("OleAut32.dll")
+    VariantTimeToSystemTime= ::OleAut32.api("VariantTimeToSystemTime","bool(double vtime,struct& lpSystemTime)");
+    SystemTimeToVariantTime= ::OleAut32.api("SystemTimeToVariantTime","bool(struct lpSystemTime,double&pvtime)");  
+}
+
+isole = function(v){
+	return v@ == ole._meta;
+}
+
+
+/*intellisense()
+time.ole(.(__,"%Y/%m/%d %H:%M:%S") = 创建OLE时间对象，返回对象可传入其他线程使用，\n参数@1可以是表示时间的数值、字符串、或time,time.ole 对象,\n也可以指定一个仅提供time对象的部分键值的表作为参数\n\n参数@2指定格式化串,首字符为!表示GMT时间\n\n可选使用@3指定对象的locale属性,即文本格式化语言,\nlocale支持的参数与setlocale相同,英文"enu",中文"chs"\n\n此对象继承自时间对象,所有功能相同,与time对象的区别是:\nOLE时间对象在输入数值或转换为数值是是以天数为单位的,而time对象以秒为单位.\nOLE时间对象支持从100年1月1日到9999年12月31日的时间,正数1899年12月30日算起的天数,\n小数部分是一天当中的片段时间,负数表示1899年12月30日之前的时间.\n\n注意：格式化为字符串时调用systemFormat格式化,请参考该函数说明
+time.ole() = !time_ole.
+time.ole.now() = !time_ole.
+time.ole = 数值运算支持从100年1月1日到9999年12月31日的时间\n正数1899年12月30日算起的天数，小数部分是一天当中的片段时间\n负数表示1899年12月30日之前的时间\n\n注意：格式化为字符串时调用systemFormat格式化,请参考该函数说明
+time.isole(__) = 检测参数中指定的值是否time.ole对象
+end intellisense*/
+
+/**intellisense(!time_ole)
+year = 年
+dayofweek = 星期\n星期一到星期六的值对应数值为1到6,星期日的值为 0,\n注意修改这个字段不会更新时间值,\n\n这个字段只有参与数值运算或调用 add*** 函数才会填充或更新,\n例如调用 addday(0) 会更新此字段
+day = 日
+month = 月
+hour = 小时
+minute = 分钟
+second = 秒
+milliseconds = 毫秒
+endstr = 文本解析为时间后，\n最后一个格式化标记解析成功并跳过空白字符以后的剩余的连续不含空白字符串，\n可用于后续解析iso8601等格式的时区（解析后将必须删除）。
+locale = 格式化时间使用的语言代码\n参数与setlocale相同,英文"enu",中文"chs",\n该属性为空表示使用当前默认语言
+format = @.format="%Y年%m月%d日 %H时%M分%S秒";\n//指定格式化串,首字符为!表示GMT时间
+local() = 将UTC时间转换为本地时间\n格式化串首字符为!表示UTF时间\n如果不是UTC时间直接返回\n返回自身\n
+local(true) = 将UTC时间转换为本地时间\n并创建一个新的时间对象返回\n如果不是UTC时间直接复制并返回\n不修改自身并返回新对象
+utc() = 将本地时间转换为UTC时间\n格式化串首字符为!表示UTF时间\n如果已经是UTC时间直接返回\n修改并返回自身\n
+utc(true) = 将本地时间转换为UTC时间\n并创建一个新的时间对象返回\n如果已经是UTC时间直接复制并返回\n不修改自身并返回新对象
+update() = 重新计算时间并更新dayOfWeek字段.\n
+addmonth(__/*输入数值*/) = 增加月份数,返回自身
+addday(__/*输入数值*/) = 增加天数,可以为负数,返回自身
+addsecond(__/*输入数值*/) = 增加秒数,可以为负数,返回自身
+addminute(__/*输入数值*/) = 增加分钟数,可以为负数,返回自身
+addhour(__/*输入数值*/) = 增加小时数,可以为负数,返回自身
+addmonth() = !time_ole.
+addday() = !time_ole.
+addsecond() = !time_ole.
+addminute() = !time_ole.
+addhour() = !time_ole.
+diffmonth(__/*指定datetime对象*/) = 计算两个time对象相差月份
+diffday(__/*指定datetime对象*/) = 计算两个time对象相差天数
+diffsecond(__/*指定datetime对象*/) = 计算两个time对象相差秒数
+diffminute(__/*指定datetime对象*/) = 计算两个time对象相差分钟数
+diffhour(__/*指定datetime对象*/) = 计算两个time对象相差小时数 
+systemFormat(.(格式化串,区域代码)= 使用系统格式化规则格式化时期,区域代码应使用3字母缩写\n不指定格式化串时获取format属性并转为系统时间格式化串,\n转换规则如下：\n"%y" -> "yy" 表示2位年份\n"%Y" -> "yyyy" 表示4位年份\n"%B" -> "MMMM" "" 表示月份全称\n"%b" -> "MMM" 表示月份缩写\n"%m" -> "MM" 表示2位月份\n"%d" -> "dd" 表示月份的第几天\n"%H" -> "HH" 表示2位24时制小时\n"%I" -> "hh" 表示2位12时制小时\n"%M" -> "mm" 表示2位分钟数\n"%S" -> "ss" 表示2分秒数\n"%p" -> "tt" 表示12时制显示上午或下午
+toSystemFormat(__) = 取参数指定的格式化串，或format属性指定的格式化串,\n转换为系统格式化语法并返回新的格式化串，不会修改原来的格式化串,\n转换规则如下：\n"%y" -> "yy" 表示2位年份\n"%Y" -> "yyyy" 表示4位年份\n"%B" -> "MMMM" "" 表示月份全称\n"%b" -> "MMM" 表示月份缩写\n"%m" -> "MM" 表示2位月份\n"%d" -> "dd" 表示月份的第几天\n"%H" -> "HH" 表示2位24时制小时\n"%I" -> "hh" 表示2位12时制小时\n"%M" -> "mm" 表示2位分钟数\n"%S" -> "ss" 表示2分秒数\n"%p" -> "tt" 表示12时制显示上午或下午\n\n注意不要直接修改format属性为系统格式化语法\n这会导致time.ole与time对象不能兼容转换
+end intellisense**/

package/aardio/lib/time/performance.aardio

@@ -0,0 +1,28 @@
+//performance 高性能计时器
+namespace time.performance;
+
+QueryPerformanceCounter := ::Kernel32.api("QueryPerformanceCounter","bool(struct &lpPerformanceCount)")
+QueryPerformanceFrequency := ::Kernel32.api("QueryPerformanceFrequency","bool(struct &lpPerformanceCount)")
+
+LARGE_INTEGER  = class{ 
+    long QuadPart;
+}
+var endf = LARGE_INTEGER();
+
+//此参数获取定时器每秒的震荡频率数
+var ok ,freq = QueryPerformanceFrequency( LARGE_INTEGER() );
+if(!ok)
+	error("系统不支持高性能计数器",2)
+	
+tick = function(){
+	var count = LARGE_INTEGER();
+	//获得当前系统频率记数器的震荡次数
+	if( QueryPerformanceCounter(count) ){
+		return ( count.QuadPart / freq.QuadPart) * 1000;
+	}
+}
+
+/**intellisense()
+time.performance.tick() = 返回高性能计时\n以毫秒(千分之一秒)为单位 
+time.performance = 高性能计时器,可精确到毫秒
+end intellisense**/

package/aardio/lib/time/timer.aardio

@@ -0,0 +1,32 @@
+//timer 计时器
+namespace time.timer{
+	import time.performance;
+	var performance_tick = time.performance.tick;
+	var tkBegin = 0;
+	var map = {}
+	
+	start = function(name="default"){
+		map[name] = {};
+		map[name].tkBegin = performance_tick() 
+	}
+	
+	endTick = function(name="default"){
+		var ret = performance_tick()  - map[name].tkBegin ; 
+		map[name] = null;
+		return ret;
+	}
+	
+	test = function( loop,f ){
+		var b = performance_tick(); 
+		for(i=1;loop;1){ 
+			f(); 
+		}
+		return (performance_tick()-b) / loop;
+	}
+}
+
+/**intellisense(time.timer)
+start("name__") = 创建一个名字为name的计时器\n调用time.timer.endTick("name")函数时终止计时器\n并返回所耗时间(毫秒)。
+endTick("name__") = 终止指定名字计时器\n并返回所耗时间(毫秒)。
+test = @.test( 5, \n	function(){\n		for(i=1;1000){\n			__/*输入测试代码*/\n		} \n	}\n)
+end intellisense**/

package/aardio/lib/time/zone.aardio

@@ -0,0 +1,97 @@
+//zone 时区转换
+namespace time.zone;
+
+class TIME_ZONE_INFORMATION {
+  int bias;
+  WORD standardName[32];
+  struct standardDate = ..time();
+  int standardBias;
+  WORD daylightName[32];
+  struct daylightDate = ..time();
+  int daylightBias;
+  formatBias = function(){
+  	var b = owner.bias : 0; 
+	var sig,b = b < 0 ? "+":"-", ..math.abs(b);
+	var s = b % 60
+	return sig + ..string.format("%02d:%02d",( b - s ) / 60, s);
+  }
+  toLocal = function(tm){
+  	if( ! ..time.istime(tm) ) tm = ..time().utc();
+  	
+  	var tmResult = ..time(); 
+  	tmResult.format="%Y-%m-%dT%H:%M:%S" +  owner.formatBias();
+  	
+	if( ::Kernel32.SystemTimeToTzSpecificLocalTime(owner,tm,tmResult) )
+		return tmResult;
+  }
+  toUtc = function(tm){
+  	if( ! ..time.istime(tm) ) tm = ..time();
+	
+	var tmResult = ..time(,"!%Y-%m-%dT%H:%M:%SZ");
+	if( ::Kernel32.TzSpecificLocalTimeToSystemTime(owner,tm,tmResult) )
+		return tmResult;	
+  } 
+  now = function(){
+  	var tm = ..time();
+  	::Kernel32.GetSystemTime(tm);
+  	return owner.toLocal(tm); 
+  } 
+} 
+ 
+getInfo = function(bias){
+	var zoneInfo = TIME_ZONE_INFORMATION()
+	if( bias ){ 
+		zoneInfo.bias = bias;
+		return zoneInfo;
+	}
+	
+	var zoneId = ::Kernel32.GetTimeZoneInformation(zoneInfo)
+	return zoneInfo,zoneId;
+}
+
+setInfo = function( info ){
+	info = ..table.assign( getInfo(),info); 
+	info.standardName = ..string.toUnicode(info.standardName); 
+	info.daylightName = ..string.toUnicode(info.daylightName); 
+	setprivilege('SeSystemtimePrivilege',true)
+	setprivilege('SeTimeZonePrivilege',true)
+	var ret = !!::Kernel32.SetTimeZoneInformation( info )
+	setprivilege('SeSystemtimePrivilege',false)
+	setprivilege('SeTimeZonePrivilege',false)
+	return ret;
+} 
+
+toLocal = function(tm,bias){
+	if( ! ..time.istime(tm) )  error("参数错误",2) 
+	return getInfo(bias).toLocal(tm);
+}
+
+toUtc = function(tm,bias){
+	if( ! ..time.istime(tm) )  error("参数错误",2) 
+	return getInfo(bias).toUtc(tm);
+}
+
+/**intellisense(time.zone)
+getInfo() = 返回当前时区信息\n!time_zone_info.
+toLocal(.(时间对象,时差) = 参数一为time对象,\n时差以分钟为单位,默认取当前时区时差\n应用ISO 8601格式
+toUtc(.(时间对象,时差) = 参数一为time对象,\n时差以分钟为单位,默认取当前时区时差\n应用ISO 8601格式
+toLocal() = !time.
+toUtc() = !time.
+setInfo(zoneInfo) = @.setInfo( bias = -480 )
+end intellisense**/
+
+/**intellisense(!time_zone_info.)
+toLocal(.(时间对象) = UTC时间转换为区域时间\n省略参数则使用当前时间\n应用ISO 8601格式
+toUtc(.(时间对象) = 区域时间转换为UTC时间\n省略参数则使用当前时间\n应用ISO 8601格式
+toLocal() = !time.
+toUtc() = !time.
+now() = 当前时间\n!time.
+formatBias() = 格式化如：+08:00
+bias = 时差
+standardName = 时区名
+standardDate = 当前时间\n!time.
+standardBias = 标准时差
+daylightName = 夏令时区名
+daylightDate = 夏令时\n!time.
+daylightBias = 夏令时差
+end intellisense**/