/Users/mourrain/Devel/mmx/basix/src/cpp_printer.cpp

Go to the documentation of this file.

/******************************************************************************
* MODULE     : cpp_printer.cpp
* DESCRIPTION: C++ tree printer
* COPYRIGHT  : (C) 2000  Joris van der Hoeven, 2007  Gregoire Lecerf
*******************************************************************************
* This software falls under the GNU general public license and comes WITHOUT
* ANY WARRANTY WHATSOEVER. See the file $TEXMACS_PATH/LICENSE for more details.
* If you don't have this file, write to the Free Software Foundation, Inc.,
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
******************************************************************************/

#include <basix/basix-config.hpp>
#if defined (BASIX_HAVE_CXXABI_H)
#include <cxxabi.h>
#endif
#include <basix/cpp_syntax.hpp>
#include <basix/list.hpp>
#include <basix/table.hpp>
#include <basix/literal.hpp>
#include <basix/compound.hpp>

namespace mmx {

generic CPP_APPLY (".()");
generic CPP_ACCESS (".[]");
generic CPP_ALIAS_TYPE ("Alias");
generic CPP_AND ("and");
generic CPP_ARRAY_TYPE ("Array");
generic CPP_ARROW ("->");
generic CPP_ASSIGN (":=");
generic CPP_BEGIN ("begin");
generic CPP_BITWISE_AND ("/\\");
generic CPP_BITWISE_OR ("\\/");
generic CPP_BITWISE_XOR ("xor");
generic CPP_BOOL_TYPE ("Boolean");
generic CPP_BRACKETS ("()");
generic CPP_BREAK ("break");
generic CPP_CAST (":>");
generic CPP_CATCH ("catch");
generic CPP_CHAR_TYPE ("Char");
generic CPP_CLASS_TYPE ("Type");
generic CPP_COMMA (",");
generic CPP_COMPLEMENT ("~");
generic CPP_CONST ("const");
generic CPP_CONST_METHOD ("const_method");
generic CPP_CONSTRUCT ("construct");
generic CPP_CONSTRUCTOR ("constructor");
generic CPP_CONTINUE ("continue");
generic CPP_DEFINE ("==");
generic CPP_DELETE ("delete");
generic CPP_DESTRUCTOR ("destructor");
generic CPP_DO ("do");
generic CPP_DOT (".");
generic CPP_ELSE ("else");
generic CPP_EQUAL ("=");
generic CPP_EXIT ("exit");
generic CPP_EXTERN ("extern");
generic CPP_EXTERN_C ("extern_C");
generic CPP_FOR ("for");
generic CPP_FRIEND ("friend");
generic CPP_FUNCTION_TYPE ("Function");
generic CPP_GTR (">");
generic CPP_GTREQ (">=");
generic CPP_GTRGTR (">>");
generic CPP_GTRGTREQ (">>=");
generic CPP_IF ("if");
generic CPP_INHERIT ("inherit");
generic CPP_INITIALIZE ("initialize");
generic CPP_INLINE ("inline");
generic CPP_INT_TYPE ("Int");
generic CPP_LESS ("<");
generic CPP_LESSEQ ("<=");
generic CPP_LESSLESS ("<<");
generic CPP_LESSLESSEQ ("<<=");
generic CPP_MACRO ("cpp_macro");
generic CPP_MINUS ("-");
generic CPP_MINUS_ASSIGN ("-=");
generic CPP_MMX_APPLICATION_TYPE ("Mmx_application");
generic CPP_MOD ("%");
generic CPP_MOD_ASSIGN ("%=");
generic CPP_NAMESPACE ("namespace");
generic CPP_NEW ("new");
generic CPP_NOT ("!");
generic CPP_OR ("or");
generic CPP_OVER ("/");
generic CPP_OVER_ASSIGN ("/=");
generic CPP_PLUS ("+");
generic CPP_PLUS_ASSIGN ("+=");
generic CPP_POINTER_TYPE ("Pointer");
generic CPP_POSTDEC (".--");
generic CPP_POSTINC (".++");
generic CPP_POWER ("^");
generic CPP_PREDEC ("--.");
generic CPP_PREINC ("++.");
generic CPP_PUBLIC ("public");
generic CPP_RETURN ("return");
generic CPP_SCOPE ("::");
generic CPP_SEMICOLON (";");
generic CPP_SPECIALIZE ("specialize");
generic CPP_STATIC ("static");
generic CPP_STRING_TYPE ("String");
generic CPP_STRUCT ("struct");
generic CPP_SWITCH ("switch");
generic CPP_TEMPLATE ("template");
generic CPP_THROW ("raise");
generic CPP_TIMES ("*");
generic CPP_TIMES_ASSIGN ("*=");
generic CPP_TRY ("try");
generic CPP_TYPE (":");
generic CPP_TYPEDEF ("typedef");
generic CPP_TYPE_CONSTRUCTOR ("type_constructor");
generic CPP_UNALIAS ("unalias");
generic CPP_UNEQUAL ("!=");
generic CPP_UNFUNCTION ("unfunction");
generic CPP_UNPOINTER ("unpointer");
generic CPP_USING ("using");
generic CPP_VERBATIM ("verbatim");
generic CPP_VIRTUAL ("virtual");
generic CPP_VOID_TYPE ("Void");
generic CPP_WHILE ("while");
generic CPP_XOR ("^^");

/******************************************************************************
* Useful symbols and subroutines
******************************************************************************/

inline generic
cAr (const vector<generic>& a) {
  if (N(a) == 0)
    return generic ();
  return a[N(a)-1];
}

inline vector<generic>
cDr (const vector<generic>& a) {
  if (N(a) == 0)
    return a;
  return range (a,0,N(a)-1);
}

#define SET_OPNAME(var, val) \
  t [literal_to_string (var)] = val; \
  t [string ("operator ") * val] = val;

static table<string, string>
opname_table () {
  table<string, string> t;
  SET_OPNAME (CPP_PLUS, "+")
  SET_OPNAME (CPP_MINUS, "-");
  SET_OPNAME (CPP_TIMES, "*");
  SET_OPNAME (CPP_OVER, "/");
  SET_OPNAME (CPP_MOD, "%");
  SET_OPNAME (CPP_AND, "&&");
  SET_OPNAME (CPP_OR, "||");
  SET_OPNAME (CPP_NOT, "!");
  SET_OPNAME (CPP_BITWISE_AND, "&");
  SET_OPNAME (CPP_BITWISE_OR, "|");
  SET_OPNAME (CPP_BITWISE_XOR, "^");
  SET_OPNAME (CPP_ASSIGN, "=");
  SET_OPNAME (CPP_LESS, "<");
  SET_OPNAME (CPP_GTR, ">");
  SET_OPNAME (CPP_PLUS_ASSIGN, "+=");
  SET_OPNAME (CPP_MINUS_ASSIGN, "-=");
  SET_OPNAME (CPP_TIMES_ASSIGN, "*=");
  SET_OPNAME (CPP_OVER_ASSIGN, "/=");
  SET_OPNAME (CPP_MOD_ASSIGN, "%=");
  SET_OPNAME (CPP_LESSLESS, "<<");
  SET_OPNAME (CPP_LESSLESSEQ, "<<=");
  SET_OPNAME (CPP_GTRGTR, ">>");
  SET_OPNAME (CPP_GTRGTREQ, ">>=");
  SET_OPNAME (CPP_EQUAL, "==");
  SET_OPNAME (CPP_UNEQUAL, "!=");
  SET_OPNAME (CPP_LESSEQ, "<=");
  SET_OPNAME (CPP_GTREQ, ">=");
  SET_OPNAME (CPP_PREINC, "++");
  SET_OPNAME (CPP_PREDEC, "--");
  SET_OPNAME (CPP_ACCESS, "[]");
  SET_OPNAME (CPP_COMPLEMENT, "~");
  SET_OPNAME (CPP_ARROW, "->");
  return t;
}

/******************************************************************************
* Printing to strings
******************************************************************************/

enum print_controls { LF, INDENT, UNINDENT };

static nat indentation_level= 0;

static string&
operator << (string& out, print_controls pc) {
  switch (pc) {
  case LF:
    out << "\n";
    for (nat i=0; i<indentation_level; i++) out << "  ";
    break;
  case INDENT:
    indentation_level++;
    out << "  ";
    break;
  case UNINDENT:
    indentation_level--;
    if (N(out) >= 2 && out[N(out)-2] == ' ' && out[N(out)-1] == ' ')
      inside (out) -> resize (N(out) - 2);
    break;
  }
  return out;
}

static string&
operator << (string& out, const char* s) {
  return out << string (s);
}

static string&
operator << (string& out, const generic& g) {
  if (is<string> (g)) return out << as<string> (g);
  if (is<literal> (g)) return out << (*(as<literal> (g)));
  mmerr << g << ": " << type_name (g) << "\n";
  assert (false);
  return out;
}

/******************************************************************************
* The cpp printer class
******************************************************************************/

class cpp_printer {
private:
  string        out;
  list<generic> sl;
  bool          lf_flag;
  bool          lf_done;

private:
  void pp_begin (const generic& g);
  void pp_instr (const generic& g);
  void pp_init (const generic& g);

  void pp_decl (const generic& var, bool large= true);
  void pp_decl (const generic& var, const generic& type, bool large);
  void pp_type (const generic& g);
  void pp_funarg (const generic& g);
  void pp_funargs (const generic& g);

  void pp_expr (const generic& g);
  void pp_exprs (const generic& g);
  void pp_comma (const generic& g);
  void pp_assign (const generic& g);

  void pp_cond (const generic& g);
  void pp_seqor (const generic& g);
  void pp_seqand (const generic& g);
  void pp_or (const generic& g);
  void pp_xor (const generic& g);
  void pp_and (const generic& g);
  void pp_eq (const generic& g);
  void pp_rel (const generic& g);

  void pp_shift (const generic& g);
  void pp_lshift (const generic& g);
  void pp_rshift (const generic& g);
  void pp_add (const generic& g);
  void pp_mult (const generic& g);

  void pp_unary (const generic& g);
  void pp_postfix (const generic& g);
  void pp_primary (const generic& g);
    
public:
  inline cpp_printer (): out ("") { indentation_level= 0; }
  inline ~cpp_printer () {}

  void pp (const generic& g);
  friend string as_cpp (const generic& g);
};

/******************************************************************************
* Required routines for generic structures
******************************************************************************/

inline syntactic
flatten (const cpp_printer& p) {
  return "#cpp_printer<>";
}

inline nat
hash (const cpp_printer& p) {
  return 0;
}

/******************************************************************************
* ABI support for name unmangling
******************************************************************************/

#if defined (BASIX_HAVE_CXXABI_H)

string cpp_demangle(const char* name) {
  size_t size= 4096;
  char* buf= (char*) malloc (size);
  int status;
  char* res= abi::__cxa_demangle (name, buf, &size, &status);
  string ans (res); free ((void*) res);
  ASSERT (status==0, "invalid C++ type name");
  return ans;
}

#else

string cpp_demangle(const char* name) {
  static bool first= true;
  if (first) {
    mmerr << "Warning: C++ name unmangling is not available\n";
    first= false;
  }
  return string (name);
}

#endif

/******************************************************************************
* Instructions
******************************************************************************/

void
cpp_printer::pp_instr (const generic& g) {
  if (is_func (g, CPP_VERBATIM, 1) && is<string> (g[1])) {
    string s = as<string> (g[1]);
    int i, n = N(s);
    for (i=0; i<n; i++)
      if (s[i] == '\n') out << LF;
      else out << s[i];
  }
  else if (is_func (g, CPP_NAMESPACE, 2)) {
    out << "namespace " << g[1] << " {" << LF << INDENT;
    pp_begin (g[2]);
    out << UNINDENT << "}" << LF;
  }
  else if (is_func (g, CPP_INITIALIZE)) {
    pp_init (g);
    generic last= cAr (compound_to_vector (g));
    if (is_func (last, CPP_BEGIN)) pp_instr (last);
    else pp_instr (gen (CPP_BEGIN, last));
  }
  else if (is_func (g, CPP_BEGIN)) {
    out << "{" << LF << INDENT;
    pp_begin (g);
    out << UNINDENT << "}" << LF;
  }
  else if (is_func (g, CPP_IF, 2)) {
    out << "if (";
    pp_expr (g[1]);
    out << ") ";
    if (is_func (g[2], CPP_IF)) pp_instr (gen (CPP_BEGIN, g[2]));
    else pp_instr (g[2]);
  }
  else if (is_func (g, CPP_IF, 3)) {
    out << "if (";
    pp_expr (g[1]);
    out << ") ";
    if (is_func (g[2], CPP_IF, 2)) pp_instr (gen (CPP_BEGIN, g[2]));
    else pp_instr (g[2]);
    out << "else ";
    pp_instr (g[3]);
  }
  else if (is_func (g, CPP_WHILE, 2)) {
    out << "while (";
    pp_expr (g[1]);
    out << ") ";
    pp_instr (g[2]);
  }
  else if (is_func (g, CPP_DO, 2)) {
    out << "do ";
    pp_instr (g[1]);
    out << "while (";
    pp_expr (g[2]);
    out << ");";
  }
  else if (is_func (g, CPP_FOR, 4)) {
    out << "for (";
    pp_expr (g[1]);
    out << "; ";
    pp_expr (g[2]);
    out << "; ";
    pp_expr (g[3]);
    out << ") ";
    pp_instr (g[4]);
  }
  else if (is_func (g, CPP_BREAK, 0))
    out << "break;" << LF;
  else if (is_func (g, CPP_CONTINUE, 0))
    out << "continue;" << LF;
  else if (is_func (g, CPP_RETURN, 0))
    out << "return;" << LF;
  else if (is_func (g, CPP_RETURN, 1)) {
    out << "return ";
    pp_expr (g[1]);
    out << ";" << LF;
  }
  else if (is_func (g, CPP_THROW, 1)) {
    out << "throw ";
    pp_expr (g[1]);
    out << ";" << LF;
  }
  else if (is_func (g, CPP_TRY) && N(g) >= 2) {
    out << "try ";
    pp_instr (is_func (g[1], CPP_BEGIN)? g[1]: gen (CPP_BEGIN, g[1]));
    for (nat i=2; i<N(g); i++) pp_instr (g[i]);
  }
  else if (is_func (g, CPP_CATCH, 2)) {
    out << "catch (";
    pp_decl (g[1], false);
    out << ") ";
    pp_instr (g[2]);
  }
  else if (is_func (g, CPP_EXTERN_C, 1)) {
    out << "extern \"C\" ";
    pp (g[1]);
  }
  else pp_decl (g);
}

void
cpp_printer::pp_init (const generic& g) {
  vector<generic> l= cDr (cdr (compound_to_vector (g)));
  iterator<generic> i = iterate (l);
  bool first= true;
  for ( ; busy (i); ++i) {
    if (first) out << ": ";
    else out << ", ";
    pp_expr (*i);
    first= false;
  }
}

void
cpp_printer::pp_begin (const generic& g) {
  if (is_func (g, CPP_BEGIN) || is_func (g, CPP_STRUCT)) {
    lf_flag= false;
    lf_done= true;
    for (nat i=1; i<N(g); i++) {
      if (lf_flag) { out << LF; lf_flag= false; lf_done= true; }
      pp_instr (g[i]);
      lf_done= false;
    }
  }
  else pp_instr (g);
}

/******************************************************************************
* Declarations
******************************************************************************/

void
cpp_printer::pp_decl (const generic& var, const generic& type, bool large) {
  // prefixes
  if (is_func (type, CPP_CONST, 1)) {
    out << "const ";
    pp_decl (var, type[1], large);
  }
  else if (is_func (type, CPP_CONST_METHOD, 1)) {
    pp_decl (var, type[1], large);
    out << " const";
  }
  else if (is_func (type, CPP_EXTERN, 1)) {
    out << "extern ";
    pp_decl (var, type[1], large);
  }
  else if (is_func (type, CPP_EXTERN, 2)) {
    out << "extern " << type[1] << " ";
    pp_decl (var, type[2], large);
  }
  else if (is_func (type, CPP_INLINE, 1)) {
    out << "inline ";
    pp_decl (var, type[1], large);
  }
  else if (is_func (type, CPP_FRIEND, 1)) {
    out << "friend ";
    pp_decl (var, type[1], large);
  }
  else if (is_func (type, CPP_STATIC, 1)) {
    out << "static ";
    pp_decl (var, type[1], large);
  }
  else if (is_func (type, CPP_VIRTUAL, 1)) {
    out << "virtual ";
    pp_decl (var, type[1], large);
  }
  else if (is_func (type, CPP_TEMPLATE)) {
    vector<generic> x= cDr (cdr (compound_to_vector (type)));
    out << "template<";
    bool first = true;
    iterator<generic> i;
    for (i = iterate (x); busy(i); ++i) {
      if (!first) out << ", ";
      pp_funarg (*i);
      first = false;
    }
    out << "> ";
    pp_decl (var, cAr (compound_to_vector (type)), large);
  }

  // rewriting into C++ form
  else if (is_func (type, CPP_ALIAS_TYPE, 1))
    pp_decl (gen (CPP_UNALIAS, var), type[1], large);
  else if (is_func (type, CPP_POINTER_TYPE, 1))
    pp_decl (gen (CPP_UNPOINTER, var), type[1], large);
  else if (is_func (type, CPP_ARRAY_TYPE)) {
    vector<generic> unfun= vec<generic> (CPP_ACCESS, var);
    vector<generic> args = cdr (cdr (compound_to_vector (type)));
    pp_decl (vector_to_compound (append (unfun, args)), type[1], large);
  }
  else if (is_func (type, CPP_FUNCTION_TYPE)) {
    vector<generic> unfun= vec<generic> (CPP_UNFUNCTION, var);
    vector<generic> args = cdr (cdr (compound_to_vector (type)));
    pp_decl (vector_to_compound (append (unfun, args)), type[1], large);
  }
  else if (is_func (type, CPP_CONSTRUCTOR)) {
    vector<generic> unfun= vec<generic> (CPP_UNFUNCTION, var);
    vector<generic> args = cdr (compound_to_vector (type));
    pp_decl (vector_to_compound (append (unfun, args)), "", large);
  }
  else if (is_func (type, CPP_DESTRUCTOR, 0))
    pp_decl (gen (CPP_UNFUNCTION, var), "~", large);
  else if (is_func (type, CPP_INHERIT)) {
    out << "struct " << var << ": ";
    iterator<generic> i;
    bool first = true;
    for (i = iterate (cdr (compound_to_vector (type))); busy(i); ++i) {
      if (!first) out << ", ";
      pp_type (*i);
      first = false;
    }
  }

  // normal declarations
  else if (type == "~") {
    if (is_func (var, CPP_UNFUNCTION, 1) && is_func (var[1], CPP_SCOPE, 2)) {
      generic v= var[1];
      ASSERT (!is_func (v[2], CPP_SCOPE, 2), "unimplemented nested scope");
      pp_type (v[1]);
      out << "::~";
      pp_type (v[2]);
      out << " ()";
    }
    else {
      out << "~";
      pp_expr (var);
    }
  }
  else {
    pp_type (type);
    if (type == "");
    else if (large && (type != CPP_CLASS_TYPE)) out << LF;
    else out << " ";
    pp_expr (var);
  }
}

static bool
is_function_type (const generic& g) {
  return
    is_func (g, CPP_FUNCTION_TYPE) ||
    (is_func (g, CPP_INLINE, 1) && is_function_type (g[1])) ||
    (is_func (g, CPP_STATIC, 1) && is_function_type (g[1]));
}

void
cpp_printer::pp_decl (const generic& g, bool large) {
  if (is_func (g, CPP_TYPEDEF, 2)) {
    out << "typedef ";
    pp_decl (gen (CPP_TYPE, g[1], g[2]));
  }
  else if (is_func (g, CPP_DEFINE, 2) || is_func (g, CPP_ASSIGN, 2)) {
    bool large2= false;
    bool emptyb= false;
    if (is_func (g[1], CPP_TYPE, 2)) {
      // fix functions bodies which are not of the kind CPP_BEGIN
      if (is_function_type (g[1][2]) && !is_func (g[2], CPP_BEGIN)) {
        pp_decl (gen (g[0], g[1], gen (CPP_BEGIN, g[2])), large);
        return;
      }

      large2= is_func (g[2], CPP_INITIALIZE);
      large2 |= is_func (g[2], CPP_BEGIN);
      large2 |= is_func (g[2], CPP_STRUCT);
      emptyb |= is_func (g[2], CPP_BEGIN, 0);
      emptyb |= is_func (g[2], CPP_INITIALIZE) &&
        is_func (g[2][N(g[2])-1], CPP_BEGIN, 0);
      if (large && large2 && (!lf_done) && (!emptyb)) out << LF;
      if (is_func (g[2], CPP_CONSTRUCT)) {
        vector<generic> var=
          cons (g[1][1], cdr (compound_to_vector (g[2])));
        if (is_func (g, CPP_DEFINE, 2))
          pp_decl (vector_to_compound (var), gen (CPP_CONST, g[1][2]), large2);
        else pp_decl (vector_to_compound (var), g[1][2], large2);
      }
      else {
        if (is_func (g, CPP_DEFINE, 2) && (!large2))
          pp_decl (g[1][1], gen (CPP_CONST, g[1][2]), large2);
        else pp_decl (g[1][1], g[1][2], large2);
      }
    }
    else pp_cond (g[1]);
    if (large && large2) {
      generic h= g[2];
      if (is_func (h, CPP_INITIALIZE)) {
        pp_init (h);
        generic last= cAr (compound_to_vector (h));
        if (is_func (last, CPP_BEGIN)) h= last;
        else h= gen (CPP_BEGIN, last);
      }
      if (emptyb) {
        out << " {";
        pp_begin (h);
        out << "}";
        out << LF;
        lf_flag= false;
      }
      else {
        out << " {" << LF << INDENT;
        pp_begin (h);
        out << UNINDENT << "}";
        if (is_func (h, CPP_STRUCT)) out << ";";
        out << LF;
        lf_flag= true;
      }
    }
    else {
      if (!is_func (g[2], CPP_CONSTRUCT)) {
        out << " = ";
        pp_expr (g[2]);
      }
      if (large) out << ";" << LF;
    }
  }
  else if (is_func (g, CPP_TYPE, 2)) {
    pp_decl (g[1], g[2], false);
    if (large) out << ";" << LF;
  }
  else if (is_func (g, CPP_USING, 1)) {
    out << "using ";
    pp_expr (g[1]);
    out << ";" << LF;
  }
  else {
    pp_expr (g);
    out << ";" << LF;
  }
}

/******************************************************************************
* Function arguments in function declarations
******************************************************************************/

void
cpp_printer::pp_type (const generic& g) {
  if (is_func (g, CPP_ALIAS_TYPE, 1)) {
    pp_type (g[1]);
    out << "&";
  }
  else if (is_func (g, CPP_POINTER_TYPE, 1)) {
    pp_type (g[1]);
    out << "*";
  }
  else if (is_func (g, CPP_SCOPE, 2)) {
    pp_type (g[1]);
    out << "::";
    pp_type (g[2]);
  }
  else if (is_func (g, CPP_CONST, 1)) {
    out << "const ";
    pp_type (g[1]);
  }
  else if (is_func (g, CPP_CONST_METHOD, 1)) {
    pp_type (g[1]);
    out << " const";
  }
  else if (is_func (g, CPP_PUBLIC, 1)) {
    out << "public ";
    pp_type (g[1]);
  }
  else if (is_func (g, CPP_SPECIALIZE)) {
    generic fun= g[1];
    bool macro_flag= is_func (fun, CPP_MACRO, 1);
    if (macro_flag) fun= fun[1];
    pp_postfix (fun);
    if (macro_flag) out << "(";
    else out << "<";
    pp_funargs (cdr (cdr (g)));
    if (N(g) > 2) out << " ";
    if (macro_flag) out << ")";
    else out << ">";
  }
  else if (is<compound> (g)) {
    vector<generic> l= compound_to_vector (g);
    generic fun= car (l);
    bool macro_flag= is_func (fun, CPP_MACRO, 1);
    if (macro_flag) fun= fun[1];
    pp_type (fun);
    l= cdr (l);
    if (macro_flag) out << "(";
    else out << "<";
    while (N (l) != 0) {
      pp_type (car (l));
      if (N(cdr (l)) !=0 && is<compound> (car (l)))
        out << " ";
      if (N (l) != 1) out << ", ";
      else if (is<compound> (l[0])) out << " ";
      l= cdr (l);
    }
    if (macro_flag) out << ")";
    else out << ">";
  }
  else if (g == CPP_CLASS_TYPE) out << "struct";
  else if (g == CPP_VOID_TYPE) out << "void";
  else if (g == CPP_BOOL_TYPE) out << "bool";
  else if (g == CPP_CHAR_TYPE) out << "char";
  else if (g == CPP_INT_TYPE) out << "int";
  else if (g == CPP_STRING_TYPE) out << "string";
  else out << g;
}

void
cpp_printer::pp_funarg (const generic& g) {
  if (is_func (g, CPP_TYPE, 2) && (g[2] == CPP_CLASS_TYPE))
    pp_decl (g[1], CPP_CLASS_TYPE, false);
  else if (is_func (g, CPP_TYPE, 2))
    pp_decl (g[1], g[2], false);
  else if (is_func (g, CPP_DEFINE, 2) || is_func (g, CPP_ASSIGN, 2))
    pp_decl (g, false);
  else pp_type (g);
}

void
cpp_printer::pp_funargs (const generic& g) {
  if (N(g) == 1) pp_funarg (car (g));
  if (N(g) <= 1) return;
  pp_funarg (car (g));
  out << ", ";
  pp_funargs (cdr (g));
}

/******************************************************************************
* Expressions
******************************************************************************/

void
cpp_printer::pp_expr (const generic& g) {
  if (is_func (g, "$text", 1) || is_func (g, "$math", 1))
    pp_expr (g[1]);
  else pp_comma (g);
}

void
cpp_printer::pp_exprs (const generic& g) {
  if (N(g) == 1) pp_expr (car (g));
  if (N(g) <= 1) return;
  pp_expr (car (g));
  out << ", ";
  pp_exprs (cdr (g));
}

void
cpp_printer::pp_comma (const generic& g) {
  if (is_func (g, CPP_BEGIN)) {
    if (N(g) == 1);
    else if (N(g) == 2) pp_comma (g[1]);
    else for (nat i=1; i<N(g); i++) {
      if (i>1) out << ", ";
      pp_comma (g[i]);
    }
  }
  else pp_assign (g);
}

/******************************************************************************
* Assignments
******************************************************************************/

void
cpp_printer::pp_assign (const generic& g) {
  if (is_func (g, CPP_ASSIGN, 2)) {
    pp_cond (g[1]);
    out << " = ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_PLUS_ASSIGN, 2)) {
    pp_cond (g[1]);
    out << " += ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_MINUS_ASSIGN, 2)) {
    pp_cond (g[1]);
    out << " -= ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_TIMES_ASSIGN, 2)) {
    pp_cond (g[1]);
    out << " *= ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_OVER_ASSIGN, 2)) {
    pp_cond (g[1]);
    out << " /= ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_MOD_ASSIGN, 2)) {
    pp_cond (g[1]);
    out << " %= ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_LESSLESSEQ, 2)) {
    pp_cond (g[1]);
    out << " <<= ";
    pp_assign (g[2]);
  }
  else if (is_func (g, CPP_GTRGTREQ, 2)) {
    pp_cond (g[1]);
    out << " >>= ";
    pp_assign (g[2]);
  }
  else pp_cond (g);
}

/******************************************************************************
* Conditional expressions
******************************************************************************/

void
cpp_printer::pp_cond (const generic& g) {
  if (is_func (g, CPP_IF, 3)) {
    pp_seqor (g[1]);
    out << " ? ";
    pp_seqor (g[2]);
    out << " : ";
    pp_seqor (g[3]);
  }
  else pp_seqor (g);
}

/******************************************************************************
* Logical expressions
******************************************************************************/

void
cpp_printer::pp_seqor (const generic& g) {
  if (is_func (g, CPP_OR, 2)) {
    pp_seqor (g[1]);
    out << " || ";
    pp_seqor (g[2]);
  }
  else pp_seqand (g);
}

void
cpp_printer::pp_seqand (const generic& g) {
  if (is_func (g, CPP_AND, 2)) {
    pp_seqand (g[1]);
    out << " && ";
    pp_seqand (g[2]);
  }
  else pp_or (g);
}

void
cpp_printer::pp_or (const generic& g) {
  if (is_func (g, CPP_BITWISE_OR, 2)) {
    pp_or (g[1]);
    out << " | ";
    pp_or (g[2]);
  }
  else pp_xor (g);
}

void
cpp_printer::pp_xor (const generic& g) {
  if (is_func (g, CPP_BITWISE_XOR, 2)) {
    pp_xor (g[1]);
    out << " ^ ";
    pp_xor (g[2]);
  }
  else pp_and (g);
}

void
cpp_printer::pp_and (const generic& g) {
  if (is_func (g, CPP_BITWISE_AND, 2)) {
    pp_and (g[1]);
    out << " & ";
    pp_and (g[2]);
  }
  else pp_eq (g);
}

/******************************************************************************
* Relational expressions
******************************************************************************/

void
cpp_printer::pp_eq (const generic& g) {
  if (is_func (g, CPP_EQUAL, 2)) {
    pp_rel (g[1]);
    out << " == ";
    pp_rel (g[2]);
  }
  else if (is_func (g, CPP_UNEQUAL, 2)) {
    pp_rel (g[1]);
    out << " != ";
    pp_rel (g[2]);
  }
  else pp_rel (g);
}

void
cpp_printer::pp_rel (const generic& g) {
  if (is_func (g, CPP_LESS, 2)) {
    pp_shift (g[1]);
    out << " < ";
    pp_shift (g[2]);
  }
  else if (is_func (g, CPP_LESSEQ, 2)) {
    pp_shift (g[1]);
    out << " <= ";
    pp_shift (g[2]);
  }
  else if (is_func (g, CPP_GTR, 2)) {
    pp_shift (g[1]);
    out << " > ";
    pp_shift (g[2]);
  }
  else if (is_func (g, CPP_GTREQ, 2)) {
    pp_shift (g[1]);
    out << " >= ";
    pp_shift (g[2]);
  }
  else pp_shift (g);
}

/******************************************************************************
* Arithmetic expressions
******************************************************************************/

void
cpp_printer::pp_shift (const generic& g) {
  if (is_func (g, CPP_LESSLESS, 2)) {
    pp_lshift (g[1]);
    out << " << ";
    pp_add (g[2]);
  }
  else if (is_func (g, CPP_GTRGTR, 2)) {
    pp_add (g[1]);
    out << " >> ";
    pp_rshift (g[2]);
  }
  else pp_add (g);
}

void
cpp_printer::pp_lshift (const generic& g) {
  if (is_func (g, CPP_LESSLESS, 2)) {
    pp_lshift (g[1]);
    out << " << ";
    pp_add (g[2]);
  }
  else pp_add (g);
}

void
cpp_printer::pp_rshift (const generic& g) {
  if (is_func (g, CPP_GTRGTR, 2)) {
    pp_add (g[1]);
    out << " >> ";
    pp_rshift (g[2]);
  }
  else pp_add (g);
}

void
cpp_printer::pp_add (const generic& g) {
  if (is_func (g, CPP_PLUS, 2)) {
    pp_add (g[1]);
    out << " + ";
    pp_add (g[2]);
  }
  else if (is_func (g, CPP_MINUS, 2)) {
    pp_add (g[1]);
    out << " - ";
    pp_mult (g[2]);
  }
  else pp_mult (g);
}

void
cpp_printer::pp_mult (const generic& g) {
  if (is_func (g, CPP_TIMES, 2)) {
    pp_mult (g[1]);
    out << " * ";
    pp_mult (g[2]);
  }
  else if (is_func (g, CPP_OVER, 2)) {
    pp_mult (g[1]);
    out << " / ";
    pp_unary (g[2]);
  }
  else if (is_func (g, CPP_MOD, 2)) {
    pp_mult (g[1]);
    out << " % ";
    pp_unary (g[2]);
  }
  else pp_unary (g);
}

/******************************************************************************
* Unary, postfix and primary expressions
******************************************************************************/

void
cpp_printer::pp_unary (const generic& g) {
  if (is_func (g, CPP_PREINC, 1)) {
    out << "++";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_PREDEC, 1)) {
    out << "--";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_TIMES, 1) || is_func (g, CPP_UNPOINTER, 1)) {
    out << "*";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_UNALIAS, 1)) {
    out << "&";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_PLUS, 1)) {
    out << "+";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_MINUS, 1)) {
    out << "-";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_NOT, 1)) {
    out << "!";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_COMPLEMENT, 1)) {
    out << "~";
    pp_unary (g[1]);
  }
  else if (is_func (g, CPP_DELETE, 1)) {
    out << "delete ";
    pp_expr (g[1]);
  }
  else if (is_func (g, CPP_NEW)) {
    out << "new ";
    pp_type (g[1]);
    out << " (";
    pp_exprs (cdr (cdr (g)));
    out << ")";
  }
  else if (is_func (g, CPP_CAST)) {
    out << "((";
    pp_type (g[2]);
    out << ") ";
    pp_expr (g[1]);
    out << ")";
  }
  else pp_postfix (g);
}

/******************************************************************************
* Postfix expressions
******************************************************************************/

static bool
is_applicable (const generic& g) {
  if (is<literal> (g)) {
    string s= *as<literal> (g);
    if (N(s) == 0) return false;
    nat i;
    for (i=0; i<N(s); i++)
      if (((s[i]<'0') || (s[i]>'9')) &&
          ((s[i]<'a') || (s[i]>'z')) &&
          ((s[i]<'A') || (s[i]>'Z')) &&
          ((s[i]<'_') || (s[i]>'_')))
        return false;
    return
      s != CPP_IF && s != CPP_AND && s != CPP_OR && s != CPP_XOR &&
      s != CPP_UNALIAS && s != CPP_UNPOINTER;
  }
  else if (is_func (g, CPP_SPECIALIZE) && N(g)>=2 && is_applicable (g[1]))
    return true;
  else if (is_func (g, CPP_TYPE_CONSTRUCTOR, 1))
    return true;
  else return false;
}

void
cpp_printer::pp_postfix (const generic& g) {
  if (is_func (g, CPP_SCOPE, 2)) {
    pp_type (g[1]);
    out << "::";
    pp_postfix (g[2]);
  }
  else if (is_func (g, CPP_DOT, 2)) {
    pp_postfix (g[1]);
    out << ".";
    pp_primary (g[2]);
  }
  else if (is_func (g, CPP_ARROW, 2)) {
    pp_postfix (g[1]);
    out << "->";
    pp_primary (g[2]);
  }
  else if (is_func (g, CPP_POSTINC, 1)) {
    pp_postfix (g[1]);
    out << "++";
  }
  else if (is_func (g, CPP_POSTDEC, 1)) {
    pp_postfix (g[1]);
    out << "--";
  }
  else if (is_func (g, CPP_APPLY)) {
    pp_postfix (g[1]);
    out << " (";
    pp_exprs (cdr (cdr (g)));
    out << ")";
  }
  else if (is_func (g, CPP_UNFUNCTION)) {
    pp_postfix (g[1]);
    out << " (";
    pp_funargs (cdr (cdr (g)));
    out << ")";
  }
  else if (is_func (g, CPP_SPECIALIZE)) {
    generic fun= g[1];
    bool macro_flag= is_func (fun, CPP_MACRO, 1);
    if (macro_flag) fun= fun[1];
    pp_postfix (fun);
    if (macro_flag) out << "(";
    else out << "<";
    pp_funargs (cdr (cdr (g)));
    if (N(g) > 2) out << " ";
    if (macro_flag) out << ")";
    else out << ">";
  }
  else if (is_func (g, CPP_TYPE_CONSTRUCTOR, 1)) {
    generic tp= g[1];
    pp_type (tp);
  }
  else if (is_func (g, CPP_ACCESS)) {
    pp_postfix (g[1]);
    out << "[";
    pp_exprs (cdr (cdr (g)));
    out << "]";
  }
  else if (is_func (g, CPP_POWER, 2)) {
    out << "pow (";
    pp_exprs (cdr (g));
    out << ")";
  }
  else if (((N(g) > 0) && is_applicable (g[0])) ||
           ((!is_nil (sl)) && (car (sl) == g))) {
    pp_postfix  (car (g));
    out << " (";
    pp_exprs (cdr (g));
    out << ")";
  }
  else pp_primary (g);
}

/******************************************************************************
* Primary expressions
******************************************************************************/

void
cpp_printer::pp_primary (const generic& g) {
  static table<string, string> t (opname_table ());

  if (is<string> (g)) { ERROR ("invalid primary symbol"); }
  //else if (is<string> (g) && (t->contains (as<string> (g))))
  //out << string ("operator ") * t [as<string> (g)];
  else if (g == CPP_POWER) out << "pow";
  else if (is<literal> (g)) {
    string s= *as<literal> (g);
    if (t->contains (s)) out << (string ("operator ") * t [s]);
    else out << s;
  }
  else if (N(g) == 0) out << g;
  else if (is_func (g, CPP_BRACKETS, 1)) {
    out << "(";
    pp_expr (g[1]);
    out << ")";
  }
  else {
    out << "(";
    sl= cons (g, sl);
    pp_expr (g);
    sl= cdr (sl);
    out << ")";
  }
}

/******************************************************************************
* Interface
******************************************************************************/

void
cpp_printer::pp (const generic& g) {
  pp_begin (g);
}

string
as_cpp (const generic& g) {
  cpp_printer pp;
  pp.pp (g);
  while (N (pp.out) > 0 && pp.out [N (pp.out) - 1] == '\n')
    inside (pp.out) -> resize (N (pp.out) - 1);
  return pp.out;
}

string
flatten_as_cpp (const generic& g) {
  generic f= as_generic (flatten (g));
  return as_cpp (f);
}

} // namespace mmx