Revision [1398]

Last edited on 2010-05-13 09:08:17 by DavidLee
Additions:
- imported modules and packages (See [[Modules]])
- Shell variables (Environment variables and internal shell variables) (See [[BuiltinVariables]])
Deletions:
- imported modules and packages
- Shell variables (Environment variables and internal shell variables) [[BuiltinVariables]]


Revision [1397]

Edited on 2010-05-13 09:07:44 by DavidLee
Additions:
- Declared functions (See [[SyntaxFunction]] )
Deletions:
- Declared functions (See [[Functions]] )


Revision [1396]

Edited on 2010-05-13 09:07:26 by DavidLee
Additions:
- Namespaces, including the default namespace (See [[Namespaces]])
- Declared functions (See [[Functions]] )
Deletions:
- Namespaces, including the default namespace [[Namespaces]]
- Declared functions


Revision [1395]

Edited on 2010-05-13 09:07:07 by DavidLee
Additions:
- Namespaces, including the default namespace [[Namespaces]]
Deletions:
- Namespaces, including the default namespace


Revision [1327]

Edited on 2010-04-17 17:22:07 by DavidLee
Additions:
- Shell variables (Environment variables and internal shell variables) [[BuiltinVariables]]
Deletions:
- Shell variables (Environment variables and internal shell variables)


Revision [1194]

Edited on 2010-02-11 06:27:54 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy Philosophy]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1191]

Edited on 2010-02-11 04:46:58 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells (see [[PhilosophyXXX XXX]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1190]

Edited on 2010-02-11 04:43:34 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells (see [[PhilosophyXXX XXX]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy XXX]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1189]

Edited on 2010-02-11 04:42:13 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy XXX]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1188]

Edited on 2010-02-11 04:40:50 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy]]) . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells ; see [[Philosophy]] . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1187]

Edited on 2010-02-11 04:39:24 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells ; see [[Philosophy]] . If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells ; see [[Philosophy Philosophy]]. If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1186]

Edited on 2010-02-11 04:38:02 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells ; see [[Philosophy Philosophy]]. If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy Philosophy]]). If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1185]

Edited on 2010-02-10 11:37:19 by DavidLee
Deletions:
Test


Revision [1184]

Edited on 2010-02-10 11:34:09 by DavidLee
Additions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy Philosophy]]). If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.
Deletions:
xmlsh is derived from a similar syntax as the unix shells (see [[Philosophy]]). If you are familiar with any of these shell languages (sh,bash,ksh,zsh) you should be right at home. An attempt was made to stay very close to the sh syntax where reasonable, but not all subtlies or features of the unix shells are implemented. In order to accomidate native XML types and pipelines some deviations and extensions were necessary. Lastly, as an implementation issue, xmlsh is implemented in java using the [[https://javacc.dev.java.net javacc]] compiler for parsing. This made support for some of the syntax and features of the C based shells difficult or impossible. Future work may try to tighten up these issues.


Revision [1183]

Edited on 2010-02-10 11:33:16 by DavidLee
Additions:
Test


Revision [1182]

Edited on 2010-02-10 11:32:36 by DavidLee
Deletions:
==


Revision [845]

Edited on 2009-11-07 12:32:43 by DavidLee
Additions:
==


Revision [844]

Edited on 2009-11-07 12:04:12 by DavidLee

No Differences

Revision [810]

Edited on 2009-09-30 06:11:56 by DavidLee
Additions:
- Exceptions raised can be handled with a [[ExceptionHandling try/catch block]].


Revision [677]

Edited on 2009-08-25 07:16:50 by DavidLee

No Differences

Revision [637]

Edited on 2009-07-09 07:39:25 by DavidLee
Additions:
For details on xmlsh invocation and parameters see [[CommandXmlsh xmlsh command]]


Revision [517]

Edited on 2009-05-13 13:24:07 by DavidLee
Additions:
- imported modules and packages
- Shell Options (-v, -x ...)
Deletions:
- imported modules


Revision [404]

Edited on 2009-01-13 17:31:45 by DavidLee
Additions:
- Standard ports ( input/output/error )
The shell itself maintains additional environment which is passed to all subshells, but not to external (sub process) commands.
- Namespaces, including the default namespace
- Declared functions
- imported modules
- Shell variables (Environment variables and internal shell variables)
- Positional parameters ($1 ... $n)
Deletions:
- Standard input/output/error


Revision [242]

Edited on 2008-07-04 11:21:44 by DavidLee
Additions:
- Variable assignment. Prefix variable assignment is performed. [[Variables]] and [[CoreSyntax]].
Deletions:
- Variable assignment. Prefix variable assignment is performed. [[CommandVariableAssign]] and [[CoreSyntax]].


Revision [76]

Edited on 2008-04-20 12:57:04 by DavidLee
Additions:
- Parse statement. Statements are parsed using the [[CoreSyntax Core Syntax]].
- Expand variables. Variable expansion is performed. See [[Variables]] and [[CoreSyntax]].
- Variable assignment. Prefix variable assignment is performed. [[CommandVariableAssign]] and [[CoreSyntax]].
- IO Redirection. IO redirection (input,output, here documents) [[CommandRedirect]] and [[CoreSyntax]].
Deletions:
- Parse command. Commands are parsed using the [[CoreSyntax Core Syntax]].
- Expand variables. Variable expansion is performed. See [[Variables]].
- Variable assignment. Prefix variable assignment is performed. [[CommandVariableAssign]]
- IO Redirection. IO redirection (input,output, here documents) [[CommandRedirect]]


Revision [67]

Edited on 2008-04-20 09:17:44 by DavidLee
Additions:
After the command is executed, then the process repeats.
Deletions:
-


Revision [66]

Edited on 2008-04-20 09:16:54 by DavidLee
Additions:
- Expand variables. Variable expansion is performed. See [[Variables]].
- Variable assignment. Prefix variable assignment is performed. [[CommandVariableAssign]]
- IO Redirection. IO redirection (input,output, here documents) [[CommandRedirect]]
- Command execution. Commands are executed. [[CommandExecution]]
-
Deletions:
- Expand variables. Variable expansion is performed
- Variable assignment. Prefix variable assignment is performed
- IO Redirection. IO redirection (input,output, here documents)
- Command execution. Commands are executed.


Revision [65]

Edited on 2008-04-20 09:15:54 by DavidLee
Additions:
=====Running Commands / Basic Syntax =====
On startup, xmlsh reads the standard input (interactive mode) or the script file (batch mode), parses one command at a time and executes it. The following steps are performed
- Parse command. Commands are parsed using the [[CoreSyntax Core Syntax]].
- Expand variables. Variable expansion is performed
- Variable assignment. Prefix variable assignment is performed
- IO Redirection. IO redirection (input,output, here documents)
- Command execution. Commands are executed.


Revision [64]

Edited on 2008-04-20 09:10:04 by DavidLee
Additions:
You can run an xmlsh script by passing it as the first argument, followed by any script arguments
%%(shell)
xmlsh myscript.xsh arg1 arg2
%%
=====Environment=====
On invocation, xmlsh inherits the process environment of the caller. In particular this includes
- Current Directory
- Environment variables
- Standard input/output/error


Revision [63]

Edited on 2008-04-20 09:06:11 by DavidLee
Additions:
=====Invocation=====
xmlsh can run in 2 modes, interactive and batch. In interactive mode, a prompt ("$ ") is displayed and in batch mode there is no prompt. Otherwise they are identical. Running xmlsh with no arguments starts an interactive shell. Running with an argument runs in batch mode and invokes the given script.


Revision [62]

The oldest known version of this page was created on 2008-04-20 08:52:25 by DavidLee
Valid XHTML :: Valid CSS: :: Powered by WikkaWiki