---

member.cc

Go to the documentation of this file.

/*
  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 "member.h"
#include "mop.h"
#include "token.h"
#include "env.h"
#include "walker.h"
#include "encoding.h"
#include "ptree.h"

// class Member

Member::Member()
{
    metaobject = nil;
    declarator = nil;
    nth = -1;
    removed = FALSE;
    new_name = nil;
    new_args = nil;
    new_init = nil;
    new_body = nil;
    arg_name_filled = FALSE;

    implementation = nil;
    original_decl = nil;
}

Member::Member(const Member& m)
{
    metaobject = m.metaobject;
    declarator = m.declarator;
    nth = m.nth;
    removed = m.removed;
    new_name = m.new_name;
    new_args = m.new_args;
    new_init = m.new_init;
    new_body = m.new_body;
    arg_name_filled = m.arg_name_filled;

    implementation = m.implementation;
    original_decl = m.original_decl;
}

Member::Member(Class* c, Ptree* decl)
{
    metaobject = c;
    declarator = decl;
    nth = -1;
    removed = FALSE;
    new_name = nil;
    new_args = nil;
    new_init = nil;
    new_body = nil;
    arg_name_filled = FALSE;

    implementation = nil;
    original_decl = nil;
}

void Member::Set(Class* c, Ptree* decl, int n)
{
    metaobject = c;
    declarator = decl;
    nth = n;
    removed = FALSE;
    new_name = nil;
    new_args = nil;
    new_init = nil;
    new_body = nil;
    arg_name_filled = FALSE;

    implementation = nil;
    original_decl = nil;
}

void Member::Signature(TypeInfo& t) const
{
    if(declarator == nil){
        MopErrorMessage("Member::Signature()", "not initialized object.");
        return;
    }

    char* type = declarator->GetEncodedType();
    if(type == nil)
        t.Unknown();
    else
        t.Set(type, metaobject->GetEnvironment());
}

Ptree* Member::Name()
{
    int len;
    char* name = Name(len);
    return Encoding::NameToPtree(name, len);
}

char* Member::Name(int& len)
{
    if(declarator == nil){
        MopErrorMessage("Member::Name()", "not initialized object.");
        return nil;
    }

    char* name = declarator->GetEncodedName();
    if(name != nil){
        Environment* e = metaobject->GetEnvironment();
        name = Encoding::GetBaseName(name, len, e);
    }

    return name;
}

Ptree* Member::Comments()
{
    if(declarator == nil){
        MopErrorMessage("Member::Comments()", "not initialized object.");
        return nil;
    }

    if (declarator->IsA(ntDeclarator))
        return ((PtreeDeclarator*)declarator)->GetComments();
    else
        return nil;
}

int Member::Nth()
{
    if(Find())
        return nth;
    else
        return -1;
}

Class* Member::Supplier()
{
    if(Find())
        return metaobject->GetMemberList()->Ref(nth)->supplying;
    else
        return nil;
}

bool Member::IsConstructor()
{
    if(declarator == nil){
        MopErrorMessage("Member::IsConstructor()", "not initialized object.");
        return FALSE;
    }

    char* name = declarator->GetEncodedName();
    if(name != nil){
        int len;
        Environment* e = metaobject->GetEnvironment();
        name = Encoding::GetBaseName(name, len, e);
        if(name != nil) {
            Class* sup = Supplier();
            if (sup != nil)
                return sup->Name()->Eq(name, len);
        }
    }

    return FALSE;
}

bool Member::IsDestructor()
{
    if(declarator == nil){
        MopErrorMessage("Member::IsDestructor()", "not initialized object.");
        return FALSE;
    }

    char* name = declarator->GetEncodedName();
    if(name != nil){
        int len;
        Environment* e = metaobject->GetEnvironment();
        name = Encoding::GetBaseName(name, len, e);
        if(name != nil)
            return bool(*name == '~');
    }

    return FALSE;
}

bool Member::IsFunction()
{
    TypeInfo t;
    Signature(t);
    return t.IsFunction();
}

bool Member::IsPublic()
{
    if(Find())
        return bool(metaobject->GetMemberList()->Ref(nth)->access
                    == PUBLIC);
    else
        return FALSE;
}

bool Member::IsProtected()
{
    if(Find())
        return bool(metaobject->GetMemberList()->Ref(nth)->access
                    == PROTECTED);
    else
        return FALSE;
}

bool Member::IsPrivate()
{
    if(Find())
        return bool(metaobject->GetMemberList()->Ref(nth)->access
                    == PRIVATE);
    else
        return FALSE;
}

bool Member::IsStatic()
{
    if(Find())
        return metaobject->GetMemberList()->Ref(nth)->is_static;
    else
        return FALSE;
}

bool Member::IsMutable()
{
    if(Find())
        return metaobject->GetMemberList()->Ref(nth)->is_mutable;
    else
        return FALSE;
}

bool Member::IsInline()
{
    if(Find() && metaobject->GetMemberList()->Ref(nth)->is_inline)
        return TRUE;

    if(IsFunctionImplementation())
        return IsInlineFuncImpl();
    else
        return FALSE;
}

bool Member::IsInlineFuncImpl()
{
    Ptree* header = implementation->Car();
    while(header != nil){
        Ptree* h = header->Car();
        if(h->IsA(INLINE))
            return TRUE;

        header = header->Cdr();
    }

    return FALSE;
}

bool Member::IsVirtual()
{
    if(Find())
        return metaobject->GetMemberList()->Ref(nth)->is_virtual;
    else
        return FALSE;
}

bool Member::IsPureVirtual()
{
    if(IsFunction())
        return declarator->Last()->Car()->Eq('0');
    else
        return FALSE;
}

Ptree* Member::GetUserAccessSpecifier()
{
    if(Find())
        return metaobject->GetMemberList()->Ref(nth)->user_access;
    else
        return nil;
}

bool Member::GetUserArgumentModifiers(PtreeArray& mods)
{
    Ptree* args;

    mods.Clear();
    if(!Find())
        return FALSE;

    if(!Walker::GetArgDeclList((PtreeDeclarator*)declarator, args))
        return FALSE;

    while(args != nil){
        Ptree* a = args->Car();
        if(!a->IsLeaf() && a->Car()->IsA(ntUserdefKeyword))
            mods.Append(a->Car());
        else
            mods.Append(nil);
        
        args = Ptree::ListTail(args, 2);        // skip ,
    }

    return TRUE;
}

Ptree* Member::GetUserMemberModifier()
{
    if(Find())
        return metaobject->GetMemberList()->Ref(nth)->user_mod;
    else
        return nil;
}

bool Member::Find()
{
    if(nth >= 0)
        return TRUE;
    else if(metaobject == nil || declarator == nil)
        return FALSE;

    MemberList* mlist = metaobject->GetMemberList();

    int len;
    char* name = Name(len);
    char* sig = declarator->GetEncodedType();
    if(mlist == nil || name == nil || sig == nil)
        return FALSE;

    nth = mlist->Lookup(name, len, sig);
    if(nth >= 0){
        MemberList::Mem* m = mlist->Ref(nth);
        metaobject = m->supplying;
        declarator = m->declarator;
        return TRUE;
    }
    else
        return FALSE;
}

void Member::SetQualifiedName(Ptree* name)
{
    new_name = name;
}

void Member::SetName(Ptree* name)
{
    if(IsFunctionImplementation())
        SetName(name, original_decl);
    else
        SetName(name, declarator);
}

void Member::SetName(Ptree* name, Ptree* decl)
{
    if(decl == nil){
        MopErrorMessage("Member::SetName()", "not initialized object.");
        return;
    }

    char* encoded = decl->GetEncodedName();
    if(encoded != nil && *encoded == 'Q'){
        Ptree* qname = ((PtreeDeclarator*)decl)->Name();
        Ptree* old_name = qname->Last()->First();
        new_name = Ptree::ShallowSubst(name, old_name, qname);
    }
    else
        new_name = name;
}

Ptree* Member::ArgumentList()
{
    if(IsFunctionImplementation())
        return ArgumentList(original_decl);
    else
        return ArgumentList(declarator);
}

Ptree* Member::ArgumentList(Ptree* decl)
{
    Ptree* args;
    if(Walker::GetArgDeclList((PtreeDeclarator*)decl, args))
        return args;
    else
        return nil;
}

void Member::SetArgumentList(Ptree* args)
{
    new_args = args;
}

Ptree* Member::MemberInitializers()
{
    if(IsFunctionImplementation())
        return MemberInitializers(original_decl);
    else
        return MemberInitializers(declarator);
}

Ptree* Member::MemberInitializers(Ptree* decl)
{
    if(IsConstructor()){
        Ptree* init = decl->Last()->Car();
        if(!init->IsLeaf() && init->Car()->Eq(':'))
            return init;
    }

    return nil;
}

void Member::SetMemberInitializers(Ptree* init)
{
    new_init = init;
}

Ptree* Member::FunctionBody()
{
    if(IsFunctionImplementation())
        return implementation->Nth(3);
    else if(Find()){
        Ptree* def = metaobject->GetMemberList()->Ref(nth)->definition;
        Ptree* decls = def->Third();
        if(decls->IsA(ntDeclarator))
            return def->Nth(3);
    }

    return nil;
}

void Member::SetFunctionBody(Ptree* body)
{
    new_body = body;
}

Ptree* Member::Arguments()
{
    return Arguments(ArgumentList(), 0);
}

Ptree* Member::Arguments(Ptree* args, int i)
{
    Ptree* rest;

    if(args == nil)
        return args;

    if(args->Cdr() == nil)
        rest = nil;
    else{
        rest = Arguments(args->Cddr(), i + 1);  // skip ","
        rest = Ptree::Cons(args->Cadr(), rest);
    }

    Ptree* a = args->Car();
    Ptree* p;
    if(a->IsLeaf())
        p = a;
    else{
        if(a->Car()->IsA(ntUserdefKeyword, REGISTER))
            p = a->Third();
        else
            p = a->Second();

        p = ((PtreeDeclarator*)p)->Name();
    }

    if(p == nil){
        arg_name_filled = TRUE;
        p = Ptree::Make(Walker::argument_name, i);
    }

    return Ptree::Cons(p, rest);
}

void Member::Copy(Member* mem, void* ptr)
{
    ChangedMemberList::Cmem* cmem = (ChangedMemberList::Cmem*)ptr;
    ChangedMemberList::Copy(mem, cmem, Class::Undefined);
    if(mem->IsFunctionImplementation()){
        cmem->declarator = mem->original_decl;
        cmem->def = mem->implementation;
    }
}


// class MemberFunction

MemberFunction::MemberFunction(Class* c, Ptree* impl, Ptree* decl)
: Member(c, decl)
{
    implementation = impl;
    original_decl = decl;
}


// class MemberList

MemberList::MemberList()
{
    this_class = nil;
    num = 0;
    size = -1;
    array = nil;
}

MemberList::Mem* MemberList::Ref(int i)
{
    const int unit = 16;
    if(i >= size){
        int old_size = size;
        size = ((unsigned int)i + unit) & ~(unit - 1);
        Mem* a = new (GC) Mem[size];
        if(old_size > 0)
            memmove(a, array, old_size * sizeof(Mem));

        array = a;
    }

    return &array[i];
}

void MemberList::Make(Class* metaobject)
{
    this_class = metaobject;
    num = 0;

    AppendThisClass(metaobject);

    Environment* env = metaobject->GetEnvironment();
    Ptree* bases = metaobject->BaseClasses();
    while(bases != nil){
        bases = bases->Cdr();           // skip : or ,
        if(bases != nil){
            AppendBaseClass(env, bases->Car());
            bases = bases->Cdr();
        }
    }
}

void MemberList::AppendThisClass(Class* metaobject)
{
    int access = PRIVATE;
    Ptree* user_access = nil;
    Ptree* members = metaobject->Members();
    while(members != nil){
        Ptree* def = members->Car();
        if(def->IsA(ntDeclaration)){
            Ptree* decl;
            int nth = 0;
            do{
                int i = nth++;
                decl = Walker::NthDeclarator(def, i);
                if(decl != nil)
                    Append(def, decl, access, user_access);
            } while(decl != nil);
        }
        else if(def->IsA(ntAccessSpec)){
            access = def->Car()->What();
            user_access = nil;
        }
        else if(def->IsA(ntUserAccessSpec))
            user_access = def;
        else if(def->IsA(ntAccessDecl))
            /* not implemented */;

        members = members->Cdr();
    }
}

void MemberList::Append(Ptree* declaration, Ptree* decl,
                        int access, Ptree* user_access)
{
    int len;
    Mem mem;
    char* name = decl->GetEncodedName();
    char* signature = decl->GetEncodedType();
    Environment* e = this_class->GetEnvironment();
    name = Encoding::GetBaseName(name, len, e);

    CheckHeader(declaration, &mem);

    Mem* m = Ref(num++);
    m->supplying = this_class;
    m->definition = declaration;
    m->declarator = decl;
    m->name = name;
    m->signature = signature;
    m->is_constructor = bool(this_class->Name()->Eq(name, len));
    m->is_destructor = bool(*name == '~');
    m->is_virtual = mem.is_virtual;
    m->is_static = mem.is_static;
    m->is_mutable = mem.is_mutable;
    m->is_inline = mem.is_inline;
    m->user_mod = mem.user_mod;
    m->access = access;
    m->user_access = user_access;
}

void MemberList::AppendBaseClass(Environment* env, Ptree* base_class)
{
    int access = PRIVATE;
    while(base_class->Cdr() != nil){
        Ptree* p = base_class->Car();
        if(p->IsA(PUBLIC, PROTECTED, PRIVATE))
            access = p->What();

        base_class = base_class->Cdr();
    }   

    Class* metaobject = env->LookupClassMetaobject(base_class->Car());
    if(metaobject == nil)
        return;

    MemberList* mlist = metaobject->GetMemberList();
    for(int i = 0; i < mlist->num; ++i){
        Mem* m = &mlist->array[i];
        Mem* m2 = Lookup(m->name, m->signature);
        if(m2 != nil){                          // overwrittten
            if(!m2->is_virtual)
                m2->is_virtual = m->is_virtual;
        }
        else if(m->access != PRIVATE){          // inherited
            m2 = Ref(num++);
            *m2 = *m;
            if(access == PRIVATE)
                m2->access = PRIVATE;
            else if(access == PROTECTED)
                m2->access = PROTECTED;
        }
    }
}

MemberList::Mem* MemberList::Lookup(char* name, char* signature)
{
    for(int i = 0; i < num; ++i){
        Mem* m = Ref(i);
        if(strcmp(m->name, name) == 0 && strcmp(m->signature, signature) == 0)
            return m;
    }

    return nil;
}

int MemberList::Lookup(char* name, int len, char* signature)
{
    for(int i = 0; i < num; ++i){
        Mem* m = Ref(i);
        if(strcmp(m->signature, signature) == 0
           && strncmp(m->name, name, len) == 0 && m->name[len] == '\0')
            return i;
    }

    return -1;
}

int MemberList::Lookup(Environment* env, Ptree* member, int index)
{
    char* name;
    int len;

    if(member == nil)
        return -1;
    else if(member->IsLeaf()){
        name = member->GetPosition();
        len = member->GetLength();
    }
    else
        name = Encoding::GetBaseName(member->GetEncodedName(), len, env);

    for(int i = 0; i < num; ++i){
        Mem* m = Ref(i);
        if(strncmp(m->name, name, len) == 0 && m->name[len] == '\0')
            if(index-- <= 0)
                return i;
    }

    return -1;
}

int MemberList::Lookup(Environment*, char* name, int index)
{
    if(name == nil)
        return -1;

    for(int i = 0; i < num; ++i){
        Mem* m = Ref(i);
        if(strcmp(m->name, name) == 0)
            if(index-- <= 0)
                return i;
    }

    return -1;
}

void MemberList::CheckHeader(Ptree* declaration, Mem* m)
{
    m->is_virtual = FALSE;
    m->is_static = FALSE;
    m->is_mutable = FALSE;
    m->is_inline = FALSE;
    m->user_mod = nil;

    Ptree* header = declaration->Car();
    while(header != nil){
        Ptree* h = header->Car();
        if(h->IsA(VIRTUAL))
            m->is_virtual = TRUE;
        else if(h->IsA(STATIC))
            m->is_static = TRUE;
        else if(h->IsA(MUTABLE))
            m->is_mutable = TRUE;
        else if(h->IsA(INLINE))
            m->is_inline = TRUE;
        else if(h->IsA(ntUserdefKeyword))
            m->user_mod = h;

        header = header->Cdr();
    }

    Ptree* d = declaration->Third();
    if(d != nil && d->IsA(ntDeclarator))
        m->is_inline = TRUE;
}

// class ChangedMemberList

ChangedMemberList::ChangedMemberList()
{
    num = 0;
    size = -1;
    array = nil;
}

void ChangedMemberList::Append(Member* m, int access)
{
    Cmem* mem = Ref(num++);
    Copy(m, mem, access);
}

void ChangedMemberList::Copy(Member* src, Cmem* dest, int access)
{
    dest->declarator = src->declarator;
    dest->removed = src->removed;
    dest->name = src->new_name;
    dest->args = src->new_args;
    dest->init = src->new_init;
    dest->body = src->new_body;
    dest->arg_name_filled = src->arg_name_filled;

    if(src->Find()){
        MemberList::Mem* m = src->metaobject->GetMemberList()->Ref(src->nth);
        dest->def = m->definition;
        if(access == Class::Undefined)
            dest->access = m->access;
        else
            dest->access = access;
    }
    else{
        dest->def = nil;
        if(access == Class::Undefined)
            dest->access = Class::Public;
        else
            dest->access = access;
    }
}

ChangedMemberList::Cmem* ChangedMemberList::Lookup(Ptree* decl)
{
    for(int i = 0; i < num; ++i){
        Cmem* m = Ref(i);
        if(m->declarator == decl)
            return m;
    }

    return nil;
}

ChangedMemberList::Cmem* ChangedMemberList::Get(int i)
{
    if(i >= num)
        return nil;
    else
        return Ref(i);
}

ChangedMemberList::Cmem* ChangedMemberList::Ref(int i)
{
    const int unit = 16;
    if(i >= size){
        int old_size = size;
        size = ((unsigned int)i + unit) & ~(unit - 1);
        Cmem* a = new (GC) Cmem[size];
        if(old_size > 0)
            memmove(a, array, old_size * sizeof(Cmem));

        array = a;
    }

    return &array[i];
}

---