/*description:
{
	Here is the complete grammar of the CodeWorker's scripting language.

	It is expressed in the extended-BNF dialect of CodeWorker, so has the
	advantage of running under \CodeWorker\ for scanning scripts, and has the
	original feature to be auto-descriptive.
}
*/

/* "CodeWorker":	a scripting language for parsing and generating text.

Copyright (C) 1996-1997, 1999-2003 Cédric Lemaire

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

To contact the author: codeworker@free.fr
*/

//##markup##"header"
//##begin##"header"
 /*********************************************************************
  *                      Grammar of CodeWorker
  *                           version 3.3
  *********************************************************************
  *
  * The grammar conforms to the extended-BNF notation of CodeWorker
  *
  *********************************************************************/
//##end##"header"

// Defines how to ignore insignificant characters between tokens.
#ignore	::= [' ' | '\t' | '\r' | '\n' | "/*" ignoreEmbeddedComment | "//"->'\n']*;

// The first production rule is the head of the grammar.
// The context variable pointed to by 'this' holds information about the
// type of the script to scan:
//   - "procedural": the backbone of the scripting language,
//   - "extended-BNF": includes also translation scripts,
//   - "template-based": the server-page notation for generation patterns,
// If the type is unknown, an empty string must be passed to the context
// variable.
translation_unit	::= script<this>;

// The type of the script is unknown: the production rule tries the 3
// types.
// This rule is the less declarative. It specifies the current script's type
// for scanning and catches syntax errors for looking at alternatives.
// Note the possible use of a C++-template syntax for non-terminal symbols.
script<"">	::=
		#try
			// '=>' is an escape mode to execute a procedural instruction
			// or block.
			=> set this = "procedural";
			script<"procedural">
		// We don't want to stop on error if the script wasn't recognized
		// as a common one.
		#catch(sError1)
	|
		#try
			=> set this = "extended-BNF";
			script<"extended-BNF">
		#catch(sError2)
	|
		#try
			=> set this = "template-based";
			script<"template-based">
		#catch(sError3)
	|
		// If none of the 3 types, the error for each of them is raised.
		=> set this = "";
		=> error("Not recognized as a 'CodeWorker' script:\n" +
				 "  - procedural script:\n" + sError1 +
				 "  - extended-BNF script:\n" + sError2 +
				 "  - template-based script:\n" + sError3);
	;

// The non terminal 'script<"procedural">' scans a common script, such as a
// leader script: not BNF and not template-based.
// An error is raised if a syntax error is encountered (use of '#continue').
script<"procedural">	::=
		#ignore // ignore blanks and C++ comments between symbols
		#continue // the rest of the sequence must be valid (or the scanner raises a syntax error)
		[instruction]*
		#empty // end of file expected; because of '#continue', a syntax error is raised if not reached
		;

// The well-named non terminal script<"extended-BNF"> scans an extended-BNF script.
// It expects a set of:
//   - BNF directives (case sensitive or not, ...),
//   - functions declaration/definition,
//   - production rules.
// An error is raised if a syntax error is encountered (use of '#continue').
script<"extended-BNF">	::=
		#ignore
		#continue
		[BNF_instruction]+
		#empty;

BNF_instruction	::=
			BNF_general_directive
		|
			FUNCTION_KEYWORD:sKeyword
			#continue
			instruction<sKeyword>
		|
			production_rule
		;

// The non terminal script<"template-based"> scans a template-based script.
// Procedural instructions or expressions are embedded between @ symbols
// or between <% and %>.
// An error is raised if a syntax error is encountered (use of '#continue').
script<"template-based">	::=
		#continue
		[
			STARTING_RAW_TEXT
			#continue
			#ignore
			[
					!preprocessor expression
					STARTING_TAG_OR_END
				|
					[instruction]*
					STARTING_TAG_OR_END
			]
		]+;


// Called by '#ignore'.
ignoreEmbeddedComment	::= ->["*/" | "/*" ignoreEmbeddedComment | "//"->'\n' ignoreEmbeddedComment];

//-------------------------------------------------------------
//                          The expressions
//-------------------------------------------------------------

// A default expression (non arithmetic) that manipulates and returns
// a string.
expression	::=	boolean_expression<false>;

// A condition for 'while', 'if', ... statements.
boolean_expression	::= ternary_expression<bNumeric> [boolean_operator #continue ternary_expression<bNumeric>]*;

// A concatenation of string expressions: the '+' is interpreted as
// concatenation.
concatenation_expression	::= comparison_member_expression<false>;

// The template non terminal 'expression<bNumeric>' handles a string
// expression when the template variable 'bNumeric' is worth false
// ('false' is a keyword of the language that means an empty string),
// and an arithmetic expression when it is instantiated with true
// (keyword that means "true").
// See the escape mode '$' in 'literal_expression<bNumeric>' to
// understand how to swap in arithmetic mode.
expression<bNumeric>	::=	boolean_expression<bNumeric>;

// Generic form of a boolean expression, both for arithmetic and string
// expressions.
boolean_expression<bNumeric>	::= ternary_expression<bNumeric> [boolean_operator #continue ternary_expression<bNumeric>]*;
boolean_operator	::= "&&" | "||" | "^^" | '&' | '|' | '^';

// Non terminal of the C-like ternary operator '?' ':'.
ternary_expression<bNumeric>	::= comparison_expression<bNumeric> ['?' #continue expression<bNumeric> ':' expression<bNumeric>]?;

// Generic form of a comparison (both arithmetic and string).
comparison_expression<bNumeric>	::=
		comparison_member_expression<bNumeric>
		[
				comparison_operator #continue comparison_member_expression<bNumeric>
			|
				INSET #continue constant_set
		]*
		;
comparison_operator	::=	"<=" | "<>" | ">=" | "!=" | "==" | '<' | '=' | '>';
constant_set	::=
		'{' #continue
		[CONSTANT_STRING | CONSTANT_CHAR]
		[
			','
			#continue
			[CONSTANT_STRING | CONSTANT_CHAR]
		]*
		'}'
		;

// The generic non-terminal 'comparison_member_expression' is quite
// particular. A comparison's member returns either a numeric (stored as
// a string) or a string. Here, 'comparison_member_expression<true>'
// handles an arithmetic expression. It means that it recognizes
// arithmetic operators ('+' means addition instead of concatenation).
comparison_member_expression<true>	::= shift_expression [sum_operator #continue shift_expression]*;
sum_operator	::= PLUS | '-';

// Binary shift operators, as in C/C++/Java ...
shift_expression	::= factor_expression [shift_operator #continue factor_expression]*;
shift_operator	::= "<<" | ">>";

// The multiplication.
factor_expression	::= literal_expression<true> [factor_operator #continue literal_expression<true>]*;
factor_operator	::= '*' | '/' | '%';


// The non-terminal 'comparison_member_expression<false>' recognizes
// string expressions only and '+' means concatenation. Arithmetic
// operators like '-' and '%' aren't available.
comparison_member_expression<false>	::= literal_expression<false> [CONCAT #continue literal_expression<false>]*;


// The generic non terminal of a literal:
//   - string between double quotes,
//   - expression between parenthesis,
//   - arithmetic expression between '$' (cannot be reentrant),
//   - bitwise negation,
//   - constant char (interpreted as a string in CodeWorker),
//   - boolean negation,
//   - number (interpreted as a string in CodeWorker),
//   - predefined constants 'true' (= "true") and 'false' (= ""),
//   - function call,
//   - variable expression, perhaps followed by a method call.
literal_expression<bNumeric>	::=
		CONSTANT_STRING
	|
		'(' #continue expression<bNumeric> ')'
	|
		'$' #continue #check(!bNumeric) expression<true> '$'
	|
		'~' #continue #check(bNumeric) literal_expression<true>
	|
		CONSTANT_CHAR
	|
		'!' #continue literal_expression<bNumeric>
	|
		#readNumeric // scans a number
	|
		// '#readIdentifier' is a predefined non terminal that scans
		// a C-like identifier.
		// - A:{"s1", ..., "sN"} means that the token must be worth
		//   a constant string of the set,
		// - A:var means that the token value is assigned to the
		//   variable 'var'. If the variable doesn't exist yet, it is
		//   declared in the local scope,
		// - A:{"s1", ..., "sN"}:var means that the token must belong
		//   to the set and that the value is assigned to the variable.
		#readIdentifier:{"true", "false"}
	|
		function_call
	|
		variable_expression ['.' #continue method_call]?
		;

// Non terminal of a variable.
variable_expression	::=
		#readIdentifier:sIdentifier variable_expression<sIdentifier>
	|
		'#' #continue "evaluateVariable" '(' expression ')'
		;

// Non terminal of a script file to execute (parse/generation/interpretation).
// Usually, it represents the file name of the script, but it may be the
// full description of the script to execute, between brackets.
script_file_expression<"free">	::=
		'{' #continue [instruction]* '}'
	|
		expression
		;

script_file_expression<"pattern">	::=
		'{' #continue
		=> local bContinue = true;
		[
			#check(bContinue)
			STARTING_RAW_TEXT
			#continue
			#ignore
			[
					!preprocessor expression
					[STARTING_TAG | '}' => set bContinue = false;]
				|
					[instruction]*
					[STARTING_TAG | '}' => set bContinue = false;]
			]
		]+
	|
		expression
		;

script_file_expression<"translate">	::= script_file_expression<"BNF">;
script_file_expression<"BNF">	::=
		'{' #continue [BNF_instruction]* '}'
	|
		expression
		;

// The right-side of a variable. '#!ignore' in the non-terminal declaration
// part of the production rule means that neither blanks or C++-like comments
// must be scanned before calling the non-terminal. Because of an ambiguity
// on '#' and '[' with the extended-BNF syntax, whitespaces aren't allowed
// before them in a variable expression, while a BNF directive (#...) or a
// repeatable sequence ([...]...) must have at least a blank or comment before
// them.
//
//   - points to a subnode with '.' as in C/C++/Java... for accessing
//     the attributes of a structure,
//   - points to an item of the current node's array,
//   - accesses to the first/last item of the array or to the parent's node,
//   - accesses to the nth item of the array (starting at 0),
variable_expression<sIdentifier> : #!ignore	::=
		[
				#ignore '.' #readIdentifier
				![['<' concatenation_expression '>']? '(']
			|
				'[' #ignore #continue expression ']'
			|
				'#'
				[
						#readIdentifier:{"front", "back", "parent"}
					|
						'[' #ignore #continue expression ']'
				]
		]*
		;

// A method call consists of calling a function where (generally) the first
// parameter is provided as an expression on the left-side:
//    sText.findString('/');
// calls the function
//    findString(sText, '/');
// For some predefined functions, the expression doesn't represent
// the first parameter:
//    list.findElement("BNF");
// calls the function
//    findElement("BNF", list);
// where 'list' occupied the second position.
method_call	::=
		#readIdentifier:sMethodName
		[
				predefined_method_call<sMethodName>
			|
				user_method_call
		];
user_method_call	::=	['<' concatenation_expression '>']? '(' #continue [expression [',' #continue expression]*]? ')';

// Call of a predefined/user-defined function.
function_call	::=
		#readIdentifier:sFunctionName
		[
				predefined_function_call<sFunctionName>
			|
				module_function_call
			|
				user_function_call
		];
module_function_call	::= "::" #readIdentifier:sFunctionName '(' #continue [expression [',' #continue expression]*]? ')';
user_function_call	::=	['<' concatenation_expression '>']? '(' #continue [expression [',' #continue expression]*]? ')';


//-------------------------------------------------------------
//                          The instructions
//-------------------------------------------------------------

// The non-terminal of an instruction:
//   - a block of instructions,
//   - a simple statement,
//   - a call to a predefined function,
//   - a call to a predefined procedure,
//   - a call to a user function,
//   - a preprocessor directive,
//   - a server page's raw text (between @ or %> <%).
instruction	::=
		'{' #continue [instruction]* '}'
	|
		#readIdentifier:sKeyword
		[
				instruction<sKeyword>
			|
				predefined_function_call<sKeyword> ';'
			|
				predefined_procedure_call<sKeyword> ';'
			|
				module_function_call ';'
			|
				user_function_call ';'
		]
	|
		preprocessor
	|
		variable_expression '.' #continue method_call ';'
	|
		#check(this != "procedural")
		STARTING_TAG
		#!ignore
		#continue STARTING_ENDING_RAW_TEXT
		#ignore
		[!preprocessor expression ![!'@' !"%>" !#empty]]?
		;

// Looks for a preprocessing directive
preprocessor	::= '#' #readIdentifier:sKeyword preprocessor<sKeyword>;

// The non-terminal 'preprocessor<"include">' includes a script file.
preprocessor<"include">	::= #continue CONSTANT_STRING;

// The 'use' directive loads a dynamic library, whose name is the name
// of the module ending with "cw".
// Then, it adds new commands in CodeWorker.
// Example: #use "PGSQL"   -> load of "PGSQLcw.dll"
preprocessor<"use">	::= #continue #readIdentifier;

// The generic form 'instruction<sIdentifier>' is called when the keyword
// wasn't recognized as a statement. It might be an assignment.
instruction<sIdentifier>	::=	variable_expression<sIdentifier> ['=' | "+="] #continue expression ';';

//------------------ Some classical statements ------------------
instruction<"if">	::= #continue boolean_expression instruction [ELSE #continue instruction]?;
instruction<"do">	::= #continue instruction WHILE boolean_expression ';';
instruction<"while">	::= #continue boolean_expression instruction;

// The 'switch' statement works on strings. The 'start' label takes the
// flow of control if the controlled sequence starts with the corresponding
// constant expression.
instruction<"switch">	::= #continue '(' expression ')' switch_body;
switch_body	::=
		'{'
		#continue
		[
			[
				DEFAULT
			|
				[CASE | START] #continue CONSTANT_STRING
			]
			':'
			[instruction]*
		]*
		'}';

//------------------ Some assignment operators ------------------

// The right member of an assignment operator may describe a constant tree
// to assign to the variable (the left member).
assignment_expression	::=
		'{'
		#continue
		[
			assignment_expression
			[',' #continue assignment_expression]*
		]?
		'}'
	|
		expression
	;

// Declare a local variable on the stack as a tree. The scope manages its
// timelife. A value may be assigned to the variable.
instruction<"local">	::= #continue variable_expression ['=' #continue assignment_expression]? ';';

// Declare a global variable visible everywhere. A value may be assigned
// to the variable.
instruction<"global">	::= #continue variable_expression ['=' #continue assignment_expression]? ';';

// Declare a local variable and assign a reference to another node.
//     localref A = B;
//   is the equivalent of:
//     local A;
//     ref A = B;
instruction<"localref">	::= #continue variable_expression '=' variable_expression ';';

// Copy a node to another integrally, after cleaning the destination node.
instruction<"setall">	::= #continue variable_expression '=' variable_expression ';';

// Merge a node to another integrally.
instruction<"merge">	::= #continue variable_expression '=' variable_expression ';';

// Classical assignment of a value to a node. If the node doesn't exist
// yet, a warning is displayed but the node is created and the value
// assigned. It is better to use 'insert' to create a node.
instruction<"set">	::= #continue variable_expression ["+=" | '='] assignment_expression ';';

// Assignment of a value to a node. If the node doesn't exist yet, it is created.
// If nothing has to be assigned, the node is just created.
instruction<"insert">	::= #continue variable_expression [["+=" | '='] #continue assignment_expression]? ';';

// Assigns a reference to another node.
instruction<"ref">	::= #continue variable_expression '=' variable_expression ';';

// Adds a new item in an array, whose key is worth the position of the item
// in the array (the last) starting at 0.
instruction<"pushItem">	::= #continue variable_expression ['=' #continue expression]? ';';

// The statement 'foreach' iterates items of an array.
// It may sort items before, taking the case into account or not.
// It may propagate the iteration on branches, which have the same
// name as the array. Example: 'foreach i in cascading a.b.c ...'
// will propagate the 'foreach' on 'i.c' and so on recursively.
instruction<"foreach">	::= #continue #readIdentifier
		IN
		[
				[REVERSE]?
				SORTED
				[NO_CASE]?
			|
				CASCADING
				[#readIdentifier:{"first", "last"}]?
		]*
		variable_expression
		instruction
		;

// The 'continue' statement, same meaning as in C/C++/Java.
instruction<"continue">	::= #continue ';';
// The 'break' statement, same meaning as in C/C++/Java.
instruction<"break">	::= #continue ';';

// The statement 'forfile' browses a directory and iterates all
// files matching a pattern. The seach is recursive on directories
// if 'cascading' is chosen.
instruction<"forfile">	::= #continue #readIdentifier
		IN
		[
				[REVERSE]?
				SORTED
				[NO_CASE]?
			|
				CASCADING
				[#readIdentifier:{"first", "last"}]?
		]*
		expression
		instruction
		;

// The statement 'select' crosscuts all tree nodes that match a
// pattern of branch, in the spirit of XPath (XSL).
instruction<"select">	::= #continue #readIdentifier
		IN
		[SORTED]?
		motif_expression
		instruction
		;

// the non-terminal 'motif_expression' defines a kind of XPath expression
// to apply on a subtree.
motif_expression	::=
		[
				'(' #continue motif_expression ')'
			|
				motif_and_expression
		]
		[
			["||" | '|']
			#continue
			motif_and_expression
		]*;
motif_and_expression	::=	motif_concat_expression [["&&" | '&'] #continue motif_concat_expression]*;
motif_concat_expression	::= motif_path_expression ['+' #continue motif_path_expression]*;
motif_path_expression	::=
		motif_step_expression
		[
				"..." #continue motif_ellipsis_expression
			|
				'.' #continue motif_step_expression
		]*;
motif_ellipsis_expression	::= motif_step_expression;
motif_step_expression	::=
		#continue
		['*' | #readIdentifier]
		['[' [expression]? ']']*
		;


//---------- Declaration / definition of user-defined functions ----------

// The definition of a user-defined function starts with the keyword
// 'function'. A function may have a kind of template form, instantiated
// with a key between '<' and '>'.
instruction<"function">	::= #continue #readIdentifier ['<' #continue CONSTANT_STRING '>']? '(' [function_parameter [',' #continue function_parameter]*]? ')' function_body;
classical_function_definition	::= #readIdentifier '(' #continue function_parameters ')' function_body;
instantiated_template_function_definition	::= #readIdentifier '<' #continue CONSTANT_STRING '>' #continue '(' function_parameters ')' function_body;
generic_template_function_definition	::= #readIdentifier '<' #continue #readIdentifier '>' #continue '(' function_parameters ')' [template_function_body | function_body];
function_parameters	::= [function_parameter [',' #continue function_parameter]*]?;
function_parameter	::=	#readIdentifier [':' #continue function_parameter_type]?;
function_parameter_type	::= #readIdentifier:{"value", "variable", "node", "reference", "index"};
function_body	::=	#continue '{' [instruction]* '}';
template_function_body	::=
		"{{" #continue
		[
			STARTING_RAW_TEXT
			#continue
			#ignore
			[
					!preprocessor expression
					[STARTING_TAG | '}' #break]
				|
					[instruction]*
					[STARTING_TAG | '}' #break]
			]
		]+
		'}'
		;

// Forward declaration of a function.
instruction<"declare">	::= #continue FUNCTION #readIdentifier ['<' #continue CONSTANT_STRING '>']? '(' [function_parameter [',' #continue function_parameter]*]? ')' ';';

// External function: binding with a C++ implementation of the function,
// defined by the user.
instruction<"external">	::= #continue FUNCTION #readIdentifier ['<' #continue CONSTANT_STRING '>']? '(' [function_parameter [',' #continue function_parameter]*]? ')' ';';

// The hook 'readonlyHook' is called when the tool tries to save a generated
// file but that the replaced file is locked for writing. The name of the file
// is passed by value. It must return a non-empty value if the file have been
// unlocked in the body (suceeded call to the source code control system).
instruction<"readonlyHook">	::= #continue '(' #readIdentifier ')' function_body;

instruction<"writefileHook">	::= #continue '(' #readIdentifier ',' #readIdentifier ',' #readIdentifier ')' function_body;

// The hook 'stepintoHook' is called when entering into a BNF non-terminal call,
// just before running the production rule.
// It passes first the signature of the BNF clause, and then the local scope.
instruction<"stepintoHook">	::= #continue '(' #readIdentifier ',' #readIdentifier ')' function_body;

// The hook 'stepoutHook' is called when finishing a BNF non-terminal call,
// just after running the production rule.
// It passes the signature of the BNF clause, then the local scope and then
// a boolean, is worth "true" if success.
instruction<"stepoutHook">	::= #continue '(' #readIdentifier ',' #readIdentifier ',' #readIdentifier ')' function_body;

// Returns the value of a user-defined function. It is never a node.
// If no expression returned, one consider returning the value of a hidden
// local variable having the name of the function.
instruction<"return">	::= #continue [expression]? ';';

// Classical 'try/catch' statement. The tool puts the error message into a
// variable.
instruction<"try">	::= #continue instruction "catch" '(' variable_expression ')' instruction;

// The statement 'finally' defines a block to execute each time the flow
// of control leaves the scope of the function, even in case of exception
// raising.
instruction<"finally">	::= #continue instruction;

// Deprecated way to call a function, ignoring the output result.
instruction<"nop">	::= #continue '(' function_call ')' ';';

// A 'jointpoint' statement to declare into a template-based script (Aspect-oriented construct)
instruction<"jointpoint">	::=
	#continue
	[#readIdentifier:"iterate"]?
	#readIdentifier
	['(' #continue variable_expression ')']?
	[';' | instruction]
	;

// A 'advice' statement to declare into a template-based script (Aspect-oriented construct)
instruction<"advice">	::=
	#continue
	ADVICE_TYPE
	['(' #continue #readIdentifier ')']?
	':' expression
	instruction
	;


//---------- Statement modifiers ----------

// Choose a file as the standard input (function 'inputLine()').
instruction<"file_as_standard_input">	::= #continue '(' expression ')' instruction;

// Choose a string as the standard input (function 'inputLine()').
instruction<"string_as_standard_input">	::= #continue '(' expression ')' instruction;

// Redirects all console outputs to a variable while running an instruction.
instruction<"quiet">	::= #continue '(' variable_expression ')' instruction;

// Measures the time consumed by an instruction. Use 'getLastDelay()' to
// take the value in milliseconds after running the instruction.
instruction<"delay">	::= #continue instruction;

// Runs an instruction under the integrated debug mode, running to the
// console.
instruction<"debug">	::= #continue instruction;

// Runs an instruction under the integrated quantify mode, measuring time
// consuming in functions and the number of times each line of script is
// visited.
instruction<"quantify">	::= #continue ['(' #continue expression ')']? instruction;

// The 'project' tree is the main tree of the application, a global tree.
// To change it locally, just for running an instruction, use 'new_project'.
instruction<"new_project">	::= #continue instruction;

// In a translation or BNF script, change of the current parsed file.
instruction<"parsed_file">	::= #continue '(' expression ')' instruction;

// In a translation or BNF script, change of the current input to a parsed string.
instruction<"parsed_string">	::= #continue '(' expression ')' instruction;

// In a translation or template-based script, change of the current
// generated file.
instruction<"generated_file">	::= #continue '(' expression ')' instruction;

// In a translation or template-based script, change of the current
// output to an appending mode in a given file.
instruction<"appended_file">	::= #continue '(' expression ')' instruction;

// In a translation or template-based script, change of the current
// output to a string instead of ta file.
instruction<"generated_string">	::= #continue '(' variable_expression ')' instruction;


//---------------------------------------------------------------------
//                        Some lexical tokens
//---------------------------------------------------------------------

PLUS	::= '+' #!ignore !'=';
CONCAT	::= '+' #!ignore !'=';

DEFAULT	::= #readIdentifier:"default";
CASE	::= #readIdentifier:"case";
START	::= #readIdentifier:"start";
CASCADING	::= #readIdentifier:"cascading";
ELSE	::= #readIdentifier:"else";
IN		::= #readIdentifier:"in";
INSET	::= #readIdentifier:"in";
NO_CASE	::= #readIdentifier:"no_case";
REVERSE	::= #readIdentifier:"reverse";
SORTED	::= #readIdentifier:"sorted";
WHILE	::= #readIdentifier:"while";

CONSTANT_STRING	::= #readCString;
CONSTANT_CHAR	::= '\'' #!ignore #continue ['\\']? #readChar '\'';

FUNCTION_KEYWORD	::= [FUNCTION | DECLARE | EXTERNAL | WRITEFILE_HOOK | READONLY_HOOK | STEPINTO_HOOK | STEPOUT_HOOK];
FUNCTION	::= #readIdentifier:"function";
DECLARE		::= #readIdentifier:"declare";
EXTERNAL	::= #readIdentifier:"external";
WRITEFILE_HOOK	::= #readIdentifier:"writefileHook";
READONLY_HOOK	::= #readIdentifier:"readonlyHook";
STEPINTO_HOOK	::= #readIdentifier:"stepintoHook";
STEPOUT_HOOK	::= #readIdentifier:"stepoutHook";

PRULE_SYMBOL	::= "::=";
NON_TERMINAL	::=	#readIdentifier;
ALTERNATION		::= '|';
TR_BEGIN		::= '<';
TR_END			::= '>';
PIPESUP			::= "|>";
ANDOR			::= "&|";

ADVICE_TYPE		::=	#readIdentifier:{"before", "before_iteration", "around", "around_iteration", "after", "after_iteration"}

STARTING_RAW_TEXT	::= ->['@' | "<%"];
STARTING_ENDING_RAW_TEXT	::= ->['@' | "<%" | #empty];
STARTING_TAG	::= ['@' | "%>"];
STARTING_TAG_OR_END	::= ['@' | "%>" | #empty];


//---------------------------------------------------------------------
//                                BNF script
//---------------------------------------------------------------------

// A BNF directive starts with the symbol '#' and may be related to the
// case or to the production rule for ignoring blanks between tokens...
BNF_general_directive	::=
		'#'
		#readIdentifier:sKeyword
		BNF_general_directive<sKeyword>
		;

// If not recognized as a BNF directive, it is a common preprocessor
// directive.
BNF_general_directive<T>	::= preprocessor<T>;

// If set, the case isn't taken into account.
BNF_general_directive<"noCase">	::= #check(true);

// If set, the grammar will run in trace mode
BNF_general_directive<"trace">	::= #check(true);

// Defines the production rule for ignoring comments and blanks between
// tokens.
BNF_general_directive<"ignore">	::=
		#continue
		['[' #continue #readCString ']']?
		PRULE_SYMBOL right_side_production_rule
		;

// Overload a non-terminal whose production rule has already been defined.
BNF_general_directive<"overload">	::=
		'#' #continue #readIdentifier:"ignore" BNF_general_directive<"ignore">
	|
		production_rule;

// Only under the translation mode: means that the input stream is copied
// to the output stream automatically while scanning (useful for program
// transformations).
BNF_general_directive<"implicitCopy">	::= ['(' #continue #readIdentifier ['<' #continue CONSTANT_STRING '>']? ')']?;

// Only under the translation mode, chosen by default: the script specifies
// between '@' symbols (or between '%>' '<%') the text to write in the output
// stream.
BNF_general_directive<"explicitCopy">	::= #check(true);

BNF_general_directive<"parameters">	::=
		#continue #readIdentifier '('
		[clause_parameter [',' #continue clause_parameter]*]?
		')' expression;

BNF_general_directive<"transformRules">	::=
		#continue
		expression // the filter
		'{' #continue [BNF_instruction]* '}' // the left member
		'{' #continue [BNF_instruction]* '}' // the production rule
		;

// Definition of a production rule that may be template, resolved/instantiated
// or not.
// A non-terminal admits parameters (passed by value, by reference, by node) and
// may return a value (see documentation).
production_rule	::=
		NON_TERMINAL
		#continue
		[
			TR_BEGIN
			#continue
			[
					#readIdentifier
				|
					CONSTANT_STRING
			]
			TR_END
		]?
		[
			'('
			#continue
			[
				clause_parameter
				[',' #continue clause_parameter]*

			]?
			')'
		]?
		[
			':'
			BNF_clause_return_value
		]?
		[BNF_clause_preprocessing]?
		PRULE_SYMBOL right_side_production_rule
		;

// Normally, what a non-terminal returns is the portion of text it has
// scanned. Nevertheless, it is possible to specify to return a different
// value.
// Note: "node" and "list" aren't validated yet.
BNF_clause_return_value	::= #readIdentifier:{"value", "node", "list"};

// Preprocessing just before executing the right side of the production
// rule.
BNF_clause_preprocessing	::=
		':' '#'
		#continue
		[
				'!'
				#continue
				#readIdentifier:"ignore"
			|
				#readIdentifier:"ignore"
				['(' #continue [#readCString | BNF_ignore_type] ')']?
		];

BNF_ignore_type	::= "C++/Doxygen" | "C++" | "JAVA" | "HTML" | "XML" | "blanks" | "LaTeX";

// A non-terminal may accept parameters. Here are the allowed ones.
clause_parameter	::=	#readIdentifier #continue ':' clause_parameter_type;
clause_parameter_type	::= #readIdentifier:{"node", "value", "variable", "reference"};

// Right-side of the production rule.
right_side_production_rule	::= BNF_sequence #continue [ALTERNATION #continue BNF_sequence]* ';';
BNF_sequence	::= [BNF_literal]+;

// A BNF literal is a terminal or non-terminal or a directive.
// 'BNF_literal<true>' means that the literal might be followed by a
// constant (or set of constants) the token must match, or a variable
// that will receive the scanned token.
BNF_literal	::=	BNF_literal<true>;
BNF_literal<bTokenCondition>	::=
	[
			CONSTANT_STRING
			[#check(bTokenCondition) BNF_variable_assignation]?
		|
			CONSTANT_CHAR
			[
					".." #continue CONSTANT_CHAR
					[#check(bTokenCondition) BNF_token_post_processing]?
				|
					[#check(bTokenCondition) BNF_variable_assignation]?
			]
		|
			[
					'~'
				|
					'^'
				|
					'!'
				|
					"->"
					[multiplicity]?
					[
						'('	#continue
						[BNF_variable_assignation]?
						['-' BNF_variable_assignation]?
						[BNF_sequence]?
						')'
					]?
			]
			#continue BNF_literal<false>
			[#check(bTokenCondition) BNF_token_post_processing]?
		|
			'[' #continue BNF_sequence [ALTERNATION #continue BNF_sequence]* ']'
			[multiplicity]?
			[#check(bTokenCondition) BNF_token_post_processing]?
		|
			'#'
			#continue
			[
					'!'
					#continue
					#readIdentifier:"ignore"
				|
					#readIdentifier:sDirective
					BNF_directive<sDirective>:bTokenConditionAllowed
					[
						#check(bTokenCondition && bTokenConditionAllowed)
						BNF_token_post_processing
					]?
			]
		|
			"=>" #continue instruction
		|
			BNF_clause_call
			[#check(bTokenCondition) BNF_token_post_processing]?
	]
	[
		[PIPESUP | ANDOR]
		#continue
		BNF_literal<bTokenCondition>
	]?
	;

BNF_variable_assignation	::= [':' | ":+"] #continue variable_expression;

multiplicity	::=
			'?' | '+' | '*'
		|
			"#repeat" #continue '(' expression [',' #continue expression]? ')'
		|
			#readInteger [".." #continue [#readInteger | '*']]?
		;

// '#continue' means that the rest of the sequence must be valid.
// If not, a syntax error is raised at the point where a literal
// of the sequence doesn't match the sentence.
BNF_directive<"continue"> : value	::= #check(true);

// '#noCase' means that the case is ignored for the rest of the sequence.
BNF_directive<"noCase"> : value	::= #check(true);

// '#nextStep' fixes the cursor jump in '->' and '~' operators.
BNF_directive<"nextStep"> : value	::= #check(true);

// '#ratchet' allows that the cursor in the input stream never
// comes back before.
BNF_directive<"ratchet"> : value	::= #check(true);

// '#super' works on non-terminals that overload a clause. It refers to
// the overloaded clause.
BNF_directive<"super"> : value	::=
		#continue "::" ['#' #continue "super" "::"]* BNF_clause_call
		=> set BNF_directive = true;
		;

// BNF directive to catch errors thrown from the sequence inlayed in
// '#try'/'#catch'.
BNF_directive<"try"> : value	::=
		#continue
		[!['#' #readIdentifier:"catch"] #continue BNF_literal]+
		BNF_catch;
BNF_catch	::= '#' "catch" '(' variable_expression ')';

// Directive to change the input file for the rest of the sequence.
BNF_directive<"parsedFile"> : value	::= #continue '(' expression ')' BNF_sequence;

// Directive to change the output file for the rest of the sequence for a
// translation script.
BNF_directive<"generatedFile"> : value	::= #continue '(' expression ')' BNF_sequence;

// Directive to change the output for the rest of the sequence for a
// translation script. The output is written into a variable.
BNF_directive<"generatedString"> : value	::= #continue '(' variable_expression ')' BNF_sequence;

// Directive to change the output file for the rest of the sequence for a
// translation script. The output is appended.
BNF_directive<"appendedFile"> : value	::= #continue '(' expression ')' BNF_sequence;

// Choose how to ignore insignificant characters between tokens:
//   - C++/Java/HTML/XML/LaTeX whitespaces and comments,
//   - blanks
BNF_directive<"ignore"> : value	::= ['(' #continue [#readCString | BNF_ignore_type] ')']?;

// leaves a repeat token, considering that it has succeeded
BNF_directive<"break"> : value	::= #check(true);

// Expects the end of the input file.
BNF_directive<"empty"> : value	::= #check(true);

// Adds a new item in an array. If the rest of the sequence fails, the item
// is removed. If the directive had created the array node, it is removed too.
BNF_directive<"pushItem"> : value	::= #continue '(' variable_expression ')';

// Inserts a new node. If the rest of the sequence fails and if the node wasn't
// existing before, the node is removed.
BNF_directive<"insert"> : value	::= #continue '(' variable_expression ')';

// Reads a byte and returns it as a two hexadecimal digits. It admits a post
// processing for variable assignment or constant's comparison.
BNF_directive<"readByte"> : value	::= => { set BNF_directive = true; };
BNF_directive<"readBytes"> : value	::= => { set BNF_directive = true; };

// Reads a character. It admits a post processing for variable assignment
// or constant's comparison.
BNF_directive<"readChar"> : value	::= => { set BNF_directive = true; };
BNF_directive<"readChars"> : value	::= => { set BNF_directive = true; };

// Reads a C-like string. It admits a post processing for variable assignment
// or constant's comparison.
BNF_directive<"readCString"> : value	::= => { set BNF_directive = true; };

// Reads a Python-like string. It admits a post processing for variable assignment
// or constant's comparison.
BNF_directive<"readPythonString"> : value	::= => { set BNF_directive = true; };

// Reads a C-like identifier. It admits a post processing for variable
// assignment or constant's comparison.
BNF_directive<"readIdentifier"> : value	::= => { set BNF_directive = true; };

// Reads a C-like identifier if the position points to the beginning of an
// identifier. It admits a post processing for variable assignment or
// constant's comparison.
BNF_directive<"readCompleteIdentifier"> : value	::= => { set BNF_directive = true; };

// Reads an integer. It admits a post processing for variable
// assignment or constant's comparison.
BNF_directive<"readInteger"> : value	::= => { set BNF_directive = true; };

// Reads an unsigned long and converts it between network and host representation.
// It admits a post processing for variable assignment or constant's comparison.
BNF_directive<"readNetworkLong"> : value	::= => { set BNF_directive = true; };

// Reads an unsigned short and converts it between network and host representation.
// It admits a post processing for variable assignment or constant's comparison.
BNF_directive<"readNetworkShort"> : value	::= => { set BNF_directive = true; };

// Reads an unsigned long in binary representation.
// It admits a post processing for variable assignment or constant's comparison.
BNF_directive<"readBinaryLong"> : value	::= => { set BNF_directive = true; };

// Reads an unsigned short in binary representation.
// It admits a post processing for variable assignment or constant's comparison.
BNF_directive<"readBinaryShort"> : value	::= => { set BNF_directive = true; };

// Reads an floating-point. It admits a post processing for variable
// assignment or constant's comparison.
BNF_directive<"readNumeric"> : value	::= => { set BNF_directive = true; };

// Scans a terminal given as the result of an expression. It admits a post
// processing for variable assignment or constant's comparison.
BNF_directive<"readText"> : value	::= #continue '(' expression ')' => { set BNF_directive = true; };

// Forces to skip insignificant characters, as specified previously to
// the BNF directive "ignore(...) or as required between parenthesis"
BNF_directive<"skipIgnore"> : value	::= ['(' #continue [#readCString | BNF_ignore_type] ')']?;

// Checks a condition. Does nothing about scan.
BNF_directive<"check"> : value	::= #continue '(' expression ')';

// Available only in a translation script: swap to 'implicit copy' for the
// rest of the sequence.
BNF_directive<"implicitCopy"> : value	::= #check(true);

// Available only in a translation script: swap to 'explicit copy' for the
// rest of the sequence.
BNF_directive<"explicitCopy"> : value	::= #check(true);

// The call of a non-terminal.
BNF_clause_call	::=
		NON_TERMINAL
		[TR_BEGIN #continue concatenation_expression TR_END]?
		['(' #continue [expression [',' #continue expression]*]? ')']?
		;

// Some tokens accept a post processing. It consists of checking whether
// the scanned value belongs to a set of constants or not, and/or assigning
// the value to a variable.
BNF_token_post_processing	::=
		[
			':'
			[
					'{' #continue CONSTANT_STRING [',' #continue CONSTANT_STRING]* '}'
				|
					CONSTANT_STRING
			]
		]?
		[BNF_variable_assignation]?;


//---------------------------------------------------------------------
//               Predefined functions/methods/procedures
//---------------------------------------------------------------------

predefined_function_call<T>	::= #check(false);
//##marker##"predefined_function_call"
//##begin##"predefined_function_call"
predefined_function_call<"flushOutputToSocket">	::=	'(' #continue expression ')';
predefined_function_call<"acceptSocket">	::=	'(' #continue expression ')';
predefined_function_call<"add">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"byteToChar">	::=	'(' #continue expression ')';
predefined_function_call<"bytesToLong">	::=	'(' #continue expression ')';
predefined_function_call<"bytesToShort">	::=	'(' #continue expression ')';
predefined_function_call<"canonizePath">	::=	'(' #continue expression ')';
predefined_function_call<"changeDirectory">	::=	'(' #continue expression ')';
predefined_function_call<"changeFileTime">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_function_call<"charAt">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"charToByte">	::=	'(' #continue expression ')';
predefined_function_call<"charToInt">	::=	'(' #continue expression ')';
predefined_function_call<"chmod">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"ceil">	::=	'(' #continue expression ')';
predefined_function_call<"compareDate">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"completeDate">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"completeLeftSpaces">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"completeRightSpaces">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"composeCLikeString">	::=	'(' #continue expression ')';
predefined_function_call<"composeHTMLLikeString">	::=	'(' #continue expression ')';
predefined_function_call<"composeSQLLikeString">	::=	'(' #continue expression ')';
predefined_function_call<"coreString">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_function_call<"countStringOccurences">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"createINETClientSocket">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"createINETServerSocket">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"createVirtualFile">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"createVirtualTemporaryFile">	::=	'(' #continue expression ')';
predefined_function_call<"decodeURL">	::=	'(' #continue expression ')';
predefined_function_call<"decrement">	::=	'(' #continue variable_expression ')';
predefined_function_call<"deleteFile">	::=	'(' #continue expression ')';
predefined_function_call<"deleteVirtualFile">	::=	'(' #continue expression ')';
predefined_function_call<"div">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"encodeURL">	::=	'(' #continue expression ')';
predefined_function_call<"endl">	::=	'(' #continue ')';
predefined_function_call<"endString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"equal">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"equalsIgnoreCase">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"equalTrees">	::=	'(' #continue variable_expression ',' variable_expression ')';
predefined_function_call<"executeStringQuiet">	::=	'(' #continue variable_expression ',' expression ')';
predefined_function_call<"existEnv">	::=	'(' #continue expression ')';
predefined_function_call<"existFile">	::=	'(' #continue expression ')';
predefined_function_call<"existVirtualFile">	::=	'(' #continue expression ')';
predefined_function_call<"existVariable">	::=	'(' #continue variable_expression ')';
predefined_function_call<"exp">	::=	'(' #continue expression ')';
predefined_function_call<"exploreDirectory">	::=	'(' #continue variable_expression ',' expression ',' expression ')';
predefined_function_call<"extractGenerationHeader">	::=	'(' #continue expression ',' variable_expression ',' variable_expression ',' variable_expression ')';
predefined_function_call<"fileCreation">	::=	'(' #continue expression ')';
predefined_function_call<"fileLastAccess">	::=	'(' #continue expression ')';
predefined_function_call<"fileLastModification">	::=	'(' #continue expression ')';
predefined_function_call<"fileLines">	::=	'(' #continue expression ')';
predefined_function_call<"fileMode">	::=	'(' #continue expression ')';
predefined_function_call<"fileSize">	::=	'(' #continue expression ')';
predefined_function_call<"findElement">	::=	'(' #continue expression ',' variable_expression ')';
predefined_function_call<"findFirstChar">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"findFirstSubstringIntoKeys">	::=	'(' #continue expression ',' variable_expression ')';
predefined_function_call<"findLastString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"findNextString">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_function_call<"findNextSubstringIntoKeys">	::=	'(' #continue expression ',' variable_expression ',' expression ')';
predefined_function_call<"findString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"first">	::=	'(' #continue #readIdentifier ')';
predefined_function_call<"floor">	::=	'(' #continue expression ')';
predefined_function_call<"formatDate">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"getArraySize">	::=	'(' #continue variable_expression ')';
predefined_function_call<"getCommentBegin">	::=	'(' #continue ')';
predefined_function_call<"getCommentEnd">	::=	'(' #continue ')';
predefined_function_call<"getCurrentDirectory">	::=	'(' #continue ')';
predefined_function_call<"getEnv">	::=	'(' #continue expression ')';
predefined_function_call<"getGenerationHeader">	::=	'(' #continue ')';
predefined_function_call<"getHTTPRequest">	::=	'(' #continue expression ',' variable_expression ',' variable_expression ')';
predefined_function_call<"getIncludePath">	::=	'(' #continue ')';
predefined_function_call<"getLastDelay">	::=	'(' #continue ')';
predefined_function_call<"getNow">	::=	'(' #continue ')';
predefined_function_call<"getProperty">	::=	'(' #continue expression ')';
predefined_function_call<"getTextMode">	::=	'(' #continue ')';
predefined_function_call<"getVariableAttributes">	::=	'(' #continue variable_expression ',' variable_expression ')';
predefined_function_call<"getVersion">	::=	'(' #continue ')';
predefined_function_call<"getWorkingPath">	::=	'(' #continue ')';
predefined_function_call<"hexaToDecimal">	::=	'(' #continue expression ')';
predefined_function_call<"hostToNetworkLong">	::=	'(' #continue expression ')';
predefined_function_call<"hostToNetworkShort">	::=	'(' #continue expression ')';
predefined_function_call<"increment">	::=	'(' #continue variable_expression ')';
predefined_function_call<"indentFile">	::=	'(' #continue expression ')';
predefined_function_call<"inf">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"inputKey">	::=	'(' #continue expression ')';
predefined_function_call<"inputLine">	::=	'(' #continue expression ')';
predefined_function_call<"isEmpty">	::=	'(' #continue variable_expression ')';
predefined_function_call<"isIdentifier">	::=	'(' #continue expression ')';
predefined_function_call<"isNegative">	::=	'(' #continue expression ')';
predefined_function_call<"isPositive">	::=	'(' #continue expression ')';
predefined_function_call<"joinStrings">	::=	'(' #continue variable_expression ',' expression ')';
predefined_function_call<"key">	::=	'(' #continue #readIdentifier ')';
predefined_function_call<"last">	::=	'(' #continue #readIdentifier ')';
predefined_function_call<"leftString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"lengthString">	::=	'(' #continue expression ')';
predefined_function_call<"loadBinaryFile">	::=	'(' #continue expression ')';
predefined_function_call<"loadFile">	::=	'(' #continue expression ')';
predefined_function_call<"loadVirtualFile">	::=	'(' #continue expression ')';
predefined_function_call<"log">	::=	'(' #continue expression ')';
predefined_function_call<"longToBytes">	::=	'(' #continue expression ')';
predefined_function_call<"midString">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_function_call<"mod">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"mult">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"networkLongToHost">	::=	'(' #continue expression ')';
predefined_function_call<"networkShortToHost">	::=	'(' #continue expression ')';
predefined_function_call<"not">	::=	'(' #continue expression ')';
predefined_function_call<"octalToDecimal">	::=	'(' #continue expression ')';
predefined_function_call<"parseFreeQuiet">	::=	'(' #continue expression ',' variable_expression ',' expression ')';
predefined_function_call<"pathFromPackage">	::=	'(' #continue expression ')';
predefined_function_call<"postHTTPRequest">	::=	'(' #continue expression ',' variable_expression ',' variable_expression ')';
predefined_function_call<"pow">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"randomInteger">	::=	'(' #continue ')';
predefined_function_call<"receiveBinaryFromSocket">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"receiveFromSocket">	::=	'(' #continue expression ',' variable_expression ')';
predefined_function_call<"receiveTextFromSocket">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"relativePath">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"removeDirectory">	::=	'(' #continue expression ')';
predefined_function_call<"repeatString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"replaceString">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_function_call<"replaceTabulations">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"resolveFilePath">	::=	'(' #continue expression ')';
predefined_function_call<"rightString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"rsubString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"scanDirectories">	::=	'(' #continue variable_expression ',' expression ',' expression ')';
predefined_function_call<"scanFiles">	::=	'(' #continue variable_expression ',' expression ',' expression ',' expression ')';
predefined_function_call<"sendBinaryToSocket">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"sendHTTPRequest">	::=	'(' #continue expression ',' variable_expression ')';
predefined_function_call<"sendTextToSocket">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"shortToBytes">	::=	'(' #continue expression ')';
predefined_function_call<"startString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"sub">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"subString">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"sup">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"system">	::=	'(' #continue expression ')';
predefined_function_call<"toLowerString">	::=	'(' #continue expression ')';
predefined_function_call<"toUpperString">	::=	'(' #continue expression ')';
predefined_function_call<"translateString">	::=	'(' #continue script_file_expression<"translate"> ',' variable_expression ',' expression ')';
predefined_function_call<"trimLeft">	::=	'(' #continue variable_expression ')';
predefined_function_call<"trimRight">	::=	'(' #continue variable_expression ')';
predefined_function_call<"trim">	::=	'(' #continue variable_expression ')';
predefined_function_call<"truncateAfterString">	::=	'(' #continue variable_expression ',' expression ')';
predefined_function_call<"truncateBeforeString">	::=	'(' #continue variable_expression ',' expression ')';
predefined_function_call<"UUID">	::=	'(' #continue ')';
predefined_function_call<"countInputLines">	::=	'(' #continue ')';
predefined_function_call<"getInputFilename">	::=	'(' #continue ')';
predefined_function_call<"getLastReadChars">	::=	'(' #continue expression ')';
predefined_function_call<"getLocation">	::=	'(' #continue ')';
predefined_function_call<"lookAhead">	::=	'(' #continue expression ')';
predefined_function_call<"peekChar">	::=	'(' #continue ')';
predefined_function_call<"readByte">	::=	'(' #continue ')';
predefined_function_call<"readBytes">	::=	'(' #continue expression ')';
predefined_function_call<"readChar">	::=	'(' #continue ')';
predefined_function_call<"readCharAsInt">	::=	'(' #continue ')';
predefined_function_call<"readChars">	::=	'(' #continue expression ')';
predefined_function_call<"readIdentifier">	::=	'(' #continue ')';
predefined_function_call<"readIfEqualTo">	::=	'(' #continue expression ')';
predefined_function_call<"readIfEqualToIgnoreCase">	::=	'(' #continue expression ')';
predefined_function_call<"readIfEqualToIdentifier">	::=	'(' #continue expression ')';
predefined_function_call<"readLine">	::=	'(' #continue variable_expression ')';
predefined_function_call<"readNextText">	::=	'(' #continue expression ')';
predefined_function_call<"readNumber">	::=	'(' #continue variable_expression ')';
predefined_function_call<"readString">	::=	'(' #continue variable_expression ')';
predefined_function_call<"readUptoJustOneChar">	::=	'(' #continue expression ')';
predefined_function_call<"readWord">	::=	'(' #continue ')';
predefined_function_call<"skipBlanks">	::=	'(' #continue ')';
predefined_function_call<"skipEmptyCpp">	::=	'(' #continue ')';
predefined_function_call<"skipEmptyCppExceptDoxygen">	::=	'(' #continue ')';
predefined_function_call<"skipEmptyHTML">	::=	'(' #continue ')';
predefined_function_call<"skipEmptyLaTeX">	::=	'(' #continue ')';
predefined_function_call<"countOutputLines">	::=	'(' #continue ')';
predefined_function_call<"existFloatingLocation">	::=	'(' #continue expression ',' expression ')';
predefined_function_call<"getFloatingLocation">	::=	'(' #continue expression ')';
predefined_function_call<"getLastWrittenChars">	::=	'(' #continue expression ')';
predefined_function_call<"getMarkupKey">	::=	'(' #continue ')';
predefined_function_call<"getMarkupValue">	::=	'(' #continue ')';
predefined_function_call<"getOutputFilename">	::=	'(' #continue ')';
predefined_function_call<"getOutputLocation">	::=	'(' #continue ')';
predefined_function_call<"getProtectedArea">	::=	'(' #continue expression ')';
predefined_function_call<"getProtectedAreaKeys">	::=	'(' #continue variable_expression ')';
predefined_function_call<"indentText">	::=	'(' #continue expression ')';
predefined_function_call<"newFloatingLocation">	::=	'(' #continue expression ')';
predefined_function_call<"remainingProtectedAreas">	::=	'(' #continue variable_expression ')';
predefined_function_call<"removeProtectedArea">	::=	'(' #continue expression ')';
//##end##"predefined_function_call"

predefined_method_call<T> : value	::= #check(false);
//##marker##"predefined_method_call"
//##begin##"predefined_method_call"
predefined_method_call<"flushOutputToSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "flushOutputToSocket"; ;
predefined_method_call<"acceptSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "acceptSocket"; ;
predefined_method_call<"add"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "add"; ;
predefined_method_call<"byteToChar"> : value	::=	'(' #continue ')' => set predefined_method_call = "byteToChar"; ;
predefined_method_call<"bytesToLong"> : value	::=	'(' #continue ')' => set predefined_method_call = "bytesToLong"; ;
predefined_method_call<"bytesToShort"> : value	::=	'(' #continue ')' => set predefined_method_call = "bytesToShort"; ;
predefined_method_call<"canonizePath"> : value	::=	'(' #continue ')' => set predefined_method_call = "canonizePath"; ;
predefined_method_call<"changeDirectory"> : value	::=	'(' #continue ')' => set predefined_method_call = "changeDirectory"; ;
predefined_method_call<"changeFileTime"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "changeFileTime"; ;
predefined_method_call<"charAt"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "charAt"; ;
predefined_method_call<"charToByte"> : value	::=	'(' #continue ')' => set predefined_method_call = "charToByte"; ;
predefined_method_call<"charToInt"> : value	::=	'(' #continue ')' => set predefined_method_call = "charToInt"; ;
predefined_method_call<"chmod"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "chmod"; ;
predefined_method_call<"ceil"> : value	::=	'(' #continue ')' => set predefined_method_call = "ceil"; ;
predefined_method_call<"compareDate"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "compareDate"; ;
predefined_method_call<"completeDate"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "completeDate"; ;
predefined_method_call<"completeLeftSpaces"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "completeLeftSpaces"; ;
predefined_method_call<"completeRightSpaces"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "completeRightSpaces"; ;
predefined_method_call<"composeCLikeString"> : value	::=	'(' #continue ')' => set predefined_method_call = "composeCLikeString"; ;
predefined_method_call<"composeHTMLLikeString"> : value	::=	'(' #continue ')' => set predefined_method_call = "composeHTMLLikeString"; ;
predefined_method_call<"composeSQLLikeString"> : value	::=	'(' #continue ')' => set predefined_method_call = "composeSQLLikeString"; ;
predefined_method_call<"coreString"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "coreString"; ;
predefined_method_call<"countStringOccurences"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "countStringOccurences"; ;
predefined_method_call<"createINETClientSocket"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "createINETClientSocket"; ;
predefined_method_call<"createINETServerSocket"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "createINETServerSocket"; ;
predefined_method_call<"createVirtualFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "createVirtualFile"; ;
predefined_method_call<"createVirtualTemporaryFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "createVirtualTemporaryFile"; ;
predefined_method_call<"decodeURL"> : value	::=	'(' #continue ')' => set predefined_method_call = "decodeURL"; ;
predefined_method_call<"decrement"> : value	::=	'(' #continue ')' => set predefined_method_call = "decrement"; ;
predefined_method_call<"deleteFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "deleteFile"; ;
predefined_method_call<"deleteVirtualFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "deleteVirtualFile"; ;
predefined_method_call<"div"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "div"; ;
predefined_method_call<"encodeURL"> : value	::=	'(' #continue ')' => set predefined_method_call = "encodeURL"; ;
predefined_method_call<"endString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "endString"; ;
predefined_method_call<"equal"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "equal"; ;
predefined_method_call<"equalsIgnoreCase"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "equalsIgnoreCase"; ;
predefined_method_call<"equalTrees"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "equalTrees"; ;
predefined_method_call<"executeStringQuiet"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "executeStringQuiet"; ;
predefined_method_call<"existEnv"> : value	::=	'(' #continue ')' => set predefined_method_call = "existEnv"; ;
predefined_method_call<"existFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "existFile"; ;
predefined_method_call<"existVirtualFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "existVirtualFile"; ;
predefined_method_call<"existVariable"> : value	::=	'(' #continue ')' => set predefined_method_call = "existVariable"; ;
predefined_method_call<"exp"> : value	::=	'(' #continue ')' => set predefined_method_call = "exp"; ;
predefined_method_call<"exploreDirectory"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "exploreDirectory"; ;
predefined_method_call<"extractGenerationHeader"> : value	::=	'(' #continue variable_expression ',' variable_expression ',' variable_expression ')' => set predefined_method_call = "extractGenerationHeader"; ;
predefined_method_call<"fileCreation"> : value	::=	'(' #continue ')' => set predefined_method_call = "fileCreation"; ;
predefined_method_call<"fileLastAccess"> : value	::=	'(' #continue ')' => set predefined_method_call = "fileLastAccess"; ;
predefined_method_call<"fileLastModification"> : value	::=	'(' #continue ')' => set predefined_method_call = "fileLastModification"; ;
predefined_method_call<"fileLines"> : value	::=	'(' #continue ')' => set predefined_method_call = "fileLines"; ;
predefined_method_call<"fileMode"> : value	::=	'(' #continue ')' => set predefined_method_call = "fileMode"; ;
predefined_method_call<"fileSize"> : value	::=	'(' #continue ')' => set predefined_method_call = "fileSize"; ;
predefined_method_call<"findElement"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "findElement"; ;
predefined_method_call<"findFirstChar"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "findFirstChar"; ;
predefined_method_call<"findFirstSubstringIntoKeys"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "findFirstSubstringIntoKeys"; ;
predefined_method_call<"findLastString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "findLastString"; ;
predefined_method_call<"findNextString"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "findNextString"; ;
predefined_method_call<"findNextSubstringIntoKeys"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "findNextSubstringIntoKeys"; ;
predefined_method_call<"findString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "findString"; ;
predefined_method_call<"first"> : value	::=	'(' #continue ')' => set predefined_method_call = "first"; ;
predefined_method_call<"floor"> : value	::=	'(' #continue ')' => set predefined_method_call = "floor"; ;
predefined_method_call<"formatDate"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "formatDate"; ;
predefined_method_call<"size"> : value	::=	'(' #continue ')' => set predefined_method_call = "getArraySize"; ;
predefined_method_call<"getArraySize"> : value	::=	'(' #continue ')' => set predefined_method_call = "getArraySize"; ;
predefined_method_call<"getEnv"> : value	::=	'(' #continue ')' => set predefined_method_call = "getEnv"; ;
predefined_method_call<"getHTTPRequest"> : value	::=	'(' #continue variable_expression ',' variable_expression ')' => set predefined_method_call = "getHTTPRequest"; ;
predefined_method_call<"getProperty"> : value	::=	'(' #continue ')' => set predefined_method_call = "getProperty"; ;
predefined_method_call<"getVariableAttributes"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "getVariableAttributes"; ;
predefined_method_call<"hexaToDecimal"> : value	::=	'(' #continue ')' => set predefined_method_call = "hexaToDecimal"; ;
predefined_method_call<"hostToNetworkLong"> : value	::=	'(' #continue ')' => set predefined_method_call = "hostToNetworkLong"; ;
predefined_method_call<"hostToNetworkShort"> : value	::=	'(' #continue ')' => set predefined_method_call = "hostToNetworkShort"; ;
predefined_method_call<"increment"> : value	::=	'(' #continue ')' => set predefined_method_call = "increment"; ;
predefined_method_call<"indentFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "indentFile"; ;
predefined_method_call<"inf"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "inf"; ;
predefined_method_call<"inputKey"> : value	::=	'(' #continue ')' => set predefined_method_call = "inputKey"; ;
predefined_method_call<"inputLine"> : value	::=	'(' #continue ')' => set predefined_method_call = "inputLine"; ;
predefined_method_call<"empty"> : value	::=	'(' #continue ')' => set predefined_method_call = "isEmpty"; ;
predefined_method_call<"isEmpty"> : value	::=	'(' #continue ')' => set predefined_method_call = "isEmpty"; ;
predefined_method_call<"isIdentifier"> : value	::=	'(' #continue ')' => set predefined_method_call = "isIdentifier"; ;
predefined_method_call<"isNegative"> : value	::=	'(' #continue ')' => set predefined_method_call = "isNegative"; ;
predefined_method_call<"isPositive"> : value	::=	'(' #continue ')' => set predefined_method_call = "isPositive"; ;
predefined_method_call<"joinStrings"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "joinStrings"; ;
predefined_method_call<"key"> : value	::=	'(' #continue ')' => set predefined_method_call = "key"; ;
predefined_method_call<"last"> : value	::=	'(' #continue ')' => set predefined_method_call = "last"; ;
predefined_method_call<"leftString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "leftString"; ;
predefined_method_call<"length"> : value	::=	'(' #continue ')' => set predefined_method_call = "lengthString"; ;
predefined_method_call<"lengthString"> : value	::=	'(' #continue ')' => set predefined_method_call = "lengthString"; ;
predefined_method_call<"loadBinaryFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "loadBinaryFile"; ;
predefined_method_call<"loadFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "loadFile"; ;
predefined_method_call<"loadVirtualFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "loadVirtualFile"; ;
predefined_method_call<"log"> : value	::=	'(' #continue ')' => set predefined_method_call = "log"; ;
predefined_method_call<"longToBytes"> : value	::=	'(' #continue ')' => set predefined_method_call = "longToBytes"; ;
predefined_method_call<"midString"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "midString"; ;
predefined_method_call<"mod"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "mod"; ;
predefined_method_call<"mult"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "mult"; ;
predefined_method_call<"networkLongToHost"> : value	::=	'(' #continue ')' => set predefined_method_call = "networkLongToHost"; ;
predefined_method_call<"networkShortToHost"> : value	::=	'(' #continue ')' => set predefined_method_call = "networkShortToHost"; ;
predefined_method_call<"not"> : value	::=	'(' #continue ')' => set predefined_method_call = "not"; ;
predefined_method_call<"octalToDecimal"> : value	::=	'(' #continue ')' => set predefined_method_call = "octalToDecimal"; ;
predefined_method_call<"parseFreeQuiet"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "parseFreeQuiet"; ;
predefined_method_call<"pathFromPackage"> : value	::=	'(' #continue ')' => set predefined_method_call = "pathFromPackage"; ;
predefined_method_call<"postHTTPRequest"> : value	::=	'(' #continue variable_expression ',' variable_expression ')' => set predefined_method_call = "postHTTPRequest"; ;
predefined_method_call<"pow"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "pow"; ;
predefined_method_call<"receiveBinaryFromSocket"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "receiveBinaryFromSocket"; ;
predefined_method_call<"receiveFromSocket"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "receiveFromSocket"; ;
predefined_method_call<"receiveTextFromSocket"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "receiveTextFromSocket"; ;
predefined_method_call<"relativePath"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "relativePath"; ;
predefined_method_call<"removeDirectory"> : value	::=	'(' #continue ')' => set predefined_method_call = "removeDirectory"; ;
predefined_method_call<"repeatString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "repeatString"; ;
predefined_method_call<"replaceString"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "replaceString"; ;
predefined_method_call<"replaceTabulations"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "replaceTabulations"; ;
predefined_method_call<"resolveFilePath"> : value	::=	'(' #continue ')' => set predefined_method_call = "resolveFilePath"; ;
predefined_method_call<"rightString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "rightString"; ;
predefined_method_call<"rsubString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "rsubString"; ;
predefined_method_call<"scanDirectories"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "scanDirectories"; ;
predefined_method_call<"scanFiles"> : value	::=	'(' #continue expression ',' expression ',' expression ')' => set predefined_method_call = "scanFiles"; ;
predefined_method_call<"sendBinaryToSocket"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "sendBinaryToSocket"; ;
predefined_method_call<"sendHTTPRequest"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "sendHTTPRequest"; ;
predefined_method_call<"sendTextToSocket"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "sendTextToSocket"; ;
predefined_method_call<"shortToBytes"> : value	::=	'(' #continue ')' => set predefined_method_call = "shortToBytes"; ;
predefined_method_call<"startString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "startString"; ;
predefined_method_call<"sub"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "sub"; ;
predefined_method_call<"subString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "subString"; ;
predefined_method_call<"sup"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "sup"; ;
predefined_method_call<"system"> : value	::=	'(' #continue ')' => set predefined_method_call = "system"; ;
predefined_method_call<"toLowerString"> : value	::=	'(' #continue ')' => set predefined_method_call = "toLowerString"; ;
predefined_method_call<"toUpperString"> : value	::=	'(' #continue ')' => set predefined_method_call = "toUpperString"; ;
predefined_method_call<"translateString"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "translateString"; ;
predefined_method_call<"trimLeft"> : value	::=	'(' #continue ')' => set predefined_method_call = "trimLeft"; ;
predefined_method_call<"trimRight"> : value	::=	'(' #continue ')' => set predefined_method_call = "trimRight"; ;
predefined_method_call<"trim"> : value	::=	'(' #continue ')' => set predefined_method_call = "trim"; ;
predefined_method_call<"truncateAfterString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "truncateAfterString"; ;
predefined_method_call<"truncateBeforeString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "truncateBeforeString"; ;
predefined_method_call<"getLastReadChars"> : value	::=	'(' #continue ')' => set predefined_method_call = "getLastReadChars"; ;
predefined_method_call<"lookAhead"> : value	::=	'(' #continue ')' => set predefined_method_call = "lookAhead"; ;
predefined_method_call<"readBytes"> : value	::=	'(' #continue ')' => set predefined_method_call = "readBytes"; ;
predefined_method_call<"readChars"> : value	::=	'(' #continue ')' => set predefined_method_call = "readChars"; ;
predefined_method_call<"readIfEqualTo"> : value	::=	'(' #continue ')' => set predefined_method_call = "readIfEqualTo"; ;
predefined_method_call<"readIfEqualToIgnoreCase"> : value	::=	'(' #continue ')' => set predefined_method_call = "readIfEqualToIgnoreCase"; ;
predefined_method_call<"readIfEqualToIdentifier"> : value	::=	'(' #continue ')' => set predefined_method_call = "readIfEqualToIdentifier"; ;
predefined_method_call<"readLine"> : value	::=	'(' #continue ')' => set predefined_method_call = "readLine"; ;
predefined_method_call<"readNextText"> : value	::=	'(' #continue ')' => set predefined_method_call = "readNextText"; ;
predefined_method_call<"readNumber"> : value	::=	'(' #continue ')' => set predefined_method_call = "readNumber"; ;
predefined_method_call<"readString"> : value	::=	'(' #continue ')' => set predefined_method_call = "readString"; ;
predefined_method_call<"readUptoJustOneChar"> : value	::=	'(' #continue ')' => set predefined_method_call = "readUptoJustOneChar"; ;
predefined_method_call<"existFloatingLocation"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "existFloatingLocation"; ;
predefined_method_call<"getFloatingLocation"> : value	::=	'(' #continue ')' => set predefined_method_call = "getFloatingLocation"; ;
predefined_method_call<"getLastWrittenChars"> : value	::=	'(' #continue ')' => set predefined_method_call = "getLastWrittenChars"; ;
predefined_method_call<"getProtectedArea"> : value	::=	'(' #continue ')' => set predefined_method_call = "getProtectedArea"; ;
predefined_method_call<"getProtectedAreaKeys"> : value	::=	'(' #continue ')' => set predefined_method_call = "getProtectedAreaKeys"; ;
predefined_method_call<"indentText"> : value	::=	'(' #continue ')' => set predefined_method_call = "indentText"; ;
predefined_method_call<"newFloatingLocation"> : value	::=	'(' #continue ')' => set predefined_method_call = "newFloatingLocation"; ;
predefined_method_call<"remainingProtectedAreas"> : value	::=	'(' #continue ')' => set predefined_method_call = "remainingProtectedAreas"; ;
predefined_method_call<"removeProtectedArea"> : value	::=	'(' #continue ')' => set predefined_method_call = "removeProtectedArea"; ;
predefined_method_call<"appendFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "appendFile"; ;
predefined_method_call<"autoexpand"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "autoexpand"; ;
predefined_method_call<"clearVariable"> : value	::=	'(' #continue ')' => set predefined_method_call = "clearVariable"; ;
predefined_method_call<"compileToCpp"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "compileToCpp"; ;
predefined_method_call<"copyFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "copyFile"; ;
predefined_method_call<"copyGenerableFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "copyGenerableFile"; ;
predefined_method_call<"copySmartDirectory"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "copySmartDirectory"; ;
predefined_method_call<"copySmartFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "copySmartFile"; ;
predefined_method_call<"cutString"> : value	::=	'(' #continue expression ',' variable_expression ')' => set predefined_method_call = "cutString"; ;
predefined_method_call<"environTable"> : value	::=	'(' #continue ')' => set predefined_method_call = "environTable"; ;
predefined_method_call<"error"> : value	::=	'(' #continue ')' => set predefined_method_call = "error"; ;
predefined_method_call<"executeString"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "executeString"; ;
predefined_method_call<"expand"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "expand"; ;
predefined_method_call<"generate"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "generate"; ;
predefined_method_call<"generateString"> : value	::=	'(' #continue variable_expression ',' variable_expression ')' => set predefined_method_call = "generateString"; ;
predefined_method_call<"invertArray"> : value	::=	'(' #continue ')' => set predefined_method_call = "invertArray"; ;
predefined_method_call<"openLogFile"> : value	::=	'(' #continue ')' => set predefined_method_call = "openLogFile"; ;
predefined_method_call<"parseAsBNF"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "parseAsBNF"; ;
predefined_method_call<"parseStringAsBNF"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "parseStringAsBNF"; ;
predefined_method_call<"parseFree"> : value	::=	'(' #continue variable_expression ',' expression ')' => set predefined_method_call = "parseFree"; ;
predefined_method_call<"produceHTML"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "produceHTML"; ;
predefined_method_call<"putEnv"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "putEnv"; ;
predefined_method_call<"randomSeed"> : value	::=	'(' #continue ')' => set predefined_method_call = "randomSeed"; ;
predefined_method_call<"removeAllElements"> : value	::=	'(' #continue ')' => set predefined_method_call = "removeAllElements"; ;
predefined_method_call<"removeElement"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "removeElement"; ;
predefined_method_call<"removeFirstElement"> : value	::=	'(' #continue ')' => set predefined_method_call = "removeFirstElement"; ;
predefined_method_call<"removeLastElement"> : value	::=	'(' #continue ')' => set predefined_method_call = "removeLastElement"; ;
predefined_method_call<"removeRecursive"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "removeRecursive"; ;
predefined_method_call<"removeVariable"> : value	::=	'(' #continue ')' => set predefined_method_call = "removeVariable"; ;
predefined_method_call<"saveBinaryToFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "saveBinaryToFile"; ;
predefined_method_call<"saveProject"> : value	::=	'(' #continue ')' => set predefined_method_call = "saveProject"; ;
predefined_method_call<"saveProjectTypes"> : value	::=	'(' #continue ')' => set predefined_method_call = "saveProjectTypes"; ;
predefined_method_call<"saveToFile"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "saveToFile"; ;
predefined_method_call<"setCommentBegin"> : value	::=	'(' #continue ')' => set predefined_method_call = "setCommentBegin"; ;
predefined_method_call<"setCommentEnd"> : value	::=	'(' #continue ')' => set predefined_method_call = "setCommentEnd"; ;
predefined_method_call<"setGenerationHeader"> : value	::=	'(' #continue ')' => set predefined_method_call = "setGenerationHeader"; ;
predefined_method_call<"setIncludePath"> : value	::=	'(' #continue ')' => set predefined_method_call = "setIncludePath"; ;
predefined_method_call<"setNow"> : value	::=	'(' #continue ')' => set predefined_method_call = "setNow"; ;
predefined_method_call<"setProperty"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "setProperty"; ;
predefined_method_call<"setTextMode"> : value	::=	'(' #continue ')' => set predefined_method_call = "setTextMode"; ;
predefined_method_call<"setVersion"> : value	::=	'(' #continue ')' => set predefined_method_call = "setVersion"; ;
predefined_method_call<"setWorkingPath"> : value	::=	'(' #continue ')' => set predefined_method_call = "setWorkingPath"; ;
predefined_method_call<"slideNodeContent"> : value	::=	'(' #continue variable_expression ')' => set predefined_method_call = "slideNodeContent"; ;
predefined_method_call<"traceLine"> : value	::=	'(' #continue ')' => set predefined_method_call = "traceLine"; ;
predefined_method_call<"traceObject"> : value	::=	'(' #continue ')' => set predefined_method_call = "traceObject"; ;
predefined_method_call<"traceText"> : value	::=	'(' #continue ')' => set predefined_method_call = "traceText"; ;
predefined_method_call<"translate"> : value	::=	'(' #continue variable_expression ',' expression ',' expression ')' => set predefined_method_call = "translate"; ;
predefined_method_call<"attachInputToSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "attachInputToSocket"; ;
predefined_method_call<"detachInputFromSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "detachInputFromSocket"; ;
predefined_method_call<"setLocation"> : value	::=	'(' #continue ')' => set predefined_method_call = "setLocation"; ;
predefined_method_call<"attachOutputToSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "attachOutputToSocket"; ;
predefined_method_call<"detachOutputFromSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "detachOutputFromSocket"; ;
predefined_method_call<"insertText"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "insertText"; ;
predefined_method_call<"insertTextOnce"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "insertTextOnce"; ;
predefined_method_call<"insertTextToFloatingLocation"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "insertTextToFloatingLocation"; ;
predefined_method_call<"insertTextOnceToFloatingLocation"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "insertTextOnceToFloatingLocation"; ;
predefined_method_call<"overwritePortion"> : value	::=	'(' #continue expression ',' expression ')' => set predefined_method_call = "overwritePortion"; ;
predefined_method_call<"populateProtectedArea"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "populateProtectedArea"; ;
predefined_method_call<"resizeOutputStream"> : value	::=	'(' #continue ')' => set predefined_method_call = "resizeOutputStream"; ;
predefined_method_call<"setFloatingLocation"> : value	::=	'(' #continue expression ')' => set predefined_method_call = "setFloatingLocation"; ;
predefined_method_call<"setOutputLocation"> : value	::=	'(' #continue ')' => set predefined_method_call = "setOutputLocation"; ;
predefined_method_call<"setProtectedArea"> : value	::=	'(' #continue ')' => set predefined_method_call = "setProtectedArea"; ;
predefined_method_call<"writeBytes"> : value	::=	'(' #continue ')' => set predefined_method_call = "writeBytes"; ;
predefined_method_call<"writeText"> : value	::=	'(' #continue ')' => set predefined_method_call = "writeText"; ;
predefined_method_call<"writeTextOnce"> : value	::=	'(' #continue ')' => set predefined_method_call = "writeTextOnce"; ;
predefined_method_call<"closeSocket"> : value	::=	'(' #continue ')' => set predefined_method_call = "closeSocket"; ;
//##end##"predefined_method_call"

predefined_procedure_call<T>	::= #check(false);
//##marker##"predefined_procedure_call"
//##begin##"predefined_procedure_call"
predefined_procedure_call<"appendFile">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"autoexpand">	::=	'(' #continue expression ',' variable_expression ')';
predefined_procedure_call<"clearVariable">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"compileToCpp">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_procedure_call<"copyFile">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"copyGenerableFile">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"copySmartDirectory">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"copySmartFile">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"cutString">	::=	'(' #continue expression ',' expression ',' variable_expression ')';
predefined_procedure_call<"environTable">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"error">	::=	'(' #continue expression ')';
predefined_procedure_call<"executeString">	::=	'(' #continue variable_expression ',' expression ')';
predefined_procedure_call<"expand">	::=	'(' #continue script_file_expression<"pattern"> ',' variable_expression ',' expression ')';
predefined_procedure_call<"generate">	::=	'(' #continue script_file_expression<"pattern"> ',' variable_expression ',' expression ')';
predefined_procedure_call<"generateString">	::=	'(' #continue script_file_expression<"pattern"> ',' variable_expression ',' variable_expression ')';
predefined_procedure_call<"invertArray">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"openLogFile">	::=	'(' #continue expression ')';
predefined_procedure_call<"parseAsBNF">	::=	'(' #continue script_file_expression<"BNF"> ',' variable_expression ',' expression ')';
predefined_procedure_call<"parseStringAsBNF">	::=	'(' #continue script_file_expression<"BNF"> ',' variable_expression ',' expression ')';
predefined_procedure_call<"parseFree">	::=	'(' #continue script_file_expression<"free"> ',' variable_expression ',' expression ')';
predefined_procedure_call<"produceHTML">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"putEnv">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"randomSeed">	::=	'(' #continue expression ')';
predefined_procedure_call<"removeAllElements">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"removeElement">	::=	'(' #continue variable_expression ',' expression ')';
predefined_procedure_call<"removeFirstElement">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"removeLastElement">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"removeRecursive">	::=	'(' #continue variable_expression ',' expression ')';
predefined_procedure_call<"removeVariable">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"saveBinaryToFile">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"saveProject">	::=	'(' #continue expression ')';
predefined_procedure_call<"saveProjectTypes">	::=	'(' #continue expression ')';
predefined_procedure_call<"saveToFile">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"setCommentBegin">	::=	'(' #continue expression ')';
predefined_procedure_call<"setCommentEnd">	::=	'(' #continue expression ')';
predefined_procedure_call<"setGenerationHeader">	::=	'(' #continue expression ')';
predefined_procedure_call<"setIncludePath">	::=	'(' #continue expression ')';
predefined_procedure_call<"setNow">	::=	'(' #continue expression ')';
predefined_procedure_call<"setProperty">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"setTextMode">	::=	'(' #continue expression ')';
predefined_procedure_call<"setVersion">	::=	'(' #continue expression ')';
predefined_procedure_call<"setWorkingPath">	::=	'(' #continue expression ')';
predefined_procedure_call<"slideNodeContent">	::=	'(' #continue variable_expression ',' variable_expression ')';
predefined_procedure_call<"traceEngine">	::=	'(' #continue ')';
predefined_procedure_call<"traceLine">	::=	'(' #continue expression ')';
predefined_procedure_call<"traceObject">	::=	'(' #continue variable_expression ')';
predefined_procedure_call<"traceStack">	::=	'(' #continue ')';
predefined_procedure_call<"traceText">	::=	'(' #continue expression ')';
predefined_procedure_call<"translate">	::=	'(' #continue script_file_expression<"translate"> ',' variable_expression ',' expression ',' expression ')';
predefined_procedure_call<"attachInputToSocket">	::=	'(' #continue expression ')';
predefined_procedure_call<"detachInputFromSocket">	::=	'(' #continue expression ')';
predefined_procedure_call<"goBack">	::=	'(' #continue ')';
predefined_procedure_call<"setLocation">	::=	'(' #continue expression ')';
predefined_procedure_call<"attachOutputToSocket">	::=	'(' #continue expression ')';
predefined_procedure_call<"detachOutputFromSocket">	::=	'(' #continue expression ')';
predefined_procedure_call<"insertText">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"insertTextOnce">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"insertTextToFloatingLocation">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"insertTextOnceToFloatingLocation">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"overwritePortion">	::=	'(' #continue expression ',' expression ',' expression ')';
predefined_procedure_call<"populateProtectedArea">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"resizeOutputStream">	::=	'(' #continue expression ')';
predefined_procedure_call<"setFloatingLocation">	::=	'(' #continue expression ',' expression ')';
predefined_procedure_call<"setOutputLocation">	::=	'(' #continue expression ')';
predefined_procedure_call<"setProtectedArea">	::=	'(' #continue expression ')';
predefined_procedure_call<"writeBytes">	::=	'(' #continue expression ')';
predefined_procedure_call<"writeText">	::=	'(' #continue expression ')';
predefined_procedure_call<"writeTextOnce">	::=	'(' #continue expression ')';
predefined_procedure_call<"closeSocket">	::=	'(' #continue expression ')';
//##end##"predefined_procedure_call"