Your IP : 172.69.214.232
<?php
/**
* Configuration file editor.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
* http://www.gnu.org/copyleft/gpl.html
*
* @file
*/
/**
* This is a state machine style parser with two internal stacks:
* * A next state stack, which determines the state the machine will progress to next
* * A path stack, which keeps track of the logical location in the file.
*
* Reference grammar:
*
* file = T_OPEN_TAG *statement
* statement = T_VARIABLE "=" expression ";"
* expression = array / scalar / T_VARIABLE
* array = T_ARRAY "(" [ element *( "," element ) [ "," ] ] ")"
* element = assoc-element / expression
* assoc-element = scalar T_DOUBLE_ARROW expression
* scalar = T_LNUMBER / T_DNUMBER / T_STRING / T_CONSTANT_ENCAPSED_STRING
*/
class ConfEditor {
/** The text to parse */
var $text;
/** The token array from token_get_all() */
var $tokens;
/** The current position in the token array */
var $pos;
/** The current 1-based line number */
var $lineNum;
/** The current 1-based column number */
var $colNum;
/** The current 0-based byte number */
var $byteNum;
/** The current ConfEditorToken object */
var $currentToken;
/** The previous ConfEditorToken object */
var $prevToken;
/**
* The state machine stack. This is an array of strings where the topmost
* element will be popped off and become the next parser state.
*/
var $stateStack;
/**
* The path stack is a stack of associative arrays with the following elements:
* name The name of top level of the path
* level The level (number of elements) of the path
* startByte The byte offset of the start of the path
* startToken The token offset of the start
* endByte The byte offset of thee
* endToken The token offset of the end, plus one
* valueStartToken The start token offset of the value part
* valueStartByte The start byte offset of the value part
* valueEndToken The end token offset of the value part, plus one
* valueEndByte The end byte offset of the value part, plus one
* nextArrayIndex The next numeric array index at this level
* hasComma True if the array element ends with a comma
* arrowByte The byte offset of the "=>", or false if there isn't one
*/
var $pathStack;
/**
* The elements of the top of the pathStack for every path encountered, indexed
* by slash-separated path.
*/
var $pathInfo;
/**
* Next serial number for whitespace placeholder paths (\@extra-N)
*/
var $serial;
/**
* Editor state. This consists of the internal copy/insert operations which
* are applied to the source string to obtain the destination string.
*/
var $edits;
/**
* Simple entry point for command-line testing
*
* @param $text string
*
* @return string
*/
static function test( $text ) {
try {
$ce = new self( $text );
$ce->parse();
} catch ( ConfEditorParseError $e ) {
return $e->getMessage() . "\n" . $e->highlight( $text );
}
return "OK";
}
/**
* Construct a new parser
*/
public function __construct( $text ) {
$this->text = $text;
}
/**
* Edit the text. Returns the edited text.
* @param array $ops of operations.
*
* Operations are given as an associative array, with members:
* type: One of delete, set, append or insert (required)
* path: The path to operate on (required)
* key: The array key to insert/append, with PHP quotes
* value: The value, with PHP quotes
*
* delete
* Deletes an array element or statement with the specified path.
* e.g.
* array('type' => 'delete', 'path' => '$foo/bar/baz' )
* is equivalent to the runtime PHP code:
* unset( $foo['bar']['baz'] );
*
* set
* Sets the value of an array element. If the element doesn't exist, it
* is appended to the array. If it does exist, the value is set, with
* comments and indenting preserved.
*
* append
* Appends a new element to the end of the array. Adds a trailing comma.
* e.g.
* array( 'type' => 'append', 'path', '$foo/bar',
* 'key' => 'baz', 'value' => "'x'" )
* is like the PHP code:
* $foo['bar']['baz'] = 'x';
*
* insert
* Insert a new element at the start of the array.
*
* @throws MWException
* @return string
*/
public function edit( $ops ) {
$this->parse();
$this->edits = array(
array( 'copy', 0, strlen( $this->text ) )
);
foreach ( $ops as $op ) {
$type = $op['type'];
$path = $op['path'];
$value = isset( $op['value'] ) ? $op['value'] : null;
$key = isset( $op['key'] ) ? $op['key'] : null;
switch ( $type ) {
case 'delete':
list( $start, $end ) = $this->findDeletionRegion( $path );
$this->replaceSourceRegion( $start, $end, false );
break;
case 'set':
if ( isset( $this->pathInfo[$path] ) ) {
list( $start, $end ) = $this->findValueRegion( $path );
$encValue = $value; // var_export( $value, true );
$this->replaceSourceRegion( $start, $end, $encValue );
break;
}
// No existing path, fall through to append
$slashPos = strrpos( $path, '/' );
$key = var_export( substr( $path, $slashPos + 1 ), true );
$path = substr( $path, 0, $slashPos );
// Fall through
case 'append':
// Find the last array element
$lastEltPath = $this->findLastArrayElement( $path );
if ( $lastEltPath === false ) {
throw new MWException( "Can't find any element of array \"$path\"" );
}
$lastEltInfo = $this->pathInfo[$lastEltPath];
// Has it got a comma already?
if ( strpos( $lastEltPath, '@extra' ) === false && !$lastEltInfo['hasComma'] ) {
// No comma, insert one after the value region
list( , $end ) = $this->findValueRegion( $lastEltPath );
$this->replaceSourceRegion( $end - 1, $end - 1, ',' );
}
// Make the text to insert
list( $start, $end ) = $this->findDeletionRegion( $lastEltPath );
if ( $key === null ) {
list( $indent, ) = $this->getIndent( $start );
$textToInsert = "$indent$value,";
} else {
list( $indent, $arrowIndent ) =
$this->getIndent( $start, $key, $lastEltInfo['arrowByte'] );
$textToInsert = "$indent$key$arrowIndent=> $value,";
}
$textToInsert .= ( $indent === false ? ' ' : "\n" );
// Insert the item
$this->replaceSourceRegion( $end, $end, $textToInsert );
break;
case 'insert':
// Find first array element
$firstEltPath = $this->findFirstArrayElement( $path );
if ( $firstEltPath === false ) {
throw new MWException( "Can't find array element of \"$path\"" );
}
list( $start, ) = $this->findDeletionRegion( $firstEltPath );
$info = $this->pathInfo[$firstEltPath];
// Make the text to insert
if ( $key === null ) {
list( $indent, ) = $this->getIndent( $start );
$textToInsert = "$indent$value,";
} else {
list( $indent, $arrowIndent ) =
$this->getIndent( $start, $key, $info['arrowByte'] );
$textToInsert = "$indent$key$arrowIndent=> $value,";
}
$textToInsert .= ( $indent === false ? ' ' : "\n" );
// Insert the item
$this->replaceSourceRegion( $start, $start, $textToInsert );
break;
default:
throw new MWException( "Unrecognised operation: \"$type\"" );
}
}
// Do the edits
$out = '';
foreach ( $this->edits as $edit ) {
if ( $edit[0] == 'copy' ) {
$out .= substr( $this->text, $edit[1], $edit[2] - $edit[1] );
} else { // if ( $edit[0] == 'insert' )
$out .= $edit[1];
}
}
// Do a second parse as a sanity check
$this->text = $out;
try {
$this->parse();
} catch ( ConfEditorParseError $e ) {
throw new MWException(
"Sorry, ConfEditor broke the file during editing and it won't parse anymore: " .
$e->getMessage() );
}
return $out;
}
/**
* Get the variables defined in the text
* @return array( varname => value )
*/
function getVars() {
$vars = array();
$this->parse();
foreach( $this->pathInfo as $path => $data ) {
if ( $path[0] != '$' )
continue;
$trimmedPath = substr( $path, 1 );
$name = $data['name'];
if ( $name[0] == '@' )
continue;
if ( $name[0] == '$' )
$name = substr( $name, 1 );
$parentPath = substr( $trimmedPath, 0,
strlen( $trimmedPath ) - strlen( $name ) );
if( substr( $parentPath, -1 ) == '/' )
$parentPath = substr( $parentPath, 0, -1 );
$value = substr( $this->text, $data['valueStartByte'],
$data['valueEndByte'] - $data['valueStartByte']
);
$this->setVar( $vars, $parentPath, $name,
$this->parseScalar( $value ) );
}
return $vars;
}
/**
* Set a value in an array, unless it's set already. For instance,
* setVar( $arr, 'foo/bar', 'baz', 3 ); will set
* $arr['foo']['bar']['baz'] = 3;
* @param $array array
* @param string $path slash-delimited path
* @param $key mixed Key
* @param $value mixed Value
*/
function setVar( &$array, $path, $key, $value ) {
$pathArr = explode( '/', $path );
$target =& $array;
if ( $path !== '' ) {
foreach ( $pathArr as $p ) {
if( !isset( $target[$p] ) )
$target[$p] = array();
$target =& $target[$p];
}
}
if ( !isset( $target[$key] ) )
$target[$key] = $value;
}
/**
* Parse a scalar value in PHP
* @return mixed Parsed value
*/
function parseScalar( $str ) {
if ( $str !== '' && $str[0] == '\'' )
// Single-quoted string
// @todo FIXME: trim() call is due to mystery bug where whitespace gets
// appended to the token; without it we ended up reading in the
// extra quote on the end!
return strtr( substr( trim( $str ), 1, -1 ),
array( '\\\'' => '\'', '\\\\' => '\\' ) );
if ( $str !== '' && $str[0] == '"' )
// Double-quoted string
// @todo FIXME: trim() call is due to mystery bug where whitespace gets
// appended to the token; without it we ended up reading in the
// extra quote on the end!
return stripcslashes( substr( trim( $str ), 1, -1 ) );
if ( substr( $str, 0, 4 ) == 'true' )
return true;
if ( substr( $str, 0, 5 ) == 'false' )
return false;
if ( substr( $str, 0, 4 ) == 'null' )
return null;
// Must be some kind of numeric value, so let PHP's weak typing
// be useful for a change
return $str;
}
/**
* Replace the byte offset region of the source with $newText.
* Works by adding elements to the $this->edits array.
*/
function replaceSourceRegion( $start, $end, $newText = false ) {
// Split all copy operations with a source corresponding to the region
// in question.
$newEdits = array();
foreach ( $this->edits as $edit ) {
if ( $edit[0] !== 'copy' ) {
$newEdits[] = $edit;
continue;
}
$copyStart = $edit[1];
$copyEnd = $edit[2];
if ( $start >= $copyEnd || $end <= $copyStart ) {
// Outside this region
$newEdits[] = $edit;
continue;
}
if ( ( $start < $copyStart && $end > $copyStart )
|| ( $start < $copyEnd && $end > $copyEnd )
) {
throw new MWException( "Overlapping regions found, can't do the edit" );
}
// Split the copy
$newEdits[] = array( 'copy', $copyStart, $start );
if ( $newText !== false ) {
$newEdits[] = array( 'insert', $newText );
}
$newEdits[] = array( 'copy', $end, $copyEnd );
}
$this->edits = $newEdits;
}
/**
* Finds the source byte region which you would want to delete, if $pathName
* was to be deleted. Includes the leading spaces and tabs, the trailing line
* break, and any comments in between.
* @param $pathName
* @throws MWException
* @return array
*/
function findDeletionRegion( $pathName ) {
if ( !isset( $this->pathInfo[$pathName] ) ) {
throw new MWException( "Can't find path \"$pathName\"" );
}
$path = $this->pathInfo[$pathName];
// Find the start
$this->firstToken();
while ( $this->pos != $path['startToken'] ) {
$this->nextToken();
}
$regionStart = $path['startByte'];
for ( $offset = -1; $offset >= -$this->pos; $offset-- ) {
$token = $this->getTokenAhead( $offset );
if ( !$token->isSkip() ) {
// If there is other content on the same line, don't move the start point
// back, because that will cause the regions to overlap.
$regionStart = $path['startByte'];
break;
}
$lfPos = strrpos( $token->text, "\n" );
if ( $lfPos === false ) {
$regionStart -= strlen( $token->text );
} else {
// The line start does not include the LF
$regionStart -= strlen( $token->text ) - $lfPos - 1;
break;
}
}
// Find the end
while ( $this->pos != $path['endToken'] ) {
$this->nextToken();
}
$regionEnd = $path['endByte']; // past the end
for ( $offset = 0; $offset < count( $this->tokens ) - $this->pos; $offset++ ) {
$token = $this->getTokenAhead( $offset );
if ( !$token->isSkip() ) {
break;
}
$lfPos = strpos( $token->text, "\n" );
if ( $lfPos === false ) {
$regionEnd += strlen( $token->text );
} else {
// This should point past the LF
$regionEnd += $lfPos + 1;
break;
}
}
return array( $regionStart, $regionEnd );
}
/**
* Find the byte region in the source corresponding to the value part.
* This includes the quotes, but does not include the trailing comma
* or semicolon.
*
* The end position is the past-the-end (end + 1) value as per convention.
* @param $pathName
* @throws MWException
* @return array
*/
function findValueRegion( $pathName ) {
if ( !isset( $this->pathInfo[$pathName] ) ) {
throw new MWException( "Can't find path \"$pathName\"" );
}
$path = $this->pathInfo[$pathName];
if ( $path['valueStartByte'] === false || $path['valueEndByte'] === false ) {
throw new MWException( "Can't find value region for path \"$pathName\"" );
}
return array( $path['valueStartByte'], $path['valueEndByte'] );
}
/**
* Find the path name of the last element in the array.
* If the array is empty, this will return the \@extra interstitial element.
* If the specified path is not found or is not an array, it will return false.
* @return bool|int|string
*/
function findLastArrayElement( $path ) {
// Try for a real element
$lastEltPath = false;
foreach ( $this->pathInfo as $candidatePath => $info ) {
$part1 = substr( $candidatePath, 0, strlen( $path ) + 1 );
$part2 = substr( $candidatePath, strlen( $path ) + 1, 1 );
if ( $part2 == '@' ) {
// Do nothing
} elseif ( $part1 == "$path/" ) {
$lastEltPath = $candidatePath;
} elseif ( $lastEltPath !== false ) {
break;
}
}
if ( $lastEltPath !== false ) {
return $lastEltPath;
}
// Try for an interstitial element
$extraPath = false;
foreach ( $this->pathInfo as $candidatePath => $info ) {
$part1 = substr( $candidatePath, 0, strlen( $path ) + 1 );
if ( $part1 == "$path/" ) {
$extraPath = $candidatePath;
} elseif ( $extraPath !== false ) {
break;
}
}
return $extraPath;
}
/**
* Find the path name of first element in the array.
* If the array is empty, this will return the \@extra interstitial element.
* If the specified path is not found or is not an array, it will return false.
* @return bool|int|string
*/
function findFirstArrayElement( $path ) {
// Try for an ordinary element
foreach ( $this->pathInfo as $candidatePath => $info ) {
$part1 = substr( $candidatePath, 0, strlen( $path ) + 1 );
$part2 = substr( $candidatePath, strlen( $path ) + 1, 1 );
if ( $part1 == "$path/" && $part2 != '@' ) {
return $candidatePath;
}
}
// Try for an interstitial element
foreach ( $this->pathInfo as $candidatePath => $info ) {
$part1 = substr( $candidatePath, 0, strlen( $path ) + 1 );
if ( $part1 == "$path/" ) {
return $candidatePath;
}
}
return false;
}
/**
* Get the indent string which sits after a given start position.
* Returns false if the position is not at the start of the line.
* @return array
*/
function getIndent( $pos, $key = false, $arrowPos = false ) {
$arrowIndent = ' ';
if ( $pos == 0 || $this->text[$pos-1] == "\n" ) {
$indentLength = strspn( $this->text, " \t", $pos );
$indent = substr( $this->text, $pos, $indentLength );
} else {
$indent = false;
}
if ( $indent !== false && $arrowPos !== false ) {
$arrowIndentLength = $arrowPos - $pos - $indentLength - strlen( $key );
if ( $arrowIndentLength > 0 ) {
$arrowIndent = str_repeat( ' ', $arrowIndentLength );
}
}
return array( $indent, $arrowIndent );
}
/**
* Run the parser on the text. Throws an exception if the string does not
* match our defined subset of PHP syntax.
*/
public function parse() {
$this->initParse();
$this->pushState( 'file' );
$this->pushPath( '@extra-' . ($this->serial++) );
$token = $this->firstToken();
while ( !$token->isEnd() ) {
$state = $this->popState();
if ( !$state ) {
$this->error( 'internal error: empty state stack' );
}
switch ( $state ) {
case 'file':
$this->expect( T_OPEN_TAG );
$token = $this->skipSpace();
if ( $token->isEnd() ) {
break 2;
}
$this->pushState( 'statement', 'file 2' );
break;
case 'file 2':
$token = $this->skipSpace();
if ( $token->isEnd() ) {
break 2;
}
$this->pushState( 'statement', 'file 2' );
break;
case 'statement':
$token = $this->skipSpace();
if ( !$this->validatePath( $token->text ) ) {
$this->error( "Invalid variable name \"{$token->text}\"" );
}
$this->nextPath( $token->text );
$this->expect( T_VARIABLE );
$this->skipSpace();
$arrayAssign = false;
if ( $this->currentToken()->type == '[' ) {
$this->nextToken();
$token = $this->skipSpace();
if ( !$token->isScalar() ) {
$this->error( "expected a string or number for the array key" );
}
if ( $token->type == T_CONSTANT_ENCAPSED_STRING ) {
$text = $this->parseScalar( $token->text );
} else {
$text = $token->text;
}
if ( !$this->validatePath( $text ) ) {
$this->error( "Invalid associative array name \"$text\"" );
}
$this->pushPath( $text );
$this->nextToken();
$this->skipSpace();
$this->expect( ']' );
$this->skipSpace();
$arrayAssign = true;
}
$this->expect( '=' );
$this->skipSpace();
$this->startPathValue();
if ( $arrayAssign )
$this->pushState( 'expression', 'array assign end' );
else
$this->pushState( 'expression', 'statement end' );
break;
case 'array assign end':
case 'statement end':
$this->endPathValue();
if ( $state == 'array assign end' )
$this->popPath();
$this->skipSpace();
$this->expect( ';' );
$this->nextPath( '@extra-' . ($this->serial++) );
break;
case 'expression':
$token = $this->skipSpace();
if ( $token->type == T_ARRAY ) {
$this->pushState( 'array' );
} elseif ( $token->isScalar() ) {
$this->nextToken();
} elseif ( $token->type == T_VARIABLE ) {
$this->nextToken();
} else {
$this->error( "expected simple expression" );
}
break;
case 'array':
$this->skipSpace();
$this->expect( T_ARRAY );
$this->skipSpace();
$this->expect( '(' );
$this->skipSpace();
$this->pushPath( '@extra-' . ($this->serial++) );
if ( $this->isAhead( ')' ) ) {
// Empty array
$this->pushState( 'array end' );
} else {
$this->pushState( 'element', 'array end' );
}
break;
case 'array end':
$this->skipSpace();
$this->popPath();
$this->expect( ')' );
break;
case 'element':
$token = $this->skipSpace();
// Look ahead to find the double arrow
if ( $token->isScalar() && $this->isAhead( T_DOUBLE_ARROW, 1 ) ) {
// Found associative element
$this->pushState( 'assoc-element', 'element end' );
} else {
// Not associative
$this->nextPath( '@next' );
$this->startPathValue();
$this->pushState( 'expression', 'element end' );
}
break;
case 'element end':
$token = $this->skipSpace();
if ( $token->type == ',' ) {
$this->endPathValue();
$this->markComma();
$this->nextToken();
$this->nextPath( '@extra-' . ($this->serial++) );
// Look ahead to find ending bracket
if ( $this->isAhead( ")" ) ) {
// Found ending bracket, no continuation
$this->skipSpace();
} else {
// No ending bracket, continue to next element
$this->pushState( 'element' );
}
} elseif ( $token->type == ')' ) {
// End array
$this->endPathValue();
} else {
$this->error( "expected the next array element or the end of the array" );
}
break;
case 'assoc-element':
$token = $this->skipSpace();
if ( !$token->isScalar() ) {
$this->error( "expected a string or number for the array key" );
}
if ( $token->type == T_CONSTANT_ENCAPSED_STRING ) {
$text = $this->parseScalar( $token->text );
} else {
$text = $token->text;
}
if ( !$this->validatePath( $text ) ) {
$this->error( "Invalid associative array name \"$text\"" );
}
$this->nextPath( $text );
$this->nextToken();
$this->skipSpace();
$this->markArrow();
$this->expect( T_DOUBLE_ARROW );
$this->skipSpace();
$this->startPathValue();
$this->pushState( 'expression' );
break;
}
}
if ( count( $this->stateStack ) ) {
$this->error( 'unexpected end of file' );
}
$this->popPath();
}
/**
* Initialise a parse.
*/
protected function initParse() {
$this->tokens = token_get_all( $this->text );
$this->stateStack = array();
$this->pathStack = array();
$this->firstToken();
$this->pathInfo = array();
$this->serial = 1;
}
/**
* Set the parse position. Do not call this except from firstToken() and
* nextToken(), there is more to update than just the position.
*/
protected function setPos( $pos ) {
$this->pos = $pos;
if ( $this->pos >= count( $this->tokens ) ) {
$this->currentToken = ConfEditorToken::newEnd();
} else {
$this->currentToken = $this->newTokenObj( $this->tokens[$this->pos] );
}
return $this->currentToken;
}
/**
* Create a ConfEditorToken from an element of token_get_all()
* @return ConfEditorToken
*/
function newTokenObj( $internalToken ) {
if ( is_array( $internalToken ) ) {
return new ConfEditorToken( $internalToken[0], $internalToken[1] );
} else {
return new ConfEditorToken( $internalToken, $internalToken );
}
}
/**
* Reset the parse position
*/
function firstToken() {
$this->setPos( 0 );
$this->prevToken = ConfEditorToken::newEnd();
$this->lineNum = 1;
$this->colNum = 1;
$this->byteNum = 0;
return $this->currentToken;
}
/**
* Get the current token
*/
function currentToken() {
return $this->currentToken;
}
/**
* Advance the current position and return the resulting next token
*/
function nextToken() {
if ( $this->currentToken ) {
$text = $this->currentToken->text;
$lfCount = substr_count( $text, "\n" );
if ( $lfCount ) {
$this->lineNum += $lfCount;
$this->colNum = strlen( $text ) - strrpos( $text, "\n" );
} else {
$this->colNum += strlen( $text );
}
$this->byteNum += strlen( $text );
}
$this->prevToken = $this->currentToken;
$this->setPos( $this->pos + 1 );
return $this->currentToken;
}
/**
* Get the token $offset steps ahead of the current position.
* $offset may be negative, to get tokens behind the current position.
* @return ConfEditorToken
*/
function getTokenAhead( $offset ) {
$pos = $this->pos + $offset;
if ( $pos >= count( $this->tokens ) || $pos < 0 ) {
return ConfEditorToken::newEnd();
} else {
return $this->newTokenObj( $this->tokens[$pos] );
}
}
/**
* Advances the current position past any whitespace or comments
*/
function skipSpace() {
while ( $this->currentToken && $this->currentToken->isSkip() ) {
$this->nextToken();
}
return $this->currentToken;
}
/**
* Throws an error if the current token is not of the given type, and
* then advances to the next position.
*/
function expect( $type ) {
if ( $this->currentToken && $this->currentToken->type == $type ) {
return $this->nextToken();
} else {
$this->error( "expected " . $this->getTypeName( $type ) .
", got " . $this->getTypeName( $this->currentToken->type ) );
}
}
/**
* Push a state or two on to the state stack.
*/
function pushState( $nextState, $stateAfterThat = null ) {
if ( $stateAfterThat !== null ) {
$this->stateStack[] = $stateAfterThat;
}
$this->stateStack[] = $nextState;
}
/**
* Pop a state from the state stack.
* @return mixed
*/
function popState() {
return array_pop( $this->stateStack );
}
/**
* Returns true if the user input path is valid.
* This exists to allow "/" and "@" to be reserved for string path keys
* @return bool
*/
function validatePath( $path ) {
return strpos( $path, '/' ) === false && substr( $path, 0, 1 ) != '@';
}
/**
* Internal function to update some things at the end of a path region. Do
* not call except from popPath() or nextPath().
*/
function endPath() {
$key = '';
foreach ( $this->pathStack as $pathInfo ) {
if ( $key !== '' ) {
$key .= '/';
}
$key .= $pathInfo['name'];
}
$pathInfo['endByte'] = $this->byteNum;
$pathInfo['endToken'] = $this->pos;
$this->pathInfo[$key] = $pathInfo;
}
/**
* Go up to a new path level, for example at the start of an array.
*/
function pushPath( $path ) {
$this->pathStack[] = array(
'name' => $path,
'level' => count( $this->pathStack ) + 1,
'startByte' => $this->byteNum,
'startToken' => $this->pos,
'valueStartToken' => false,
'valueStartByte' => false,
'valueEndToken' => false,
'valueEndByte' => false,
'nextArrayIndex' => 0,
'hasComma' => false,
'arrowByte' => false
);
}
/**
* Go down a path level, for example at the end of an array.
*/
function popPath() {
$this->endPath();
array_pop( $this->pathStack );
}
/**
* Go to the next path on the same level. This ends the current path and
* starts a new one. If $path is \@next, the new path is set to the next
* numeric array element.
*/
function nextPath( $path ) {
$this->endPath();
$i = count( $this->pathStack ) - 1;
if ( $path == '@next' ) {
$nextArrayIndex =& $this->pathStack[$i]['nextArrayIndex'];
$this->pathStack[$i]['name'] = $nextArrayIndex;
$nextArrayIndex++;
} else {
$this->pathStack[$i]['name'] = $path;
}
$this->pathStack[$i] =
array(
'startByte' => $this->byteNum,
'startToken' => $this->pos,
'valueStartToken' => false,
'valueStartByte' => false,
'valueEndToken' => false,
'valueEndByte' => false,
'hasComma' => false,
'arrowByte' => false,
) + $this->pathStack[$i];
}
/**
* Mark the start of the value part of a path.
*/
function startPathValue() {
$path =& $this->pathStack[count( $this->pathStack ) - 1];
$path['valueStartToken'] = $this->pos;
$path['valueStartByte'] = $this->byteNum;
}
/**
* Mark the end of the value part of a path.
*/
function endPathValue() {
$path =& $this->pathStack[count( $this->pathStack ) - 1];
$path['valueEndToken'] = $this->pos;
$path['valueEndByte'] = $this->byteNum;
}
/**
* Mark the comma separator in an array element
*/
function markComma() {
$path =& $this->pathStack[count( $this->pathStack ) - 1];
$path['hasComma'] = true;
}
/**
* Mark the arrow separator in an associative array element
*/
function markArrow() {
$path =& $this->pathStack[count( $this->pathStack ) - 1];
$path['arrowByte'] = $this->byteNum;
}
/**
* Generate a parse error
*/
function error( $msg ) {
throw new ConfEditorParseError( $this, $msg );
}
/**
* Get a readable name for the given token type.
* @return string
*/
function getTypeName( $type ) {
if ( is_int( $type ) ) {
return token_name( $type );
} else {
return "\"$type\"";
}
}
/**
* Looks ahead to see if the given type is the next token type, starting
* from the current position plus the given offset. Skips any intervening
* whitespace.
* @return bool
*/
function isAhead( $type, $offset = 0 ) {
$ahead = $offset;
$token = $this->getTokenAhead( $offset );
while ( !$token->isEnd() ) {
if ( $token->isSkip() ) {
$ahead++;
$token = $this->getTokenAhead( $ahead );
continue;
} elseif ( $token->type == $type ) {
// Found the type
return true;
} else {
// Not found
return false;
}
}
return false;
}
/**
* Get the previous token object
*/
function prevToken() {
return $this->prevToken;
}
/**
* Echo a reasonably readable representation of the tokenizer array.
*/
function dumpTokens() {
$out = '';
foreach ( $this->tokens as $token ) {
$obj = $this->newTokenObj( $token );
$out .= sprintf( "%-28s %s\n",
$this->getTypeName( $obj->type ),
addcslashes( $obj->text, "\0..\37" ) );
}
echo "<pre>" . htmlspecialchars( $out ) . "</pre>";
}
}
/**
* Exception class for parse errors
*/
class ConfEditorParseError extends MWException {
var $lineNum, $colNum;
function __construct( $editor, $msg ) {
$this->lineNum = $editor->lineNum;
$this->colNum = $editor->colNum;
parent::__construct( "Parse error on line {$editor->lineNum} " .
"col {$editor->colNum}: $msg" );
}
function highlight( $text ) {
$lines = StringUtils::explode( "\n", $text );
foreach ( $lines as $lineNum => $line ) {
if ( $lineNum == $this->lineNum - 1 ) {
return "$line\n" .str_repeat( ' ', $this->colNum - 1 ) . "^\n";
}
}
return '';
}
}
/**
* Class to wrap a token from the tokenizer.
*/
class ConfEditorToken {
var $type, $text;
static $scalarTypes = array( T_LNUMBER, T_DNUMBER, T_STRING, T_CONSTANT_ENCAPSED_STRING );
static $skipTypes = array( T_WHITESPACE, T_COMMENT, T_DOC_COMMENT );
static function newEnd() {
return new self( 'END', '' );
}
function __construct( $type, $text ) {
$this->type = $type;
$this->text = $text;
}
function isSkip() {
return in_array( $this->type, self::$skipTypes );
}
function isScalar() {
return in_array( $this->type, self::$scalarTypes );
}
function isEnd() {
return $this->type == 'END';
}
}