Launching external programs from plugins in Windows

[Gavin-Holt]

Hi,

From the help file (excert below) I can choose from :

• ExecCommand()
• RunCommand()
• RunBackgroundShell()
• JobStart()
• JobSpawn()

All these options wait for a result, blocking any other activity in Micro.

I guess these functions are useful when you need to get output back into Micro.

However, I have had problems just launching a program, without waiting for a return value.

(I have been trying the 1BRC in Lua and wanted to launch my script - it's not fast)

I have tried various invocations of the functions above:

• RunCommand([[cmd.exe /c start ""]])
• ExecCommand([[cmd.exe /c start ""]])
• RunCommand([[cmd.exe /c start "" >2nul >nul ]])
• ExecCommand([[cmd.exe /c start "" >2nul >nul ]])

The only way I have found is to use an external Windows specific launcher:

function shelexec(command,parameters,directory)
-- Spawn new processes - without waiting for output
-- requires shelexec.exe from http://www.naughter.com/shelexec.html
    local cmd  = [[shelexec.exe]]
    if parameters then
        cmd = cmd..[[ /Params:]]..parameters
    elseif directory then
        cmd = cmd..[[ /Dir:]]..directory
    end
    shell.RunCommand(cmd..[[ /EXE ]]..command)
end

function runfile(Current)
    -- Save the current file
    Current.Buf:Save()
    -- Launch with default association
    shelexec(Current.Buf.Path)
end

Is there a better way?

Kind Regards Gavin Holt

From the help file:

• micro/shell

  • ExecCommand(name string, arg ...string) (string, error): runs an
    executable with the given arguments, and pipes the output (stderr
    and stdout) of the executable to an internal buffer, which is
    returned as a string, along with a possible error.

  • RunCommand(input string) (string, error): same as ExecCommand,
    except this uses micro's argument parser to parse the arguments from
    the input. For example, cat 'hello world.txt' file.txt, will pass
    two arguments in the ExecCommand argument list (quoting arguments
    will preserve spaces).

  • RunBackgroundShell(input string) (func() string, error): returns a
    function that will run the given shell command and return its output.

  • RunInteractiveShell(input string, wait bool, getOutput bool) (string, error):
    temporarily closes micro and runs the given command in the terminal.
    If wait is true, micro will wait for the user to press enter before
    returning to text editing. If getOutput is true, micro will redirect
    stdout from the command to the returned string.

  • JobStart(cmd string, onStdout, onStderr, onExit func(string, []interface{}), userargs ...interface{}) *exec.Cmd:
    Starts a background job by running the shell on the given command
    (using sh -c). Three callbacks can be provided which will be called
    when the command generates stdout, stderr, or exits. The userargs will
    be passed to the callbacks, along with the output as the first
    argument of the callback. Returns the started command.

  • JobSpawn(cmd string, cmdArgs []string, onStdout, onStderr, onExit func(string, []interface{}), userargs ...interface{}) *exec.Cmd:
    same as JobStart, except doesn't run the command through the shell
    and instead takes as inputs the list of arguments. Returns the started
    command.

My 1BRC in Lua

-- 1BRC https://github.com/gunnarmorling/1brc
-- Naïve Lua implementation

nClock = os.clock()

-- 1. Create custom functions
local min = math.min
local max = math.max
local floor = math.floor
local function split(inputstr)
    local semi = inputstr:find([[;]])
    return inputstr:sub(1,semi-1), inputstr:sub(semi+1)
end

-- 2. Create results table and key table
results = {}
keys = {}

-- 3. Iterate over file and save city keys
file  = [[O:\MyProfile\tests\lua\measurements.txt]]
for line in io.lines(file) do
    city, temp = split(line)
    if not results[city] then
        results[city] = {min = temp,max = temp,sum = temp,count = 1}
        table.insert(keys, city)
    else
        results[city].count = results[city].count + 1
        results[city].min = min(results[city].min,temp)
        results[city].max = max(results[city].max,temp)
        results[city].sum = results[city].sum + temp
    end
end

-- 4. Sort keys
table.sort(keys)

-- 5. Format and output
io.write("{")
for _, key in ipairs(keys) do
    local avg = floor((results[key].sum/results[key].count)*10)/10
    io.write(key.."=".. results[key].min.."/"..avg.."/".. results[key].max)
end
io.write("}")

-- 6. Finish
print("Elapsed time is: " .. os.clock()-nClock)

-- 7. View result
os.execute("pause")

[Andriamanitra]

The last two functions you listed (shell.JobStart, and shell.JobSpawn) just start the command (without waiting for it to finish) and return a Cmd object that you can use to communicate with the process. They shouldn't block any other activity in micro.