aview-app 1.0.2

package/aardio/lib/fsys/mmap/_.aardio

@@ -0,0 +1,233 @@
+import fsys.file;
+import util.metaProperty;
+import sys.info;
+namespace fsys;
+
+class mmap {
+
+	ctor( path,name,lowSize,hiSize,access,protect,secAttrib  ){
+		var targ1 = type(path);
+		if( targ1 == "pointer" )   {
+			this.hFileMapping	= path;
+			if(name===true)..table.gc( this,"close" );
+		}
+		else{
+			if(access===null) access = 0x2/*_FILE_MAP_ALL_ACCESS*/;
+			if(protect===null) protect = 0x4/*_PAGE_READWRITE*/;
+			
+			this.name = name;
+			this.hFileMapping = name ? topointer( ::Kernel32.OpenFileMapping(access,false,name) );
+			if(!this.hFileMapping) {
+			    if(hiSize===null){
+			    	if(lowSize!==null) lowSize,hiSize = ..math.size64(lowSize).split32();
+			    }
+			    
+				if( path ){
+					var file,err = path;
+					if( ! ..fsys.file.is(path) ){ 
+						file,err = ..fsys.file( path
+							,..io.exist(path) ? "r+b" : "w+b"
+							,3/*_FILE_SHARE_READ | _FILE_SHARE_WRITE*/,,,secAttrib);
+					};
+					if(!file) return null,err;
+					
+					if((lowSize===null) && (hiSize===null) ){
+						if( file.size64() == ..math.size64(0)){
+							lowSize=0x4000000;
+						};
+					};
+					
+					this.hFileMapping = topointer( ::Kernel32.CreateFileMappingW( file.handle,secAttrib,protect,hiSize:0,lowSize:0,name) );
+					file.close(); 
+				}
+				else {
+					if((lowSize===null) && (hiSize===null) ){
+						lowSize=0x4000000;
+					};
+					this.hFileMapping = topointer( ::Kernel32.CreateFileMappingW( _INVALID_HANDLE_VALUE,secAttrib,protect,hiSize:0,lowSize:0,name) ); 
+				}
+				
+				if(!this.hFileMapping) {
+					this.hFileMapping = name ? topointer( ::Kernel32.OpenFileMapping(access,false,name) );
+					if(!this.hFileMapping) return null,..lasterr(); 
+					else this.conflict = "该映射文件已存在";
+				}
+			}
+			else {
+				this.conflict = "该映射文件已存在" 
+			}
+			..table.gc(this,"close");
+		}
+		
+		this.offset = ..math.size64(0); 
+		this.ptr2map = {};
+	}
+	@_metaProperty;  
+}
+
+namespace mmap {
+	_metaProperty = ..util.metaProperty( 
+		close = function(){
+			for(ptr,hMap in owner.ptr2map){ 
+				UnmapViewOfFile(hMap);
+				owner.ptr2map[ptr] = null;
+			}
+			if( owner.hFileMapping ){
+				..raw.closehandle(owner.hFileMapping);
+				owner.hFileMapping = null;
+			};
+		};
+		seek = function(mode,off,hiOff){
+			if( mode === null ) {
+				mode = "cur";
+			}
+			if( mode == "set"){ 
+				owner.offset.reset(0);
+				if( off ?  off < 0 ) error("错误的指针地址",2);
+			}
+			if( hiOff === null ){
+				if( !off && mode == "cur") return owner.offset;  
+				owner.offset.add( off );  
+			}
+			else {
+				owner.offset.add( ..math.size64(off,hiOff) ); 	
+			} 
+		}
+		mapView = function(len){
+	    	offsetReal =  tonumber( owner.offset % __allocationGranularity ); 
+	    	offsetMap = owner.offset - offsetReal; 
+	
+	    	var lowOffsetMap,hiOffsetMap = offsetMap.split32();
+			var hMap = topointer( ::Kernel32.MapViewOfFile( owner.hFileMapping,0x2/*_FILE_MAP_ALL_ACCESS*/,hiOffsetMap,lowOffsetMap,len + offsetReal ) );
+			if( hMap ){
+				owner.offset.add(len);
+				var ptr =  topointer(hMap,offsetReal);
+				if( owner.ptr2map[ptr] ){
+					owner.unmapView(ptr);
+				}
+				owner.ptr2map[ptr] = hMap;
+				return ptr; 
+			} 
+		};
+		unmapView = function(ptr){
+			var hMap = owner.ptr2map[ptr];
+			if(!hMap) error("错误的内存地址参数",2);
+			var ret = ::Kernel32.UnmapViewOfFile(hMap);
+			owner.ptr2map[ptr] = null;
+			return ret;
+		};
+		read = function(len){ 
+			var tArg = type(len);
+			if( tArg !=type.number){  
+				if( tArg == type.table && len[["_struct"]] ){
+					var s = len;
+					var l =  ..raw.sizeof(s)
+					
+					var p = owner.mapView(l);
+					if( p ){  
+						..raw.convert(p,s);
+						owner.unmapView(p);
+						return s;
+					} 
+					return;
+				}
+				error("参数不正确",2)
+			} 
+			if(len<0) {
+				error("参数不正确",2);
+			} 
+			var p =  owner.mapView(len)
+			if( p ){  
+				var r = ..raw.tostring(p,1,len);
+				owner.unmapView(p);
+				return r;
+			};
+				
+			return null,..lasterr(); 
+		}
+		write = function(s,l){ 
+			var st = type(s);
+			
+			if( st == "table") {
+				if( s._struct ){ 
+					var l =  ..raw.sizeof(s);
+					var p = owner.mapView(l);
+					if( p ){
+						::CopyMemoryByStruct(p,s,l);
+						owner.unmapView(p);
+						return true,l;
+					} 
+					else {
+						return false;
+					} 	
+				}
+				else return false;
+			} 
+			elseif( st == "number")
+				s = tostring(s);
+			
+			if(l===null) l = #s;
+			var p = owner.mapView(l);
+			if( p ){ 
+				::CopyMemory(p,s,l);
+				owner.unmapView(p);
+				return true,l;
+			}
+			
+			return false,..lasterr();
+		};
+		writeTable = function(tab){
+			var s = ..table.tostring(tab,true);
+			owner.write( {INT len=#s} );
+			owner.write(s);
+		};
+		readTable = function(){
+			var st = owner.read({INT len});
+			if( st && st.len){
+				var s = owner.read(st.len);
+				if(s) {
+					var r,t = call(eval,,s);
+					if( r ) return t;
+					return null,s;
+				}
+			}
+		};
+		getOffset = function(){
+			return ..math.size64(owner.offset);
+		};
+		getOffset32 = function(){
+			return owner.offset.split32();
+		};
+		_topointer = function(){
+			return owner.hFileMapping;
+		};
+		_serialize = function(kernelCall){
+			if(kernelCall) return ..raw.serializeDupHandle("fsys.mmap",owner.hFileMapping);
+		};
+	)
+	__allocationGranularity = ..sys.info().dwAllocationGranularity; 
+}
+
+/**intellisense()
+fsys.mmap = 用于创建内存映射,主要用于进程间共享内存,\n例如process.command就使用了fsys.mmap在进程间共享数据
+fsys.mmap( = 创建或打开内存映射文件,\n返回对象可传入其他线程使用。
+fsys.mmap(.(内存映射文件句柄) = 使用句柄直接打开内存映射文件
+fsys.mmap(.(内存映射文件句柄,true) = 使用句柄直接打开内存映射文件\n添加析构函数负责释放句柄
+fsys.mmap(.(文件路径,共享名,文件大小,文件大小高32位,访问属性,内存保护属性) = 创建内存映射文件,所有参数可选,\n参数@1可为空，可指定文件路径,也可直指定fsys.file对象,\n\n省略共享名创建匿名对象,\n共享名可用于跨进程共享内存映射文件，\n共享名不能包含反斜杠,不能超过260个字符\nthread.event,process.mutex,fsys.mmap等共享名字不能相同,\n\n如果不指定文件，或打开空文件,则大小默认设为64MB，\n文件大小高32位如果省略，可选使用math.size64对象指定文件大小
+fsys.mmap() = !fsys_mmap.
+!fsys_mmap.getOffset32() = 返回当前位置\n返回两个值,分别为低32位,高32位
+!fsys_mmap.getOffset() = 返回当前位置,math.size64对象,\n!math_size64.
+!fsys_mmap.conflict = 如果打开已存在的内存映射,该属性为真
+!fsys_mmap.mapView(.(内存大小) = 映射内存并返回指针
+!fsys_mmap.unmapView(.(内存指针) = 取消映射,\n参数必须是mapView函数返回的指针地址
+!fsys_mmap.seek(.("cur",偏移量,偏移量高位) = 移动文件指针,\n参数一为"cur"表示相对当前位置\n参数三为可选参数
+!fsys_mmap.seek(.("set",偏移量,偏移量高位) = 移动文件指针,\n参数一为"set"表示相对开始位置\n参数三为可选参数,参数二默认为0
+!fsys_mmap.read(__) = 自当前位置读取数据,\n读取成功向后移动指针指向已读取数据尾部\n参数可以为读取长度,也可以是结构体
+!fsys_mmap.write( = 写入数据\n多进程读写应使用 process.mutex 创建互斥锁
+!fsys_mmap.write(.(写入数据) = 写入数据\参数可以是结构体或字符串、buffer、或数值\n该函数不支持多个参数,读取成功返回true,以及长度,\n失败返回false,以及错误信息
+!fsys_mmap.write(.(写入数据,写入长度) = 写入数据\参数可以是字符串、buffer、指针\n字符串、buffer 可选指定写入长度\n指针必须指定长度
+!fsys_mmap.writeTable( = 写入table对象\n多进程读写应使用 process.mutex 创建互斥锁
+!fsys_mmap.writeTable(.(table对象) = 写入table对象,仅支持可序列化为字面量的对象\n多进程读写应使用 process.mutex 创建互斥锁
+!fsys_mmap.readTable() = 读入table对象\n成功返回table,失败返回null值以及读入的文本
+!fsys_mmap.close() = 关闭文件映射对象
+end intellisense**/

package/aardio/lib/fsys/multipartFormData.aardio

@@ -0,0 +1,188 @@
+//multipartFormData 上传文件数据
+namespace fsys;
+
+class multipartFormData{
+
+	ctor( path,boundary,blockSize){ {
+	
+		var file,err = ..io.open(path,"rb");
+		if(!file) return null,err;
+		
+		path = path;
+		blockSize = blockSize : 0x100000;
+		this.getPath = function(){
+			return path;
+		}
+		
+		var current;
+		var multipart = {};
+		var outBuffer = ..raw.buffer(blockSize);
+		var readSize = file.readBuffer(outBuffer);
+		if(!boundary){
+			boundary = ..string.match(outBuffer,"^--([^\r]+)");
+			if(!boundary) return;
+		}
+		var nextboundary = '@\r\n--' + boundary + '\r\n';
+		var boundarylen = #nextboundary -1;
+		var bound,boundEnd = ..string.find(outBuffer,'@--' + boundary + '\r\n');
+
+		while(readSize){
+				if(! ( bound && ( (bound+boundarylen) <= readSize) ) ){
+					if(!current) return;
+					
+					if( readSize < blockSize){
+						if( readSize < boundarylen + 2 ) return;
+					} 
+					
+					bound = ..string.find(outBuffer,'@\r\n--' +  boundary + '--');
+					if(( bound && ( (bound+boundarylen-1) <= readSize) ) ){
+						current.length = ( (file.seek() - readSize) + (bound - 1 )) - current.offset ;
+						if( bound - 1 >= current.length ){
+							current["contentValue"] = ..string.slice(outBuffer,(bound)-current.length,bound- 1);
+						}
+						break ;
+					}
+					
+					if( ! file.read(0) ){
+						return;
+					}
+					
+					file.seek("cur",-(boundarylen+2)  );
+					
+					::Ntdll.RtlZeroMemory(outBuffer,blockSize);
+					readSize = file.readBuffer(outBuffer);
+					bound,boundEnd = ..string.find(outBuffer,nextboundary);
+					continue;
+				}
+
+				if(current){
+					current.length = ( (file.seek() - readSize) + (bound - 1 ) ) - current.offset;
+					if( bound - 1 >= current.length ){
+						current["contentValue"] = ..string.slice(outBuffer,bound-current.length,bound-1);
+					}
+				}
+				current = {}
+			
+				boundEnd++;
+				var offset = ..string.find(outBuffer,'@\r\n\r\n',boundEnd);
+				if(!offset){
+					var right = ..math.min(4,readSize - boundEnd);
+					if( readSize-right > boundEnd )
+						current.header = ..string.slice(outBuffer,boundEnd,readSize-right);
+					
+					file.seek("set", -right );
+					::Ntdll.RtlZeroMemory(outBuffer,blockSize);
+					readSize = file.readBuffer(outBuffer);
+					if(!readSize) return null;
+					
+					boundEnd = 0; 
+					offset = ..string.find(outBuffer,'@\r\n\r\n');
+					if(!offset)  return; 
+				}			
+				
+				current.header = ..string.concat(current.header,..string.slice(outBuffer,boundEnd,offset-1) );
+				file.seek("cur",-(readSize -(offset+ 3 )) );
+				current.offset = file.seek() ;
+				..table.push(multipart,current);
+				
+				::Ntdll.RtlZeroMemory(outBuffer,blockSize);
+				readSize = file.readBuffer(outBuffer);
+				bound,boundEnd = ..string.find(outBuffer,nextboundary);
+		}
+
+		for(k,part in multipart){
+			var formData = {};
+		
+			for line in ..string.lines(part.header) { 
+				var nv = ..string.split(line,":",2);
+				if(nv[2]){
+					formData[ ..string.trim(..string.lower(nv[1])) ] = ..string.trim(nv[2]);
+				}
+			} 
+			
+			var dp = formData["content-disposition"];
+			if(!dp) continue;
+				
+			for k,v in ..string.gmatch( dp,`([^=;\s]+)\s*=\s*(<"[^"]+">|<[^;]+>)`) { 
+				k = ..string.lower(k);
+				formData[k] = ..string.trim(v,`'"`);
+			}
+			
+			if(!formData.name) continue; 
+			
+			formData["contentType"] = formData["content-type"];
+			formData["contentOffset"] = part.offset;
+			formData["contentLength"] = part.length;
+			formData["contentValue"] = part["contentValue"];
+			formData.value = function(){
+				if( !owner["contentValue"] ){
+					var file,err = ..io.open(this.getPath(),"r+b");
+					if(!file) return;
+					
+					file.seek("set",owner["contentOffset"])
+					owner["contentValue"] = file.read(owner["contentLength"] )
+					file.close();
+				}
+				return owner["contentValue"];
+			}
+			formData.save = function(savePath){
+				if(owner["contentValue"] ){
+					..string.save(savePath,owner["contentValue"]);
+					return true;
+				}
+				var fileR,err = ..io.open(this.getPath(),"rb");
+				if(!fileR) return null,err;
+					
+				var fileW,err = ..io.open(savePath,"w+b");
+				if(!fileW) {
+					fileR.close();
+					return null,err;
+				}
+				
+				fileR.seek("set",owner["contentOffset"])
+				
+				var len = owner["contentLength"];
+				var outBuffer = ..raw.buffer(blockSize);
+				var readSize = fileR.readBuffer(outBuffer,..math.min(len,blockSize));
+				while(readSize){
+					fileW.writeBuffer(outBuffer,readSize);
+					len = len - readSize;
+					if(len<=0) break;
+					readSize = fileR.readBuffer(outBuffer,..math.min(len,blockSize));
+				} 
+				fileR.close();
+				fileW.close();
+				return true; 
+			} 
+			
+			this[formData.name] = formData;
+		}
+			
+		file.close();
+		outBuffer = null;
+		return this;
+	} };
+}
+
+::Ntdll := ..raw.loadDll("Ntdll.dll");
+
+/**intellisense()
+fsys.multipartFormData = multipart/form-data格式文件解析器
+fsys.multipartFormData(.("文件路径","分隔符") = 解析文件返回表对象\n可选在参数@3中指定读写缓冲区大小
+fsys.multipartFormData() = !stdfsysmultipartFormData
+end intellisense**/
+
+/**intellisense(!stdfsysmultipartFormData)
+? = multipart/form-data对象的每个键名下保存每个字段的信息\n!stdfsysmultipartFormField.
+getPath() = 参数中指定的文件路径
+end intellisense**/
+
+/**intellisense(!stdfsysmultipartFormField)
+name = 字段名称
+filename = 文件名\n如果不是文件则为空
+value() = 此函数直接读取并返回此字段的数据\n较大文件应使用save函数转存文件
+save(.("文件路径") = 保存文件\n上传文件数据如果不保存,在请求结束将被自动删除
+contentType = MIME类型
+contentLength = 数据长度
+contentOffset = 偏移位置
+end intellisense**/

package/aardio/lib/fsys/namedPipe.aardio

@@ -0,0 +1,95 @@
+//namedPipe 命名管道
+import fsys.file;
+namespace fsys;
+
+class namedPipe{
+
+	ctor( pipeName,maxInstancess,defaultTimeOut
+		,openMode,pipeMode,outBufferSize,inBufferSize,securityAttributes){
+	
+		var pipe =  ::Kernel32.CreateNamedPipeP(pipeName
+			, ( openMode : 0x3/*_PIPE_ACCESS_DUPLEX*/ )
+			, pipeMode : 0/*_PIPE_TYPE_BYTE | _PIPE_READMODE_BYTE | _PIPE_WAIT*/
+			, maxInstancess : 255 
+			, outBufferSize : 0  
+			, inBufferSize : 0
+			, defaultTimeOut : 0
+			, securityAttributes : null
+		);
+	 	if( !pipe || pipe == _INVALID_HANDLE_VALUE ) return null;
+	 	this = ..fsys.file( pipe,true )
+	};
+	connect = function(){
+		if(  !!::Kernel32.ConnectNamedPipe( this.hfile ,null ) ) 
+			return true;
+		
+		if( ::GetLastError() == 0x217/*_ERROR_PIPE_CONNECTED*/){
+			return true;
+		}
+	};
+	disconnect = function(){
+		return !!::Kernel32.DisconnectNamedPipe( this.hfile );
+	};
+	getClientComputerName = function(){
+		var buffer = ..raw.buffer(15/*_MAX_COMPUTERNAME_LENGTH*/);
+		var r,name = ::Kernel32.GetNamedPipeClientComputerName( this.hfile,buffer,15 );
+		if(r) return tostring(buffer);
+	};
+	getClientSessionId = function(){
+		var r,client = ::Kernel32.GetNamedPipeClientSessionId( this.hfile,{INT id} );
+		if(r) return client.id;
+	};
+	getClientProcessId = function(){
+		var r,client = ::Kernel32.GetNamedPipeClientProcessId( this.hfile,{INT id} );
+		if(r) return client.id;
+	};
+	peek = function(){   
+		var ret,read,total,leftmsg = PeekNamedPipe(this.hfile, ,0,0,0,0) 
+		if(ret && total) return this.read(total);
+	}; 
+}
+
+namespace namedPipe{
+	PeekNamedPipe = ::Kernel32.api( "PeekNamedPipe", "bool(pointer pipe,pointer buf,INT size,INT &read,INT & total,INT & leftMsg)");
+
+	wait = function(pipeName,mode = "r+",timeout,secAttrib,template){
+		if( !!::Kernel32.WaitNamedPipe(pipeName,timeout : 0x0/*_NMPWAIT_USE_DEFAULT_WAIT*/) ){
+			return ..fsys.file(pipeName,mode,0,0x3/*_OPEN_EXISTING*/,0x80/*_FILE_ATTRIBUTE_NORMAL*/,secAttrib,template)
+		}
+	} 
+}
+
+/**intellisense()
+fsys.namedPipe.wait("\\->\pipe\pipename","r+") = 等待并打开可用管道
+fsys.namedPipe.wait() = !fsysPipe.
+fsys.namedPipe("\\->\pipe\pipename",2,2000) = 参数分别为管道名,最大实例数,超时值\n其他参数就参考源码
+fsys.namedPipe() = !fsysPipe.
+!fsysPipe.connect() = 等待客户端连接
+!fsysPipe.disconnect() = 断开客户端连接
+!fsysPipe.getClientComputerName() = 返回客户端计算机名，不支持WinXP系统
+!fsysPipe.getClientSessionId() = 返回客户端会话ID
+!fsysPipe.getClientProcessId() = 返回客户端进程ID
+!fsysPipe.peek() = 如果命名管道中有数据则返回数据
+!fsysPipe.read(__/*字节数*/) = 读取指定长度的字节\n不支持多参数
+!fsysPipe.read({int number} ) = 参数可以是一个结构体\n不支持多参数
+!fsysPipe.read() = 读取一行文本\n返回文本不包含回车换行符
+!fsysPipe.read(-1) = 读取所有内容到文件尾部
+!fsysPipe.write(__/*字符串*/) = 写入字符串\n参数也可以是数值、结构体
+!fsysPipe.readBuffer( = 读取数据到 buffer ,成功返回读取长度,失败返回null
+!fsysPipe.readBuffer(.(buffer,读取长度) = 直接读数据到内存\n参数@1可以是 buffer 对象,或内存指针,\n如果是指针则必须指定读取长度,否则长度参数可选\n成功返回读取长度
+!fsysPipe.writeBuffer( = 写入缓冲区数据,成功返回写入长度,失败返回null
+!fsysPipe.writeBuffer(.(buffer,写入长度) = 直接写数据到内存\n参数@1可以是 buffer 对象,或内存指针,\n如果是指针则必须指定写入长度,否则长度参数可选\n成功返回写入长度
+!fsysPipe.seek("end") = 移动指针至结束处\n返回当前位置,返回值大于2GB则为负值,\n获取文件大小推荐使用 size() 函数
+!fsysPipe.seek("end",__) = 移动至相对结束处的指定偏移量
+!fsysPipe.seek() = 得到当前位置
+!fsysPipe.seek("cur",__) = 移动至相对当前位置的指定偏移量
+!fsysPipe.seek("set") = 移动指针到开始
+!fsysPipe.seek("set",__) = 移动至相对开始处的指定偏移量
+!fsysPipe.path = 返回文件路径
+!fsysPipe.flush() = 刷新缓冲区
+!fsysPipe.close() = 关闭文件句柄
+!fsysPipe.seteof() = 设置文件结束 
+!fsysPipe.size() = 返回文件大小\n可选参数一指定单位大小(默认自动选择),\n可选用参数二指定小数精度(默认为2)\n返回文件大小,单位大小,单位名("bytes","KB","MB","GB"等)
+!fsysPipe.size64() = 返回文件大小\n返回值为math.size64长整数对象\n!math_size64.
+!fsysPipe.handle = 返回文件句柄
+end intellisense**/

package/aardio/lib/fsys/partFile.aardio

@@ -0,0 +1,186 @@
+//partFile 分卷文件
+import fsys;
+namespace fsys.partFile;
+
+class joiner {
+
+	ctor( path,mode="w+b",bufsize= 0xA00000 ){
+	 
+		var buffer = ..raw.buffer( bufsize ); 
+		
+		var file; 
+		if( path ) file =  ..io.open(path,mode);
+		if( !file ) return null,"打开文件失败" + path;
+		
+		..table.gc(this,"close");
+	}; 
+	append = function( path, ... ){
+		if(!file) error("请先打开目标文件",2)
+		if( type( path ) == "table" ){
+			var name;
+			for(i=1;#path;1){
+				name = path[i];
+				var ok,err = this.append( path[name] or name );
+				if(!ok) return err;
+			}
+			return true;
+		}
+		
+		var file2,err = path ? ..io.open(path,"rb");
+		if( !file2 ) return null,err;
+	
+		var blocks = 0;	
+		var blockCount = ..math.ceil(file2.size(bufsize)) : 1;
+		while( 
+	    	var readSize;
+	    	readSize = file2.readBuffer(buffer); //读文件
+	    	readSize
+		) {
+			file.writeBuffer(buffer,readSize);
+			blocks++;
+			if( this.onCopyData ) this.onCopyData(path,readSize,blocks,blockCount);
+		}  
+		file2.close();
+		if(!...) return true;
+		return this.append(...);
+	}; 
+	close = function(){
+		if(file){
+			file.close();
+			file = null;
+		}
+	} 
+} 
+
+
+class splitter{
+
+	ctor( path,partSize,bufsize = 0xA00000 ){
+	
+		if( bufsize > partSize ) bufsize = partSize ; 
+		var buffer = ..raw.buffer( bufsize or 0xA00000 ); 
+		
+		var file; 
+		if( path ) file =  ..io.open(path,"r+b");
+		if( !file ) return null,"打开文件失败" + path;
+		
+		this.formatName = ..io.splitpath(path).file + ".%03d";
+		this.partSize = partSize;
+		
+		..table.gc(this,"close");
+	};
+	split = function(dir,first=1){  
+		var idx = first; 
+		if(!dir) dir = ..fsys.getParentDir(path);
+		
+		var blocks = 0;
+		var blockCount = ..math.ceil(file.size(bufsize)) : 1;
+		var path = ..fsys.joinpath(dir,..string.format(this.formatName , idx) ); 
+		var file2,err = ..io.open(path,"w+b");
+		if(!file2) return null,err;
+		var remain = this.partSize;
+		  
+		while( 
+	    	var readSize;
+	    	readSize = file.readBuffer(buffer,remain > bufsize ? bufsize : remain ); //读文件
+	    	readSize  
+		) {
+			remain -= readSize; 
+			file2.writeBuffer(buffer,readSize);
+			
+			blocks++;
+			if( this.onCopyData ) this.onCopyData(path,readSize,blocks,blockCount); 
+			
+			if( remain == 0 ) {
+				idx++; 
+				file2.close();
+				path = ..fsys.joinpath(dir,..string.format(this.formatName , idx) ); 
+				file2,err = ..io.open(path,"w+b");
+				if(!file2) return null,err;
+				remain = this.partSize;
+			}
+		}  
+		file2.close();
+		file.seek("set");
+		return true;
+	};
+	close = function(){
+		if(file){
+			file.close();
+			file = null;
+		}
+	} 
+}
+
+split = function(path,partSize,dir){
+	var spliter,err = splitter(path,partSize);
+	if(!spliter) return null,err; 
+	spliter.onCopyData = onCopyData;
+	var ret = spliter.split(); 
+	spliter.close();
+	return ret;
+}
+
+join = function( path,parts,... ){ 
+	if( !parts ) { 
+		parts,path = group(path);  
+		if( #parts < 2  ) return;
+	};
+	if( !parts ) return;	
+	
+	var jointer,err = joiner( path,"a+b");
+	if(!jointer) return null,err;
+	jointer.onCopyData = onCopyData;
+	var ret = jointer.append(parts,...); 
+	jointer.close();
+	return ret;
+} 
+
+group = function(path) {
+	if( !path ) error("路径参数不能为空",2)
+	path = ..fsys.path.removeBackslash(path);
+	var tPath = ..io.splitpath(path);
+	if(!#tPath.file) return;
+	
+	var b,d,e = ..string.match(tPath.file,"(.*)!\d(\d+)(\D*)$");
+	if(!(b&&d&&e) ) return;
+	
+	var p = "\d+";
+	if(#b) p = "<@@" + b + "@>" + p;
+	if(#e) p = p + "<@@" + e + "@>";
+	 
+	var parts = ..fsys.list(tPath.dir,p + "$" );
+	..table.sort( parts, function(filename){
+		var a = ..string.match(owner,"(\d+)(\D*)$");
+		var b = ..string.match(filename,"(\d+)(\D*)$");
+		return tonumber(a,10) < tonumber(b,10);  
+	} ); 
+
+	return parts,..fsys.joinpath(tPath.dir,b++e); 
+}
+
+/**intellisense()
+fsys.partFile = 分卷文件操作
+fsys.partFile.joiner(.("目标文件路径","w+b",读写块大小) = 创建合并文件对象\n除参数@1以外其他参数可选\n参数@2为打开文件模式,默认为"w+b"即重建目标文件\n块大小默认为10MB
+fsys.partFile.joiner() = !partFile_joiner.
+!partFile_joiner.append(.("合并文件路径") = 支持不定个参数指定的文件路径\n或者使用一个参数传入待合并文件路径数组\n将参数传入的文件读取并追加到合并目标文件\n成功返回true
+!partFile_joiner.close() = 关闭合并目标文件
+!partFile_joiner.onCopyData = @.onCopyData = function(path,writeSize,blocks,count){
+	io.print( path,fsys.formatSize(writeSize),blocks,count )
+}
+fsys.partFile.splitter(.("拆分源文件路径",分卷文件大小,读写块大小) = 拆分文件\n读写块大小默认为10MB
+fsys.partFile.splitter() = !partFile_splitter.
+!partFile_splitter.split(.("创建分卷文件目录",分卷初始序号) = 拆分文件,所有参数可选\n默认使用源文件所在目录存储分卷文件,\n初始分卷序号默认为1
+!partFile_splitter.close() = 关闭源文件
+!partFile_splitter.formatName = 生成分卷文件名的格式化串\n默认为 "源文件名" + ".%03d"
+!partFile_splitter.onCopyData = @.onCopyData = function(path,writeSize,blocks,count){
+	io.print( path,fsys.formatSize(writeSize),blocks,count )
+}
+fsys.partFile.group(.("分卷文件路径") = 自动查找关联分卷文件\n并返回排序好的文件名数组\n文件名数组序号最小的在数组开始\n数组包含文件名到完整路径的键值映射\n返回值2为去掉分卷号路径,可作为合并目标路径
+fsys.partFile.search(.("搜索目录",是否查找子目录) = 查找分卷文件,\n返回一个表,键为未分卷文件名,值为分卷文件路径数组,该数组已排序\n除参数一以外,其他参数可选,默认不查找子目录\n参数3,4请保持默认值,高级用法请查看该函数源码
+fsys.partFile.join(.("合并目标文件",待合并文件) = 合并文件,成功返回true\n待合并文件可以是一个数组或多个参数\n如果未指定参数@2,则参数@1必须是一个分卷文件路径\n仅指定一个分卷路径时自动设定所有参数\n该函数使用追加模式,不清空目标文件\n可选用 fsys.partFile.onCopyData 显示进度
+fsys.partFile.split(.("被拆分文件路径",分卷文件大小,存储目录) = 拆分文件,成功返回true\n不指定目录则取被拆分文件所在目录\n可选用 fsys.partFile.onCopyData 显示进度
+fsys.partFile.onCopyData = @.onCopyData = function(path,writeSize,blocks,count){
+	io.print( path,fsys.formatSize(writeSize),blocks,count )
+}
+end intellisense**/