/*
  Copyright (C) 1997-2001 Shigeru Chiba, Tokyo Institute of Technology.

  Permission to use, copy, distribute and modify this software and   
  its documentation for any purpose is hereby granted without fee,        
  provided that the above copyright notice appear in all copies and that 
  both that copyright notice and this permission notice appear in 
  supporting documentation.

  Shigeru Chiba makes no representations about the suitability of this 
  software for any purpose.  It is provided "as is" without express or
  implied warranty.
*/

#include <string.h>
#include <iostream.h>
#include "token.h"
#include "ptree.h"
#include "encoding.h"
#include "walker.h"

// class Leaf

Leaf::Leaf(char* ptr, int len)
{
    data.leaf.position = ptr;
    data.leaf.length = len;
}

Leaf::Leaf(Token& tk)
{
    data.leaf.position = tk.ptr;
    data.leaf.length = tk.len;
}

bool Leaf::IsLeaf()
{
    return TRUE;
}

void Leaf::Print(ostream& s, int, int)
{
    char* p = data.leaf.position;
    int n = data.leaf.length;

    // Recall that [, ], and @ are special characters.

    if(n < 1)
	return;
    else if(n == 1 && *p == '@'){
	s << "\\@";
	return;
    }

    char c = *p++;
    if(c == '[' || c == ']')
	s << '\\' << c;		// [ and ] at the beginning are escaped.
    else
	s << c;

    while(--n > 0)
	s << *p++;
}

int Leaf::Write(ostream& out, int indent)
{
    int n = 0;
    char* ptr = data.leaf.position;
    int len = data.leaf.length;
    while(len-- > 0){
	char c = *ptr++;
	if(c == '\n'){
	    PrintIndent(out, indent);
	    ++n;
	}
	else
	    out << c;
    }

    return n;
}

void Leaf::WritePS(ProgramString& out)
{
    char* ptr = data.leaf.position;
    int len = data.leaf.length;
    while(len-- > 0)
	out << *ptr++;
}


// class LeafName

LeafName::LeafName(Token& t) : Leaf(t) {}

Ptree* LeafName::Translate(Walker* w)
{
    return w->TranslateVariable(this);
}

void LeafName::Typeof(Walker* w, TypeInfo& t)
{
    w->TypeofVariable(this, t);
}

// class DupLeaf
// This allocates new memory to the given string.

DupLeaf::DupLeaf(char* str, int len) : Leaf(new (GC) char[len], len)
{
    memmove(data.leaf.position, str, len);
}

DupLeaf::DupLeaf(char* str1, int len1, char* str2, int len2)
: Leaf(new (GC) char[len1 + len2], len1 + len2)
{
    memmove(data.leaf.position, str1, len1);
    memmove(&data.leaf.position[len1], str2, len2);
}

void DupLeaf::Print(ostream& s, int, int)
{
    int i, j;
    char* pos;

    pos = data.leaf.position;
    j = data.leaf.length;

    if(j == 1 && *pos == '@'){
	s << "\\@";
	return;
    }

    s << '`';
    for(i = 0; i < j; ++i)
	if(pos[i] == '[' || pos[i] == ']'){
	    s << '\\';
	    s << pos[i];
	}
	else
	    s << pos[i];

    s << '`';
}

int LeafThis::What()
{
    return THIS;
}

Ptree* LeafThis::Translate(Walker* w)
{
    return w->TranslateThis(this);
}

void LeafThis::Typeof(Walker* w, TypeInfo& t)
{
    w->TypeofThis(this, t);
}

#define ResearvedWordImpl(w) \
int Leaf##w::What() { return w; }

ResearvedWordImpl(AUTO)
ResearvedWordImpl(BOOLEAN)
ResearvedWordImpl(CHAR)
ResearvedWordImpl(CONST)
ResearvedWordImpl(DOUBLE)
ResearvedWordImpl(EXTERN)
ResearvedWordImpl(FLOAT)
ResearvedWordImpl(FRIEND)
ResearvedWordImpl(INLINE)
ResearvedWordImpl(INT)
ResearvedWordImpl(LONG)
ResearvedWordImpl(MUTABLE)
ResearvedWordImpl(NAMESPACE)
ResearvedWordImpl(PRIVATE)
ResearvedWordImpl(PROTECTED)
ResearvedWordImpl(PUBLIC)
ResearvedWordImpl(REGISTER)
ResearvedWordImpl(SHORT)
ResearvedWordImpl(SIGNED)
ResearvedWordImpl(STATIC)
ResearvedWordImpl(UNSIGNED)
ResearvedWordImpl(USING)
ResearvedWordImpl(VIRTUAL)
ResearvedWordImpl(VOID)
ResearvedWordImpl(VOLATILE)

ResearvedWordImpl(UserKeyword2)

#undef ResearvedWordImpl

// class NonLeaf

NonLeaf::NonLeaf(Ptree* p, Ptree* q)
{
    data.nonleaf.child = p;
    data.nonleaf.next = q;
}

bool NonLeaf::IsLeaf()
{
    return FALSE;
}

void NonLeaf::Print(ostream& s, int indent, int depth)
{
    if(TooDeep(s, depth))
	return;

    Ptree* rest = this;
    s << '[';
    while(rest != nil){
	if(rest->IsLeaf()){
	    s << "@ ";
	    rest->Print(s, indent, depth + 1);
	    rest = nil;
	}
	else{
	    Ptree* head = rest->data.nonleaf.child;
	    if(head == nil)
		s << "nil";
	    else
		head->Print(s, indent, depth + 1);
	    rest = rest->data.nonleaf.next;
	    if(rest != nil)
		s << ' ';
	}
    }

    s << ']';
}

bool NonLeaf::TooDeep(ostream& s, int depth)
{
    if(depth >= 32){
	s << " ** too many nestings ** ";
	return TRUE;
    }
    else
	return FALSE;
}

int NonLeaf::Write(ostream& out, int indent)
{
    int n = 0;
    Ptree* p = this;
    for(;;){
	Ptree* head = p->Car();
	if(head != nil)
	    n += head->Write(out, indent);

	p = p->Cdr();
	if(p == nil)
	    break;
	else if(p->IsLeaf()){
	    MopErrorMessage("NonLeaf::Write()", "not list");
	    break;
	}
	else
	    out << ' ';
    }

    return n;
}

void NonLeaf::PrintWithEncodeds(ostream& s, int indent, int depth)
{
    char* encode = GetEncodedType();
    if(encode != nil){
	s << '#';
	Encoding::Print(s, encode);
    }

    encode = GetEncodedName();
    if(encode != nil){
	s << '@';
	Encoding::Print(s, encode);
    }

    NonLeaf::Print(s, indent, depth);
}

void NonLeaf::WritePS(ProgramString& out)
{
    Ptree* p = this;
    for(;;){
	Ptree* head = p->Car();
	if(head != nil)
	    head->WritePS(out);

	p = p->Cdr();
	if(p == nil)
	    break;
	else if(p->IsLeaf()){
	    MopErrorMessage("NonLeaf::WritePS()", "not list");
	    break;
	}
	else
	    out << ' ';
    }
}


// class PtreeBrace

void PtreeBrace::Print(ostream& s, int indent, int depth)
{
    if(TooDeep(s, depth))
	return;

    int indent2 = indent + 1;
    s << "[{";
    Ptree* body = Ptree::Second(this);
    if(body == nil){
	PrintIndent(s, indent2);
	s << "nil";
    }
    else
	while(body != nil){
	    PrintIndent(s, indent2);
	    if(body->IsLeaf()){
		s << "@ ";
		body->Print(s, indent + 1, depth + 1);
	    }
	    else{
		Ptree* head = body->Car();
		if(head == nil)
		    s << "nil";
		else
		    head->Print(s, indent + 1, depth + 1);
	    }

	    body = body->Cdr();
	}

    PrintIndent(s, indent);
    s << "}]";
}

int PtreeBrace::Write(ostream& out, int indent)
{
    int n = 0;

    out << '{';
    Ptree* p = this->Cadr();
    while(p != nil){
	if(p->IsLeaf()){
	    MopErrorMessage("PtreeBrace::Write()", "non list");
	    break;
	}
	else{
	    PrintIndent(out, indent + 1);
	    ++n;
	    Ptree* q = p->Car();
	    p = p->Cdr();
	    if(q != nil)
		n += q->Write(out, indent + 1);
	}
    }

    PrintIndent(out, indent);
    ++n;
    out << '}';
    return n;
}

Ptree* PtreeBrace::Translate(Walker* w)
{
    return w->TranslateBrace(this);
}

// class PtreeBlock

Ptree* PtreeBlock::Translate(Walker* w)
{
    return w->TranslateBlock(this);
}

// class PtreeClassBody

Ptree* PtreeClassBody::Translate(Walker* w)
{
    return w->TranslateClassBody(this, nil, nil);
}

// class PtreeTypedef

int PtreeTypedef::What()
{
    return ntTypedef;
}

Ptree* PtreeTypedef::Translate(Walker* w)
{
    return w->TranslateTypedef(this);
}

// class PtreeTemplateDecl

int PtreeTemplateDecl::What()
{
    return ntTemplateDecl;
}

Ptree* PtreeTemplateDecl::Translate(Walker* w)
{
    return w->TranslateTemplateDecl(this);
}

// class PtreeTemplateInstantiation

int PtreeTemplateInstantiation::What()
{
    return ntTemplateInstantiation;
}

Ptree* PtreeTemplateInstantiation::Translate(Walker* w)
{
    return w->TranslateTemplateInstantiation(this);
}

// class PtreeExternTemplate

int PtreeExternTemplate::What()
{
    return ntExternTemplate;
}

Ptree* PtreeExternTemplate::Translate(Walker* w)
{
    return w->TranslateExternTemplate(this);
}

// class PtreeMetaclassDecl

int PtreeMetaclassDecl::What()
{
    return ntMetaclassDecl;
}

Ptree* PtreeMetaclassDecl::Translate(Walker* w)
{
    return w->TranslateMetaclassDecl(this);
}

// class PtreeLinkageSpec

int PtreeLinkageSpec::What()
{
    return ntLinkageSpec;
}

Ptree* PtreeLinkageSpec::Translate(Walker* w)
{
    return w->TranslateLinkageSpec(this);
}

// class PtreeNamespaceSpec

int PtreeNamespaceSpec::What()
{
    return ntNamespaceSpec;
}

Ptree* PtreeNamespaceSpec::Translate(Walker* w)
{
    return w->TranslateNamespaceSpec(this);
}

// class PtreeUsing

PtreeUsing::PtreeUsing(Ptree* p, Ptree* q, Ptree* r, Encoding& e, Ptree* s)
: NonLeaf(p, Ptree::List(q, r, s))
{
    name = e.Get();
}

char* PtreeUsing::GetEncodedName()
{
  return name;
}

int PtreeUsing::What()
{
    return ntUsing;
}

Ptree* PtreeUsing::Translate(Walker* w)
{
    return w->TranslateUsing(this);
}

// class PtreeDeclaration

int PtreeDeclaration::What()
{
    return ntDeclaration;
}

Ptree* PtreeDeclaration::Translate(Walker* w)
{
    return w->TranslateDeclaration(this);
}

// class PtreeDeclarator

PtreeDeclarator::PtreeDeclarator(Ptree* list, Encoding& t, Encoding& n,
				 Ptree* dname)
: NonLeaf(list->Car(), list->Cdr())
{
    type = t.Get();
    name = n.Get();
    declared_name = dname;
    comments = nil;
}

PtreeDeclarator::PtreeDeclarator(Encoding& t, Encoding& n, Ptree* dname)
: NonLeaf(nil, nil)
{
    type = t.Get();
    name = n.Get();
    declared_name = dname;
    comments = nil;
}

PtreeDeclarator::PtreeDeclarator(Ptree* p, Ptree* q,
				 Encoding& t, Encoding& n, Ptree* dname)
: NonLeaf(p, q)
{
    type = t.Get();
    name = n.Get();
    declared_name = dname;
    comments = nil;
}

PtreeDeclarator::PtreeDeclarator(Ptree* list, Encoding& t)
: NonLeaf(list->Car(), list->Cdr())
{
    type = t.Get();
    name = nil;
    declared_name = nil;
    comments = nil;
}

PtreeDeclarator::PtreeDeclarator(Encoding& t)
: NonLeaf(nil, nil)
{
    type = t.Get();
    name = nil;
    declared_name = nil;
    comments = nil;
}

PtreeDeclarator::PtreeDeclarator(PtreeDeclarator* decl, Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
    type = decl->type;
    name = decl->name;
    declared_name = decl->declared_name;
    comments = nil;
}

int PtreeDeclarator::What()
{
    return ntDeclarator;
}

char* PtreeDeclarator::GetEncodedType()
{
    return type;
}

char* PtreeDeclarator::GetEncodedName()
{
    return name;
}

void PtreeDeclarator::Print(ostream& s, int i, int d)
{
    if(show_encoded)
	PrintWithEncodeds(s, i, d);
    else
	NonLeaf::Print(s, i, d);
}


// class PtreeName

PtreeName::PtreeName(Ptree* p, Encoding& e)
: NonLeaf(p->Car(), p->Cdr())
{
    name = e.Get();
}

int PtreeName::What()
{
    return ntName;
}

char* PtreeName::GetEncodedName()
{
    return name;
}

void PtreeName::Print(ostream& s, int i, int d)
{
    if(show_encoded)
	PrintWithEncodeds(s, i, d);
    else
	NonLeaf::Print(s, i, d);
}

Ptree* PtreeName::Translate(Walker* w)
{
    return w->TranslateVariable(this);
}

void PtreeName::Typeof(Walker* w, TypeInfo& t)
{
    w->TypeofVariable(this, t);
}

// class PtreeFstyleCastExpr

PtreeFstyleCastExpr::PtreeFstyleCastExpr(Encoding& e, Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
    type = e.Get();
}

PtreeFstyleCastExpr::PtreeFstyleCastExpr(char* e, Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
    type = e;
}

int PtreeFstyleCastExpr::What()
{
    return ntFstyleCast;
}

char* PtreeFstyleCastExpr::GetEncodedType()
{
    return type;
}

void PtreeFstyleCastExpr::Print(ostream& s, int i, int d)
{
    if(show_encoded)
	PrintWithEncodeds(s, i, d);
    else
	NonLeaf::Print(s, i, d);
}

Ptree* PtreeFstyleCastExpr::Translate(Walker* w)
{
    return w->TranslateFstyleCast(this);
}

void PtreeFstyleCastExpr::Typeof(Walker* w, TypeInfo& t)
{
    w->TypeofFstyleCast(this, t);
}

// class PtreeClassSpec

PtreeClassSpec::PtreeClassSpec(Ptree* p, Ptree* q, Ptree* c)
: NonLeaf(p, q)
{
    encoded_name = nil;
    comments = c;
}

PtreeClassSpec::PtreeClassSpec(Ptree* car, Ptree* cdr,
		Ptree* c, char* encode) : NonLeaf(car, cdr)
{
    encoded_name = encode;
    comments = c;
}

int PtreeClassSpec::What()
{
    return ntClassSpec;
}

Ptree* PtreeClassSpec::Translate(Walker* w)
{
    return w->TranslateClassSpec(this);
}

char* PtreeClassSpec::GetEncodedName()
{
    return encoded_name;
}

Ptree* PtreeClassSpec::GetComments()
{
    return comments;
}

// class PtreeEnumSpec

PtreeEnumSpec::PtreeEnumSpec(Ptree* head)
: NonLeaf(head, nil)
{
    encoded_name = nil;
}

int PtreeEnumSpec::What()
{
    return ntEnumSpec;
}

Ptree* PtreeEnumSpec::Translate(Walker* w)
{
    return w->TranslateEnumSpec(this);
}

char* PtreeEnumSpec::GetEncodedName()
{
    return encoded_name;
}

PtreeAccessSpec::PtreeAccessSpec(Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
}

int PtreeAccessSpec::What()
{
    return ntAccessSpec;
}

Ptree* PtreeAccessSpec::Translate(Walker* w)
{
    return w->TranslateAccessSpec(this);
}

PtreeAccessDecl::PtreeAccessDecl(Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
}

int PtreeAccessDecl::What()
{
    return ntAccessDecl;
}

Ptree* PtreeAccessDecl::Translate(Walker* w)
{
    return w->TranslateAccessDecl(this);
}

PtreeUserAccessSpec::PtreeUserAccessSpec(Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
}

int PtreeUserAccessSpec::What()
{
    return ntUserAccessSpec;
}

Ptree* PtreeUserAccessSpec::Translate(Walker* w)
{
    return w->TranslateUserAccessSpec(this);
}

PtreeUserdefKeyword::PtreeUserdefKeyword(Ptree* p, Ptree* q)
: NonLeaf(p, q)
{
}

int PtreeUserdefKeyword::What()
{
    return ntUserdefKeyword;
}

#define PtreeStatementImpl(s)\
int Ptree##s##Statement::What() { return nt##s##Statement; }\
Ptree* Ptree##s##Statement::Translate(Walker* w) {\
    return w->Translate##s(this); }

PtreeStatementImpl(If)
PtreeStatementImpl(Switch)
PtreeStatementImpl(While)
PtreeStatementImpl(Do)
PtreeStatementImpl(For)
PtreeStatementImpl(Try)
PtreeStatementImpl(Break)
PtreeStatementImpl(Continue)
PtreeStatementImpl(Return)
PtreeStatementImpl(Goto)
PtreeStatementImpl(Case)
PtreeStatementImpl(Default)
PtreeStatementImpl(Label)

#undef PtreeStatementImpl

int PtreeExprStatement::What()
{
    return ntExprStatement;
}

Ptree* PtreeExprStatement::Translate(Walker* w)
{
    return w->TranslateExprStatement(this);
}

#define PtreeExprImpl(n)\
int Ptree##n##Expr::What() { return nt##n##Expr; }\
Ptree* Ptree##n##Expr::Translate(Walker* w) {\
    return w->Translate##n(this); }\
void Ptree##n##Expr::Typeof(Walker* w, TypeInfo& t) {\
    w->Typeof##n(this, t); }

PtreeExprImpl(Comma)
PtreeExprImpl(Assign)
PtreeExprImpl(Cond)
PtreeExprImpl(Infix)
PtreeExprImpl(Pm)
PtreeExprImpl(Cast)
PtreeExprImpl(Unary)
PtreeExprImpl(Throw)
PtreeExprImpl(Sizeof)
PtreeExprImpl(New)
PtreeExprImpl(Delete)
PtreeExprImpl(Array)
PtreeExprImpl(Funcall)
PtreeExprImpl(Postfix)
PtreeExprImpl(UserStatement)
PtreeExprImpl(DotMember)
PtreeExprImpl(ArrowMember)
PtreeExprImpl(Paren)
PtreeExprImpl(StaticUserStatement)

#undef PtreeExprImpl