org.vishia.cmd

Class JZtxtcmdExecuter

java.lang.Object

org.vishia.cmd.JZtxtcmdExecuter

public class JZtxtcmdExecuter
extends java.lang.Object

This class is the executer of JZcmd. The translated JZscript is contained in an instance of JZtxtcmdScript. It can be executed with a given script:

• execute(JZtxtcmdScript, boolean, boolean, Appendable, String) executes a given translated script.
• execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File) executes one subroutine from a translated script. It is possible to translate a script one time, and then invoke any subroutine from a java context on demand.
• #initialize(JZtxtcmdScript, boolean, Map, String, boolean) cleans the instance and generates all script variables. It prepares usage for execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File).
• reset() cleans the instance. The scriptvariables will be generate by first call of execute(JZtxtcmdScript, boolean, boolean, Appendable, String)

To use the Java platform's CompiledScript eval method start JZtxtcmdScript.eval(ScriptContext) with an instance of scriptLevel().

An instance of this class is used while #execute(JZcmdScript, boolean, boolean, Appendable)) is running. You should not use the instance concurrently in more as one thread. But you can use this instance for one after another call of #execute(JZtxtcmdScript, boolean, boolean, Appendable). Note that Threads can be created in the script.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	JZtxtcmdExecuter.CmdErrorLevelException A thread instance of JZcmd.
static class	JZtxtcmdExecuter.ExecuteLevel Wrapper to generate a script with specified localVariables.
static class	JZtxtcmdExecuter.ExitException
protected static class	JZtxtcmdExecuter.JZcmdBindings
static class	JZtxtcmdExecuter.JZcmdThrow
protected static class	JZtxtcmdExecuter.JzScriptException
static class	JZtxtcmdExecuter.JzTcMain This class is the jzcmd main level from a script.
static class	JZtxtcmdExecuter.ListMap It is a List but also with Map
static class	JZtxtcmdExecuter.NextNr Simple class to build a countered number.

Field Summary

Fields

Modifier and Type	Field and Description
private JZtxtcmdExecuter.JzTcMain	acc The usable instance of the JZtxtcmdExecuter for some managements.
protected java.lang.String	accessError Variable for any exception while accessing any java resources.
static short	kBreak Should break a loop, break statement.
static short	kException Has thrown an not catch exception. onerror statement not found.
private static short	kFalse Only internal designation.
static short	kReturn Should return from subroutine, return statement.
static short	kSuccess Should continue.
private static java.lang.CharSequence	retException This instance is used to mark a return object as exception return.
static java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>>	useScriptLevel This is an instance used as marker for execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File) for the argument args to use the script level in the sub routine variable instead.
static java.lang.String	version Version, history and license.

Constructor Summary

Constructors

Constructor and Description
JZtxtcmdExecuter() Creates a JZcmdExecuter with possible writing exceptions in the output text.
JZtxtcmdExecuter(LogMessage log) Creates a JZcmdExecuter with possible writing exceptions in the output text.

Method Summary

Modifier and Type	Method and Description
boolean	abortCmdExecution() Aborts all CmdExecuter for operation system calls in all threads of this.
private boolean	checkInitialize(JZtxtcmdScript script, boolean accessPrivate, java.lang.CharSequence sCurrdir)
private boolean	checkInitialize(JZtxtcmdScript script, boolean accessPrivate, java.util.List<DataAccess.Variable<java.lang.Object>> args, java.lang.CharSequence sCurrdir)
private boolean	checkInitialize(JZtxtcmdScript script, boolean accessPrivate, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args, java.lang.CharSequence sCurrdir)
private boolean	checkInitialize(JZtxtcmdScript script, boolean accessPrivate, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args, java.io.File currdir)
java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>>	execSub(JZtxtcmdScript.Subroutine statement, java.util.List<DataAccess.Variable<java.lang.Object>> arglist, boolean accessPrivate, java.lang.Appendable out, java.io.File currdir, CmdExecuter cmdExecuter) Executes the given sub routine invoked from any user application.
java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>>	execSub(JZtxtcmdScript.Subroutine statement, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args, boolean accessPrivate, java.lang.Appendable out, java.io.File currdir) Executes a subroutine.
java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>>	execSub(JZtxtcmdScript script, java.lang.String name, java.util.List<DataAccess.Variable<java.lang.Object>> args, boolean accessPrivate, java.lang.Appendable out, java.io.File currdir) Executes a subroutine.
java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>>	execSub(JZtxtcmdScript script, java.lang.String name, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args, boolean accessPrivate, java.lang.Appendable out, java.io.File currdir) Executes a subroutine.
(package private) void	execute_i(JZtxtcmdScript script, boolean accessPrivate, boolean bWaitForThreads, java.lang.String sCurrdir, boolean bscriptInitialized) Inner routine to process the execution after initializing the script.
JZtxtcmdExecuter.ExecuteLevel	execute_Scriptclass(JZtxtcmdScript.JZcmdClass clazz) Executes the code of a class in a script without checking the whole script.
JZtxtcmdExecuter.ExecuteLevel	execute_Scriptclass(java.lang.String sClazz) Initializes respectively calculates a class newly.
void	execute(JZtxtcmdScript script, boolean accessPrivate, boolean bWaitForThreads, java.lang.Appendable outFromCmdlineArg, java.util.List<DataAccess.Variable<java.lang.Object>> data, java.lang.String sCurrdir) Executes the given script.
void	execute(JZtxtcmdScript script, boolean accessPrivate, boolean bWaitForThreads, java.lang.Appendable outFromCmdlineArg, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> data, java.lang.String sCurrdir) Executes the given script.
void	execute(JZtxtcmdScript script, boolean accessPrivate, boolean bWaitForThreads, java.lang.Appendable outFromCmdlineArg, java.lang.String sCurrdir) Executes the given script.
void	executeScriptLevel(JZtxtcmdScript script, java.lang.CharSequence sCurrdir) Stores the script and executes the script level to generate the script level variables, especially the script variables were calculated yet.
JZtxtcmdScript	getScript() Returns the currently assigned script, maybe null on start.
DataAccess.Variable<java.lang.Object>	getScriptVariable(java.lang.String name)
private void	initialize_i(JZtxtcmdScript script, boolean accessPrivate, java.lang.CharSequence sCurrdirArg)
void	initialize(JZtxtcmdScript script, boolean accessPrivate, java.lang.CharSequence sCurrdirArg) Initializes the standard script variables and maybe executes the script level.
void	initialize(JZtxtcmdScript script, boolean accessPrivate, java.util.List<DataAccess.Variable<java.lang.Object>> srcVariables, java.lang.CharSequence sCurrdirArg) Initializes the standard script variables and maybe executes the script level.
void	initialize(JZtxtcmdScript script, boolean accessPrivate, java.util.List<DataAccess.Variable<java.lang.Object>> srcVariables, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> envar, java.lang.CharSequence sCurrdirArg) Initializes the standard script variables and maybe executes the script level.
void	initialize(JZtxtcmdScript script, boolean accessPrivate, java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> srcVariables, java.lang.CharSequence sCurrdirArg) Initializes the standard script variables and maybe executes the script level.
JZtxtcmdExecuter.ExecuteLevel	newExecuteLevel(JZtxtcmdThreadData threadData) Creates a ExecuteLevel for the script which can be used to execute some sub routines (not only main) in the given thread on demand.
DataAccess.Variable<java.lang.Object>	removeScriptVariable(java.lang.String name)
void	reset() Clears the instance.
JZtxtcmdExecuter.ExecuteLevel	scriptLevel() Returns the script level instance.
java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>>	scriptVariables() Returns the association to all script variables.
void	setScriptVariable(java.lang.String name, char type, java.lang.Object content, boolean bConst) Deprecated. It is deprecated now. On start of a script or a subroutine from a script a List or Map of additional script variables can be provided. This is a safe but other way. The script variable created with this routine may be removed if the script was newly initialized. Only if the following order of execution is given, it is proper: initialize(script, accessPrivate, currDir); //will initialize setScriptVariable(name, type, content, const); execute(script, ....); The JZcmdExecuter instance should be firstly initialize with the same script.
(package private) void	stop()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

version

public static final java.lang.String version

Version, history and license.

• 2023-08-14 new getScript(), newExecuteLevel(JZtxtcmdThreadData), ExecuteLevel#exec_Subroutine(Subroutine, List, StringFormatter, int) Used for org.vishia.gral.cfg.GuiCfg in srcJava_vishiaGui component.
• 2023-07-21 rarely bug fixed in 'exec_Subroutine(...)': if argument is null, should not throw. null should be admissible.
• 2022-11-13 Hartmut meaningful change: JZtxtcmdExecuter.ExecuteLevel.changeCurrDir(CharSequence) now sets the "user.dir" Java system's property. With them it is possible generally in Java to open a file via FileFunctions.newFile(System.getProperty("user.dir"), sRelativePath), then this is effective. It does not effect the operation system's PWD, but usable via this property.
• 2022-01-31 Hartmut feature: Now the order of statements from included files are proper. In the versions before script statements of included files were placed after the statements of the current file, due to processing the includes after wards. Now in the JZtxtcmdScript.createScriptFromString(org.vishia.util.StringPartScan, LogMessage, File, File) the included script statements are stored in the JZtxtcmdScript.JZcmdInclude item itself, and executed in this order. Additonal case '.' in JZtxtcmdExecuter.ExecuteLevel.execute(org.vishia.cmd.JZtxtcmdScript.StatementList, StringFormatter, int, Map, int).
• 2021-06-21 Hartmut new jztc.envar A container which can be given to hold variables from the calling environment (a Java program) This variables are not changed if a new JZtxtcmdScript is translated and started. Used firstly for the Stimuli Selector GUI https://vishia.org/StimuliSel/html/StimuliSel.html
• 2021-06-12 Hartmut now write to System.err if inside a thread there is an error. Before (bug) it was silent, an error was not seen.
• 2021-06-12 Hartmut capability of JZtxtcmdExecuter.JzTcMain.envar for simple access to Java data from the calling environment. initialize(JZtxtcmdScript, boolean, List, Map, CharSequence) enhanced for that.
• 2021-06-11 Hartmut refactoring: Only formally replacements, but possible side effects, not supposed but not excluded. Change IndexMultiTable to TreeMap for the variables. The IndexMultiTable is also a Map, but not supported from Eclipse debug view "Show Logical Structure". It is more complex handling for debugging. Hence replaced.
  The difference TreeMap, IndexMultiTable is: last one should not have unique keys. But for that application the keys are unique (the variables). Hence there should not be side effects. Only one passage in ExecuteLevel#exec_cmdline(org.vishia.cmd.JZtxtcmdScript.CmdInvoke), see comment there.
• 2021-06-08 Hartmut improved: throw on missing main is a better error messaging.
• 2021-02-07 Hartmut new: List ... [ @ <$?keyVariableName> ] then the List is stored with a Map part to access an element via the value in the named variable. Access possible via get(name)
• 2021-02-06 Hartmut bugfix: Now variables scriptfile and scriptdir are correct.
• 2020-07-22 Hartmut bugfix: now invoke level.close(): {@link ExecuteLevel#close()}, it invokes this.cmdExecuter.close() {@link CmdExecuter#close() }which closes the out and error Thread. Note: The {@link ExecuteLevel#cmdExecuter} will remain open, not removed, so long the level runs. For this time the output and error thread of the CmdExecuter remain open. It is a proven concept since few years. Do not close the CmdExcuter every time when finished. Held open for the next action may be in a loop.
• 2020-03-14 Hartmut bugfix: {@link ExecuteLevel#ctNesting} should be counted if internal execute levels are created, elsewhere the {@link ExecuteLevel#cmdExecuter} is closed on inner levels. fixed.
• 2018-10-16 Hartmut bugfix: The empty statement list in script part onerror{} was syntactically admissible but the execution crashes. fixed.
• 2018-09-22 Hartmut new in {@link ExecuteLevel#exec_OpenTextOut(org.vishia.cmd.JZtxtcmdScript.JZcmditem, StringFormatter, boolean)} : text = appendableObj can be used yet, it is especially to assign the text output to an GUI output box widget.
• 2018-09-17 new {@link JzTcMain#sleep(int)}
• 2018-09-10 Hartmut bugfix. The script variable text = path/to/textout cannot be set. Now the argument -t=out wins against the script variable, but if -t is not set, the scriptVariable text = ... is used. bugfix: setting text = ... in the script should be used immediately after that. Changing of {@link ExecuteLevel#exec_OpenTextOut(org.vishia.cmd.JZtxtcmdScript.JZcmditem, StringFormatter, boolean)}.
• 2018-08-29 Hartmut new: {@link ExecuteLevel#exec_DefVariable(Map, org.vishia.cmd.JZtxtcmdScript.DefVariable, char, Object, boolean)}: Converts to Numeric value on a Num variable ('K'). TODO: do same for Bool ('Q')
• 2018-08-29 Hartmut new: true, false, Num as script variable.
• 2018-08-29 Hartmut new: Conversion Bool to boolean for java operation args, see {@link DataAccess}.
• 2018-01-07 Hartmut new: mkdir with ' at least for path/to/file, see documentation.
• 2017-09-09 Hartmut chg: The zmake uses a datapath yet instead a String-named Fileset variable. It is more universal in application and more clear in syntax. There may be used 2 datapath, 1 for the accessPath and the Fileset. If only one datapath is used, the type of the gotten instance decides whether it is only one file given with access path (not a Fileset) or the only one datapath is the Fileset. Writing &access.path&myfileset or &access.onefile or &myFileset The older scripts are running unregarded of this change. The description in www.vishia.org/.../JZtxtcmd.html is renewed.
• 2017-09-04 Hartmut bugfix: {@link ExecuteLevel#evalCondition(org.vishia.cmd.JZtxtcmdScript.JZcmditem)}: A Integer value will be convert to bool now. Before: Bool val = 0 is interpret as true because 0 is an Integer object which exists. Now Integer.intValue() !=0 is checked.
• 2017-08-30 Hartmut new: implementation of the feature Obj name :type = ...., checking of the type now on assigning of the value. This feature was prepared in syntax but not implemented till now.
• 2017-08-30 Hartmut new: uses {@link JzScriptException} extends {@link ScriptException} only because the line:col should be able to read on start of the next line, better able to found on error messages.
• 2017-07-12 Hartmut new: debugOp
• 2017-06-13 Hartmut chg: for(entry: numvalue) works now for 0 to numvalue-1, especially for array indices.
• 2017-01-13 Hartmut chg: On any call of execute(...) or execSub(..) the given script will be used as current and replaces an old one. If it is another script as the last one, the new script will be established. It means, the existing script variables are deleted and the script variables of the new given script are calculated and stored. If the script is the same, the variables won't be replaced. It is a spare of time, but also additional variables will be kept. The new rule is: the JZcmdExecuter can be used for several scripts one after another (in one thread). The current script wins.
• 2016-12-27 Hartmut chg: {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, boolean, Appendable, File)} now works with a List of arguments instead Map. The arguments are checked in {@link ExecuteLevel#exec_Subroutine(org.vishia.cmd.JZcmdScript.Subroutine, ExecuteLevel, List, List, StringFormatter, int, int).} Thus argument type conversion is done especially argument type {@link FilePath} for the.File.commander - execution. The {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)} with Map supports a Variable Map, but it is not necessary for example for the.File:commander execution. The {@link ExecuteLevel#levelForSubroutine(org.vishia.cmd.JZtxtcmdScript.Subroutine)} now centralizes getting a new level (gardening, before more a one time the adquate algorithm).
• 2016-12-27 Hartmut new: {@link #abortCmdExecution()} necessary if an execution hangs.
• 2016-12-27 Hartmut new: class {@link JzTcMain} renamed from JZcmd and set package private. Because possible confusion with {@link org.vishia.jztxtcmd.JZtxtcmd}
• 2016-03-06 Hartmut new:
  • Create a codeBlock variable with {@link ExecuteLevel#exec_DefCodeblockVariable(Map, org.vishia.cmd.JZtxtcmdScript.Subroutine, boolean) on statement Subtext name = ...,
  • Create a codeBlock content in {@link ExecuteLevel#exec_DefList(org.vishia.cmd.JZtxtcmdScript.DefContainerVariable, Map)} on {@link Subroutine} as content
  • execute the codeBlock in {@link ExecuteLevel#exec_Call(org.vishia.cmd.JZtxtcmdScript.CallStatement, List, StringFormatter, int, int)} on found codeBlock variable as name
  • execute the codeBlock in {@link ExecuteLevel#exec_Datatext(org.vishia.cmd.JZtxtcmdScript.DataText, StringFormatter, int, int)} on found codeBlock variable (type 'X') with local given variables.
  • evaluating of the code block with
• 2016-02-20 Hartmut new: ExecuteLevel#exec_Datatext(...): On exception an replacement text can be written, Syntax is <&datapath:?replacement:format>
• 2016-02-20 Hartmut new: Check statementList on if, while, for because an empty list is admissible. The syntax is changed.
• 2016-02-20 Hartmut chg: The for variable is set to null on end of for-loop without break. Therewith it can be tested whether a for has broken on found element. The description is enhanced with that feature with example. It is admissible to write for(variable:container && !variable.check()); especially to search somewhat in a container.
• 2016-02-20 Hartmut gardening in check of break in while loops.
• 2016-02-20 Hartmut bugfix: ExecuteLevel.isBreak was set permanently and has broken the next for-loop. fix: The break statement forces return {@link #kBreak}. That is used in while loops already. Now used in for loop too. gardening.
• 2016-01-10 Hartmut new: {@link #execute_Scriptclass(String)}
• 2016-01-10 Hartmut chg: {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)} now returns the "return" Map, not the localVariables. This is a more consequent concept. To assemble some user Parameter use {@link #execute_Scriptclass(org.vishia.cmd.JZtxtcmdScript.JZcmdClass)}, whereby a class can define some variables.
• 2016-01-09 Hartmut {@link ExecuteLevel#exec_Call(org.vishia.cmd.JZtxtcmdScript.CallStatement, List, StringFormatter, int, int)} Execution of a <:subtext:&var> which contains a Subtext is prepared, but the maybe better variant is only <&var> and detection, it is a subtext.
• 2016-01-09 Hartmut 'e': {@link ExecuteLevel#exec_Datatext(org.vishia.cmd.JZtxtcmdScript.DataText, StringFormatter, int, int)} Execution of a Subtext variable which's statements are evaluated in the given environment.
• 2016-01-09 Hartmut 'L': {@link ExecuteLevel#exec_DefList(org.vishia.cmd.JZtxtcmdScript.DefContainerVariable, Map)}: Execution of a List, it is filled on creation of a list variable with content which is evaluated in the given environment.
• 2016-01-06 Hartmut functionality enhancing: {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)} now returns all variable of the subroutine level.
• 2016-01-06 Hartmut functionality enhancing: {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)} can work on the script level variables. That is proper for initializing routines or routines for parameter.
• 2015-12-24 Hartmut chg: <&datatext>: On a {@link CalculatorExpr.Value} it invokes {@link CalculatorExpr.Value#stringValue()} to convert in a String representation. The {@link CalculatorExpr.Value#toString()} is not proper for that. Commonly toString() is invoked on any Object.
• 2015-08-30 Hartmut chg: The functionality to remove indentation is moved to the JZcmdScript because it is done only one time on preparation of the script, not more as one in any loop of execution. It is changed in functionality: <:s> to skip over white spaces and the next line indentation.
• 2015-08-30 Hartmut bugfix: The {@link JzTcMain#currdir()} and {@link JzTcMain#calctime()} should be moved from the environment class because there should be able to access as jzcmd.currdir() in the script.
• 2015-08-30 Hartmut new: The simple syntax text = newFile; to change the <+>output<.+> has a less semantic effect. Therefore it is replaced by <+:create>newFile<.+> or <+:append>... with the possibility of append to an existing file.
• 2015-08-30 Hartmut bug: Closing System.out, <+out>text... does not work if a new text output will be used to replace the given one by <+:create>newFile<.+>. Fix: System.out is used for the text output via the argument out for {@link #execute(JZtxtcmdScript, boolean, boolean, Appendable, String)}. That is done if the {@link org.vishia.jztxtcmd.JZtxtcmd} script was called without an -text argument. The System.out should not closed. It is checked now.
• 2015-08-30 Hartmut new: flush an output in {@link ExecuteLevel#exec_TextAppendToVar(org.vishia.cmd.JZtxtcmdScript.TextOut, int)}.
• 2015-07-18 Hartmut chg: In {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)}: An exception should not be thrown forward, rather than an ScriptException with the file, line and column should be thrown because it is not an exception in deep Java algorithm mostly but it is usual an error in a script. That exception is a better hint to find out the problem.
• 2015-06-04 Hartmut bugfix and improve: in {@link ExecuteLevel#exec_Text(org.vishia.cmd.JZtxtcmdScript.JZcmditem, Appendable, int)}: The processing of insertion characters was not according to the description. It is fixed, enhanced and described. Now '+++' and '===' are possible as insertion text marking characters too.
• 2015-05-24 Hartmut chg: copy, move, del with options, uses {@link FileOpArg}
• 2015-05-23 Hartmut new: {@link JzTcMain#getstdin()}
• 2015-05-23 Hartmut chg: Divide the class JZcmdExecuter in a part which is available for execution: {@link JzTcMain}. While execution some methods from the main class should not in focus!
• 2015-05-17 Hartmut new: syntax "File : " is now able as start path of a DataPath. Therefore it's possible to write File: "myFile".exists() or adequate. A relative filename is related to the {@link JZtxtcmdExecuter.ExecuteLevel#currdir()}.
• 2015-05-17 Hartmut new: mkdir
• 2015-05-17 Hartmut new: text = path/to/output is able to set in the script yet too.
• 2015-05-10 Hartmut chg: {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)} uses the argumet out as textout for <+>text output<.+> now. It is adequate like {@link #execute(JZtxtcmdScript, boolean, boolean, Appendable, String)}
• 2015-04-25 Hartmut chg: scriptdir is the really script dir on included scripts.
• 2014-12-14 Hartmut new: {@link ExecuteLevel#jzClass} stores the current class statement. Not call of own class methods without the class name is possible. TODO instances
• 2014-12-12 Hartmut new: If a subroutine's argument has the type 'F': {@link JZtxtcmdFilepath}, then the argument is converted into this type if necessary. TODO: do so for all non-Obj argument types. It is probably to work with a simple String as argument if a Filepath is expected. Therefore new {@link ExecuteLevel#convert2FilePath(Object)}.
• 2014-12-06 Hartmut new: don't need a main routine, writes only a warning on System.out.
• 2014-11-28 Hartmut chg: {@link ExecuteLevel#bForHasNext} instead calling argument for all execute...(...), it was forgotten in one level.
• 2014-11-21 Hartmut chg: Character ::: can be used as indentation characters
• 2014-11-16 Hartmut chg: enhancement of capability of set text column: <:@ nr> nr can be an expression. Not only a constant.
• 2014-10-20 Hartmut chg: break in a condition should break a loop, forwarding {@link #kBreak} from execution level in {@link ExecuteLevel#exec_IfStatement(org.vishia.cmd.JZtxtcmdScript.IfStatement, StringFormatter, int, int)}.
• 2014-10-20 Hartmut new: Map name = { String variable = "value"; Obj next; } now works. Changed 'M' instead 'X' in {@link JZtxtcmdScript.JZcmditem#add_dataStruct(org.vishia.cmd.JZtxtcmdScript.StatementList)}. {@link ExecuteLevel#evalObject(org.vishia.cmd.JZtxtcmdScript.JZcmditem, boolean)} has accepted such dataStruct already (used in argumentlist), now with 'M' instead 'X'. {@link ExecuteLevel#exec_DefMapVariable(org.vishia.cmd.JZtxtcmdScript.DefVariable, Map)} newly.
• 2014-10-20 Hartmut bufgix: some parameter in call of {@link ExecuteLevel#execute(org.vishia.cmd.JZtxtcmdScript.StatementList, StringFormatter, int, boolean, Map, int)} were set faulty. Last change bug from 2014-07-27.
• 2014-08-10 Hartmut new: <:>...<.> as statement writes into the current out Buffer. Before: calculates an textexpression which is never used then. In opposite:<+>...<.> writes to the main text output always, not to the current buffer.
• 2014-08-10 Hartmut new: !checkXmlFile = filename;
• 2014-07-27 Hartmut bugfix: {@link ExecuteLevel#exec_hasNext(org.vishia.cmd.JZtxtcmdScript.JZcmditem, StringFormatter, int, boolean, int)}
• 2014-07-27 Hartmut chg: save one level for recursive execution, less stack, better able to view by calling {@link ExecuteLevel#execute(org.vishia.cmd.JZtxtcmdScript.StatementList, StringFormatter, int, boolean, Map, int)}immediately.
• 2014-06-15 Hartmut chg: improved {@link ExecuteLevel#exec_zmake(org.vishia.cmd.JZtxtcmdScript.Zmake, StringFormatter, int, int)}: works with a Filepath for output.
• 2014-06-15 Hartmut chg: improved {@link ExecuteLevel#exec_Copy(org.vishia.cmd.JZtxtcmdScript.CallStatement)}: works with a Filepath. TODO for execMove!
• 2014-06-14 Hartmut chg: {@link ExecuteLevel} implements {@link FilePath.FilePathEnvAccess} now, therewith a {@link JZtxtcmdFileset#listFiles(List, JZtxtcmdFilepath, boolean, org.vishia.util.FilePath.FilePathEnvAccess)} does not need an accessPath, it may be empty respectively null.
• 2014-06-10 Hartmut chg: improved Exception handling of the script.
• 2014-06-01 Hartmut chg: {@link #genScriptVariables(JZtxtcmdScript, boolean, Map, CharSequence)} and {@link #initialize(JZtxtcmdScript, boolean, Map, String, boolean)} throws on any error.
• 2014-06-01 Hartmut chg: "File :" as conversion type for any objExpr, not in a dataPath.TODO: Do the same for Filepath, Fileset with accessPath
• 2014-06-01 Hartmut chg: uses {@value #kException} as return value of all called {@link ExecuteLevel#execute(org.vishia.cmd.JZtxtcmdScript.StatementList, StringFormatter, int, boolean, Map, int)} instead a new ForwardException. Reason: Stacktrace of Exception is not disturbed. The ForwardException has put its Stacktrace only. Too complex to read the causer.
• 2014-05-18 Hartmut chg: DefFilepath now uses a textValue and divides the path to its components at runtime, doesn't use the prepFilePath in ZBNF. Reason: More flexibility. The path can be assmebled on runtime.
• 2014-05-18 Hartmut new: try to implement javax.script interfaces, not ready yet
• 2014-05-18 Hartmut chg: {@link ExecuteLevel#exec_Subroutine(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, StringFormatter, int)} called from {@link org.vishia.jztxtcmd.JZtxtcmd#execSub(File, String, Map, ExecuteLevel)} for a sub routine in a new translated script.
• 2014-05-18 Hartmut chg: Handling of {@link ExecuteLevel#currdir}
• 2014-05-10 Hartmut new: File: supported as conversion with currdir. See {@link JZtxtcmdScript.JZcmdDataAccess#filepath}.
• 2014-05-10 Hartmut new: {@link ExecuteLevel#cmdExecuter} instantiated in a whole subroutine. It is more faster instead creating a new instance for any cmd invocation.
• 2014-04-24 Hartmut chg: {@link #execute(JZtxtcmdScript, boolean, boolean, Appendable, String)} returns nothing, No confusion between argument out and return value! If out is not given, then <:>text<.> is not possible. It causes an NullPointerException which may be thrown.
• 2014-04-24 Hartmut new: {@link #textline} the same for all threads, used synchronized.
• 2014-04-25 Hartmut new: {@link NextNr#start()} etc. more capability.
• 2014-03-08 Hartmut new: debug_dataAccessArgument() able to call from outside, to force breakpoint.
• 2014-03-08 Hartmut new: Filepath as type of a named argument regarded on call, see syntax
• 2014-03-07 Hartmut new: All capabilities from Zmake are joined here. Only one concept!
• 2014-03-01 Hartmut new: {@link ExecuteLevel#execForContainer(org.vishia.cmd.JZtxtcmdScript.ForStatement, Appendable, int)} now supports arrays as container too.
• 2014-03-01 Hartmut new: !argsCheck! functionality.
• 2014-02-22 Hartmut new: Bool and Num as variable types.
• 2014-02-16 Hartmut chg: Build of script variable currdir, scriptfile, scriptdir with them in {@link JZtxtcmdExecuter#genScriptVariables(JZtxtcmdScript, boolean, Map, CharSequence)}. {@link #execute(JZtxtcmdScript, boolean, boolean, Appendable, String)} and {@link #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File)} with sCurrDir.
• 2014-02-01 Hartmut new: onerror errorlevel for cmd now works as statement. {@link ExecuteLevel#cmdErrorlevel}.
• 2014-02-01 Hartmut chg: now {@link ExecuteLevel#execute(org.vishia.cmd.JZtxtcmdScript.StatementList, Appendable, int, boolean)} returns the exit designation (break, return)
• 2014-01-12 Hartmut chg: now uses a Stringjar {@link StringPartAppend} instead StringBuffer in Syntax and execution.
• 2014-01-09 Hartmut new: If the "text" variable or any other Appendable variable has a null-value, a StringBuilder is instantiated therefore and stored in this variable. It is possible therewith to create an text only if necessary. We don't need a StringBuilder instance if it is never used.
• 2014-01-06 Hartmut new: {@link ThreadData} has the error Variable, test thread
• 2013-12-26 Hartmut new: subroutine returns a value and assigns to any variable.
• 2013-12-26 Hartmut re-engineering: Now the Statement class is obsolete. Instead all statements have the base class {@link JZcmditem}. That class contains only elements which are necessary for all statements. Some special statements have its own class with some more elements, especially for the ZBNF parse result. Compare it with the syntax in {@link org.vishia.jztxtcmd.JZtxtcmdSyntax}.
• 2013-10-27 Hartmut chg: Definition of a String name [= value] is handled like assign. Stored with {@link DataAccess#storeValue(List, Map, Object, boolean)} with special designation in {@link DataAccess.DatapathElement#whatisit}
• 2013-10-20 Hartmut chg: The {@link #scriptVariables} and the {@link ExecuteLevel#localVariables} are of type {@link DataAccess.Variable} and not only Object. Advantage: The variable references can be changed in the instance of {@link DataAccess.Variable#val}, this changing is valid for all references to that variable. In this kind a script-variable can be changed in a subroutine. This may be necessary and should be supported. Nevertheless a concept of non-changeable script variables may be proper. It should realized in runtime.
• 2013-10-13 Hartmut chg: onerror: only the coherent statements in one block are checked for onerror. See description. onerror exit treaded.
• 2013-01-13 Hartmut chg: The method getContent is moved and adapted to {@link ZbatchGenScript.ZbatchExpressionSet#ascertainValue(Object, Map, boolean, boolean, boolean)}.
• 2013-01-12 Hartmut chg: improvements while documentation. Some syntax details. Especially handling of visibility of variables.
• 2013-01-02 Hartmut chg: The variables in each script part are processed in the order of statements of generation. In that kind a variable can be redefined maybe with its own value (cummulative etc.). A ZText_scriptVariable is valid from the first definition in order of generation statements. But a script-global variable referred with {@link #listScriptVariables} is defined only one time on start of text generation with the routine {@link ZbatchExecuter#genScriptVariables(ZbatchGenScript, Object, boolean)}.
• 2012-12-23 Hartmut chg: {@link #getContent(org.vishia.zbatch.ZbatchGenScript.ZbatchExpressionSet, Map, boolean)} now uses an {@link ZbatchGenScript.ZbatchExpressionSet} instead a List<{@link DataAccess.DatapathElement}>. Therewith const values are able to use without extra dataPath, only with a ScriptElement.
• 2012-12-23 Hartmut new: formatText in the {@link ZbatchGenScript.ZbatchExpressionSet#textArg} if a data path is given, use for formatting a numerical value.
• 2012-12-08 Hartmut new: <:subtext:name:formalargs> has formal arguments now. On call it will be checked and maybe default values will be gotten.
• 2012-12-08 Hartmut chg: {@link #parseGenScript(File, Appendable)}, {@link #genScriptVariables()}, {@link #genContent(ZbatchGenScript, Object, boolean, Appendable)} able to call extra especially for Zmake, currDir. It is possible to define any script variables in the generating script and use it then to control getting data from the input data.
• 2012-11-25 Hartmut chg: Now Variables are designated starting with $.
• 2012-11-04 Hartmut chg: adaption to DataAccess respectively distinguish between getting a container or an simple element.
• 2012-10-19 Hartmut chg: <:if...> works.
• 2012-10-10 Usage of {@link ZbatchGenScript}.
• 2012-10-03 created. Backgorund was the {@link org.vishia.zmake.Zmake} generator, but that is special for make problems. A generator which converts ZBNF-parsed data from a Java data context to output texts in several form, documentation, C-sources was need.

Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:

1. You can use this source without any restriction for any desired purpose.
2. You can redistribute copies of this source to everybody.
3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
4. But the LPGL is not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.

If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.

See Also:

Constant Field Values

acc

private final JZtxtcmdExecuter.JzTcMain acc

The usable instance of the JZtxtcmdExecuter for some managements. It is private because only internally to use.

accessError

protected java.lang.String accessError

Variable for any exception while accessing any java resources. It is the $error variable of the script.

kBreak

public static final short kBreak

Should break a loop, break statement.

See Also:

Constant Field Values

kReturn

public static final short kReturn

Should return from subroutine, return statement.

See Also:

Constant Field Values

kFalse

private static final short kFalse

Only internal designation.

See Also:

Constant Field Values

kException

public static final short kException

Has thrown an not catch exception. onerror statement not found.

See Also:

Constant Field Values

kSuccess

public static final short kSuccess

Should continue.

See Also:

Constant Field Values

retException

private static java.lang.CharSequence retException

This instance is used to mark a return object as exception return.

useScriptLevel

public static java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> useScriptLevel

This is an instance used as marker for execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File) for the argument args to use the script level in the sub routine variable instead.

Constructor Detail

JZtxtcmdExecuter

public JZtxtcmdExecuter(LogMessage log)

Creates a JZcmdExecuter with possible writing exceptions in the output text.

Parameters:

log - maybe null

JZtxtcmdExecuter

public JZtxtcmdExecuter()

Creates a JZcmdExecuter with possible writing exceptions in the output text.

Method Detail

initialize

public void initialize(JZtxtcmdScript script,
                       boolean accessPrivate,
                       java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> srcVariables,
                       java.lang.CharSequence sCurrdirArg)
                throws javax.script.ScriptException

Initializes the standard script variables and maybe executes the script level. All content before is removed. Especially script variables from a previous usage of the instance are removed. If you want to use a JZcmdExecuter more as one time with different scripts but with the same script variables, one should call this routine one time on start, and then #execute(JZtxtcmdScript, boolean, boolean, Appendable) with maybe several scripts, which should not contain script variables, or one should call #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable) with one of the subroutines in the given script.

Parameters:

genScriptArg - Generation script in java-prepared form. It contains the building prescript for the script variables.

accessPrivate - decision whether private and protected members from Java instances can be accessed.

srcVariables -

sCurrdir -

bExecuteScriptLevel -

Throws:

javax.script.ScriptException

initialize

public void initialize(JZtxtcmdScript script,
                       boolean accessPrivate,
                       java.util.List<DataAccess.Variable<java.lang.Object>> srcVariables,
                       java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> envar,
                       java.lang.CharSequence sCurrdirArg)
                throws javax.script.ScriptException

Initializes the standard script variables and maybe executes the script level. All content before is removed. Especially script variables from a previous usage of the instance are removed. If you want to use a JZcmdExecuter more as one time with different scripts but with the same script variables, one should call this routine one time on start, and then #execute(JZtxtcmdScript, boolean, boolean, Appendable) with maybe several scripts, which should not contain script variables, or one should call #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable) with one of the subroutines in the given script.

Parameters:

script - jzTc script in java-prepared form. It contains the building prescript for the script variables.

accessPrivate - decision whether private and protected members from Java instances can be accessed.

srcVariables -

envar - Variables from the Java environment used by reference. Preserve content on new initialized script. The new initialized script can use the before set content.

sCurrdir -

bExecuteScriptLevel -

Throws:

javax.script.ScriptException

initialize

public void initialize(JZtxtcmdScript script,
                       boolean accessPrivate,
                       java.util.List<DataAccess.Variable<java.lang.Object>> srcVariables,
                       java.lang.CharSequence sCurrdirArg)
                throws javax.script.ScriptException

Initializes the standard script variables and maybe executes the script level. All content before is removed. Especially script variables from a previous usage of the instance are removed. If you want to use a JZcmdExecuter more as one time with different scripts but with the same script variables, one should call this routine one time on start, and then #execute(JZtxtcmdScript, boolean, boolean, Appendable) with maybe several scripts, which should not contain script variables, or one should call #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable) with one of the subroutines in the given script.

Parameters:

genScriptArg - Generation script in java-prepared form. It contains the building prescript for the script variables.

accessPrivate - decision whether private and protected members from Java instances can be accessed.

srcVariables -

sCurrdir -

bExecuteScriptLevel -

Throws:

javax.script.ScriptException

initialize

public void initialize(JZtxtcmdScript script,
                       boolean accessPrivate,
                       java.lang.CharSequence sCurrdirArg)
                throws javax.script.ScriptException

Initializes the standard script variables and maybe executes the script level. All content before is removed. Especially script variables from a previous usage of the instance are removed. If you want to use a JZcmdExecuter more as one time with different scripts but with the same script variables, one should call this routine one time on start, and then #execute(JZtxtcmdScript, boolean, boolean, Appendable) with maybe several scripts, which should not contain script variables, or one should call #execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable) with one of the subroutines in the given script.

Parameters:

genScriptArg - Generation script in java-prepared form. It contains the building prescript for the script variables.

accessPrivate - decision whether private and protected members from Java instances can be accessed.

srcVariables -

sCurrdir -

bExecuteScriptLevel -

Throws:

javax.script.ScriptException

initialize_i

private void initialize_i(JZtxtcmdScript script,
                          boolean accessPrivate,
                          java.lang.CharSequence sCurrdirArg)
                   throws javax.script.ScriptException

Throws:

javax.script.ScriptException

getScript

public final JZtxtcmdScript getScript()

Returns the currently assigned script, maybe null on start.

executeScriptLevel

public void executeScriptLevel(JZtxtcmdScript script,
                               java.lang.CharSequence sCurrdir)
                        throws javax.script.ScriptException

Stores the script and executes the script level to generate the script level variables, especially the script variables were calculated yet. The initialize(JZtxtcmdScript, boolean, Map, CharSequence) may had invoked before, then the standard variables are created already. Any additional user variable can be stored also. If the JZtxtcmdExecuter.ExecuteLevel.localVariables are empty, then initialize(JZtxtcmdScript, boolean, Map, CharSequence) is called with the script instead.

This method should be used. For example the script level can be used to execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, Map, boolean, Appendable, File) for a sub routine which does not use script level variables, for example to set parameter. Note: The standard script variables are set with #initialize(JZtxtcmdScript, boolean, Map, String, boolean) already.

Parameters:

script - The given script

Throws:

javax.script.ScriptException

execute_Scriptclass

public JZtxtcmdExecuter.ExecuteLevel execute_Scriptclass(java.lang.String sClazz)
                                                  throws javax.script.ScriptException

Initializes respectively calculates a class newly.

Parameters:

sClazz - Name

Returns:

The executeLevel, able to use for subroutines or to get the variables of the class.

Throws:

javax.script.ScriptException

execute_Scriptclass

public JZtxtcmdExecuter.ExecuteLevel execute_Scriptclass(JZtxtcmdScript.JZcmdClass clazz)
                                                  throws javax.script.ScriptException

Executes the code of a class in a script without checking the whole script. If the executer was not initialized or initialized with another script, it is possible. The script class should only define simple variables then without dependencies.

Parameters:

clazz - the class in any Script

Returns:

The executeLevel, able to use for subroutines or to get the variables of the class.

Throws:

javax.script.ScriptException

newExecuteLevel

public JZtxtcmdExecuter.ExecuteLevel newExecuteLevel(JZtxtcmdThreadData threadData)

Creates a ExecuteLevel for the script which can be used to execute some sub routines (not only main) in the given thread on demand.

Parameters:

threadData - environment for the specific JzTxtCmd thread

Returns:

a new ExecuteLevel.

scriptVariables

public java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> scriptVariables()

Returns the association to all script variables. The script variables can be changed via this association. Note that change of script variables is a global action, which should not be done for special requests in any subroutine.

scriptLevel

public JZtxtcmdExecuter.ExecuteLevel scriptLevel()

Returns the script level instance. This instance is created with the constructor of this class (a composite). The JZtxtcmdExecuter.ExecuteLevel.localVariables of the script level are the script variables. They are filled with the given script on call of #initialize(JZtxtcmdScript, boolean, Map, String, boolean) or if execute(JZtxtcmdScript, boolean, boolean, Appendable, String) was called.

reset

public void reset()

Clears the instance. A newly use will create the script variables in any case from the given script.

abortCmdExecution

public boolean abortCmdExecution()

Aborts all CmdExecuter for operation system calls in all threads of this.

Returns:

true if at least one was aborted.

checkInitialize

private boolean checkInitialize(JZtxtcmdScript script,
                                boolean accessPrivate,
                                java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args,
                                java.lang.CharSequence sCurrdir)
                         throws javax.script.ScriptException

Throws:

javax.script.ScriptException

checkInitialize

private boolean checkInitialize(JZtxtcmdScript script,
                                boolean accessPrivate,
                                java.util.List<DataAccess.Variable<java.lang.Object>> args,
                                java.lang.CharSequence sCurrdir)
                         throws javax.script.ScriptException

Throws:

javax.script.ScriptException

checkInitialize

private boolean checkInitialize(JZtxtcmdScript script,
                                boolean accessPrivate,
                                java.lang.CharSequence sCurrdir)
                         throws javax.script.ScriptException

Throws:

javax.script.ScriptException

checkInitialize

private boolean checkInitialize(JZtxtcmdScript script,
                                boolean accessPrivate,
                                java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args,
                                java.io.File currdir)
                         throws javax.script.ScriptException

Throws:

javax.script.ScriptException

execute

public void execute(JZtxtcmdScript script,
                    boolean accessPrivate,
                    boolean bWaitForThreads,
                    java.lang.Appendable outFromCmdlineArg,
                    java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> data,
                    java.lang.String sCurrdir)
             throws javax.script.ScriptException

Executes the given script. See execute(JZtxtcmdScript, boolean, boolean, Appendable, String)

Parameters:

given - data as input.

Throws:

javax.script.ScriptException

execute

public void execute(JZtxtcmdScript script,
                    boolean accessPrivate,
                    boolean bWaitForThreads,
                    java.lang.Appendable outFromCmdlineArg,
                    java.util.List<DataAccess.Variable<java.lang.Object>> data,
                    java.lang.String sCurrdir)
             throws javax.script.ScriptException

Executes the given script. See execute(JZtxtcmdScript, boolean, boolean, Appendable, String)

Parameters:

data - data as input.

Throws:

javax.script.ScriptException

execute

public void execute(JZtxtcmdScript script,
                    boolean accessPrivate,
                    boolean bWaitForThreads,
                    java.lang.Appendable outFromCmdlineArg,
                    java.lang.String sCurrdir)
             throws javax.script.ScriptException

Executes the given script.

Parameters:

script - The script. If this instance was used with the same script before, the calculated script variables are not refreshed. That may be important if script variables are produced by running sub routines before. Use reset() if that is not desired. If the script is another and after reset(), previous script variables are removed firstly, and the script variables and script statements are firstly processed.

accessPrivate -

bWaitForThreads - should set to true if it is a command line invocation of Java, the exit should wait for all threads. May set to false if calling inside a long running application.

out - Any output for text generation using <+>text output<.>. It is used also for direct text output <:>text<.>.

sCurrdir - maybe null, the current directory. If given, it is set in any case for the script level.

Throws:

java.io.IOException - only if out.append throws it.

java.lang.IllegalAccessException - if a const scriptVariable are attempt to modify.

javax.script.ScriptException

execute_i

void execute_i(JZtxtcmdScript script,
               boolean accessPrivate,
               boolean bWaitForThreads,
               java.lang.String sCurrdir,
               boolean bscriptInitialized)
        throws javax.script.ScriptException

Inner routine to process the execution after initializing the script. This routine is called from all other.

Parameters:

script - The compiled script.

accessPrivate - true if private access to any given Java data inside a script.

bWaitForThreads - true then wait for finish all threads to exit

outFromCmdline - If System.out then it can be overridden by internal given text = path/to/file It is set by cmd line invocation with -o=file with opend file. If text = path/to/file is given by initializing the script, the given file will be closed and the script determined

sCurrdir -

bscriptInitialized -

Throws:

javax.script.ScriptException

execSub

public java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> execSub(JZtxtcmdScript script,
                                                                                     java.lang.String name,
                                                                                     java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args,
                                                                                     boolean accessPrivate,
                                                                                     java.lang.Appendable out,
                                                                                     java.io.File currdir)
                                                                              throws javax.script.ScriptException

Executes a subroutine. See execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, boolean, Appendable, File, CmdExecuter). This variation should be used only if the args are given for example and especially as Variables in a Map.

Parameters:

script - maybe null. If null the last given script will be used. If not null and not equal the given script this script will be newly used. initialize(JZtxtcmdScript, boolean, CharSequence) will be invoked then.

args - given as Map. It is converted to a list firstly.

Throws:

javax.script.ScriptException

execSub

public java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> execSub(JZtxtcmdScript script,
                                                                                     java.lang.String name,
                                                                                     java.util.List<DataAccess.Variable<java.lang.Object>> args,
                                                                                     boolean accessPrivate,
                                                                                     java.lang.Appendable out,
                                                                                     java.io.File currdir)
                                                                              throws javax.script.ScriptException

Executes a subroutine. It invokes execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, boolean, Appendable, File, CmdExecuter) if the subroutine is found per name in the given script.

Parameters:

script - The script. If this instance was used with the same script before, the calculated script variables are not refreshed. That may be important if script variables are produced by running sub routines before. Use reset() if that is not desired. If the script is another and after reset(), previous script variables are removed firstly, and the script variables and script statements are firstly processed.

name - of the sub routine in the given script. Maybe in form "theclass.thesub"-

args - given as Map. It is converted to a list firstly.

Throws:

javax.script.ScriptException

execSub

public java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> execSub(JZtxtcmdScript.Subroutine statement,
                                                                                     java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> args,
                                                                                     boolean accessPrivate,
                                                                                     java.lang.Appendable out,
                                                                                     java.io.File currdir)
                                                                              throws javax.script.ScriptException

Executes a subroutine. See execSub(org.vishia.cmd.JZtxtcmdScript.Subroutine, List, boolean, Appendable, File, CmdExecuter). This variation should be used only if the args are given for example and especially as Variables in a Map.

Parameters:

args - given as Map. It is converted to a list firstly.

Throws:

javax.script.ScriptException

execSub

public java.util.Map<java.lang.String,DataAccess.Variable<java.lang.Object>> execSub(JZtxtcmdScript.Subroutine statement,
                                                                                     java.util.List<DataAccess.Variable<java.lang.Object>> arglist,
                                                                                     boolean accessPrivate,
                                                                                     java.lang.Appendable out,
                                                                                     java.io.File currdir,
                                                                                     CmdExecuter cmdExecuter)
                                                                              throws javax.script.ScriptException

Executes the given sub routine invoked from any user application. The time measurements #startmilli and #startnano starts newly. This is the core routine.

Parameters:

statement - The subroutine in a script. The script of this subroutine is used as new script. If this instance was used with the same script before, the calculated script variables are not refreshed. That may be important if script variables are produced by running sub routines before. Use reset() if that is not desired. If the script is another and after reset(), previous script variables are removed firstly, and the script variables and script statements are firstly processed.

args - Some variables which are stored as argument values. Use useScriptLevel to advertise that no extra level should be used. Then all changed and created variables are part of the script level.

accessPrivate - flag for access private Java data.

out - Any output for text generation using <+>text output<.>. It is used also for direct text output <:>text<.>.

currdir - if not null, then this directory is used as JZtxtcmdExecuter.ExecuteLevel.changeCurrDir(CharSequence) for this subroutine.

Returns:

the variables which are stored in a definition of return variables in the sub routine, or null if no such variables were built.

Throws:

java.lang.Throwable

java.io.IOException

javax.script.ScriptException

setScriptVariable

@Deprecated
public void setScriptVariable(java.lang.String name,
                                           char type,
                                           java.lang.Object content,
                                           boolean bConst)
                                    throws java.lang.IllegalAccessException

Deprecated. It is deprecated now. On start of a script or a subroutine from a script a List or Map of additional script variables can be provided. This is a safe but other way. The script variable created with this routine may be removed if the script was newly initialized. Only if the following order of execution is given, it is proper:

   initialize(script, accessPrivate, currDir);  //will initialize
   setScriptVariable(name, type, content, const);
   execute(script, ....);
   

The JZcmdExecuter instance should be firstly initialize with the same script.

Sets a script variable for a given initialized script. The routine DataAccess.createOrReplaceVariable() will be called with the given scriptLevel().JZtxtcmdExecuter.ExecuteLevel.localVariables

Parameters:

name - Name of the script variable

type - One of DataAccess.Variable#type()

content -

bConst -

Throws:

java.lang.IllegalAccessException

getScriptVariable

public DataAccess.Variable<java.lang.Object> getScriptVariable(java.lang.String name)
                                                        throws java.lang.NoSuchFieldException

Throws:

java.lang.NoSuchFieldException

removeScriptVariable

public DataAccess.Variable<java.lang.Object> removeScriptVariable(java.lang.String name)

stop

void stop()