aview-app 1.0.2

package/aardio/lib/process/gcc/_.aardio

@@ -0,0 +1,236 @@
+import fsys.lnk;
+import fsys.path;
+import string.cmdline;
+import win.path;
+import process.popen;
+import console;
+
+namespace process;
+
+class gcc {
+	
+	ctor( workDir){ 
+		this.workDir = workDir : "\";
+	};
+	exec = function(...){ 
+		..console.open();
+		
+		::Kernel32.SetCurrentDirectory( ..io.fullpath(this.workDir+"\") );
+		
+		var path = check();
+		var params = ..string.cmdline.arguments(...);
+		if(params[1]){
+			var exe = __exe__[params[1]];
+			if(exe){
+				path = ..fsys.path.replaceFile(path,exe);
+				..table.shift(params);
+			} 
+			elseif(..string.right(params[1],4)==".exe"){
+				path = ..fsys.path.replaceFile(path,params[1]); 
+				..table.shift(params);
+			};
+		}  
+		
+		var prcs = ..process(path,params,{workDir = this.workDir});  
+		if(!prcs) error("不支持该命令行",2); 
+		
+		prcs.waitOne();
+		prcs.free();
+		
+		..console.pause(true);
+	};  
+	popen = function(...){
+		::Kernel32.SetCurrentDirectory( ..io.fullpath(this.workDir+"\") );
+		
+		var path = check();
+		var params = ..string.cmdline.arguments(...);
+		if(params[1]){
+			var exe = __exe__[params[1]];
+			if(exe){
+				path = ..fsys.path.replaceFile(path,exe);
+				..table.shift(params);
+			} 
+			elseif(..string.right(params[1],4)==".exe"){
+				path = ..fsys.path.replaceFile(path,params[1]); 
+				..table.shift(params);
+			};
+		} 
+		
+		var prcs = ..process.popen(path,params,{workDir = this.workDir});  
+		if(!prcs) error("不支持该命令行",2); 
+		return prcs;
+	}; 
+	@{
+		_set = function(k,v){
+			if(type.isString(k) && type.isString(v) ){ 
+				
+				if(..string.cmp(k,"Makefile")==0 ){
+					..string.save(..io.joinpath(this.workDir,"makefile"),v );
+					return;
+				}
+				
+				if( ..string.match(k,"^\w+$") ){
+					..string.save(..io.joinpath(this.workDir,k + ".c"),v );
+					return;
+				}
+				
+				if(..string.match(k,"^\w+\.\w+$")){
+					..string.save(..io.joinpath(this.workDir,k),v );
+					return;
+				} 
+			}
+			
+			owner[[k]] = v;	
+		} 
+	}
+}
+
+
+namespace gcc{
+	
+	__exe__ = {
+		"g++":"g++.exe",
+		"gfortran":"gfortran.exe",
+		"make":"mingw32-make.exe"
+	}
+	
+	install = function(url){
+		if(!(
+			..io.exist(..io.appData("aardio/mingw32/bin/gcc.exe")) || ..io.exist(..io.appData("aardio/mingw64/bin/gcc.exe")) 
+		) ){
+			import sevenZip.decoder2.httpFile;
+			if(!url) url = "https://jaist.dl.sourceforge.net/project/mingw-w64/Toolchains%20targetting%20Win32/Personal%20Builds/mingw-builds/8.1.0/threads-win32/dwarf/i686-8.1.0-release-win32-dwarf-rt_v6-rev0.7z";
+			if( ..sevenZip.decoder2.httpFile.download(url,"正在下载 MinGW-w64",..io.appData("aardio/down~temp~"),..io.appData("aardio")) ){
+				var path = ..io.exist(..io.appData("aardio/mingw32/bin/gcc.exe"))
+				if(path){
+					..win.path.add(..io.appData("aardio/mingw32/bin"),,true);
+					..string.setenv("MINGW_HOME",..io.appData("aardio/mingw32"));
+					return path;	
+				}
+				
+				var path = ..io.exist(..io.appData("aardio/mingw64/bin/gcc.exe"));
+				if(path){
+					..win.path.add(..io.appData("aardio/mingw64/bin"),,true);
+					..string.setenv("MINGW_HOME",..io.appData("aardio/mingw64"));
+					return path;	
+				}
+			}	
+		}	
+	}
+	
+	check = function(){
+		if(..io.exist(path)){
+			return path;
+		}
+		
+		path = ..io.exist(..io.appData("aardio/mingw32/bin/gcc.exe"))
+		if(path){
+			..win.path.add(..io.appData("aardio/mingw32/bin"),,true);
+			..string.setenv("MINGW_HOME",..io.appData("aardio/mingw32"));
+			return path;
+		}
+		
+		path = ..io.exist(..io.appData("aardio/mingw64/bin/gcc.exe"));
+		if(path){
+			..win.path.add(..io.appData("aardio/mingw64/bin"),,true);
+			..string.setenv("MINGW_HOME",..io.appData("aardio/mingw64"));
+			return path;
+		}
+		
+		var mingw = ..fsys.lnk.search( {"mingw"},"terminal" )  
+		if(mingw){
+			var str  = ..string.load(mingw);
+			if(str){
+				var mingw  = ..string.match(str,"set\s*PATH\s*=\s*(.+?\mingw32\\bin)\;\%PATH\%");
+				if(mingw){
+					..win.path.add(mingw,,true);
+					..string.setenv("MINGW_HOME",..fsys.getParentDir(mingw));
+					path = ..io.joinpath(mingw,"gcc.exe");
+					return path;
+				}
+			} 
+		}
+		else {
+			var mingw = ..fsys.lnk.search( {"tdm-gcc"},"Modify or Remove MinGW" );
+			if(mingw){
+				mingw = ..io.joinpath( ..fsys.getParentDir( ..fsys.getParentDir(mingw) ),"bin");
+				path = ..io.exist(..io.joinpath(mingw,"gcc.exe") );
+				
+				if( path ){
+					..win.path.add(mingw,,true);
+					..string.setenv("MINGW_HOME",..fsys.getParentDir(mingw));
+					return path;
+				}
+			}
+		}
+		
+		path = ..io.exist(..win.path.search("gcc.exe"));
+		if(path){
+			return path;
+		}
+		
+		path = ..io.exist("C:\TDM-GCC-32\bin\gcc.exe") 
+			|| ..io.exist("D:\TDM-GCC-32\bin\gcc.exe")
+			|| ..io.exist("E:\TDM-GCC-32\bin\gcc.exe")  
+			
+		if(path){
+			..win.path.add(..io.splitpath(path).dir,,true);
+			return path;
+		}
+		
+		path = ..io.exist("C:\MinGW\bin\gcc.exe")
+			|| ..io.exist("D:\MinGW\bin\gcc.exe")
+			|| ..io.exist("E:\MinGW\bin\gcc.exe")
+			 
+		if(path){
+			var bin = ..io.splitpath(path).dir;
+			..win.path.add(bin,,true);
+			
+			bin = ..string.trimright(bin,"\/");
+			..string.setenv("MINGW_HOME",..io.splitpath(bin).dir);
+			return path;
+		}
+		
+		path = install();
+		
+		return path;
+	} 
+	
+	get = function(...){
+		var prcs,err = ..process.gcc().popen(...);
+		if(!prcs) return null,err;
+		
+		var out,err,exitCode = prcs.readAll();
+		prcs.close();
+		
+		if(exitCode){
+			return null,err			
+		}
+		
+		return out;
+	}
+	
+	match = function(p,...){
+		var out,err = get(...);
+		if(out){
+			return ..string.match(out,p);
+		}
+		
+		return null,err;
+	}
+}
+
+/**intellisense()
+process.gcc = 用于创建或安装 GCC 编译环境。\n用法请参考范例 / 调用其他语言 / GCC\n\n此扩展库所有函数执行命令的第一个参数如果是:\n"g++","make" 或其他 GCC 同目录下以 ".exe" 结尾的文件名，\n则执行该程序而非默认的 gcc.exe
+process.gcc.install() = 安装 Mingw-w64\n可选在参数中指定 Mingw-w64 离线安装包下载地址
+process.gcc.check() = 搜索并返回 gcc.exe 路径，自动设置 GCC 环境变量。\n如果找不到 gcc.exe，自动安装 Mingw-w64 并返回 gcc.exe 路径。\n失败返回 null 
+process.gcc.path = 调用 check 函数并返回 true 以后可会返回 gcc.exe 路径
+process.gcc.get(__) = 可用一个或多个字符串参数指定命令行参数，\n也可以用在一个字符串参数中用空格分隔多个参数。\n\n执行成功返回进程标准输出。\n失败返回 null,错误信息
+process.gcc.match(.(模式串,->->) = 执行 GCC 命令（第一个参数可以改为 g++）。\n自参数 @2 开始可用一个或多个字符串参数指定命令行参数，\n也可以用在一个字符串参数中用空格分隔多个参数。\n\n执行成功使用参数 @1 指定的模式串匹配进程查找标准输出并返回结果。\n失败返回 null,错误信息\n\n示例：\nprocess.gcc.match( "__STDC_VERSION__\s+(\d+)","-dM -E -x c NUL")\nprocess.gcc.match( "__cplusplus\s+(\d+)","-dM -E -x c++ NUL")
+process.gcc(__) = 创建 GCC 编译环境，\n可选用参数指定工作目录，默认为"/"（应用程序根目录）
+process.gcc() = !processGcc.
+!processGcc.popen(命令参数) = @.popen("main.c -o main.dll -shared -s -municode -m32 -O2 -static -lgcc -lstdc++")
+!processGcc.exec(命令参数) = @.exec("main.c -o main.dll -shared -s -municode -m32 -O2 -static -lgcc -lstdc++")
+!processGcc.popen() = !process_popen.
+!processGcc.? = 如果键值都是字符串：\n当键名只包含字母与数字，在 GCC 工作目录生成同名 ".c" 文件。\n如果键名已包含后缀名，则不添加".c" 后缀。\n含后缀名时请使用下标操作符赋值。\n\n在 aardio 中段注释可以赋值为字符串，首尾星号数目要相同
+end intellisense**/

package/aardio/lib/process/gfortran/_.aardio

@@ -0,0 +1,71 @@
+import process;
+import process.gcc;
+import string.cmdline;
+import console;
+
+namespace process;
+
+class gfortran {
+	ctor(workDir){
+		if(!..process.gcc.check()){
+			return;
+		}
+		
+		this.workDir = workDir : ..io.fullpath("/");
+		this.path = ..io.joinpath(..io.splitpath(..process.gcc.path).dir,"gfortran.exe");
+	};
+	command = function(...){
+		..console.open() 
+		..console.showLoading(" Building");
+		
+		var arguments = ..string.cmdline.arguments(...); 
+		var prcs =  ..process( this.path
+			,arguments ,{workDir=this.workDir;environment=this.environment} ); 
+		
+		prcs.wait();
+		prcs.free();
+		
+		..console.log("")
+	};
+	buildShared = function(...){
+		//-static-libgcc 参数是为了静态链接 GCC 的库生成独立 DLL ，  -Wl,-S 用于移除调试符号减小体积
+		var args1 = ..string.cmdline.arguments("-shared -fPIC -m32 -O3 -Wl,-S -fcoarray=single -static-libgcc -static-libstdc++ -static");
+		var args2 = ..string.cmdline.arguments(...);
+		
+		this.command(..table.append(args1,args2));
+		..console.pause(true);
+	};
+
+	@{
+		_set = function(k,v){
+			if(type.isString(k) && type.isString(v) ){
+				if(..string.match(k,"^\w+$")){
+					..string.save(..io.joinpath(this.workDir,k + ".f95"),v );
+					return;
+				}
+				if(..string.match(k,"^\w+\.f\d+$")){
+					..string.save(..io.joinpath(this.workDir,k),v );
+					return;
+				}
+			}
+			
+			owner[[k]] = v;	
+		} 
+	}
+}
+
+/**details(参考文档)
+[aardio 静态类型](chm://libraries/kernel/raw/datatype.html)
+[Fortran C兼容类型](https://gcc.gnu.org/onlinedocs/gfortran/ISO_005fC_005fBINDING.html)
+end details**/
+
+/**intellisense()
+process.gfortran() = 创建 Fortran 编译器，\n可选用参数@1指定工作目录，默认工作目录为应用程序根目录 "/"\n!processGfortran.
+end intellisense**/
+
+/**intellisense(!processGfortran)
+command(__) = 运行 gfortran ,可指定一个或多个启动参数,\n启动参数兼容 process 启动参数\n\n未输出错误信息就是成功
+buildShared("-o fortan->dll fortan->f90__") = 编译 DLL 文件 ,可指定一个或多个启动参数,\n启动参数兼容 process 启动参数\n\n未输出错误信息就是成功
+workDir = 工作目录，也就是 Fortran 源码所在目录，\n默认工作目录为应用程序根目录
+? = 如果指定合法标识符，且名称只包含字母与数字，\n如果赋值为字符串，则在工作目录生成同名 ".f95" 文件。\n键名也可以为符合前述规则的文件名加上文件后缀，但要放在下标操作符中
+end intellisense**/

package/aardio/lib/process/heap.aardio

@@ -0,0 +1,59 @@
+//heap 进程堆
+import process
+namespace process.heap;
+
+Heap32ListFirst = ::Kernel32.api("Heap32ListFirst","int(pointer hsnap,struct& lppe)")
+Heap32ListNext = ::Kernel32.api("Heap32ListNext","int(pointer hsnap,struct& lppe)") 
+
+class HEAPLIST32{
+	INT dwSize;
+	INT th32ProcessID;
+	INT th32HeapID;
+	INT dwFlags;
+}
+
+eachList = function(pid) {	
+	if( _STUDIO_INVOKED == "thread" ) return function(){}; 
+    return ..process.eachSnap( pid:..process.getId(),0x1/*_TH32CS_SNAPHEAPLIST*/,HEAPLIST32(),Heap32ListFirst,Heap32ListNext)
+}
+
+Heap32First = ::Kernel32.api("Heap32First","int(struct &lphe,INT pid,INT hid)")
+Heap32Next = ::Kernel32.api("Heap32Next","int(struct &lphe)")  
+
+HEAPENTRY32 = class {
+	INT dwSize;
+	int hHandle;
+	INT dwAddress;
+	INT dwBlockSize;
+	INT dwFlags;
+	INT dwLockCount;
+	INT dwResvd;
+	INT th32ProcessID;
+	int th32HeapID;
+}
+
+each = function(heapList) {
+	if( _STUDIO_INVOKED == "thread" ) return function(){}; 
+	
+	var firstEntry = HEAPENTRY32()
+	
+	firstEntry.dwSize = 36 
+	if( ! Heap32First(firstEntry,heapList.th32ProcessID,heapList.th32HeapID) ){
+		firstEntry = null; 
+	}
+    return function(entry){
+    	if( entry){
+    		entry.dwSize = 36 
+    		if( Heap32Next(entry) )
+    			return entry;
+    	}
+    	else
+    		return firstEntry;
+    }
+    
+}
+
+/**intellisense(process.heap)
+each =  @for heapEntry in process.heap.each(heapList) { \n//io.print( heapEntry.dwAddress  )\n \n}
+eachList =  @for heapList in process.heap.eachList(__/*进程ID*/) { \n//io.print( heapList.dwAddress  )\n \n}
+end intellisense**/

package/aardio/lib/process/imageView.aardio

@@ -0,0 +1,13 @@
+import process;
+
+namespace process;
+
+class imageView{
+	ctor(path){
+		..raw.loadDll("shimgvw.dll").ImageView_FullscreenW(0,_HINSTANSE,..io.fullpath(path),5/*_SW_SHOW*/ );
+	};
+}
+
+/**intellisense()
+process.imageView(__) = 参数输入图像图径,\n调用Windows图片查看器浏览图像
+end intellisense**/

package/aardio/lib/process/job/limitKill.aardio

@@ -0,0 +1,107 @@
+import process;
+namespace process.job;
+
+var limitKillJob;
+limitKillJob = class {
+	ctor(){
+		this.handle = ::Kernel32.CreateJobObjectP( null,null); 
+		if( !this.handle ) return null;
+	
+		var limitInfo = {
+			struct BasicLimitInformation = {
+				LONG PerProcessUserTimeLimit;
+				LONG PerJobUserTimeLimit;
+				INT LimitFlags = 0x2000/*JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE*/;
+				INT MinimumWorkingSetSize;
+				INT MaximumWorkingSetSize;
+				INT ActiveProcessLimit;
+				INT Affinity;
+				INT PriorityClass;
+				INT SchedulingClass;
+			};
+			struct IoInfo = {
+				LONG ReadOperationCount;
+				LONG WriteOperationCount;
+				LONG OtherOperationCount;
+				LONG ReadTransferCount;
+				LONG WriteTransferCount;
+				LONG OtherTransferCount;
+			}; 
+			INT ProcessMemoryLimit;
+			INT JobMemoryLimit;
+			INT PeakProcessMemoryUsed;
+			INT PeakJobMemoryUsed;
+		}
+
+	
+		if( 0 == ::Kernel32.SetInformationJobObject( this.handle
+			, 9/*JobObjectExtendedLimitInformation*/, limitInfo, ..raw.sizeof(limitInfo)))
+		{
+			return null;
+		}	
+	};
+	isIn = function(p){  
+		var result ={bool v};
+		if(type(p)==type.number){
+			var prcs = ..process(p,0x400/*_PROCESS_QUERY_INFORMATION*/)
+			
+			if(prcs){
+				var result ={bool v}
+				::Kernel32.IsProcessInJob(prcs.handle,this.handle,result);
+				prcs.free();  
+			}
+		}
+		elseif(type(p)==type.pointer || p[["handle"]]){
+			var result ={bool v}
+			::Kernel32.IsProcessInJob(p,this.handle,result);
+		}
+		elseif(p[["assignToJobObject"]] ){
+			var result ={bool v}
+			::Kernel32.IsProcessInJob(p,this.handle,result);
+		}
+		else {
+			error("参数类型错误",2)
+		}
+		
+		return result.v; 
+	}; 
+	assignProcess = function(p){
+		var r;
+		if(type(p)==type.number){
+			var prcs = ..process(p,0x100/*_PROCESS_SET_QUOTA*/ | 0x1/*_PROCESS_TERMINATE*/)
+			if(prcs){
+				r = ::Kernel32.AssignProcessToJobObjectB(this.handle,prcs.handle);
+				prcs.free();  
+			}
+		}
+		elseif(type(p)==type.pointer){
+			r = ::Kernel32.AssignProcessToJobObjectB(this.handle,p);
+		}
+		elseif(p[["assignToJobObject"]]){
+			p.assignToJobObject(this.handle);
+		} 	
+		else{
+			error("参数类型错误",2)
+		}
+		
+		return r;
+	}; 
+	@{
+		_topointer = lambda() this.handle;
+		_call = function(){
+			return limitKillJob();
+		} 
+	}
+}
+
+limitKill = limitKillJob();
+
+/**intellisense()
+process.job.limitKill = 使用子进程对象的 assignToJobObject 函数绑定此对象,\n则进程退出时子进程自动终止\n!processJobLimitKill.
+process.job.limitKill() = 创建新的 process.job.limitKill 作业对象\n!processJobLimitKill.
+end intellisense**/
+
+/**intellisense(!processJobLimitKill)
+isIn(.(processId) = 判断参数指定的进程是否属于当前作业对象,\n参数可以指定使用数值指定进程ID，或使用指针指定进程句柄,\n也可以传入 process 或 process.popen 对象
+assignProcess(.(processId) = 将参数指定的进程绑定当前作业对象,\n参数可以指定使用数值指定进程ID，或使用指针指定进程句柄,\n也可以传入 process 或 process.popen 对象
+end intellisense**/

package/aardio/lib/process/mutex.aardio

@@ -0,0 +1,105 @@
+//mutex 线程互斥量
+namespace process;
+
+class mutex {
+	ctor( uniqueName,inheritHandle,initialOwner ){
+		var tArg1 = type(uniqueName);
+		if( tArg1 == "pointer" )   {
+			this.handle	= uniqueName;
+			if(inheritHandle===true)..table.gc( this,"close" );
+		}
+		else{
+			if( inheritHandle===null )inheritHandle=1/*_TRUE*/; 
+			
+			if(tArg1=="string"){
+				uniqueName = ..string.replace(uniqueName,"@\","/");
+				this.handle = OpenMutex(0x1f0001/* MUTANT_ALL_ACCESS*/,inheritHandle,uniqueName);
+			}
+			
+			if(this.handle) {
+    			this.conflict = "互斥体已存在" 
+    		}
+			else{
+				this.handle  =  CreateMutex( { INT  nLength;pointer secDesc;bool inherit = inheritHandle }
+					,initialOwner,uniqueName);  
+					 
+				if(tArg1=="string") { 	
+					if(!this.handle) {
+						this.handle = OpenMutex(0x1f0001/* MUTANT_ALL_ACCESS*/,inheritHandle,uniqueName);
+						if(this.handle ) this.conflict = "互斥体已存在";  
+					}
+					elseif(::GetLastError()==0xB7/*_ERROR_ALREADY_EXISTS*/){
+						this.conflict = "互斥体已存在"
+					}
+				}
+			} 
+			
+			if(!this.handle) return null;
+			..table.gc(this,"close");
+		}
+	};
+	
+	close = function(){  
+		//The system closes the handle automatically when the process terminates. 
+		//The mutex object is destroyed when its last handle has been closed.
+		if( this.handle ){
+			..raw.closehandle(this.handle);
+			this.handle = null;
+		}
+	} 
+	@_metaProperty
+}
+
+
+namespace mutex{
+	import util.metaProperty
+	
+	_metaProperty = util.metaProperty(
+	
+		_topointer = function(){
+			return owner.handle;
+		} 
+		_serialize = function(kernelCall){
+			if(kernelCall) return ..raw.serializeDupHandle("process.mutex",owner.handle);
+		}
+		release = function(count=1){
+			return ReleaseMutex( owner.handle )
+		} 
+		wait = function(timeout){
+			return ..thread.wait(owner.handle,timeout)
+		}   
+		waitOne = function(timeout){
+			return ..thread.waitOne(owner.handle,timeout)
+		}  
+	)
+	
+	OpenMutex = ::Kernel32.api("OpenMutex","ptr(INT desiredAccess,bool bInherit,ustring lpName)"); 
+	CreateMutex = ::Kernel32.api("CreateMutex","ptr(struct attr,bool bOwner,ustring lpName)" ); 
+	ReleaseMutex= ::Kernel32.api("ReleaseMutex","int(ptr h)"); 
+	
+	lock = function(name,proc){
+		if(!name) error("请指定互斥体名称",2);
+		var mutex = ..process.mutex(name);
+		mutex.waitOne();
+		proc();
+		mutex.release();
+		mutex.close();
+	}
+}
+ 
+ 
+/**intellisense() 
+
+process.mutex = 互斥体\n可用于进程间同步
+process.mutex( = 创建或打开互斥体对象,\n返回对象可传入其他线程使用。
+process.mutex(.(互斥体句柄) = 使用句柄直接打开互斥体
+process.mutex(.(互斥体句柄,true) = 使用句柄直接打开互斥体\n添加析构函数负责释放句柄
+process.mutex(.("唯一名称",句柄是否可继承,获取初始所有权) = 创建互斥体\n名称不能超过260个字符,名称内的反斜杠自动替换为正斜杠,\nthread.event,process.mutex,fsys.mmap等命名不能相同,\n省略名称创建匿名对象,\n参数@2指定句柄是否可被子进程继承,为可选参数,默认为false,\n可选用参数@3指定是否获取初始所有权,默认为 false，\n因为可能同时创建互斥体，不建议将参数@3指定为 true
+process.mutex.lock(.("互斥体名称",回调函数) = 该函数在多进程中互斥执行
+!mutex.close() = 关闭互斥体句柄\n该函数并不关闭互斥体创建的内核对象\n当所有引用内核对象的对象关闭,内核对象自动释放
+!mutex.conflict = 如果互斥体已存在,此属性为真值\n否则为空值
+!mutex.release() =  线程在处理完共享资源后,\n应在离开时调用此函数释放互斥体所有权
+!mutex.wait() = 等待并获取互斥体独占所有权,\n可选增加一个参数指定超时,以毫秒为单位\n注意此函数应与release函数配对使用\n在同一线程中可多次取得所有权,但需要相同次数调用release函数释放\n在UI线程中应使用非阻塞的waitOne()函数替代
+!mutex.waitOne() = 等待并获取互斥体独占所有权,\n可选增加一个参数指定超时,以毫秒为单位\n注意此函数应与release函数配对使用\n在同一线程中可多次取得所有权,但需要相同次数调用release函数释放\n
+process.mutex() = !mutex.
+end intellisense**/

package/aardio/lib/process/php/5.2.aardio

@@ -0,0 +1,7 @@
+import process.php; 
+process.php.cgiPath = "~\lib\php\.dll\php-cgi.exe";
+process.php["5"] = {["2"]={}}
+
+if(_STUDIO_INVOKED && !..io.exist(process.php.cgiPath)){
+	import php; 
+}

package/aardio/lib/process/php/5.6.aardio

@@ -0,0 +1,10 @@
+import sys.vc11;
+import process.php; 
+process.php.cgiPath = ..io.appData("aardio\std\php\php-5.6.40-Win32-VC11-x86\php-cgi.exe");
+process.php["5"] = {["6"]={}}
+
+if(!..io.exist(process.php.cgiPath)){
+	import zlib.httpFile;
+	zlib.httpFile.download("https://windows.php.net/downloads/releases/archives/php-5.6.40-Win32-VC11-x86.zip",
+		"正在下载本程序必须组件：PHP 5.6",..io.appData("/aardio/std/php") )
+}