/**
* @param string $l the level to match
*/
public function setLevelToMatch($l)
{
if ($l instanceof LoggerLevel) {
$this->levelToMatch = $l;
} else {
$this->levelToMatch = LoggerOptionConverter::toLevel($l, null);
}
}
public function testToBoolean()
{
self::assertEquals(true, LoggerOptionConverter::toBoolean(null, true));
self::assertEquals(true, LoggerOptionConverter::toBoolean(null));
self::assertEquals(true, LoggerOptionConverter::toBoolean(true));
self::assertEquals(true, LoggerOptionConverter::toBoolean("1"));
self::assertEquals(true, LoggerOptionConverter::toBoolean("true"));
self::assertEquals(true, LoggerOptionConverter::toBoolean("on"));
self::assertEquals(true, LoggerOptionConverter::toBoolean("yes"));
self::assertEquals(false, LoggerOptionConverter::toBoolean(null, false));
self::assertEquals(false, LoggerOptionConverter::toBoolean(false));
self::assertEquals(false, LoggerOptionConverter::toBoolean(""));
self::assertEquals(false, LoggerOptionConverter::toBoolean("0"));
self::assertEquals(false, LoggerOptionConverter::toBoolean("false"));
self::assertEquals(false, LoggerOptionConverter::toBoolean("off"));
self::assertEquals(false, LoggerOptionConverter::toBoolean("no"));
}
public function setProperties($properties, $prefix)
{
$len = strlen($prefix);
while (list($key, ) = each($properties)) {
if (strpos($key, $prefix) === 0) {
if (strpos($key, '.', $len + 1) > 0) {
continue;
}
$value = LoggerOptionConverter::findAndSubst($key, $properties);
$key = substr($key, $len);
if ($key == 'layout' and $this->obj instanceof LoggerAppender) {
continue;
}
$this->setProperty($key, $value);
}
}
$this->activate();
}
/**
* @param array $props array of properties
* @param string $appenderName
* @return LoggerAppender
*/
private function parseAppender($props, $appenderName)
{
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName);
$prefix = self::APPENDER_PREFIX . $appenderName;
if ($appender === null) {
// Appender was not previously initialized.
$appenderClass = @$props[$prefix];
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName, $appenderClass);
if ($appender === null) {
return null;
}
}
if ($appender->requiresLayout()) {
$layoutPrefix = $prefix . ".layout";
$layoutClass = @$props[$layoutPrefix];
$layoutClass = LoggerOptionConverter::substVars($layoutClass, $props);
if (empty($layoutClass)) {
$layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple');
} else {
$layout = LoggerReflectionUtils::createObject($layoutClass);
if ($layout === null) {
$layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple');
}
}
LoggerReflectionUtils::setPropertiesByObject($layout, $props, $layoutPrefix . ".");
$appender->setLayout($layout);
}
LoggerReflectionUtils::setPropertiesByObject($appender, $props, $prefix . ".");
return $appender;
}
/**
* Set the threshold level of this appender.
*
* @param mixed $threshold can be a {@link LoggerLevel} object or a string.
* @see LoggerOptionConverter::toLevel()
*/
function setThreshold($threshold)
{
if (is_string($threshold)) {
$this->threshold = LoggerOptionConverter::toLevel($threshold, null);
} elseif (is_a($threshold, 'loggerlevel')) {
$this->threshold = $threshold;
}
}
/**
* @param array $props array of properties
* @param string $appenderName
* @return LoggerAppender
*/
function &parseAppender($props, $appenderName)
{
$appender =& LoggerAppender::singleton($appenderName);
if ($appender !== null) {
LoggerLog::debug("LoggerPropertyConfigurator::parseAppender() " . "Appender [{$appenderName}] was already parsed.");
return $appender;
}
// Appender was not previously initialized.
$prefix = LOG4PHP_LOGGER_PROPERTY_CONFIGURATOR_APPENDER_PREFIX . $appenderName;
$layoutPrefix = $prefix . ".layout";
$appenderClass = @$props[$prefix];
if (!empty($appenderClass)) {
$appender =& LoggerAppender::singleton($appenderName, $appenderClass);
if ($appender === null) {
LoggerLog::warn("LoggerPropertyConfigurator::parseAppender() " . "Could not instantiate appender named [{$appenderName}].");
return null;
}
} else {
LoggerLog::warn("LoggerPropertyConfigurator::parseAppender() " . "Could not instantiate appender named [{$appenderName}] with null className.");
return null;
}
$appender->setName($appenderName);
if ($appender->requiresLayout()) {
LoggerLog::debug("LoggerPropertyConfigurator::parseAppender() " . "Parsing layout section for [{$appenderName}].");
$layoutClass = @$props[$layoutPrefix];
$layoutClass = LoggerOptionConverter::substVars($layoutClass, $props);
if (empty($layoutClass)) {
LoggerLog::warn("LoggerPropertyConfigurator::parseAppender() " . "layout class is empty in '{$layoutPrefix}'. Using Simple layout");
$layout = LoggerLayout::factory('LoggerLayoutSimple');
} else {
$layout = LoggerLayout::factory($layoutClass);
if ($layout === null) {
LoggerLog::warn("LoggerPropertyConfigurator::parseAppender() " . "cannot create layout '{$layoutClass}'. Using Simple layout");
$layout = LoggerLayout::factory('LoggerLayoutSimple');
}
}
LoggerLog::debug("LoggerPropertyConfigurator::parseAppender() " . "Parsing layout options for [{$appenderName}].");
LoggerPropertySetter::setPropertiesByObject($layout, $props, $layoutPrefix . ".");
LoggerLog::debug("LoggerPropertyConfigurator::parseAppender() " . "End Parsing layout options for [{$appenderName}].");
$appender->setLayout($layout);
}
LoggerPropertySetter::setPropertiesByObject($appender, $props, $prefix . ".");
LoggerLog::debug("LoggerPropertyConfigurator::parseAppender() " . "Parsed [{$appenderName}] options.");
return $appender;
}
public static function substVars($val, $props = null)
{
$sbuf = '';
$i = 0;
while (true) {
$j = strpos($val, self::DELIM_START, $i);
if ($j === false) {
// no more variables
if ($i == 0) {
// this is a simple string
return $val;
} else {
// add the tail string which contails no variables and return the result.
$sbuf .= substr($val, $i);
return $sbuf;
}
} else {
$sbuf .= substr($val, $i, $j - $i);
$k = strpos($val, self::DELIM_STOP, $j);
if ($k === false) {
// LoggerOptionConverter::substVars() has no closing brace. Opening brace
return '';
} else {
$j += self::DELIM_START_LEN;
$key = substr($val, $j, $k - $j);
// first try in System properties
$replacement = LoggerOptionConverter::getSystemProperty($key, null);
// then try props parameter
if ($replacement == null and $props !== null) {
$replacement = @$props[$key];
}
if (!empty($replacement)) {
// Do variable substitution on the replacement string
// such that we can solve "Hello ${x2}" as "Hello p1"
// the where the properties are
// x1=p1
// x2=${x1}
$recursiveReplacement = LoggerOptionConverter::substVars($replacement, $props);
$sbuf .= $recursiveReplacement;
}
$i = $k + self::DELIM_STOP_LEN;
}
}
}
}
/**
* @param string $l the level max to match
*/
function setLevelMax($l)
{
$this->levelMax = LoggerOptionConverter::toLevel($l, null);
}
/**
* Set the properites for the object that match the
* <code>prefix</code> passed as parameter.
*
* @param array $properties An array containing keys and values.
* @param string $prefix Only keys having the specified prefix will be set.
*/
function setProperties($properties, $prefix)
{
LoggerLog::debug("LoggerOptionConverter::setProperties():prefix=[{$prefix}]");
$len = strlen($prefix);
while (list($key, ) = each($properties)) {
if (strpos($key, $prefix) === 0) {
if (strpos($key, '.', $len + 1) > 0) {
continue;
}
$value = LoggerOptionConverter::findAndSubst($key, $properties);
$key = substr($key, $len);
if ($key == 'layout' && is_a($this->obj, 'loggerappender')) {
continue;
}
$this->setProperty($key, $value);
}
}
$this->activate();
}
/**
* The <b>ContextPrinting</b> option specifies log output will include
* the nested context information belonging to the current thread.
* This is true by default.
*/
public function setContextPrinting($contextPrinting)
{
$this->contextPrinting = LoggerOptionConverter::toBoolean($contextPrinting);
}
public function setHtmlLineBreaks($value)
{
$this->htmlLineBreaks = LoggerOptionConverter::toBoolean($value, false);
}
public function testSubstituteVars()
{
$props['OTHER_CONSTANT'] = "OTHER";
$props['MY_CONSTANT'] = "TEST";
$props['NEXT_CONSTANT'] = "NEXT";
$result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT}.', $props);
self::assertEquals('Value of key is TEST.', $result);
$result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT} or ${OTHER_CONSTANT}.', $props);
self::assertEquals('Value of key is TEST or OTHER.', $result);
$result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT_CONSTANT}.', $props);
self::assertEquals('Value of key is DEFINE.', $result);
$result = LoggerOptionConverter::substVars('Value of key is ${MY_CONSTANT_CONSTANT} or ${MY_CONSTANT_CONSTANT_OTHER}.', $props);
self::assertEquals('Value of key is DEFINE or DEFINE_OTHER.', $result);
}
private function doConfigure($url, LoggerHierarchy $hierarchy)
{
$config = (require $url);
// set threshold
if (isset($config['threshold'])) {
$hierarchy->setThreshold(LoggerOptionConverter::toLevel($config['threshold'], LoggerLevel::getLevelAll()));
}
// parse and create appenders
if (isset($config['appenders'])) {
foreach ($config['appenders'] as $appenderName => $appenderProperties) {
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName, $appenderProperties['class']);
if ($appender->requiresLayout()) {
if (isset($appenderProperties['layout'])) {
if (isset($appenderProperties['layout']['class']) and !empty($appenderProperties['layout']['class'])) {
$layoutClass = $appenderProperties['layout']['class'];
} else {
$layoutClass = 'LoggerLayoutSimple';
}
$layout = LoggerReflectionUtils::createObject($layoutClass);
if ($layout === null) {
$layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple');
}
if ($layout instanceof LoggerLayoutPattern) {
$layout->setConversionPattern($appenderProperties['layout']['conversionPattern']);
}
$appender->setLayout($layout);
} else {
// TODO: throw exception?
}
}
}
}
// parse and create root logger
if (isset($config['rootLogger'])) {
$rootLogger = $hierarchy->getRootLogger();
if (isset($config['rootLogger']['level'])) {
$rootLogger->setLevel(LoggerOptionConverter::toLevel($config['rootLogger']['level'], LoggerLevel::getLevelDebug()));
if (isset($config['rootLogger']['appenders'])) {
foreach ($config['rootLogger']['appenders'] as $appenderName) {
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName);
if ($appender !== null) {
$rootLogger->addAppender($appender);
}
}
}
}
}
// parse and create loggers
if (isset($config['loggers'])) {
foreach ($config['loggers'] as $loggerName => $loggerProperties) {
if (is_string($loggerName)) {
$logger = $hierarchy->getLogger($loggerName);
if (isset($loggerProperties['level'])) {
$logger->setLevel(LoggerOptionConverter::toLevel($loggerProperties['level'], LoggerLevel::getLevelDebug()));
if (isset($loggerProperties['appenders'])) {
foreach ($loggerProperties['appenders'] as $appenderName) {
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName);
if ($appender !== null) {
$logger->addAppender($appender);
}
}
}
}
} else {
// TODO: throw exception
}
}
}
return true;
}
private function doConfigure($url, LoggerHierarchy $hierarchy)
{
if (!is_array($url)) {
$config = (require $url);
} else {
$config = $url;
}
// set threshold
if (isset($config['threshold'])) {
$hierarchy->setThreshold(LoggerOptionConverter::toLevel($config['threshold'], LoggerLevel::getLevelAll()));
}
// add renderes
if (isset($config['renderers'])) {
foreach ($config['renderers'] as $renderedClass => $renderingClass) {
$hierarchy->getRendererMap()->addRenderer($renderedClass, $renderingClass);
}
}
// parse and create appenders
if (isset($config['appenders'])) {
foreach ($config['appenders'] as $appenderName => $appenderProperties) {
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName, $appenderProperties['class']);
// unset so that the property wont be drawn up again
unset($appenderProperties['class']);
if ($appender->requiresLayout()) {
if (isset($appenderProperties['layout'])) {
if (isset($appenderProperties['layout']['class']) and !empty($appenderProperties['layout']['class'])) {
$layoutClass = $appenderProperties['layout']['class'];
} else {
$layoutClass = 'LoggerLayoutSimple';
}
$layout = LoggerReflectionUtils::createObject($layoutClass);
if ($layout === null) {
$layout = LoggerReflectionUtils::createObject('LoggerLayoutSimple');
}
if (isset($appenderProperties['file']) && method_exists($appender, 'setFileName')) {
$appender->setFile($appenderProperties['file'], true);
}
if ($layout instanceof LoggerLayoutPattern) {
$layout->setConversionPattern($appenderProperties['layout']['conversionPattern']);
}
$appender->setLayout($layout);
// unset so that the property wont be drawn up again
unset($appenderProperties['layout']);
} else {
// TODO: throw exception?
}
}
// set remaining properties and activate appender
$setter = new LoggerReflectionUtils($appender);
foreach ($appenderProperties as $key => $val) {
$setter->setProperty($key, $val);
}
$setter->activate();
}
}
// parse and create root logger
if (isset($config['rootLogger'])) {
$rootLogger = $hierarchy->getRootLogger();
if (isset($config['rootLogger']['level'])) {
$rootLogger->setLevel(LoggerOptionConverter::toLevel($config['rootLogger']['level'], LoggerLevel::getLevelDebug()));
if (isset($config['rootLogger']['appenders'])) {
foreach ($config['rootLogger']['appenders'] as $appenderName) {
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName);
if ($appender !== null) {
$rootLogger->addAppender($appender);
}
}
}
}
}
// parse and create loggers
if (isset($config['loggers'])) {
foreach ($config['loggers'] as $loggerName => $loggerProperties) {
if (is_string($loggerName)) {
$logger = $hierarchy->getLogger($loggerName);
if (isset($loggerProperties['level'])) {
$logger->setLevel(LoggerOptionConverter::toLevel($loggerProperties['level'], LoggerLevel::getLevelDebug()));
if (isset($loggerProperties['appenders'])) {
foreach ($loggerProperties['appenders'] as $appenderName) {
$appender = LoggerAppenderPool::getAppenderFromPool($appenderName);
if ($appender !== null) {
$logger->addAppender($appender);
}
}
}
}
} else {
// TODO: throw exception
}
}
}
return true;
}
function setCreateTable($flag)
{
$this->createTable = LoggerOptionConverter::toBoolean($flag, true);
}
/**
* Perform variable substitution in string <var>$val</var> from the
* values of keys found with the {@link getSystemProperty()} method.
*
* <p>The variable substitution delimeters are <b>${</b> and <b>}</b>.
*
* <p>For example, if the "MY_CONSTANT" contains "value", then
* the call
* <code>
* $s = LoggerOptionConverter::substituteVars("Value of key is ${MY_CONSTANT}.");
* </code>
* will set the variable <i>$s</i> to "Value of key is value.".</p>
*
* <p>If no value could be found for the specified key, then the
* <var>$props</var> parameter is searched, if the value could not
* be found there, then substitution defaults to the empty string.</p>
*
* <p>For example, if {@link getSystemProperty()} cannot find any value for the key
* "inexistentKey", then the call
* <code>
* $s = LoggerOptionConverter::substVars("Value of inexistentKey is [${inexistentKey}]");
* </code>
* will set <var>$s</var> to "Value of inexistentKey is []".</p>
*
* <p>A warn is thrown if <var>$val</var> contains a start delimeter "${"
* which is not balanced by a stop delimeter "}" and an empty string is returned.</p>
*
* @log4j-author Avy Sharell
*
* @param string $val The string on which variable substitution is performed.
* @param array $props
* @return string
*
* @static
*/
function substVars($val, $props = null)
{
LoggerLog::debug("LoggerOptionConverter::substVars():val=[{$val}]");
$sbuf = '';
$i = 0;
while (true) {
$j = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_START, $i);
if ($j === false) {
LoggerLog::debug("LoggerOptionConverter::substVars() no more variables");
// no more variables
if ($i == 0) {
// this is a simple string
LoggerLog::debug("LoggerOptionConverter::substVars() simple string");
return $val;
} else {
// add the tail string which contails no variables and return the result.
$sbuf .= substr($val, $i);
LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]. Returning sbuf");
return $sbuf;
}
} else {
$sbuf .= substr($val, $i, $j - $i);
LoggerLog::debug("LoggerOptionConverter::substVars():sbuf=[{$sbuf}]:i={$i}:j={$j}.");
$k = strpos($val, LOG4PHP_OPTION_CONVERTER_DELIM_STOP, $j);
if ($k === false) {
LoggerLog::warn("LoggerOptionConverter::substVars() " . "'{$val}' has no closing brace. Opening brace at position {$j}.");
return '';
} else {
$j += LOG4PHP_OPTION_CONVERTER_DELIM_START_LEN;
$key = substr($val, $j, $k - $j);
// first try in System properties
$replacement = LoggerOptionConverter::getSystemProperty($key, null);
// then try props parameter
if ($replacement == null and $props !== null) {
$replacement = @$props[$key];
}
if (!empty($replacement)) {
// Do variable substitution on the replacement string
// such that we can solve "Hello ${x2}" as "Hello p1"
// the where the properties are
// x1=p1
// x2=${x1}
$recursiveReplacement = LoggerOptionConverter::substVars($replacement, $props);
$sbuf .= $recursiveReplacement;
}
$i = $k + LOG4PHP_OPTION_CONVERTER_DELIM_STOP_LEN;
}
}
}
}
}
}
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
if (!defined('LOG4PHP_DEFAULT_INIT_OVERRIDE')) {
if (isset($_ENV['log4php.defaultInitOverride'])) {
/**
* @ignore
*/
define('LOG4PHP_DEFAULT_INIT_OVERRIDE', LoggerOptionConverter::toBoolean($_ENV['log4php.defaultInitOverride'], false));
} elseif (isset($GLOBALS['log4php.defaultInitOverride'])) {
/**
* @ignore
*/
define('LOG4PHP_DEFAULT_INIT_OVERRIDE', LoggerOptionConverter::toBoolean($GLOBALS['log4php.defaultInitOverride'], false));
} else {
/**
* Controls init execution
*
* With this constant users can skip the default init procedure that is
* called when this file is included.
*
* <p>If it is not user defined, log4php tries to autoconfigure using (in order):</p>
*
* - the <code>$_ENV['log4php.defaultInitOverride']</code> variable.
* - the <code>$GLOBALS['log4php.defaultInitOverride']</code> global variable.
* - defaults to <i>false</i>
*
* @var boolean
*/
private function subst($value)
{
return LoggerOptionConverter::substVars($value);
}
/**
* @param string $l the level to match
*/
function setLevelToMatch($l)
{
$this->levelToMatch = LoggerOptionConverter::toLevel($l, null);
}
/**
* @param mixed
*/
function setUseXml($flag)
{
$this->useXml = LoggerOptionConverter::toBoolean($flag, $this->getUseXml());
}
/**
* Configures a logger.
*
* @param Logger $logger The logger to configure
* @param array $config Logger configuration options.
*/
private function configureLogger(Logger $logger, $config)
{
$loggerName = $logger->getName();
// Set logger level
if (isset($config['level'])) {
$level = LoggerLevel::toLevel($config['level']);
if (isset($level)) {
$logger->setLevel($level);
} else {
$default = $logger->getLevel();
$this->warn("Invalid level value [{$config['level']}] specified for logger [{$loggerName}]. Ignoring level definition.");
}
}
// Link appenders to logger
if (isset($config['appenders'])) {
foreach ($config['appenders'] as $appenderName) {
if (isset($this->appenders[$appenderName])) {
$logger->addAppender($this->appenders[$appenderName]);
} else {
$this->warn("Nonexistnant appender [{$appenderName}] linked to logger [{$loggerName}].");
}
}
}
// Set logger additivity
if (isset($config['additivity'])) {
$additivity = LoggerOptionConverter::toBoolean($config['additivity'], null);
if (is_bool($additivity)) {
$logger->setAdditivity($additivity);
} else {
$this->warn("Invalid additivity value [{$config['additivity']}] specified for logger [{$loggerName}]. Ignoring additivity setting.");
}
}
}
/**
* Check that various boolean equivalents from ini file convert properly
* to boolean.
*/
public function testBooleanValues()
{
$values = parse_ini_file(PHPUNIT_CONFIG_DIR . '/adapters/ini/values.ini');
$actual = LoggerOptionConverter::toBooleanEx($values['unquoted_true']);
self::assertTrue($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['unquoted_yes']);
self::assertTrue($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['unquoted_false']);
self::assertFalse($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['unquoted_no']);
self::assertFalse($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['quoted_true']);
self::assertTrue($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['quoted_false']);
self::assertFalse($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['unquoted_one']);
self::assertTrue($actual);
$actual = LoggerOptionConverter::toBooleanEx($values['unquoted_zero']);
self::assertFalse($actual);
}
function setAppend($flag)
{
$this->append = LoggerOptionConverter::toBoolean($flag, true);
}
/**
* Setter function for string type.
*/
protected function setString($property, $value, $nullable = false)
{
if ($value === null) {
if ($nullable) {
$this->{$property} = null;
} else {
$this->warn("Null value given for '{$property}' property. Expected a string. Property not changed.");
}
} else {
try {
$value = LoggerOptionConverter::toStringEx($value);
$this->{$property} = LoggerOptionConverter::substConstants($value);
} catch (Exception $ex) {
$value = var_export($value, true);
$this->warn("Invalid value given for '{$property}' property: [{$value}]. Expected a string. Property not changed.");
}
}
}
/**
* Set the threshold level of this appender.
*
* @param mixed $threshold can be a {@link LoggerLevel} object or a string.
* @see LoggerOptionConverter::toLevel()
*/
public function setThreshold($threshold)
{
if (is_string($threshold)) {
$this->threshold = LoggerOptionConverter::toLevel($threshold, null);
} else {
if ($threshold instanceof LoggerLevel) {
$this->threshold = $threshold;
}
}
}
/**
* @param boolean
*/
public function setLog4jNamespace($flag)
{
$this->log4jNamespace = LoggerOptionConverter::toBoolean($flag, true);
}
public function testSubstituteConstants()
{
define('OTHER_CONSTANT', 'OTHER');
define('MY_CONSTANT', 'TEST');
define('NEXT_CONSTANT', 'NEXT');
$result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT}.');
self::assertEquals('Value of key is TEST.', $result);
$result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT} or ${OTHER_CONSTANT}.');
self::assertEquals('Value of key is TEST or OTHER.', $result);
$result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT_CONSTANT}.');
self::assertEquals('Value of key is DEFINE.', $result);
$result = LoggerOptionConverter::substConstants('Value of key is ${MY_CONSTANT_CONSTANT} or ${MY_CONSTANT_CONSTANT_OTHER}.');
self::assertEquals('Value of key is DEFINE or DEFINE_OTHER.', $result);
}
