sfos/ledger
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 't/scopes' into next

Browse source
This commit is contained in:
John Wiegley 2012-02-21 01:45:36 -06:00
commit 902673a199
8 changed files with 182 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/compare.cc
View file

@ -44,7 +44,7 @@ void push_sort_value(std::list<sort_value_t>& sort_values,
if (node->kind == expr_t::op_t::O_CONS) { if (node->kind == expr_t::op_t::O_CONS) {
while (node && node->kind == expr_t::op_t::O_CONS) { while (node && node->kind == expr_t::op_t::O_CONS) {
push_sort_value(sort_values, node->left(), scope); push_sort_value(sort_values, node->left(), scope);
node = node->right(); node = node->has_right() ? node->right() : NULL;
} }
} else { } else {
bool inverted = false; bool inverted = false;

2
src/format.cc
View file

@ -225,7 +225,7 @@ format_t::element_t * format_t::parse_elements(const string& fmt,
expr_t::ptr_op_t colorize_op; expr_t::ptr_op_t colorize_op;
if (op->kind == expr_t::op_t::O_CONS) { if (op->kind == expr_t::op_t::O_CONS) {
amount_op = op->left(); amount_op = op->left();
colorize_op = op->right(); colorize_op = op->has_right() ? op->right() : NULL;
} else { } else {
amount_op = op; amount_op = op;
} }

230
src/op.cc
View file

@ -50,7 +50,7 @@ namespace {
expr_t::ptr_op_t value_op; expr_t::ptr_op_t value_op;
if (next->kind == expr_t::op_t::O_CONS) { if (next->kind == expr_t::op_t::O_CONS) {
value_op = next->left(); value_op = next->left();
next = next->right(); next = next->has_right() ? next->right() : NULL;
} else { } else {
value_op = next; value_op = next;
next = NULL; next = NULL;
@ -78,10 +78,12 @@ namespace {
expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth) expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
{ {
if (is_ident()) { scope_t * scope_ptr = &scope;
DEBUG("expr.compile", "lookup: " << as_ident());
if (ptr_op_t def = scope.lookup(symbol_t::FUNCTION, as_ident())) { if (is_ident()) {
DEBUG("expr.compile", "Lookup: " << as_ident());
if (ptr_op_t def = scope_ptr->lookup(symbol_t::FUNCTION, as_ident())) {
// Identifier references are first looked up at the point of // Identifier references are first looked up at the point of
// definition, and then at the point of every use if they could // definition, and then at the point of every use if they could
// not be found there. // not be found there.
@ -98,36 +100,40 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
} }
return this; return this;
} }
else if (is_scope()) {
if (kind < TERMINALS) shared_ptr<scope_t> subscope(new symbol_scope_t(scope));
set_scope(subscope);
scope_ptr = subscope.get();
}
else if (kind < TERMINALS) {
return this; return this;
}
if (kind == O_DEFINE) { else if (kind == O_DEFINE) {
switch (left()->kind) { switch (left()->kind) {
case IDENT: case IDENT:
scope.define(symbol_t::FUNCTION, left()->as_ident(), right()); scope_ptr->define(symbol_t::FUNCTION, left()->as_ident(), right());
break; break;
case O_CALL: case O_CALL:
if (left()->left()->is_ident()) { if (left()->left()->is_ident()) {
ptr_op_t node(new op_t(op_t::O_LAMBDA)); ptr_op_t node(new op_t(op_t::O_LAMBDA));
node->set_left(left()->right()); node->set_left(left()->right());
node->set_right(right()); node->set_right(right());
scope_ptr->define(symbol_t::FUNCTION, left()->left()->as_ident(),
scope.define(symbol_t::FUNCTION, left()->left()->as_ident(), node); node);
} else { break;
throw_(compile_error, _("Invalid function definition"));
} }
break; // fall through...
default: default:
throw_(compile_error, _("Invalid function definition")); throw_(compile_error, _("Invalid function definition"));
} }
return wrap_value(value_t());
} }
ptr_op_t lhs(left()->compile(scope, depth)); ptr_op_t lhs(left()->compile(*scope_ptr, depth));
ptr_op_t rhs(kind > UNARY_OPERATORS && has_right() ? ptr_op_t rhs(kind > UNARY_OPERATORS && has_right() ?
(kind == O_LOOKUP ? right() : (kind == O_LOOKUP ? right() :
right()->compile(scope, depth)) : NULL); right()->compile(*scope_ptr, depth)) : NULL);
if (lhs == left() && (! rhs || rhs == right())) if (lhs == left() && (! rhs || rhs == right()))
return this; return this;
@ -136,25 +142,22 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
// Reduce constants immediately if possible // Reduce constants immediately if possible
if ((! lhs || lhs->is_value()) && (! rhs || rhs->is_value())) if ((! lhs || lhs->is_value()) && (! rhs || rhs->is_value()))
return wrap_value(intermediate->calc(scope, NULL, depth)); return wrap_value(intermediate->calc(*scope_ptr, NULL, depth + 1));
return intermediate; return intermediate;
} }
value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth) value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
{ {
#if defined(DEBUG_ON)
bool skip_debug = false;
#endif
try { try {
value_t result; value_t result;
#if defined(DEBUG_ON) #if defined(DEBUG_ON)
if (! skip_debug && SHOW_DEBUG("expr.calc")) { if (SHOW_DEBUG("expr.calc")) {
for (int i = 0; i < depth; i++) for (int i = 0; i < depth; i++)
ledger::_log_buffer << '.'; ledger::_log_buffer << '.';
ledger::_log_buffer << op_context(this) << " => ..."; ledger::_log_buffer << op_context(this) << " => ...";
DEBUG("expr.calc", ""); DEBUG("expr.calc", "");
} }
#endif #endif
@ -165,40 +168,83 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
break; break;
case O_DEFINE: case O_DEFINE:
//result = left()->calc(scope, locus, depth + 1);
result = NULL_VALUE; result = NULL_VALUE;
break; break;
case IDENT: { case IDENT: {
ptr_op_t definition = left(); ptr_op_t definition = left();
// If no definition was pre-compiled for this identifier, look it up
// in the current scope.
if (! definition) { if (! definition) {
// If no definition was pre-compiled for this identifier, look it DEBUG("scope.symbols", "Looking for IDENT '" << as_ident() << "'");
// up in the current scope.
definition = scope.lookup(symbol_t::FUNCTION, as_ident()); definition = scope.lookup(symbol_t::FUNCTION, as_ident());
} }
if (! definition) if (! definition)
throw_(calc_error, _("Unknown identifier '%1'") << as_ident()); throw_(calc_error, _("Unknown identifier '%1'") << as_ident());
// Evaluating an identifier is the same as calling its definition // Evaluating an identifier is the same as calling its definition
// directly, so we create an empty call_scope_t to reflect the scope for // directly
// this implicit call. result = definition->calc(scope, locus, depth + 1);
call_scope_t call_args(scope, locus, depth);
result = definition->compile(call_args, depth + 1)
->calc(call_args, locus, depth + 1);
check_type_context(scope, result); check_type_context(scope, result);
break; break;
} }
case FUNCTION: { case FUNCTION: {
// Evaluating a FUNCTION is the same as calling it directly; this happens // Evaluating a FUNCTION is the same as calling it directly; this
// when certain functions-that-look-like-variables (such as "amount") are // happens when certain functions-that-look-like-variables (such as
// resolved. // "amount") are resolved.
call_scope_t call_args(scope, locus, depth); call_scope_t call_args(scope, locus, depth + 1);
result = as_function()(call_args); result = as_function()(call_args);
check_type_context(scope, result); check_type_context(scope, result);
#if defined(DEBUG_ON) break;
skip_debug = true; }
#endif
case SCOPE:
assert(! is_scope_unset());
if (is_scope_unset()) {
symbol_scope_t subscope(scope);
result = left()->calc(subscope, locus, depth + 1);
} else {
bind_scope_t bound_scope(scope, *as_scope());
result = left()->calc(bound_scope, locus, depth + 1);
}
break;
case O_LOOKUP: {
context_scope_t context_scope(scope, value_t::SCOPE);
bool scope_error = true;
if (value_t obj = left()->calc(context_scope, locus, depth + 1)) {
if (obj.is_scope() && obj.as_scope() != NULL) {
bind_scope_t bound_scope(scope, *obj.as_scope());
result = right()->calc(bound_scope, locus, depth + 1);
scope_error = false;
}
}
if (scope_error)
throw_(calc_error, _("Left operand does not evaluate to an object"));
break;
}
case O_CALL: {
ptr_op_t func = left();
const string& name(func->as_ident());
func = func->left();
if (! func)
func = scope.lookup(symbol_t::FUNCTION, name);
if (! func)
throw_(calc_error, _("Calling unknown function '%1'") << name);
call_scope_t call_args(scope, locus, depth + 1);
if (has_right())
call_args.set_args(split_cons_expr(right()));
if (func->is_function())
result = func->as_function()(call_args);
else
result = func->calc(call_args, locus, depth + 1);
check_type_context(scope, result);
break; break;
} }
@ -207,13 +253,11 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
std::size_t args_count(call_args.size()); std::size_t args_count(call_args.size());
std::size_t args_index(0); std::size_t args_index(0);
symbol_scope_t call_scope(call_args); symbol_scope_t call_scope(call_args);
ptr_op_t sym(left());
for (; sym; sym = sym->has_right() ? sym->right() : NULL) {
ptr_op_t varname = sym;
if (sym->kind == O_CONS)
varname = sym->left();
for (ptr_op_t sym = left();
sym;
sym = sym->has_right() ? sym->right() : NULL) {
ptr_op_t varname = sym->kind == O_CONS ? sym->left() : sym;
if (! varname->is_ident()) { if (! varname->is_ident()) {
throw_(calc_error, _("Invalid function definition")); throw_(calc_error, _("Invalid function definition"));
} }
@ -237,59 +281,6 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
break; break;
} }
case O_LOOKUP: {
context_scope_t context_scope(scope, value_t::SCOPE);
bool scope_error = true;
if (value_t obj = left()->calc(context_scope, locus, depth + 1)) {
if (obj.is_scope() && obj.as_scope() != NULL) {
bind_scope_t bound_scope(scope, *obj.as_scope());
result = right()->calc(bound_scope, locus, depth + 1);
scope_error = false;
}
}
if (scope_error)
throw_(calc_error, _("Left operand does not evaluate to an object"));
break;
}
case O_CALL: {
call_scope_t call_args(scope, locus, depth);
if (has_right())
call_args.set_args(split_cons_expr(right()));
ptr_op_t func = left();
const string& name(func->as_ident());
func = func->left();
if (! func)
func = scope.lookup(symbol_t::FUNCTION, name);
if (! func)
throw_(calc_error, _("Calling unknown function '%1'") << name);
#if defined(DEBUG_ON)
if (! skip_debug && SHOW_DEBUG("expr.calc")) {
for (int i = 0; i < depth; i++)
ledger::_log_buffer << '.';
ledger::_log_buffer << " args: ";
if (call_args.args.is_sequence()) {
foreach (value_t& arg, call_args)
ledger::_log_buffer << arg << " ";
} else {
ledger::_log_buffer << call_args.args[0] << " ";
}
DEBUG("expr.calc", "");
}
#endif
if (func->is_function())
result = func->as_function()(call_args);
else
result = func->calc(call_args, locus, depth + 1);
check_type_context(scope, result);
break;
}
case O_MATCH: case O_MATCH:
result = (right()->calc(scope, locus, depth + 1).as_mask() result = (right()->calc(scope, locus, depth + 1).as_mask()
.match(left()->calc(scope, locus, depth + 1).to_string())); .match(left()->calc(scope, locus, depth + 1).to_string()));
@ -358,7 +349,6 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
case O_QUERY: case O_QUERY:
assert(right()); assert(right());
assert(right()->kind == O_COLON); assert(right()->kind == O_COLON);
if (value_t temp = left()->calc(scope, locus, depth + 1)) if (value_t temp = left()->calc(scope, locus, depth + 1))
result = right()->left()->calc(scope, locus, depth + 1); result = right()->left()->calc(scope, locus, depth + 1);
else else
@ -371,8 +361,6 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
case O_CONS: case O_CONS:
result = left()->calc(scope, locus, depth + 1); result = left()->calc(scope, locus, depth + 1);
DEBUG("op.cons", "car = " << result);
if (has_right()) { if (has_right()) {
value_t temp; value_t temp;
temp.push_back(result); temp.push_back(result);
@ -382,28 +370,25 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
ptr_op_t value_op; ptr_op_t value_op;
if (next->kind == O_CONS) { if (next->kind == O_CONS) {
value_op = next->left(); value_op = next->left();
next = next->right(); next = next->has_right() ? next->right() : NULL;
} else { } else {
value_op = next; value_op = next;
next = NULL; next = NULL;
} }
temp.push_back(value_op->calc(scope, locus, depth + 1)); temp.push_back(value_op->calc(scope, locus, depth + 1));
DEBUG("op.cons", "temp now = " << temp);
} }
result = temp; result = temp;
} }
break; break;
case O_SEQ: { case O_SEQ: {
symbol_scope_t seq_scope(scope); // An O_SEQ is very similar to an O_CONS except that only the last
// result value in the series is kept. O_CONS builds up a list.
// An O_SEQ is very similar to an O_CONS except that only the last result
// value in the series is kept. O_CONS builds up a list.
// //
// Another feature of O_SEQ is that it pushes a new symbol scope onto the // Another feature of O_SEQ is that it pushes a new symbol scope
// stack. // onto the stack. We evaluate the left side here to catch any
result = left()->calc(seq_scope, locus, depth + 1); // side-effects, such as definitions in the case of 'x = 1; x'.
result = left()->calc(scope, locus, depth + 1);
if (has_right()) { if (has_right()) {
ptr_op_t next = right(); ptr_op_t next = right();
while (next) { while (next) {
@ -415,7 +400,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
value_op = next; value_op = next;
next = NULL; next = NULL;
} }
result = value_op->calc(seq_scope, locus, depth + 1); result = value_op->calc(scope, locus, depth + 1);
} }
} }
break; break;
@ -426,7 +411,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
} }
#if defined(DEBUG_ON) #if defined(DEBUG_ON)
if (! skip_debug && SHOW_DEBUG("expr.calc")) { if (SHOW_DEBUG("expr.calc")) {
for (int i = 0; i < depth; i++) for (int i = 0; i < depth; i++)
ledger::_log_buffer << '.'; ledger::_log_buffer << '.';
ledger::_log_buffer << op_context(this) << " => "; ledger::_log_buffer << op_context(this) << " => ";
@ -476,9 +461,8 @@ namespace {
if (op->has_right()) { if (op->has_right()) {
out << "; "; out << "; ";
if (op->right()->kind == expr_t::op_t::O_SEQ)
if (op->right()->kind == expr_t::op_t::O_CONS) found = print_seq(out, op->right(), context);
found = print_cons(out, op->right(), context);
else if (op->right()->print(out, context)) else if (op->right()->print(out, context))
found = true; found = true;
} }
@ -515,6 +499,11 @@ bool expr_t::op_t::print(std::ostream& out, const context_t& context) const
out << "<FUNCTION>"; out << "<FUNCTION>";
break; break;
case SCOPE:
if (left() && left()->print(out, context))
found = true;
break;
case O_NOT: case O_NOT:
out << "! "; out << "! ";
if (left() && left()->print(out, context)) if (left() && left()->print(out, context))
@ -625,7 +614,6 @@ bool expr_t::op_t::print(std::ostream& out, const context_t& context) const
case O_CONS: case O_CONS:
found = print_cons(out, this, context); found = print_cons(out, this, context);
break; break;
case O_SEQ: case O_SEQ:
found = print_seq(out, this, context); found = print_seq(out, this, context);
break; break;
@ -726,6 +714,14 @@ void expr_t::op_t::dump(std::ostream& out, const int depth) const
out << "FUNCTION"; out << "FUNCTION";
break; break;
case SCOPE:
out << "SCOPE: ";
if (is_scope_unset())
out << "null";
else
out << as_scope().get();
break;
case O_DEFINE: out << "O_DEFINE"; break; case O_DEFINE: out << "O_DEFINE"; break;
case O_LOOKUP: out << "O_LOOKUP"; break; case O_LOOKUP: out << "O_LOOKUP"; break;
case O_LAMBDA: out << "O_LAMBDA"; break; case O_LAMBDA: out << "O_LAMBDA"; break;
@ -765,7 +761,7 @@ void expr_t::op_t::dump(std::ostream& out, const int depth) const
// An identifier is a special non-terminal, in that its left() can // An identifier is a special non-terminal, in that its left() can
// hold the compiled definition of the identifier. // hold the compiled definition of the identifier.
if (kind > TERMINALS || is_ident()) { if (kind > TERMINALS || is_scope()) {
if (left()) { if (left()) {
left()->dump(out, depth + 1); left()->dump(out, depth + 1);
if (kind > UNARY_OPERATORS && has_right()) if (kind > UNARY_OPERATORS && has_right())

51
src/op.h
View file

@ -58,10 +58,12 @@ private:
mutable short refc; mutable short refc;
ptr_op_t left_; ptr_op_t left_;
variant<ptr_op_t, // used by all binary operators variant<boost::blank,
ptr_op_t, // used by all binary operators
value_t, // used by constant VALUE value_t, // used by constant VALUE
string, // used by constant IDENT string, // used by constant IDENT
expr_t::func_t // used by terminal FUNCTION expr_t::func_t, // used by terminal FUNCTION
shared_ptr<scope_t> // used by terminal SCOPE
> data; > data;
public: public:
@ -73,6 +75,7 @@ public:
CONSTANTS, CONSTANTS,
FUNCTION, FUNCTION,
SCOPE,
TERMINALS, TERMINALS,
@ -173,7 +176,7 @@ public:
return kind == FUNCTION; return kind == FUNCTION;
} }
expr_t::func_t& as_function_lval() { expr_t::func_t& as_function_lval() {
assert(kind == FUNCTION); assert(is_function());
return boost::get<expr_t::func_t>(data); return boost::get<expr_t::func_t>(data);
} }
const expr_t::func_t& as_function() const { const expr_t::func_t& as_function() const {
@ -183,21 +186,41 @@ public:
data = val; data = val;
} }
bool is_scope() const {
return kind == SCOPE;
}
bool is_scope_unset() const {
return data.which() == 0;
}
shared_ptr<scope_t> as_scope_lval() {
assert(is_scope());
return boost::get<shared_ptr<scope_t> >(data);
}
const shared_ptr<scope_t> as_scope() const {
return const_cast<op_t *>(this)->as_scope_lval();
}
void set_scope(shared_ptr<scope_t> val) {
data = val;
}
// These three functions must use 'kind == IDENT' rather than
// 'is_ident()', because they are called before the `data' member gets
// set, which is_ident() tests.
ptr_op_t& left() { ptr_op_t& left() {
assert(kind > TERMINALS || kind == IDENT); assert(kind > TERMINALS || kind == IDENT || is_scope());
return left_; return left_;
} }
const ptr_op_t& left() const { const ptr_op_t& left() const {
assert(kind > TERMINALS || kind == IDENT); assert(kind > TERMINALS || kind == IDENT || is_scope());
return left_; return left_;
} }
void set_left(const ptr_op_t& expr) { void set_left(const ptr_op_t& expr) {
assert(kind > TERMINALS || kind == IDENT); assert(kind > TERMINALS || kind == IDENT || is_scope());
left_ = expr; left_ = expr;
} }
ptr_op_t& as_op_lval() { ptr_op_t& as_op_lval() {
assert(kind > TERMINALS || kind == IDENT); assert(kind > TERMINALS || is_ident());
return boost::get<ptr_op_t>(data); return boost::get<ptr_op_t>(data);
} }
const ptr_op_t& as_op() const { const ptr_op_t& as_op() const {
@ -219,7 +242,7 @@ public:
bool has_right() const { bool has_right() const {
if (kind < TERMINALS) if (kind < TERMINALS)
return false; return false;
return as_op(); return data.which() != 0 && as_op();
} }
private: private:
@ -284,6 +307,7 @@ public:
static ptr_op_t wrap_value(const value_t& val); static ptr_op_t wrap_value(const value_t& val);
static ptr_op_t wrap_functor(expr_t::func_t fobj); static ptr_op_t wrap_functor(expr_t::func_t fobj);
static ptr_op_t wrap_scope(shared_ptr<scope_t> sobj);
#if defined(HAVE_BOOST_SERIALIZATION) #if defined(HAVE_BOOST_SERIALIZATION)
private: private:
@ -295,13 +319,13 @@ private:
void serialize(Archive& ar, const unsigned int /* version */) { void serialize(Archive& ar, const unsigned int /* version */) {
ar & refc; ar & refc;
ar & kind; ar & kind;
if (Archive::is_loading::value || ! left_ || left_->kind != FUNCTION) { if (Archive::is_loading::value || ! left_ || ! left_->is_function()) {
ar & left_; ar & left_;
} else { } else {
ptr_op_t temp_op; ptr_op_t temp_op;
ar & temp_op; ar & temp_op;
} }
if (Archive::is_loading::value || kind == VALUE || kind == IDENT || if (Archive::is_loading::value || is_value() || is_ident() ||
(kind > UNARY_OPERATORS && (kind > UNARY_OPERATORS &&
(! has_right() || ! right()->is_function()))) { (! has_right() || ! right()->is_function()))) {
ar & data; ar & data;
@ -335,6 +359,13 @@ expr_t::op_t::wrap_functor(expr_t::func_t fobj) {
return temp; return temp;
} }
inline expr_t::ptr_op_t
expr_t::op_t::wrap_scope(shared_ptr<scope_t> sobj) {
ptr_op_t temp(new op_t(op_t::SCOPE));
temp->set_scope(sobj);
return temp;
}
#define MAKE_FUNCTOR(x) expr_t::op_t::wrap_functor(bind(&x, this, _1)) #define MAKE_FUNCTOR(x) expr_t::op_t::wrap_functor(bind(&x, this, _1))
#define WRAP_FUNCTOR(x) expr_t::op_t::wrap_functor(x) #define WRAP_FUNCTOR(x) expr_t::op_t::wrap_functor(x)

33
src/parser.cc
View file

@ -434,7 +434,6 @@ expr_t::parser_t::parse_comma_expr(std::istream& in,
ptr_op_t prev(node); ptr_op_t prev(node);
node = new op_t(op_t::O_CONS); node = new op_t(op_t::O_CONS);
node->set_left(prev); node->set_left(prev);
next = node; next = node;
} }
@ -493,7 +492,9 @@ expr_t::parser_t::parse_assign_expr(std::istream& in,
ptr_op_t prev(node); ptr_op_t prev(node);
node = new op_t(op_t::O_DEFINE); node = new op_t(op_t::O_DEFINE);
node->set_left(prev); node->set_left(prev);
node->set_right(parse_lambda_expr(in, tflags)); ptr_op_t scope(new op_t(op_t::SCOPE));
scope->set_left(parse_lambda_expr(in, tflags));
node->set_right(scope);
} else { } else {
push_token(tok); push_token(tok);
} }
@ -509,24 +510,24 @@ expr_t::parser_t::parse_value_expr(std::istream& in,
ptr_op_t node(parse_assign_expr(in, tflags)); ptr_op_t node(parse_assign_expr(in, tflags));
if (node && ! tflags.has_flags(PARSE_SINGLE)) { if (node && ! tflags.has_flags(PARSE_SINGLE)) {
ptr_op_t next; ptr_op_t chain;
while (true) { while (true) {
token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT)); token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT));
if (tok.kind == token_t::SEMI) { if (tok.kind == token_t::SEMI) {
if (! next) { ptr_op_t seq(new op_t(op_t::O_SEQ));
ptr_op_t prev(node); if (! chain) {
node = new op_t(op_t::O_SEQ); seq->set_left(node);
node->set_left(prev); ptr_op_t scope(new op_t(op_t::SCOPE));
scope->set_left(seq);
next = node; node = scope;
} else {
seq->set_left(chain->right());
ptr_op_t scope(new op_t(op_t::SCOPE));
scope->set_left(seq);
chain->set_right(scope);
} }
seq->set_right(parse_assign_expr(in, tflags));
ptr_op_t chain(new op_t(op_t::O_SEQ)); chain = seq;
chain->set_left(parse_assign_expr(in, tflags));
next->set_right(chain);
next = chain;
} else { } else {
push_token(tok); push_token(tok);
break; break;

8
src/scope.cc
View file

@ -40,7 +40,8 @@ scope_t * scope_t::default_scope = NULL;
void symbol_scope_t::define(const symbol_t::kind_t kind, void symbol_scope_t::define(const symbol_t::kind_t kind,
const string& name, expr_t::ptr_op_t def) const string& name, expr_t::ptr_op_t def)
{ {
DEBUG("scope.symbols", "Defining '" << name << "' = " << def); DEBUG("scope.symbols",
"Defining '" << name << "' = " << def << " in " << this);
if (! symbols) if (! symbols)
symbols = symbol_map(); symbols = symbol_map();
@ -64,9 +65,12 @@ expr_t::ptr_op_t symbol_scope_t::lookup(const symbol_t::kind_t kind,
const string& name) const string& name)
{ {
if (symbols) { if (symbols) {
DEBUG("scope.symbols", "Looking for '" << name << "' in " << this);
symbol_map::const_iterator i = symbols->find(symbol_t(kind, name)); symbol_map::const_iterator i = symbols->find(symbol_t(kind, name));
if (i != symbols->end()) if (i != symbols->end()) {
DEBUG("scope.symbols", "Found '" << name << "' in " << this);
return (*i).second; return (*i).second;
}
} }
return child_scope_t::lookup(kind, name); return child_scope_t::lookup(kind, name);
} }

2
src/scope.h
View file

@ -188,6 +188,8 @@ public:
scope_t& _grandchild) scope_t& _grandchild)
: child_scope_t(_parent), grandchild(_grandchild) { : child_scope_t(_parent), grandchild(_grandchild) {
TRACE_CTOR(bind_scope_t, "scope_t&, scope_t&"); TRACE_CTOR(bind_scope_t, "scope_t&, scope_t&");
DEBUG("scope.symbols",
"Binding scope " << &_parent << " with " << &_grandchild);
} }
virtual ~bind_scope_t() { virtual ~bind_scope_t() {
TRACE_DTOR(bind_scope_t); TRACE_DTOR(bind_scope_t);

2
src/value.cc
View file

@ -1727,7 +1727,7 @@ void value_t::print(std::ostream& _out,
switch (type()) { switch (type()) {
case VOID: case VOID:
out << ""; out << "(null)";
break; break;
case BOOLEAN: case BOOLEAN: