aview-app 1.0.2

package/aardio/lib/fsys/stream.aardio

@@ -0,0 +1,276 @@
+//stream 文件流
+import util.metaProperty;
+import com.interface.IStream;
+namespace fsys;
+
+class stream{
+	ctor( str,len,grfMode){   
+		if( type(str) == "pointer" ){
+			this.stream = ..com.interface(str,..com.interface.IStream );
+			if(len) ..com.Release(str);
+		}
+		elseif( type(len) == type.string ){
+			var mode = len;
+			var grfMode = 0;
+			var f=mode[1];
+			var seekend;
+			
+			if(grfMode===null) grfMode = 0x00000020/*STGM_SHARE_DENY_WRITE*/
+			if( f='r'# ) { 
+				grfMode |= 0/* _STGM_READ*/
+			}
+			else {  
+				if( f='w'#  ) {
+					grfMode |= 0x00001000/*STGM_CREATE*/ | 1/*STGM_WRITE*/;
+					if( ..io.exist(str) ) ..io.remove(str)
+				}
+				else{ 
+					grfMode |=  1/*STGM_WRITE*/
+					if(! ..io.exist(str) ) grfMode |= 0x00001000/*STGM_CREATE*/;
+					seekend = true;
+				}
+			}
+			
+			if(..string.indexAny(mode,"+") ){ 
+				grfMode = grfMode | 2/*STGM_READWRITE*/; 
+			} 
+			
+			var ppstm = {ptr pIStream}
+			var hr = ::Shlwapi.SHCreateStreamOnFileW(..io.fullpath(str), grfMode,ppstm);
+			if(  (hr)<0/*_FAILED*/ ) return;
+			this.stream = ..com.interface(ppstm.pIStream,..com.interface.IStream) 
+			..com.Release(ppstm.pIStream);
+			
+			if(seekend)this.stream.Seek(0,0x2/*_FILE_END*/,0);
+		} 
+		else{
+			var hMemory;
+			if( str || len ){
+				if(!len) len = #str;
+				len = ..math.max(len,#str) 
+				hMemory= ::GlobalAlloc( 0x2 /*_GMEM_MOVEABLE*/, len);
+				if( str ){
+					var pMemory=::GlobalLock(hMemory);
+					::CopyMemory(pMemory,str,len);
+					::GlobalUnlock(hMemory); 
+				}
+			}
+			
+			var hr,pIStream = ::CreateStreamOnHGlobal(hMemory, true/*GlobalFree*/); 
+			if(  (hr)<0/*_FAILED*/ ) return;
+		    this.stream = ..com.interface(pIStream,..com.interface.IStream) 
+			..com.Release(pIStream);
+		}
+		this.__isIStream = true;
+	};
+
+	@_metaProperty;
+}
+namespace stream{
+
+	_metaProperty = ..util.metaProperty(
+		close = function(){
+			if(owner.stream){
+				..com.Release(owner.stream);
+				owner.stream = null;
+			} 
+		};
+		readAll = function(){
+			owner.reset();
+			return owner.read(-1);
+		};
+		read = function(len){
+			if( len === null ){
+				var d = {};
+				while( 
+			    	var hr,s,size;
+			    	hr,s,size = owner.stream.Read(1,1,0); 
+			    	( (hr)>=0/*_SUCCEEDED*/ && size )
+				) {
+					if( s == '\n' ) return ..string.join(d);
+					if(s!='\r')..table.push(d,s);
+				}
+				return; 
+			}
+			if( len[["_struct"]] ){
+					var t = len;
+					var len =  ..raw.sizeof(t)
+					var hr,s,size = owner.stream.Read(len,len,0);
+					if(  (hr)>=0/*_SUCCEEDED*/ ) { 
+						if(size == len) return ..raw.convert(s,t);
+					}
+					return;
+				}
+					
+			if( len < 0 ) len = ( owner.size() - owner.seek() ) + len + 1; 
+			var hr,s,size = owner.stream.Read(len,len,0);
+			if(  (hr)>=0/*_SUCCEEDED*/ ) { 
+				if(size != len)return ..string.left(s,size);
+				return s;
+			}
+		};
+		readTo = function(ends){  
+			if( type(ends)!="string" || (!#ends) ) error("参数错误",2);
+			var lends = #ends; 
+			var bytes = {}  
+			var push = ..table.push;
+			while( 
+				var hr,byte,size;
+				hr,byte,size = owner.stream.Read(1,1,0);
+				(  (hr)>=0/*_SUCCEEDED*/ ) && size 
+			) {    
+				push(bytes,byte); 
+				if( byte == ends[[lends]]){ 
+					var l = #bytes;
+					for(i=lends-1;1;-1){ 
+						if( ends[[i]] != bytes[l-lends + i ] ){ 
+							continue 2;
+						} 
+					}
+					..table.pop(bytes,lends);
+					return ..string.join(bytes); 
+				}  
+			}
+		}; 
+		readBuffer = function(buf,len){
+			if(len===null) len=#buf;
+			var hr,s,size = owner.stream.Read(buf,len,0);
+			if(  (hr)>=0/*_SUCCEEDED*/ ) {  
+				return size;
+			}
+		}; 
+		write = function(str,len){
+			if( str[["_struct"]]) str = ..raw.buffer(str); 
+			
+			if(!len) len = #str;
+			var hr,len = owner.stream.Write(str,len,0);
+			if(  (hr)>=0/*_SUCCEEDED*/ ){ 
+				var cur = owner.seek(); 
+				if( cur > owner.size() ) owner.setSize(cur);
+				return len;
+			}
+		};
+		writeBuffer = function(buf,len){
+			if(len===null) len=#buf;
+			var hr,len = owner.stream.Write(buf,len,0);
+			if(  (hr)>=0/*_SUCCEEDED*/ ){ 
+				var cur = owner.seek(); 
+				if( cur > owner.size() ) owner.setSize(cur);
+				return len;
+			}
+		}; 
+		seek = function(org="cur",move=0){
+			var hr,pos = owner.stream.Seek(move,_seekMode[org],0);
+			if(  (hr)>=0/*_SUCCEEDED*/ ) return pos;
+		};
+		setSize = function(size){
+			var hr,pos = owner.stream.SetSize(size);
+			if(  (hr)>=0/*_SUCCEEDED*/ ) return size;	
+		};
+		stat = function(flag  = 0/*_STATFLAG_DEFAULT*/ ){
+			var hr,s = owner.stream.Stat( STATSTG(),flag);
+			if(  (hr)>=0/*_SUCCEEDED*/ ) return s;
+		};
+		size = function(){
+			var c = owner.seek();
+			var len = owner.seek("end",0);
+			owner.seek("set",c);
+			return len; 
+		}; 
+		reset = function(){
+			owner.seek("set",0);
+			return owner;
+		};
+		commit = function(flag){
+			owner.stream.Commit(flag:0);
+		};
+		revert = function(flag){
+			return owner.stream.Revert(flag:0);
+		}
+		flush = function(){
+			owner.stream.Commit(flag:0);
+		};
+		lockPointer = function(){
+			var hr,handle = ::GetHGlobalFromStream(owner.stream);    
+			if( (hr)<0/*_FAILED*/ ) return;
+			if( !handle ) return;
+			var size = ::GlobalSize(handle);
+			var ptr = ::GlobalLock(handle); 
+			return ptr,size;
+		};
+		unlockPointer = function(){
+			var hr,handle = ::GetHGlobalFromStream(owner.stream);    
+			if( (hr)<0/*_FAILED*/ ) return;
+			if( !handle ) return;
+
+			return !::GlobalUnlock(handle); 
+		};
+		_topointer = function(){
+			return owner.stream;
+		};
+		_serialize = function(kernelCall){
+			 return "null"
+		}
+		_type="fsys.stream";
+	)
+	::Shlwapi  := ..raw.loadDll("Shlwapi.dll");
+	
+	_seekMode = {
+	 	["cur"] = 0x1/*_FILE_CURRENT*/;
+	 	["end"] = 0x2/*_FILE_END*/;
+	 	["set"] = 0x0/*_FILE_BEGIN*/;
+	} 	
+	
+	class STATSTG {
+  		pointer pwcsName;
+  		INT type;
+  		LONG cbSize;
+  		struct mtime = ::FILETIME();
+  		struct ctime = ::FILETIME();
+  		struct atime = ::FILETIME();
+  		INT grfMode;
+  		INT grfLocksSupported;
+  		struct clsid = ..win.guid();
+  		INT grfStateBits;
+  		INT reserved;
+	}
+}
+
+/**intellisense()
+fsys.stream = 文件流对象\n兼容IStream,ISequentialStream接口
+fsys.stream( = 创建文件流对象,返回对象可传入其他线程使用。
+fsys.stream(.(IStream接口指针) = 直接使用指针创建对象
+fsys.stream(.(IStream接口指针,true) = 直接使用指针创建对象,该指针的COM引用计数减一\n注意对象自身会增加COM引用计数并在释放时移除
+fsys.stream(.(初始化数据,缓冲区长度) = 创建内存流文件,所有参数可选\n可选使用参数@3指定选项,此参数请参考库源码
+fsys.stream(.("文件路径","r+") = 读写模式打开文件流,文件必须存在\n注意流对象总是以二进制模式读写，不需要添加b标记
+fsys.stream(.("文件路径","w") = 只写模式打开文件流,创建新文件清空原文件\n注意流对象总是以二进制模式读写，不需要添加b标记
+fsys.stream(.("文件路径","w+") = 读写模式打开文件流,创建新文件清空原文件\n注意流对象总是以二进制模式读写，不需要添加b标记
+fsys.stream(.("文件路径","a") = 只写追加模式打开文件流,创建新文件保留原文件
+fsys.stream(.("文件路径","a+") = 读写追加模式打开文件流,创建新文件保留原文件\n注意流对象总是以二进制模式读写，不需要添加b标记
+fsys.stream() = !fsys_stream.
+!fsys_stream.read( = 读数据
+!fsys_stream.read(.(-1) = 参数指定读取长度,-1为读到尾部\n参数也可以指定一个结构体用于填充读取的数据,\n无参数读取一行
+!fsys_stream.readAll() = 移到指针到文件头\n读取到文件尾返回所有数据
+!fsys_stream.readTo( = 读取直到以指定的字符串结束
+!fsys_stream.readTo(.('结束串') = 读取直到以指定的字符串结束,返回值不包含结束串,\n该函数每次仅读取一个字节,效率较低
+!fsys_stream.size() = 得到数据长度
+!fsys_stream.write( = 写数据
+!fsys_stream.write(.(数据,长度) = 写入数据\n参数@1可使用字符串、buffer、指针、结构体等\n如果指定指针就必须明确指定写入长度
+!fsys_stream.readBuffer(.(buffer,读取长度) = 读取数据到 buffer,\n参数@1应是 buffer 对象,参数@2省略则默认为缓冲区长度
+!fsys_stream.writeBuffer(.(buffer,读取长度) = buffer 写入流,\n参数@1应是 buffer 对象,参数@2省略则默认为缓冲区长度
+!fsys_stream.seek("end") = 移动指针至结束处
+!fsys_stream.seek("end",__) = 移动至相对结束处的指定偏移量
+!fsys_stream.seek() = 得到当前位置
+!fsys_stream.seek("cur",__) = 移动至相对当前位置的指定偏移量
+!fsys_stream.seek("set") = 移动指针到开始
+!fsys_stream.seek("set",__) = 移动至相对开始处的指定偏移量
+!fsys_stream.reset() = 文件指针移动到开始\n类似seek(0,"set"),不同的是此函数返回对象自身\n!fsys_stream.
+!fsys_stream.close() = 关闭对象
+!fsys_stream.stat() = 返回流状态\n返回值为STATSTG结构体\n!fsysstramSTATSTG.
+!fsys_stream.flush() = 提交更改\n兼容aardio标准流接口
+!fsys_stream.commit(.(flags) = 提交更改 
+!fsys_stream.revert() = 撤消更改
+!fsys_stream.lockPointer() = 如果这是一个内存流,\n锁定内存并返回内存指针，内存长度,\n需要使用对象的unlockPointer()成员函数解锁内存\n写入内存流可能导致重新分配内存,所以返回的指针可能会变动
+!fsys_stream.unlockPointer() = 解锁内存\n用lockPointer函数获取内存指针使用以后，必须调用此函数
+!fsysstramSTATSTG.cbSize = 文件长度
+end intellisense**/ 

package/aardio/lib/fsys/streamInfo.aardio

@@ -0,0 +1,47 @@
+//streamInfo 命名数据流
+import fsys.file;
+
+namespace fsys
+
+class streamInfo{
+	ctor(...){
+ 		var file,err = ..fsys.file(...);
+ 		if(!file) return null,::GetLastError();
+ 			
+		var infoBlock = ..raw.buffer(96 * 1024);
+		var status = ::Ntdll.NtQueryInformationFile(file, { addr Status; INT Information; } 
+			, infoBlock,#infoBlock,22/*FileStreamInformation*/);
+			
+		if( 0 != status ) {
+			file.close();
+			return null,status;
+		}
+			
+		var pInfo = ..raw.toPointer(infoBlock);
+		do{
+			var info = ..raw.convert(pInfo, {
+  				INT nextEntryOffset;
+  				INT streamNameLength;
+  				LONG streamSize;
+  				LONG streamAllocationSize;
+			} )
+			
+			if(info.streamNameLength){
+				var name = ..string.fromUnicode(topointer(pInfo,24),,info.streamNameLength/2)	
+				..table.push(this,name);	
+			}
+		
+			pInfo = info.nextEntryOffset ? topointer(pInfo,info.nextEntryOffset) : null
+		}while(pInfo);
+		
+		file.close();
+	}; 
+	@{_type="array"}
+}
+
+/**intellisense()
+fsys.streamInfo = 用于获取文件或目录的全部数据流名称,\nNTFS 文件系统支持  Alternate Data Streams 特性,\n允许同一文件或目录附加存储多个命名数据流,\n普通读写文件默认访问的是主数据流（未命名流）,\n\n备用数据流（命名流）默认是不可见的，\n通过在文件名后 + ":" + "流名称" 可读写命名数据流
+fsys.streamInfo( = 用于获取文件或目录的全部数据流名称,\n成功返回数组,失败返回 null,错误代码,\n如果传入不存在或非NTFS分区的文件路径则返回 null\n\n因为#操作符可用于null或数组,\n可用#操作符判断是否存在命名数据流
+fsys.streamInfo(.(path) = 用于获取文件或目录的全部数据流名称,\n@path 参数指定文件或目录路径,\n成功返回数组,失败返回 null,错误代码
+fsys.streamInfo(.(path,mode,shareMode,creation,flagsAndAttributes,secAttrib) = 用于获取文件或目录的全部数据流名称,\n@path 参数指定文件或目录路径,\n\n其他所有参数与 fsys.file 相同,\n一般不必指定这些参数
+end intellisense**/

package/aardio/lib/fsys/table.aardio

@@ -0,0 +1,102 @@
+//table 配置表
+import fsys;
+import util.metaProperty
+namespace fsys;
+
+class table{ 
+	ctor( file,dt ){
+		this@ = ( 
+			..util.metaProperty(
+				load = function(){
+					for(k,v in this){ 
+						if( ( (type(k)!="string") || (k[1]!='_'#) )  && type(v) != type.function )   
+							this[k] = null;
+					}
+					var s = ..string.load(file);
+					
+					if(#s){
+						if(  ! ( s[1] == 0xEF  && s[2] == 0xBB && s[3] == 0xBF )  ) {
+							s = ..string.fromto(s,0,65001);
+						} 
+		
+						var ok,t = call(eval,,s);
+						if(! (ok && t) ) {
+							error(t,2)
+						}
+						..table.assign(this,t );
+					} 
+					if( type(this.afterLoad) == type.function ) this.afterLoad();
+					return this;
+				};
+				afterLoad = function(){};
+				save  = function(){
+					if( type( this.beforeSave ) == "function"  ){
+						this.beforeSave();
+					}
+					
+					var str = ..table.tostring(this)
+					if( !..io.exist(file) )
+						..fsys.createParentDir(file);
+					
+					/*
+					fsys.table 并非实时读写，而是将配置读入内存。
+					所以请不要多对象、多线程、多进程打开基于 fsys.table 或 fsys.config 的配置文件。
+					这会导致多份不同步的配置指向同一文件，读写时可能会相互覆盖。
+					
+					多对象、多线程、多进程共享配置文件时，应改为实时读写配置文件，
+					并尽量多读少写，避免同时写，同时写出现冲突请参考下面的代码重试。
+					*/
+					for(i=1;3;1){
+						var file = ..io.open(file,"w+",0x20 /* _SH_DENYWR */ );
+						if(file){
+							file.write('\xEF\xBB\xBF');
+							file.write( str );
+							file.close();
+							
+							return this;
+						}
+						sleep(100);
+					}
+				};
+				beforeSave = function(){};
+				mixin = function(...){
+					..table.assign(this,...);
+					this.save();
+					return this;
+				};
+				mix = function(...){
+					..table.mix(this,...);
+					return this;
+				};  
+				update = function(){ };
+				_tostring = function(){
+					return ..table.tostring(this)
+				} 	
+			) 
+		);
+		
+		var s = ..string.load(file);
+		if( s ) {
+			..table.assign(this,eval( s ) )	
+		};
+		if( dt ) {
+			..table.mix(this,dt);
+		};	
+		..table.gc( this,"save" );
+	}; 
+} 
+ 
+/**intellisense()
+fsys.table = 支持将 table 对象自动序列化为硬盘文件。\nfsys.table 可作为普通 table 对象使用，\n在线程退出时将会同步存储到文件中。\n\n一般建议直接使用 fsys.config
+fsys.table(.("/config/setting->table",默认配置表 ) = 创建 table 对象，在线程退出时将会同步存储到文件中。\n可选使用 参数@2 指定一个 table 对象指定字段的默认值。\n\nfsys.table 并非实时读写，而是将配置读入内存。\n所以请不要多对象、多线程、多进程打开同一配置文件。\n这会导致多份不同步的配置写入存储设备时会相互覆盖。\n\n注意此对象不可跨线程传递。\n多线程可通过 winform 成员函数转发到界面线程操作配置文件即可，\n多进程可利用原子窗体、进程互斥体避免冲突
+fsys.table() = !fsys_table.
+!fsys_table.load() = 从文件载入\n加载成功返回对象,加载失败返回null空值\n!fsys_table.
+!fsys_table.save() = 存储到文件\n在线程退出时也会自动调用该函数\n!fsys_table.
+!fsys_table.afterLoad = 指定一个函数,在下次重新加载配置文件时调用\n此函数默认为空函数,在调用 winform.bindConfig 后会被自动赋值用于写入控件值
+!fsys_table.beforeSave = 指定一个函数,在保存配置以前自动调用\n此函数默认为空函数,在调用 winform.bindConfig 后会被自动赋值用于读取控件值
+!fsys_table.assign(混入表) = @.mixin(\n   键名 = 值__;\n   键名2 = 值;\n);//该数会自动调用save函数保存配置到文件
+!fsys_table.mix(混入默认值表) = @.mix(\n   键名 = 默认值__;\n   键名2 = 默认值;\n);//该函数用于设定默认值,但不会修改已存在的值
+!fsys_table.assign() = !fsys_table.
+!fsys_table.mix() = !fsys_table.
+!fsys_table.? = 自配置文件读写属性。\n使用 table.tostring 函数序列化配置表。\n\n仅序列化以字符串、数值为键的元素，\n仅序列化值为字符串、数值、buffer 以及定义了 _serialize 元方法的成员。\n循环引用的值转换为 null，序列化时忽略成员函数。\n\n配置文件在首次使用时自动加载,退出程序时自动保存.
+end intellisense**/

package/aardio/lib/fsys/tar.aardio

@@ -0,0 +1,181 @@
+//tar 文件打包
+import zlib;
+import fsys;
+import fsys.file;
+import fsys.time;
+namespace fsys;
+
+class tar {
+
+	ctor( tarPath,rootDir ){
+	
+		var tarFile;
+		if( rootDir ){
+			rootDir = ..io.exist(rootDir);
+			if(!rootDir) return null,"错误的根目录路径";
+		} 
+		 
+		if( ! (tarPath?..fsys.createParentDir(tarPath) ) )
+			return null,"存储路径错误";
+		 
+		if( ..string.match(tarPath,"<.gz>|<.tgz>$") ){
+			tarFile = ..zlib.gzFile(tarPath,"wb")
+		}
+		else {
+			tarFile = ..io.open(tarPath,"w+b",0x10)
+		}
+		
+		if(!tarFile) return null,"创建tar文件失败";
+
+		var tarHeader = tar_header();
+		var buffer = ..raw.buffer(512);
+		var zeroBuffer = ..raw.buffer(512,0);
+		
+		..table.gc(this,"close");
+	};
+	
+	addFile = function(path) {
+	
+		path = ..io.exist(path);
+		if(!rootDir) rootDir = ..fsys.getParentDir(path);
+		
+		var name = path ? ..fsys.path.relative(path,rootDir,false);
+		if(!name) error("文件路径错误",2); 
+		name = ..string.replace( name,"@\", "/" ); 
+
+		tarHeader.name = this.utf8 ? name : ..string.fromto(name,65001,0);
+
+		var file = ..fsys.file(path,"rb");
+		if(!file) error("读取文件失败:" + path,2)
+		
+		tarHeader.linkflag = '0'#; 
+		var size = file.size(1);
+		tarHeader.size = ..string.format('% 11o ',( file.size(1) )  );
+		tarHeader.mtime = ..string.format('% 10o \0',tonumber( file.getFileTime().write.toSystemTime().local() ) ); 
+		tarHeader.mode =  ..string.format('% 6o \0',0100777);
+		
+		tarHeader.chksum = checksum(tarHeader);
+		tarFile.write(tarHeader);
+		if( this.onWriteFile) this.onWriteFile(name); 
+		
+		var readSize = file.readBuffer(buffer,512);
+		while( readSize ){
+			if( this.onWriteFileBock ) this.onWriteFileBock(name,readSize,size);
+			
+			tarFile.writeBuffer( buffer,readSize );
+			if( readSize < 512 ){
+				tarFile.writeBuffer( zeroBuffer,512 - readSize ); 
+				break;
+			}
+			readSize = file.readBuffer(buffer,512);
+		} 
+		
+		file.close();
+	}
+	addFolder = function(path){
+		
+		path = ..io.exist(path); 
+		if(!rootDir) rootDir = ..fsys.getParentDir(path);
+	
+		var name = path ? ..fsys.path.relative(path,rootDir,false);
+ 		if(!name) error("文件路径错误",2); 
+		name = ..string.replace( name,"@@\", "/" ); 
+		
+		if( name[#name] != '/'# ) name = name + "/"; 
+		tarHeader.name = this.utf8 ? name : ..string.fromto(name,65001,0);
+		
+		tarHeader.linkflag = '5'#;
+		tarHeader.size = ..string.format('% 11o ',0); 
+		tarHeader.mode =  ..string.format('% 6o \0',040777); 
+		var file = ..fsys.file(path,,,,0x2000000/*_FILE_FLAG_BACKUP_SEMANTICS*/);
+		tarHeader.mtime = ..string.format('% 10o \0',tonumber( file.getFileTime().write.toSystemTime().local() ) ); 
+		file.close();
+		  
+		tarHeader.chksum = checksum(tarHeader);
+		tarFile.write(tarHeader); 
+		if( this.onWriteDir) this.onWriteDir(name); 
+	} 
+	pack = function(path,pattern,selfName=true){
+		if( !rootDir ){
+			if(selfName){
+				rootDir = ..fsys.getParentDir(path);
+				this.addFolder(path);
+			}
+			else {
+				rootDir = path;	
+			}
+		}
+		
+		..fsys.enum( path,pattern,function(dir,filename,fullpath,findData){ 
+			..io.print(fullpath)
+			if(filename) this.addFile(fullpath);
+			else this.addFolder(fullpath);
+		} );
+	};
+	close = function(){
+		if( tarFile ){
+			if( tarFile.seek() ){
+				tarFile.writeBuffer( zeroBuffer,512 );
+				tarFile.writeBuffer( zeroBuffer,512 );
+			}
+			tarFile.close();
+			tarFile = null;
+		}
+	}
+}
+
+namespace tar {
+
+	class tar_header{
+	
+		byte name[100];
+		byte mode[8];
+		byte uid[8] = '     \x30 \0';
+		byte gid[8] = '     \x30 \0';
+		byte size[12];
+		byte mtime[12];
+		byte chksum[8];
+		byte linkflag;
+		byte linkname[100];
+		byte magic[8];
+		byte uname[32];
+		byte gname[32];
+		byte devmajor[8];
+		byte devminor[8];
+		byte prefix[155];
+		byte data[12]
+	}
+	
+	var __nchkshum_fileds = { byte chksum[8]={};byte linkflag = 1 }
+	checksum = function(tarHeader){ 
+		var chksum = 0x100 + tarHeader.linkflag ;
+		for(k,v in tarHeader){
+			if( v ? ( ! __nchkshum_fileds[k] ) ){
+				for(i=1;#v ){
+					chksum = chksum + v[i];
+				} 
+			} 
+		} 
+		return ..string.format('% 6o \0', chksum  )
+	}
+}
+
+/**intellisense()
+fsys.tar = tar文件打包
+fsys.tar(.("tar文件路径","打包根目录") = 参数一可以是tar文件或tar.gz文件路径,\n如果省略根目录参数,打包首个文件则取其父目录为根目录
+fsys.tar() = !fsys_tarfile.
+!fsys_tarfile.utf8 = 是否使用UTF8编码文件名
+!fsys_tarfile.pack(.(目录路径,文件通配符,是否添加该目录名字) = 打包目录下的所有文件
+!fsys_tarfile.addFile(.("文件路径") = 添加文件,\n必须是指定根目录下的文件
+!fsys_tarfile.addFolder(.("文件路径") = 添加文件,\n必须是指定根目录下的子目录
+!fsys_tarfile.close() = 关闭文件
+!fsys_tarfile.onWriteFileBock = @.onWriteFileBock = function( filename,writeSize,fileSize){
+	io.print( filename,writeSize,fsys.formatSize(fileSize) );__/*写入文件块回调函数*/
+}
+!fsys_tarfile.onWriteDir = @.onWriteDir = function( filename ){
+	__/*添加目录回调函数*/
+}
+!fsys_tarfile.onWriteFile = @.onWriteFile = function( filename ){
+	__/*添加目录回调函数*/
+}
+end intellisense**/