---

translator.cc

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#include "translator.h"
#include "translator_i.h"

#line 27 "translator.cpp"

using namespace std;

#line 29 "translator.cpp"

void
Translator::translate(Source* s)
{
  Translate_visitor translator (s);

  translator.visit ();
}

#line 69 "translator.cpp"


Translate_visitor::Translate_visitor(Source* s)
  : Ptree_program_visitor<bool> (s), 
    Ptree_visitor<bool> (s), 
    _value (-1),
    _number (0),
    _alloc ("static"),
    _last_alloc (""),
    _expecting_lvalue (false),
    //    _have_initializer (false),
    out (&cout)
{
}

#line 83 "translator.cpp"


Translate_visitor::~Translate_visitor()
{
}

#line 88 "translator.cpp"

// 
// From here on, override functions of Ptree_visitor to translate the program.
// 

bool
Translate_visitor::visit_function(Ptree* storagespec, 
                                   Ptree* returntype, 
                                   PtreeDeclarator* decl, 
                                   PtreeBlock* block)
{
  // Only handle built-in types for now

  char *enctype = returntype->Car()->ToString();
  char *encname = decl->Car()->ToString();

  if (!encname || !enctype) 
    {
      throw "encname or enctype null";
    }

  cerr << "name = " << encname << "; type = " << enctype << endl;

  Ptree& name_node = decl->IsLeaf() ? *decl : *decl->First();

  string name = _sym.insert (name_node, 'F');

  _var[name].name = name;
  _var[name].basename = name_node.ToString();
  _var[name].enctype = enctype;
  _var[name].number = _number++;

  // Record the function here.  Rest of precessing done later
  // in TranslateFunctionBody.
  _var[name].type = string("C'T") + enctype;
  _var[name].alloc = "text";

  _func = name;

  // XXX handle arguments

  _sym.enter_scope(_var[_func].basename, 'F');

  string type = _var[_func].type == "C'Tvoid" ? "" : _var[_func].type;

  new_function_prologue (_func, type);

  string old_alloc = _alloc;
  _alloc = "stack";
  _last_alloc = "";

  assert (* block->First()->ToString() = '{');
  assert (* block->Third()->ToString() = '}');
  visit (block->Second());      // Skip block's braces

  new_function_epilogue (_func, type == "" ? "" : "retvalue");

  _alloc = old_alloc;
  _sym.leave_scope();

  _func = "";
  return true;
}

#line 151 "translator.cpp"

bool 
Translate_visitor::visit_name_declaration(Ptree* storagespec, 
                                           Ptree* type, 
                                           Ptree* decllist)
{
  for (;
       decllist;
       decllist = decllist->Cdr() ? decllist->Cdr()->Cdr() : 0)
    {
      Ptree* decl = decllist->Car();

      // Only handle built-in types for now
      char *enctype = type->Car()->ToString();
      char *encname = decl->First()->ToString();
      
      if (!encname || !enctype) 
        {
          throw "encname or enctype null";
        }
      
      cerr << "name = " << encname << "; type = " << enctype << endl;
      
      Ptree* name_node = decl->First();
      
      string name = _sym.insert (*name_node, 'V');
      
      _var[name].name = name;
      _var[name].basename = name_node->ToString();
      _var[name].enctype = enctype;
      _var[name].number = _number++;

      _var[name].type = string("C'T") + enctype;
      _var[name].alloc = _alloc;
      
      // Now visit initializers, if any.
      
      string initializer;       // Default: no initialization
      
      // TODO: lookup = operator or constructor
      
      // Find expression
      Ptree* exp;
      
      for (exp = decl->Cdr(); exp; exp = exp->Cdr())
        {
          if (exp->Car()->IsLeaf() && * exp->Car()->ToString() == '=')
            {
              break;
            }
        }
      
      if (exp)
        {
          exp = exp->Cdr();
          
          ostream* old_out = out;
          out = &_expr;
          _expr.str("");
          
          visit (exp);
          
          cerr << "Found an initializer: " << _expr.str() << endl;
          
          out = old_out;
          
          initializer = _expr.str();
        }
      
      new_variable (name, initializer);
    } // for

  return true;
}

#line 225 "translator.cpp"

bool
Translate_visitor::visit_return(PtreeReturnStatement* exp)
{
  if (_var[_func].type == "C'Tvoid")
    {
      if (exp->Length() != 2)
        {
          // XXX actually, void functions _can_ return a value if that
          // value is cast to void.
          throw "void functions cannot return a value"; 
        }

      return exp;
    }

  if (_var[_func].type != "C'Tvoid"
      && exp->Length() == 2)
    {
      throw "Non-void function must return a value";
    }

  visit (exp->Second());

  *out << "let retvalue = value_" << _value << endl;

  return true;
}

#line 253 "translator.cpp"


bool
Translate_visitor::visit_exprstatement(PtreeExprStatement* exp)
{
  // Skip over final ';'
  assert (* exp->Second()->ToString() = ';');
  return visit (exp->First());
}

#line 262 "translator.cpp"

bool
Translate_visitor::visit_assign(PtreeAssignExpr* exp)
{
  // [left = right]
  // TODO: lookup = operator

  visit(exp->Third());

  _expecting_lvalue = true;

  visit(exp->First());

  if (_expecting_lvalue)
    throw string ("Cannot assign to expression \"") + exp->First()->ToString()
      + "\"";

  return true;
}

#line 281 "translator.cpp"

bool
Translate_visitor::visit_infix(PtreeInfixExpr* exp)
{
  // [left operator right]
  // TODO: lookup operator
  
  // XXX Fixed evaluation order: Right to left

  push_lvalue();

  string op (exp->Second()->ToString());

  cerr << "Translating infix expression " << op << endl;

  visit (exp->Third());
  int right = _value;

  visit (exp->First());
  int left = _value;

  new_value (Sstring() << "value_" << left << " "
             << op << " value_" << right);

  pop_lvalue();

  return true;
}

#line 309 "translator.cpp"

bool
Translate_visitor::visit_postfix(PtreePostfixExpr* exp)
{
  // [expr operator++/--]
  // TODO: lookup operator

  // XXX Fixed evaluation order: Update occurs right after evaluation

  push_lvalue();
  
  string op (exp->Second()->ToString());
  assert (op == "++" || op == "--");

  cerr << "Translating postfix expression " << op << endl;

  visit (exp->First());
  int result = _value;

  new_value (Sstring () << "value_" << result << " "
             << (op == "++" ? "+" : "-") << " 1");

  _expecting_lvalue = true;

  visit (exp->First());

  if (_expecting_lvalue)
    throw string ("Cannot assign to ") + exp->First()->ToString();

  new_value (Sstring() << "value_" << result);

  pop_lvalue();

  return true;
}

#line 344 "translator.cpp"

bool
Translate_visitor::visit_funcall(PtreeFuncallExpr* exp)
{
  string global;
  _sym.lookup_global_name (*exp->Car(), &global);

  // XXX find arguments in exp->Crd()

  if (_var[global].type == "C'Tvoid")
    new_state (global);
  else
    {
      *out << "let (state, retval) = " << global << " in" << endl;
      
      new_value ("retval");
      new_state ("state");
    }

  return true;
}

#line 365 "translator.cpp"

bool
Translate_visitor::visit_name(Ptree* exp)
{
  assert (exp->IsLeaf());       // Handle only unscoped names for now.
  
  string name (exp->ToString());
  
  // First check for keywords.  Parse them like constants.
  if (name == "true" || name == "false")
    return visit_leaf (dynamic_cast<Leaf*>(exp));

  string global;
  if (! _sym.lookup_global_name (*exp, &global))
    throw "Unknown variable";

  vrec* var = &_var[global];
  
  if (var->alloc != _last_alloc)
    {
      new_state (Sstring() << "if_change_alloc state " << var->alloc);
      _last_alloc = var->alloc;
    }

  if (_expecting_lvalue)        // Variable write
    {
      cerr << "Writing to variable " << var->name << endl;

      new_state (Sstring() << "if_write state " << var->name << "_vrec "
                 << "value_" << _value);

      _expecting_lvalue = false;
    }
  else                          // Variable read
    {
      cerr << "Reading from variable " << var->name << endl; 

      new_value (Sstring() << "if_read state " << var->name << "_vrec");
    }

  return true;
}

#line 410 "translator.cpp"

bool
Translate_visitor::visit_leaf(Leaf* exp)
{
  // Translate expression -- hopefully a constant
  assert (exp->IsLeaf());

  string leaf (exp->ToString());
  
  // First check for keywords.  Parse them like constants.
  if (leaf == "true")
    new_value ("True");
  else if (leaf == "false")
    new_value ("False");
  // Numerics?
  else if (leaf.find_first_not_of ("0123456789") == string::npos)
    new_value (string("#") + leaf);
  else
    throw "Unknown stuff -- barf!";

  return true;
}

#line 432 "translator.cpp"

// 
// Output functions
// 
void 
Translate_visitor::new_value(const string& val)
{
  *out << "let value_" << ++_value << " = " << val << " in" << endl;
}

#line 441 "translator.cpp"

void
Translate_visitor::new_variable(const string& name,
                                const string& initializer)
{
  cerr << "  Allocating number " << _var[name].number 
       << " for variable " 
       << _var[name].name << " from allocator " 
       << _var[name].alloc << endl;

  // Declare a vrec for this variable
  if (_var[name].alloc == "stack") 
    *out << "let " << _var[name].name << "_vrec = ";
  else 
    *out << "constdefs " << name << "_vrec :: \"" 
         << _var[name].type << " VREC\"" << endl
         << "          \"" << name << "_vrec == ";

  *out << "(| vr_locn = #" << _var[name].number 
       << ", vr_type = dummy_" << _var[name].type << " |)";

  if (_var[name].alloc == "stack") 
    *out << " in" << endl;
  else
    {
      *out << "\"" << endl << endl;

      new_function_prologue (name + "_alloc", "");
    }

  // Switch to current allocator
  if (_var[name].alloc != _last_alloc)
    {
      new_state (Sstring () << "if_change_alloc state " << _var[name].alloc);
      _last_alloc = _var[name].alloc;
    }
  
  // Allocate this variable from the current allocator
  new_state (Sstring () << "if_alloc state " 
             << _var[name].name << "_vrec");
  
  // Initialize the variable.
  if (initializer != "")
    {
      *out << initializer;
      new_state (Sstring() << _var[name].type << "'directinit state "
                 << _var[name].name << "_vrec value_" << _value);
    }
  else
    new_state (Sstring() << _var[name].type << "'defaultinit state "
               << _var[name].name << "_vrec");

  if (_var[name].alloc == "stack") 
    // Get new allocator state
    *out << "let " << _var[name].alloc << " = (snd state) in" << endl;
  else
    new_function_epilogue (name + "_alloc", "");

}

#line 500 "translator.cpp"

void
Translate_visitor::new_function_prologue(const string& name, 
                                         const string& rettype)
{
  *out << "constdefs " << name << " :: \"State => ";

  if (rettype != "")
    *out << "(State * " << rettype << ")";
  else
    *out << "State";

  *out << " option\"" << endl
       << "\"" << name << " state ==" << endl;
}

#line 515 "translator.cpp"

void
Translate_visitor::new_function_epilogue(const string& name, 
                                         const string& value)
{
  if (value != "")
    *out << "Some (state * " << value << ")\"" << endl << endl;
  else
    *out << "Some state" << "\"" << endl << endl;
  
}

#line 526 "translator.cpp"

void 
Translate_visitor::new_state(const string& func)
{
  *out << "let state = " << func << " in" << endl;
}

#line 532 "translator.cpp"

// 
// Helper functions to keep track of lvalue evaluations
// 
void
Translate_visitor::push_lvalue()
{
  _lvalue_stack.push (_expecting_lvalue);
  _expecting_lvalue = false;
}

#line 542 "translator.cpp"

void
Translate_visitor::pop_lvalue()
{
  _expecting_lvalue = _lvalue_stack.top ();
  _lvalue_stack.pop();
}

---