Introduced a new SCOPE expression terminal

src/compare.cc

@@ -44,7 +44,7 @@ void push_sort_value(std::list<sort_value_t>& sort_values,
   if (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);
-      node = node->right();
+      node = node->has_right() ? node->right() : NULL;
     }
   } else {
     bool inverted = false;

src/format.cc

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

src/op.cc

@@ -50,7 +50,7 @@ namespace {
         expr_t::ptr_op_t value_op;
         if (next->kind == expr_t::op_t::O_CONS) {
           value_op = next->left();
-          next     = next->right();
+          next     = next->has_right() ? next->right() : NULL;
         } else {
           value_op = next;
           next     = NULL;
@@ -78,10 +78,12 @@ namespace {
 
 expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
 {
+  scope_t * scope_ptr = &scope;
+
   if (is_ident()) {
     DEBUG("expr.compile", "lookup: " << as_ident());
 
-    if (ptr_op_t def = scope.lookup(symbol_t::FUNCTION, 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
       // definition, and then at the point of every use if they could
       // not be found there.
@@ -91,21 +93,26 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
         def->dump(*_log_stream, 0);
       }
 #endif // defined(DEBUG_ON)
-      return copy(def);
+     return copy(def);
     }
     else if (left()) {
       return copy();
     }
     return this;
   }
-
+  else if (is_scope()) {
-  if (kind < TERMINALS)
+    shared_ptr<scope_t> subscope(new symbol_scope_t(scope));
+    DEBUG("expr.compile", "creating scope");
+    set_scope(subscope);
+    scope_ptr = subscope.get();
+  }
+  else if (kind < TERMINALS) {
     return this;
-
+  }
-  if (kind == O_DEFINE) {
+  else if (kind == O_DEFINE) {
     switch (left()->kind) {
     case IDENT:
-      scope.define(symbol_t::FUNCTION, left()->as_ident(), right());
+      scope_ptr->define(symbol_t::FUNCTION, left()->as_ident(), right());
       break;
     case O_CALL:
       if (left()->left()->is_ident()) {
@@ -113,7 +120,8 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
         node->set_left(left()->right());
         node->set_right(right());
 
-        scope.define(symbol_t::FUNCTION, left()->left()->as_ident(), node);
+        scope_ptr->define(symbol_t::FUNCTION, left()->left()->as_ident(),
+                          node);
       } else {
         throw_(compile_error, _("Invalid function definition"));
       }
@@ -121,13 +129,13 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
     default:
       throw_(compile_error, _("Invalid function definition"));
     }
-    return wrap_value(value_t());
+    return wrap_value(NULL_VALUE);
   }
 
-  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() ?
                (kind == O_LOOKUP ? right() :
-                right()->compile(scope, depth)) : NULL);
+                right()->compile(*scope_ptr, depth)) : NULL);
 
   if (lhs == left() && (! rhs || rhs == right()))
     return this;
@@ -136,22 +144,19 @@ expr_t::ptr_op_t expr_t::op_t::compile(scope_t& scope, const int depth)
 
   // Reduce constants immediately if possible
   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));
 
   return intermediate;
 }
 
 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 {
 
   value_t result;
 
 #if defined(DEBUG_ON)
-  if (! skip_debug && SHOW_DEBUG("expr.calc")) {
+  if (SHOW_DEBUG("expr.calc")) {
     for (int i = 0; i < depth; i++)
       ledger::_log_buffer << '.';
     ledger::_log_buffer << op_context(this) <<  " => ...";
@@ -196,12 +201,18 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
     call_scope_t call_args(scope, locus, depth);
     result = as_function()(call_args);
     check_type_context(scope, result);
-#if defined(DEBUG_ON)
-    skip_debug = true;
-#endif
     break;
   }
 
+  case SCOPE:
+    if (is_scope_unset()) {
+      symbol_scope_t subscope(scope);
+      result = left()->calc(subscope, locus, depth + 1);
+    } else {
+      result = left()->calc(*as_scope(), locus, depth + 1);
+    }
+    break;
+
   case O_LAMBDA: {
     call_scope_t&  call_args(downcast<call_scope_t>(scope));
     std::size_t    args_count(call_args.size());
@@ -267,7 +278,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
       throw_(calc_error, _("Calling unknown function '%1'") << name);
 
 #if defined(DEBUG_ON)
-    if (! skip_debug && SHOW_DEBUG("expr.calc")) {
+    if (SHOW_DEBUG("expr.calc")) {
       for (int i = 0; i < depth; i++)
         ledger::_log_buffer << '.';
       ledger::_log_buffer << "    args: ";
@@ -382,7 +393,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
         ptr_op_t value_op;
         if (next->kind == O_CONS) {
           value_op = next->left();
-          next     = next->right();
+          next     = next->has_right() ? next->right() : NULL;
         } else {
           value_op = next;
           next     = NULL;
@@ -395,14 +406,13 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
     break;
 
   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()) {
       ptr_op_t next = right();
@@ -415,7 +425,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
           value_op = next;
           next     = NULL;
         }
-        result = value_op->calc(seq_scope, locus, depth + 1);
+        result = value_op->calc(scope, locus, depth + 1);
       }
     }
     break;
@@ -426,7 +436,7 @@ value_t expr_t::op_t::calc(scope_t& scope, ptr_op_t * locus, const int depth)
   }
 
 #if defined(DEBUG_ON)
-  if (! skip_debug && SHOW_DEBUG("expr.calc")) {
+  if (SHOW_DEBUG("expr.calc")) {
     for (int i = 0; i < depth; i++)
       ledger::_log_buffer << '.';
     ledger::_log_buffer << op_context(this) <<  " => ";
@@ -476,9 +486,8 @@ namespace {
 
     if (op->has_right()) {
       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))
         found = true;
     }
@@ -515,6 +524,11 @@ bool expr_t::op_t::print(std::ostream& out, const context_t& context) const
     out << "<FUNCTION>";
     break;
 
+  case SCOPE:
+    if (left() && left()->print(out, context))
+      found = true;
+    break;
+
   case O_NOT:
     out << "! ";
     if (left() && left()->print(out, context))
@@ -625,7 +639,6 @@ bool expr_t::op_t::print(std::ostream& out, const context_t& context) const
   case O_CONS:
     found = print_cons(out, this, context);
     break;
-
   case O_SEQ:
     found = print_seq(out, this, context);
     break;
@@ -726,6 +739,14 @@ void expr_t::op_t::dump(std::ostream& out, const int depth) const
     out << "FUNCTION";
     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_LOOKUP: out << "O_LOOKUP"; break;
   case O_LAMBDA: out << "O_LAMBDA"; break;
@@ -765,7 +786,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
   // hold the compiled definition of the identifier.
-  if (kind > TERMINALS || is_ident()) {
+  if (kind > TERMINALS || is_ident() || is_scope()) {
     if (left()) {
       left()->dump(out, depth + 1);
       if (kind > UNARY_OPERATORS && has_right())

src/op.h

@@ -58,10 +58,12 @@ private:
   mutable short refc;
   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
           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;
 
 public:
@@ -73,6 +75,7 @@ public:
     CONSTANTS,
 
     FUNCTION,
+    SCOPE,
 
     TERMINALS,
 
@@ -173,7 +176,7 @@ public:
     return kind == FUNCTION;
   }
   expr_t::func_t& as_function_lval() {
-    assert(kind == FUNCTION);
+    assert(is_function());
     return boost::get<expr_t::func_t>(data);
   }
   const expr_t::func_t& as_function() const {
@@ -183,21 +186,41 @@ public:
     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() {
-    assert(kind > TERMINALS || kind == IDENT);
+    assert(kind > TERMINALS || kind == IDENT || is_scope());
     return left_;
   }
   const ptr_op_t& left() const {
-    assert(kind > TERMINALS || kind == IDENT);
+    assert(kind > TERMINALS || kind == IDENT || is_scope());
     return left_;
   }
   void set_left(const ptr_op_t& expr) {
-    assert(kind > TERMINALS || kind == IDENT);
+    assert(kind > TERMINALS || kind == IDENT || is_scope());
     left_ = expr;
   }
 
   ptr_op_t& as_op_lval() {
-    assert(kind > TERMINALS || kind == IDENT);
+    assert(kind > TERMINALS || is_ident());
     return boost::get<ptr_op_t>(data);
   }
   const ptr_op_t& as_op() const {
@@ -219,7 +242,7 @@ public:
   bool has_right() const {
     if (kind < TERMINALS)
       return false;
-    return as_op();
+    return data.which() != 0 && as_op();
   }
 
 private:
@@ -284,6 +307,7 @@ public:
 
   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_scope(shared_ptr<scope_t> sobj);
 
 #if defined(HAVE_BOOST_SERIALIZATION)
 private:
@@ -295,13 +319,13 @@ private:
   void serialize(Archive& ar, const unsigned int /* version */) {
     ar & refc;
     ar & kind;
-    if (Archive::is_loading::value || ! left_ || left_->kind != FUNCTION) {
+    if (Archive::is_loading::value || ! left_ || ! left_->is_function()) {
       ar & left_;
     } else {
       ptr_op_t 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 &&
          (! has_right() || ! right()->is_function()))) {
       ar & data;
@@ -335,6 +359,13 @@ expr_t::op_t::wrap_functor(expr_t::func_t fobj) {
   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 WRAP_FUNCTOR(x) expr_t::op_t::wrap_functor(x)
 

src/parser.cc

@@ -434,7 +434,6 @@ expr_t::parser_t::parse_comma_expr(std::istream& in,
           ptr_op_t prev(node);
           node = new op_t(op_t::O_CONS);
           node->set_left(prev);
-
           next = node;
         }
 
@@ -493,7 +492,9 @@ expr_t::parser_t::parse_assign_expr(std::istream& in,
       ptr_op_t prev(node);
       node = new op_t(op_t::O_DEFINE);
       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 {
       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));
 
   if (node && ! tflags.has_flags(PARSE_SINGLE)) {
-    ptr_op_t next;
+    ptr_op_t chain;
     while (true) {
       token_t& tok = next_token(in, tflags.plus_flags(PARSE_OP_CONTEXT));
-
       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 {
         push_token(tok);
         break;

src/value.cc

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