2012-04-13 10:38:12 +00:00
|
|
|
<?php
|
|
|
|
|
|
|
|
abstract class Scribunto_LuaEngine extends ScribuntoEngineBase {
|
2013-02-15 23:41:20 +00:00
|
|
|
/**
|
|
|
|
* Libraries to load. See also the 'ScribuntoExternalLibraries' hook.
|
|
|
|
* @var array Maps module names to PHP classes
|
|
|
|
*/
|
2013-02-14 17:38:03 +00:00
|
|
|
protected static $libraryClasses = array(
|
2013-02-01 20:48:18 +00:00
|
|
|
'mw.site' => 'Scribunto_LuaSiteLibrary',
|
2013-01-26 00:09:50 +00:00
|
|
|
'mw.uri' => 'Scribunto_LuaUriLibrary',
|
2012-12-11 02:53:43 +00:00
|
|
|
'mw.ustring' => 'Scribunto_LuaUstringLibrary',
|
2013-01-25 19:03:04 +00:00
|
|
|
'mw.language' => 'Scribunto_LuaLanguageLibrary',
|
2013-02-08 14:56:44 +00:00
|
|
|
'mw.message' => 'Scribunto_LuaMessageLibrary',
|
2013-02-07 17:50:21 +00:00
|
|
|
'mw.title' => 'Scribunto_LuaTitleLibrary',
|
2013-01-25 17:53:18 +00:00
|
|
|
);
|
|
|
|
|
2013-02-15 23:41:20 +00:00
|
|
|
/**
|
|
|
|
* Paths for modules that may be loaded from Lua. See also the
|
|
|
|
* 'ScribuntoExternalLibraryPaths' hook.
|
|
|
|
* @var array Paths
|
|
|
|
*/
|
2013-02-14 17:38:03 +00:00
|
|
|
protected static $libraryPaths = array(
|
|
|
|
'.',
|
|
|
|
'luabit',
|
|
|
|
'ustring',
|
|
|
|
);
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
protected $loaded = false;
|
|
|
|
protected $executeModuleFunc, $interpreter;
|
2012-05-22 03:56:07 +00:00
|
|
|
protected $mw;
|
2013-02-19 00:49:08 +00:00
|
|
|
protected $currentFrames = array();
|
2012-05-22 03:56:07 +00:00
|
|
|
protected $expandCache = array();
|
2013-01-25 17:53:18 +00:00
|
|
|
protected $loadedLibraries = array();
|
2012-05-22 03:56:07 +00:00
|
|
|
|
|
|
|
const MAX_EXPAND_CACHE_SIZE = 100;
|
2012-04-13 10:38:12 +00:00
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
|
|
|
* Create a new interpreter object
|
2013-02-15 23:41:20 +00:00
|
|
|
* @return Scribunto_LuaInterpreter
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
*/
|
2012-04-13 10:38:12 +00:00
|
|
|
abstract function newInterpreter();
|
|
|
|
|
|
|
|
protected function newModule( $text, $chunkName ) {
|
|
|
|
return new Scribunto_LuaModule( $this, $text, $chunkName );
|
|
|
|
}
|
|
|
|
|
2012-04-23 11:36:13 +00:00
|
|
|
public function newLuaError( $message, $params = array() ) {
|
|
|
|
return new Scribunto_LuaError( $message, $this->getDefaultExceptionParams() + $params );
|
|
|
|
}
|
|
|
|
|
2012-09-05 09:39:58 +00:00
|
|
|
public function destroy() {
|
|
|
|
// Break reference cycles
|
|
|
|
$this->interpreter = null;
|
|
|
|
$this->executeModuleFunc = null;
|
|
|
|
$this->mw = null;
|
|
|
|
$this->expandCache = null;
|
2013-02-17 23:38:48 +00:00
|
|
|
$this->loadedLibraries = null;
|
2012-09-05 09:39:58 +00:00
|
|
|
parent::destroy();
|
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
|
|
|
* Initialise the interpreter and the base environment
|
|
|
|
*/
|
2012-04-13 10:38:12 +00:00
|
|
|
public function load() {
|
|
|
|
if( $this->loaded ) {
|
|
|
|
return;
|
|
|
|
}
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
$this->loaded = true;
|
2012-04-13 10:38:12 +00:00
|
|
|
|
|
|
|
$this->interpreter = $this->newInterpreter();
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
|
2013-01-25 17:53:18 +00:00
|
|
|
$funcs = array(
|
|
|
|
'loadPackage',
|
2013-02-19 00:49:08 +00:00
|
|
|
'frameExists',
|
|
|
|
'newChildFrame',
|
2013-01-25 17:53:18 +00:00
|
|
|
'getExpandedArgument',
|
|
|
|
'getAllExpandedArguments',
|
|
|
|
'expandTemplate',
|
2013-03-04 05:42:17 +00:00
|
|
|
'callParserFunction',
|
2013-02-01 20:43:32 +00:00
|
|
|
'preprocess',
|
|
|
|
'incrementExpensiveFunctionCount',
|
2013-01-25 17:53:18 +00:00
|
|
|
);
|
|
|
|
|
|
|
|
$lib = array();
|
|
|
|
foreach ( $funcs as $name ) {
|
|
|
|
$lib[$name] = array( $this, $name );
|
|
|
|
}
|
2012-05-22 03:56:07 +00:00
|
|
|
|
2013-01-25 17:53:18 +00:00
|
|
|
$this->mw = $this->registerInterface( 'mw.lua', $lib,
|
2012-05-23 06:51:59 +00:00
|
|
|
array( 'allowEnvFuncs' => $this->options['allowEnvFuncs'] ) );
|
2013-01-25 17:53:18 +00:00
|
|
|
|
2013-02-14 17:38:03 +00:00
|
|
|
$libraries = $this->getLibraries( 'lua', self::$libraryClasses );
|
|
|
|
foreach ( $libraries as $name => $class ) {
|
2013-01-25 17:53:18 +00:00
|
|
|
$this->loadedLibraries[$name] = new $class( $this );
|
|
|
|
$this->loadedLibraries[$name]->register();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-15 23:41:20 +00:00
|
|
|
/**
|
|
|
|
* Register a Lua Library
|
|
|
|
*
|
|
|
|
* This should be called from the library's PHP module's register() method.
|
|
|
|
*
|
|
|
|
* The value for $interfaceFuncs is used to populate the mw_interface
|
|
|
|
* global that is defined when the library's Lua module is loaded. Values
|
|
|
|
* must be PHP callables, which will be seen in Lua as functions.
|
|
|
|
*
|
|
|
|
* @param $moduleFileName string The path to the Lua portion of the library
|
|
|
|
* (absolute, or relative to $this->getLuaLibDir())
|
|
|
|
* @param $interfaceFuncs array Populates mw_interface
|
|
|
|
* @param $setupOptions array Passed to the modules setupInterface() method.
|
|
|
|
* @return Lua package
|
|
|
|
*/
|
2013-01-25 17:53:18 +00:00
|
|
|
public function registerInterface( $moduleFileName, $interfaceFuncs, $setupOptions = array() ) {
|
|
|
|
$this->interpreter->registerLibrary( 'mw_interface', $interfaceFuncs );
|
2013-02-14 17:38:03 +00:00
|
|
|
$moduleFileName = $this->normalizeModuleFileName( $moduleFileName );
|
|
|
|
$package = $this->loadLibraryFromFile( $moduleFileName );
|
2013-01-25 17:53:18 +00:00
|
|
|
if ( $package['setupInterface'] ) {
|
|
|
|
$this->interpreter->callFunction( $package['setupInterface'], $setupOptions );
|
|
|
|
}
|
|
|
|
return $package;
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
2013-02-15 23:41:20 +00:00
|
|
|
/**
|
|
|
|
* Return the base path for Lua modules.
|
|
|
|
* @return string
|
|
|
|
*/
|
2012-09-05 09:39:58 +00:00
|
|
|
public function getLuaLibDir() {
|
|
|
|
return dirname( __FILE__ ) .'/lualib';
|
|
|
|
}
|
|
|
|
|
2013-02-14 17:38:03 +00:00
|
|
|
/**
|
|
|
|
* Normalize a lua module to its full path. If path does not begin with "/",
|
|
|
|
* prepend getLuaLibDir()
|
|
|
|
*
|
|
|
|
* @param $file String name of the lua module file
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
protected function normalizeModuleFileName( $fileName ) {
|
2013-03-14 14:09:11 +00:00
|
|
|
return $fileName[0] !== DIRECTORY_SEPARATOR ? "{$this->getLuaLibDir()}/{$fileName}" : $fileName;
|
2013-02-14 17:38:03 +00:00
|
|
|
}
|
|
|
|
|
2013-01-25 17:53:18 +00:00
|
|
|
/**
|
|
|
|
* Get performance characteristics of the Lua engine/interpreter
|
|
|
|
*
|
|
|
|
* phpCallsRequireSerialization: boolean
|
|
|
|
* whether calls between PHP and Lua functions require (slow)
|
|
|
|
* serialization of parameters and return values
|
2013-02-15 23:41:20 +00:00
|
|
|
*
|
|
|
|
* @return array
|
2013-01-25 17:53:18 +00:00
|
|
|
*/
|
|
|
|
public abstract function getPerformanceCharacteristics();
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
|
|
|
* Get the current interpreter object
|
2013-02-15 23:41:20 +00:00
|
|
|
* @return Scribunto_LuaInterpreter
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
*/
|
|
|
|
public function getInterpreter() {
|
|
|
|
$this->load();
|
|
|
|
return $this->interpreter;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Execute a module chunk in a new isolated environment
|
|
|
|
*/
|
2012-04-13 10:38:12 +00:00
|
|
|
public function executeModule( $chunk ) {
|
2012-05-22 03:56:07 +00:00
|
|
|
return $this->getInterpreter()->callFunction( $this->mw['executeModule'], $chunk );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Execute a module function chunk
|
|
|
|
*/
|
|
|
|
public function executeFunctionChunk( $chunk, $frame ) {
|
2013-02-19 00:49:08 +00:00
|
|
|
$oldFrames = $this->currentFrames;
|
|
|
|
$this->currentFrames = array(
|
|
|
|
'current' => $frame,
|
|
|
|
'parent' => isset( $frame->parent ) ? $frame->parent : null,
|
|
|
|
);
|
|
|
|
try {
|
|
|
|
$result = $this->getInterpreter()->callFunction(
|
|
|
|
$this->mw['executeFunction'],
|
|
|
|
$chunk );
|
|
|
|
} catch ( Exception $ex ) {
|
|
|
|
$this->currentFrames = $oldFrames;
|
|
|
|
throw $ex;
|
|
|
|
}
|
|
|
|
$this->currentFrames = $oldFrames;
|
2012-05-22 03:56:07 +00:00
|
|
|
return $result;
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
|
|
|
* Load a library from the given file and execute it in the base environment.
|
2013-02-15 23:41:20 +00:00
|
|
|
* @param string File name/path to load
|
|
|
|
* @return mixed the export list, or null if there isn't one.
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
*/
|
2012-04-13 10:38:12 +00:00
|
|
|
protected function loadLibraryFromFile( $fileName ) {
|
|
|
|
$code = file_get_contents( $fileName );
|
|
|
|
if ( $code === false ) {
|
|
|
|
throw new MWException( 'Lua file does not exist: ' . $fileName );
|
|
|
|
}
|
2012-04-19 07:40:56 +00:00
|
|
|
# Prepending an "@" to the chunk name makes Lua think it is a filename
|
|
|
|
$module = $this->getInterpreter()->loadString( $code, '@' . basename( $fileName ) );
|
|
|
|
$ret = $this->getInterpreter()->callFunction( $module );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
return isset( $ret[0] ) ? $ret[0] : null;
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
public function getGeSHiLanguage() {
|
|
|
|
return 'lua';
|
|
|
|
}
|
2012-05-22 03:56:07 +00:00
|
|
|
|
2012-04-13 10:38:12 +00:00
|
|
|
public function getCodeEditorLanguage() {
|
|
|
|
return 'lua';
|
|
|
|
}
|
|
|
|
|
2012-07-14 04:23:42 +00:00
|
|
|
public function runConsole( $params ) {
|
2013-02-19 00:49:08 +00:00
|
|
|
$oldFrames = $this->currentFrames;
|
|
|
|
$this->currentFrames = array(
|
|
|
|
'current' => $this->getParser()->getPreprocessor()->newFrame(),
|
|
|
|
);
|
|
|
|
|
|
|
|
try {
|
|
|
|
/**
|
|
|
|
* TODO: provide some means for giving correct line numbers for errors
|
|
|
|
* in console input, and for producing an informative error message
|
|
|
|
* if there is an error in prevQuestions.
|
|
|
|
*
|
|
|
|
* Maybe each console line could be evaluated as a different chunk,
|
|
|
|
* apparently that's what lua.c does.
|
|
|
|
*/
|
|
|
|
$code = "return function (__init)\n" .
|
|
|
|
"local p = mw.executeModule(__init)\n" .
|
|
|
|
"local print = mw.log\n";
|
|
|
|
foreach ( $params['prevQuestions'] as $q ) {
|
|
|
|
if ( substr( $q, 0, 1 ) === '=' ) {
|
|
|
|
$code .= "print(" . substr( $q, 1 ) . ")";
|
|
|
|
} else {
|
|
|
|
$code .= $q;
|
|
|
|
}
|
|
|
|
$code .= "\n";
|
|
|
|
}
|
|
|
|
$code .= "mw.clearLogBuffer()\n";
|
|
|
|
if ( substr( $params['question'], 0, 1 ) === '=' ) {
|
|
|
|
// Treat a statement starting with "=" as a return statement, like in lua.c
|
|
|
|
$code .= "return mw.allToString(" . substr( $params['question'], 1 ) . "), mw.getLogBuffer()\n";
|
2012-07-14 04:23:42 +00:00
|
|
|
} else {
|
2013-02-19 00:49:08 +00:00
|
|
|
$code .= $params['question'] . "\n" .
|
|
|
|
"return nil, mw.getLogBuffer()\n";
|
2012-07-14 04:23:42 +00:00
|
|
|
}
|
2013-02-19 00:49:08 +00:00
|
|
|
$code .= "end\n";
|
|
|
|
|
|
|
|
$contentModule = $this->newModule(
|
|
|
|
$params['content'], $params['title']->getPrefixedDBkey() );
|
|
|
|
$contentInit = $contentModule->getInitChunk();
|
|
|
|
|
|
|
|
$consoleModule = $this->newModule(
|
|
|
|
$code,
|
|
|
|
wfMessage( 'scribunto-console-current-src' )->text()
|
|
|
|
);
|
|
|
|
$consoleInit = $consoleModule->getInitChunk();
|
|
|
|
$ret = $this->executeModule( $consoleInit );
|
|
|
|
$func = $ret[0];
|
|
|
|
$ret = $this->getInterpreter()->callFunction( $func, $contentInit );
|
|
|
|
} catch ( Exception $ex ) {
|
|
|
|
$this->currentFrames = $oldFrames;
|
|
|
|
throw $ex;
|
2012-07-14 04:23:42 +00:00
|
|
|
}
|
|
|
|
|
2013-02-19 00:49:08 +00:00
|
|
|
$this->currentFrames = $oldFrames;
|
2012-07-14 04:23:42 +00:00
|
|
|
return array(
|
|
|
|
'return' => isset( $ret[0] ) ? $ret[0] : null,
|
|
|
|
'print' => isset( $ret[1] ) ? $ret[1] : '',
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2012-04-13 10:38:12 +00:00
|
|
|
/**
|
|
|
|
* Workalike for luaL_checktype()
|
|
|
|
*
|
|
|
|
* @param $funcName The Lua function name, for use in error messages
|
|
|
|
* @param $args The argument array
|
|
|
|
* @param $index0 The zero-based argument index
|
|
|
|
* @param $type The type name as given by gettype()
|
|
|
|
* @param $msgType The type name used in the error message
|
|
|
|
*/
|
|
|
|
public function checkType( $funcName, $args, $index0, $type, $msgType ) {
|
Added tests and fixed bugs
* Added unit tests for the two Lua interpreter classes
* Fixed a bug in checkType()
* Have Scribunto_LuaSandboxInterpreter throw an exception on construct
when the extension doesn't exist, to match the standalone behaviour.
* In Scribunto_LuaSandboxInterpreter, removed debugging statements
accidentally left in.
* Convert LuaSandboxTimeoutError to the appropriate common error
message.
* Moved the option munging from the sandbox engine to the interpreter,
so that the interpreter can be unit tested separately.
* Use /bin/sh instead of bash for lua_ulimit.sh, since dash is smaller
and still supports ulimit.
* Use exec to run the lua binary, so that the vsize of the shell doesn't
add to the memory limit.
* Added a quit function to the standalone interpreter. Unused at present.
* Don't add a comma after the last element of a table in a Lua
expression.
* Make the SIGXCPU detection work: proc_open() runs the command via a
shell, which reports signals in the child via the exit status, so
proc_get_status() will never return a valid termsig element.
* In MWServer:call(), fixed a bug causing the return values to be
wrapped in an array.
* Fixed a misunderstanding of what select() does.
* In MWServer:getStatus(), fixed indexes so that vsize will be correct.
Removed RSS, since it wasn't used anyway and turns out to be measured
in multiples of the page size, and I couldn't be bothered trying to
fetch that from getconf. Return the PID and vsize as numbers rather
than strings.
* Added a simple table dump feature to MWServer:debug().
* Fixed brackets in MWServer:tostring().
* Added missing Linux 32-bit binary.
Change-Id: Ibf5f4656b1c0a9f81287d363184c3fe9d2abdafd
2012-04-16 04:41:08 +00:00
|
|
|
if ( !isset( $args[$index0] ) || gettype( $args[$index0] ) !== $type ) {
|
2012-04-13 10:38:12 +00:00
|
|
|
$index1 = $index0 + 1;
|
|
|
|
throw new Scribunto_LuaError( "bad argument #$index1 to '$funcName' ($msgType expected)" );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Workalike for luaL_checkstring()
|
|
|
|
*
|
|
|
|
* @param $funcName The Lua function name, for use in error messages
|
|
|
|
* @param $args The argument array
|
|
|
|
* @param $index0 The zero-based argument index
|
|
|
|
*/
|
|
|
|
public function checkString( $funcName, $args, $index0 ) {
|
|
|
|
$this->checkType( $funcName, $args, $index0, 'string', 'string' );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Workalike for luaL_checknumber()
|
|
|
|
*
|
|
|
|
* @param $funcName The Lua function name, for use in error messages
|
|
|
|
* @param $args The argument array
|
|
|
|
* @param $index0 The zero-based argument index
|
|
|
|
*/
|
|
|
|
public function checkNumber( $funcName, $args, $index0 ) {
|
|
|
|
$this->checkType( $funcName, $args, $index0, 'double', 'number' );
|
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
2013-01-25 17:53:18 +00:00
|
|
|
* Handler for the loadPackage() callback. Load the specified
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
* module and return its chunk. It's not necessary to cache the resulting
|
|
|
|
* chunk in the object instance, since there is caching in a wrapper on the
|
|
|
|
* Lua side.
|
|
|
|
*/
|
|
|
|
function loadPackage( $name ) {
|
2012-04-13 10:38:12 +00:00
|
|
|
$args = func_get_args();
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
$this->checkString( 'loadPackage', $args, 0 );
|
|
|
|
|
2013-02-08 19:20:32 +00:00
|
|
|
# This is what Lua does for its built-in loaders
|
|
|
|
$luaName = str_replace( '.', '/', $name ) . '.lua';
|
2013-02-14 17:38:03 +00:00
|
|
|
$paths = $this->getLibraryPaths( 'lua', self::$libraryPaths );
|
|
|
|
foreach ( $paths as $path ) {
|
|
|
|
$fileName = $this->normalizeModuleFileName( "$path/$luaName" );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
if ( !file_exists( $fileName ) ) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
$code = file_get_contents( $fileName );
|
2013-02-08 19:20:32 +00:00
|
|
|
$init = $this->interpreter->loadString( $code, "@$luaName" );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
return array( $init );
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
|
|
|
|
$title = Title::newFromText( $name );
|
|
|
|
if ( !$title || $title->getNamespace() != NS_MODULE ) {
|
|
|
|
return array();
|
|
|
|
}
|
|
|
|
|
2012-04-13 10:38:12 +00:00
|
|
|
$module = $this->fetchModuleFromParser( $title );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
if ( $module ) {
|
|
|
|
return array( $module->getInitChunk() );
|
|
|
|
} else {
|
|
|
|
return array();
|
|
|
|
}
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
2012-05-22 03:56:07 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Helper function for the implementation of frame methods
|
|
|
|
*/
|
|
|
|
protected function getFrameById( $frameId ) {
|
2013-02-19 00:49:08 +00:00
|
|
|
if ( isset( $this->currentFrames[$frameId] ) ) {
|
|
|
|
return $this->currentFrames[$frameId];
|
2012-05-22 03:56:07 +00:00
|
|
|
} else {
|
|
|
|
throw new Scribunto_LuaError( 'invalid frame ID' );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-02-19 00:49:08 +00:00
|
|
|
* Handler for frameExists()
|
|
|
|
*/
|
|
|
|
function frameExists( $frameId ) {
|
|
|
|
return array( isset( $this->currentFrames[$frameId] ) );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Handler for newChildFrame()
|
2012-05-22 03:56:07 +00:00
|
|
|
*/
|
2013-02-19 00:49:08 +00:00
|
|
|
function newChildFrame( $frameId, $title, $args ) {
|
|
|
|
if ( count( $this->currentFrames ) > 100 ) {
|
|
|
|
throw new Scribunto_LuaError( 'newChild: too many frames' );
|
|
|
|
}
|
|
|
|
|
|
|
|
$frame = $this->getFrameById( $frameId );
|
|
|
|
if ( $title === false ) {
|
|
|
|
$title = $frame->getTitle();
|
|
|
|
} else {
|
|
|
|
$title = Title::newFromText( $title );
|
|
|
|
if ( !$title ) {
|
|
|
|
throw new Scribunto_LuaError( 'newChild: invalid title' );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
$args = $this->getParser()->getPreprocessor()->newPartNodeArray( $args );
|
|
|
|
$newFrame = $frame->newChild( $args, $title );
|
|
|
|
$newFrameId = 'frame' . count( $this->currentFrames );
|
|
|
|
$this->currentFrames[$newFrameId] = $newFrame;
|
|
|
|
return array( $newFrameId );
|
2012-05-22 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-25 17:53:18 +00:00
|
|
|
* Handler for getExpandedArgument()
|
2012-05-22 03:56:07 +00:00
|
|
|
*/
|
|
|
|
function getExpandedArgument( $frameId, $name ) {
|
|
|
|
$args = func_get_args();
|
|
|
|
$this->checkString( 'getExpandedArgument', $args, 0 );
|
|
|
|
|
|
|
|
$frame = $this->getFrameById( $frameId );
|
2013-03-06 23:28:24 +00:00
|
|
|
$this->getInterpreter()->pauseUsageTimer();
|
2012-05-22 03:56:07 +00:00
|
|
|
$result = $frame->getArgument( $name );
|
|
|
|
if ( $result === false ) {
|
|
|
|
return array();
|
|
|
|
} else {
|
|
|
|
return array( $result );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-25 17:53:18 +00:00
|
|
|
* Handler for getAllExpandedArguments()
|
2012-05-22 03:56:07 +00:00
|
|
|
*/
|
|
|
|
function getAllExpandedArguments( $frameId ) {
|
|
|
|
$frame = $this->getFrameById( $frameId );
|
2013-03-06 23:28:24 +00:00
|
|
|
$this->getInterpreter()->pauseUsageTimer();
|
2012-05-22 03:56:07 +00:00
|
|
|
return array( $frame->getArguments() );
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2013-01-25 17:53:18 +00:00
|
|
|
* Handler for expandTemplate()
|
2012-05-22 03:56:07 +00:00
|
|
|
*/
|
|
|
|
function expandTemplate( $frameId, $titleText, $args ) {
|
|
|
|
$frame = $this->getFrameById( $frameId );
|
|
|
|
$title = Title::newFromText( $titleText, NS_TEMPLATE );
|
|
|
|
if ( !$title ) {
|
2012-07-09 03:23:31 +00:00
|
|
|
throw new Scribunto_LuaError( 'expandTemplate: invalid title' );
|
2012-05-22 03:56:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( $frame->depth >= $this->parser->mOptions->getMaxTemplateDepth() ) {
|
|
|
|
throw new Scribunto_LuaError( 'expandTemplate: template depth limit exceeded' );
|
|
|
|
}
|
|
|
|
if ( MWNamespace::isNonincludable( $title->getNamespace() ) ) {
|
|
|
|
throw new Scribunto_LuaError( 'expandTemplate: template inclusion denied' );
|
|
|
|
}
|
|
|
|
|
|
|
|
list( $dom, $finalTitle ) = $this->parser->getTemplateDom( $title );
|
|
|
|
if ( $dom === false ) {
|
2012-07-09 03:23:31 +00:00
|
|
|
throw new Scribunto_LuaError( "expandTemplate: template \"$titleText\" does not exist" );
|
2012-05-22 03:56:07 +00:00
|
|
|
}
|
|
|
|
if ( !$frame->loopCheck( $finalTitle ) ) {
|
|
|
|
throw new Scribunto_LuaError( 'expandTemplate: template loop detected' );
|
|
|
|
}
|
|
|
|
|
|
|
|
$newFrame = $this->parser->getPreprocessor()->newCustomFrame( $args );
|
|
|
|
$text = $this->doCachedExpansion( $newFrame, $dom,
|
|
|
|
array(
|
|
|
|
'template' => $finalTitle->getPrefixedDBkey(),
|
|
|
|
'args' => $args
|
|
|
|
) );
|
|
|
|
return array( $text );
|
|
|
|
}
|
|
|
|
|
2013-03-04 05:42:17 +00:00
|
|
|
/**
|
|
|
|
* Handler for callParserFunction()
|
|
|
|
*/
|
|
|
|
function callParserFunction( $frameId, $function, $args ) {
|
|
|
|
$frame = $this->getFrameById( $frameId );
|
|
|
|
|
|
|
|
# Make zero-based, without screwing up named args
|
|
|
|
$args = array_merge( array(), $args );
|
|
|
|
|
|
|
|
# Sort, since we can't rely on the order coming in from Lua
|
|
|
|
uksort( $args, function ( $a, $b ) {
|
|
|
|
if ( is_int( $a ) !== is_int( $b ) ) {
|
|
|
|
return is_int( $a ) ? -1 : 1;
|
|
|
|
}
|
|
|
|
if ( is_int( $a ) ) {
|
|
|
|
return $a - $b;
|
|
|
|
}
|
|
|
|
return strcmp( $a, $b );
|
|
|
|
} );
|
|
|
|
|
|
|
|
# Be user-friendly
|
|
|
|
$colonPos = strpos( $function, ':' );
|
|
|
|
if ( $colonPos !== false ) {
|
|
|
|
array_unshift( $args, trim( substr( $function, $colonPos + 1 ) ) );
|
|
|
|
$function = substr( $function, 0, $colonPos );
|
|
|
|
}
|
|
|
|
|
|
|
|
$result = $this->parser->callParserFunction( $frame, $function, $args );
|
|
|
|
if ( !$result['found'] ) {
|
|
|
|
throw new Scribunto_LuaError( "callParserFunction: function \"$function\" was not found" );
|
|
|
|
}
|
|
|
|
|
|
|
|
# Set defaults for various flags
|
|
|
|
$result += array(
|
|
|
|
'nowiki' => false,
|
|
|
|
'isChildObj' => false,
|
|
|
|
'isLocalObj' => false,
|
|
|
|
'isHTML' => false,
|
|
|
|
'title' => false,
|
|
|
|
);
|
|
|
|
|
|
|
|
$text = $result['text'];
|
|
|
|
if ( $result['isChildObj'] ) {
|
|
|
|
$newFrame = $frame->newChild( $args, $result['title'] );
|
|
|
|
if ( $result['nowiki'] ) {
|
|
|
|
$text = $newFrame->expand( $text, PPFrame::RECOVER_ORIG );
|
|
|
|
} else {
|
|
|
|
$text = $newFrame->expand( $text );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if ( $result['isLocalObj'] && $result['nowiki'] ) {
|
|
|
|
$text = $frame->expand( $text, PPFrame::RECOVER_ORIG );
|
|
|
|
$result['isLocalObj'] = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
# Replace raw HTML by a placeholder
|
|
|
|
if ( $result['isHTML'] ) {
|
|
|
|
$text = $this->parser->insertStripItem( $text );
|
|
|
|
} elseif ( $result['nowiki'] ) {
|
|
|
|
# Escape nowiki-style return values
|
|
|
|
$text = wfEscapeWikiText( $text );
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( $result['isLocalObj'] ) {
|
|
|
|
$text = $frame->expand( $text );
|
|
|
|
}
|
|
|
|
|
|
|
|
return array( "$text" );
|
|
|
|
}
|
|
|
|
|
2012-05-22 03:56:07 +00:00
|
|
|
/**
|
2013-01-25 17:53:18 +00:00
|
|
|
* Handler for preprocess()
|
2012-05-22 03:56:07 +00:00
|
|
|
*/
|
|
|
|
function preprocess( $frameId, $text ) {
|
|
|
|
$args = func_get_args();
|
|
|
|
$this->checkString( 'preprocess', $args, 0 );
|
|
|
|
|
|
|
|
$frame = $this->getFrameById( $frameId );
|
|
|
|
|
|
|
|
if ( !$frame ) {
|
|
|
|
throw new Scribunto_LuaError( 'attempt to call mw.preprocess with no frame' );
|
|
|
|
}
|
2013-03-06 23:28:24 +00:00
|
|
|
|
|
|
|
// Don't count the time for expanding all the frame arguments against
|
|
|
|
// the Lua time limit.
|
|
|
|
$this->getInterpreter()->pauseUsageTimer();
|
|
|
|
$args = $frame->getArguments();
|
|
|
|
$this->getInterpreter()->unpauseUsageTimer();
|
|
|
|
|
2012-08-27 01:11:32 +00:00
|
|
|
$text = $this->doCachedExpansion( $frame, $text,
|
2012-05-22 03:56:07 +00:00
|
|
|
array(
|
|
|
|
'inputText' => $text,
|
2013-03-06 23:28:24 +00:00
|
|
|
'args' => $args,
|
2012-05-22 03:56:07 +00:00
|
|
|
) );
|
|
|
|
return array( $text );
|
|
|
|
}
|
|
|
|
|
2013-02-01 20:43:32 +00:00
|
|
|
/**
|
|
|
|
* Increment the expensive function count, and throw if limit exceeded
|
|
|
|
*
|
|
|
|
* @return null
|
|
|
|
*/
|
|
|
|
public function incrementExpensiveFunctionCount() {
|
|
|
|
if ( !$this->getParser()->incrementExpensiveFunctionCount() ) {
|
|
|
|
throw new Scribunto_LuaError( "too many expensive function calls" );
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
2012-08-27 01:11:32 +00:00
|
|
|
function doCachedExpansion( $frame, $input, $cacheKey ) {
|
2012-05-22 03:56:07 +00:00
|
|
|
$hash = md5( serialize( $cacheKey ) );
|
|
|
|
if ( !isset( $this->expandCache[$hash] ) ) {
|
2012-08-27 01:11:32 +00:00
|
|
|
if ( is_scalar( $input ) ) {
|
|
|
|
$dom = $this->parser->getPreprocessor()->preprocessToObj(
|
|
|
|
$input, Parser::PTD_FOR_INCLUSION );
|
|
|
|
} else {
|
|
|
|
$dom = $input;
|
|
|
|
}
|
2012-05-22 03:56:07 +00:00
|
|
|
if ( count( $this->expandCache ) > self::MAX_EXPAND_CACHE_SIZE ) {
|
|
|
|
reset( $this->expandCache );
|
|
|
|
$oldHash = key( $this->expandCache );
|
|
|
|
unset( $this->expandCache[$oldHash] );
|
|
|
|
}
|
|
|
|
$this->expandCache[$hash] = $frame->expand( $dom );
|
|
|
|
}
|
|
|
|
return $this->expandCache[$hash];
|
|
|
|
}
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
class Scribunto_LuaModule extends ScribuntoModuleBase {
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
protected $initChunk;
|
2012-04-13 10:38:12 +00:00
|
|
|
|
2012-06-15 23:34:35 +00:00
|
|
|
/**
|
|
|
|
* @param $name string
|
|
|
|
* @return Scribunto_LuaFunction
|
|
|
|
*/
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
protected function newFunction( $name ) {
|
2012-06-15 23:34:35 +00:00
|
|
|
return new Scribunto_LuaFunction( $this, $name, $contents ); // FIXME: $contents is undefined
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
public function validate() {
|
|
|
|
try {
|
2012-04-23 11:36:13 +00:00
|
|
|
$this->getInitChunk();
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
} catch ( ScribuntoException $e ) {
|
|
|
|
return $e->toStatus();
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
return Status::newGood();
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
|
|
|
* Execute the module function and return the export table.
|
|
|
|
*/
|
|
|
|
public function execute() {
|
|
|
|
$init = $this->getInitChunk();
|
|
|
|
$ret = $this->engine->executeModule( $init );
|
|
|
|
if( !$ret ) {
|
2012-04-23 11:36:13 +00:00
|
|
|
throw $this->engine->newException( 'scribunto-lua-noreturn' );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
}
|
|
|
|
if( !is_array( $ret[0] ) ) {
|
2012-04-23 11:36:13 +00:00
|
|
|
throw $this->engine->newException( 'scribunto-lua-notarrayreturn' );
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
return $ret[0];
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
|
|
|
* Get the chunk which, when called, will return the export table.
|
|
|
|
*/
|
|
|
|
public function getInitChunk() {
|
|
|
|
if ( !$this->initChunk ) {
|
|
|
|
$this->initChunk = $this->engine->getInterpreter()->loadString(
|
|
|
|
$this->code,
|
2012-04-19 07:40:56 +00:00
|
|
|
// Prepending an "=" to the chunk name avoids truncation or a "[string" prefix
|
|
|
|
'=' . $this->chunkName );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
}
|
|
|
|
return $this->initChunk;
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
/**
|
2012-05-22 03:56:07 +00:00
|
|
|
* Invoke a function within the module. Return the expanded wikitext result.
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
*/
|
2012-05-22 03:56:07 +00:00
|
|
|
public function invoke( $name, $frame ) {
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
$exports = $this->execute();
|
|
|
|
if ( !isset( $exports[$name] ) ) {
|
2012-04-23 11:36:13 +00:00
|
|
|
throw $this->engine->newException( 'scribunto-common-nosuchfunction' );
|
Added more Lua environment features
Package library:
* Added a simulation of the Lua 5.1 package library.
* Removed mw.import(), replaced it with a package loader. Packages can be
retrieved from the wiki, using require('Module:Foo'), or from files
distributed with Scribunto, using require('foo'). The "Module:" prefix allows
for source compatibility with existing Lua code.
* Added a couple of libraries from LuaForge: luabit and stringtools.
* Made fetchModuleFromParser() return null on error instead of throwing an
exception, to more easily support the desired behaviour of the package loader,
which needs to return null on error.
* Renamed mw.setupEnvironment() to mw.setup() since it is setting up things
other than the environment now.
* In MWServer:handleRegisterLibrary(), remove the feature which interprets dots
in library names, since LuaSandbox doesn't support this.
Improved module isolation and related refactoring:
* Expose restricted versions of getfenv() and setfenv() to user Lua code.
Requires luasandbox r114952.
* Don't cache the export list returned by module execution for later function
calls. This breaks isolation of #invoke calls, since the local variables are
persistent.
* Removed ScribuntoFunctionBase and its children, since it doesn't really have
a purpose if it can't cache anything. Instead, invoke functions using a module
method called invoke().
* Removed Module::initialize(), replaced it with a validate() function. This is
a more elegant interface and works better with the new module caching scheme.
* Use a Status object for the return value of Engine::validate() instead of an
array. Use the formatting facilities of the Status class.
Other:
* Removed "too many returns" error, doesn't fit in with Lua conventions.
* Use the standalone engine by default, so that the extension will work without
configuration for more people.
* Added an accessor for $engine->interpreter
* Fix mw.clone() to correctly clone metatables
* If the standalone interpreter exits due to an error, there are some contexts
where the initial error will be caught and ignored, and the user will see the
error from checkValid() instead. In this case, rethrow the original error for
a more informative message.
* Load mw.lua into the initial standalone environment, to reduce code
duplication between mw.lua and MWServer.lua.
* Fixed a bug in Scribunto_LuaStandaloneInterpreter::handleCall() for functions
that return no results.
* Fixed a bug in encodeLuaVar() for strings with "\r". Added test case.
* In MWServer.lua, don't call error() for internal errors, instead just print
the error and exit. This avoids a protocol violation when an error is
encountered from within handleCall().
* Added lots of documentation. Lua doc comments are in LuaDoc format.
Change-Id: Ie2fd572c362bedf02f45d3fa5352a5280e034740
2012-04-18 03:46:18 +00:00
|
|
|
}
|
2012-04-13 10:38:12 +00:00
|
|
|
|
2012-05-22 03:56:07 +00:00
|
|
|
$result = $this->engine->executeFunctionChunk( $exports[$name], $frame );
|
2012-04-13 10:38:12 +00:00
|
|
|
if ( isset( $result[0] ) ) {
|
|
|
|
return $result[0];
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
class Scribunto_LuaError extends ScribuntoException {
|
2012-07-14 04:23:42 +00:00
|
|
|
var $luaMessage, $lineMap = array();
|
2012-04-13 10:38:12 +00:00
|
|
|
|
2012-04-23 11:36:13 +00:00
|
|
|
function __construct( $message, $options = array() ) {
|
2012-04-13 10:38:12 +00:00
|
|
|
$this->luaMessage = $message;
|
2012-04-23 11:36:13 +00:00
|
|
|
$options = $options + array( 'args' => array( $message ) );
|
|
|
|
if ( isset( $options['module'] ) && isset( $options['line'] ) ) {
|
|
|
|
$msg = 'scribunto-lua-error-location';
|
|
|
|
} else {
|
|
|
|
$msg = 'scribunto-lua-error';
|
|
|
|
}
|
|
|
|
|
|
|
|
parent::__construct( $msg, $options );
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
function getLuaMessage() {
|
|
|
|
return $this->luaMessage;
|
|
|
|
}
|
2012-04-23 11:36:13 +00:00
|
|
|
|
2012-07-14 04:23:42 +00:00
|
|
|
function setLineMap( $map ) {
|
|
|
|
$this->lineMap = $map;
|
|
|
|
}
|
|
|
|
|
2012-10-07 00:11:21 +00:00
|
|
|
/**
|
|
|
|
* @param array $options Options for message processing. Currently supports:
|
|
|
|
* $options['msgOptions']['content'] to use content language.
|
|
|
|
* @return bool|string
|
|
|
|
*/
|
2012-04-23 11:36:13 +00:00
|
|
|
function getScriptTraceHtml( $options = array() ) {
|
2012-04-24 10:40:40 +00:00
|
|
|
if ( !isset( $this->params['trace'] ) ) {
|
|
|
|
return false;
|
|
|
|
}
|
2012-04-23 11:36:13 +00:00
|
|
|
if ( isset( $options['msgOptions'] ) ){
|
|
|
|
$msgOptions = $options['msgOptions'];
|
|
|
|
} else {
|
|
|
|
$msgOptions = array();
|
|
|
|
}
|
|
|
|
|
|
|
|
$s = '<ol class="scribunto-trace">';
|
|
|
|
foreach ( $this->params['trace'] as $info ) {
|
2012-07-14 04:23:42 +00:00
|
|
|
$short_src = $srcdefined = $info['short_src'];
|
|
|
|
$currentline = $info['currentline'];
|
|
|
|
|
|
|
|
$src = htmlspecialchars( $short_src );
|
|
|
|
if ( $currentline > 0 ) {
|
|
|
|
$src .= ':' . htmlspecialchars( $currentline );
|
2012-04-23 11:36:13 +00:00
|
|
|
|
2012-07-14 04:23:42 +00:00
|
|
|
$title = Title::newFromText( $short_src );
|
2012-04-23 11:36:13 +00:00
|
|
|
if ( $title && $title->getNamespace() === NS_MODULE ) {
|
2012-07-14 04:23:42 +00:00
|
|
|
$title->setFragment( '#mw-ce-l' . $currentline );
|
2012-04-23 11:36:13 +00:00
|
|
|
$src = Html::rawElement( 'a',
|
|
|
|
array( 'href' => $title->getFullURL( 'action=edit' ) ),
|
|
|
|
$src );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ( strval( $info['namewhat'] ) !== '' ) {
|
2012-10-07 00:11:21 +00:00
|
|
|
$function = wfMessage( 'scribunto-lua-in-function', $info['name'] );
|
|
|
|
in_array( 'content', $msgOptions ) ?
|
|
|
|
$function = $function->inContentLanguage()->text() :
|
|
|
|
$function = $function->text();
|
2012-04-23 11:36:13 +00:00
|
|
|
} elseif ( $info['what'] == 'main' ) {
|
2012-10-07 00:11:21 +00:00
|
|
|
$function = wfMessage( 'scribunto-lua-in-main' );
|
|
|
|
in_array( 'content', $msgOptions ) ?
|
|
|
|
$function = $function->inContentLanguage()->text() :
|
|
|
|
$function = $function->text();
|
2012-04-23 11:36:13 +00:00
|
|
|
} elseif ( $info['what'] == 'C' || $info['what'] == 'tail' ) {
|
|
|
|
$function = '?';
|
|
|
|
}
|
2012-10-07 00:11:21 +00:00
|
|
|
|
|
|
|
$backtraceLine = wfMessage( 'scribunto-lua-backtrace-line', "<strong>$src</strong>", $function );
|
|
|
|
in_array( 'content', $msgOptions ) ?
|
|
|
|
$backtraceLine = $backtraceLine->inContentLanguage()->text() :
|
|
|
|
$backtraceLine = $backtraceLine->text();
|
|
|
|
|
|
|
|
$s .= "<li>\n\t" . $backtraceLine . "\n</li>\n";
|
2012-04-23 11:36:13 +00:00
|
|
|
}
|
|
|
|
$s .= '</ol>';
|
|
|
|
return $s;
|
|
|
|
}
|
2012-04-13 10:38:12 +00:00
|
|
|
}
|