//reg 注册表操作
namespace win; 

class reg{
	ctor(rpath,openExisting,root,samDesired,createOption,securityAttributes,retrySamDesired){
		if( type(rpath) == type.number ){ 
			this.handle = rpath;
			var len = {INT value}
        	var ret = ::Ntdll.NtQueryKey(this.handle, 3, 0, 0, len); 
        	if (ret == -1073741789/*_STATUS_BUFFER_TOO_SMALL*/) {
            	var buffer = ..raw.buffer(len.value)
            	ret = ::Ntdll.NtQueryKey(this.handle, 3, buffer, len.value, len);
            	if (ret == 0/*_STATUS_SUCCESS*/){
                	var path = ..string.right(..string.fromUtf16(buffer),-4); 
                	path = ..string.replace(path,"^\\REGISTRY\\MACHINE\\","HKEY_LOCAL_MACHINE\");
 					this.path = ..string.replace(path,"^\\REGISTRY\USER\\","HKEY_USERS\");
            	}
        	}
        }
		elseif( type(rpath) != type.string ) error("注册表路径必须是字符串对象",2);
		else{
			if(!root){
				this.path = rpath;
				var sep = ..string.indexAny( rpath,"\" );  
				if(sep){
					var lpath = ..string.left(rpath,sep-1);
					rpath = ..string.slice(rpath,sep+1) 
					root = assert( __predefinedKeys[lpath],'错误的注册表路径\n注册表路径必须使用斜杠"\\"分隔路径'); 
				}
				else{
						this.handle = __predefinedKeys[rpath]
						assert( this.handle,"错误的注册表路径");  
				}
			}
				
			if(not this.handle){
				if( samDesired===null){
					samDesired = 0xF003F/*_KEY_ALL_ACCESS*/;
					retrySamDesired = true; 
				}
				elseif( ( samDesired & ~( 0x200/*_KEY_WOW64_32KEY*/   | 0x0100/*_KEY_WOW64_64KEY*/ ) ) == 0  ) {
					samDesired = samDesired | 0xF003F/*_KEY_ALL_ACCESS*/;
					retrySamDesired = true;   
				}
				
				var re,tempkey = RegOpenKeyEx( root ,rpath ,0,samDesired,0 ); 
				if( re==0x5/*_ERROR_ACCESS_DENIED*/ && retrySamDesired  ){
					samDesired = samDesired & ( 0x200/*_KEY_WOW64_32KEY*/   | 0x0100/*_KEY_WOW64_64KEY*/ ); 
					re,tempkey = RegOpenKeyEx( root ,rpath ,0,0x20019/*_KEY_READ*/ | 0x20006/*_KEY_WRITE*/ | samDesired,0 ); 
					if( re==0x5/*_ERROR_ACCESS_DENIED*/  ){
						re,tempkey = RegOpenKeyEx( root ,rpath ,0,0x20019/*_KEY_READ*/ | samDesired,0 ); 
						if( re==0x5/*_ERROR_ACCESS_DENIED*/  ){  
							re,tempkey = RegOpenKeyEx( root ,rpath ,0,0x20000/*_STANDARD_RIGHTS_READ*/ | 0x1/*_KEY_QUERY_VALUE*/ | samDesired,0 );
						} 
					}
				} 
				
				if( !tempkey ){
					if(openExisting)
						return null,"打开注册表出错!",re; 
						
					if(!securityAttributes) securityAttributes = {};
					if(createOption===null) createOption = 0/*_REG_OPTION_NON_VOLATILE*/;
					re,tempkey,disposition = RegCreateKeyEx( root ,rpath,0,/*lpClass*/,createOption,samDesired,securityAttributes,0,0 );
						
					if( re==0x5/*_ERROR_ACCESS_DENIED*/  ){
						samDesired = samDesired & ( 0x200/*_KEY_WOW64_32KEY*/   | 0x0100/*_KEY_WOW64_64KEY*/ );
						re,tempkey,disposition = RegCreateKeyEx( root ,rpath,0,/*lpClass*/,createOption
						,samDesired | 0x20019/*_KEY_READ*/ | 0x20006/*_KEY_WRITE*/,securityAttributes,0,0 );
					}
				}
					
					if (re != 0/*_ERROR_SUCCESS*/ )
					return null,"打开注册表出错!",re;
						
				this.handle = tempkey; 
			}
		} 
	};
	eachKey = function(len=256){ 
		var index = 0;
		return function(){ 
			var re,lpName,,,,lastWriteTime = RegEnumKeyEx(this.handle,index,len,len,/*lpReserved*/,0,0, ::FILETIME() );
			if (re != 0/*_ERROR_SUCCESS*/ ) return null,re;
			index++;
			return ..string.str(lpName),lastWriteTime;
		}
	
	};
	keys = function(len){
		var r ={};
		for(name in this.eachKey(len) ){
			..table.push(r,name);  
		}
		return r;	
	};
	enumKey = function(proc,len=256){
		var keys = this.keys(len);
		var name,sub;
		for(i=1;#keys){
			name = keys[i];
			sub=this.open(name); 
			if(sub){
				sub.enumKey(proc,len);
				sub.close();	
			}
			proc(this,name); 
		}
	};
	eachValue = function (cbBuffer=256) {
		var index = 0;
		var buffer = ..raw.buffer(cbBuffer);
		return function () {
			var re, name, namelen, vType, cbBuffer = RegEnumValue(this.handle, index
				, 256, 256, , 0, buffer, #buffer);
				
			if(re == 0xEA/*_ERROR_MORE_DATA*/){
				buffer = ..raw.buffer(cbBuffer);
				re, name, namelen, vType, cbBuffer = RegEnumValue(this.handle, index
					, 256, 256, , 0, buffer, #buffer);
			}
			
			if (re == 0x103/*_ERROR_NO_MORE_ITEMS*/ || re ) return null;
		
			var value;
			if( vType == 0x4/*_REG_DWORD*/){
				value = ..raw.convert(buffer,{INT v }).v; 
			}
			elseif (  vType == 1/*_REG_SZ*/ || vType == 2/*_REG_EXPAND_SZ*/  ){
				value = ..string.fromUtf16(buffer,,cbBuffer>=2 ? cbBuffer/2 - 1 : 0);
			}
			elseif ( vType == 7/*_REG_MULTI_SZ*/ ){ 
				value = ..string.fromUtf16(buffer,,cbBuffer>=2 ? cbBuffer/2 - 1 : 0);
					value = ..string.trimright(value,'\0');
					value = ..string.split(value,'\0');
			}
			elseif ( vType == 3/*_REG_BINARY*/ ){ 
				value = ..raw.buffer(cbBuffer,buffer);
			}
			elseif( vType == 0x5/*_REG_DWORD_BIG_ENDIAN*/){
				value = ..raw.convert(buffer,{INT v});
				value = ..raw.swap(value.v,"INT"); 
			}
			elseif( vType == 0xB/*_REG_QWORD*/){
				value = ..raw.convert(buffer,{ LONG v = ..math.size64() }).v;
			}
			
			index++;
			return name, value, vType;
		}
	};
	setDwValue = function(name,value) {
		var res=RegSetValueEx( this.handle,name,0,0x4/*_REG_DWORD*/,{INT dw = value },4);
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setDwValueBigEndian = function( name,value) {	
		res=RegSetValueEx( this.handle,name,0,0x5/*_REG_DWORD_BIG_ENDIAN*/,{INT dw = ..raw.swap(value,"INT") },4);
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setQwValue = function( name,value,value2) {
		var res=RegSetValueEx( this.handle,name,0,0xB/*_REG_QWORD*/
			,{LONG qw =..math.isSize64(value) ? value : ..math.size64(value,value2)},8);
			
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setSzValue = function( name,value)  {
		value = ..string.toUtf16(value);
		var res=RegSetValueExBinary( this.handle,name,0,0x1/*_REG_SZ*/,value,#value+2);
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setExpandValue = function( name,value)  {
		value = ..string.toUtf16(value);
		var res=RegSetValueExBinary( this.handle,name,0,2/*_REG_EXPAND_SZ*/,value,#value+2);
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setMultiSzValue = function( name,...)  {
		var v = ( type(...) == type.table ) ? ... : {...};
		v = ..string.join(v,'\0');
		if(  ..string.endsWith( v,'\0\0') == false) v ++= '\0\0';
		
		v = ..string.toUtf16(v);
		var res =RegSetValueExBinary( this.handle,name,0,0x7/*_REG_MULTI_SZ*/,v,#v );
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setBinValue = function(name,value) { 
		var res=RegSetValueExBinary( this.handle,name,0,0x3/*_REG_BINARY*/,value,#value);
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	setValue = function(n,v){
		var t = type(v);
		if(t==="number") this.setDwValue(n,v);
		elseif(t==="string") this.setSzValue(n,v);
		elseif(t==="buffer") this.setBinValue(n,v);
		elseif(t==="table") this.setMultiSzValue(n,v);
		elseif(..math.size64(v)) this.setQwValue(n,v);
		elseif(v===null) this.delValue(n);
		else this.setSzValue(n,tostring(v));
	};
	queryValueTable = function(r,...) {
		r = r : {} 
		if(type(r)!="table") r={r,...}
		
		if(#r){
			var t,k = {};
			for(i=1;#r;1){
				k = r[i];
				if(type(k)==="string") t[k] = owner.queryValue(k)
			} 
			
			return (t[r[1]]!==null) ? t : null;
		}
		
		for(name,value in owner.eachValue()) {
			r[name] = value;
		}
		return r;
	};
	queryValue = function(name) { 
		var r,t,len = RegQueryValueExLen( this.handle,name,0,0,null,0);
		if(r!=0 || !len) return null;

		select(t) { 
			case 0x1/*_REG_SZ*/,0x2/*_REG_EXPAND_SZ*/ {
				r,t,p,len = RegQueryValueExBinary( this.handle,name,0,0,len,len); 
				return ..string.fromUtf16(p,,-1);
			}
			case 0x4/*_REG_DWORD*/ {
				r,t,p,len = RegQueryValueEx( this.handle,name,0,0,{INT val },len);
				return p.val,t;
			}
			case 0x3/*_REG_BINARY*/ {
				var buf = ..raw.buffer(len);
				r,t,p,len = RegQueryValueExBinary( this.handle,name,0,0,buf,len);
				return p,t;
			} 
			case 0x7/*_REG_MULTI_SZ*/ {
				r,t,p,len = RegQueryValueExBinary( this.handle,name,0,0,len,len);
				p = ..string.fromUtf16(p);
				p = ..string.trimright(p,'\0');
				p = ..string.split(p,'\0');
				return p,t;
			} 
			case 0xB/*_REG_QWORD*/ {
				r,t,p,len = RegQueryValueEx( this.handle,name,0,0,{LONG v = ..math.size64()},len);
				return p.v,t;
			}   
			case 0x5/*_REG_DWORD_BIG_ENDIAN*/ {
				r,t,p,len = RegQueryValueEx( this.handle,name,0,0,{INT v },len); 
				return ..raw.swap(p.v,"INT"),t;
			}
		}
		return null;
	};
	delValue = function(name) {
		var res=RegDeleteValue(this.handle,name);
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	delKey = function(name) {
		var res=RegDeleteKey(this.handle,name); 
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	delKeyTree = function(name) {
		var k = this.open(name,true);
		if(!k) return false;
		
		k.enumKey(
			function(cur,kn){
				RegDeleteKey(cur.handle,kn); 
			}
		)
		k.close();
		
		var res=RegDeleteKey(this.handle,name); 
		if (res!=0/*_ERROR_SUCCESS*/) return null,res;
		return true; 
	};
	renameKey = function(newName) {
		newName =..string.toUtf16(newName);
		return ::Ntdll.NtRenameKey(this.handle, {
			WORD len = #newName;
			WORD max =  #newName + 2;
			ustring buf = ..raw.buffer(newName);
		});
	};
	queryTable = function(names,...){
		if(type(names)!="table") names={names,...}
		var a = {};
		for k in this.eachKey() {
			var r = this.open(k,true);
			if(r){
				a[k] = r.queryValueTable(names);
				r.close();
			}
		}
		
		return a;
	};
	open = function(subpath, openExisting ){
		reg =  ..win.reg(subpath,openExisting,this.handle,samDesired,createOption,securityAttributes);
		if(reg){
			reg.path =  ..string.concat(this.path , "\" , subpath);
			return reg;
		}
	};
	//@Deprecated
	openReg = function(...){
		return this.open(...);
	};
	close = function(){
			if (this.handle){
				RegCloseKey(this.handle);
				this.handle=null;
			}
	};
	save = function( filepath ){   
		setprivilege('SeBackupPrivilege',true)     
		ret = RegSaveKey(this.handle, ..io.fullpath(filepath) );  
		return !ret   
		
	};
	load = function(filepath){   
		setprivilege('SeRestorePrivilege',true)   
		ret = RegRestoreKey(this.handle, ..io.fullpath(filepath) ,0x00000008/*_REG_FORCE_RESTORE*/  ) 
		return !ret;
	};
	getValue = this.queryValue;//@Deprecated
	get = this.queryValue;//@Deprecated
	set = setValue;//@Deprecated
}

namespace reg{
	::Advapi32 :=  ..raw.loadDll("Advapi32.dll")
	RegCreateKeyEx = Advapi32.api("RegCreateKeyExW","int( addr hKey,ustring subKey,INT Reserved,ustring lpClass,INT opt,INT samDesired,struct lpSecurityAttributes,addr &phk,INT &lpdwDisposition)" );
	RegOpenKeyEx = Advapi32.api("RegOpenKeyExW","int(addr hKey,ustring subKey,INT ulOpt,INT samDesired,addr &phk)" ); 
	RegCloseKey = Advapi32.api("RegCloseKey","int(addr hKey)" );
	RegDeleteValue = Advapi32.api("RegDeleteValue","int(addr hKey,ustring name)" )
	RegDeleteKey = Advapi32.api("RegDeleteKey","int(addr hKey,ustring lpSubKey)" )
		
	RegSetValueExBinary = Advapi32.api("RegSetValueEx","int(addr hKey,ustring name,INT Reserved,INT dwType,string lpData,INT cbData)" ); 
	RegQueryValueExBinary = Advapi32.api("RegQueryValueEx","int(addr hKey,ustring name,INT Reserved,INT &dwType,string&lpData,INT&lpcbData)" ); 

	RegSetValueEx = Advapi32.api("RegSetValueEx","int(addr hKey,ustring name,INT Reserved,INT dwType,struct lpData,INT cbData)" ); 
	RegQueryValueEx = Advapi32.api("RegQueryValueEx","int(addr hKey,ustring name,INT Reserved,INT &dwType,struct&lpData,INT&lpcbData)" ); 
	RegQueryValueExLen = Advapi32.api("RegQueryValueEx","int(addr hKey,ustring name,INT Reserved,INT &dwType,pointer lpData,INT&lpcbData)" ); 
		
	RegSaveKey =  Advapi32.api("RegSaveKey","int(addr hKey,ustring lpFile,pointer lpSecurityAttributes)")
	RegRestoreKey = Advapi32.api("RegRestoreKey","int(addr hKey,ustring lpFile,int dwFlags)")
	
	RegEnumValue = Advapi32.api("RegEnumValue","int(addr hKey,int index,ustring &name,int& cbValueName,pointer reserved,int& lpType,ptr lpData,int& cbData)")
	RegEnumKeyEx = Advapi32.api("RegEnumKeyExW","int(addr hKey,int dwIndex,ustring &lpName,int& lpcchName,pointer lpReserved,ustring &lpClass,int& lpcchClass,struct& lpftLastWriteTime)")
	RegOverridePredefKey = Advapi32.api("RegOverridePredefKey","int(addr hKey,addr lpSubKey)" )
	
	namespace __predefinedKeys{
		HKEY_CLASSES_ROOT=0x80000000;
		HKCR=0x80000000;
		HKEY_CURRENT_USER=0x80000001;
		HKCU=0x80000001;
		HKEY_LOCAL_MACHINE=0x80000002;
		HKLM=0x80000002;
		HKEY_USERS=0x80000003;
		HKEY_PERFORMANCE_DATA=0x80000004;
		HKEY_PERFORMANCE_TEXT=0x80000050;
		HKEY_PERFORMANCE_NLSTEXT=0x80000060;
		HKEY_CURRENT_CONFIG=0x80000005;
		HKEY_DYN_DATA=0x80000006;
		HKEY_CURRENT_USER_LOCAL_SETTINGS=0x80000007;
	}  
	
	overrideClasses = function(runas,proc){
		if(runas){ proc(); return true; }
		return overridePredefinedKey("HKEY_CLASSES_ROOT","HKEY_CURRENT_USER\Software\Classes",proc)
	}
	
	overridePredefinedKey = function(pred,rpath,proc){
		var predKey = pred ? __predefinedKeys[pred]
			if(!predKey) error("错误参数@1:注册表预定义键名字错误",2);
			
			if( type(rpath) != type.string ) error("错误参数@2:注册表重定向路径必须是字符串对象",2);
			if( __predefinedKeys[rpath] ) error("错误参数@2:注册表重定向路径不能是根键名字",2);
			var reg,err = ..win.reg(rpath);
			if(!reg) return null,err;
			
			if(!proc) error("错误参数@3:请指定回调函数",2);
			var err = RegOverridePredefKey(predKey,reg.handle);
			reg.close();
			
			if( 0x0/*_ERROR_SUCCESS*/ == err ){
				proc();
				RegOverridePredefKey(predKey,0); 
				return true;
			}
		return null,err;
	}
	
	query = function(path,valueName){
		var reg = ..win.regReader(path)
		if(reg){
			var v = reg.queryValue(valueName:"")
			reg.close()
			return v;
		}	
	}
	
	queryWow64 = function(path,valueName){
		var reg = ..win.regReaderWow64(path)
		if(reg){
			var v = reg.queryValue(valueName:"")
			reg.close()
			return v;
		}
	}
}

regWow64 = function(rpath,openExisting,root,samDesired,createOption,securityAttributes){
	if(samDesired===null) samDesired = 0xF003F/*_KEY_ALL_ACCESS*/;
	return reg(rpath,openExisting,root, ( samDesired & ~0x200/*_KEY_WOW64_32KEY*/ ) | 0x0100/*_KEY_WOW64_64KEY*/
		,createOption,securityAttributes,true )
}

regWow32 = function(rpath,openExisting,root,samDesired,createOption,securityAttributes){
	if(samDesired===null) samDesired = 0xF003F/*_KEY_ALL_ACCESS*/;
	return reg(rpath,openExisting,root, ( samDesired & ~0x0100/*_KEY_WOW64_64KEY*/ ) | 0x200/*_KEY_WOW64_32KEY*/
		,createOption,securityAttributes,true )
}

regReader = function(rpath,createOption,securityAttributes){ 
	return reg(rpath,true,, 0x20019/*_KEY_READ*/,createOption,securityAttributes )
}

regReaderWow64 = function(rpath,createOption,securityAttributes){ 
	return reg(rpath,true,, 0x20019/*_KEY_READ*/ | 0x0100/*_KEY_WOW64_64KEY*/,createOption,securityAttributes )
}

/*
注册表 WOW64 重定向、共享、反射键列表：
https://learn.microsoft.com/en-us/windows/win32/winprog64/shared-registry-keys
参考标准库： fsys.wow64, process.wow64
*/

/**intellisense()
win.reg = 注册表操作
win.reg( = 打开或创建注册表路径
win.reg(.(path) = 打开或创建注册表路径，\n@path 参数指定注册表路径。\n\n此函数还有其他可选参数，一般不必指定
win.reg(.(path,true) = 仅打开已存在的注册表路径，\n@path 参数指定注册表路径。\n\n此函数还有其他可选参数，一般不必指定
win.regReaderWow64("HKEY_LOCAL_MACHINE__") = 在64位系统中访问64位注册表,\n32位系统作用与 win.regReader 相同,\n仅仅以只读模式打开存在的注册表路径,如果不存在返回nulll\n此函数显式指定只读权限速度较快
win.regReader("HKEY_CURRENT_USER__") = 仅仅以只读模式打开存在的注册表路径,如果不存在返回null\n此函数显式指定只读权限速度较快
win.regWow64("HKEY_LOCAL_MACHINE__") = 打开已存在或创建新的注册表路径,\n在64位系统中访问64位注册表,\n32位系统下作用与 win.reg 相同
win.regWow64("HKEY_LOCAL_MACHINE__",true) = 仅仅打开存在的注册表路径,\n在64位系统中访问64位注册表,\n32位系统下作用与 win.reg 相同,\n如果不存在返回null
win.regWow32("HKEY_LOCAL_MACHINE__") = 打开已存在或创建新的注册表路径,\n在64位系统中访问32位注册表,\n32位系统下作用与 win.reg 相同
win.regWow32("HKEY_LOCAL_MACHINE__",true) = 仅仅打开存在的注册表路径,\n在64位系统中访问32位注册表,\n32位系统下作用与 win.reg 相同,\n如果不存在返回null
win.reg.overridePredefinedKey("根键","重定向键",回调函数) = @.overridePredefinedKey("HKEY_CLASSES_ROOT","HKEY_CURRENT_USER\Software\Classes",\n    function(){\n        __/*注册表已成功重定向*/\n    }\n);
win.reg.overrideClasses(runas,proc) = @.overrideClasses(false,\n	function(){\n		__/*重定向HKEY_CLASSES_ROOT到HKEY_CURRENT_USER\Software\Classes*/\n	}\n)
win.reg.queryWow64( = 直接读取注册表路径的指定值,\n在64位系统访问64位注册表,兼容 32 位系统
win.reg.queryWow64(.(path,valueName) = 返回 @path 参数指定的注册表路径下\n@valueName 指定名字的值,失败返回 null\n在64位系统访问64位注册表,兼容 32 位系统
win.reg.query( = 直接读取注册表路径的指定值
win.reg.query(.(path,valueName) = 返回 @path 参数指定的注册表路径下 \n @valueName 指定名字的值,失败返回 null
!win_reg.setValue(.(name,vlaue) = 设置注册表值，自动设置类型，\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 指定要存储的值
!win_reg.setDwValue(.(name,vlaue) = 设置32位数值,\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 指定要存储的值
!win_reg.setDwValueBigEndian(.(name,vlaue) = 设置大端序 32 位数值，\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 指定要存储的值
!win_reg.setQwValue(.(name,vlaue) = 设置64位数值,\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 支持 math.size64 对象表示的 64 位长整数或普通数值
!win_reg.setSzValue(.(name,vlaue) = 设置字符串值,\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 指定要存储的值
!win_reg.setExpandValue(.(name,vlaue) = 设置含环境变量的字符串值,\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 指定要存储的值
!win_reg.setMultiSzValue(.(name,vlaue) = 设置复合字符串值，\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 可用字符串数组指定要存储的值，\n也可以用多个参数传递多个字符串值
!win_reg.setBinValue(.(name,vlaue) = 设置二进制值，\n参数 @1 指定值名称（null 或 空串表示默认值），\n参数 @2 指定要存储的值
!win_reg.queryValue("__") = 查询值，\n参数 @1 指定值名称（null 或 空串表示默认值）。\n成功返回值1为查询到的数据值，返回值2为一个表示值类型的数值，\n自动识别类型:\nREG_SZ,REG_EXPAND_SZ 类型返回字符串,\nREG_EXPAND_SZ 字符串可用 string.expand 函数展开,\nREG_MULTE_SZ 类型返回字符串数组，\nREG_BINARY类型返回buffer对象,REG_DWORD类型返回数值，\nREG_QWORD类型返回math.size64对象表示的64位无符号长整数，\nREG_DWORD，REG_DWORD_BIG_ENDIAN类型返回数值
!win_reg.queryValueTable( = 返回表，包含当前键的指定名值对
!win_reg.queryValueTable(.() = 返回表，包含当前键的所有名值对
!win_reg.queryValueTable(.(default) = 参数 @default 指定默认值\n在参数 @1 中填入当前键的所有名值对\n返回参数 @1
!win_reg.queryValueTable(.(names,->->->) = 返回表，包含当前键的指定名值对\n@names 参数可以是一个要查询的值名称数组,\n也可以是用于指定查询值名称的一个或多个字符串参数,\n第一个值名称指定的值为 null 则返回 null,
!win_reg.queryTable(.(names,->->->) = 遍历当前注册表项的所有子项,\n获取 @names 指定名称的所有值,\n@names 可以是名称数组,也可以是多个字符串参数,\n返回值是表,表的键为子项名称，值为包含各子项名值对的表,\n如果子项第一个值名称对应的值为 null 则忽略该项,\n失败返回 null
!win_reg.renameKey("__") = 重命名当前打开的键\n参数只要写新的键名就可以,不要在参数中写包含反斜杠的注册表路径
!win_reg.delValue("__") = 删除值，\n参数 @1 指定值名称（null 或 空串表示默认值）。
!win_reg.delKey("__") = 删除不包含子项的键
!win_reg.delKeyTree("__") = 删除包含子项的键,\n请慎用以避免删除重要的注册表键
!win_reg.close() = 关闭注册表对象 
!win_reg.save("/backup__") = 导出注册表到文件
!win_reg.load("/backup__") = 从文件导入到注册表
!win_reg.open("__") = 打开已存在或创建新的子路径,\n返回新的win.reg对象,
!win_reg.open("__",true) = 仅仅打开已存在的子路径,\n返回新的win.reg对象,\n如果不存在返回null
!win_reg.keys() = 获取所有子键的键名
!win_reg.eachKey = @for(name,writeTime in reg.eachKey() ){
	var subKey = reg.open(name); 
	__/*name 为子键名,\nwriteTime 为 ::FILETIME 结构体,\n可用 fsys.time 解析*/
	subKey.close()
}
!win_reg.enumKey = @.enumKey(\n\n	function(\n		subKey, /*这是某个子节点(win.reg对象)*/\n		keyname/*这是reg子节点的一个子项的名字*/\n	){  \n		if( subKey.delKey(keyname)  )\n			io.print("删除" + keyname + "成功") \n	}  \n) 
!win_reg.eachValue = @for(name,value,t in reg.eachValue()) {
	__
}
!win_reg.path = 注册表路径
win.regReader() = !win_reg.
win.regWow32() = !win_reg.
win.regWow64() = !win_reg.
win.regReaderWow64() = !win_reg.
win.reg() = !win_reg.
!win_reg.open() = !win_reg.

_REG_BINARY=@3/*_REG_BINARY*/
_REG_CREATED_NEW_KEY=@1/*_REG_CREATED_NEW_KEY*/
_REG_DWORD=@4/*_REG_DWORD*/
_REG_QWORD=@0xB/*_REG_QWORD*/ 
_REG_DWORD_BIG_ENDIAN=@5/*_REG_DWORD_BIG_ENDIAN*/
_REG_DWORD_LITTLE_ENDIAN=@4/*_REG_DWORD_LITTLE_ENDIAN*/
_REG_EXPAND_SZ=@2/*_REG_EXPAND_SZ*/
_REG_FULL_RESOURCE_DESCRIPTOR=@9/*_REG_FULL_RESOURCE_DESCRIPTOR*/
_REG_LINK=@6/*_REG_LINK*/
_REG_MULTI_SZ=@7/*_REG_MULTI_SZ*/
_REG_NONE=@0/*_REG_NONE*/
_REG_NOTIFY_CHANGE_ATTRIBUTES=@2/*_REG_NOTIFY_CHANGE_ATTRIBUTES*/
_REG_NOTIFY_CHANGE_LAST_SET=@4/*_REG_NOTIFY_CHANGE_LAST_SET*/
_REG_NOTIFY_CHANGE_NAME=@1/*_REG_NOTIFY_CHANGE_NAME*/
_REG_NOTIFY_CHANGE_SECURITY=@8/*_REG_NOTIFY_CHANGE_SECURITY*/
_REG_OPENED_EXISTING_KEY=@2/*_REG_OPENED_EXISTING_KEY*/
_REG_OPTION_BACKUP_RESTORE=@4/*_REG_OPTION_BACKUP_RESTORE*/
_REG_OPTION_CREATE_LINK=@2/*_REG_OPTION_CREATE_LINK*/
_REG_OPTION_NON_VOLATILE=@0/*_REG_OPTION_NON_VOLATILE*/
_REG_OPTION_RESERVED=@0/*_REG_OPTION_RESERVED*/
_REG_OPTION_VOLATILE=@1/*_REG_OPTION_VOLATILE*/
_REG_REFRESH_HIVE=@2/*_REG_REFRESH_HIVE*/
_REG_RESOURCE_LIST=@8/*_REG_RESOURCE_LIST*/
_REG_RESOURCE_REQUIREMENTS_LIST=@0xA/*_REG_RESOURCE_REQUIREMENTS_LIST*/
_REG_SZ=@1/*_REG_SZ*/
_REG_WHOLE_HIVE_VOLATILE=@1/*_REG_WHOLE_HIVE_VOLATILE*/
end intellisense**/