( Some help pages may not display correctly in html because those help pages may have sample codein them, part of which may be mis-interpreted as html tags.

All help pages, including this help page, are available in biterScripting with the help command. )

System Feature
edit
Purpose
Explains the matrix of automated editors available.
Aliases
None
Syntax
See syntax for individual editors.
Options
See help pages on individual editors.
Arguments
See below.
Stream Input
See help pages on individual editors.
Stream Output
See help pages on individual editors.
Stream Error
See help pages on individual editors.
Description
A powerful matrix of editors are available in biterScripting.
The editors are divided according to
- the TARGETs they seek or edit
- the editor OPERATION the perform.
We will explain each.
TARGET
----------
biterScripting editors can seek, find, count and perform various operations on
targets of various kinds. The folloing target types are available.
Character
A single character. Can be a printable, non-printable, or
special character. Editor commands that operate on characters
have the prefix of "ch".
Word
A collection of characters. Words are separated by word-separator characters,
which typically are space, tab, comma, etc. Editor commands that
operate on words have the prfix of "w". These commands use a special
system variable $wsep, which contains the list of word separator characters.
Any character in the value of $wsep is assumed to end one word and start
another. A default value is assigned to $wsep at startup. You can change this value
to make word editors behave according to your requirements.
Line
A collection of characters and words. Line are separated by line-separator characters,
which typically is newline ("\n"). Editor commands that
operate on lines have the prfix of "l". These commands use a special
system variable $lsep, which contains the list of line separator characters.
Any character in the value of $lsep is assumed to end one line and start
another. A default value is assigned to $lsep at startup. You can change this value
to make line editors behave according to your requirements.
String
A collection of characters, words and lines. Strings do not have any separators.
They are identified with their values such as "abc", "\n", etc. Editor commands that
operate on strings have the prfix of "s".
OPERATION
------------
biterScripting editors can perform the following operations on each of the targets.
Enumerate
Enumerate or count. The enumerator editors have the suffix of "en".
Find (Extract)
Delete or Remove (Extract)
Find and Delete operations are combined into EXTRACT operation.
See later on how to use the same Extractor editor to do both of these
operations. The extractor editors have the suffix of "ex".
Insert
The inserter editors have the suffix of "in".
Append
The appender editors have the suffix of "ap".
Alter
Alter, change, replace or modify. The alterer editors have the suffix of "al".
COMMAND NAMES
--------------
Using the prefixes and suffixes described above, we will now draw a table (matrix) of
available editor commands.
OPERATION TARGET
--------------- ------------------------------------------------------------------------
Character Word Line String
(ch) (w) (l) (s)
--------------- --------------- --------------- ---------------
Enumerate (en) chen wen len sen
Extract (ex) chex wex lex stex
Insert (in) chin win lin sin
Append (ap) chap wap lap sap
Alter (al) chal wal lal sal
Arguments
The following are commonly used arguments.
<input_string>
This is the input on which commands will operate. Note that this input
is NOT passed through stream input (all editor commands ignore stream input -
this is done for a specific reason, which will become apparent a little later).
Rather, <input_string> is passed throuh an argument on the command line.
<input_string> can be a constant, a variable, an expression, a function call,
an inline command (do you see the benefit of passing <input_string> through arguments
instead of stream input now ?), or any combination of these, together forming
a valid expression (resulting in str value).
<input_string> can be vary large, and biterScripting str variables are able to handle
any size of data. For example you can read an entire file, or all pages on your
web site into one str variable, and pass that variable as <input_string> argument to
any of the editor commands.
<search_string>
This is also called search target. This is used by string editors. It is
enclsoed within carets (^) (also known as cut-here symbols).
For example, "^Copyright^" will indicate that the command is to look for the
target "Copyright". <search_string> can be a constant, a variable, an expression,
a function call, an inline command or any combination of these, together forming
a valid expression (resulting in str value).
To achieve more power from string editors, <search_string> can be a Regular Expression.
If the -r option is specified in string editor commands, <search_string> will be
treated as a Regular Expression. See the help page on RE (Regular Expression) for
the syntax of Regular Expressions.
<n> The instance number. Instance numbers are counted from 1. <n> can be any number from
1 onwards. It can also be "l" (Lower case Ell - L), indicating last instance. For example,
"^Copyright^2" will mean second (2nd) instance of string target "Copyright". <n> can
be a constant, a variable, an expression, a function call, an inline command or any
combination of these, together forming a valid expression (resulting in str value).
<insert_string>, <append_string> or <alter_string>
One of these arguments is used by the inserter, appender and alterer editors.
These represent the string to insert before, append after, or replace in place of,
the <serach_target>. These also can be a constant, a variable, an expression,
a function call, an inline command or any combination of these, together forming a
valid expression (resulting in str value).
<start_bounder>
<end_bounder>
These bounder further narrow down the target of operation. They can be either
absent, or open bracket ([), or close bracket (]). Open bracket indicates
"starting at". Close bracket indicates "ending at". For example,
"^Copyright^3]" would indicate that the operation target is from start of
the <input_string> upto (and including) the third (3rd) instance of string
"Copyright". Similarly, "^Copyright^3[" would indicate that the operation target
starts after (but not including) third (3rd) instance of string "Copyright" and goes
on till the end of <input_string>. See the help page on an individual editor command,
which will show all combination of these bounders and explain how that command interprets
those combinations.
All of the <input_string> <search_string>, <n>, <insert_string>, <append_string>, <alter_string>,
<start_bounder> and <end_bounder> can be passed using a constant, a variable, an expression, a function call,
an inline command or any combination of these, together forming a valid expression (resulting in str value).
THIS MEANS THAT THESE ARGUMENTS ARE EVALUATED WHEN THE COMMAND IS ACTUALLY EXECUTED (and NOT when the
command is parsed), WHICH PROVIDES THE MAXIMUM FLEXIBILITY AND THE HIGHEST BENEFIT OF EDITOR COMMANDS.
This is the primary reason why all of these are supplied through arguments and NOT through stream input.
Special Characters
Many characters have special significance in editor commands. As we saw above, the caret (^)
(also called the cut-here symbol) indicates the start and end of a <search_string>, The
open ([) and close (]) brackets indicate the bounders. Similarly, Regular Expressions
use special characters to indicate special significance. If your <search_string> contains
these symbols, you do not wish them to be treated with special significance, escape them
with a backslash, such as, \^, \[, \], etc.
Restrictions
Valid Examples
See help pages for individual editor commands.
Invalid Examples
See help pages for individual editor commands.
See Also
escapeREchenwenlensenchexwexlexstexchinwinlinsinchapwaplapsapchalwallalsal