252 lines
8.2 KiB
PHP
252 lines
8.2 KiB
PHP
<?php
|
|
|
|
class Symbol {
|
|
public $id = NULL;
|
|
public $name = NULL;
|
|
public $value = NULL;
|
|
public $first = NULL;
|
|
public $second = NULL;
|
|
public $third = NULL;
|
|
public $lbp = 0;
|
|
public $reserved = FALSE;
|
|
public $global_scope = FALSE;
|
|
public $assignment = FALSE;
|
|
public $arity;
|
|
public $type;
|
|
public $line_number;
|
|
public $char_pos;
|
|
|
|
public $nud = 'nud_default';
|
|
public $led = 'led_default';
|
|
public $std = NULL;
|
|
|
|
public $bp = 0;
|
|
|
|
public function possible_variable() {
|
|
return $this->value == '.' || $this->value == '[' || $this->arity == 'name';
|
|
}
|
|
|
|
public function is_option() {
|
|
return $this->first && ($this->value == '||' || $this->value == '&&');
|
|
}
|
|
|
|
public function is_lookup($statement = NULL) {
|
|
if (!$statement) {
|
|
$statement = $this;
|
|
}
|
|
|
|
$first = $statement->first;
|
|
$second = $statement->second;
|
|
|
|
if ($first && $statement->arity == 'binary' && ($statement->id == '.' || $statement->id == '[')) {
|
|
return (is_object($first) && $first->is_lookup() && $second->arity == 'literal');
|
|
}
|
|
else {
|
|
return ($statement->arity == 'name' || $statement->arity == 'literal' || $statement->arity == 'this');
|
|
}
|
|
}
|
|
|
|
public function resolve($as_array = FALSE, $statement = NULL, $public = FALSE, $firsts = array()) {
|
|
if (!$statement) {
|
|
$public = TRUE; // Whether the call is non-resursive
|
|
$statement = $this;
|
|
}
|
|
|
|
$first = $statement->first;
|
|
$second = $statement->second;
|
|
|
|
$results = array();
|
|
|
|
if ($first && $statement->arity == 'binary' && ($statement->id == '.' || $statement->id == '[')) {
|
|
// foo.bar.baz or foo["bar"].baz
|
|
foreach ($this->resolve(TRUE, $first, FALSE, $firsts) as $resolved) {
|
|
list($is_global, $name) = $resolved;
|
|
|
|
if (!$second->arity == 'literal') {
|
|
throw new Exception(sprintf('Line %d, char %d: Lookup is not by literal: %s', $statement->line_number, $statement->char_pos, $second));
|
|
}
|
|
|
|
if (is_object($name) && $name->id == '{') {
|
|
$is_global = $first->global_scope;
|
|
|
|
// The parent item resolved to an object
|
|
// so we need to continue the lookup
|
|
foreach ($name->first as $value) {
|
|
// -> first has all values with their key
|
|
if ($value->key == $second->value) {
|
|
if ($value->first() == $statement->first()) {
|
|
// Object references itself, within itself
|
|
continue;
|
|
}
|
|
if ($value->arity == 'name') {
|
|
// Contains an actual variable name
|
|
$results[] = array($value->global_scope, $value->value);
|
|
break 2;
|
|
}
|
|
elseif ($value->arity == 'binary' && ($value->id == '.' || $value->id == '[')) {
|
|
// Contains a new variable for us to resolve
|
|
$results = array_merge($results, $this->resolve(TRUE, $value, TRUE, $firsts));
|
|
break 2;
|
|
}
|
|
elseif (!$public && $value->id == '{') {
|
|
// Contains an object
|
|
$results[] = array(NULL, $value);
|
|
break 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
$name = $first->value;
|
|
}
|
|
|
|
if (!is_string($name)) {
|
|
throw new Exception(sprintf('Line %d, char %d: Parent variable resolution returned an unknown (%s)', $statement->line_number, $statement->char_pos, $statement));
|
|
}
|
|
|
|
if ($is_global && $name == 'this') {
|
|
$results[] = array($is_global, $second->value);
|
|
}
|
|
else {
|
|
$results[] = array($is_global, sprintf('%s.%s', $name, $second->value));
|
|
}
|
|
}
|
|
|
|
return $as_array ? $results : $results[0];
|
|
}
|
|
elseif ($statement->arity == 'name' || $statement->arity == 'literal' || $statement->arity == 'this') {
|
|
// This is the first item in the variable (e.g. for foo.bar.baz, it would be foo)
|
|
// It only matters if it's an object or an assignment
|
|
if ($assignments = $statement->scope->assigned($statement->value, TRUE)) {
|
|
foreach ($assignments as $assignment) {
|
|
if ($assignment->first() != $statement->first() && !in_array($statement->first(), $firsts)) {
|
|
if ($assignment->arity == 'name') {
|
|
$results[] = array($assignment->global_scope, $assignment->value);
|
|
}
|
|
elseif ($assignment->arity == 'binary' && ($assignment->id == '.' || $assignment->id == '[')) {
|
|
// Deal with stuff like c = p.constructor;
|
|
// followed by p = c.superclass
|
|
// where they "look each other up"
|
|
$results = array_merge($results, $this->resolve(TRUE, $assignment, TRUE, array_merge($firsts, array($statement->first()))));
|
|
}
|
|
elseif (!$public && $assignment->id == '{') {
|
|
$results[] = array(NULL, $assignment);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (count($results)) {
|
|
return $as_array ? $results : $results[0];
|
|
}
|
|
|
|
$result = array($statement->global_scope, $statement->value);
|
|
return $as_array ? array($result) : $result;
|
|
}
|
|
|
|
throw new Exception(sprintf('Line %d, char %d: Expected a variable in the form foo.bar with %s', $statement->line_number, $statement->char_pos, $statement->id));
|
|
}
|
|
|
|
public function first($statement = NULL) {
|
|
if (!$statement) {
|
|
$statement = $this;
|
|
}
|
|
|
|
$first = $statement->first;
|
|
$second = $statement->second;
|
|
|
|
if ($first && $statement->arity == 'binary' && ($statement->id == '.' || $statement->id == '[')) {
|
|
return $this->first($first);
|
|
}
|
|
elseif ($statement->arity == 'name') {
|
|
return $statement->value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a symbol with a statement denotation function
|
|
* that reads until it finds an opening {
|
|
*/
|
|
public function block($parser) {
|
|
$parser->peek('{');
|
|
$token = $parser->token;
|
|
$parser->advance('{');
|
|
return $token->std($parser);
|
|
}
|
|
|
|
public function nud_default($parser) {
|
|
throw new Exception("Syntax error on line {$this->line_number}, character {$this->char_pos} ({$this->id}:'{$this->value}')");
|
|
}
|
|
|
|
public function nud_prefix($parser) {
|
|
$this->first = $parser->expression(70);
|
|
return $this;
|
|
}
|
|
|
|
public function nud_itself($parser) {
|
|
return $this;
|
|
}
|
|
|
|
public function nud_constant($parser) {
|
|
$parser->scope->reserve($this);
|
|
$this->value = $parser->new_symbol($this->id, TRUE)->value;
|
|
$this->arity = 'literal';
|
|
return $this;
|
|
}
|
|
|
|
public function led_default($parser, $left) {
|
|
throw new Exception("Unknown operator ({$this->id}:'{$this->value}')");
|
|
}
|
|
|
|
public function led_infix($parser, $left) {
|
|
$this->first = $left;
|
|
$this->second = $parser->expression($this->bp);
|
|
return $this;
|
|
}
|
|
|
|
public function led_infixr($parser, $left) {
|
|
$this->first = $left;
|
|
$this->second = $parser->expression($this->bp - 1);
|
|
return $this;
|
|
}
|
|
|
|
public function led_assignment($parser, $left) {
|
|
if ($left->id != '.' && $left->id != '[' && $left->arity != 'name') {
|
|
throw new Error('Bad lvalue');
|
|
}
|
|
$this->first = $left;
|
|
$this->second = $parser->expression(9);
|
|
$this->assignment = true;
|
|
$this->arity = 'binary';
|
|
return $this;
|
|
}
|
|
|
|
public function __call($method, $args) {
|
|
if ($method == 'lbp') {
|
|
if (is_numeric($this->lbp)) {
|
|
return $this->lbp;
|
|
}
|
|
return call_user_func_array(array($this, $this->lbp), $args);
|
|
}
|
|
if ($method == 'nud') {
|
|
return call_user_func_array(array($this, $this->nud), $args);
|
|
}
|
|
if ($method == 'led') {
|
|
return call_user_func_array(array($this, $this->led), $args);
|
|
}
|
|
if ($method == 'std') {
|
|
return call_user_func_array(array($this, $this->std), $args);
|
|
}
|
|
}
|
|
|
|
public function __toString() {
|
|
// debug_backtrace_clean();
|
|
if ($this->id == '(name)' || $this->id == '(literal)') {
|
|
return '(' . substr($this->id, 1, strlen($this->id) - 2) . " {$this->value})";
|
|
}
|
|
$first = is_array($this->first) ? ('[' . implode(', ', $this->first) . ']') : $this->first;
|
|
$second = is_array($this->second) ? ('[' . implode(', ', $this->second) . ']') : $this->second;
|
|
$third = is_array($this->third) ? ('[' . implode(', ', $this->third) . ']') : $this->third;
|
|
$out = array_diff(array($this->id, $first, $second, $third), array(NULL));
|
|
return '(' . implode(' ', $out) . ')';
|
|
}
|
|
} |