//raw 原生类型
namespace builtin;
self.raw = global.raw;

namespace raw{
	convertArray = function(p,l,t="pointer"){
		if(!p) return; 
		
		var a; 
		if(type(t)=="class") t = t();
		
		if( !t[["_struct"]] ) a = toarray(l,t,"v" );
		else{
	    	a = toarray(l,"struct","v");a.v = [t];
		} 
		
		return convert(p,a).v;
	};
	
	mixin = function(p,s,v,...){
 		if(v){
    		convert(p, s);
    		..table.assign(s,v,...)
    	}
    	convert(s,p);
    	return s;
	};
	
	dup = function(h,src,dst,inherit){
		var t = {ptr v}
		if( ::Kernel32.DuplicateHandle(src:-1,h,dst :-1,t,0,inherit,2) ) return t.v;
	};
	
	serializeDupHandle = function(cls,handle){ 
		return ..string.format("global.import('%s') : %s( ..raw.dup(topointer(0x%p)),true)",cls,cls,topointer(handle) );
	};

	__module__ = {};
	module = function(cal){
		if(!cal)cal="stdcall";
		if( __module__[cal] ) return __module__[cal];
		__module__[cal] = loadDll(,,cal); 
		return __module__[cal];
	};
	
	main = module("stdcall");
	
	class number {
		ctor(t,v){
			this = v;
			this.type = t;
		};
		@_meta;
	};
	
	number._meta = {
		_tonumber=lambda() owner.value;
		_number_type=lambda() owner.type;
		_tostring=lambda() tostring(owner.value);
		_json=function() { return tostring(owner.value),true}; 
		_eq = lambda(v) owner.value = v.value;
		_type="raw.number";
	}; 
	
	double = lambda(v,ref) number("double",ref?{double value=v}:{value = v});
	float = lambda(v,ref) number("float",ref?{float value=v}:{value = v});
	byte = lambda(v,ref) number("byte",ref?{byte value=v}:{value = v});
	ubyte = lambda(v,ref) number("BYTE",ref?{BYTE value=v}:{value = v});
	word = lambda(v,ref) number("word",ref?{word value=v}:{value = v});
	uword = lambda(v,ref) number("WORD",ref?{WORD value=v}:{value = v});
	int = lambda(v,ref) number("int",ref?{int value=v}:{value = v});
	uint = lambda(v,ref) number("INT",ref?{INT value=v}:{value = v});
	long = lambda(v,ref) number("long",ref?{long value=v}:{value = v});
	ulong = lambda(v,ref) number("LONG",ref?{LONG value=v}:{value = v}); 
	
	join = function(arr,sep,b,e){
		var ls = #sep;
		var len = -ls;
		
		b,e = ..math.validateRange(#arr,b,e);
		if(!b) return;

		for(i=b;e)len = len + #arr[i] + ls;
	 	if(!len) return;
	 	
		var buf = buffer(len);
		
		len = 0;
		for(i=b;e){ 
			len = concat(buf,arr[i],len);
			if(ls) len = concat(buf,sep,len);
		} 
 		
 		return buf;
	}
	
	slice = function(b,i,j,l){
		i,j = ..math.validateRange(l||#b,i,j);
		if(i) return buffer(j-i+1,toPointer(b,i-1));
	}
	
	typeOfArray = function(v){
		return ..string.match(v[["_struct"]]:"","(\a+)\s+([^,\[\s]+)\[");
	} 
	
	malloc = buffer;//@Deprecated
}

raw.execute = function(file,param,op,show,dir,hwnd){  
	return 32 < ::Shell32.ShellExecute(hwnd || ::User32.GetActiveWindow(),op,..io.localpath(file)||file||"",param,dir,show===null?5/*_SW_SHOW*/:show); 
}

raw.explore = function(path,...){
	var args = {...};
	if(path) ..table.push(args,..io.localpath(path)||path); 
	return raw.execute( "Explorer.exe" , ..string.join(args,",") );
}

/**intellisense(raw)
mixin(.(指针,结构体对象,任意个混入表->->->) = 如果未指定参数 @3 此函数将参数 @2 指定的结构体复制到参数 @1 指定的内存，\n然后返回结构体。\n\n否则将参数 @1 指定的内存数据先复制到参数 @2 指定的结构体。\n然后将后续的所有表参数（仅包含需要修改的字段）调用  table.assign 函数混入到结构体中。\n然后再将被填充的结构体复制到参数 @1 指定的内存。\n\n例如代码 `raw.minxin(ptr,{int x;int y},{y=123})` 只会修改内存中的 y 字段。\n而 `raw.minxin(ptr,{int x;int y})` 则会将 x,y 字段都清零。
convertArray(.(源内存指针,源数组长度,"数据类型") = 将指针指向的内存转换为普通数组,传入空指针返回空值\n数据类型参数可省略,默认为"pointer"\n类型类型也可以直接传入一个结构体实例对象。\n注意该函数不会检测内存溢出错误,调用该函数时必须保证数组长度是正确的值
dup(.(源句柄,源进程,目标进程,允许子进程继承) = 返回复制的系统句柄\n除参数1之外,其他参数可选\n默认仅在当前进程中复制句柄\n复制的句柄应使用raw.closehandle释放
serializeDupHandle(.("类名",句柄) = 复制进程内有效句柄并序列化对象\n只能用于_serialize元方法，且必须kernelCall参数为真\n序列化类构造函数必须支持指针参数1为指针类型句柄,参数2为true的参数\n并负责在析构函数中调用 raw.closehandle 释放该句柄
module() = !dllModule.
module(.("调用约定") = 指定约定并返回进程主模块, \n省略参数时调用约定默认为stdcall,\n可用于将当前进程中的函数指针转换为aardio函数,
main = 进程主模块,默认调用约定为stdcall\n与raw.module("stdcall")返回的值相同,\n可用于将当前进程中的函数指针转换为aardio函数\n!dllModule.

double(__) = 转换参数@1指定的数值为 double 类型数值（64位浮点数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.double 函数
float(__) = 转换参数@1指定的数值为 float 类型数值（32位浮点数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.float 函数
byte(__) = 转换参数@1指定的数值为 byte 类型数值（8位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.byte 函数
ubyte(__) = 转换参数@1指定的数值为 BYTE 类型数值（8位无符号整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.ubyte 函数,\n注意在原生类型中使用大写的 BYTE 类型表示8位无符号整数
word(__) = 转换参数@1指定的数值为 word 类型数值（16位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.word 函数
uword(__) = 转换参数@1指定的数值为 WORD 类型数值（16位无符号整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.uword 函数,\n注意在原生类型中使用大写的 WORD 类型表示16位无符号整数
int(__) = 转换参数@1指定的数值为 int 类型数值（32位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.int 函数
uint(__) = 转换参数@1指定的数值为 INT 类型数值（32位无符号整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.uint 函数,\n注意在原生类型中使用大写的 INT 类型表示32位无符号整数
long(__) = 转换参数@1指定的数值为 long 类型数值（64位整数）包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.long 函数
ulong(__) = 参数@1可传入数值或 math.size64 对象,\n返回适用于 LONG 类型数值（64位无符号整数）的包装对象,\n返回对象支持 tonumber tostring 等类型转换函数。\n\n用于调用非声明式原生 API 函数的参数,\n默认传值,参数@2为 true 则用于传址参数（传数值的指针）。\n\n用于 COM 函数参数则总是传值, COM 函数也可使用 com.ulong 函数,\n注意在原生类型中使用大写的 LONG 类型表示64位无符号整数
execute( = 运行外部程序，成功返回 true。\n process.execute 函数提供类似的功能，区别可参考函数源码
execute(.(file,param,operation,showCmd,workDir,hwnd) = 运行外部程序，成功返回 true。\n@file 指定要运行的程序路径，其他所有参数可省略，\n@param 字符串参数，可选指定启动参数。\n@operation 可选用一个字符串指定执行动词，省略则使用默认动词或 "open"。\n@showCmd 可选用 _SW_ 前缀常量指定显示选项，默认为 _SW_SHOW。\n@workDir 参数可选指定工作目录。\n@hwnd 可选指定所有窗口句柄，默认取当前线程活动窗口
explore(.(path,args,->->->) = 使用资源管理器（Explorer.exe）打开文件或目录。\n第一个参数 @path 指定文件路径，可为空值（ null ）。\n注意 Explorer.exe 不解析标准的命令行参数转义符，这一点与其他程序不同。\n如参数 @path 尾部有双反斜杠`\\`则为无效路径并打开默认目录（打开我的文档，XP系统报错）。\n如参数 @path 指定为 ","或"file:" 则打开“此电脑（This PC）”。\n如参数 @path 使用`shell:::`前缀则可以指定特殊路径的 CLSID。\n\n可用第二个参数 @args 或更多参数指定 Explorer.exe 命令行选项，\n例如指定  "/select" 在资源管理器选择指定路径。\n注意 "/n" 等选项在新系统中是无意义的，Explorer 将总是打开新窗口。
join(.(字节串数组,分隔字符串,起始索引,结束索引) = \n拼接参数 @1 指定的字符串或 buffer 数组，返回 buffer 对象。\n- 参数 @1不可包含除字符串或 buffer 之外其他类型的值，不可包含 null 值。\n包含 buffer 的数组只能用 raw.join 拼接，不可使用 string.join 拼接。\n- 参数 @2 可选指定一个分隔字符串。\n- 起始索引与结束索引为可选参数，可传入负数表示自数组尾部倒计数\n\n如果拼接后字节长度为空，此函数返回 null。\n起始索引与结束索引可用负数表示倒计数，索引溢出则自动设为最接近的有效索引。\n如果转换后的起始索引大于结束索引此函数返回 null。
slice( = 截取字节串并返回新的 buffer 对象。
slice(.(bytes,startIndex,endIndex,size) = - 参数 @bytes 可指定 buffer,字符串或指针。\n- 参数 @startIndex 指定截取开始位置，参数 @endIndex 指定最后一个截取字节的位置。\n省略 @startIndex 则默认为 1,省略 @endIndex 则默认为 @size\n如果 @startIndex,endIndex 为负数则表示自尾部倒计数，-1 表示最后一个字节。\n如果转换后 @startIndex 小于 1 则设为 1，@endIndex 大于 size 则设为 size。\n如果 @startIndex 大于 1，@endIndex 则返回 null 值。\n- 参数 @size 指定字节串长度，如果参数 @1 指定字符串或 buffer 则可省略 size 参数。
typeOfArray(__) = 如果参数是一个包含原生数组的结构体，\n返回原生类型名，以及数组字段名字。\n如果是其他对象则返回 null 。
double() = !rawNumber.
float() = !rawNumber.
byte() = !rawNumber.
ubyte() = !rawNumber.
word() = !rawNumber.
uword() = !rawNumber.
int() = !rawNumber.
uint() = !rawNumber.
long() = !rawNumber.
ulong() = !rawNumber.
end intellisense**/

/*****intellisense()
!rawNumber.value = 对象存储的数值
end intellisense*****/