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| #ifndef _mop_h
   16| #define _mop_h
   17| 
   18| #include <iosfwd>
   19| #include "types.h"
   20| #include "ptree-core.h"
   21| #include "env.h"
   22| #include "typeinfo.h"
   23| #include "member.h"
   24| 
   25| class ClassArray;
   26| class Member;
   27| class MemberList;
   28| class ChangedMemberList;
   29| struct ChangedMemberList::Cmem;
   30| 
   31| class OCXXMOP Class : public Object {
   32| public:
   33|     Class() {}
   34|     Class(Environment* e, char* name) { Construct(e, Ptree::Make(name)); }
   35|     Class(Environment* e, Ptree* name) { Construct(e, name); }
   36| 
   37|     virtual void InitializeInstance(Ptree* def, Ptree* margs);
   38|     virtual ~Class();
   39| 
   40| // introspection
   41| 
   42|     Ptree* Comments();
   43|     Ptree* Name();
   44|     Ptree* BaseClasses();
   45|     Ptree* Members();
   46|     Ptree* Definition() { return definition; }
   47|     virtual char* MetaclassName();      // automaticallly implemented
   48|                       // by Metaclass
   49|     Class* NthBaseClass(int nth);
   50|     Ptree* NthBaseClassName(int nth);
   51|     bool IsSubclassOf(Ptree* name);
   52|     bool IsImmediateSubclassOf(Ptree* name);
   53| 
   54|     bool NthMember(int nth, Member& member);
   55|     bool LookupMember(Ptree* name);
   56|     bool LookupMember(Ptree* name, Member& member, int index = 0);
   57|     bool LookupMember(char* name);
   58|     bool LookupMember(char* name, Member& member, int index = 0);
   59|     MemberList* GetMemberList();
   60| 
   61|     // These are available only within Finalize()
   62|     static ClassArray& AllClasses();
   63|     int Subclasses(ClassArray& subclasses);
   64|     static int Subclasses(Ptree* name, ClassArray& subclasses);
   65|     int ImmediateSubclasses(ClassArray& subclasses);
   66|     static int ImmediateSubclasses(Ptree* name, ClassArray& subclasses);
   67|     static int InstancesOf(char* metaclass_name, ClassArray& classes);
   68| 
   69|     // obsolete
   70|     Ptree* NthMemberName(int);
   71|     int IsMember(Ptree*);
   72|     bool LookupMemberType(Ptree*, TypeInfo&);
   73| 
   74| // translation
   75| 
   76|     // these must be consistent with PUBLIC, PRIVATE, PROTECTED in token.h
   77|     enum { Public = 298, Protected = 297, Private = 296, Undefined = 0 };
   78| 
   79|     virtual void TranslateClass(Environment*);
   80|     void RemoveClass() { removed = TRUE; }
   81|     void AddClassSpecifier(Ptree* spec);        // only for MSVC++
   82|     void ChangeName(Ptree* name);
   83|     void ChangeBaseClasses(Ptree*);
   84|     void RemoveBaseClasses();
   85|     void AppendBaseClass(Class* c, int specifier = Public,
   86|                        bool is_virtual = false);
   87|     void AppendBaseClass(char* class_name, int specifier = Public,
   88|                        bool is_virtual = false);
   89|     void AppendBaseClass(Ptree* class_name, int specifier = Public,
   90|                        bool is_virtual = false);
   91| 
   92|     void ChangeMember(Member& changed_member);
   93|     void AppendMember(Member& added_member, int specifier = Public);
   94|     void AppendMember(Ptree* added_member);
   95|     void RemoveMember(Member&);
   96| 
   97|     virtual void TranslateMemberFunction(Environment*, Member&);
   98| 
   99|     virtual Ptree* TranslateInitializer(Environment*, Ptree* var_name,
  100|                       Ptree* initializer);
  101| 
  102|     virtual Ptree* TranslateNew(Environment*,
  103|                              Ptree* header, Ptree* new_operator,
  104|                              Ptree* placement, Ptree* type_name,
  105|                       Ptree* arglist);
  106|     virtual Ptree* TranslateDelete(Environment*, Ptree* op, Ptree* obj);
  107|     virtual Ptree* TranslateAssign(Environment*, Ptree* left,
  108|                                 Ptree* assign_op, Ptree* right);
  109|     virtual Ptree* TranslateBinary(Environment*, Ptree* left,
  110|                                 Ptree* binary_op, Ptree* right);
  111|     virtual Ptree* TranslateUnary(Environment*,
  112|                                Ptree* unary_op, Ptree* object);
  113|     virtual Ptree* TranslateSubscript(Environment*,
  114|                                    Ptree* object, Ptree* index);
  115|     virtual Ptree* TranslatePostfix(Environment*,
  116|                                  Ptree* object, Ptree* postfix_op);
  117|     virtual Ptree* TranslateFunctionCall(Environment*,
  118|                                     Ptree* object, Ptree* arglist);
  119|     virtual Ptree* TranslateMemberCall(Environment*,
  120|                                     Ptree* object, Ptree* access_op,
  121|                              Ptree* member_name,
  122|                              Ptree* arglist);
  123|     virtual Ptree* TranslateMemberCall(Environment*,
  124|                                     Ptree* member_name, Ptree* arglist);
  125|     virtual Ptree* TranslateMemberRead(Environment*,
  126|                                     Ptree* object, Ptree* access_op,
  127|                              Ptree* member_name);
  128|     virtual Ptree* TranslateMemberRead(Environment*, Ptree* member_name);
  129|     virtual Ptree* TranslateMemberWrite(Environment*,
  130|                                     Ptree* object, Ptree* access_op,
  131|                       Ptree* member_name,
  132|                                     Ptree* assign_op, Ptree* expr);
  133|     virtual Ptree* TranslateMemberWrite(Environment*,
  134|                       Ptree* member_name,
  135|                                     Ptree* assign_op, Ptree* expr);
  136|     virtual Ptree* TranslateUnaryOnMember(Environment*, Ptree* unary_op,
  137|                                     Ptree* object, Ptree* access_op,
  138|                              Ptree* member_name);
  139|     virtual Ptree* TranslateUnaryOnMember(Environment*, Ptree* unary_op,
  140|                              Ptree* member_name);
  141|     virtual Ptree* TranslatePostfixOnMember(Environment*,
  142|                                     Ptree* object, Ptree* access_op,
  143|                              Ptree* member_name,
  144|                              Ptree* postfix_op);
  145|     virtual Ptree* TranslatePostfixOnMember(Environment*,
  146|                              Ptree* member_name,
  147|                              Ptree* postfix_op);
  148|     virtual Ptree* TranslatePointer(Environment*, Ptree* var_name);
  149| 
  150|     virtual Ptree* TranslateUserStatement(Environment*,
  151|                                     Ptree* object, Ptree* access_op,
  152|                                     Ptree* keyword, Ptree* rest);
  153|     virtual Ptree* TranslateStaticUserStatement(Environment*,
  154|                                     Ptree* keyword, Ptree* rest);
  155| 
  156|     static Ptree* StripClassQualifier(Ptree* qualified_name);
  157| 
  158|     Ptree* TranslateExpression(Environment*, Ptree* expr);
  159|     Ptree* TranslateExpression(Environment*, Ptree* expr, TypeInfo& type);
  160|     Ptree* TranslateStatement(Environment* env, Ptree* expr);   // obsolete
  161|     Ptree* TranslateNewType(Environment* env, Ptree* type);
  162|     Ptree* TranslateArguments(Environment*, Ptree* arglist);
  163|     Ptree* TranslateFunctionBody(Environment*, Member& m, Ptree* body);
  164| 
  165| // others
  166| 
  167|     Environment* GetEnvironment() { return class_environment; }
  168|     virtual bool AcceptTemplate();
  169|     static bool Initialize();
  170|     static void FinalizeAll(std::ostream& out);
  171|     virtual Ptree* FinalizeInstance();
  172|     virtual Ptree* Finalize();         // obsolete
  173|     static Ptree* FinalizeClass();
  174| 
  175|     static void RegisterNewModifier(char* keyword);
  176|     static void RegisterNewAccessSpecifier(char* keyword);
  177|     static void RegisterNewMemberModifier(char* keyword);
  178|     static void RegisterNewWhileStatement(char* keyword);
  179|     static void RegisterNewForStatement(char* keyword);
  180|     static void RegisterNewClosureStatement(char* keyword);
  181|     static void RegisterMetaclass(char* keyword, char* class_name);
  182| 
  183|     static void ChangeDefaultMetaclass(char* name);
  184|     static void SetMetaclassForFunctions(char* name);
  185| 
  186|     static void InsertBeforeStatement(Environment*, Ptree*);
  187|     static void AppendAfterStatement(Environment*, Ptree*);
  188|     static void InsertBeforeToplevel(Environment*, Class*);
  189|     static void InsertBeforeToplevel(Environment*, Member&);
  190|     static void InsertBeforeToplevel(Environment*, Ptree*);
  191|     static void AppendAfterToplevel(Environment*, Class*);
  192|     static void AppendAfterToplevel(Environment*, Member&);
  193|     static void AppendAfterToplevel(Environment*, Ptree*);
  194|     bool InsertDeclaration(Environment*, Ptree* declaration);
  195|     bool InsertDeclaration(Environment*, Ptree* declaration,
  196|                          Ptree* key, void* client_data);
  197|     void* LookupClientData(Environment*, Ptree* key);
  198| 
  199|     void ErrorMessage(Environment*, char* message, Ptree* name,
  200|                     Ptree* where);
  201|     void WarningMessage(Environment*, char* message, Ptree* name,
  202|                Ptree* where);
  203|     void ErrorMessage(char* message, Ptree* name, Ptree* where);
  204|     void WarningMessage(char* message, Ptree* name, Ptree* where);
  205| 
  206|     static bool RecordCmdLineOption(char* key, char* value);
  207|     static bool LookupCmdLineOption(char* key);
  208|     static bool LookupCmdLineOption(char* key, char*& value);
  209|     static void WarnObsoleteness(char*, char* = nil);
  210| 
  211|     static void do_init_static();
  212| 
  213| private:
  214|     void Construct(Environment*, Ptree*);
  215| 
  216|     void SetEnvironment(Environment*);
  217|     Ptree* GetClassSpecifier() { return new_class_specifier; }
  218|     Ptree* GetNewName() { return new_class_name; }
  219|     Ptree* GetBaseClasses() { return new_base_classes; }
  220|     ChangedMemberList::Cmem* GetChangedMember(Ptree*);
  221|     ChangedMemberList* GetAppendedMembers() { return appended_member_list; }
  222|     Ptree* GetAppendedCode() { return appended_code; }
  223|     void TranslateClassHasFinished() { done_decl_translation = TRUE; }
  224|     void CheckValidity(char*);
  225| 
  226| private:
  227|     Ptree* definition;
  228|     Ptree* full_definition;     // including a user keyword
  229|     Environment* class_environment;
  230|     MemberList* member_list;
  231| 
  232|     bool done_decl_translation;
  233|     bool removed;
  234|     ChangedMemberList* changed_member_list;
  235|     ChangedMemberList* appended_member_list;
  236|     Ptree* appended_code;
  237|     Ptree* new_base_classes;
  238|     Ptree* new_class_specifier;
  239|     Ptree* new_class_name;
  240| 
  241|     static ClassArray* class_list;
  242| 
  243|     enum { MaxOptions = 8 };
  244|     static int num_of_cmd_options;
  245|     static char* cmd_options[MaxOptions * 2];
  246| 
  247|     static char* metaclass_for_c_functions;
  248|     static Class* for_c_functions;
  249| 
  250|     static Ptree* class_t;
  251|     static Ptree* empty_block_t;
  252|     static Ptree* public_t;
  253|     static Ptree* protected_t;
  254|     static Ptree* private_t;
  255|     static Ptree* virtual_t;
  256|     static Ptree* colon_t;
  257|     static Ptree* comma_t;
  258|     static Ptree* semicolon_t;
  259| 
  260| friend class Walker;
  261| friend class ClassWalker;
  262| friend class ClassBodyWalker;
  263| friend class Member;
  264| };
  265| 
  266| class OCXXMOP TemplateClass : public Class {
  267| public:
  268|     void InitializeInstance(Ptree* def, Ptree* margs);
  269|     static bool Initialize();
  270|     char* MetaclassName();
  271| 
  272|     Ptree* TemplateDefinition() { return template_definition; }
  273|     Ptree* TemplateArguments();
  274|     bool AcceptTemplate();
  275|     virtual Ptree* TranslateInstantiation(Environment*, Ptree*);
  276| 
  277| private:
  278|     static Ptree* GetClassInTemplate(Ptree* def);
  279| 
  280|     Ptree* template_definition;
  281| };
  282| 
  283| class OCXXMOP ClassArray : public LightObject {
  284| public:
  285|     ClassArray(int = 16);
  286|     uint Number() { return num; }
  287|     Class*& operator [] (uint index) { return Ref(index); }
  288|     Class*& Ref(uint index);
  289|     void Append(Class*);
  290|     void Clear() { num = 0; }
  291| 
  292| private:
  293|     uint num, size;
  294|     Class** array;
  295| };
  296| 
  297| 
  298| // not documented class --- internal use only
  299| 
  300| typedef Class* (*opcxx_MetaclassCreator)(Ptree*, Ptree*);
  301| 
  302| class OCXXMOP opcxx_ListOfMetaclass {
  303| public:
  304|     opcxx_ListOfMetaclass(char*, opcxx_MetaclassCreator,
  305|                         bool (*)(), Ptree* (*)());
  306|     static Class* New(Ptree*, Ptree*, Ptree*);
  307|     static Class* New(char*, Ptree*, Ptree*);
  308|     static void FinalizeAll(std::ostream&);
  309|     static bool AlreadyRecorded(char*);
  310|     static bool AlreadyRecorded(Ptree*);
  311|     static void PrintAllMetaclasses();
  312| 
  313| private:
  314|     opcxx_ListOfMetaclass* next;
  315|     char* name;
  316|     opcxx_MetaclassCreator proc;
  317|     Ptree* (*finalizer)();      // pointer to FinalizeClass()
  318|     static opcxx_ListOfMetaclass* head;
  319| };
  320| 
  321| #endif /* _mop_h */