bit
/
jsm
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
jsm/jsm.inc.php

2065 lines
46 KiB
PHP
Raw Permalink Blame History

<?php
class JSM
{
//NOTE: parsed modules are shared between JSM instances
static private $modules = array();
static private $consts = array();
private $base_dir;
private $file;
private $scope_vars = array(array());
private $includes = array();
private $defs = array();
private $buffers = array();
private $nodes = array();
private $cur_modules = array();
private $args_parser;
function __construct($base_dir, $file)
{
//for rand constants
mt_srand();
$this->base_dir = rtrim(jsm_normalize_path($base_dir, true/*nix*/), '/');
$this->file = $file;
$this->args_parser = new JSM_ArgsParser();
}
function getRootFile()
{
return $this->file;
}
function getModule($file)
{
if(isset(self::$modules[$file]))
return self::$modules[$file];
throw new Exception("Module for '$file' not found");
}
function _extractModule($file)
{
$txt = file_get_contents($file);
if($txt === false)
throw new Exception("Bad file '{$file}'");
$m = new JSM_Module($file);
$m->node = new JSM_MacroDefNode($file/*using file as name*/);
$this->_pushCurrentModule($m);
$txt = $this->_fixJunk($txt);
$txt = $this->_processIncludes($file, $txt);
$txt = $this->_removeBlockComments($txt);
$txt = $this->_removeLineComments($txt);
$txt = $this->_extractScriptDefs($file, $txt);
$this->_parseDefBody($m->node, $file, $txt);
$this->_popCurrentModule();
return $m;
}
function _pushCurrentModule(JSM_Module $m)
{
$this->cur_modules[] = $m;
}
function _popCurrentModule()
{
if(!$this->cur_modules)
throw new Exception("No module to pop");
$m = array_pop($this->cur_modules);
return $m;
}
function _currentModule()
{
$m = end($this->cur_modules);
if(!$m)
throw new Exception("No current modules");
return $m;
}
function getCurrentModule()
{
return $this->_currentModule();
}
function process()
{
$m = $this->_extractModule($this->file);
if($this->cur_modules)
throw new Exception("Non closed modules");
$this->defs = $m->defs;
$this->includes = $m->includes;
$this->_pushBuffer();
$m->node->call($this);
$res = $this->_popBuffer();
if($this->buffers)
throw new Exception("Non closed buffers " . sizeof($this->buffers));
if($this->nodes)
throw new Exception("Non closed nodes " . sizeof($this->nodes));
$res = $this->_processRelpaths($this->file, $res);
return array($res, $m);
}
function _pushNode(JSM_MacroInternalNode $n)
{
$this->nodes[] = $n;
}
function _popNode()
{
if(!$this->nodes)
throw new Exception("No nodes to pop");
$n = array_pop($this->nodes);
return $n;
}
function _node($strict = true)
{
$n = end($this->nodes);
if(!$n)
{
if($strict)
throw new Exception("No current node");
else
return null;
}
return $n;
}
function _pushBuffer()
{
$this->buffers[] = new JSM_TextBuffer();
}
function _popBuffer()
{
if(!$this->buffers)
throw new Exception("No buffers to pop");
$b = array_pop($this->buffers);
return $b->getContent();
}
function _buffer()
{
$b = end($this->buffers);
if(!$b)
throw new Exception("No current buffer");
return $b;
}
function _buffers()
{
return $this->buffers;
}
function _pushVarScope()
{
$this->scope_vars[] = array();
}
function _popVarScope()
{
array_pop($this->scope_vars);
}
function setConst($name, $value)
{
if(isset(self::$consts[$name]) && self::$consts[$name] != $value)
{
$curr_value = self::$consts[$name];
throw new Exception("Const '$name' is already defined as {$curr_value}");
}
self::$consts[$name] = $value;
}
function hasConst($name, $value)
{
return isset(self::$consts[$name]);
}
function getConst($name)
{
if(!isset(self::$consts[$name]))
throw new Exception("Const '$name' is not defined");
return self::$consts[$name];
}
function getAutoConst($name)
{
if(!isset(self::$consts[$name]))
$this->setConst($name, crc32($name) & 0xFFFFFFF);
return $this->getConst($name);
}
function setVar($name, $value)
{
$this->scope_vars[sizeof($this->scope_vars) - 1][$name] = $value;
}
function getVar($name)
{
$vars = end($this->scope_vars);
if(isset($vars[$name]))
return $vars[$name];
throw new Exception("Var '$name' not resolved");
}
function getVarAnyScope($name)
{
for($i=count($this->scope_vars) - 1; $i>=0; --$i)
{
$vars = $this->scope_vars[$i];
if(isset($vars[$name]))
return $vars[$name];
}
throw new Exception("Var '$name' not resolved");
}
private function _fixJunk($txt)
{
//windows eol
$txt = str_replace("\r\n", "\n", $txt);
return $txt;
}
private function _removeBlockComments($txt)
{
if(strpos($txt, '/*') === false)
return $txt;
$regex = '~/\*.*?\*/~s';
$txt = preg_replace_callback(
$regex,
//preserve the new lines for better error reporting
function($m) { return str_repeat("\n", substr_count($m[0], "\n")); },
$txt);
return $txt;
}
private function _removeLineComments($txt)
{
//TODO: it's not robust enough, note a hack for URL addresses
$txt = preg_replace("~\s*(?<!:)//.*~", "\n", $txt);
return $txt;
}
/*private */function _relpathCallback(array $m, $curr_dir)
{
//1) checking if such a file exists and normalizing all .. in the path
$full_path = realpath($curr_dir . '/' . $m[1]);
if(!$full_path)
throw new Exception("Bad relative path '$m[1]'");
//2) now turning the path into *nix alike
$full_path = jsm_normalize_path($full_path, true/*nix*/);
$rel_path = ltrim(str_replace($this->base_dir, '', $full_path), '/');
return $rel_path;
}
/*private */function _relconfCallback(array $m, $curr_dir)
{
//1) checking if such a file exists and normalizing all .. in the path
$full_path = realpath($curr_dir . '/' . $m[1] . '.conf.js');
if(!$full_path)
throw new Exception("Bad relative path '$m[1]'" . ($curr_dir . '/' . $m[1]));
$full_path = jsm_normalize_path($full_path, true/*nix*/);
$rel_path = ltrim(str_replace($this->base_dir, '', $full_path), '/');
$rel_path = str_replace('.conf.js', '', $rel_path);
return "@$rel_path";
}
private function _processRelpaths($file, $txt)
{
//normalizing all file paths
if(strpos($txt, './') !== false)
{
$curr_dir = dirname($file);
$self = $this;
$txt = preg_replace_callback(
'~\./((.*?)\.(jpg|jpeg|swf|png|mp3|txt|gif|ogg))~',
function($m) use($self, $curr_dir) { return $self->_relpathCallback($m, $curr_dir); },
$txt);
$txt = preg_replace_callback(
'~@\./([^"]+)~',
function($m) use($self, $curr_dir) { return $self->_relconfCallback($m, $curr_dir); },
$txt);
}
return $txt;
}
/*private */function _includesCallback(array $m, $curr_file)
{
$file_name = $m[1];
$dir = ($file_name[0] == '/') ? $this->base_dir : dirname($curr_file);
$file = jsm_normalize_path($dir . '/' . $m[1]);
$cm = $this->_currentModule();
if(!isset(self::$modules[$file]))
{
if($this->_hasExtension($file, '.js'))
{
self::$modules[$file] = $this->_extractModule($file);
}
else if($this->_hasExtension($file, '.php'))
{
include_once($file);
//special mark for PHP include
self::$modules[$file] = 1;
}
else
throw new Exception("Unknown extension of the include file '$file'");
}
$m = self::$modules[$file];
$need_include_macro = false;
//NOTE: module can be non object if it's a PHP include
if(is_object($m))
{
$need_include_macro = true;
if(!isset($cm->includes[$file]))
{
foreach($m->includes as $f => $_)
$cm->includes[$f] = 1;
foreach($m->defs as $n => $d)
{
if(isset($cm->defs[$n]) && $cm->defs[$n] !== $d)
throw new Exception("Def '$n' is already defined in '{$cm->file}' (check {$cm->defs[$n]->file})");
$cm->defs[$n] = $d;
}
}
}
$cm->includes[$file] = 1;
return $need_include_macro ? "<%INC($file)%>" : '';
}
private function _processIncludes($file, $txt)
{
if(strpos($txt, 'INC') !== false)
{
$self = $this;
$txt = preg_replace_callback(
'~<%\s*INC\s*\(\s*"([^"]+)"\s*\)\s*%>~',
function($m) use($self, $file) { return $self->_includesCallback($m, $file); },
$txt);
}
return $txt;
}
function _isIncluded($file)
{
$file = jsm_normalize_path($file);
return isset($this->includes[$file]);
}
function _hasExtension($file, $ext)
{
return strpos($file, $ext, strlen($file) - strlen($ext) - 1) !== false;
}
static function getDeps($base_dir, $file)
{
$deps = array();
self::_getDeps($base_dir, $file, $deps);
return $deps;
}
static private function _extractDeps($txt)
{
$dep_files = array();
if(preg_match_all('~<%\s*((?:INC)|(?:BHL))\s*\(\s*"([^\n]+)~', $txt, $ms))
{
foreach($ms[1] as $idx => $type)
{
$raw_dep = $ms[2][$idx];
$is_bhl = $type === "BHL";
if($is_bhl)
{
$bhl_imps = explode(',', str_replace('"', '', $raw_dep));
foreach($bhl_imps as $bhl_imp)
{
if($bhl_imp)
$dep_files[$bhl_imp . '.bhl'] = true;
}
}
else
{
$dep_file = substr($raw_dep, 0, strpos($raw_dep, '"'));
$dep_files[$dep_file] = false;
}
}
}
return $dep_files;
}
static private function _getDeps($base_dir, $file, &$deps)
{
static $cache = array();
$local_deps = array();
if(!isset($cache[$file]))
{
if(!is_file($file))
throw new Exception("Bad file '$file'");
$txt = file_get_contents($file);
if($txt === false)
throw new Exception("Bad file '$file'");
$extracted_deps = self::_extractDeps($txt);
foreach($extracted_deps as $inc => $is_bhl)
{
$dir = ($inc[0] == '/') ? $base_dir : dirname($file);
$dep_file = jsm_normalize_path($dir . "/" . $inc);
$local_deps[] = array($is_bhl, $dep_file);
$cache[$file] = $local_deps;
}
}
else
$local_deps = $cache[$file];
foreach($local_deps as $local_dep)
{
list($is_bhl, $dep_file) = $local_dep;
if(in_array($dep_file, $deps))
continue;
$deps[] = $dep_file;
//NOTE: bhl deps are shallow
if(!$is_bhl)
{
try
{
self::_getDeps($base_dir, $dep_file, $deps);
}
catch(Exception $e)
{
throw new Exception("Bad deps for '$file' : " . $e->getMessage());
}
}
}
}
private function _extractDefNameAndArgs($full_name)
{
$pos = strpos($full_name, '(');
if($pos == -1)
throw new Exception("Bad args string: $full_name");
$name = substr($full_name, 0, $pos);
$args_str = substr($full_name, $pos+1, strlen($full_name) - ($pos + 2));
$args = $this->_parseMacroDefArgs($args_str);
return array($name, $args);
}
private function _parseMacroDefArgs($args_str)
{
if(!$args_str)
return array();
return $this->args_parser->parseDef($args_str);
}
function nodes2str($nodes_or_str)
{
$str = '';
if(is_array($nodes_or_str))
{
$this->_pushBuffer();
foreach($nodes_or_str as $n)
$n->call($this);
$str = $this->_popBuffer();
}
else if(is_string($nodes_or_str))
$str = $nodes_or_str;
else
throw new Exception("Bad value: $nodes_or_str");
return $str;
}
function _processMacroArgs($arg_nodes_or_str)
{
$str = $this->nodes2str($arg_nodes_or_str);
return $this->_parseMacroArgsStr($str);
}
function _parseMacroArgsStr($orig_args_str)
{
static $cache = array();
if(!$orig_args_str)
return array(false, array());
//NOTE: this is potentially dangerous?
$may_cache = strpos($orig_args_str, '<%') === false;
if($may_cache && isset($cache[$orig_args_str]))
return $cache[$orig_args_str];
$args_str = $this->_removeBlockComments($orig_args_str);
$args_str = $this->_removeLineComments($args_str);
$args_str = rtrim($args_str, ',');
$res = $this->args_parser->parseInvoke($args_str);
if($may_cache)
$cache[$orig_args_str] = $res;
return $res;
}
private function _extractScriptDefs($file, $txt)
{
if(strpos($txt, 'def') === false)
return $txt;
//NOTE: make it more robust
$lexer_rules = array(
'~def\s+((\w+)\([^\)]*\))(.*?)\s*\n\bend\b~sA' => 1,
'~[^\r\n]+~A' => 2,
'~\r\n?|\n~A' => 3,
);
$tokens = jsm_lex($txt, $lexer_rules);
$txt = '';
foreach($tokens as $token)
{
if($token[0] == 1)
{
list($name, $args) = $this->_extractDefNameAndArgs($token[1][1]);
$body = $token[1][3];
$m = $this->_currentModule();
if(isset($m->defs[$name]))
throw new Exception("Def '$name' is already defined in '{$m->defs[$name]->file}' (check '$file')");
if(JSM_MacroPHPNode::isValid($name))
throw new Exception("Def '$name' conflicts with PHP macro");
$node = new JSM_MacroDefNode($name, $args, $file);
$m->defs[$name] = $node;
$this->_parseDefBody($node, $file, $body);
//var_dump($name, $body);
}
else
$txt .= $token[1][0];
}
return $txt;
}
private function _replaceVarsWithMacro($file, $txt)
{
//simple vals
$txt = preg_replace(
'~\{(\$[a-zA-Z0-9_]+)\}~',
'<%SVAL($1)%>',
$txt
);
//complex vals
$txt = preg_replace(
'~\{(\$[^\}]+)\}~',
'<%VAL($1)%>',
$txt
);
return $txt;
}
private function _parseDefBody(JSM_MacroDefNode $node, $file, $txt)
{
$txt = $this->_replaceVarsWithMacro($file, $txt);
if(strpos($txt, '<%') === false)
{
$node->addChild(new JSM_TextNode($txt));
return;
}
$this->_pushNode($node);
//the idea here is to split the whole text by macro start/end tags
$lexer_rules = array(
'~<%\s*(/?\w+)\s*\(~A' => 1,
'~\)\s*%>~A' => 2,
'~[^\r\n]+?(?=(?:<%)|(?:\)\s*%>))~A' => 3,
'~[^\r\n]+~A' => 4,
'~\r\n?|\n~A' => 5,
);
$tokens = jsm_lex($txt, $lexer_rules);
foreach($tokens as $token)
{
if($token[0] == 1) //starting macro invokation
{
$name = $token[1][1];
//for neat things like <%/IF()%> => <%ENDIF()%>
if($name[0] === '/')
$name = 'END'. substr($name, 1);
$mcall = $this->_newCall($name);
if($mcall === null)
throw new Exception("No node for '$name'");
$this->_pushNode($mcall);
}
else if($token[0] == 2) //finishing macro invocation
{
$mcall = $this->_popNode();
if($mcall === null)
throw new Exception("Non paired macro ending");
$tmp_node = $this->_node(false/*non strict*/);
if($tmp_node == null)
throw new Exception("No current node(prev. node " . $mcall->name . ")");
$tmp_node->addChild($mcall);
}
else
{
$txt = $token[1][0];
$node = $this->_node();
//text append optimization
if($node instanceof JSM_MacroCallNode)
$node->addText($txt);
else
$node->addChild(new JSM_TextNode($txt));
}
}
$this->_popNode();
}
function _newCall($name)
{
$func = "macro_ex_{$name}";
if(is_callable($func))
{
return $func($this);
}
else
{
return new JSM_MacroCallNode($name);
}
}
function _getMacro($name)
{
if(isset($this->defs[$name]))
return $this->defs[$name];
if(JSM_MacroPHPNode::isValid($name))
{
$node = new JSM_MacroPHPNode($name);
$this->defs[$name] = $node;
return $node;
}
throw new Exception("Macro '$name' not found");
}
}
class JSM_Module
{
var $file = '';
var $defs = array();
var $includes = array();
var $node = null;
function __construct($file)
{
$this->file = $file;
}
function getIncludes()
{
return $this->includes;
}
function getFile()
{
return $this->file;
}
}
interface JSM_MacroNode
{
function call(JSM $jsm);
}
interface JSM_MacroInternalNode extends JSM_MacroNode
{
function addChild(JSM_MacroNode $node);
}
class JSM_TextNode implements JSM_MacroNode
{
var $txt;
function __construct($txt)
{
$this->txt = $txt;
}
function call(JSM $jsm)
{
$jsm->_buffer()->addContent($this->txt);
}
}
class JSM_MacroCallNode implements JSM_MacroInternalNode
{
var $name;
var $arg_nodes = array();
function __construct($name)
{
$this->name = $name;
}
//NOTE: children are arg nodes
function addChild(JSM_MacroNode $node)
{
$this->arg_nodes[] = $node;
}
function addText($txt)
{
if($this->arg_nodes && $this->arg_nodes[sizeof($this->arg_nodes)-1] instanceof JSM_TextNode)
$this->arg_nodes[sizeof($this->arg_nodes)-1]->txt .= $txt;
else
$this->arg_nodes[] = new JSM_TextNode($txt);
}
function call(JSM $jsm)
{
try
{
$m = $jsm->_getMacro($this->name);
$m->setUserArgs($this->arg_nodes);
$m->call($jsm);
}
catch(Exception $e)
{
throw new Exception("Error calling '{$this->name}': " . $e->getMessage());
}
}
}
class JSM_MacroPHPNode implements JSM_MacroNode
{
var $func;
var $refl;
var $user_args = '';
var $is_builtin;
var $is_eval_args; //arguments will be evaluated and eval result will be passed
var $is_raw_args; //arguments result string will be passed, not evaluated
var $is_node_args; //argument nodes will be passed as is
var $is_no_args;
function __construct($func)
{
$this->func = $func;
$php_func = "macro_$func";
$this->refl = new ReflectionFunction($php_func);
$doc = $this->refl->getDocComment();
$this->is_builtin = strpos($doc, '@builtin') !== false;
$this->is_raw_args = strpos($doc, '@raw_args') !== false;
$this->is_eval_args = strpos($doc, '@eval_args') !== false;
$this->is_no_args = strpos($doc, '@no_args') !== false;
$this->is_node_args = strpos($doc, '@node_args') !== false;
}
static function isValid($func)
{
$php_func = "macro_$func";
return is_callable($php_func);
}
function setUserArgs($arg_nodes_or_str)
{
$this->user_args = $arg_nodes_or_str;
}
function call(JSM $jsm)
{
//NOTE: making sure file containing PHP macro was actually included by this file
if(!$this->is_builtin && !$jsm->_isIncluded($this->refl->getFileName()))
throw new Exception("Not found");
$named = false;
$args = array();
if($this->is_no_args)
{} //just do nothing
else if($this->is_eval_args)
$args[] = jsm_eval_string($jsm, $jsm->nodes2str($this->user_args));
else if($this->is_raw_args)
$args[] = $jsm->nodes2str($this->user_args);
else if($this->is_node_args)
$args[] = $this->user_args;
else
list($named, $args) = $jsm->_processMacroArgs($this->user_args);
if($named)
{
$params = $this->refl->getParameters();
if($params)
array_shift($params);
//first parameter is JSM instance
$call_args = array($jsm);
foreach($params as $param)
{
$name = '$'.$param->getName();
if(!$param->isOptional())
{
if(!array_key_exists($name, $args))
throw new Exception("Required argument '$name' missing");
$call_args[] = $args[$name];
}
else
{
if(array_key_exists($name, $args))
$call_args[] = $args[$name];
else
$call_args[] = $param->getDefaultValue();
}
}
$res = $this->refl->invokeArgs($call_args);
}
else
{
//first parameter is JSM instance
array_unshift($args, $jsm);
$res = $this->refl->invokeArgs($args);
}
if($res !== null)
{
$res = $this->_processPHPMacroResult($res);
$jsm->_buffer()->addContent($res);
}
}
private function _processPHPMacroResult($res)
{
if(is_array($res))
$res = jsm_json_encode($res);
else if(!is_string($res))
$res = "$res";
return $res;
}
}
class JSM_MacroDefNode implements JSM_MacroInternalNode
{
var $name = '';
var $file = '';
var $decl_args = array();
var $node_args = array();
var $children = array();
function __construct($name, $decl_args = array(), $file = '')
{
$this->name = $name;
$this->file = $file;
$this->decl_args = $decl_args;
}
function setUserArgs($node_args_or_str)
{
$this->node_args = $node_args_or_str;
}
function addChild(JSM_MacroNode $node)
{
$this->children[] = $node;
}
function call(JSM $jsm)
{
$args_str = $jsm->nodes2str($this->node_args);
$jsm->_pushVarScope();
$this->_prepareArgs($jsm, $args_str);
foreach($this->children as $c)
$c->call($jsm);
$jsm->_popVarScope();
}
function _prepareArgs(JSM $jsm, $args_str)
{
list($named, $user_args) = $jsm->_parseMacroArgsStr($args_str);
$args = $this->decl_args;
//NOTE: overriding default args if any
if($named)
{
foreach($user_args as $k => $v)
{
if(!array_key_exists($k, $args))
throw new Exception("Macro '{$this->name}' doesn't use argument '$k'");
$args[$k] = $v;
}
}
else
{
$arg_keys = array_keys($args);
foreach($user_args as $i => $v)
{
if(!isset($arg_keys[$i]))
{
//var_dump($user_args);
throw new Exception("Macro '{$this->name}' has no argument at pos '".($i+1)."'");
}
$args[$arg_keys[$i]] = $v;
}
}
foreach($args as $k => $v)
{
if($v === null)
throw new Exception("Macro '{$this->name}' argument '$k' not passed");
$jsm->setVar($k, $v);
}
}
}
class JSM_TextBuffer
{
private $txt = '';
function addContent($txt)
{
$this->txt .= $txt;
}
function getContent()
{
return $this->txt;
}
}
class JSM_Eval
{
static function evaluate(JSM $jsm, array $bytecode)
{
$stack = array();
$result = array('value' => 0, 'logical_op' => false);
if(!$bytecode)
throw new Exception("No bytecode");
foreach($bytecode as $bc)
{
if($bc['op'] === 'IDENTIFIER')
{
$stack[] = $jsm->getVar($bc['arg']);
}
else if($bc['op'] === 'FUNC')
{
$result['logical_op'] = self::computeFunc($bc['arg'], $stack);
}
else if($bc['op'] === 'NUMBER')
{
$stack[] = 1*$bc['arg'];
}
else if($bc['op'] === 'STRING')
{
$stack[] = $bc['arg'];
}
else
throw new Exception("Unknow opcode " . $bc['op']);
}
if(sizeof($stack) != 1)
throw new Exception("Missing values on stack");
$result['value'] = $stack[0];
return $result;
}
static private function computeFunc($func, &$stack)
{
//NOP
if($func === "")
return true;
if($func === "+")
{
$b = array_pop($stack); $a = array_pop($stack);
$stack[] = ($a + $b);
return true;
}
else if($func === "-")
{
$b = array_pop($stack); $a = array_pop($stack);
$stack[] = ($a - $b);
return true;
}
else if($func === "*")
{
$b = array_pop($stack); $a = array_pop($stack);
$stack[] = ($a * $b);
return true;
}
else if($func === "/")
{
$b = array_pop($stack); $a = array_pop($stack);
$stack[] = ($a / $b);
return true;
}
else if($func === ">")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = $a > $b;
$stack[] = (int)$res;
return $res;
}
else if($func === "<")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = $a < $b;
$stack[] = (int)$res;
return $res;
}
else if($func === "==")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = $a == $b;
$stack[] = (int)$res;
return $res;
}
else if($func === "!=")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = $a != $b;
$stack[] = (int)$res;
return $res;
}
else if($func === "&&")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = (bool)$a && (bool)$b;
$stack[] = (int)$res;
return $res;
}
else if($func === "||")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = (bool)$a || (bool)$b;
$stack[] = (int)$res;
return $res;
}
else if($func === "!")
{
$a = array_pop($stack);
$res = !((bool)$a);
$stack[] = (int)$res;
return $res;
}
else if($func === ">=")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = $a >= $b;
$stack[] = (int)$res;
return $res;
}
else if($func === "<=")
{
$b = array_pop($stack); $a = array_pop($stack);
$res = $a <= $b;
$stack[] = (int)$res;
return $res;
}
else if($func === "u-")
{
$a = array_pop($stack);
$stack[] = -1 * $a;
return true;
}
else if($func === "round")
{
$a = array_pop($stack);
$stack[] = round($a);
return true;
}
else
{
throw new Exception("Unknown func " . $func);
return false;
}
}
}
class JSM_Expr
{
const T_Number = 1001;
const T_Identifier = 1002;
const T_String = 1003;
const T_LParen = 1009;
const T_RParen = 1010;
const T_Func = 1011;
//token, precedence, arity
private $funcs = array(
"," => array("", 1, 0),
"&&" => array("&&", 2, 2),
"||" => array("||", 2, 2),
"=" => array("=", 10, 2),
"+" => array("+", 12, 2),
"-" => array("-", 12, 2),
">" => array(">", 12, 2),
"<" => array("<", 12, 2),
"==" => array("==", 12, 2),
"!=" => array("!=", 12, 2),
">=" => array(">=", 12, 2),
"<=" => array("<=", 12, 2),
"*" => array("*", 13, 2),
"/" => array("/", 13, 2),
"!" => array("!", 14, 1),
"u-" => array("u-", 16, 1),
"u+" => array("", 16, 0),
"round" => array("round", 16, 1),
);
private $source;
private $cursor;
function process($expr)
{
$this->source = $expr;
$this->cursor = 0;
$tokens = $this->_tokenize();
$rpl = $this->_rpl($tokens);
$bytecode = array();
foreach($rpl as $t)
{
if($t[0] == self::T_Number)
{
$bytecode[] = array('op' => 'NUMBER', 'arg' => $t[1]);
}
else if($t[0] == self::T_Identifier)
{
$bytecode[] = array('op' => 'IDENTIFIER', 'arg' => $t[1]);
}
else if($t[0] == self::T_String)
{
$bytecode[] = array('op' => 'STRING', 'arg' => $t[1]);
}
else if($t[0] == self::T_Func)
{
$bytecode[] = array('op' => 'FUNC', 'arg' => $t[1][0]);
}
else
$this->_error("Bad token {$t[0]}");
}
return $bytecode;
}
private function _rpl(array $tokens)
{
$rpl = array();
$num_rpl = 0;
$function_stack = array();
$num_function_stack = 0;
$par_level = 0;
foreach($tokens as $token)
{
switch($token[0])
{
case self::T_Number:
case self::T_Identifier:
case self::T_String:
$rpl[$num_rpl++] = $token;
break;
case self::T_LParen:
++$par_level;
break;
case self::T_RParen:
--$par_level;
break;
case self::T_Func:
{
$f = array($token, $token[1][1], $par_level);
while($num_function_stack>0 && $this->_isPrecedenceGreaterOrEqual($function_stack[$num_function_stack-1], $f))
$rpl[$num_rpl++] = $function_stack[--$num_function_stack][0];
$function_stack[$num_function_stack++] = $f;
break;
}
}
}
if($par_level != 0)
$this->_error("Non matching parenthesis");
while($num_function_stack>0)
$rpl[$num_rpl++] = $function_stack[--$num_function_stack][0];
return $rpl;
}
private function _isPrecedenceGreaterOrEqual(array $a, array $b)
{
return $this->_cmpFunc($a, $b) >= 0;
}
private function _cmpFunc(array $a, array $b)
{
//checking paren level first
if($a[2] != $b[2]) return $a[2] - $b[2];
//checking precedence
return $a[1] - $b[1];
}
private function _symbol()
{
return substr($this->source, $this->cursor, 1);
}
private function _error($msg)
{
throw new Exception("Error in '$this->source': $msg");
}
private function _tokenize()
{
$tokens = array();
// Determines if the next + or - is a binary or unary operator.
$binary = false;
while(true)
{
$token = null;
$c = $this->_symbol();
if($c === false || $c === '')
break;
++$this->cursor;
//identifiers
if($c === '$')
{
//collect all chars of an identifier
$start = $this->cursor;
while(ctype_alnum($this->_symbol()) || $this->_symbol() == '_')
$this->cursor++;
$attribute = substr($this->source, $start, $this->cursor - $start);
$token = array(self::T_Identifier, '$'.$attribute);
$binary = true;
}
else if($c === '"')
{
//collect all chars of a string
$start = $this->cursor;
while($this->_symbol() !== '"')
$this->cursor++;
$attribute = substr($this->source, $start, $this->cursor - $start);
$token = array(self::T_String, $attribute);
$this->cursor++;
$binary = true;
}
//functions
else if(ctype_alpha($c))
{
//collect all chars of an identifier
$start = $this->cursor - 1;
while(ctype_alnum($this->_symbol()) || $this->_symbol() == '_')
$this->cursor++;
$attribute = substr($this->source, $start, $this->cursor - $start);
if($this->_symbol() !== '(')
$this->_error('( expected');
$token = $this->_getFuncToken($attribute);
$binary = true;
}
//numbers
else if(ctype_digit($c))
{
$start = $this->cursor - 1;
while(ctype_digit($this->_symbol())) $this->cursor++;
if($this->_symbol() == '.')
{
$this->cursor++;
while(ctype_digit($this->_symbol())) $this->cursor++;
}
$attribute = substr($this->source, $start, $this->cursor - $start);
$token = array(self::T_Number, $attribute);
$binary = true;
}
//operators
else
{
switch($c)
{
case ' ': case "\r": case "\t": case "\n" : break;
case '(': $token = array(self::T_LParen, $c); $binary = false; break;
case ')': $token = array(self::T_RParen, $c); $binary = true; break;
case '+': $token = $this->_getFuncToken(($binary ? '+' : 'u+'), $c); $binary = false; break;
case '-': $token = $this->_getFuncToken(($binary ? '-' : 'u-'), $c); $binary = false; break;
default:
//try to peek the next symbol and check if such an operator exists
$sym = $this->_symbol();
if($sym !== false && $sym !== '' && ($token = $this->_findFuncToken($c . $sym)))
$this->cursor++;
else
$token = $this->_getFuncToken($c);
$binary = false;
}
}
if($token !== null)
$tokens[] = $token;
}
return $tokens;
}
private function _findFuncToken($c)
{
if(!isset($this->funcs[$c]))
return null;
$f = $this->funcs[$c];
return array(self::T_Func, $f);
}
private function _getFuncToken($c)
{
$t = $this->_findFuncToken($c);
if(!$t)
$this->_error("can't find func token '$c'");
return $t;
}
}
function jsm_json_encode($data)
{
//fixig weird PHP json_encode behavior
$fixed = json_encode($data);
$fixed = str_replace(array('\\\\', '\\n', '\/'), array('\\', "\n", '/'), $fixed);
return $fixed;
}
function jsm_lex($string, array $tokenMap)
{
$tokens = array();
$offset = 0; // current offset in string
while(isset($string[$offset])) // loop as long as we aren't at the end of the string
{
foreach($tokenMap as $regex => $token)
{
if(preg_match($regex, $string, $matches, null, $offset))
{
$tokens[] = array(
$token, // token ID (e.g. T_FIELD_SEPARATOR)
$matches
);
$offset += strlen($matches[0]);
continue 2; // continue the outer while loop
}
}
throw new Exception(sprintf('Unexpected character "%s"', $string[$offset]));
}
return $tokens;
}
function jsm_is_win()
{
return !(DIRECTORY_SEPARATOR == '/');
}
function jsm_normalize_path($path, $unix=null/*null means try to guess*/)
{
if(is_null($unix))
$unix = !jsm_is_win();
$path = str_replace('\\', '/', $path);
$path = preg_replace('/\/+/', '/', $path);
$parts = explode('/', $path);
$absolutes = array();
foreach($parts as $part)
{
if('.' == $part)
continue;
if('..' == $part)
array_pop($absolutes);
else
$absolutes[] = $part;
}
$res = implode($unix ? '/' : '\\', $absolutes);
return $res;
}
function jsm_eval_string(JSM $jsm, $expr_str)
{
$expr = new JSM_Expr();
$bytecode = $expr->process($expr_str);
return JSM_Eval::evaluate($jsm, $bytecode);
}
function jsm_eval_string_bool(JSM $jsm, $expr_str)
{
$eval_res = jsm_eval_string($jsm, $expr_str);
return $eval_res['logical_op'];
}
function jsm_eval_string_value(JSM $jsm, $expr_str)
{
$eval_res = jsm_eval_string($jsm, $expr_str);
return $eval_res['value'];
}
class JSM_ArgsParser
{
const ERR_CONTEXT_CHARS = 200;
private $in;
private $len;
private $c = 0;
static $ORD_SPACE;
static $ORD_0;
static $ORD_9;
function __construct()
{
self::$ORD_SPACE = ord(' ');
self::$ORD_0 = ord('0');
self::$ORD_9 = ord('9');
}
function reset($input)
{
$this->in = $input;
$this->c = 0;
$this->len = strlen($this->in);
}
function parseInvoke($input)
{
$this->reset($input);
$args = array();
$this->skip_whitespace();
$named = false;
if($this->curr() === '$')
{
$named = true;
$this->parse_named_arg($args);
}
else
$this->parse_arg($args);
if($this->c != $this->len)
$this->_error("Trailing content({$this->c} vs {$this->len})");
return array($named, $args);
}
function parseDef($input)
{
$this->reset($input);
$args = array();
$this->parse_def_arg($args);
return $args;
}
private function next()
{
if($this->c >= $this->len)
return false;
return $this->in[$this->c++];
}
private function peek($n)
{
if(($this->c+$n) >= $this->len)
return false;
return $this->in[$this->c+$n];
}
private function curr()
{
if($this->c >= $this->len)
return false;
return $this->in[$this->c];
}
private function parse_def_arg(&$out)
{
$this->skip_whitespace();
$name = $this->parse_arg_name();
$this->skip_whitespace();
$ch = $this->next();
if($ch !== '=')
{
$out[$name] = null;
}
else
{
$this->skip_whitespace();
$value = $this->parse_arg_value();
$out[$name] = $value;
$this->skip_whitespace();
$ch = $this->next();
}
if($ch === ',')
$this->parse_def_arg($out);
}
private function parse_named_arg(&$out)
{
$this->skip_whitespace();
$name = $this->parse_arg_name();
$this->skip_whitespace();
if($this->next() !== '=')
$this->_error("'=' expected");
$this->skip_whitespace();
$value = $this->parse_arg_value();
$out[$name] = $value;
$this->skip_whitespace();
$ch = $this->next();
if($ch === ',')
$this->parse_named_arg($out);
}
private function parse_arg(&$out)
{
$this->skip_whitespace();
$value = $this->parse_arg_value();
$out[] = $value;
$this->skip_whitespace();
$ch = $this->next();
if($ch === ',')
$this->parse_arg($out);
}
private function parse_arg_name()
{
if($this->next() !== '$')
$this->_error("'$' expected");
$name = '$';
while($this->c < $this->len && (ctype_alnum($ch = $this->in[$this->c]) || ($ch === '_')))
{
$name .= $ch;
++$this->c;
}
return $name;
}
private function parse_arg_value()
{
$ch = $this->curr();
if($ch === false)
$this->_error("No data for value");
switch($ch)
{
case '[': return $this->parse_bracket_string();
case '"': return $this->parse_string();
case '\'': return $this->parse_multi_string();
case '-': return $this->parse_number();
default:
if(ord($ch) >= self::$ORD_0 && ord($ch) <= self::$ORD_9)
return $this->parse_number();
else
$this->_error("Not expected symbol");
}
}
private function parse_bracket_string()
{
if($this->curr() !== '[')
$this->_error("'[' expected");
$brackets = 1;
$start = $this->c;
++$this->c;
while($this->c < $this->len)
{
$ch =$this->in[$this->c];
if($ch === ']')
--$brackets;
else if($ch === '[')
++$brackets;
if($brackets == 0)
{
++$this->c;
$end = $this->c;
return substr($this->in, $start, $end - $start);
}
++$this->c;
}
$this->_error("Non matching '['");
}
private function parse_string()
{
if($this->next() !== '"')
$this->_error("'\"' expected");
$start = $this->c;
while($this->c < $this->len)
{
if($this->in[$this->c] === '"')
{
$end = $this->c;
++$this->c;
return substr($this->in, $start, $end - $start);
}
++$this->c;
}
$this->_error("Bad string");
}
private function parse_multi_string()
{
if($this->next() !== '\'')
$this->_error("' expected");
if($this->next() !== '\'')
$this->_error("' expected");
if($this->next() !== '\'')
$this->_error("' expected");
$start = $this->c;
while($this->c < $this->len)
{
if($this->peek(1) === "'" && $this->peek(2) === "'" && $this->peek(3) === "'")
{
$end = $this->c;
$this->c += 4;
return substr($this->in, $start, $end - $start + 1);
}
++$this->c;
}
$this->_error("Bad multi string");
}
private function parse_number()
{
$is_float = false;
$start = $this->c;
if($this->in[$this->c] == '-')
++$this->c;
while($this->c < $this->len && ord($this->in[$this->c]) >= self::$ORD_0 && ord($this->in[$this->c]) <= self::$ORD_9)
++$this->c;
if($this->c < $this->len && $this->in[$this->c] == '.')
{
$is_float = true;
++$this->c;
while($this->c < $this->len && ord($this->in[$this->c]) >= self::$ORD_0 && ord($this->in[$this->c]) <= self::$ORD_9)
++$this->c;
}
if($this->c < $this->len && ($this->in[$this->c] == 'e' || $this->in[$this->c] == 'E'))
{
$is_float = true;
++$this->c;
if($this->c < $this->len && ($this->in[$this->c] == '-' || $this->in[$this->c] == '+'))
++$this->c;
while($this->c < $this->len && ord($this->in[$this->c]) >= self::$ORD_0 && ord($this->in[$this->c]) <= self::$ORD_9)
++$this->c;
}
if($is_float)
return 1*substr($this->in, $start, $this->c - $start);
else
return (int)(1*substr($this->in, $start, $this->c - $start));
}
private function _error($error)
{
if($this->c < $this->len)
throw new Exception("Parse error: $error\n" . $this->show_position($this->c));
else
throw new Exception("Parse error: $error\n" . $this->show_position($this->len-1));
}
private function skip_whitespace()
{
while($this->c < $this->len && ord($this->in[$this->c]) <= self::$ORD_SPACE)
++$this->c;
}
private function show_position($p)
{
$pre = str_replace("\n", '', $this->get_past_input($p));
$c = str_repeat('-', max(0, strlen($pre) - 1));
return $pre . str_replace("\n", '', $this->get_upcoming_input($p)) . "\n" . $c . "^";
}
private function get_past_input($c)
{
$past = substr($this->in, 0, $c+1);
return (strlen($past) > self::ERR_CONTEXT_CHARS ? '...' : '') . substr($past, -self::ERR_CONTEXT_CHARS);
}
private function get_upcoming_input($c)
{
$next = substr($this->in, $c+1);
return substr($next, 0, self::ERR_CONTEXT_CHARS) . (strlen($next) > self::ERR_CONTEXT_CHARS ? '...' : '');
}
}
//////////////////////////////////////////////////////
/**
* @builtin @raw_args
*/
function macro_DEP($jsm)
{}
/**
* @builtin @raw_args
*/
function macro_INC($jsm, $file)
{
$m = $jsm->getModule($file);
$m->node->call($jsm);
}
/**
* @builtin @raw_args
*/
function macro_LET($jsm, $txt_args)
{
$items = explode("=", $txt_args, 2);
$eval_res = jsm_eval_string($jsm, $items[1]);
$jsm->setVar(trim($items[0]), $eval_res['value']);
}
/**
* @builtin @raw_args
*/
function macro_VAL($jsm, $txt_args)
{
if(strpos($txt_args, '$$') === 0)
{
$const_name = $txt_args;
if(!preg_match('~^\$\$[a-zA-Z0-9_]+$~', $const_name))
throw new Exception("Bad characters in const name: '{$const_name}'");
return $jsm->getAutoConst(substr($const_name, 2));
}
if(strpos($txt_args, '$(') === 0)
$txt_args = ltrim($txt_args, '$');
$eval_res = jsm_eval_string($jsm, $txt_args);
return $eval_res['value'];
}
//simple version of variable echoing
/**
* @builtin @raw_args
*/
function macro_SVAL($jsm, $txt_args)
{
return $jsm->getVar($txt_args);
}
/**
* @builtin
*/
function macro_CONST($jsm, $k, $v)
{
$jsm->setConst($k, $v);
}
class JSM_If implements JSM_MacroInternalNode
{
private $branches = array();
function addToArgs(JSM_MacroNode $node)
{
if($this->branches && $this->branches[sizeof($this->branches)-1]['cond'] === null)
throw new Exception("ELSE has no args");
$this->branches[sizeof($this->branches)-1]['cond'][] = $node;
}
function addChild(JSM_MacroNode $node)
{
$b = &$this->branches[sizeof($this->branches)-1]['nodes'];
$b[] = $node;
}
function addBranch()
{
if($this->branches && $this->branches[sizeof($this->branches)-1]['cond'] === null)
throw new Exception("Not expecting any more branches");
$this->branches[] = array('cond' => array(), 'nodes' => array());
return new JSM_IfBranch($this);
}
function addElse()
{
$this->branches[] = array('cond' => null, 'nodes' => array());
return new JSM_IfBranch($this);
}
function call(JSM $jsm)
{
$branch_found = false;
foreach($this->branches as $b)
{
//else special case
if($b['cond'] === null)
continue;
$cond_txt = $jsm->nodes2str($b['cond']);
if(jsm_eval_string_bool($jsm, $cond_txt))
{
foreach($b['nodes'] as $node)
{
$node->call($jsm);
}
$branch_found = true;
}
}
if(!$branch_found)
{
$b = $this->branches[sizeof($this->branches)-1];
//checking if it's an else node
if($b['cond'] === null)
{
foreach($b['nodes'] as $node)
$node->call($jsm);
}
}
}
}
class JSM_IfBranch implements JSM_MacroInternalNode
{
private $if;
function __construct(JSM_If $if)
{
$this->if = $if;
}
function addChild(JSM_MacroNode $node)
{
$this->if->addToArgs($node);
}
function call(JSM $jsm)
{}
}
function macro_ex_IF(JSM $jsm)
{
$if = new JSM_If();
$jsm->_pushNode($if);
return $if->addBranch();
}
function macro_ex_ELSIF(JSM $jsm)
{
$if = $jsm->_node();
if(!($if instanceof JSM_If))
throw new Exception("Not expected ELSIF");
return $if->addBranch();
}
function macro_ex_ELSE(JSM $jsm)
{
$if = $jsm->_node();
if(!($if instanceof JSM_If))
throw new Exception("Not expected ELSE");
return $if->addElse();
}
function macro_ex_ENDIF(JSM $jsm)
{
$if = $jsm->_popNode();
if(!($if instanceof JSM_If))
throw new Exception("Not expected ENDIF");
return $if;
}
class JSM_Rep implements JSM_MacroInternalNode
{
private $children = array();
private $rep_args = array();
function addNumber()
{
return new JSM_RepNumber($this);
}
function addToArgs(JSM_MacroNode $node)
{
$this->rep_args[] = $node;
}
function addChild(JSM_MacroNode $n)
{
$this->children[] = $n;
}
function call(JSM $jsm)
{
$reps = jsm_eval_string_value($jsm, $jsm->nodes2str($this->rep_args));
for($i=0;$i<$reps;++$i)
{
$jsm->setVar('$_REP_INDEX_', $i);
foreach($this->children as $n)
$n->call($jsm);
}
}
}
class JSM_RepNumber implements JSM_MacroInternalNode
{
var $rep;
function __construct(JSM_Rep $rep)
{
$this->rep = $rep;
}
function addChild(JSM_MacroNode $n)
{
$this->rep->addToArgs($n);
}
function call(JSM $jsm)
{}
}
function macro_ex_REP(JSM $jsm)
{
$rep = new JSM_Rep();
$jsm->_pushNode($rep);
return $rep->addNumber();
}
function macro_ex_ENDREP(JSM $jsm)
{
$rep = $jsm->_popNode();
if(!($rep instanceof JSM_Rep))
throw new Exception("Not expected ENDREP");
return $rep;
}
/**
* @builtin @raw_args
*/
function macro_CALL($proc, $raw_args)
{
list($name, $call_args) = explode(",", $raw_args, 2);
$name = trim($name, '"');
$m = $proc->_getMacro($name);
$m->setUserArgs($call_args);
$m->call($proc);
}
/**
* @builtin @eval_args
*/
function macro_TRACE($jsm, array $eval_res)
{
echo "TRACE: " . $eval_res['value'] . "\n";
}
/**
* @builtin @raw_args
*/
function macro_LET_IF($jsm, $raw_args)
{
list($let, $cond) = explode(",", $raw_args, 2);
$eval_res = jsm_eval_string($jsm, $cond);
if($eval_res['logical_op'])
{
$items = explode("=", $let, 2);
$eval_res = jsm_eval_string($jsm, $items[1]);
$jsm->setVar(trim($items[0]), $eval_res['value']);
}
}
Reference in New Issue View Git Blame Copy Permalink