1| /*
    2|   Copyright (C) 1997-2000 Shigeru Chiba, University of Tsukuba.
    3| 
    4|   Permission to use, copy, distribute and modify this software and   
    5|   its documentation for any purpose is hereby granted without fee,        
    6|   provided that the above copyright notice appear in all copies and that 
    7|   both that copyright notice and this permission notice appear in 
    8|   supporting documentation.
    9| 
   10|   Shigeru Chiba makes no representations about the suitability of this 
   11|   software for any purpose.  It is provided "as is" without express or
   12|   implied warranty.
   13| */
   14| 
   15| #include <cstring>
   16| #include <iostream>
   17| #include "token.h"
   18| #include "ptree.h"
   19| #include "encoding.h"
   20| #include "walker.h"
   21| 
   22| // class Leaf
   23| 
   24| Leaf::Leaf(char* ptr, int len)
   25| {
   26|     data.leaf.position = ptr;
   27|     data.leaf.length = len;
   28| }
   29| 
   30| Leaf::Leaf(Token& tk)
   31| {
   32|     data.leaf.position = tk.ptr;
   33|     data.leaf.length = tk.len;
   34| }
   35| 
   36| bool Leaf::IsLeaf()
   37| {
   38|     return TRUE;
   39| }
   40| 
   41| void Leaf::Print(std::ostream& s, int, int)
   42| {
   43|     char* p = data.leaf.position;
   44|     int n = data.leaf.length;
   45| 
   46|     // Recall that [, ], and @ are special characters.
   47| 
   48|     if(n < 1)
   49|         return;
   50|     else if(n == 1 && *p == '@'){
   51|         s << "\\@";
   52|         return;
   53|     }
   54| 
   55|     char c = *p++;
   56|     if(c == '[' || c == ']')
   57|         s << '\\' << c;               // [ and ] at the beginni
   58|     else
   59|         s << c;
   60| 
   61|     while(--n > 0)
   62|         s << *p++;
   63| }
   64| 
   65| int Leaf::Write(std::ostream& out, int indent)
   66| {
   67|     int n = 0;
   68|     char* ptr = data.leaf.position;
   69|     int len = data.leaf.length;
   70|     while(len-- > 0){
   71|         char c = *ptr++;
   72|         if(c == '\n'){
   73|             PrintIndent(out, indent);
   74|         ++n;
   75|         }
   76|         else
   77|             out << c;
   78|     }
   79| 
   80|     return n;
   81| }
   82| 
   83| void Leaf::WritePS(ProgramString& out)
   84| {
   85|     char* ptr = data.leaf.position;
   86|     int len = data.leaf.length;
   87|     while(len-- > 0)
   88|         out << *ptr++;
   89| }
   90| 
   91| 
   92| // class LeafName
   93| 
   94| LeafName::LeafName(Token& t) : CommentedLeaf(t) {}
   95| 
   96| Ptree* LeafName::Translate(Walker* w)
   97| {
   98|     return w->TranslateVariable(this);
   99| }
  100| 
  101| void LeafName::Typeof(Walker* w, TypeInfo& t)
  102| {
  103|     w->TypeofVariable(this, t);
  104| }
  105| 
  106| // class DupLeaf
  107| // This allocates new memory to the given string.
  108| 
  109| DupLeaf::DupLeaf(char* str, int len) : CommentedLeaf(new (GC) char[len], len)
  110| {
  111|     memmove(data.leaf.position, str, len);
  112| }
  113| 
  114| DupLeaf::DupLeaf(char* str1, int len1, char* str2, int len2)
  115| : CommentedLeaf(new (GC) char[len1 + len2], len1 + len2)
  116| {
  117|     memmove(data.leaf.position, str1, len1);
  118|     memmove(&data.leaf.position[len1], str2, len2);
  119| }
  120| 
  121| void DupLeaf::Print(std::ostream& s, int, int)
  122| {
  123|     int i, j;
  124|     char* pos;
  125| 
  126|     pos = data.leaf.position;
  127|     j = data.leaf.length;
  128| 
  129|     if(j == 1 && *pos == '@'){
  130|         s << "\\@";
  131|         return;
  132|     }
  133| 
  134|     s << '`';
  135|     for(i = 0; i < j; ++i)
  136|         if(pos[i] == '[' || pos[i] == ']'){
  137|             s << '\\';
  138|             s << pos[i];
  139|         }
  140|         else
  141|             s << pos[i];
  142| 
  143|     s << '`';
  144| }
  145| 
  146| int LeafThis::What()
  147| {
  148|     return THIS;
  149| }
  150| 
  151| Ptree* LeafThis::Translate(Walker* w)
  152| {
  153|     return w->TranslateThis(this);
  154| }
  155| 
  156| void LeafThis::Typeof(Walker* w, TypeInfo& t)
  157| {
  158|     w->TypeofThis(this, t);
  159| }
  160| 
  161| #define ResearvedWordImpl(w) \
  162| int Leaf##w::What() { return w; }
  163| 
  164| ResearvedWordImpl(AUTO)
  165| ResearvedWordImpl(BOOLEAN)
  166| ResearvedWordImpl(CHAR)
  167| ResearvedWordImpl(CONST)
  168| ResearvedWordImpl(DOUBLE)
  169| ResearvedWordImpl(EXTERN)
  170| ResearvedWordImpl(FLOAT)
  171| ResearvedWordImpl(FRIEND)
  172| ResearvedWordImpl(INLINE)
  173| ResearvedWordImpl(INT)
  174| ResearvedWordImpl(LONG)
  175| ResearvedWordImpl(MUTABLE)
  176| ResearvedWordImpl(NAMESPACE)
  177| ResearvedWordImpl(PRIVATE)
  178| ResearvedWordImpl(PROTECTED)
  179| ResearvedWordImpl(PUBLIC)
  180| ResearvedWordImpl(REGISTER)
  181| ResearvedWordImpl(SHORT)
  182| ResearvedWordImpl(SIGNED)
  183| ResearvedWordImpl(STATIC)
  184| ResearvedWordImpl(UNSIGNED)
  185| ResearvedWordImpl(USING)
  186| ResearvedWordImpl(VIRTUAL)
  187| ResearvedWordImpl(VOID)
  188| ResearvedWordImpl(VOLATILE)
  189| 
  190| ResearvedWordImpl(UserKeyword2)
  191| 
  192| #undef ResearvedWordImpl
  193| 
  194| // class NonLeaf
  195| 
  196| NonLeaf::NonLeaf(Ptree* p, Ptree* q)
  197| {
  198|     data.nonleaf.child = p;
  199|     data.nonleaf.next = q;
  200| }
  201| 
  202| bool NonLeaf::IsLeaf()
  203| {
  204|     return FALSE;
  205| }
  206| 
  207| void NonLeaf::Print(std::ostream& s, int indent, int depth)
  208| {
  209|     if(TooDeep(s, depth))
  210|         return;
  211| 
  212|     Ptree* rest = this;
  213|     s << '[';
  214|     while(rest != nil){
  215|         if(rest->IsLeaf()){
  216|             s << "@ ";
  217|             rest->Print(s, indent, depth + 1);
  218|             rest = nil;
  219|         }
  220|         else{
  221|             Ptree* head = rest->data.nonleaf.child;
  222|             if(head == nil)
  223|                s << "nil";
  224|         else
  225|                head->Print(s, indent, depth + 1);
  226|             rest = rest->data.nonleaf.next;
  227|             if(rest != nil)
  228|                s << ' ';
  229|         }
  230|     }
  231| 
  232|     s << ']';
  233| }
  234| 
  235| bool NonLeaf::TooDeep(std::ostream& s, int depth)
  236| {
  237|     if(depth >= 32){
  238|         s << " ** too many nestings ** ";
  239|         return TRUE;
  240|     }
  241|     else
  242|         return FALSE;
  243| }
  244| 
  245| int NonLeaf::Write(std::ostream& out, int indent)
  246| {
  247|     int n = 0;
  248|     Ptree* p = this;
  249|     for(;;){
  250|         Ptree* head = p->Car();
  251|         if(head != nil)
  252|             n += head->Write(out, indent);
  253| 
  254|         p = p->Cdr();
  255|         if(p == nil)
  256|           break;
  257|         else if(p->IsLeaf()){
  258|             MopErrorMessage("NonLeaf::Write()", "not list");
  259|           break;
  260|         }
  261|         else
  262|             out << ' ';
  263|     }
  264| 
  265|     return n;
  266| }
  267| 
  268| void NonLeaf::PrintWithEncodeds(std::ostream& s, int indent, int depth)
  269| {
  270|     char* encode = GetEncodedType();
  271|     if(encode != nil){
  272|         s << '#';
  273|         Encoding::Print(s, encode);
  274|     }
  275| 
  276|     encode = GetEncodedName();
  277|     if(encode != nil){
  278|         s << '@';
  279|         Encoding::Print(s, encode);
  280|     }
  281| 
  282|     NonLeaf::Print(s, indent, depth);
  283| }
  284| 
  285| void NonLeaf::WritePS(ProgramString& out)
  286| {
  287|     Ptree* p = this;
  288|     for(;;){
  289|         Ptree* head = p->Car();
  290|         if(head != nil)
  291|             head->WritePS(out);
  292| 
  293|         p = p->Cdr();
  294|         if(p == nil)
  295|           break;
  296|         else if(p->IsLeaf()){
  297|             MopErrorMessage("NonLeaf::WritePS()", "not list");
  298|           break;
  299|         }
  300|         else
  301|             out << ' ';
  302|     }
  303| }
  304| 
  305| 
  306| // class PtreeBrace
  307| 
  308| void PtreeBrace::Print(std::ostream& s, int indent, int depth)
  309| {
  310|     if(TooDeep(s, depth))
  311|         return;
  312| 
  313|     int indent2 = indent + 1;
  314|     s << "[{";
  315|     Ptree* body = Ptree::Second(this);
  316|     if(body == nil){
  317|         PrintIndent(s, indent2);
  318|         s << "nil";
  319|     }
  320|     else
  321|         while(body != nil){
  322|             PrintIndent(s, indent2);
  323|             if(body->IsLeaf()){
  324|                s << "@ ";
  325|                body->Print(s, indent + 1, depth + 1);
  326|         }
  327|          else{
  328|                Ptree* head = body->Car();
  329|                if(head == nil)
  330|                s << "nil";
  331|         else
  332|                    head->Print(s, indent + 1, depth + 1);
  333|         }
  334| 
  335|             body = body->Cdr();
  336|         }
  337| 
  338|     PrintIndent(s, indent);
  339|     s << "}]";
  340| }
  341| 
  342| int PtreeBrace::Write(std::ostream& out, int indent)
  343| {
  344|     int n = 0;
  345| 
  346|     out << '{';
  347|     Ptree* p = this->Cadr();
  348|     while(p != nil){
  349|         if(p->IsLeaf()){
  350|             MopErrorMessage("PtreeBrace::Write()", "non list");
  351|           break;
  352|         }
  353|         else{
  354|             PrintIndent(out, indent + 1);
  355|         ++n;
  356|             Ptree* q = p->Car();
  357|             p = p->Cdr();
  358|             if(q != nil)
  359|                n += q->Write(out, indent + 1);
  360|         }
  361|     }
  362| 
  363|     PrintIndent(out, indent);
  364|     ++n;
  365|     out << '}';
  366|     return n;
  367| }
  368| 
  369| Ptree* PtreeBrace::Translate(Walker* w)
  370| {
  371|     return w->TranslateBrace(this);
  372| }
  373| 
  374| // class PtreeBlock
  375| 
  376| Ptree* PtreeBlock::Translate(Walker* w)
  377| {
  378|     return w->TranslateBlock(this);
  379| }
  380| 
  381| // class PtreeClassBody
  382| 
  383| Ptree* PtreeClassBody::Translate(Walker* w)
  384| {
  385|     return w->TranslateClassBody(this, nil, nil);
  386| }
  387| 
  388| // class PtreeTypedef
  389| 
  390| int PtreeTypedef::What()
  391| {
  392|     return ntTypedef;
  393| }
  394| 
  395| Ptree* PtreeTypedef::Translate(Walker* w)
  396| {
  397|     return w->TranslateTypedef(this);
  398| }
  399| 
  400| // class PtreeTemplateDecl
  401| 
  402| int PtreeTemplateDecl::What()
  403| {
  404|     return ntTemplateDecl;
  405| }
  406| 
  407| Ptree* PtreeTemplateDecl::Translate(Walker* w)
  408| {
  409|     return w->TranslateTemplateDecl(this);
  410| }
  411| 
  412| // class PtreeTemplateInstantiation
  413| 
  414| int PtreeTemplateInstantiation::What()
  415| {
  416|     return ntTemplateInstantiation;
  417| }
  418| 
  419| Ptree* PtreeTemplateInstantiation::Translate(Walker* w)
  420| {
  421|     return w->TranslateTemplateInstantiation(this);
  422| }
  423| 
  424| // class PtreeExternTemplate
  425| 
  426| int PtreeExternTemplate::What()
  427| {
  428|     return ntExternTemplate;
  429| }
  430| 
  431| Ptree* PtreeExternTemplate::Translate(Walker* w)
  432| {
  433|     return w->TranslateExternTemplate(this);
  434| }
  435| 
  436| // class PtreeMetaclassDecl
  437| 
  438| int PtreeMetaclassDecl::What()
  439| {
  440|     return ntMetaclassDecl;
  441| }
  442| 
  443| Ptree* PtreeMetaclassDecl::Translate(Walker* w)
  444| {
  445|     return w->TranslateMetaclassDecl(this);
  446| }
  447| 
  448| // class PtreeLinkageSpec
  449| 
  450| int PtreeLinkageSpec::What()
  451| {
  452|     return ntLinkageSpec;
  453| }
  454| 
  455| Ptree* PtreeLinkageSpec::Translate(Walker* w)
  456| {
  457|     return w->TranslateLinkageSpec(this);
  458| }
  459| 
  460| // class PtreeNamespaceSpec
  461| 
  462| int PtreeNamespaceSpec::What()
  463| {
  464|     return ntNamespaceSpec;
  465| }
  466| 
  467| Ptree* PtreeNamespaceSpec::Translate(Walker* w)
  468| {
  469|     return w->TranslateNamespaceSpec(this);
  470| }
  471| 
  472| // class PtreeUsing
  473| 
  474| int PtreeUsing::What()
  475| {
  476|     return ntUsing;
  477| }
  478| 
  479| Ptree* PtreeUsing::Translate(Walker* w)
  480| {
  481|     return w->TranslateUsing(this);
  482| }
  483| 
  484| // class PtreeDeclaration
  485| 
  486| int PtreeDeclaration::What()
  487| {
  488|     return ntDeclaration;
  489| }
  490| 
  491| Ptree* PtreeDeclaration::Translate(Walker* w)
  492| {
  493|     return w->TranslateDeclaration(this);
  494| }
  495| 
  496| // class PtreeDeclarator
  497| 
  498| PtreeDeclarator::PtreeDeclarator(Ptree* list, Encoding& t, Encoding& n,
  499|                       Ptree* dname)
  500| : NonLeaf(list->Car(), list->Cdr())
  501| {
  502|     type = t.Get();
  503|     name = n.Get();
  504|     declared_name = dname;
  505|     comments = nil;
  506| }
  507| 
  508| PtreeDeclarator::PtreeDeclarator(Encoding& t, Encoding& n, Ptree* dname)
  509| : NonLeaf(nil, nil)
  510| {
  511|     type = t.Get();
  512|     name = n.Get();
  513|     declared_name = dname;
  514|     comments = nil;
  515| }
  516| 
  517| PtreeDeclarator::PtreeDeclarator(Ptree* p, Ptree* q,
  518|                               Encoding& t, Encoding& n, Ptree* dname)
  519| : NonLeaf(p, q)
  520| {
  521|     type = t.Get();
  522|     name = n.Get();
  523|     declared_name = dname;
  524|     comments = nil;
  525| }
  526| 
  527| PtreeDeclarator::PtreeDeclarator(Ptree* list, Encoding& t)
  528| : NonLeaf(list->Car(), list->Cdr())
  529| {
  530|     type = t.Get();
  531|     name = nil;
  532|     declared_name = nil;
  533|     comments = nil;
  534| }
  535| 
  536| PtreeDeclarator::PtreeDeclarator(Encoding& t)
  537| : NonLeaf(nil, nil)
  538| {
  539|     type = t.Get();
  540|     name = nil;
  541|     declared_name = nil;
  542|     comments = nil;
  543| }
  544| 
  545| PtreeDeclarator::PtreeDeclarator(PtreeDeclarator* decl, Ptree* p, Ptree* q)
  546| : NonLeaf(p, q)
  547| {
  548|     type = decl->type;
  549|     name = decl->name;
  550|     declared_name = decl->declared_name;
  551|     comments = nil;
  552| }
  553| 
  554| int PtreeDeclarator::What()
  555| {
  556|     return ntDeclarator;
  557| }
  558| 
  559| char* PtreeDeclarator::GetEncodedType()
  560| {
  561|     return type;
  562| }
  563| 
  564| char* PtreeDeclarator::GetEncodedName()
  565| {
  566|     return name;
  567| }
  568| 
  569| void PtreeDeclarator::Print(std::ostream& s, int i, int d)
  570| {
  571|     if(show_encoded)
  572|         PrintWithEncodeds(s, i, d);
  573|     else
  574|         NonLeaf::Print(s, i, d);
  575| }
  576| 
  577| 
  578| // class PtreeName
  579| 
  580| PtreeName::PtreeName(Ptree* p, Encoding& e)
  581| : NonLeaf(p->Car(), p->Cdr())
  582| {
  583|     name = e.Get();
  584| }
  585| 
  586| int PtreeName::What()
  587| {
  588|     return ntName;
  589| }
  590| 
  591| char* PtreeName::GetEncodedName()
  592| {
  593|     return name;
  594| }
  595| 
  596| void PtreeName::Print(std::ostream& s, int i, int d)
  597| {
  598|     if(show_encoded)
  599|         PrintWithEncodeds(s, i, d);
  600|     else
  601|         NonLeaf::Print(s, i, d);
  602| }
  603| 
  604| Ptree* PtreeName::Translate(Walker* w)
  605| {
  606|     return w->TranslateVariable(this);
  607| }
  608| 
  609| void PtreeName::Typeof(Walker* w, TypeInfo& t)
  610| {
  611|     w->TypeofVariable(this, t);
  612| }
  613| 
  614| // class PtreeFstyleCastExpr
  615| 
  616| PtreeFstyleCastExpr::PtreeFstyleCastExpr(Encoding& e, Ptree* p, Ptree* q)
  617| : NonLeaf(p, q)
  618| {
  619|     type = e.Get();
  620| }
  621| 
  622| PtreeFstyleCastExpr::PtreeFstyleCastExpr(char* e, Ptree* p, Ptree* q)
  623| : NonLeaf(p, q)
  624| {
  625|     type = e;
  626| }
  627| 
  628| int PtreeFstyleCastExpr::What()
  629| {
  630|     return ntFstyleCast;
  631| }
  632| 
  633| char* PtreeFstyleCastExpr::GetEncodedType()
  634| {
  635|     return type;
  636| }
  637| 
  638| void PtreeFstyleCastExpr::Print(std::ostream& s, int i, int d)
  639| {
  640|     if(show_encoded)
  641|         PrintWithEncodeds(s, i, d);
  642|     else
  643|         NonLeaf::Print(s, i, d);
  644| }
  645| 
  646| Ptree* PtreeFstyleCastExpr::Translate(Walker* w)
  647| {
  648|     return w->TranslateFstyleCast(this);
  649| }
  650| 
  651| void PtreeFstyleCastExpr::Typeof(Walker* w, TypeInfo& t)
  652| {
  653|     w->TypeofFstyleCast(this, t);
  654| }
  655| 
  656| // class PtreeClassSpec
  657| 
  658| PtreeClassSpec::PtreeClassSpec(Ptree* p, Ptree* q, Ptree* c)
  659| : NonLeaf(p, q)
  660| {
  661|     encoded_name = nil;
  662|     comments = c;
  663| }
  664| 
  665| PtreeClassSpec::PtreeClassSpec(Ptree* car, Ptree* cdr,
  666|                Ptree* c, char* encode) : NonLeaf(car, cdr)
  667| {
  668|     encoded_name = encode;
  669|     comments = c;
  670| }
  671| 
  672| int PtreeClassSpec::What()
  673| {
  674|     return ntClassSpec;
  675| }
  676| 
  677| Ptree* PtreeClassSpec::Translate(Walker* w)
  678| {
  679|     return w->TranslateClassSpec(this);
  680| }
  681| 
  682| char* PtreeClassSpec::GetEncodedName()
  683| {
  684|     return encoded_name;
  685| }
  686| 
  687| Ptree* PtreeClassSpec::GetComments()
  688| {
  689|     return comments;
  690| }
  691| 
  692| // class PtreeEnumSpec
  693| 
  694| PtreeEnumSpec::PtreeEnumSpec(Ptree* head)
  695| : NonLeaf(head, nil)
  696| {
  697|     encoded_name = nil;
  698| }
  699| 
  700| int PtreeEnumSpec::What()
  701| {
  702|     return ntEnumSpec;
  703| }
  704| 
  705| Ptree* PtreeEnumSpec::Translate(Walker* w)
  706| {
  707|     return w->TranslateEnumSpec(this);
  708| }
  709| 
  710| char* PtreeEnumSpec::GetEncodedName()
  711| {
  712|     return encoded_name;
  713| }
  714| 
  715| PtreeAccessSpec::PtreeAccessSpec(Ptree* p, Ptree* q)
  716| : NonLeaf(p, q)
  717| {
  718| }
  719| 
  720| int PtreeAccessSpec::What()
  721| {
  722|     return ntAccessSpec;
  723| }
  724| 
  725| Ptree* PtreeAccessSpec::Translate(Walker* w)
  726| {
  727|     return w->TranslateAccessSpec(this);
  728| }
  729| 
  730| PtreeAccessDecl::PtreeAccessDecl(Ptree* p, Ptree* q)
  731| : NonLeaf(p, q)
  732| {
  733| }
  734| 
  735| int PtreeAccessDecl::What()
  736| {
  737|     return ntAccessDecl;
  738| }
  739| 
  740| Ptree* PtreeAccessDecl::Translate(Walker* w)
  741| {
  742|     return w->TranslateAccessDecl(this);
  743| }
  744| 
  745| PtreeUserAccessSpec::PtreeUserAccessSpec(Ptree* p, Ptree* q)
  746| : NonLeaf(p, q)
  747| {
  748| }
  749| 
  750| int PtreeUserAccessSpec::What()
  751| {
  752|     return ntUserAccessSpec;
  753| }
  754| 
  755| Ptree* PtreeUserAccessSpec::Translate(Walker* w)
  756| {
  757|     return w->TranslateUserAccessSpec(this);
  758| }
  759| 
  760| PtreeUserdefKeyword::PtreeUserdefKeyword(Ptree* p, Ptree* q)
  761| : NonLeaf(p, q)
  762| {
  763| }
  764| 
  765| int PtreeUserdefKeyword::What()
  766| {
  767|     return ntUserdefKeyword;
  768| }
  769| 
  770| #define PtreeStatementImpl(s)\
  771| int Ptree##s##Statement::What() { return nt##s##Statement; }\
  772| Ptree* Ptree##s##Statement::Translate(Walker* w) {\
  773|     return w->Translate##s(this); }
  774| 
  775| PtreeStatementImpl(If)
  776| PtreeStatementImpl(Switch)
  777| PtreeStatementImpl(While)
  778| PtreeStatementImpl(Do)
  779| PtreeStatementImpl(For)
  780| PtreeStatementImpl(Try)
  781| PtreeStatementImpl(Break)
  782| PtreeStatementImpl(Continue)
  783| PtreeStatementImpl(Return)
  784| PtreeStatementImpl(Goto)
  785| PtreeStatementImpl(Case)
  786| PtreeStatementImpl(Default)
  787| PtreeStatementImpl(Label)
  788| 
  789| #undef PtreeStatementImpl
  790| 
  791| int PtreeExprStatement::What()
  792| {
  793|     return ntExprStatement;
  794| }
  795| 
  796| Ptree* PtreeExprStatement::Translate(Walker* w)
  797| {
  798|     return w->TranslateExprStatement(this);
  799| }
  800| 
  801| #define PtreeExprImpl(n)\
  802| int Ptree##n##Expr::What() { return nt##n##Expr; }\
  803| Ptree* Ptree##n##Expr::Translate(Walker* w) {\
  804|     return w->Translate##n(this); }\
  805| void Ptree##n##Expr::Typeof(Walker* w, TypeInfo& t) {\
  806|     w->Typeof##n(this, t); }
  807| 
  808| PtreeExprImpl(Comma)
  809| PtreeExprImpl(Assign)
  810| PtreeExprImpl(Cond)
  811| PtreeExprImpl(Infix)
  812| PtreeExprImpl(Pm)
  813| PtreeExprImpl(Cast)
  814| PtreeExprImpl(Unary)
  815| PtreeExprImpl(Throw)
  816| PtreeExprImpl(Sizeof)
  817| PtreeExprImpl(Typeid)
  818| PtreeExprImpl(Typeof)
  819| PtreeExprImpl(New)
  820| PtreeExprImpl(Delete)
  821| PtreeExprImpl(Array)
  822| PtreeExprImpl(Funcall)
  823| PtreeExprImpl(Postfix)
  824| PtreeExprImpl(UserStatement)
  825| PtreeExprImpl(DotMember)
  826| PtreeExprImpl(ArrowMember)
  827| PtreeExprImpl(Paren)
  828| PtreeExprImpl(StaticUserStatement)
  829| 
  830| #undef PtreeExprImpl