aview-app 1.0.2

package/aardio/lib/string/aasdl.aardio

@@ -0,0 +1,35 @@
+//aasdl 生成器
+import web.json;
+namespace string;
+
+class aasdl{
+	ctor(external){
+		return ..web.json.stringify( strip(external) );
+	};
+}
+
+namespace aasdl{
+    
+    strip = function(external,p){
+		if(!p) p = {};
+		elseif(p[external]) return;
+		else p[external] = 1;
+	
+    	var r  = {};
+		for(k,v in external){
+			if(v==owner) continue ;
+			if(type(v)== type.function){
+				r[k] = 1;
+			}
+			elseif(type(v)== type.table){
+				r[k] = strip(v,p);
+			}
+		} 
+		return r;	
+    } 
+}
+
+/**intellisense()
+string.aasdl(.(external) = 转换external对象为aasdl格式JSON文本
+end intellisense**/
+

package/aardio/lib/string/builder.aardio

@@ -0,0 +1,212 @@
+//builder 字符串生成器
+namespace string;
+
+class builder{
+	ctor(len){
+		this.ptr = ..raw.realloc( len : 1024 );
+		..table.gc(this,"free");
+	};
+	@_meta
+}
+
+namespace builder{
+
+	::Msvcrt := ..raw.loadDll("Msvcrt.dll",,"cdecl");
+	var strpbrk =  ::Msvcrt.strpbrk;
+	var strstr = ::Msvcrt.strstr;
+	var strtok = ::Msvcrt.strtok;
+	var snprintf = ::Msvcrt._snprintf;
+	var concat = ..raw.concat;
+	var convert = ..raw.convert;
+	var sizeof = ..raw.sizeof;
+	var getString = ..raw.tostring;
+
+	_meta = {
+		empty = function(){
+			return ! sizeof(owner[["ptr"]])
+		};
+		capacity = function(){
+			var l,c = sizeof(owner[["ptr"]]);
+			return c:0;
+		};
+		reserve = function(size){
+			var l = sizeof(owner[["ptr"]]);
+			if( size < l ) size = l;
+			owner[["ptr"]] = ..raw.realloc(size: 1024,owner[["ptr"]]);
+			return owner; 
+		};
+		size = function(){
+			return (sizeof(owner[["ptr"]]))
+		};
+		resize = function(size){
+			var l,c = sizeof(owner[["ptr"]]);
+			if(size>c) owner[["ptr"]] = ..raw.realloc(size+1024,owner[["ptr"]]);
+			convert( {INT size = size},topointer(owner[["ptr"]],-4));
+		};
+		assign = function(v){
+			owner[["ptr"]] = ..raw.realloc( (v[["_struct"]]?sizeof(v):#v ) +1024,owner[["ptr"]],v);
+		};
+		subString = function(i,j){
+			var l,c = sizeof(owner[["ptr"]]);
+			return getString(owner[["ptr"]],i:1,j:l); 
+		};
+		leftString = function(l){
+			var c = sizeof(owner[["ptr"]]);
+			if(l<0) l = c + l + 1;
+			if(l>c) l = c;
+			return getString(owner[["ptr"]],1,l); 
+		};
+		rightString = function(l){
+			var c = sizeof(owner[["ptr"]]);
+			if(l<0) l = ..math.abs(l);
+			else l = c - l + 1;
+			if(l>c) l = c;
+			return getString(owner[["ptr"]],l,c); 
+		};
+		indexAny = function(set){
+			var p = strpbrk(owner[["ptr"]],set);
+			if(p) return  p - tonumber(owner[["ptr"]])  + 1;
+		};
+		indexOf = function(p,f){
+			if(!#p) return;
+			var r = strstr(topointer(owner[["ptr"]],f?f-1),p );
+			if(r) return ( r - tonumber(owner[["ptr"]]) )  + 1;
+		};
+		eachIndexOf = function(p){
+			var i,n=0,#p+1;
+			return function(){ 
+				i = owner.indexOf(p,i+n);
+				return i;
+			},owner;
+		};
+		tokenize = function(delimit){
+			if(!delimit) delimit='\t\n\r\v\x20';
+			
+			var tok;
+			var addr = tonumber(owner[["ptr"]]);
+			strtok(addr,delimit) 
+			return function(){
+				var tok = strtok( ,delimit)
+				if(tok) return tok-addr + 1;
+			} 
+		} 
+		trim = function(set){
+			owner.trimleft();
+			owner.trimright();
+			return owner;
+		}
+		trimleft = function(set){ 
+			if(!set) set='\t\n\r\v\x20';
+			var s = tonumber(owner[["ptr"]]);
+			var pl = ::Msvcrt.strspn(s,set);
+			if(pl == 0) return owner;
+			
+			var size = owner.size()-pl;
+			::Kernel32.RtlMoveMemory(s,s+pl,size); 
+			owner.resize(size);
+			return owner;
+		}
+		trimright = function(set){ 
+			if(!set) set='\t\n\r\v\x20';
+			var size,c = 0;
+			var indexAny = ..string.indexAny;
+			for(i=owner.size();1;-1){
+				c = convert(owner[["ptr"]],{BYTE v},i-1).v;
+				if !indexAny(set,c ){ size = i;break ; }
+			}
+			owner.resize(size);
+			return owner;
+		}
+		appendf = function(f,...){
+			var l1,c = sizeof(owner[["ptr"]]);
+			var l = snprintf( topointer(owner[["ptr"]],l1),c-l1,f,...);
+			while(l<0){
+				c = c + #f + 1024;
+				owner[["ptr"]] = ..raw.realloc(c,owner[["ptr"]]);
+				l = snprintf( topointer(owner[["ptr"]],l1),c-l1,f,...);
+			}
+			
+			convert( {INT size = l1+l},topointer(owner[["ptr"]],-4));
+			return owner;  
+		};
+		_get = function(k){
+			if(type(k)=='number') return convert(owner[["ptr"]],{BYTE v},k-1).v;
+			return owner@[[k]];
+		}
+		_set = function(k,v){
+			if((type(k)=='number') && (k>0) )convert({BYTE v = v},owner[["ptr"]],k-1)
+		}
+		append = function(s,l){
+			owner[["ptr"]] = concat(owner[["ptr"]],s,l);
+			return owner;
+		}
+		fromUnicode = function(l,codepage){
+			if(l===null) l = -1;
+			return ..string.fromUnicode(owner[["ptr"]],codepage,l);
+		}
+		toUnicode = function(l,codepage){
+			if(l===null) l = -1;
+			return ..string.toUnicode(owner[["ptr"]],codepage,l);
+		}
+		str = function(u,off){
+			return ..raw.str(owner[["ptr"]],u,off);
+		}
+		_add = function(v){
+			owner[["ptr"]] = concat(owner[["ptr"]],v);
+			return owner;
+		}
+		_concat = function(v){
+			owner[["ptr"]] = concat(owner[["ptr"]],v);
+			return owner;	
+		}
+		_tostring = function(){
+			var len = sizeof(owner[["ptr"]]);
+			if(len)return getString(owner[["ptr"]],1,len);
+		}
+		_topointer = function(){
+			return owner[["ptr"]];
+		}
+		_serialize = function(kernelCall){
+			return "null";
+		}
+		free = function(){
+			owner[["ptr"]] = ..raw.realloc(0,owner[["ptr"]]);
+		};
+	};
+}
+
+/**intellisense()
+string.builder = 字符串生成器\n创建的对象内部使用动态指针,并负责自动释放动态指针\n要切记对象虽然可以在API中转换为普通指针使用\n但任何可能导致自动调整内存大小操作都有可能改变动态指针指向的内存,并使原指针失效
+string.builder() = 创建字符串生成器，\n可选在参数中指定预分配内存大小\n生成器对象可使用+,++连接字符串、buffer、结构体,或使用[]操作符取字节码,\n此对象可用于拼接字符串，并自动调整内存大小,\n\n在大字符串频繁拼接时可明显提升速度，\n小字符串少量拼接不需要使用些对象\n!stdstringbuilder.
+end intellisense**/
+
+/**intellisense(!stdstringbuilder)
+str( = 转换为纯文本字符串\n如果需要转换为二进制字符串,直接使用 tostring 函数转换string.builder对象即可
+str(.(是否unicode,偏移) = 去掉尾部多余终结符转换为纯文本字符串,参数可省略,偏移默认为0\n参数@1为true反回字符串标记会设置UTF-16标记,否则设为UTF-8标记
+toUnicode(.(转换字节数,源编码) =  转换并返回UTF16编码字符串\n字节数可省略,默认为-1\n字节数为-1时表示查找'\0'终止符自动获取长度
+fromUnicode(.(转换字符数,目标编码) = 自UTF16编码转换为多字节编码字符串，默认为UTF8\n参数@1以字符计数，即2个字节为一个单位,字符数只能为数值，省略时默认值为-1\n字符数为-1表示查找'\u0000'终止符获取可打印文本长度
+free() = 释放内存\n此函数设置内部动态指针值为null\n释放动态指针以后,仍然可以调用reserve函数重新分配内存
+empty() = 存储内容是否为空
+capacity() = 返回预分配内存大小\n释放指针后此函数返回0
+reserve(__) = 调整预分配内存大小,返回自身\n小于存储内容大小时则设为存储内容大小\n为0时设为1024\n此函数可能改变内部动态指针值\n\n释放动态指针以后,仍然可以调用此函数重新分配内存
+reserve() = !stdstringbuilder.
+size() =  返回存储内容大小\n释放指针后此函数返回0
+resize(__) = 调整存储内容大小\n此函数可能改变内部动态指针值
+assign(__) = 重置初始值\n参数可以是字符串，buffer，或结构体\n此函数可能改变内部动态指针值
+subString(.(开始位置,结束位置) = 截取字符串\n返回字符串对象，参数不能为负数\n开始位置省略则表示1，结束位置省略则表示存储内容尾部\n不会改变内部动态指针值
+leftString(__) = 从左侧截取参数指定长度的字符串\n返回字符串对象,参数可用负数表示右侧截取位置\n不会改变内部动态指针值
+rightString(__) = 从右侧截取参数指定长度的字符串\n返回字符串对象,参数可用负数表示左侧截取位置 \n不会改变内部动态指针值
+trimleft(__) = 清除左侧空白字符\n可选用一个字符串指定要清除的单字节字符
+trimright(__) = 清除右侧空白字符\n可选用一个字符串指定要清除的单字节字符
+trim(__) = 清除两侧空白字符\n可选用一个字符串指定要清除的单字节字符
+indexOf(.(查找内容,查找开始位置) = 普通字符串查找\n不使用模式匹配语法
+indexAny("__") = 参数用一个字符串指定要查找的单字节字符\n返回任意字符最初出现的位置,找不到返回值为空
+appendf(.("C格式化串",->->->) = 使用printf函数格式化文本\n此函数可能改变内部动态指针值
+append(.(追加数据,追加长度) = 追加数据可以是字符串，buffer，或其他指针\n如果参数不是指针追加长度可省略\n此函数可能改变内部动态指针值
+eachIndexOf(查找内容) = @for(i in ??.eachIndexOf(__/*查找内容*/)){
+	
+}
+tokenize(分割符) = @for(i in ??.eachIndexOf("__/*单字节分割符*/")){
+	
+}
+end intellisense**/

package/aardio/lib/string/chineseNumber.aardio

@@ -0,0 +1,216 @@
+//chineseNumber 中文化数值
+namespace string;
+
+class chineseNumber{
+	ctor(numberChars,unitChars,wanUnitChars){
+	
+		var lcid = ::Kernel32.GetUserDefaultLCID();
+		if( lcid==0x404/*zh-TW*/ || lcid == 0x0C04/*zh-HK*/ || lcid == 0x1404/*zh-MO*/ ){
+			this.numberChars = numberChars: '零一二三四五六七八九';
+			this.unitChars = unitChars : '十百千'; 
+			this.wanUnitChars = wanUnitChars : '萬億';
+			this.moneyUnitChars = "圓角分";
+			this.minusChar = '負';
+			this.pointChar = '點';
+			this.onlyChar = "整";
+			this.defaultTimeFormat = "%p %I時%M分%S秒";
+			this.lang  = "cht";
+			this.defaultDateFormat = "%Y年%m月%d日 星期%w";
+			this.defaultDateTimeFormat  = "%Y年%m月%d日 %H時%M分%S秒";
+		}
+		else {
+			this.numberChars = numberChars: '零一二三四五六七八九';
+			this.unitChars = unitChars : '十百千';
+			this.wanUnitChars = wanUnitChars : '万亿';
+			this.moneyUnitChars = "元角分";
+			this.minusChar = '负';
+			this.pointChar = '点';
+			this.onlyChar = "整";
+			this.defaultTimeFormat = "%p %I时%M分%S秒";
+			this.lang  = "chs";
+			this.defaultDateFormat = "%Y年%m月%d日 星期%w";
+			this.defaultDateTimeFormat  = "%Y年%m月%d日 %H时%M分%S秒";
+		}
+
+		this.wanwan = true;
+	};
+	$stringify = function(num){
+		if(type(num) == type.string){
+			num = ..string.replace(num,"(\d)[\,\_]","\1")
+			return ..string.match(num,"^([+-]?0*\d+\.?\d*)$")
+		} 
+		if(num!==null) return ..math.stringify(num);
+	};
+	replace = function(num){
+		num = this.$stringify(num); 
+		var numberChars  = ..string.split(this.numberChars);   
+		return ( ..string.replace(num,"\d",function(d){
+			return numberChars[d+1];
+		}) ) 
+	};
+	number = function (num,fmtTen) {  
+		var numberChars  = ..string.split(this.numberChars);      
+		var unitChars = ..string.split(this.unitChars);
+		var wanUnitChars = ..string.split(this.wanUnitChars);
+		var zero = numberChars [1];  
+		
+		num = this.$stringify(num); 
+		if(!num) return "";
+		if(num==="0") return zero;
+		
+		var minus,int,point,decimal  = ..string.match(tostring(num),"^([+-]?)0*(\d+)(\.?)(\d*)$");
+		minus = minus=="-" ? this.minusChar : (num[1]=='0'#?zero:"");
+		if(( minus === zero ) && (fmtTen===null) ) fmtTen = false;
+		
+		if (int===null) { return num;}
+			
+		var format;
+		format  = function(number,fmtTen) { 
+			number = ..string.trimleft(number,"0");
+				var len = #number;
+				var result = "";
+				
+			if (len == 1) return numberChars[number+1];
+			elseif (len == 2) { 
+				var n = number[[1]] + 0;
+				if(n != 1 || !fmtTen){
+					result = result ++  numberChars [n+1];
+				}
+				result = result ++ (n && unitChars[1]) 	
+					
+				var n = number[[2]] + 0; 
+				result = result ++ numberChars [n+1];	 
+			}
+			elseif (len <= 4) {  
+				for(i=1;len){
+					var n = number[[i]] + 0;
+					result = result ++  numberChars [n+1] ++ ( n ? unitChars[len - i ] : '')
+				} 
+			} 
+			else {    
+				var wanCount = ..math.floor(len / 4); //4位分级读数
+				var currentCount = len % 4;
+					
+				while (currentCount == 0 || !wanUnitChars[wanCount]) { 
+					currentCount += 4;
+					wanCount--; 
+				}
+				
+				var currentNumber = ..string.slice(number,1,currentCount); 
+				var nextNumber = ..string.slice(number,currentCount+1);   
+				
+				result =  format(currentNumber,fmtTen) ++ wanUnitChars[wanCount] 
+				if(nextNumber[1]=='0'#){result = result ++ zero}
+				result = result ++ format(nextNumber,#nextNumber>4 ? fmtTen : false)   
+			}
+			
+			result = ..string.replace(result,zero+"<"+zero+">+",zero);  
+			return ..string.replace(result,zero+"$","");
+		}
+	
+		result = format(int,fmtTen===null : fmtTen);
+		if (decimal) {
+			decimal  = ..string.trimright(decimal,"0");  
+			var d = "";
+			for(i=1;#decimal;1){  
+				d  = d ++ numberChars[decimal[[i]]+1]
+			}
+				
+			d  = #d  ? (this.pointChar ++ d ) : "";  
+			result = result ++ (d:"");
+		}
+
+		if (this.wanwan && #wanUnitChars > 1) { 
+			var wan = wanUnitChars[1]
+			var yi = wanUnitChars[2];
+			var last = ..string.lastIndexOf(result,yi);
+			if (last) {
+				result = ..string.replace( 
+					..string.slice(result,1,last-1)
+					,yi, wan ++ wan) ++ ..string.slice(result,last); 
+			} 
+		} 
+			
+		return minus ++ result;
+	};
+	money = function (num,complete,fmtTen) {
+		num = this.$stringify(num); 
+		var minus,int,point,decimal  = ..string.match(tostring(num),"^([+-]?)0*(\d+)(\.?)(\d*)$"); 
+		if (int===null) { return num; } 
+		
+		var moneyUnitChars = ..string.split(this.moneyUnitChars);
+		if (complete) {
+			var result =  this.number(int,!!fmtTen) ++ moneyUnitChars[1];
+			for(i=2;#moneyUnitChars) result = result ++ this.number( decimal[[i-1]] || "0" ) ++ moneyUnitChars[i]
+			return result;
+		} 
+		else {
+			var result =  "";
+			var resultDecimal = this.onlyChar;
+			
+			decimal = ..string.trimright(decimal,"0");
+			if(int!=="0" || !#decimal){
+				result = this.number(int,!!fmtTen) ++ moneyUnitChars[1];
+			}
+			
+			if (#decimal) { 
+				resultDecimal = "";
+				for(i=2;#moneyUnitChars){
+					var n = decimal[[i-1]]; 
+					if (n != "0") {
+						if(!n) break;
+						
+						if(i>2 && !#resultDecimal && #result){
+							resultDecimal = resultDecimal ++ ..string.charAt(this.numberChars,1);
+						}
+						resultDecimal = resultDecimal ++ this.number(n) ++ moneyUnitChars[i] 
+					}  
+				}  
+			}
+			
+			return result ++ resultDecimal;
+		} 
+	};
+	time = function(t,f,l,sunday){
+		var tm = ..time(t,f:this.defaultTimeFormat,l:this.lang);
+		return ( ..string.replace(tostring(tm),"\d+",function(num){
+			if(#num>=4) return this.replace(num);
+			if(num=="0" && sunday) return sunday;
+			return this.number(tonumber(num),true)
+		}) )
+	};
+	date = function(t,f,l){
+		return this.time(t,f:this.defaultDateFormat,l,"日")
+	};
+	datetime = function(){
+		return this.time(t,f:this.defaultDateTimeFormat,l)
+	}; 
+}
+
+/**intellisense()
+string.chineseNumber(.(中文数字,单位,万亿单位) = 创建中文数值转换对象,所有参数可省略,\n参数详细用法请参考库源码
+string.chineseNumber() = !stringChineseNumber.
+end intellisense**/
+
+/**intellisense(!stringChineseNumber)
+replace(.(数值) = 数字替换为中文,不包含单位
+number(.(数值,简化十位) = 数字转换为中文,包含单位,\n参数 @1 也可以用文本指定 10 进制数值（支持大数,首字符为0时不清除）,\n参数 @2 为 true 简化一十为十，参数 @1 首字符不为 0 时参数 @2 默认值为 true
+money(.(数值,完整转换,简化十位) = 数字转换为金额,\n参数 @2 为 true 时允许返回零角零分,\n参数 @3为 true 时简化一十为十
+time(.(时间,格式化串,语言) = 中文化时间,\n兼容 time 对象构造函数全部参数,\n所有参数可省略
+date(.(时间,格式化串,语言) = 中文化日期,\n兼容 time 对象构造函数全部参数,\n所有参数可省略
+datetime(.(时间,格式化串,语言) = 中文化日期时间,\n兼容 time 对象构造函数全部参数,\n所有参数可省略
+numberChars = 默认值为'零一二三四五六七八九'
+unitChars = 默认值为'十百千' 
+wanUnitChars = 简体语言默认值为'万亿'，繁体语言默认值为'萬億'
+moneyUnitChars = 简体语言默认值为"元角分"，繁体语言默认值为"圓角分"
+minusChar = 简体语言默认值为'负'，繁体语言默认值为'負'
+pointChar = 简体语言默认值为'点'，繁体语言默认值为'點'
+onlyChar = 默认值为"整" 
+wanwan = 大数单位万万化
+lang = 格式化时间语言，默认自动选择 "chs" 或 "cht"
+end intellisense**/
+
+/*
+感谢:  
+https://github.com/cnwhy/nzh
+*/

package/aardio/lib/string/cmdline.aardio

@@ -0,0 +1,154 @@
+//cmdline 命令行参数
+import process;
+namespace string;
+
+class cmdline{
+	ctor( s ){
+		if( ( type(s) != "string") || ( !#s ) ) return null; 
+		
+		var p,argc = ::Shell32.CommandLineToArgvP(s,{int v});
+		if(p){
+			var argv = ..raw.convertArray(p,argc.v,"ustring"); 
+			if(#argv)argv[0] = ..table.shift(argv);
+			::Kernel32.LocalFree(pArgv);
+			
+			argv@ = _meta;
+			return argv;
+		}
+		
+		return null;
+		
+		/*不调用API实现{{*/
+		/*
+		var cur = {};
+		var push = ..table.push;  
+		var a,b = ..string.match(s,s[1] == '"'# ? '"([^"]+)"(.*)' : '(\\S*)(.*)')
+		this[0] = #a ? { ..string.unpack(a) } : {} ;
+		s = b;
+		
+		var len = #s;
+		for (i=1;len) {
+			var c = s[i]; 
+			if (c === '"'#) { 
+			 	while(i<=len){ i++; 
+					var c = s[i]; 
+					if( c == '"'# ){
+						if( s[i+1] == '"'# ){  push(cur,c);  i++; }
+						break; //关闭引用
+					}
+					elseif( c == '\\'# ){
+						var b,q = ..string.match( s,"(\\+)(""?)",i);
+						i = i + ( #b - 1 );
+						if( !#q ){
+							push(cur,..string.unpack(b) ); 
+							continue;
+						} 
+						
+						for(k=1;#b/2 ){ push( cur,'\\'#)  };
+						if( #b % 2 ){
+							push( cur,'"'#)
+							i++;
+						} 
+					}
+					else { push(cur,c) }  
+				}  
+				continue ; //考虑"""
+			}
+			
+			if( c === ' '# || c = '\t'# ){ 
+				if(#cur){
+					push( this,cur )
+					cur = {};
+				}
+			}
+			elseif( c == '\\'#   ){
+				var b,q = ..string.match( s,"(\\+)(""?)",i);
+				i = i + ( #b - 1 );
+				if( !#q ){
+					push(cur,..string.unpack(b) ); 
+					continue;
+				} 
+				
+				for(k=1;#b/2 ){ push( cur,'\\'#) } 
+				if( #b % 2 ){
+					push( cur,'"'#)
+					i++;
+				} 
+				continue;
+			}
+			else { push(cur,c); } 
+		}
+		
+		if(#cur)push( this,cur );
+		for(k,v in this) this[k] = ..string.pack(v);  
+		*/
+		/*}}*/
+	};  
+}
+
+cmdline._meta = {
+	_tostring = function(){
+		var s = ..process.joinArguments(owner);
+		if( !owner[0] ) s = " " + s;
+		return s;
+	}
+}
+
+cmdline.arguments = function(param,...){
+    if(!param)return {};
+    if(type(param)==="table") return param,...;
+    
+    param = ..string.trim(param);
+	if( (!...) && ..string.find(param,"\s+")){
+		
+		if( param[1] != '"'# || param[#v] != '"'#  ){
+			var p = ..string.cmdline(" " + param ); 
+			p[0] = null;
+			return p;
+		} 
+	}
+	return {param;...}
+}
+
+cmdline.argv = function(str){
+	var r = cmdline(str); 
+	
+	var n1,n2;
+	var p1,p2;
+	for(i=1;#r){
+		n2 = r[i];
+		p2 = n2[1]
+		
+		if(n1 && p2!=p1) r[n1] = n2; 
+		elseif(p2=='-'# || p2=='/'#){
+			n2 = ..string.trimleft(n2,n2[[1]]);
+			var k,v = ..string.match(n2,"(.+?)\=(.+)");
+			if(k && v){
+				r[k] = v;
+			}
+			else{
+				r[n2] = ""
+				n1 = n2;
+				p1 = p2;
+				continue;
+			}
+		}
+	
+		n1 = null;
+		p1 = null;
+	}
+	
+	return r;
+}
+
+/**intellisense()
+string.cmdline = 命令行解析
+string.cmdline( = 解析命令行,返回数组\n该数组可修改后调用 tostring 函数反解析为字符串文本\n参数不是字符串、或为空串返回 null
+string.cmdline(.("命令行") = 所有【参数段】以空格或制表等分开\n在一对双引号中表示的【引用段】则可以包含空格\n两个连续的引号表示一个引号字符并且关闭【引用段】\n关闭【引用段】后的非空格字符或引用段仍然追加其后\n\n一个或多个连续的反斜杠如果最后有一个引号则启用转义\n单个反斜杠转义其后的引号或反斜杠表示字面值\n\n首个索引为0的参数段要么是引号包含的引用段,或是任意非空白字符组成
+string.cmdline.arguments( = 解析并转换创建进程的命令行参数
+string.cmdline.arguments(.(命令行参数->->->) = 解析并转换创建进程的命令行参数,\n将一个或多个命令行参数转换为数组,\n如果参数@1是一个表,则直接返回所有参数,\n如只有一个文本参数且含空格、首尾无双引号则解析并返回数组,\n否则直接将所有参数置入数组返回,\n\n返回数组不包含索引为0的启动程序路径,\n返回数组可传入 process.joinArguments 函数 或 process 构造函数作为参数
+string.cmdline.argv( = 调用 string.cmdline 解析命令行参数并返回数组,\n该数组也包含按下列规则解析的名值对:\n以斜杠或短横线开始的前导参数作为键(键名移除一个或多个相同的前导字符,区分大小写)，\n如果前导参数包含等号,则以等号拆分为键值对,等号前后不应有空格,\n否则检查下一参数如果没有相同的首字符则设为此键对应的值，\n如果一个前导参数没有指定值,则默认值为空字符串（逻辑值为true）
+string.cmdline.argv(.("命令行") = 调用 string.cmdline 解析命令行参数并返回数组,\n该数组也包含解析后的名值对。\n\n解析名值对时忽略索引为0的参数,\n首个索引为0的参数段要么是引号包含的引用段,或是任意非空白字符组成,\n命令行以空白字符开始表示索引为 0 的参数为空
+string.cmdline.argv() = !stringCmdlineArgv.
+!stringCmdlineArgv.? = 请输入命令行参数中以斜杠或短横线开始的前导参数名
+end intellisense**/