# process 库模块帮助文档

<details>  <summary>相关范例</summary>  <p>
范例程序 > 进程
</p></details>

## process 成员列表 <a id="process" href="#process">&#x23;</a>

运行执行文件或关联文档。  
如果省略所有参数则打开当前进程  
失败则返回 null,错误信息,错误代码  
成功返回进程对象。  

个别系统 64 位程序，需要改用 process.wow64 启动以避免目录重定向。  
极个别系统程序，需要用 process.shell 函数创建 process 对象。

### process( ,系统命令行) <a id="process( ,系统命令行)" href="#process( ,系统命令行)">&#x23;</a>
如果省略第一个参数,并仅指定命令行,则作为系统命令行启动运行

### process() <a id="process()" href="#process()">&#x23;</a>
[返回对象:processObject](#processObject)

### process(执行文件,命令行参数,STARTUPINFO) <a id="process(执行文件,命令行参数,STARTUPINFO)" href="#process(执行文件,命令行参数,STARTUPINFO)">&#x23;</a>
命令行参数可以是字符串或由多个字符串组成的数组,  
数组参数调用 string.args.join 合并,  
不在双引号内、且包含空白或需要转义的参数转义处理后首尾添加双引号,  
命令参数最大长度为 32765 个字符。  
STARTUPINFO参数为process.STARTUPINFO 结构体,可选参数  
如果该参数是普通table对象.将自动创建为STARTUPINFO结构体

### process(执行文件,命令行参数,更多命令行参数,...) <a id="process(执行文件,命令行参数,更多命令行参数,...)" href="#process(执行文件,命令行参数,更多命令行参数,...)">&#x23;</a>
命令行参数可以是一个数组、一个或多个字符串参数,  

数组或多个命令行参数调用 string.args.join 合并,  
不在双引号内、且包含空白或需要转义的参数转义处理后首尾添加双引号,  
命令参数最大长度为 32765 个字符

### process(进程ID,权限) <a id="process(进程ID,权限)" href="#process(进程ID,权限)">&#x23;</a>
打开指定ID的进程,  
参数@2可选用一个数值指定请求的权限，  
不指定权限时默认尝试 _PROCESS_ALL_ACCESS 权限,  
如果失败则尝试以 _SYNCHRONIZE 权限打开进程,  
_SYNCHRONIZE权限打开时只能使用 wait,waitOne函数,  
非管理权限进程创建管理权限进程时只能以_SYNCHRONIZE权限打开进程

### process(进程句柄,负责释放进程句柄) <a id="process(进程句柄,负责释放进程句柄)" href="#process(进程句柄,负责释放进程句柄)">&#x23;</a>
使用指定的进程句柄创建进程对象,  
参数@2为可选参数,默认为true

### process.		ReadProcessMemory64 <a id="process.		ReadProcessMemory64" href="#process.		ReadProcessMemory64">&#x23;</a>
`::Ntdll.api("NtWow64ReadVirtualMemory64","int(POINTER hProcess,LONG base,struct &buf,long size,long & retSize)" )`

### process.	GetModuleFileNameEx <a id="process.	GetModuleFileNameEx" href="#process.	GetModuleFileNameEx">&#x23;</a>
`Psapi.api("GetModuleFileNameEx","INT(pointer hProcess,pointer hModule,ustring& lpFilename,INT size)" )`

### process.	MEMORY_BASIC_INFORMATION <a id="process.	MEMORY_BASIC_INFORMATION" href="#process.	MEMORY_BASIC_INFORMATION">&#x23;</a>

```aardio
class {
 		addr BaseAddress;
 		addr AllocationBase;
 		INT AllocationProtect;
 		INT RegionSize;
 		INT State;
 		INT Protect;
 		INT Type;
	}
```

### process.	THREADENTRY32 <a id="process.	THREADENTRY32" href="#process.	THREADENTRY32">&#x23;</a>

```aardio
class {
 	INT dwSize;
 	INT cntUsage;
 	INT th32ThreadID; // this thread
 	INT th32OwnerProcessID; // Process this thread is associated with
 	int tpBasePri;
 	int tpDeltaPri;
 	INT dwFlags;
	}
```

### process.::Advapi32 : <a id="process.::Advapi32 :" href="#process.::Advapi32 :">&#x23;</a>
`..raw.loadDll("Advapi32.dll")`

### process.CreateProcess <a id="process.CreateProcess" href="#process.CreateProcess">&#x23;</a>
`::Kernel32.api("CreateProcess","int(ustring app, ustring &cmd, pointer processAttributes,pointer threadAttributes, bool inheritHandles, INT creationFlags,ustring environment, ustring lpCurrentDirectory, struct lpStartupInfo, struct& lpProcessInformation )");`

### process.CreateProcessWithLogonW <a id="process.CreateProcessWithLogonW" href="#process.CreateProcessWithLogonW">&#x23;</a>
`::Advapi32.api("CreateProcessWithLogonW","int(ustring user,ustring domain,ustring pwd,INT flags,ustring app, ustring &cmd, INT creationFlags,ustring environment, ustring lpCurrentDirectory, struct lpStartupInfo, struct& lpProcessInformation )");`

### process.FindExecutable <a id="process.FindExecutable" href="#process.FindExecutable">&#x23;</a>
`::Shell32.api("FindExecutable","int(ustring file,ustring directory,ustring &result)")`

### process.GetExitCodeProcess <a id="process.GetExitCodeProcess" href="#process.GetExitCodeProcess">&#x23;</a>
`::Kernel32.api("GetExitCodeProcess","bool(POINTER hProcess,INT &code)");`

### process.GetPriorityClass <a id="process.GetPriorityClass" href="#process.GetPriorityClass">&#x23;</a>
`::Kernel32.api("GetPriorityClass","INT(POINTER hProcess");`

### process.IsWow64Process <a id="process.IsWow64Process" href="#process.IsWow64Process">&#x23;</a>
`::Kernel32.api( "IsWow64Process", "bool(pointer hProcess,bool &Wow64Process)");`

### process.OpenProcess <a id="process.OpenProcess" href="#process.OpenProcess">&#x23;</a>
`::Kernel32.api("OpenProcess","pointer(INT desiredAccess,bool inherit,INT pid)")`

### process.PROCESS_INFORMATION <a id="process.PROCESS_INFORMATION" href="#process.PROCESS_INFORMATION">&#x23;</a>

```aardio
class {
 		pointer hProcess;
 		pointer hThread;
 		INT dwProcessId;
 		INT dwThreadId;
	}
```

### process.ReadProcessMemory <a id="process.ReadProcessMemory" href="#process.ReadProcessMemory">&#x23;</a>
`::Kernel32.api("ReadProcessMemory","int(POINTER hProcess,addr base,struct &buf,INT size,INT & retSize)" )`

### process.ReadProcessMemoryByString <a id="process.ReadProcessMemoryByString" href="#process.ReadProcessMemoryByString">&#x23;</a>
`::Kernel32.api("ReadProcessMemory","int(POINTER hProcess,addr base,string &buf,INT size,INT & retSize)" )`

### process.ReadProcessMemoryByString64 <a id="process.ReadProcessMemoryByString64" href="#process.ReadProcessMemoryByString64">&#x23;</a>
`::Ntdll.api("NtWow64ReadVirtualMemory64","int(POINTER hProcess,LONG base,string &buf,long size,long & retSize)" )`

### process.STARTUPINFO <a id="process.STARTUPINFO" href="#process.STARTUPINFO">&#x23;</a>

```aardio
class {
 		INT cb = 68;
 		ustring reserved;
 		ustring desktop;
 		ustring title;
 		INT x;
 		INT y;
 		INT xSize;
 		INT ySize;
 		INT xCountChars;
 		INT yCountChars;
 		INT fillAttribute;
 		INT flags;
 		WORD showWindow;
 		WORD cbReserved2;
 		ustring lpReserved2;
 		pointer stdInput;
 		pointer stdOutput;
 		pointer stdError; 
 		creationFlag = 0;
 		inheritHandles;
	};
```

### process.STARTUPINFO() <a id="process.STARTUPINFO" href="#process.STARTUPINFO">&#x23;</a>
创建进程启动参数  

[返回对象:startinfoObject](#startinfoObject)

### process.SetPriorityClass <a id="process.SetPriorityClass" href="#process.SetPriorityClass">&#x23;</a>
`::Kernel32.api("SetPriorityClass","bool(POINTER hProcess,INT priorityClass)");`

### process.SetProcessAffinityMask <a id="process.SetProcessAffinityMask" href="#process.SetProcessAffinityMask">&#x23;</a>
`::Kernel32.api("SetProcessAffinityMask","INT(pointer hProcess,INT dwProcessAffinityMask)" )`

### process.TerminateProcess <a id="process.TerminateProcess" href="#process.TerminateProcess">&#x23;</a>
`::Kernel32.api("TerminateProcess","int(pointer hProcess,INT exitCode)")`

### process.Thread32First <a id="process.Thread32First" href="#process.Thread32First">&#x23;</a>
`::Kernel32.api("Thread32First","int(pointer hsnap,struct& lppe)")`

### process.Thread32Next <a id="process.Thread32Next" href="#process.Thread32Next">&#x23;</a>
`::Kernel32.api("Thread32Next","int(pointer hsnap,struct& lppe)")`

### process.VirtualAllocEx <a id="process.VirtualAllocEx" href="#process.VirtualAllocEx">&#x23;</a>
`::Kernel32.api("VirtualAllocEx","addr(POINTER hProcess ,addr addr,int dwSize,int flAllocationType,int flProtect)")`

### process.VirtualFreeEx <a id="process.VirtualFreeEx" href="#process.VirtualFreeEx">&#x23;</a>
`::Kernel32.api("VirtualFreeEx","int(POINTER hProcess,addr addr,int dwSize,int dwFreeType)")`

### process.VirtualProtectEx <a id="process.VirtualProtectEx" href="#process.VirtualProtectEx">&#x23;</a>
`::Kernel32.api("VirtualProtectEx","bool(POINTER hProcess,addr addr, INT dwSize, INT flNewProtect, INT &lpflOldProtect )");`

### process.VirtualQueryEx <a id="process.VirtualQueryEx" href="#process.VirtualQueryEx">&#x23;</a>
`::Kernel32.api("VirtualQueryEx","INT(pointer hProcess,addr addr,struct& buf,INT dwLength)" )`

### process.WaitForInputIdle <a id="process.WaitForInputIdle" href="#process.WaitForInputIdle">&#x23;</a>
`::User32.api("WaitForInputIdle","INT(pointer hProcess,INT dwMilliseconds)");`

### process.WriteProcessMemory <a id="process.WriteProcessMemory" href="#process.WriteProcessMemory">&#x23;</a>
`::Kernel32.api("WriteProcessMemory","int(POINTER hProcess,addr base,struct buf,INT size,INT & retSize)" )`

### process.WriteProcessMemory64 <a id="process.WriteProcessMemory64" href="#process.WriteProcessMemory64">&#x23;</a>
`::Ntdll.api("NtWow64WriteVirtualMemory64","int(POINTER hProcess,LONG base,struct buf,long size,long & retSize)" )`

### process.WriteProcessMemoryByString <a id="process.WriteProcessMemoryByString" href="#process.WriteProcessMemoryByString">&#x23;</a>
`::Kernel32.api("WriteProcessMemory","int(POINTER hProcess,addr base,string buf,INT size,INT & retSize)" )`

### process.WriteProcessMemoryByString64 <a id="process.WriteProcessMemoryByString64" href="#process.WriteProcessMemoryByString64">&#x23;</a>
`::Ntdll.api("NtWow64WriteVirtualMemory64","int(POINTER hProcess,LONG base,string buf,long size,long & retSize)" )`

### process.dup(句柄,,目标进程句柄) <a id="process.dup" href="#process.dup">&#x23;</a>
复制句柄到目标进程句柄

### process.dup(句柄,源进程句柄) <a id="process.dup" href="#process.dup">&#x23;</a>
从指定进程复制句柄到当前进程

### process.dup(句柄,源进程句柄,目标进程句柄) <a id="process.dup" href="#process.dup">&#x23;</a>
进程句柄参数省略则为当前进程句柄  
函数支持更多可选参数如下:  
(句柄,源进程,目标进程,是否可继承,选项,安全访问级别)  
默认可继承,选项默认为_DUPLICATE_CLOSE_SOURCE | _DUPLICATE_SAME_ACCESS  
如果不指定最后一个参数

### process.each <a id="process.each" href="#process.each">&#x23;</a>

```aardio
for processEntry in process.each( ".*.exe" ) {   
//搜索进程，参数指定执行文件名（支持完全匹配与模式匹配，忽略大小写）  
	//io.print( processEntry.szExeFile  )  

}
```

### process.eachModule <a id="process.eachModule" href="#process.eachModule">&#x23;</a>

```aardio
for moduleEntry in process.eachModule(/*进程ID*/) {   
//io.print( moduleEntry.szExePath  )  

}
```

### process.eachThread <a id="process.eachThread" href="#process.eachThread">&#x23;</a>

```aardio
for threadEntry in process.eachThread(/*进程ID*/) {   
//io.print( threadEntry.th32ThreadID  )  

}
```

### process.eachWindow(执行文件名,类名,标题) <a id="process.eachWindow" href="#process.eachWindow">&#x23;</a>

```aardio
for hwnd in process.eachWindow( ".*.exe" ) {  
	/*搜索进程主窗口，所有参数可选。  
参数 @1 指定应指定进程执行文件名而非文件路径，  
所有参数支持完全匹配与模式匹配，忽略大小写。  
不指定类名或标题时忽略隐藏窗口。*/  
}
```

### process.emptyWorkingSet() <a id="process.emptyWorkingSet" href="#process.emptyWorkingSet">&#x23;</a>
将工作集中的内存尽可能移动到页面文件中,  
应发在最小化或程序空闲内存确实暂不需要使用时调用,  
不应频繁调用此函数

### process.environment() <a id="process.environment" href="#process.environment">&#x23;</a>
返回当前进程的所有环境变量组成的字符串  
键与值之间使用等号分隔,每个键值对中间以`'\0'`分隔  
尾部没有`'\0'`

### process.execute <a id="process.execute" href="#process.execute">&#x23;</a>
运行exe应用程序,成功返回进程ID,  
参数详细用法请参考本函数源码以及 WINAPI 中 ShellExecuteEx 函数用法  
运行 UWP 应用请使用 com.shell.activateApp 函数  

raw.execute 提供了与本函数类似的功能。  

个别系统 64 位程序，需要改用 process.wow64.execute 以避免目录重定向。

### process.execute("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir,hwnd) <a id="process.execute" href="#process.execute">&#x23;</a>
参数 @1 为程序路径或系统命令。  

可选参数 @parameters 可以是字符串或字符串数组，用于指定启动参数。  
如果指定数组则由 string.args.join 自动处理转义并支持命名参数。  
如果启动参数只指定一个文件路径，为避免可能包含空格或以反斜杠结尾等需要转义的情况，  
建议写为 process.execute(exePath,{path}) 这种格式，让 aardio 自动处理转义。  

可选参数 @operation 为启动模式  
可选参数 @showCmd 支持 _SW_ 前缀常量或布尔值，与 win.show 参数用法相同。  
可选参数 @workdir 为工作目录  
可选参数 @hwnd 可指定父窗口句柄

### process.executeEx("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir,hwnd,fmask) <a id="process.executeEx" href="#process.executeEx">&#x23;</a>
运行 EXE 应用程序,返回 SHELLEXECUTEINFO 结构体,  
参数 @1 指定要运行的执行程序路径,  
参数 @2 可用一个字符串或字符串数组指定启动参数。  
所有参数用法与 process.execute 函数相同。  
关于 @fmask 详细用法请参考本函数源码（一般用不到）。  
除参数 @1 以外所有参数可选

### process.executeInvoke(path, parameters,operation,showCmd,workDir,hwnd) <a id="process.executeInvoke" href="#process.executeInvoke">&#x23;</a>
创建临时的后台线程运行应用程序  
在打开程序前退出主线程可能无法执行操作,  
参数与 process.execute 函数用法一样,除指定参数@1或参数@2,其他所有参数可选

### process.executeWait("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir=",hwnd=0) <a id="process.executeWait" href="#process.executeWait">&#x23;</a>
运行exe应用程序  
并等待应用程序关闭  
除参数@1以外所有参数可选，所有参数用法与 process.execute 相同

### process.executeWaitInput("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir=",hwnd=0) <a id="process.executeWaitInput" href="#process.executeWaitInput">&#x23;</a>
运行exe应用程序  
并等待进程初始化完成并接受输入  
除参数@1以外所有参数可，所有参数用法与 process.execute 相同

### process.explore(path,args,...) <a id="process.explore" href="#process.explore">&#x23;</a>
使用资源管理器（Explorer.exe）打开文件或目录。  

第一个参数 @path 指定文件路径，可为空值（ null ）。  
注意 Explorer.exe 不解析标准的命令行参数转义符，这一点与其他程序不同。  
如参数 @path 尾部有双反斜杠`\\`则为无效路径并打开默认目录（打开我的文档，XP系统报错）。  
如参数 @path 指定为 ","或"file:" 则打开“此电脑（This PC）”。  
如参数 @path 使用`shell:::`前缀则可以指定特殊路径的 CLSID。  

可用第二个参数 @args 或更多参数指定 Explorer.exe 命令行选项，  
例如指定  "/select" 在资源管理器选择指定路径。  
注意 "/n" 等选项在新系统中是无意义的，Explorer 将总是打开新窗口。  

process.explore 等价于内置函数 raw.explore 。

### process.exploreSelect("字符串参数") <a id="process.exploreSelect" href="#process.exploreSelect">&#x23;</a>
打开资源管理器，选定参数 @1 指定的文件路径。

### process.find("字符串参数") <a id="process.find" href="#process.find">&#x23;</a>
查找进程并返回进程对象。  
参数 @1 指定要查找的进程启动文件名,注意应指定文件名而非文件路径,  
文件名参数支持完全匹配与模式匹配，忽略大小写

### process.find() <a id="process.find" href="#process.find">&#x23;</a>
[返回对象:processObject](#processObject)

### process.findExe("字符串参数") <a id="process.findExe" href="#process.findExe">&#x23;</a>
查找文件关联的可执行程序

### process.findId("字符串参数") <a id="process.findId" href="#process.findId">&#x23;</a>
查找进程并返回进程 ID。  
参数 @1 指定要查找的进程启动文件名,注意应指定文件名而非文件路径,  
文件名参数支持完全匹配与模式匹配，忽略大小写

### process.findWindow <a id="process.findWindow" href="#process.findWindow">&#x23;</a>
查找进程并返回进程主窗口句柄。

### process.findWindow(执行文件名,类名,标题) <a id="process.findWindow" href="#process.findWindow">&#x23;</a>
所有参数可选。  
参数 @1 指定应指定进程执行文件名而非文件路径，  
所有参数支持完全匹配与模式匹配，忽略大小写。  
不指定类名或标题时忽略隐藏窗口。

### process.firstThreadId(进程ID) <a id="process.firstThreadId" href="#process.firstThreadId">&#x23;</a>
返回进程的首个线程 ID

### process.fromWindowHandle() <a id="process.fromWindowHandle" href="#process.fromWindowHandle">&#x23;</a>
[返回对象:processObject](#processObject)

### process.fromWindowHandle(hwnd) <a id="process.fromWindowHandle" href="#process.fromWindowHandle">&#x23;</a>
自参数 @1 指定的窗口句柄获取进程对象。  
返回进程的 pid 属性为进程 ID，tid 属性为窗口线程所在线程 ID。  
失败返回 null 。

### process.getHandle() <a id="process.getHandle" href="#process.getHandle">&#x23;</a>
获取当前进程伪句柄

### process.getId() <a id="process.getId" href="#process.getId">&#x23;</a>
获取当前进程 ID

### process.getInfo <a id="process.getInfo" href="#process.getInfo">&#x23;</a>
获取进程信息

### process.getInfo() <a id="process.getInfo" href="#process.getInfo">&#x23;</a>
[返回对象:ProcessInfoObject](#ProcessInfoObject)

### process.getInfo(handle) <a id="process.getInfo" href="#process.getInfo">&#x23;</a>
获取进程信息，参数 @1 指定进程句柄

### process.getInfo(handle,infoClass,infoStruct) <a id="process.getInfo" href="#process.getInfo">&#x23;</a>
参数 @1 指定进程句柄。  
如果参数 infoClass 指定非 null 数值，  
并且 infoStruct 指定结构体。  
在 Win8 以及之后系统获取信息到该结构体。  
成功返回原结构体

### process.getParent() <a id="process.getParent" href="#process.getParent">&#x23;</a>
获取父进程对象。  
参数@1可选用一个数值指定请求的权限，  
不指定权限时默认尝试 _PROCESS_ALL_ACCESS 权限,  
如果失败则尝试以 _SYNCHRONIZE 权限打开进程。  

[返回对象:processObject](#processObject)

### process.getParentId() <a id="process.getParentId" href="#process.getParentId">&#x23;</a>
获取父进程 ID

### process.getPath(进程ID) <a id="process.getPath" href="#process.getPath">&#x23;</a>
返回执行程序文件完整路径

### process.is() <a id="process.is" href="#process.is">&#x23;</a>
传入参数是否 process 对象

### process.isExe("字符串参数") <a id="process.isExe" href="#process.isExe">&#x23;</a>
检测目标文件是否可执行文件。  
如果是可执行文件返回"PE32"或"PE64"  
第二个返回值为子系统,GUI为2,CUI为3  
失败或参数为 null 返回 null。  
raw.pefile 对象的 isPe32 属性也可用于区分 32 位与 64 位执行文件。

### process.joinArguments <a id="process.joinArguments" href="#process.joinArguments">&#x23;</a>
用于安全地合并命令行参数，并自动处理转义字符。  
此函数实际指向 string.args.join 函数。

### process.joinArguments(参数表,...) <a id="process.joinArguments" href="#process.joinArguments">&#x23;</a>
可传入一个参数表（可包含数组成员）或多个非 null 参数。  

如果传入参数是一个表对象（可包含数组），  
参数表将自动合并为单个命令行参数并返回一个字符串值。  
表中以键名以 - 或 / 开头的名值对自动合并为命令行参数。  

数组成员也会合并到命令行，但名值对参数总是置于数组参数之前。  
如果数组成员也是表对象，则仍调用此函数直接转换为字符串（不再转义）。  
其他数组或命名参数值用 tostring 转换为字符串，按需添加引号进行必要的转义。  
不在双引号内、且含空白字符或 ^ | & 等字符的参数转义后置入双引号。

### process.kill <a id="process.kill" href="#process.kill">&#x23;</a>
查找并关闭进程,  
注意有些进程需要管理权限才能找到,  
例如资源管理器进程 "explorer.exe" 无管理权限有时会失败,  
在代码第一行添加//RUNAS//可申请管理权限

### process.kill(exePath,restart) <a id="process.kill" href="#process.kill">&#x23;</a>
查找所有同名 exe 文件的进程，并关闭进程。  
参数 @exePath 支持完全匹配与模式匹配,忽略大小写。  
返回进程的完整路径。  

如果 @restart 参数为 true，  
则杀进程成功后立即重新启动该进程

### process.kill(pid) <a id="process.kill" href="#process.kill">&#x23;</a>
使用参数@pid指定进程ID,关闭该进程

### process.openUrl() <a id="process.openUrl" href="#process.openUrl">&#x23;</a>
调用默认浏览器打开网址,用于窗口程序,  
如果不用这个方法创建线程去打开网址,可能会出现界面卡顿不流畅的现象,  
在打开网址前退出主线程可能无法执行操作  
控制台程序应调用 process.execute 以避免后台线程不能阻止控制台关闭

### process.regAs(`命令参数`) <a id="process.regAs" href="#process.regAs">&#x23;</a>
以管理权限执行 reg 命令

### process.shell <a id="process.shell" href="#process.shell">&#x23;</a>
并运行应用程序，返回 process 进程对象。  
个别系统 64 位程序，需要改用 process.wow64.shell 以禁用目录重定向。

### process.shell("字符串参数", parameters="字符串参数",operation="open",showCmd,workDir,hwnd,fmask) <a id="process.shell" href="#process.shell">&#x23;</a>
参数 @1 指定要运行的执行程序路径,  
参数 @2 可用一个字符串或字符串数组指定启动参数,  
所有参数用法与 process.execute 函数相同。  
关于 @fmask 详细用法请参考本函数源码（一般用不到）。  
除参数 @1 以外所有参数可选

### process.shell() <a id="process.shell" href="#process.shell">&#x23;</a>
[返回对象:processObject](#processObject)

### process.shellAs <a id="process.shellAs" href="#process.shellAs">&#x23;</a>
以管理权限运行 EXE 应用程序,返回进程对象

### process.shellAs("字符串参数", parameters="字符串参数",showCmd,workDir,hwnd,fmask) <a id="process.shellAs" href="#process.shellAs">&#x23;</a>
参数 @1 指定要运行的执行程序路径,  
参数 @2 可用一个字符串或字符串数组指定启动参数。  
所有参数用法与 process.execute 函数相同。  
关于 @fmask 详细用法请参考本函数源码（一般用不到）。  
除参数 @1 以外所有参数可选

### process.shellAs() <a id="process.shellAs" href="#process.shellAs">&#x23;</a>
[返回对象:processObject](#processObject)

### process.workDir <a id="process.workDir" href="#process.workDir">&#x23;</a>
创建进程默认工作目录，  
默认值为"/"，也即应用程序根目录。  

启动程序路径可直接访问时默认工作目录为应用程序所在目录，  
反之启动程序路径传入 io.exist 返回 false 则默认工作目录为 process.workDir，  
一般不建议改变默认工作目录，  
更好的选择是在创建进程的选项参数中指定 workDir

## processObject 成员列表 <a id="processObject" href="#processObject">&#x23;</a>

### processObject.asm(机器码数组,函数原型,调用约定) <a id="processObject.asm" href="#processObject.asm">&#x23;</a>
参数 @1 可使用字符串数组指定任意个机器码参数。  
机器码可以是字符串，buffer，结构体，数值或指针。  
函数原型可省略默认为 "void()"，调用约定默认为 "cdecl"

### processObject.asmCdecl(函数原型,任意多个机器码参数) <a id="processObject.asmCdecl" href="#processObject.asmCdecl">&#x23;</a>
写入机器码返回 cdecl 调用约定的原生函数对象。  
请参考: aardio 工具 » 其他 » 其他编译器 » INTEL汇编语言 » 汇编转机器码  

参数 @1 指定函数原型（与声明原生 API 的语法相同）。  
参数 @2 开始可用一个或多个参数指定机器码，机器码可以是字符串，buffer，结构体，数值或指针。  

如果仅在参数 @2 用一个字符串参数指定机器码，并且首个字节是大写的 16 进制字符，  
则逐行解析 16 进制编码的机器码，规则：  

- 忽略每一行前面的空白字符，忽略机器码之后的内容。  
- 每两个连续的大写 16 进制字等表示一个机器码，多个机器码之间必须用半角空格分开。  

例如 `55 push ebp ;分号后面写注释`。

### processObject.asmStdcall(函数原型,任意多个机器码参数) <a id="processObject.asmStdcall" href="#processObject.asmStdcall">&#x23;</a>
写入机器码返回 stdcall 调用约定的原生函数对象。  
请参考: aardio 工具 » 其他 » 其他编译器 » INTEL汇编语言 » 汇编转机器码  

参数 @1 指定函数原型（与声明原生 API 的语法相同）。  
参数 @2 开始可用一个或多个参数指定机器码，机器码可以是字符串，buffer，结构体，数值或指针。  

如果仅在参数 @2 用一个字符串参数指定机器码，并且首个字节是大写的 16 进制字符，  
则逐行解析 16 进制编码的机器码，规则：  

- 忽略每一行前面的空白字符，忽略机器码之后的内容。  
- 每两个连续的大写 16 进制字等表示一个机器码，多个机器码之间必须用半角空格分开。  

例如 `55 push ebp ;分号后面写注释`。

### processObject.asmThiscall(函数原型,任意多个机器码参数) <a id="processObject.asmThiscall" href="#processObject.asmThiscall">&#x23;</a>
写入机器码返回 thiscall 调用约定的原生函数对象。  
请参考: aardio 工具 » 其他 » 其他编译器 » INTEL汇编语言 » 汇编转机器码  

参数 @1 指定函数原型（与声明原生 API 的语法相同）。  
参数 @2 开始可用一个或多个参数指定机器码，机器码可以是字符串，buffer，结构体，数值或指针。  

如果仅在参数 @2 用一个字符串参数指定机器码，并且首个字节是大写的 16 进制字符，  
则逐行解析 16 进制编码的机器码，规则：  

- 忽略每一行前面的空白字符，忽略机器码之后的内容。  
- 每两个连续的大写 16 进制字等表示一个机器码，多个机器码之间必须用半角空格分开。  

例如 `55 push ebp ;分号后面写注释`。

### processObject.assignToJobObject(process.job.limitKill) <a id="processObject.assignToJobObject" href="#processObject.assignToJobObject">&#x23;</a>
绑定到作业对象,成功返回 true  
作业对象示例请参考标准库 process.job.limitKill 的源码。  
也可直接调用 killOnExit 函数绑定 process.job.limitKill

### processObject.closeMainWindow() <a id="processObject.closeMainWindow" href="#processObject.closeMainWindow">&#x23;</a>
关闭进程的主窗口，忽略隐藏窗口

### processObject.ctrlEvent(0) <a id="processObject.ctrlEvent" href="#processObject.ctrlEvent">&#x23;</a>
发送 `Ctrl+C`（SIGINT 信号），等价于调用 sendCtrlC 方法。   
信号将传递到与目标进程控制台连接的所有非分离控制台进程，  
64 位目标进程会导致当前控制台暂时关闭

### processObject.ctrlEvent(1) <a id="processObject.ctrlEvent" href="#processObject.ctrlEvent">&#x23;</a>
发送 `Ctrl+Break`（SIGBREAK 信号）。  
信号将传递到与目标进程控制台连接的所有非分离控制台进程  
64 位目标进程会导致当前控制台暂时关闭

### processObject.eachModule <a id="processObject.eachModule" href="#processObject.eachModule">&#x23;</a>

```aardio
for moduleEntry in processObject.eachModule() {   
//此函数仅支持 32 位进程  

}
```

### processObject.eachQuery(开始地址,搜索内存长度,搜索数据) <a id="processObject.eachQuery" href="#processObject.eachQuery">&#x23;</a>

```aardio
for( curMemAddr,curMemSize,strResult,i,j,remainSize in processObject.eachQuery(  , ,"/*搜索模式*/" ) ){  

}
```

### processObject.eachThread <a id="processObject.eachThread" href="#processObject.eachThread">&#x23;</a>

```aardio
for threadEntry in processObject.eachThread() {   
//io.print( threadEntry.th32ThreadID  )  

}
```

### processObject.emptyWorkingSet() <a id="processObject.emptyWorkingSet" href="#processObject.emptyWorkingSet">&#x23;</a>
将工作集中的内存尽可能移动到页面文件中,  
可在最小化或程序空闲时调用以释放活动内存，  
不建议频繁调用此函数

### processObject.free() <a id="processObject.free" href="#processObject.free">&#x23;</a>
释放进程对象。  
不是关闭进程,仅仅是释放对进程的控制句柄。

### processObject.getExitCode() <a id="processObject.getExitCode" href="#processObject.getExitCode">&#x23;</a>
该函数调用成功有两个返回值:进程退出代码,进程是否已退出

### processObject.getInfo <a id="processObject.getInfo" href="#processObject.getInfo">&#x23;</a>
获取进程信息。  
获取程序的版本信息请改用 fsys.version.getInfo 函数。

### processObject.getInfo() <a id="processObject.getInfo" href="#processObject.getInfo">&#x23;</a>
无参数时调用 NtQueryInformationProcess 获取 PROCESS_BASIC_INFORMATION 结构体。

[返回对象:ProcessInfoObject](#ProcessInfoObject)

### processObject.getInfo(infoClass,infoStruct) <a id="processObject.getInfo" href="#processObject.getInfo">&#x23;</a>
如果参数 infoClass 指定非 null 数值，  
并且 infoStruct 指定结构体。  
在 Win8 以及之后系统获取信息到该结构体。  
成功返回原结构体。  

此用法内部调用 ::Kernel32.GetProcessInformation  
细节请参考该 API 文档

### processObject.getMainWindow() <a id="processObject.getMainWindow" href="#processObject.getMainWindow">&#x23;</a>
返回进程的主窗口以及窗口进程 ID，找不到则搜寻子进程主窗口。  
查找时忽略隐藏窗口。  

也可以调用 winex.mainWindows 获取主窗口。  
winex.mainWindows 查找规则略有不同，请参考源码

### processObject.getMainWindow(类名,标题) <a id="processObject.getMainWindow" href="#processObject.getMainWindow">&#x23;</a>
返回进程的指定类名的主窗口以及窗口进程 ID，找不到则搜寻子进程主窗口。  
类名与标题支持完全匹配与模式匹配，忽略大小写。  
所有参数可选，不指定类名或标题时忽略隐藏窗口。

### processObject.getModuleBaseAddress(模块名) <a id="processObject.getModuleBaseAddress" href="#processObject.getModuleBaseAddress">&#x23;</a>
返回模块基址。  
模块名忽略大小写,  
不指定模块名则返回应用程序基址。  

此函数仅支持 32 位程序。  
64位进程返回 math.size64 对象（暂不支持指定模块名）

### processObject.getParent() <a id="processObject.getParent" href="#processObject.getParent">&#x23;</a>
获取父进程对象。  
参数@1可选用一个数值指定请求的权限，  
不指定权限时默认尝试 _PROCESS_ALL_ACCESS 权限,  
如果失败则尝试以 _SYNCHRONIZE 权限打开进程。  

[返回对象:processObject](#processObject)

### processObject.getParentId() <a id="processObject.getParentId" href="#processObject.getParentId">&#x23;</a>
获取父进程 ID

### processObject.getPath() <a id="processObject.getPath" href="#processObject.getPath">&#x23;</a>
返回执行程序文件完整路径。  
如果该进程以管理权限运行，  
则调用函数的进程也必须以管理权限运行  
才能获取到路径

### processObject.getPriorityClass() <a id="processObject.getPriorityClass" href="#processObject.getPriorityClass">&#x23;</a>
返回进程优先级

### processObject.getUiInfo() <a id="processObject.getUiInfo" href="#processObject.getUiInfo">&#x23;</a>
获取UI线程窗口焦点,光标等信息  

[返回对象:guithreadinfoObject](#guithreadinfoObject)

### processObject.handle <a id="processObject.handle" href="#processObject.handle">&#x23;</a>
进程句柄

### processObject.id <a id="processObject.id" href="#processObject.id">&#x23;</a>
进程 ID

### processObject.isWow64() <a id="processObject.isWow64" href="#processObject.isWow64">&#x23;</a>
进程是否在64位系统上运行的32进程

### processObject.isX64() <a id="processObject.isX64" href="#processObject.isX64">&#x23;</a>
是否64位进程

### processObject.kill() <a id="processObject.kill" href="#processObject.kill">&#x23;</a>
杀除进程

### processObject.killOnExit() <a id="processObject.killOnExit" href="#processObject.killOnExit">&#x23;</a>
主进程退出时自动退出此进程

### processObject.malloc(长度) <a id="processObject.malloc" href="#processObject.malloc">&#x23;</a>
在目标进程分配内存空间

### processObject.malloc(长度,访问类型) <a id="processObject.malloc" href="#processObject.malloc">&#x23;</a>
在目标进程分配内存空间

### processObject.malloc(长度,访问类型,分配类型) <a id="processObject.malloc" href="#processObject.malloc">&#x23;</a>
在目标进程分配内存空间

### processObject.mfree(指针) <a id="processObject.mfree" href="#processObject.mfree">&#x23;</a>
释放malloc成员函数分配的内存指针

### processObject.mfree(指针,释放长度,0x4000) <a id="processObject.mfree" href="#processObject.mfree">&#x23;</a>
释放malloc成员函数分配的内存指针  
不建议手工指定长度

### processObject.protect(内存地址,4/*_PAGE_READWRITE*/,1) <a id="processObject.protect" href="#processObject.protect">&#x23;</a>
修改内存保护属性,返回原来的保护属性,  
第三个参数指定内存长度

### processObject.query(开始地址,搜索内存长度,搜索数据) <a id="processObject.query" href="#processObject.query">&#x23;</a>
查找下一个有效内存地址,所有参数可选,  
搜索数据可以是字符串或结构体  
返回值: curMemAddr,curMemSize,strResult,i,j,remainSize

### processObject.readNumber(内存地址) <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个int整数,32位  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"BYTE") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个字节,8位无符号  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"INT") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个int整数,32位无符号  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"LONG") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个long类型整数,64位无符号  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"WORD") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个word类型整数,16位无符号  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"byte") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个字节,8位  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"long") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个long类型整数,64位  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumber(内存地址,"word") <a id="processObject.readNumber" href="#processObject.readNumber">&#x23;</a>
读取一个word类型整数,16位  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readNumberPtr(内存地址) <a id="processObject.readNumberPtr" href="#processObject.readNumberPtr">&#x23;</a>
读取 int 整数的指针，  
然后用在指针指向的内存读取读取数值。  
可用参数 @2 指定原生类型，用法同 readNumber 函数。

### processObject.readPtr() <a id="processObject.readPtr" href="#processObject.readPtr">&#x23;</a>
读取指针地址。  
64 位进程读取 8 字节并返回 math.size64 对象。  
32 位进程读取 4 字节并返回数值。

### processObject.readString(内存地址,长度) <a id="processObject.readString" href="#processObject.readString">&#x23;</a>
读取定长字符串  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readStringPtr(内存地址,长度) <a id="processObject.readStringPtr" href="#processObject.readStringPtr">&#x23;</a>
在参数指定的地址读取字符串指针，  
然后用在指针指向的内存读取字符串。

### processObject.readStringUtf16(内存地址,长度) <a id="processObject.readStringUtf16" href="#processObject.readStringUtf16">&#x23;</a>
读取定长 UTF-16 字符串（ustring），  
返回字符串转换为 UTF-8 编码。  
注意长度以字符为单位  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readStringUtf16Ptr(内存地址,长度) <a id="processObject.readStringUtf16Ptr" href="#processObject.readStringUtf16Ptr">&#x23;</a>
在参数指定的地址读取字符串指针，  
然后用在指针指向的内存读取定长 UTF-16 字符串（ustring）。  
返回字符串转换为UTF8编码。  
注意长度以字符为单位

### processObject.readStruct(内存地址,结构体) <a id="processObject.readStruct" href="#processObject.readStruct">&#x23;</a>
读取定义的结构体  
打开进程需要指定 _PROCESS_VM_READ 权限

### processObject.readStructPtr(内存地址,结构体) <a id="processObject.readStructPtr" href="#processObject.readStructPtr">&#x23;</a>
在参数指定的地址读取结构体指针，  
然后用在指针指向的内存读取结构体

### processObject.remoteApi <a id="processObject.remoteApi" href="#processObject.remoteApi">&#x23;</a>
在外部进程内创建远程调用函数

### processObject.remoteApi("void()","dll名","函数名") <a id="processObject.remoteApi("void" href="#processObject.remoteApi("void">&#x23;</a>
参数(函数原型,加载DLL模块名,函数名,调用约定)   
不指定调用约定时默认使用stdcall调用约定  
不会在API函数名字后面自动添加或移除"A","W"编码声明后缀,  
并且要注意搜索DLL时默认搜索路径包含目标EXE所在目录,而非当前EXE目录

### processObject.remoteApi("void()","dll名","函数名","cdecl,borland") <a id="processObject.remoteApi("void" href="#processObject.remoteApi("void">&#x23;</a>
参数(函数原型,加载DLL模块名,函数名,调用约定)   
不会在API函数名字后面自动添加或移除"A","W"编码声明后缀,  
并且要注意搜索DLL时默认搜索路径包含目标EXE所在目录,而非当前EXE目录

### processObject.remoteApi("void()",CALL地址,调用约定) <a id="processObject.remoteApi("void" href="#processObject.remoteApi("void">&#x23;</a>
参数(函数原型,CALL地址,调用约定)   
不指定调用约定在数时默认使用stdcall调用约定

### processObject.remoteApi("void(INT thisAddr)","dll名","函数名","thiscall") <a id="processObject.remoteApi("void" href="#processObject.remoteApi("void">&#x23;</a>
参数(函数原型,加载DLL模块名,函数名,调用约定)  
thiscall使用第一个参数指定this指针地址  
不会在API函数名字后面自动添加或移除"A","W"编码声明后缀,  
并且要注意搜索DLL时默认搜索路径包含目标EXE所在目录,而非当前EXE目录

### processObject.resume() <a id="processObject.resume" href="#processObject.resume">&#x23;</a>
恢复运行

### processObject.sendCtrlC() <a id="processObject.sendCtrlC" href="#processObject.sendCtrlC">&#x23;</a>
发送 `Ctrl+C`（SIGINT 信号），等价于调用进程对象的 ctrlEvent(0) 方法。

### processObject.sendMessage(hwnd,message,wParam,lParam) <a id="processObject.sendMessage" href="#processObject.sendMessage">&#x23;</a>
向外部进程窗口发送消息  
lParam如果是结构体则复制到目标进程内存,  
结构体如果包含指针应当自行调用 process.malloc 分配内存并复制  
发送消息涉及的用法太多,尤其是涉及到访问外部进程内存,  
所涉及的知识量不能通过看几句函数说明获得,  
普通用户请不要学习或使用此函数

### processObject.setAffinity(1) <a id="processObject.setAffinity" href="#processObject.setAffinity">&#x23;</a>
指定进程运行的CPU内核

### processObject.setInfo(infoClass,infoStruct) <a id="processObject.setInfo" href="#processObject.setInfo">&#x23;</a>
设置进程信息，成功返回 true。  
infoClass 指定数值，infoStruct 指定结构体。  
此函数内部调用 ::Kernel32.SetProcessInformation 。  
详细用法请参考 API 文档。  
在低于 Win8 的系统不执行操作

### processObject.setPriorityClass(0x80/*_HIGH_PRIORITY_CLASS*/) <a id="processObject.setPriorityClass" href="#processObject.setPriorityClass">&#x23;</a>
设置进程优先级

### processObject.stillActive() <a id="processObject.stillActive" href="#processObject.stillActive">&#x23;</a>
进程是否仍在运行

### processObject.suspend() <a id="processObject.suspend" href="#processObject.suspend">&#x23;</a>
暂停进程

### processObject.terminate() <a id="processObject.terminate" href="#processObject.terminate">&#x23;</a>
强行终止进程  
可在参数中指定退出代码

### processObject.tid <a id="processObject.tid" href="#processObject.tid">&#x23;</a>
返回进程的主线程 ID

### processObject.wait() <a id="processObject.wait" href="#processObject.wait">&#x23;</a>
等待进程关闭,  
可选使用一个毫秒值参数设定超时  
超时或失败返回 false,  
进程已退出则返回值1为true,返回值2为退出代码

### processObject.waitForInputIdle(超时间隔) <a id="processObject.waitForInputIdle" href="#processObject.waitForInputIdle">&#x23;</a>
等待进程完成初始化并等待用户输入的空闲状态（没有待处理输入）。  
超时间隔以毫秒为单位，省略参数则一直等待。  

默认会在创建进程时被自动调用此函数，  
除非创建进程的 startInfo 参数的 waitInputTimeout 字段为 0,  
或者 startInfo 参数的  suspended字段为 true 。

### processObject.waitMainWindow <a id="processObject.waitMainWindow" href="#processObject.waitMainWindow">&#x23;</a>
等待并返回进程主窗口以及窗口进程ID。  
也可调用 winex.mainWindows 且指定参数 @2 为 true 以等待主窗口。  
winex.mainWindows 查找规则略有不同，请参考源码

### processObject.waitMainWindow(类名,等待窗口句柄) <a id="processObject.waitMainWindow" href="#processObject.waitMainWindow">&#x23;</a>
等待并返回进程主窗口以及窗口进程ID。  
所有参数可选。  
可选指定要等待的类名，类名支持完全匹配与模式匹配，忽略大小写。  
不指定类名时忽略隐藏窗口,  
可选指定等待窗口句柄,该窗口关闭时些函数不再等待并直接返回结果

### processObject.waitOne() <a id="processObject.waitOne" href="#processObject.waitOne">&#x23;</a>
等待进程关闭,不阻塞UI消息循环,  
可选使用一个毫秒值参数设定超时  
超时或失败返回 false,  
进程已退出则返回值1为true,返回值2为退出代码

### processObject.write(内存地址,任意个字符串或结构体参数) <a id="processObject.write" href="#processObject.write">&#x23;</a>
写入数据,成功返回写入尾部内存地址,  
失败返回空

### processObject.writeNumber(内存地址,0) <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个int整数,32位

### processObject.writeNumber(内存地址,0,"BYTE") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个字节,8位无符号

### processObject.writeNumber(内存地址,0,"INT") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个int整数,32位无符号

### processObject.writeNumber(内存地址,0,"LONG") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个long类型整数,64位无符号

### processObject.writeNumber(内存地址,0,"WORD") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个word类型整数,16位无符号

### processObject.writeNumber(内存地址,0,"byte") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个字节,8位

### processObject.writeNumber(内存地址,0,"long") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个long类型整数,64位

### processObject.writeNumber(内存地址,0,"word") <a id="processObject.writeNumber" href="#processObject.writeNumber">&#x23;</a>
写入一个word类型整数,16位

### processObject.writeString(内存地址,字符串,长度) <a id="processObject.writeString" href="#processObject.writeString">&#x23;</a>
写入字符串,长度为可选参数,  
省略内存地址参数则自动分配内存,  
该函数返回写入内存地址,写入长度

### processObject.writeStringUtf16(内存地址,字符串) <a id="processObject.writeStringUtf16" href="#processObject.writeStringUtf16">&#x23;</a>
写入 UTF-16 字符串（ustring）。  
参数可以为默认的UTF8编码文本

### processObject.writeStruct(内存地址,结构体) <a id="processObject.writeStruct" href="#processObject.writeStruct">&#x23;</a>
写入定义的结构体,  
省略内存地址参数则自动分配内存,  
该函数返回写入内存地址,写入长度

## ProcessInfoObject 成员列表 <a id="ProcessInfoObject" href="#ProcessInfoObject">&#x23;</a>

### ProcessInfoObject.exitStatus <a id="ProcessInfoObject.exitStatus" href="#ProcessInfoObject.exitStatus">&#x23;</a>
进程退出代码

### ProcessInfoObject.parentId <a id="ProcessInfoObject.parentId" href="#ProcessInfoObject.parentId">&#x23;</a>
父进程 ID

### ProcessInfoObject.pebBaseAddress <a id="ProcessInfoObject.pebBaseAddress" href="#ProcessInfoObject.pebBaseAddress">&#x23;</a>
PEB 地址,  
注意 64 位进程这里返回 math.size64 对象,  
32 位进程返回数值

## heapEntry 成员列表 <a id="heapEntry" href="#heapEntry">&#x23;</a>

### heapEntry.dwAddress <a id="heapEntry.dwAddress" href="#heapEntry.dwAddress">&#x23;</a>
`Linear address of start of block`

### heapEntry.dwBlockSize <a id="heapEntry.dwBlockSize" href="#heapEntry.dwBlockSize">&#x23;</a>
`Size of block in bytes`

### heapEntry.dwFlags <a id="heapEntry.dwFlags" href="#heapEntry.dwFlags">&#x23;</a>
`dwLockCount =`

### heapEntry.dwResvd <a id="heapEntry.dwResvd" href="#heapEntry.dwResvd">&#x23;</a>
`th32ProcessID = owning process`

### heapEntry.dwSize <a id="heapEntry.dwSize" href="#heapEntry.dwSize">&#x23;</a>
结构体大小;

### heapEntry.hHandle <a id="heapEntry.hHandle" href="#heapEntry.hHandle">&#x23;</a>
`Handle of this heap block`

### heapEntry.th32HeapID <a id="heapEntry.th32HeapID" href="#heapEntry.th32HeapID">&#x23;</a>
`heap block is in`

## heapList 成员列表 <a id="heapList" href="#heapList">&#x23;</a>

### heapList.dwFlags <a id="heapList.dwFlags" href="#heapList.dwFlags">&#x23;</a>
``

### heapList.dwSize <a id="heapList.dwSize" href="#heapList.dwSize">&#x23;</a>
结构体大小;

### heapList.th32HeapID <a id="heapList.th32HeapID" href="#heapList.th32HeapID">&#x23;</a>
`heap (in owning process's context!)`

### heapList.th32ProcessID <a id="heapList.th32ProcessID" href="#heapList.th32ProcessID">&#x23;</a>
`owning process`

## moduleEntry 成员列表 <a id="moduleEntry" href="#moduleEntry">&#x23;</a>

### moduleEntry.GlblcntUsage <a id="moduleEntry.GlblcntUsage" href="#moduleEntry.GlblcntUsage">&#x23;</a>
`ProccntUsage =`

### moduleEntry.dwSize <a id="moduleEntry.dwSize" href="#moduleEntry.dwSize">&#x23;</a>
结构体大小

### moduleEntry.modBaseAddr <a id="moduleEntry.modBaseAddr" href="#moduleEntry.modBaseAddr">&#x23;</a>
模块基址;

### moduleEntry.modBaseSize <a id="moduleEntry.modBaseSize" href="#moduleEntry.modBaseSize">&#x23;</a>
hModule = 模块句柄

### moduleEntry.szExePath <a id="moduleEntry.szExePath" href="#moduleEntry.szExePath">&#x23;</a>
``

### moduleEntry.szModule <a id="moduleEntry.szModule" href="#moduleEntry.szModule">&#x23;</a>
`0;`

### moduleEntry.th32ModuleID <a id="moduleEntry.th32ModuleID" href="#moduleEntry.th32ModuleID">&#x23;</a>
模块ID;

### moduleEntry.th32ProcessID <a id="moduleEntry.th32ProcessID" href="#moduleEntry.th32ProcessID">&#x23;</a>
进程ID,INT数据类型

## processEntryObject 成员列表 <a id="processEntryObject" href="#processEntryObject">&#x23;</a>

### processEntryObject.cntThreads <a id="processEntryObject.cntThreads" href="#processEntryObject.cntThreads">&#x23;</a>
此进程开启的线程计数

### processEntryObject.dwSize <a id="processEntryObject.dwSize" href="#processEntryObject.dwSize">&#x23;</a>
结构体长度，以字节为单位

### processEntryObject.pcPriClassBase <a id="processEntryObject.pcPriClassBase" href="#processEntryObject.pcPriClassBase">&#x23;</a>
进程优先级,INT数据类型

### processEntryObject.szExeFile <a id="processEntryObject.szExeFile" href="#processEntryObject.szExeFile">&#x23;</a>
进程启动文件名,不是文件完整路径

### processEntryObject.th32ParentProcessID <a id="processEntryObject.th32ParentProcessID" href="#processEntryObject.th32ParentProcessID">&#x23;</a>
父进程的 ID

### processEntryObject.th32ProcessID <a id="processEntryObject.th32ProcessID" href="#processEntryObject.th32ProcessID">&#x23;</a>
进程ID,INT数据类型

## startinfoObject 成员列表 <a id="startinfoObject" href="#startinfoObject">&#x23;</a>

### startinfoObject.createNoWindow <a id="startinfoObject.createNoWindow" href="#startinfoObject.createNoWindow">&#x23;</a>
应用程序不创建控制台窗口

### startinfoObject.creationFlag <a id="startinfoObject.creationFlag" href="#startinfoObject.creationFlag">&#x23;</a>

```aardio
startinfoObject.creationFlag = CREATE //创建进程的参数,参考API CreateProcess的说明
```

### startinfoObject.desktop <a id="startinfoObject.desktop" href="#startinfoObject.desktop">&#x23;</a>
标识启动应用程序所在的桌面的名字

### startinfoObject.domain <a id="startinfoObject.domain" href="#startinfoObject.domain">&#x23;</a>
域名

### startinfoObject.environment <a id="startinfoObject.environment" href="#startinfoObject.environment">&#x23;</a>
指定新进程的环境变量。  
可指定包含环境变量名值对的表对象。  
也可传入以下格式的字符串对象：  

环境变量的名字与值之间以`=`号分隔，多个环境变量以``'\0'``分隔。

### startinfoObject.fillAttribute <a id="startinfoObject.fillAttribute" href="#startinfoObject.fillAttribute">&#x23;</a>
控制台窗口使用的文本和背景颜色

### startinfoObject.flags <a id="startinfoObject.flags" href="#startinfoObject.flags">&#x23;</a>

```aardio
startinfoObject.flags = _STARTF_USE //指定结构体中哪些成员生效
```

### startinfoObject.inheritEnvironment <a id="startinfoObject.inheritEnvironment" href="#startinfoObject.inheritEnvironment">&#x23;</a>
如果此属性的值恒等于 false ,且同时指定了 environment 的值,  
那么创建的子进程不会继承父进程的环境变量  
此属性不指定值时默认值为true

### startinfoObject.inheritHandles <a id="startinfoObject.inheritHandles" href="#startinfoObject.inheritHandles">&#x23;</a>
默认值为真,所有有可被继承属性的内核对象都会被复制到子进程(实际上是内核对象引用计数加一)

### startinfoObject.logonFlags <a id="startinfoObject.logonFlags" href="#startinfoObject.logonFlags">&#x23;</a>
登录选项,默认为 _LOGON_WITH_PROFILE

### startinfoObject.password <a id="startinfoObject.password" href="#startinfoObject.password">&#x23;</a>
登录密码

### startinfoObject.processAttributes <a id="startinfoObject.processAttributes" href="#startinfoObject.processAttributes">&#x23;</a>
SECURITY_ATTRIBUTES结构体指针,一般不建议设置  
如需设置请使用 raw.buffer 将结构体转换为指针

### startinfoObject.showWindow <a id="startinfoObject.showWindow" href="#startinfoObject.showWindow">&#x23;</a>
显示参数，  
支持以_SW_ 前缀的常量  
_SW_HIDE 表示隐藏窗口（默认值）。  
此属性用于指定是否显示控制台以外的窗口，  
flags 字段必须指定 _STARTF_USESHOWWINDOW 才会生效

### startinfoObject.stdError <a id="startinfoObject.stdError" href="#startinfoObject.stdError">&#x23;</a>
标准错误输出(可用于创建管道)

### startinfoObject.stdInput <a id="startinfoObject.stdInput" href="#startinfoObject.stdInput">&#x23;</a>
标准输入（可用于创建管道）

### startinfoObject.stdOutput <a id="startinfoObject.stdOutput" href="#startinfoObject.stdOutput">&#x23;</a>
标准输出（可用于创建管道）

### startinfoObject.suspended <a id="startinfoObject.suspended" href="#startinfoObject.suspended">&#x23;</a>
是否休眠创建进程的主线程  
如果为真自动添加_CREATE_SUSPENDED参数

### startinfoObject.threadAttributess <a id="startinfoObject.threadAttributess" href="#startinfoObject.threadAttributess">&#x23;</a>
SECURITY_ATTRIBUTES结构体指针,一般不建议设置  
如需设置请使用 raw.buffer 将结构体转换为指针

### startinfoObject.title <a id="startinfoObject.title" href="#startinfoObject.title">&#x23;</a>
控制台标题

### startinfoObject.username <a id="startinfoObject.username" href="#startinfoObject.username">&#x23;</a>
登录用户名

### startinfoObject.waitInputTimeout <a id="startinfoObject.waitInputTimeout" href="#startinfoObject.waitInputTimeout">&#x23;</a>
进程启动后自动调用 waitForInputIdle 等待进入输入空闲状态的最大超时。  
默认为0xFFFFFFFF(无限等待),设为0则不等待

### startinfoObject.workDir <a id="startinfoObject.workDir" href="#startinfoObject.workDir">&#x23;</a>
进程工作目录,  
默认值为 process.workDir

### startinfoObject.x <a id="startinfoObject.x" href="#startinfoObject.x">&#x23;</a>
x坐标(子进程使用默认坐标时、或控制台窗口支持)

### startinfoObject.xCountChars <a id="startinfoObject.xCountChars" href="#startinfoObject.xCountChars">&#x23;</a>
控制台宽度(字符单位)

### startinfoObject.xSize <a id="startinfoObject.xSize" href="#startinfoObject.xSize">&#x23;</a>
窗口宽(子进程使用默认坐标时、或控制台窗口支持)

### startinfoObject.y <a id="startinfoObject.y" href="#startinfoObject.y">&#x23;</a>
y坐标(子进程使用默认坐标时、或控制台窗口支持)

### startinfoObject.yCountChars <a id="startinfoObject.yCountChars" href="#startinfoObject.yCountChars">&#x23;</a>
控制台高度(字符单位)

### startinfoObject.ySize <a id="startinfoObject.ySize" href="#startinfoObject.ySize">&#x23;</a>
窗口高(子进程使用默认坐标时、或控制台窗口支持)

## threadEntry 成员列表 <a id="threadEntry" href="#threadEntry">&#x23;</a>

### threadEntry.cntUsage <a id="threadEntry.cntUsage" href="#threadEntry.cntUsage">&#x23;</a>
引用计数

### threadEntry.dwFlags <a id="threadEntry.dwFlags" href="#threadEntry.dwFlags">&#x23;</a>
th32OwnerProcessID = 进程ID

### threadEntry.dwSize <a id="threadEntry.dwSize" href="#threadEntry.dwSize">&#x23;</a>
结构体大小

### threadEntry.th32OwnerProcessID <a id="threadEntry.th32OwnerProcessID" href="#threadEntry.th32OwnerProcessID">&#x23;</a>
`Process this thread is associated with`

### threadEntry.th32ThreadID <a id="threadEntry.th32ThreadID" href="#threadEntry.th32ThreadID">&#x23;</a>
线程ID

### threadEntry.tpBasePri <a id="threadEntry.tpBasePri" href="#threadEntry.tpBasePri">&#x23;</a>
`tpDeltaPri =`

### 自动完成常量
_CREATE_NEW_CONSOLE=0x10  
_CREATE_NEW_PROCESS_GROUP=0x200  
_CREATE_NO_WINDOW=0x8000000  
_CREATE_PROCESS_DEBUG_EVENT=3  
_CREATE_SUSPENDED=4  
_MEM_4MB_PAGES=0x80000000  
_MEM_COMMIT=0x1000  
_MEM_DECOMMIT=0x4000  
_MEM_FREE=0x10000  
_MEM_LARGE_PAGES=0x20000000  
_MEM_MAPPED=0x40000  
_MEM_PHYSICAL=0x400000  
_MEM_PRIVATE=0x20000  
_MEM_RELEASE=0x8000  
_MEM_RESERVE=0x2000  
_MEM_RESET=0x80000  
_MEM_ROTATE=0x800000  
_MEM_TOP_DOWN=0x100000  
_MEM_WRITE_WATCH=0x200000  
_PAGE_EXECUTE=0x10  
_PAGE_EXECUTE_READ=0x20  
_PAGE_EXECUTE_READWRITE=0x40  
_PAGE_EXECUTE_WRITECOPY=0x80  
_PAGE_GUARD=0x100  
_PAGE_NOACCESS=1  
_PAGE_NOCACHE=0x200  
_PAGE_READONLY=2  
_PAGE_READWRITE=4  
_PAGE_WRITECOMBINE=0x400  
_PAGE_WRITECOPY=8  
_PROCESS_ALL_ACCESS=0x1FFFFF  
_PROCESS_CREATE_PROCESS=0x80  
_PROCESS_CREATE_THREAD=2  
_PROCESS_DUP_HANDLE=0x40  
_PROCESS_QUERY_INFORMATION=0x400  
_PROCESS_QUERY_LIMITED_INFORMATION=0x1000  
_PROCESS_SET_INFORMATION=0x200  
_PROCESS_SET_QUOTA=0x100  
_PROCESS_SET_SESSIONID=4  
_PROCESS_SUSPEND_RESUME=0x800  
_PROCESS_TERMINATE=1  
_PROCESS_VM_OPERATION=8  
_PROCESS_VM_READ=0x10  
_PROCESS_VM_WRITE=0x20  
_STANDARD_RIGHTS_REQUIRED=0xF0000  
_SYNCHRONIZE=0x100000  
_TH32CS_INHERIT=0x80000000  
_TH32CS_SNAPALL=0xF  
_TH32CS_SNAPHEAPLIST=1  
_TH32CS_SNAPMODULE=8  
_TH32CS_SNAPMODULE32=0x10  
_TH32CS_SNAPPROCESS=2  
_TH32CS_SNAPTHREAD=4  
