Working with Processes

FOR-PROCS: "proc_pattern" <...> ;FOR-PROCS

This is a special cycle which can be used to perform operations not just on single processes, but entire groups of processes matching a specified mask; commands included in the body of FOR-PROCS loop will be applied to each of these processes.

It works in this way: if there are, for example, five processes matching a certain mask, then FOR-PROCS: loop will be automatically executed five times and each time values of the variables %FOUND-PROC% and %FOUND-PID% will be renewed; these variables contains a name of last found process and its Process ID (PID) respectively.


#( test_for_processes
\ printing to console names of all running processes
    FOR-PROCS: "*.exe"

That means that on each iteration of the loop you get access to the name and PID of the next process matching a specified mask, and now it only remains to perform the required action with this process (e.g. stop it or assign a desired priority etc.) or to perform another check in order to decide what to do with this process.


#( test_for_processes1
\ displaying a query and ending, one by one,  
\ all found processes of Internet Explorer
    FOR-PROCS: "iexplore.exe"
        QUERY: "End process %FOUND-PROC%?"
            KILL: "%FOUND-PID%"

KILL: "proc_pattern"

This word terminates a specified process. It can take as its argument a mask of a process name (which is normally the same as the name of the executable file which is used to start this process) or a string containing numerical process identifier (PID), which is stored in predefined variable PROC-ID immediately after a program has been started.

By using a process identifier as an argument, you can terminate a particular process even if there are several instances of the same program running, i. e. there are several processes with the same name. Please note that variable PROC-ID is filled each time a when a program is successfully started by words START-APP, START-APPW or QSTART-APP, but if the process we want to stop was started by word START-APPW, you shouldn't use the value stored in PROC-ID, for in this case this variable would contain PID of the process which was already stopped.

KILL: can also be used with predefined variable %WATCH-PROC-ID%, in which words WatchProc:/WatchProcStop: store the PID of the process they have found.


\ using process name
KILL: "opera.exe"
KILL: "notepad.exe"
KILL: "*pad.exe"
\ using process identifier (PID)
KILL: "2121"
#( test_proc_id
VARIABLE my_notepad_id
    START-APP: notepad.exe
    PAUSE: 1000
    START-APP: notepad.exe
    PROC-ID my_notepad_id !
    PAUSE: 1000
    START-APP: notepad.exe
    \ ... something useful here
    \ terminating the second instance of Notepad
    KILL: "%my_notepad_id @%"

There also exists a postfix version of this word:

S" opera.exe" KILL
S" 2121" KILL

kill ( pid -- )

This postfix word terminates a process accepting its PID as an argument. Since word kill takes a number as its argument, you won't have to convert a number returned by PROC-ID or WATCH-PROC-ID into a string:

386 kill
PROC-ID kill
my_proc_id @ kill

PROC-TIME: "proc_pattern"

Puts on stack the time (number of seconds) during which a specified process has been working.

Works only in WinNT/2000/XP.

ProcActiveTime ( pid -- ms)

Puts on stack the time (double number - number of milliseconds) during which the specified process has been working. Takes a PID as its argument.


#( test_proctime
    S" notepad.exe" PROC-EXIST? ?DUP
        \ printing the time of work to console
        ProcActiveTime D>S . CR
        MSG: "Notepad is not started!"

PROC-EXIST: "proc_pattern"

Returns TRUE (-1) if there exists a process matching a specified pattern. As an argument for PROC-EXIST: one should normally use the name of the executable file that starts a process.


Rule: PROC-EXIST: "winword.exe"

A process can be identified not only by the file name, but also by full path to the application file. In order to do that, use option PROC-FULLPATH. If the process name contains at least one backslash ('\'), nnCron will automatically try to identify it by the full path to its executable file.



If you want to find out PID of a process, use postfix word PROC-EXIST?


\ puts on stack PID of 'winword.exe'
S" winword.exe" PROC-EXIST?

PROC-FULLNAME ( pid - a u)
PROC-NAME ( pid - a u)

These postfix words get Process ID (PID) as their arguments and return a string with full/short process name. PROC-NAME returns a short process name (usually a name of the executable file, like notepad.exe), and PROC-FULLNAME returns the name of the executable file together with the full path to this file (c:\windows\system32\notepad.exe).


#( test_procname
WatchProc: "notepad.exe"
\ printing process short name to the console
\ displaying a message with process full name

PROC-WAIT-IDLE ( pid -- )

This postfix word pauses the task until the specified process becomes idle. For example, you can use PROC-WAIT-IDLE when launching an application (START-APP:) if you want to make sure the application is fully loaded into computer memory before the task resumes it's work.


#( test_start_app
    START-APP: your_prog.exe
    \ pausing the task until your_prog.exe is 
    \ fully loaded into computer memory
    \ resuming the task
    \ ...

proc_pattern is a process's name or name mask. Normally, a process name is the same as the name of executable file which is used to start this process. However, one can also use a full path to the executable file as a process name. In masks of process names or paths to executable files, you can use wildcard characters '*' and '?', or regular expressions between slashes: /<regexp>/.
If a mask contains at least one backslash ('\'), it will be compared with the full path of executable file.
Process identifiers also can be used as values for proc_pattern. (See PROC-ID, %WATCH-PROC-ID%).


\ process name
PROC-EXIST: "notepad.exe"
\ mask of  process name
PROC-EXIST: "notepad*"
PROC-EXIST: "*pad.exe" \ masks of process names taking in account the full path PROC-EXIST: "*\notepad*" PROC-EXIST: "c:\*\notepad.exe" \ regular expression PROC-EXIST: "/(note)|(word)pad.exe/i" \ process identifier PROC-EXIST: "1116"
PROC-EXIST: "%my_proc_id @%"

See also: