The WHILE-like instructions.

To be read by the PhpMyCellScript interpreter.

• access: public

Compile a regular-expression-based grammar.

• return: The compiled grammar. Sample result:

           array(
               'SIMPLE_SENTENCE' => array(
                   'is_terminal' => false,
                   'regex' => '(((\\w+)(\\s*))+)(\\.)',
                   'is_generating_regex' => false,
                   'quantifier' => '',
                   'is_alternation' => false,
                   'sub_symbols' => array('WORDS', ''),
                   'sub_regexes' => array('((\\w+)(\\s*))+', '\\.')
               ),
               'WORDS' => array(
                   'is_terminal' => false,
                   'regex' => '((\\w+)(\\s*))+',
                   'is_generating_regex' => false,
                   'quantifier' => '+',
                   'is_alternation' => false,
                   'sub_symbols' => array('WORD', ''),
                   'sub_regexes' => array('\\w+', '\\s*')
               ),
               'WORD' => array(
                   'is_terminal' => true,
                   'regex' => '\\w+'
               )
           )

• access: public

• array $regex_grammar: The grammar to compile. Sample value:

           array(
               array(
                   // For a non-terminal symbol.
                   'SIMPLE_SENTENCE', // The first element is the name of the symbol.
                   '', // The second element specifies a quantifier (?, *, +, ...) or an alternation operator (|), if needed.
                   'WORDS', // The remaining elements can refer to another symbol,
                   '\\.' // or specify a regular expression directly.
               ),
               array(
                   'WORDS',
                   '+',
                   'WORD',
                   '\\s*'
               ),
               array(
                   // For a terminal symbol.
                   'WORD', // The first element is the name of the symbol.
                   '\\w+' // The second element is the regular expression for the symbol.
               )
           )

Utility: Create XML nodes according to the data given in a cell array, then insert them to a given XML node, or create a SimpleXML object for accessing them if a XML node is not given.

• access: public

• array $cell_array: The data which list what nodes to create. Sample value:

           array(
               // Each row defines a node.
               0 => array(
                   0 => 'div', // The name of an element node.
                   1 => 'id', // The name of an attribute.
                   2 => 'my_div', // The value of the attribute.
                   3 => 'text()', // Create a text node inside the element node.
                   4 => 'Link: ' // The text content.
               ),
               1 => array(
                   0 => null, // Use indentation to create child nodes for 'div'.
                   1 => 'a', // The name of an element node.
                   2 => 'href',
                   3 => 'http://phpmycodegen.sourceforge.net/',
                   4 => 'text()',
                   5 => 'PhpMyCodeGenerator'
               ),
               2 => array(
                   0 => null, // Use indentation to create child nodes for 'a'.
                   1 => null, // Use indentation to create child nodes for 'a'.
                   2 => 'text()', // Create a text node.
                   3 => ' & PhpMyCellScript'
               ),
               3 => array(
                   0 => null, // Use indentation to create child nodes for 'div'.
                   1 => 'table' // The name of an element node.
               ),
               4 => array(
                   0 => null, // Use indentation to create child nodes for 'table'.
                   1 => null, // Use indentation to create child nodes for 'table'.
                   2 => 'rows()', // Used to create row and cell nodes in a more convenient way.
                   3 => 'tr', // The name of the row element nodes.
                   4 => 'td', // The name of the cell element nodes.
                   5 => '2', // The number of cells in a row.
                   6 => 'false' // Indicate whether to convert newline to br.
               ),
               5 => array(
                   0 => null, // Use indentation to pass row data to rows().
                   1 => null, // Use indentation to pass row data to rows().
                   2 => null, // Use indentation to pass row data to rows().
                   3 => 'Row 1 Cell 1',
                   4 => 'Row 1 Cell 2'
               ),
               6 => array(
                   0 => null, // Use indentation to pass row data to rows().
                   1 => null, // Use indentation to pass row data to rows().
                   2 => null, // Use indentation to pass row data to rows().
                   3 => 'Row 2 Cell 1',
                   4 => 'Row 2 Cell 2'
               ),
               7 => array(
                   0 => null, // Use indentation to create child nodes for 'div'.
                   1 => 'html()', // Create nodes for a HTML string.
                   2 => '<div><b>Bold HTML string</b></div>'
               ),
               8 => array(
                   0 => null, // Use indentation to create child nodes for 'div'.
                   1 => 'cell_array()', // Create nodes using another cell array.
                   2 => array( // Note that this is an array, not a string.
                       0 => array(
                           0 => 'div',
                           1 => 'text()',
                           2 => 'Text from another cell array.'
                       )
                   )
               ),
               9 => array(
                   0 => 'pre' // The name of an element node.
               ),
               10 => array(
                   0 => null, // Use indentation to create child nodes for 'pre'.
                   1 => 'text_from_cell_array()', // Create a text node using the following cell array.
                   2 => "\n", // The row separator.
                   3 => "\t", // The cell separator.
                   4 => "\n", // The prefix.
                   5 => "\n" // The suffix.
               ),
               11 => array(
                   0 => null, // Use indentation to create child nodes for 'pre'.
                   1 => null, // Use indentation to pass data to text_from_cell_array().
                   2 => 'function test() {'
               ),
               12 => array(
                   0 => null, // Use indentation to create child nodes for 'pre'.
                   1 => null, // Use indentation to pass data to text_from_cell_array().
                   2 => null, // Use indentation to pass data to text_from_cell_array().
                   3 => 'alert("Test");'
               ),
               13 => array(
                   0 => null, // Use indentation to create child nodes for 'pre'.
                   1 => null, // Use indentation to pass data to text_from_cell_array().
                   2 => '}'
               ),
               14 => array(
                   0 => 'macro()', // Define a macro.
                   1 => 'HYPERLINK', // The name of the macro.
                   2 => 'a', // The name of an element node.
                   3 => 'href', // The name of the first attribute.
                   4 => 'text()' // The name of the second attribute.
               ),
               15 => array(
                   0 => '@HYPERLINK', // Refer to a macro.
                   1 => 'http://phpmycodegen.sourceforge.net/', // The value of the first attribute.
                   2 => 'PhpMyCodeGenerator' // The value of the second attribute.
               ),
               16 => array(
                   0 => 'comment()', // Create a comment.
                   1 => '--End--' // The comment to output.
               ),
               17 => array(
                   0 => 'comment()', // Create a comment.
                   1 => null, // No comment to output.
                   2 => '--End--' // The comment which will not be outputted.
               )
           )

• SimpleXMLElement/DOMNode &$root_node: The nodes created will be inserted into this node if given, otherwise, a SimpleXML object will be created and returned. Sample result:

           <div id="my_div">Link: <a href="http://phpmycodegen.sourceforge.net/">PhpMyCodeGenerator &amp; PhpMyCellScript</a><table><tr><td>Row 1 Cell 1</td><td>Row 1 Cell 2</td></tr><tr><td>Row 2 Cell 1</td><td>Row 2 Cell 2</td></tr></table><div><b>Bold HTML string</b></div><div>Text from another cell array.</div></div>
           <pre>
           function test() {
               alert("Test");
           }
           </pre>
           <a href="http://phpmycodegen.sourceforge.net/">PhpMyCodeGenerator</a>
           <!----End---->

Parse an input string against a compiled LL grammar.

• return: The parse tree as a SimpleXML object, or false if the input string does not match the grammar.
• access: public

• array $compiled_grammar: The data returned by compileLLGrammar().
• string $input_string: The input string to parse. Should be in UTF-8.
• string $start_symbol: The start symbol.
• int $max_depth: An exception will be thrown if the height of the result parse tree would exceed the maximum depth. Ignored if <= 0.

Utility: Execute an AutoIt script, and return its output.

• return: The output of the script.

• string $script: The AutoIt script to execute.

This instruction collects cell values after the current row and the current column, and then merges them into an array variable.

Syntax: ARRAY_MERGE variable [keep_empty_row]

• variable: an array variable for merging the cell values to.
• keep_empty_row: Indicate whether to keep the empty rows. (optional)

• OutputVariable $variable
• PhpExpressionValue $keep_empty_row
• PhpMyCellScript $interpreter

This instruction collects cell values after the current row and the current column, then evaluates the expressions in the cell values, and then merges them into an array variable.

Syntax: ARRAY_MERGE_VALUE variable [keep_empty_row]

• variable: an array variable for merging the cell values (where expressions will be evaluated) to.
• keep_empty_row: Indicate whether to keep the empty rows. (optional)

• OutputVariable $variable
• PhpExpressionValue $keep_empty_row
• PhpMyCellScript $interpreter
• DynamicPhpExpressionValues $expressions

This instruction assigns a string to a variable.

This instruction may be used to save code snippet for output later.

Syntax: ASSIGN variable string

• variable: the variable.
• string: the string to assign. Variables in the string will be parsed.

• OutputVariable $variable
• VariableExpandedString $string

This instruction assigns a PHP value (obtained by evaluating a PHP expression) to a variable.

This instruction provides a cell-based approach to do assignment, instead of using the PHP assignment operator.

Syntax: ASSIGN_VALUE variable value

• variable: the variable.
• value: a PHP expression, which will be evaluated to obtain a value.

• OutputVariable $variable
• PhpExpressionValue $value

This instruction gets a string from the clipboard, using AutoIt.

Syntax: CLIP_GET output_variable

• output_variable: a variable for returning the string, in UTF8.

• OutputVariable $output_variable

This instruction concats a string to a variable.

This instruction may be used to prepare code for output later.

Syntax: CONCAT variable string

• variable: the variable.
• string: the string to concat to the variable. Variables in the string will be parsed.

• OutputVariable $variable
• VariableExpandedString $string

This instruction copies a directory recursively.

Syntax: DIR_COPY source dest [preserve_timestamp]

• source: the source directory, where variables will be parsed.
• dest: the destination path, where variables will be parsed.
• preserve_timestamp: indicate whether to preserve the timestamp of the file/directory. Default is false. (optional)

• VariableExpandedString $source
• VariableExpandedString $dest
• PhpExpressionValue $preserve_timestamp
• PhpMyCellScript $interpreter

This instruction returns the name of a temporary directory.

Syntax: DIR_TEMP dir_name_variable [prefix] [suffix]

• dir_name_variable: a variable for returning the name of the temporary directory.
• prefix: the prefix of the temporary directory, where variables will be parsed. (optional)
• suffix: the suffix of the temporary directory, where variables will be parsed. (optional)

• OutputVariable $dir_name_variable
• VariableExpandedString $prefix
• VariableExpandedString $suffix

This instruction echos a string to the console.

This instruction may be used to output generated code to the console.

Syntax: ECHO output_string

• output_string: the string to output. Variables in the string will be parsed.

• VariableExpandedString $output_string

This instruction echos the strings in the following columns as a row, separating the values by tabs.

Syntax: ECHO_ROW [string1] [string2] ...

• stringX: the strings, where variables will be parsed.

• array $strings
• DynamicVariableExpandedStrings $expanded_strings

This instruction supports alternative branches for IF-like instructions, and works similar to IF_E.

Syntax: ELSEIF_E string1 string2

• string1: the first string, where variables will be parsed.
• string2: the second string, where variables will be parsed.

• VariableExpandedString $string1
• VariableExpandedString $string2
• PhpMyCellScript $interpreter

This instruction escapes a string and saves the escaped string to a variable.

The escaped string can be unescaped by parsing it as a heredoc string.

Syntax: ESCAPE_STRING output_variable string [use_full_version]

• output_variable: the variable for returning the escaped string.
• string: the string to escape. Variables in the string will be parsed.
• use_full_version: indicate whether to escape more characters. See escapeCellHeredocString(). (optional)

• OutputVariable $output_variable
• VariableExpandedString $string
• PhpExpressionValue $use_full_version

This instruction copies a file, which may be used to download a file or extract a file from an archive too.

Syntax: FILE_COPY source dest [preserve_timestamp]

• source: the source file, where variables will be parsed.
• dest: the destination path, where variables will be parsed.
• preserve_timestamp: indicate whether to preserve the timestamp of the file. Default is false. (optional)

• VariableExpandedString $source
• VariableExpandedString $dest
• PhpExpressionValue $preserve_timestamp
• PhpMyCellScript $interpreter

This instruction loads the content of a file to a variable, which makes it more convenient to work with files in the spreadsheet.

Syntax: FILE_LOAD file_name result_variable

• file_name: the file name, where variables will be parsed.
• result_variable: a variable for returning the file content, or FALSE on failure.

• VariableExpandedString $file_name
• OutputVariable $result_variable
• PhpMyCellScript $interpreter

This instruction saves some content to a file, which makes it more convenient to work with files in the spreadsheet.

Syntax: FILE_SAVE file_name file_content

• file_name: the file name, where variables will be parsed.
• file_content: the file content, where variables will be parsed.

• VariableExpandedString $file_name
• VariableExpandedString $file_content

This instruction sets the modification time of a file, based on the modification time of another file.

Syntax: FILE_TOUCH target [source]

• target: the target file, where variables will be parsed.
• source: if given, the modification time of the target file will be set to the modification time of the source file. Variables will be parsed. (optional)

• VariableExpandedString $target
• VariableExpandedString $source

This instruction uses the compileRegexGrammar() function to compile a regular-expression-based grammar, and then you can use the GRAMMAR_PARSE instruction to parse input strings.

Syntax: GRAMMAR_COMPILE grammar compiled_grammar_variable

• grammar: the grammar, see compileRegexGrammar().
• compiled_grammar_variable: a variable for returning the compiled grammar.

• PhpExpressionValue $grammar
• OutputVariable $compiled_grammar_variable

This instruction uses the parseAgainstLLGrammar() function to parse an input string against a compiled LL grammar, a parse tree will be returned as a SimpleXML object for you to query against.

Syntax: GRAMMAR_LL_PARSE compiled_grammar input_string parse_tree_variable [start_symbol] [max_depth]

• compiled_grammar: the compiled grammar, returned by GRAMMAR_LL_COMPILE.
• input_string: the input string to parse, where variables will be parsed. Should be in UTF-8.
• parse_tree_variable: a variable for returning the parse tree, which is a SimpleXML object. An Exception object will be returned on error.
• start_symbol: the start symbol of the grammar, where variables will be parsed. (optional)
• max_depth: failed if the height of the result parse tree would exceed the maximum depth. (optional)

• PhpExpressionValue $compiled_grammar
• VariableExpandedString $input_string
• OutputVariable $parse_tree_variable
• VariableExpandedString $start_symbol
• PhpExpressionValue $max_depth
• PhpMyCellScript $interpreter

This instruction interprets a string of HTML into a SimpleXML object.

Syntax: HTML_LOAD html_string xml_variable

• html_string: the HTML string to interpret, where variables will be parsed.
• xml_variable: a variable for returning the SimpleXMLIterator object, or FALSE on failure.

• VariableExpandedString $html_string
• OutputVariable $xml_variable
• PhpMyCellScript $interpreter

This instruction corresponds to the PHP iconv() function, which makes it more convenient to perform character set conversion on strings in the spreadsheet.

As the encoding of the string returned by Cells()->Value depends on the system code page, but some PHP functions (like XML or Selenium ones) take or return UTF-8 strings, you may use this instruction to do conversion if needed.

Syntax: ICONV in_charset out_charset input_string output_variable

• in_charset: the charset of the input string, where variables will be parsed.
• out_charset: the output charset, where variables will be parsed.
• input_string: the string to be converted, where variables will be parsed.
• output_variable: a variable for returning the converted string, or FALSE on failure.

• VariableExpandedString $in_charset
• VariableExpandedString $out_charset
• VariableExpandedString $input_string
• OutputVariable $output_variable

This instruction searches a source string for a match to a given regular expression, using the PHP function preg_match().

Syntax: IF_M pattern source_string [match_result_variable]

• pattern: a pattern, which will be passed to preg_match(), and where variables will be parsed.
• source_string: the source string, where variables will be parsed.
• match_result_variable: a variable for returning the match information, as returned by preg_match(). (optional)

• VariableExpandedString $pattern
• VariableExpandedString $source_string
• OutputVariable $match_result_variable
• PhpMyCellScript $interpreter

This instruction checks whether CLI PHP is used.

Syntax: IS_CLI

If success, then the instructions in the next column will be processed.

• PhpMyCellScript $interpreter

This instruction checks whether PHP is used in the web context.

Syntax: IS_WEB

If success, then the instructions in the next column will be processed.

• PhpMyCellScript $interpreter

This instruction converts a PHP value to a JSON string.

Syntax: JSON_TO_STRING result_variable value

• result_variable: a variable for returning the JSON string.
• value: the PHP value to convert.

• OutputVariable $result_variable
• PhpExpressionValue $value

This instruction saves/merges a string to a file.

This instruction may be used to output generated code to a file.

Syntax: MERGE file_name output_string

• file_name: the file name, where variables will be parsed.
• output_string: the string to output. Variables in the string will be parsed.

• VariableExpandedString $file_name
• VariableExpandedString $output_string

This instruction finds all instances of a given search text, and returns the ranges of the instances found.

Syntax: MSWORD_FIND range_object search_text result_variable [max_num_of_results]

• range_object: the Range object, within which the text will be searched.
• search_text: the text to find, where variables will be parsed.
• result_variable: a variable for returning the ranges of the instances found.
• max_num_of_results: the maximum number of results to return. No limit if <= 0. (optional)

• PhpExpressionValue $range_object
• VariableExpandedString $search_text
• OutputVariable $result_variable
• PhpExpressionValue $max_num_of_results
• PhpMyCellScript $interpreter

This instruction opens a Microsoft Word document, which intends to use with other related instructions to make it easier to extract information from Microsoft Word documents.

Syntax: MSWORD_OPEN file_name document_variable

• file_name: the file name, where variables will be parsed.
• document_variable: a variable for returning the Word.Document object, or FALSE on failure.

• VariableExpandedString $file_name
• OutputVariable $document_variable
• PhpMyCellScript $interpreter

This instruction corresponds to the PHP odbc_columns() function, which makes it easier to write database related scripts.

Syntax: ODBC_COLUMNS qualifier schema table_name column_name result_variable

• qualifier: a parameter to odbc_columns(), where variables will be parsed.
• schema: a parameter to odbc_columns(), where variables will be parsed.
• table_name: a parameter to odbc_columns(), where variables will be parsed.
• column_name: a parameter to odbc_columns(), where variables will be parsed.
• result_variable: a variable for returning the result set, or FALSE on failure.

• VariableExpandedString $qualifier
• VariableExpandedString $schema
• VariableExpandedString $table_name
• VariableExpandedString $column_name
• OutputVariable $result_variable
• PhpMyCellScript $interpreter
• DynamicOutputVariable $connection_id_variable

This instruction corresponds to the PHP odbc_exec() function, which makes it easier to write database related scripts.

Syntax: ODBC_EXEC query_string result_variable [result_type]

• query_string: a parameter to odbc_exec(), where variables will be parsed.
• result_variable: a variable for returning the result set, or FALSE on failure.
• result_type: indicate what type of result set array to return, either BOTH, ASSOC or NUM, where variables will be parsed. (optional)

• VariableExpandedString $query_string
• OutputVariable $result_variable
• VariableExpandedString $result_type
• PhpMyCellScript $interpreter
• DynamicOutputVariable $connection_id_variable

This instruction corresponds to the PHP odbc_tables() function, which makes it easier to write database related scripts.

Syntax: ODBC_TABLES qualifier owner name result_variable

• qualifier: a parameter to odbc_tables(), where variables will be parsed.
• owner: a parameter to odbc_tables(), where variables will be parsed.
• name: a parameter to odbc_tables(), where variables will be parsed.
• result_variable: a variable for returning the result set, or FALSE on failure.

• VariableExpandedString $qualifier
• VariableExpandedString $owner
• VariableExpandedString $name
• OutputVariable $result_variable
• PhpMyCellScript $interpreter
• DynamicOutputVariable $connection_id_variable

This instruction evaluates a PHP template, and returns the evaluation result, which makes it possible to write code template using PHP in the spreadsheet.

Syntax: PHP php_template [output_variable]

• php_template: the PHP template.
• output_variable: a variable for returning the output. (optional)

• EvaluatedPhpTemplate $php_template
• OutputVariable $output_variable

This instruction executes a command using the PHP function proc_open(), which provides a much greater degree of control over the program execution.

Syntax: PROC_OPEN command [cwd] [process_variable]

• command: the command to execute, where variables will be parsed.
• cwd: the initial working dir for the command, where variables will be parsed. (optional)
• process_variable: a variable for returning the return value of proc_open(), or false on error. (optional)

• VariableExpandedString $command
• VariableExpandedString $cwd
• OutputVariable $process_variable
• PhpMyCellScript $interpreter

This instruction sends a string to the stdin of a process, started by PROC_OPEN.

Syntax: PROC_STDIN input_string [result_variable] [echo_flag]

• input_string: the input string to send to the stdin of the process, where variables will be parsed.
• result_variable: a variable for returning the return value of fwrite(), i.e. the number of bytes written, or false on error. (optional)
• echo_flag: indicate whether to echo the input string sent to the process. (optional)

• VariableExpandedString $input_string
• OutputVariable $result_variable
• PhpExpressionValue $echo_flag
• PhpMyCellScript $interpreter

This instruction echos a prompt string, then gets and returns the user input, which helps to get user input in the spreadsheet.

Syntax: PROMPT prompt_string [output_variable]

• prompt_string: the prompt string, where variables will be parsed.
• output_variable: a variable for returning the user input. (optional)

• VariableExpandedString $prompt_string
• OutputVariable $output_variable

This instruction just replaces the current selection marked by the FIND instruction with a given string, and update the current selection, which makes it easier to modify a string in the spreadsheet.

Syntax: REPLACE replacement_string

• replacement_string: the replacement string, where variables will be parsed.

• VariableExpandedString $replacement_string
• PhpMyCellScript $interpreter
• DynamicOutputVariable $source_string_variable
• DynamicOutputVariable $selection_start_variable
• DynamicOutputVariable $selection_length_variable

This instruction executes a command asynchronously.

Syntax: RUN_ASYNC command [window_style]

• command: the command and its arguments, where variables will be parsed.
• window_style: the window style, which will be passed to the Run method of the WScript.Shell object. (optional)

• VariableExpandedString $command
• PhpExpressionValue $window_style

This instruction shows a list of options, and asks the user to select one of them.

Syntax: SELECT_OPTION prompt_string options output_variable

• prompt_string: the prompt string, where variables will be parsed.
• options: an array of options.
• output_variable: a variable for returning the index of the selected option. The variable may be initialized with the index of the default option.

• VariableExpandedString $prompt_string
• PhpExpressionValue $options
• OutputVariable $output_variable

This instruction starts a browser using Selenium Remote Control, so that you can script a browser.

You need to install the Selenium PHP client driver in order to use this instruction.

Syntax: SELENIUM_START browser browser_url [selenium_variable] [host] [port]

• browser: the browser to start, which will be passed to the constructor of Testing_Selenium, and where variables will be parsed.
• browser_url: a URL, which will be passed to the constructor of Testing_Selenium, and where variables will be parsed.
• selenium_variable: a variable for returning the Testing_Selenium object. (optional)
• host: the host of the RC server, where variables will be parsed. (optional)
• port: the port of the RC server, where variables will be parsed. (optional)

• VariableExpandedString $browser
• VariableExpandedString $browser_url
• OutputVariable $selenium_variable
• VariableExpandedString $host
• VariableExpandedString $port
• PhpMyCellScript $interpreter

This instruction uses the PHP function shell_exec() to execute a command.

Syntax: SHELL_EXEC command [argument1 argument2 ... argumentn output_variable]

• command: the name of the command, where variables will be parsed. Command string will not be escaped.
• argument1..n: the arguments of the command, where variables will be parsed. Argument strings will be escaped. (optional)
• output_variable: a variable for returning the output of the executed command. This is in the last non-empty cell. Optional if no argument is given.

• VariableExpandedString $command
• array $arguments
• DynamicOutputVariable $output_variable
• DynamicVariableExpandedStrings $expanded_strings

This instruction creates an array of strings.

Syntax: STRING_ARRAY [string1] [string2] ... [stringn] array_variable

• string1..n: the strings, where variables will be parsed. (optional)
• array_variable: a variable for returning the array created. This is in the last non-empty cell.

• array $strings
• DynamicOutputVariable $array_variable
• DynamicVariableExpandedStrings $expanded_strings

This instruction uses the PHP function system() to execute an external program.

Syntax: SYSTEM command [argument1 argument2 ... argumentn return_status_variable]

• command: the name of the command, where variables will be parsed. Command string will not be escaped.
• argument1..n: the arguments of the command, where variables will be parsed. Argument strings will be escaped. (optional)
• return_status_variable: a variable for returning the status of the executed command. This is in the last non-empty cell. Optional if no argument is given.

• VariableExpandedString $command
• array $arguments
• DynamicOutputVariable $return_status_variable
• DynamicVariableExpandedStrings $expanded_strings

This instruction creates an array of values.

Syntax: VALUE_ARRAY [expression1] [expression2] ... [expressionn] array_variable

• expression1..n: the expressions to evaluate. (optional)
• array_variable: a variable for returning the array created. This is in the last non-empty cell.

• array $expressions
• DynamicOutputVariable $array_variable
• DynamicPhpExpressionValues $values

This instruction uses the convertValueToXmlObject() function to convert a value into a SimpleXML object, against which you can run XPath queries.

Syntax: XML_FROM_VALUE value xml_variable [encoding]

• value: an array, object or simply a scalar value.
• xml_variable: a variable for returning the SimpleXMLIterator object.
• encoding: the encoding of the value, where variables will be parsed. (optional)

• PhpExpressionValue $value
• OutputVariable $xml_variable
• VariableExpandedString $encoding

This instruction dumps a XML string for a XML node.

Syntax: XML_TO_STRING result_variable xml_node [format_output_flag] [remove_xml_declaration_flag]

• result_variable: a variable for returning the XML string.
• xml_node: the XML node to dump. A SimpleXMLElement or DOMNode object.
• format_output_flag: indicate whether to format the XML string. (optional)
• remove_xml_declaration_flag: indicate whether to remove the XML declaration from the XML string. (optional)

• OutputVariable $result_variable
• PhpExpressionValue $xml_node
• PhpExpressionValue $format_output_flag
• PhpExpressionValue $remove_xml_declaration_flag

This instruction creates an XSLTProcessor object, and imports a stylesheet for transformations using the XSLT_TRANSFORM instruction.

Syntax: XSLT_NEW [stylesheet] [xslt_variable]

• stylesheet: the stylesheet to import, as a DOMDocument or SimpleXMLElement object. (optional)
• xslt_variable: a variable for returning the new XSLTProcessor object. (optional)

• PhpExpressionValue $stylesheet
• OutputVariable $xslt_variable
• PhpMyCellScript $interpreter

For escaping special characters in a PHP heredoc string, like "\" and "$".

Some other characters will be escaped too in order to prevent problems in Excel:

1. Some non-printable characters, like TAB, and non-ASCII characters may be ignored by Excel.
2. Excel may interpret a cell differently if the cell starts with certain characters, like "=".
3. Some HTML tags, like TABLE, may be recognized by Excel, which may cause problems. (full version)

• string $s: The string to escape.
• boolean $use_full_version: If true, more characters will be escaped.