Execução de Scripts a partir de Scripts
Modelo de Dados
Funções de Gerência de Scripts
list = Scripts.ListScritps()
Descrição:
Lista todos os nomes de scritps associados ao seu código-fonte em Lua.
Parâmetros de saída:
Tabela Lua cujas chaves são nomes de scripts e cujos valores são os respectivos códigos-fonte.
Exemplo de utilização:
local scripts = Scripts.ListScripts()
for pathname, src_code in pairs(scripts) do
print(pathname .. " : " .. tostring(#src_code))
end
result,error = Scripts.Run(script_path_name [, param [, exec_parallel=false]])
Descrição:
Executa o script cujo caminho e nome são descritos por script_path_name. É possível executá-lo sincronamente no contexto do script chamador, ou em paralelo. Se a invocação for em paralelo (exec_parallel=true) então o parâmetro param deve ser obrigatoriamente nil, neste caso o par result,error será sempre nil,nil.
Parâmetros de entrada:
Script_path_name - Caminho e Nome do script já registrado que deve ser executado. (Ex.: Kernel.Scripts.ScriptGroup_001.Script_001)
Params - Valor passado como parâmetro (opcional).
Exec_parallel - Booleano que indica se a execução será em paralelo, ou o chamador ficará em espera pelo término da execução (default).
Parâmetros de saída:
Result - Valor lua retornado pelo script invocado ou nil (em caso de erro ou caso o script invocado não retorne explicitamente um valor).
Error - nil (se a execução for bem sucedida) ou mensagem de erro.
Exemplo de utilização:
-- Execução sem parâmetros
local err
local result
result,err = Scripts.Run('Kernel.Scripts.ScriptGroup_001.Script_001')
if err then
print(err)
else
print('Script executado com sucesso:' .. tostring(result))
end
O uso de caminho completo no nome de script foi introduzido a partir da versão 1.0.05. O uso de apenas o nome do script como primeiro parâmetro só é suportado no HIscada Pro até a versão 1.0.04.
Tratamento de erros
Em um script a função padrão de Lua error(msg) pode ser utilizada para interromper a execução de um script e sinalizar para quem invocou o script qual a mensagem de erro.
Script invocador:
result,err = Scripts.Run("Viewers.Scripts.ScriptGroup_001.Script_001", 1)
print("Invocado com 1, result:" .. tostring(result) .. ", err:" .. tostring(err))
result,err = Scripts.Run("Viewers.Scripts.ScriptGroup_001.Script_001", 2)
print("Invocado com 2, result:" .. tostring(result) .. ", err:" .. tostring(err))
Script invocado (Viewers.Scripts.ScriptGroup_001.Script_001) que sinaliza situação de erro:
print("Param recebido " .. tostring(Param))
if Param==2 then
error("erro em script")
print("nunca deve ser impresso")
end
return Param*2
Saída da execução:
Param recebido 1
Invocado com 1, result:2, err:nil
Param recebido 2
Invocado com 2, result:nil, err:[string "print("Param recebido " .. tostring(Param))
..."]:3: erro em script (Viewers.Scripts.ScriptGroup_001.Script_001)
Exemplo de utilização de invocação sequêncial
O terceiro parâmetro de Scripts.Run() define se a invocação é sequencial ou em paralelo. Se não especificado, este parâmetro assume o valor default igual a false que representa invocação sequencial. No caso da invocação sequencial, as variáveis e funções globais que existiam no script invocador estão disponíveis também no script invocado, pois ambos executam no mesmo contexto. É possível retornar valores do script invocado para o script invocador.
Scripts que serão invocados
Callee1
print("Param: " .. tostring(Param))
print("não retorno parâmetros")
Callee2
print("Param: " .. tostring(Param))
print("Esperava receber uma tabela")
local result = {}
for k,v in pairs(Param) do
print(tostring(k) .. " -> " .. tostring(v))
result[v]=k
end
return result
Callee3
print("Param: " .. tostring(Param))
print("retorno 2 parâmetros = 1, 'One'")
return 1,"One"
Script que invocará outros scripts
print("Callee1")
result, err = Scripts.Run("Kernel.Scripts.ScriptGroup_001.callee1")
print("Result:" .. tostring(result))
print("Erro: " .. tostring(err))
print("Callee2")
local p = {x=1, y=2}
result, err = Scripts.Run("Kernel.Scripts.ScriptGroup_001.callee2", p)
print("Erro: " .. tostring(err))
print("Result")
for k,v in pairs(result) do
print(tostring(k) .. " -> " .. tostring(v))
end
print("Callee3")
result1, result2, err = Scripts.Run("Kernel.Scripts.ScriptGroup_001.callee3")
print("Result 1:" .. tostring(result1))
print("Result 2:" .. tostring(result2))
print("Erro: " .. tostring(err))
Resultado da execução:
Callee1
Param: nil
não retorno parâmetros
Result:nil
Erro: nil
Callee2
Param: table: 02D59538
Esperava receber uma tabela
y -> 2
x -> 1
Erro: nil
Result
1 -> x
2 -> y
Callee3
Result 1:nil
Param: nil
Result 2:nil
retorno 2 parâmetros = 1, 'One'
Erro: nil
Exemplo de utilização de invocação paralela
Quando o terceiro parâmetro de Scripts.Run() é true, a invocação é em paralelo. No caso da invocação paralela, as variáveis e funções globais que existiam no script invocador NÃO estão disponíveis no script invocado, pois os dois scripts executam em contextos isolados e em paralelo. Neste caso, não é possível retornar valores do script invocado para o script invocador, e os resultados (result,error) de Scripts.Run() serão sempre nulos (nil,nil).
Callee
-- mesmo em scripts executados em paralelo é possível passar parâmetros entre os dois scripts.
print("Param recebido " .. tostring(Param))
if type(Param)=='number' and Param==2 then
-- simula situação de erro
error("erro em script")
print("nunca deve ser impresso")
end
-- script executado em paralelo não tem como retornar valor
Script que invocará outros scripts em paralelo
result,err = Scripts.Run("Viewers.Scripts.ScriptGroup_001.Script_001", {1,2,3}, true)
print("Invoca com 1, result:" .. tostring(result) .. ", err:" .. tostring(err))
result,err = Scripts.Run("Viewers.Scripts.ScriptGroup_001.Script_001", 2, true)
print("Invoca com 2, result:" .. tostring(result) .. ", err:" .. tostring(err))
Resultado da execução:
Executando __interactive__
Invoca com 1, result:nil, err:nil
Param recebido table: 04377FB0
Invoca com 2, result:nil, err:nil
Param recebido 2
Script_001:[string "print("Param recebido " .. tostring(Param))..."]:5: erro em script