AS Autobinder: remove unused ASClassBinder; Rename ASClassBinderNew to ASClassBinder (#2799)

Source/Tools/BindingGenerator/ASClassBinderNew.cpp

@@ -1,1418 +0,0 @@
-//
-// Copyright (c) 2008-2020 the Urho3D project.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-
-#include "ASResult.h"
-#include "ASUtils.h"
-#include "Tuning.h"
-#include "Utils.h"
-#include "XmlAnalyzer.h"
-#include "XmlSourceData.h"
-
-#include <cassert>
-#include <fstream>
-#include <iostream>
-#include <regex>
-#include <vector>
-#include <unordered_map>
-#include <unordered_set>
-
-namespace ASBindingGenerator
-{
-
-static void RegisterObjectType(const ClassAnalyzer& classAnalyzer, ProcessedClass& inoutProcessedClass)
-{
-    string className = classAnalyzer.GetClassName();
-
-    if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-    {
-        inoutProcessedClass.objectTypeRegistration_ = "engine->RegisterObjectType(\"" + className + "\", 0, asOBJ_REF);";
-    }
-    else // Value type
-    {
-        string flags = "asOBJ_VALUE | asGetTypeTraits<" + className + ">()";
-
-        if (classAnalyzer.IsPod())
-        {
-            flags += " | asOBJ_POD";
-
-            if (classAnalyzer.AllFloats())
-                flags += " | asOBJ_APP_CLASS_ALLFLOATS";
-            else if (classAnalyzer.AllInts())
-                flags += " | asOBJ_APP_CLASS_ALLINTS";
-        }
-
-        inoutProcessedClass.objectTypeRegistration_ = "engine->RegisterObjectType(\"" + className + "\", sizeof(" + className + "), " + flags + ");";
-    }
-}
-
-static bool IsConstructorRequired(const ClassAnalyzer& classAnalyzer)
-{
-    if (classAnalyzer.IsRefCounted())
-        return false;
-
-    if (Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-        return false;
-
-    if (classAnalyzer.IsPod())
-        return false;
-
-    return true;
-}
-
-static bool IsDestructorRequired(const ClassAnalyzer& classAnalyzer)
-{
-    if (classAnalyzer.IsRefCounted())
-        return false;
-
-    if (Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-        return false;
-
-    if (classAnalyzer.IsPod())
-        return false;
-
-    return true;
-}
-
-// Iterate over overrided funcions
-static bool HaveMark(const MethodAnalyzer& methodAnalyzer, const string& mark)
-{
-    if (Contains(methodAnalyzer.GetComment(), mark))
-        return true;
-
-    shared_ptr<MethodAnalyzer> reimplements = methodAnalyzer.Reimplements();
-
-    if (!reimplements)
-        return false;
-
-    return HaveMark(*reimplements, mark);
-}
-
-static void RegisterConstructor(const MethodAnalyzer& methodAnalyzer, ProcessedClass& processedClass)
-{
-    ClassAnalyzer classAnalyzer = methodAnalyzer.GetClass();
-
-    if (classAnalyzer.IsAbstract())
-        return;
-
-    if (methodAnalyzer.IsDeleted())
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because deleted";
-        processedClass.unregisteredSpecialMethods_.push_back(regError);
-        return;
-    }
-
-    if (HaveMark(methodAnalyzer, "NO_BIND"))
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because have @nobind mark";
-        processedClass.unregisteredSpecialMethods_.push_back(regError);
-        return;
-    }
-
-    if (HaveMark(methodAnalyzer, "MANUAL_BIND"))
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because have @manualbind mark";
-        processedClass.unregisteredSpecialMethods_.push_back(regError);
-        return;
-    }
-
-    SpecialMethodRegistration result;
-    //result.name_ = methodAnalyzer.GetName();
-    result.comment_ = methodAnalyzer.GetDeclaration();
-    
-    string asClassName = classAnalyzer.GetClassName();
-    string cppClassName = classAnalyzer.GetClassName();
-    vector<ParamAnalyzer> params = methodAnalyzer.GetParams();
-
-    if (params.empty()) // Default constructor
-    {
-        if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-            result.registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_FACTORY, \"" + asClassName + "@+ f()\", asFUNCTION(ASCompatibleFactory<" + cppClassName + ">), AS_CALL_CDECL);";
-        else
-            result.registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_CONSTRUCT, \"void f()\", asFUNCTION(ASCompatibleConstructor<" + cppClassName + ">), AS_CALL_CDECL_OBJFIRST);";
-
-        result.comment_ = methodAnalyzer.GetLocation(); // Rewrite comment
-        processedClass.defaultConstructor_ = make_shared<SpecialMethodRegistration>(result);
-        return;
-    }
-
-
-    vector<ConvertedVariable> convertedParams;
-    for (const ParamAnalyzer& param : params)
-    {
-        ConvertedVariable convertedParam;
-
-        try
-        {
-            convertedParam = CppVariableToAS(param.GetType(), VariableUsage::FunctionParameter, param.GetDeclname(), param.GetDefval());
-        }
-        catch (const Exception& e)
-        {
-            MemberRegistrationError regError;
-            regError.name_ = methodAnalyzer.GetName();
-            regError.comment_ = methodAnalyzer.GetDeclaration();
-            regError.message_ = e.what();
-            processedClass.unregisteredSpecialMethods_.push_back(regError);
-            return;
-        }
-
-        convertedParams.push_back(convertedParam);
-    }
-
-    bool needWrapper = false;
-    for (const ConvertedVariable& convertedParam : convertedParams)
-    {
-        if (convertedParam.NeedWrapper())
-            needWrapper = true;
-    }
-
-    if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-    {
-        string asDeclaration = asClassName + "@+ f(" + JoinASDeclarations(convertedParams) + ")";
-        result.registration_ = result.registration_ =
-            "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_FACTORY, \"" + asDeclaration + "\", AS_FUNCTION("
-            + GenerateWrapperName(methodAnalyzer) + ") , AS_CALL_CDECL);";
-
-        result.glue_ = GenerateFactoryWrapper(methodAnalyzer, convertedParams);
-    }
-    else
-    {
-        string asDeclaration = "void f(" + JoinASDeclarations(convertedParams) + ")";
-        result.registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_CONSTRUCT, \"" + asDeclaration +
-            "\", AS_FUNCTION_OBJFIRST(" + GenerateWrapperName(methodAnalyzer) + "), AS_CALL_CDECL_OBJFIRST);";
-
-        result.glue_ = GenerateConstructorWrapper(methodAnalyzer, convertedParams);
-    }
-
-    processedClass.nonDefaultConstructors_.push_back(result);
-}
-
-static void RegisterDestructor(const ClassAnalyzer& classAnalyzer, ProcessedClass& processedClass)
-{
-    if (classAnalyzer.IsRefCounted())
-        return;
-
-    if (Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-        return;
-
-    string className = classAnalyzer.GetClassName();
-    string wrapperName = className + "_Destructor";
-
-    shared_ptr<SpecialMethodRegistration> result = make_shared<SpecialMethodRegistration>();
-
-    //result->name_ = "~" + className;
-
-    result->registration_ = "engine->RegisterObjectBehaviour(\"" + className + "\", asBEHAVE_DESTRUCT, \"void f()\", AS_DESTRUCTOR(" + className + "), AS_CALL_CDECL_OBJFIRST);";
-
-    shared_ptr<MethodAnalyzer> thisDestructor = classAnalyzer.GetDefinedThisDestructor();
-
-    if (thisDestructor)
-    {
-        result->comment_ = thisDestructor->GetDeclaration();
-        processedClass.destructor_ = result;
-    }
-    else if (!classAnalyzer.HasThisDestructor() && IsDestructorRequired(classAnalyzer))
-    {
-        result->comment_ = className + "::~" + className + "() | Implicitly-declared";
-        processedClass.destructor_ = result;
-    }
-}
-
-// https://www.angelcode.com/angelscript/sdk/docs/manual/doc_script_class_ops.html
-static string CppMethodNameToAS(const MethodAnalyzer& methodAnalyzer)
-{
-    string name = methodAnalyzer.GetName();
-
-    if (name == "operator=")
-        return "opAssign";
-
-    if (name == "operator+")
-        return "opAdd";
-
-    if (name == "operator-")
-    {
-        if (!methodAnalyzer.GetParams().size()) // If no params
-            return "opNeg";               // then unary minus
-        else
-            return "opSub";
-    }
-
-    if (name == "operator*")
-        return "opMul";
-
-    if (name == "operator/")
-        return "opDiv";
-
-    if (name == "operator+=")
-        return "opAddAssign";
-
-    if (name == "operator-=")
-        return "opSubAssign";
-
-    if (name == "operator*=")
-        return "opMulAssign";
-
-    if (name == "operator/=")
-        return "opDivAssign";
-
-    if (name == "operator==")
-        return "opEquals";
-
-    if (name == "operator[]")
-        return "opIndex";
-
-    // Conversion to another type operator
-    if (StartsWith(name, "operator "))
-    {
-        if (methodAnalyzer.IsExplicit())
-            return "opConv";
-        else
-            return "opImplConv";
-    }
-
-    if (name == "operator!=")
-        throw Exception("Only operator == is needed");
-
-    if (name == "operator<")
-        throw Exception("Registerd as opCmp separately");
-
-    if (name == "operator>")
-        throw Exception("Registerd as opCmp separately");
-
-    return name;
-}
-
-// https://www.angelcode.com/angelscript/sdk/docs/manual/doc_reg_objprop.html
-static string CppMethodNameToASProperty(const MethodAnalyzer& methodAnalyzer)
-{
-    string name = methodAnalyzer.GetName();
-
-    if (StartsWith(name, "Is") || StartsWith(name, "Get"))
-    {
-        string result = CutStart(name, "Is");
-        result = CutStart(result, "Get");
-        result = "get_" + FirstCharToLower(result);
-        return result;
-    }
-
-    if (StartsWith(name, "Set"))
-    {
-        string result = CutStart(name, "Set");
-        result = "set_" + FirstCharToLower(result);
-        return result;
-    }
-
-    if (methodAnalyzer.CanBeGetProperty())
-    {
-        string result = name;
-        result = "get_" + FirstCharToLower(result);
-        return result;
-    }
-
-    if (methodAnalyzer.CanBeSetProperty())
-    {
-        string result = name;
-        result = "set_" + FirstCharToLower(result);
-        return result;
-    }
-
-    throw Exception("Can not be property");
-}
-
-// Can return BIND_AS_ALIAS_xxxx or BIND_AS_PROPERTY
-// Return "" if no this marks
-static string GetPropertyMark(const MethodAnalyzer& methodAnalyzer)
-{
-    string comment = methodAnalyzer.GetComment();
-
-    smatch match;
-    regex_match(comment, match, regex(".*\\b(BIND_AS_ALIAS_.+?)\\b.*"));
-    if (match.size() == 2)
-        return match[1].str();
-
-    regex_match(comment, match, regex(".*\\bBIND_AS_PROPERTY\\b.*"));
-    if (match.size() == 1)
-        return "BIND_AS_PROPERTY";
-
-    shared_ptr<MethodAnalyzer> reimplements = methodAnalyzer.Reimplements();
-
-    if (!reimplements)
-        return "";
-
-    return GetPropertyMark(*reimplements);
-}
-
-static string GetSignature(const MethodAnalyzer& method)
-{
-    xml_node memberdef = method.GetMemberdef();
-
-    string result = string(memberdef.child_value("name")) + '|';
-    result += RemoveRefs(memberdef.child("type")) + '|';
-
-    for (xml_node param : memberdef.children("param"))
-        result += RemoveRefs(param.child("type")) + '|';
-
-    if (method.IsStatic())
-        result += "static" + result;
-
-    return result;
-}
-
-struct ClassMemeberSignatures
-{
-    unordered_set<string> methods_; // Signatures of all nonstatic public methods (including inherited)
-    unordered_map<string, vector<string>> hiddenInAnyDerivedClassesMethods_; // method signature -> derived class names
-    unordered_map<string, vector<string>> existsInBaseClassesMethods_; // method signature -> base class names
-};
-
-static unordered_map<string, shared_ptr<ClassMemeberSignatures>> _cachedMemberSignatures; // className -> signatures
-
-static bool ContainsSameSignature(const string& className, const string& methodSignature)
-{
-    shared_ptr<ClassMemeberSignatures> classData = _cachedMemberSignatures[className];
-    return classData->methods_.find(methodSignature) != classData->methods_.end();
-}
-
-static void InitCachedMemberSignatures()
-{ 
-    // Fill signatures
-    for (auto element : SourceData::classesByID_)
-    {
-        xml_node compounddef = element.second;
-        ClassAnalyzer classAnalyzer(compounddef);
-        shared_ptr<ClassMemeberSignatures> classData = make_shared<ClassMemeberSignatures>();
-        vector<MethodAnalyzer> methods = classAnalyzer.GetAllPublicMethods();
-        for (const MethodAnalyzer& method : methods)
-            classData->methods_.insert(GetSignature(method));
-        _cachedMemberSignatures[classAnalyzer.GetClassName()] = classData;
-    }
-
-    // Fill hidden in any derived classes members
-    for (auto element : SourceData::classesByID_)
-    {
-        xml_node compounddef = element.second;
-        ClassAnalyzer classAnalyzer(compounddef);
-        string className = classAnalyzer.GetClassName();
-        shared_ptr<ClassMemeberSignatures> classData = _cachedMemberSignatures[classAnalyzer.GetClassName()];
-        vector<MethodAnalyzer> methods = classAnalyzer.GetAllPublicMethods();
-        vector<ClassAnalyzer> allDerivedClasses = classAnalyzer.GetAllDerivedClasses();
-        vector<ClassAnalyzer> baseClasses = classAnalyzer.GetBaseClasses();
-        for (const MethodAnalyzer& method : methods)
-        {
-            string methodSignature = GetSignature(method);
-
-            vector<string> hiddenInderivedClasses;
-            
-            for (const ClassAnalyzer& derivedClass : allDerivedClasses)
-            {
-                string derivedClassName = derivedClass.GetClassName();
-                if (!ContainsSameSignature(derivedClassName, methodSignature))
-                    hiddenInderivedClasses.push_back(derivedClassName);
-            }
-
-            if (hiddenInderivedClasses.size())
-                classData->hiddenInAnyDerivedClassesMethods_[methodSignature] = hiddenInderivedClasses;
-
-            vector<string> existInBaseClasses;
-
-            for (const ClassAnalyzer& baseClass : baseClasses)
-            {
-                string baseClassName = baseClass.GetClassName();
-                if (ContainsSameSignature(baseClassName, methodSignature))
-                    existInBaseClasses.push_back(baseClassName);
-            }
-
-            if (existInBaseClasses.size())
-                classData->existsInBaseClassesMethods_[methodSignature] = existInBaseClasses;
-        }
-    }
-
-
-}
-
-/*static bool ContainsSameSignature(const ClassAnalyzer& classAnalyzer, const MethodAnalyzer& method)
-{
-    vector<MethodAnalyzer> methods = classAnalyzer.GetAllPublicMethods();
-    
-    for (const MethodAnalyzer& m : methods)
-    {
-        if (GetSignature(m) == GetSignature(method))
-            return true;
-    }
-
-    return false;
-}*/
-
-
-
-static vector<string> HiddenInAnyDerivedClasses(const MethodAnalyzer& method)
-{
-    /*vector<string> result;
-
-    vector<ClassAnalyzer> derivedClasses = method.GetClass().GetAllDerivedClasses();
-    for (const ClassAnalyzer& derivedClass : derivedClasses)
-    {
-        //if (!ContainsSameSignature(derivedClass, method))
-        //    result.push_back(derivedClass.GetClassName());
-
-        if (!ContainsSameSignature(derivedClass.GetClassName(), GetSignature(method)))
-            result.push_back(derivedClass.GetClassName());
-    }
-
-    return result;*/
-    string classname = method.GetClassName();
-    string methodSignature = GetSignature(method);
-    shared_ptr<ClassMemeberSignatures> classData = _cachedMemberSignatures[classname];
-
-    auto it = classData->hiddenInAnyDerivedClassesMethods_.find(methodSignature);
-    if (it == classData->hiddenInAnyDerivedClassesMethods_.end())
-        return vector<string>();
-    else
-        return it->second;
-}
-
-static vector<string> HiddenInAnyDerivedClasses(const MethodAnalyzer& method, const ClassAnalyzer& classAnalyzer)
-{
-    /*vector<string> result;
-
-    vector<ClassAnalyzer> derivedClasses = classAnalyzer.GetAllDerivedClasses();
-    for (const ClassAnalyzer& derivedClass : derivedClasses)
-    {
-        //if (!ContainsSameSignature(derivedClass, method))
-        //    result.push_back(derivedClass.GetClassName());
-        if (!ContainsSameSignature(derivedClass.GetClassName(), GetSignature(method)))
-            result.push_back(derivedClass.GetClassName());
-    }
-
-    return result;*/
-
-    string classname = classAnalyzer.GetClassName();
-    string methodSignature = GetSignature(method);
-    shared_ptr<ClassMemeberSignatures> classData = _cachedMemberSignatures[classname];
-
-    auto it = classData->hiddenInAnyDerivedClassesMethods_.find(methodSignature);
-    if (it == classData->hiddenInAnyDerivedClassesMethods_.end())
-        return vector<string>();
-    else
-        return it->second;
-}
-
-static vector<string> ExistsInBaseClasses(const MethodAnalyzer& method)
-{
-    /*vector<string> result;
-
-    vector<ClassAnalyzer> baseClasses = method.GetClass().GetBaseClasses();
-    string methodSignature = GetSignature(method);
-    for (const ClassAnalyzer& baseClass : baseClasses)
-    {
-        //if (ContainsSameSignature(baseClass, method))
-        //    result.push_back(baseClass.GetClassName());
-        if (ContainsSameSignature(baseClass.GetClassName(), methodSignature))
-            result.push_back(baseClass.GetClassName());
-    }
-
-    return result;*/
-
-    string classname = method.GetClassName();
-    string methodSignature = GetSignature(method);
-    shared_ptr<ClassMemeberSignatures> classData = _cachedMemberSignatures[classname];
-    
-    auto it = classData->existsInBaseClassesMethods_.find(methodSignature);
-    if (it == classData->existsInBaseClassesMethods_.end())
-        return vector<string>();
-    else
-        return it->second;
-}
-
-static vector<string> ExistsInBaseClasses(const MethodAnalyzer& method, const ClassAnalyzer& classAnalyzer)
-{
-    /*vector<string> result;
-
-    vector<ClassAnalyzer> baseClasses = classAnalyzer.GetBaseClasses();
-    string methodSignature = GetSignature(method);
-    for (const ClassAnalyzer& baseClass : baseClasses)
-    {
-        //if (ContainsSameSignature(baseClass, method))
-        //    result.push_back(baseClass.GetClassName());
-        if (ContainsSameSignature(baseClass.GetClassName(), methodSignature))
-            result.push_back(baseClass.GetClassName());
-    }
-
-    return result;*/
-
-    string classname = classAnalyzer.GetClassName();
-    string methodSignature = GetSignature(method);
-    shared_ptr<ClassMemeberSignatures> classData = _cachedMemberSignatures[classname];
-
-    auto it = classData->existsInBaseClassesMethods_.find(methodSignature);
-    if (it == classData->existsInBaseClassesMethods_.end())
-        return vector<string>();
-    else
-        return it->second;
-}
-
-// Returns names of derived class that has base classes with the same method signature
-// (multiple inheriance methods with same signature - we can not register this in template because this cause multiple registration same signature)
-static string FindConflicts(const MethodAnalyzer& method)
-{
-    vector<ClassAnalyzer> derivedClasses = method.GetClass().GetAllDerivedClasses();
-    for (const ClassAnalyzer& derivedClass : derivedClasses)
-    {
-        vector<string> existsInBaseClasses = ExistsInBaseClasses(method, derivedClass);
-
-        if (existsInBaseClasses.size() > 1)
-            return derivedClass.GetClassName(); // Conflict found
-    }
-
-    return string(); // No conflicts
-}
-
-static string FindConflicts(const MethodAnalyzer& method, const ClassAnalyzer& classAnalyzer)
-{
-    vector<ClassAnalyzer> derivedClasses = classAnalyzer.GetAllDerivedClasses();
-    for (const ClassAnalyzer& derivedClass : derivedClasses)
-    {
-        vector<string> existsInBaseClasses = ExistsInBaseClasses(method, derivedClass);
-
-        if (existsInBaseClasses.size() > 1)
-            return derivedClass.GetClassName(); // Conflict found
-    }
-
-    return string(); // No conflicts
-}
-
-
-static void RegisterMethod(const MethodAnalyzer& methodAnalyzer, ProcessedClass& processedClass)
-{
-    if (methodAnalyzer.IsDefine())
-        return;
-
-    // TEST
-
-    if (methodAnalyzer.GetClassName() == "Component" && methodAnalyzer.GetName() == "DrawDebugGeometry")
-        int ddd = 1;
-
-    // TEST END
-
-    // TODO: This functions take 99% of generation time. Need some cache?
-    // ===============================================
-
-    vector<string> existsInBaseClasses = ExistsInBaseClasses(methodAnalyzer);
-
-
-    if (existsInBaseClasses.size() == 1)
-    {
-        shared_ptr<ClassAnalyzer> baseClass = FindClassByName(existsInBaseClasses[0]);
-        if (HiddenInAnyDerivedClasses(methodAnalyzer, *baseClass).empty() && FindConflicts(methodAnalyzer, *baseClass).empty())
-            return; // Already registered in template of base class
-    }
-
-    bool regInTemplate = true;
-
-    vector<string> hiddenInDerivedClasses = HiddenInAnyDerivedClasses(methodAnalyzer);
-
-    if (!hiddenInDerivedClasses.empty())
-    {
-        if (methodAnalyzer.IsThisMethod())
-        {
-            MemberRegistrationError msg;
-            msg.name_ = methodAnalyzer.GetName();
-            msg.comment_ = methodAnalyzer.GetDeclaration();
-            msg.message_ = "Can not be registered here bacause hidden in derived classes: " + Join(hiddenInDerivedClasses, ", ");
-            processedClass.unregisteredTemplateMethods_.push_back(msg);
-        }
-
-        regInTemplate = false; // Impossible register in template
-    }
-
-    if (regInTemplate) // Additional check
-    {
-
-        string conflict = FindConflicts(methodAnalyzer);
-
-        if (!conflict.empty())
-            regInTemplate = false; // Impossible register in tempalte
-    }
-
-    // ====================================================
-    // END
-
-    if (methodAnalyzer.IsTemplate())
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because template";
-
-        if (regInTemplate)
-            processedClass.unregisteredTemplateStaticMethods_.push_back(regError);
-        else
-            processedClass.unregisteredPersonalStaticMethods_.push_back(regError);
-        return;
-    }
-
-    if (methodAnalyzer.IsDeleted())
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because deleted";
-        if (regInTemplate)
-            processedClass.unregisteredTemplateStaticMethods_.push_back(regError);
-        else
-            processedClass.unregisteredPersonalStaticMethods_.push_back(regError);
-
-        return;
-    }
-
-    if (methodAnalyzer.IsStatic())
-    {
-        if (HaveMark(methodAnalyzer, "NO_BIND"))
-        {
-            MemberRegistrationError regError;
-            regError.name_ = methodAnalyzer.GetName();
-            regError.comment_ = methodAnalyzer.GetDeclaration();
-            regError.message_ = "Not registered because have @nobind mark";
-            if (regInTemplate)
-                processedClass.unregisteredTemplateStaticMethods_.push_back(regError);
-            else
-                processedClass.unregisteredPersonalStaticMethods_.push_back(regError);
-
-            return;
-        }
-
-        if (HaveMark(methodAnalyzer, "MANUAL_BIND"))
-        {
-            MemberRegistrationError regError;
-            regError.name_ = methodAnalyzer.GetName();
-            regError.comment_ = methodAnalyzer.GetDeclaration();
-            regError.message_ = "Not registered because have @manualbind mark";
-            if (regInTemplate)
-                processedClass.unregisteredTemplateStaticMethods_.push_back(regError);
-            else
-                processedClass.unregisteredPersonalStaticMethods_.push_back(regError);
-
-            return;
-        }
-
-        ClassStaticFunctionAnalyzer staticMethodAnalyzer(methodAnalyzer.GetClass(), methodAnalyzer.GetMemberdef());
-
-        vector<ParamAnalyzer> params = staticMethodAnalyzer.GetParams();
-        vector<ConvertedVariable> convertedParams;
-        string outGlue;
-        bool needWrapper = false;
-
-        for (const ParamAnalyzer& param : params)
-        {
-            ConvertedVariable conv;
-            try
-            {
-                conv = CppVariableToAS(param.GetType(), VariableUsage::FunctionParameter, param.GetDeclname(), param.GetDefval());
-            }
-            catch (const Exception& e)
-            {
-                MemberRegistrationError regError;
-                regError.name_ = staticMethodAnalyzer.GetName();
-                regError.comment_ = methodAnalyzer.GetDeclaration();
-                regError.message_ = e.what();
-                if (regInTemplate)
-                    processedClass.unregisteredTemplateStaticMethods_.push_back(regError);
-                else
-                    processedClass.unregisteredPersonalStaticMethods_.push_back(regError);
-
-                return;
-            }
-
-            if (conv.NeedWrapper())
-                needWrapper = true;
-
-            convertedParams.push_back(conv);
-        }
-
-        ConvertedVariable convertedReturn;
-
-        try
-        {
-            convertedReturn = CppVariableToAS(staticMethodAnalyzer.GetReturnType(), VariableUsage::FunctionReturn);
-        }
-        catch (const Exception& e)
-        {
-            MemberRegistrationError regError;
-            regError.name_ = staticMethodAnalyzer.GetName();
-            regError.comment_ = methodAnalyzer.GetDeclaration();
-            regError.message_ = e.what();
-            if (regInTemplate)
-                processedClass.unregisteredTemplateStaticMethods_.push_back(regError);
-            else
-                processedClass.unregisteredPersonalStaticMethods_.push_back(regError);
-
-            return;
-        }
-
-        if (convertedReturn.NeedWrapper())
-            needWrapper = true;
-
-
-        Registration result;
-        result.comment_ = methodAnalyzer.GetDeclaration();
-
-        string funcPointer;
-        string callConv = "AS_CALL_CDECL";
-
-        string asFunctionName = staticMethodAnalyzer.GetName();
-        string cppClassName = methodAnalyzer.GetClass().GetClassName();
-        string className = staticMethodAnalyzer.GetClassName();
-
-        if (needWrapper)
-        {
-            /*result.glue_ = GenerateWrapper(methodAnalyzer, false, convertedParams, retConv);
-            result.registration_.funcPointer_ = "AS_FUNCTION_OBJFIRST(" + GenerateWrapperName(methodAnalyzer) + ")";
-            result.registration_.callConv_ = "AS_CALL_CDECL_OBJFIRST";*/
-
-            result.glue_ = GenerateWrapper(staticMethodAnalyzer, regInTemplate, convertedParams, convertedReturn);
-            funcPointer = "AS_FUNCTION(" + GenerateWrapperName(staticMethodAnalyzer);
-            if (regInTemplate)
-                funcPointer += "<" + cppClassName + ">";
-            funcPointer += ")";
-        }
-        else
-        {
-            /*result.registration_.funcPointer_ = Generate_asMETHODPR(methodAnalyzer, regInTemplate);
-            result.registration_.callConv_ = "AS_CALL_THISCALL";*/
-
-            funcPointer = Generate_asFUNCTIONPR(staticMethodAnalyzer, regInTemplate);
-        }
-
-        string asClassName = cppClassName;
-
-        string decl = convertedReturn.asDeclaration_ + " " + asFunctionName + "(" + JoinASDeclarations(convertedParams) + ")";
-
-        if (regInTemplate)
-        {
-            result.registration_.push_back(
-                "engine->SetDefaultNamespace(className);"
-                "engine->RegisterGlobalFunction(\"" + decl + "\", " + funcPointer + ", " + callConv + ");"
-                "engine->SetDefaultNamespace(\"\");"
-            );
-        }
-        else
-        {
-            result.registration_.push_back(
-                "engine->SetDefaultNamespace(\"" + asClassName + "\");"
-                "engine->RegisterGlobalFunction(\"" + decl + "\", " + funcPointer + ", " + callConv + ");"
-                "engine->SetDefaultNamespace(\"\");"
-            );
-        }
-/*
-
-        StaticMethodRegistration result;
-        result.cppDeclaration_ = methodAnalyzer.GetDeclaration();
-        result.name_ = staticMethodAnalyzer.GetName();
-        result.registration_.asDeclarations_.push_back(decl);
-        result.registration_.callConv_ = "AS_CALL_CDECL";
-        
-        if (needWrapper)
-            result.registration_.funcPointer_ = "AS_FUNCTION(" + GenerateWrapperName(staticMethodAnalyzer) + ")";
-        else
-            result.registration_.funcPointer_ = Generate_asFUNCTIONPR(staticMethodAnalyzer);
-
-        if (needWrapper)
-            result.glue_ = GenerateWrapper(staticMethodAnalyzer, convertedParams, convertedReturn);
-
-        processedClass.staticMethods_.push_back(result);
-
-        */
-
-
-        if (regInTemplate)
-            processedClass.templateStaticMethods_.push_back(result);
-        else
-            processedClass.personalStaticMethods_.push_back(result);
-
-        return;
-    }
-
-    if (HaveMark(methodAnalyzer, "NO_BIND"))
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because have @nobind mark";
-        if (regInTemplate)
-            processedClass.unregisteredTemplateMethods_.push_back(regError);
-        else
-            processedClass.unregisteredPersonalMethods_.push_back(regError);
-        return;
-    }
-
-    if (HaveMark(methodAnalyzer, "MANUAL_BIND"))
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because have @manualbind mark";
-        if (regInTemplate)
-            processedClass.unregisteredTemplateMethods_.push_back(regError);
-        else
-            processedClass.unregisteredPersonalMethods_.push_back(regError);
-        return;
-    }
-
-    vector<ParamAnalyzer> params = methodAnalyzer.GetParams();
-    vector<ConvertedVariable> convertedParams;
-    bool needWrapper = false;
-
-    for (const ParamAnalyzer& param : params)
-    {
-        ConvertedVariable conv;
-
-        try
-        {
-            conv = CppVariableToAS(param.GetType(), VariableUsage::FunctionParameter, param.GetDeclname(), param.GetDefval());
-        }
-        catch (const Exception& e)
-        {
-            MemberRegistrationError regError;
-            regError.name_ = methodAnalyzer.GetName();
-            regError.comment_ = methodAnalyzer.GetDeclaration();
-            regError.message_ = e.what();
-            if (regInTemplate)
-                processedClass.unregisteredTemplateMethods_.push_back(regError);
-            else
-                processedClass.unregisteredPersonalMethods_.push_back(regError);
-
-            return;
-        }
-
-        convertedParams.push_back(conv);
-
-        if (conv.NeedWrapper())
-            needWrapper = true;
-    }
-
-    ConvertedVariable retConv;
-
-    try
-    {
-        retConv = CppVariableToAS(methodAnalyzer.GetReturnType(), VariableUsage::FunctionReturn);
-    }
-    catch (const Exception& e)
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = e.what();
-        if (regInTemplate)
-            processedClass.unregisteredTemplateMethods_.push_back(regError);
-        else
-            processedClass.unregisteredPersonalMethods_.push_back(regError);
-
-        return;
-    }
-
-    if (retConv.NeedWrapper())
-        needWrapper = true;
-
-    string asReturnType = retConv.asDeclaration_;
-
-    string asFunctionName = methodAnalyzer.GetName();
-    if (methodAnalyzer.IsConsversionOperator())
-        asReturnType = CutStart(asFunctionName, "operator ");
-    
-    try
-    {
-        asFunctionName = CppMethodNameToAS(methodAnalyzer);
-    }
-    catch (const Exception& e)
-    {
-        MemberRegistrationError regError;
-        regError.name_ = methodAnalyzer.GetName();
-        regError.comment_ = methodAnalyzer.GetDeclaration();
-        regError.message_ = e.what();
-        if (regInTemplate)
-            processedClass.unregisteredTemplateMethods_.push_back(regError);
-        else
-            processedClass.unregisteredPersonalMethods_.push_back(regError);
-
-        return;
-    }
-
-    string cppClassName = methodAnalyzer.GetClass().GetClassName();
-
-    /*MethodRegistration result;
-    result.name_ = methodAnalyzer.GetName();
-    result.cppDeclaration_ = ReplaceAll(methodAnalyzer.GetDeclaration(), "\"", "\\\"");*/
-
-    Registration result;
-    result.comment_ = methodAnalyzer.GetDeclaration();
-
-    string funcPointer;
-    string callConv;
-
-    //bool templateVersion = true;
-
-    if (needWrapper)
-    {
-        /*result.glue_ = GenerateWrapper(methodAnalyzer, false, convertedParams, retConv);
-        result.registration_.funcPointer_ = "AS_FUNCTION_OBJFIRST(" + GenerateWrapperName(methodAnalyzer) + ")";
-        result.registration_.callConv_ = "AS_CALL_CDECL_OBJFIRST";*/
-
-        result.glue_ = GenerateWrapper(methodAnalyzer, regInTemplate, convertedParams, retConv);
-        funcPointer = "AS_FUNCTION_OBJFIRST(" + GenerateWrapperName(methodAnalyzer, regInTemplate);
-        if (regInTemplate)
-            funcPointer += "<" + cppClassName + ">";
-        funcPointer += ")";
-
-        callConv = "AS_CALL_CDECL_OBJFIRST";
-    }
-    else
-    {
-        /*result.registration_.funcPointer_ = Generate_asMETHODPR(methodAnalyzer, regInTemplate);
-        result.registration_.callConv_ = "AS_CALL_THISCALL";*/
-
-        funcPointer = Generate_asMETHODPR(methodAnalyzer, regInTemplate);
-        callConv = "AS_CALL_THISCALL";
-    }
-
-    string decl = asReturnType + " " + asFunctionName + "(" + JoinASDeclarations(convertedParams) + ")";
-
-    if (methodAnalyzer.IsConst())
-        decl += " const";
-
-    string asClassName = cppClassName;
-
-    //result.registration_.asDeclarations_.push_back(decl);
-
-  if (regInTemplate)
-      result.registration_.push_back("engine->RegisterObjectMethod(className, \"" + decl + "\", " + funcPointer + ", " + callConv + ");");
-  else
-      result.registration_.push_back("engine->RegisterObjectMethod(\"" + asClassName + "\", \"" + decl + "\", " + funcPointer + ", " + callConv + ");");
-
-    // Also register as property if needed
-    string propertyMark = GetPropertyMark(methodAnalyzer);
-    if (!propertyMark.empty())
-    {
-        if (StartsWith(propertyMark, "BIND_AS_ALIAS_"))
-        {
-            asFunctionName = CutStart(propertyMark, "BIND_AS_ALIAS_");
-        }
-        else
-        {
-            try
-            {
-                asFunctionName = CppMethodNameToASProperty(methodAnalyzer);
-            }
-            catch (const Exception& e)
-            {
-                MemberRegistrationError regError;
-                regError.name_ = methodAnalyzer.GetName();
-                regError.comment_ = methodAnalyzer.GetDeclaration();
-                regError.message_ = e.what();
-                if (regInTemplate)
-                    processedClass.unregisteredTemplateMethods_.push_back(regError);
-                else
-                    processedClass.unregisteredPersonalMethods_.push_back(regError);
-
-                return;
-            }
-        }
-
-        decl = asReturnType + " " + asFunctionName + "(" + JoinASDeclarations(convertedParams) + ")";
-
-        if (methodAnalyzer.IsConst())
-            decl += " const";
-
-        //result.registration_.asDeclarations_.push_back(decl);
-
-        if (regInTemplate)
-            result.registration_.push_back("engine->RegisterObjectMethod(className, \"" + decl + "\", " + funcPointer + ", " + callConv + ");");
-        else
-            result.registration_.push_back("engine->RegisterObjectMethod(\"" + asClassName + "\", \"" + decl + "\", " + funcPointer + ", " + callConv + ");");
-
-        //result.registration_.push_back("engine->RegisterObjectMethod(className, \"" + decl + "\", " + funcPointer + ", " + callConv + ");");
-    }
-
-    //processedClass.methods_.push_back(result);
-
-    if (regInTemplate)
-        processedClass.templateMethods_.push_back(result);
-    else
-        processedClass.personalMethods_.push_back(result);
-}
-
-static void RegisterField(const FieldAnalyzer& fieldAnalyzer, ProcessedClass& processedClass)
-{
-    if (Contains(fieldAnalyzer.GetComment(), "NO_BIND"))
-    {
-        MemberRegistrationError regError;
-        regError.name_ = fieldAnalyzer.GetName();
-        regError.comment_ = fieldAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because have @nobind mark";
-        processedClass.unregisteredTemplateFields_.push_back(regError);
-        return;
-    }
-
-    if (Contains(fieldAnalyzer.GetComment(), "MANUAL_BIND"))
-    {
-        MemberRegistrationError regError;
-        regError.name_ = fieldAnalyzer.GetName();
-        regError.comment_ = fieldAnalyzer.GetDeclaration();
-        regError.message_ = "Not registered because have @manualbind mark";
-        processedClass.unregisteredTemplateFields_.push_back(regError);
-        return;
-    }
-
-    if (fieldAnalyzer.IsStatic())
-    {
-        string asType;
-
-        try
-        {
-            asType = CppTypeToAS(fieldAnalyzer.GetType(), TypeUsage::StaticField);
-        }
-        catch (const Exception& e)
-        {
-            MemberRegistrationError regError;
-            regError.name_ = fieldAnalyzer.GetName();
-            regError.comment_ = fieldAnalyzer.GetDeclaration();
-            regError.message_ = e.what();
-            processedClass.unregisteredTemplateStaticFields_.push_back(regError);
-            return;
-        }
-
-        if (fieldAnalyzer.GetType().IsConst())
-            asType = "const " + asType;
-
-        asType = ReplaceAll(asType, "struct ", "");
-
-        string cppClassName = fieldAnalyzer.GetClassName();
-        string asPropertyName = fieldAnalyzer.GetName();
-
-        /*StaticFieldRegistration result;
-        result.cppDeclaration_ = fieldAnalyzer.GetDeclaration();
-        result.name_ = fieldAnalyzer.GetName();
-        result.registration_.asDeclarations_.push_back(asType + " " + asPropertyName);
-        result.registration_.pointer_ = "(void*)&" + cppClassName + "::" + fieldAnalyzer.GetName();
-
-        processedClass.staticFields_.push_back(result);
-        */
-
-        Registration reg;
-        reg.comment_ = fieldAnalyzer.GetDeclaration();
-        reg.registration_.push_back(
-            "engine->SetDefaultNamespace(className);"
-            "engine->RegisterGlobalProperty(\"" + asType + " " + asPropertyName + "\", " + "(void*)&T::" + fieldAnalyzer.GetName() + ");"
-            "engine->SetDefaultNamespace(\"\");");
-
-        processedClass.templateStaticFields_.push_back(reg);
-    }
-    else
-    {
-        if (fieldAnalyzer.IsArray())
-        {
-            MemberRegistrationError regError;
-            regError.name_ = fieldAnalyzer.GetName();
-            regError.comment_ = fieldAnalyzer.GetDeclaration();
-            regError.message_ = "Not registered because array";
-            processedClass.unregisteredTemplateFields_.push_back(regError);
-            return;
-        }
-
-        if (fieldAnalyzer.GetType().IsPointer())
-        {
-            MemberRegistrationError regError;
-            regError.name_ = fieldAnalyzer.GetName();
-            regError.comment_ = fieldAnalyzer.GetDeclaration();
-            regError.message_ = "Not registered because pointer";
-            processedClass.unregisteredTemplateFields_.push_back(regError);
-            return;
-        }
-
-        string asPropertyType;
-
-        try
-        {
-            asPropertyType = CppTypeToAS(fieldAnalyzer.GetType(), TypeUsage::Field);
-        }
-        catch (const Exception& e)
-        {
-            MemberRegistrationError regError;
-            regError.name_ = fieldAnalyzer.GetName();
-            regError.comment_ = fieldAnalyzer.GetDeclaration();
-            regError.message_ = e.what();
-            processedClass.unregisteredTemplateFields_.push_back(regError);
-            return;
-        }
-
-        string cppFieldName = fieldAnalyzer.GetName();
-        assert(!cppFieldName.empty());
-        string asPropertyName = CutEnd(cppFieldName, "_");
-
-        string cppClassName = fieldAnalyzer.GetClassName();
-
-        /*FieldRegistration result;
-        result.name_ = cppFieldName;
-        result.cppDeclaration_ = fieldAnalyzer.GetDeclaration();
-        result.registration_.asDeclarations_.push_back(asPropertyType + " " + asPropertyName);
-        result.registration_.byteOffset_ = "offsetof(" + cppClassName + ", " + cppFieldName + ")";*/
-
-        Registration reg;
-        reg.comment_ = fieldAnalyzer.GetDeclaration();
-        reg.registration_.push_back("engine->RegisterObjectProperty(className, \"" + asPropertyType + " " + asPropertyName + "\", "
-            "offsetof(T, " + cppFieldName + "));");
-
-        processedClass.templateFields_.push_back(reg);
-
-        //processedClass.fields_.push_back(result);
-    }
-}
-
-static void RegisterComparisonOperator(const ClassAnalyzer& classAnalyzer, ProcessedClass& processedClass)
-{
-    string className = classAnalyzer.GetClassName();
-    shared_ptr<MethodAnalyzer> methodAnalyzer = classAnalyzer.GetMethod("operator<");
-    assert(methodAnalyzer);
-    string wrapperName = GenerateWrapperName(*methodAnalyzer);
-
-    Registration result;
-    result.comment_ = methodAnalyzer->GetDeclaration();
-    
-    result.glue_ =
-        "template <class T> int " + wrapperName + "(const T& lhs, const T& rhs)\n"
-        "{\n"
-        "    if (lhs < rhs)\n"
-        "        return -1;\n\n"
-        "    if (lhs > rhs)\n"
-        "        return 1;\n\n"
-        "    return 0;\n"
-        "}\n";
-
-    //result.name_ = methodAnalyzer->GetName();
-    result.registration_.push_back(
-        "engine->RegisterObjectMethod(className, \"int opCmp(const " + className + "& in) const\", "
-        "AS_FUNCTION_OBJFIRST(" + wrapperName + "<T>), AS_CALL_CDECL_OBJFIRST);");
-
-    processedClass.templateMethods_.push_back(result);
-}
-
-static void TryRegisterImplicitlyDeclaredAssignOperator(const ClassAnalyzer& classAnalyzer, ProcessedClass& processedClass)
-{
-    string className = classAnalyzer.GetClassName();
-
-    processedClass.additionalLines_.push_back("    // " + className + "& " + className + "::operator =(const " + className + "&) | Possible implicitly-declared");
-    processedClass.additionalLines_.push_back("    RegisterImplicitlyDeclaredAssignOperatorIfPossible<" + className + ">(engine, \"" + className + "\");");
-}
-
-static void ProcessClass(const ClassAnalyzer& classAnalyzer)
-{
-    if (classAnalyzer.IsInternal())
-        return;
-
-    // TODO: Remove
-    if (classAnalyzer.IsTemplate())
-        return;
-
-    string header = classAnalyzer.GetHeaderFile();
-    Result::AddHeader(header);
-
-    if (IsIgnoredHeader(header))
-        return;
-
-    ProcessedClass processedClass;
-    processedClass.name_ = classAnalyzer.GetClassName();
-    processedClass.dirName_ = classAnalyzer.GetDirName();
-    processedClass.comment_ = classAnalyzer.GetLocation();
-    processedClass.insideDefine_ = InsideDefine(header);
-    processedClass.inherianceDeep_ = classAnalyzer.GetInherianceDeep();
-
-    //cout << processedClass.name_ << " DEEP: " << processedClass.inherianceDeep_;
-    cout << processedClass.name_ << "\n";
-
-    vector<MethodAnalyzer> methods = classAnalyzer.GetAllPublicMethods();
-    for (const MethodAnalyzer& method : methods)
-    {
-        if (method.IsStatic())
-            continue; // TODO remove hack
-
-        if (method.IsThisConstructor())
-            RegisterConstructor(method, processedClass);
-        else if (method.IsDestructor())
-            continue;
-        else if (method.IsConstructor())
-            continue;
-        else
-            RegisterMethod(method, processedClass);
-    }
-
-    // TODO отдельный класс для статических методов?
-    vector<MethodAnalyzer> staticMethods = classAnalyzer.GetThisPublicStaticMethods();
-    for (const MethodAnalyzer& staticMethod : staticMethods)
-    {
-        RegisterMethod(staticMethod, processedClass);
-    }
-
-    vector<FieldAnalyzer> fields = classAnalyzer.GetThisPublicFields();
-    for (const FieldAnalyzer& field : fields)
-        RegisterField(field, processedClass);
-
-    vector<FieldAnalyzer> staticFields = classAnalyzer.GetThisPublicStaticFields();
-    for (const FieldAnalyzer& staticField : staticFields)
-        RegisterField(staticField, processedClass);
-
-    vector<ClassAnalyzer> baseClasses = classAnalyzer.GetBaseClasses();
-    for (const ClassAnalyzer& baseClass : baseClasses)
-        processedClass.baseClassNames_.push_back(baseClass.GetClassName());
-
-    //processedClass.hiddenMethods_ = classAnalyzer.GetHiddenMethods();
-    /*processedClass.hiddenStaticMethods_ = classAnalyzer.GetHiddenStaticMethods();
-    processedClass.hiddenFields_ = classAnalyzer.GetHiddenFields();
-    processedClass.hiddenStaticFields_ = classAnalyzer.GetHiddenStaticFields();*/
-
-    if (classAnalyzer.IsAbstract() && !(classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF")))
-    {
-        processedClass.objectTypeRegistration_ = "// Not registered because value types can not be abstract";
-        processedClass.noBind_ = true;
-        Result::classes_.push_back(processedClass);
-        return;
-    }
-
-    string classComment = classAnalyzer.GetComment();
-
-    if (Contains(classComment, "NO_BIND"))
-    {
-        processedClass.objectTypeRegistration_ = "// Not registered because have @nobind mark";
-        processedClass.noBind_ = true;
-        Result::classes_.push_back(processedClass);
-        return;
-    }
-
-    if (Contains(classComment, "MANUAL_BIND"))
-    {
-        processedClass.objectTypeRegistration_ = "// Not registered because have @manualbind mark";
-        processedClass.noBind_ = true;
-        Result::classes_.push_back(processedClass);
-        return;
-    }
-
-    RegisterObjectType(classAnalyzer, processedClass);
-
-    if (Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-    {
-        string cppClassName = classAnalyzer.GetClassName();
-        string asClassName = classAnalyzer.GetClassName();
-        SpecialMethodRegistration fakeRef;
-        fakeRef.registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_ADDREF, \"void f()\", AS_FUNCTION_OBJLAST(FakeAddRef), AS_CALL_CDECL_OBJLAST);";
-        processedClass.fakeRefBehaviors_.push_back(fakeRef);
-
-        fakeRef.registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_RELEASE, \"void f()\", AS_FUNCTION_OBJLAST(FakeReleaseRef), AS_CALL_CDECL_OBJLAST);";
-        processedClass.fakeRefBehaviors_.push_back(fakeRef);
-    }
-
-    if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-    {
-        vector<ClassAnalyzer> baseClasses = classAnalyzer.GetAllBaseClasses();
-        for (ClassAnalyzer baseClass : baseClasses)
-        {
-            if (baseClass.IsRefCounted() || Contains(baseClass.GetComment(), "FAKE_REF"))
-            {
-                string cppBaseClassName = baseClass.GetClassName();
-                string asBaseClassName = cppBaseClassName;
-
-                string cppClassName = classAnalyzer.GetClassName();
-                string asClassName = classAnalyzer.GetClassName();
-
-                string reg = "RegisterSubclass<" + cppBaseClassName + ", " + cppClassName + ">(engine, \"" + asBaseClassName + "\", \"" + asClassName + "\");";
-                processedClass.subclassRegistrations_.push_back(reg);
-            }
-        }
-    }
-
-    // 2 operators is replaced by single function opCmp
-    if (classAnalyzer.ContainsMethod("operator>") || classAnalyzer.ContainsMethod("operator<"))
-        RegisterComparisonOperator(classAnalyzer, processedClass);
-
-    if (!classAnalyzer.ContainsMethod("operator="))
-        TryRegisterImplicitlyDeclaredAssignOperator(classAnalyzer, processedClass);
-
-    if (classAnalyzer.IsAbstract()) // Abstract refcounted type
-    {
-        Result::classes_.push_back(processedClass);
-        return;
-    }
-
-    if (!classAnalyzer.HasThisConstructor() && IsConstructorRequired(classAnalyzer))
-    {
-        shared_ptr<SpecialMethodRegistration> result = make_shared<SpecialMethodRegistration>();
-        string cppClassName = classAnalyzer.GetClassName();
-        string asClassName = classAnalyzer.GetClassName();
-
-        if (classAnalyzer.IsRefCounted() || Contains(classAnalyzer.GetComment(), "FAKE_REF"))
-            result->registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_FACTORY, \"" + asClassName + "@+ f()\", asFUNCTION(ASCompatibleFactory<" + cppClassName + ">), AS_CALL_CDECL);";
-        else
-            result->registration_ = "engine->RegisterObjectBehaviour(\"" + asClassName + "\", asBEHAVE_CONSTRUCT, \"void f()\", asFUNCTION(ASCompatibleConstructor<" + cppClassName + ">), AS_CALL_CDECL_OBJFIRST);";
-
-        result->comment_ = cppClassName + "::" + cppClassName + "() | Implicitly-declared";
-        processedClass.defaultConstructor_ = result;
-    }
-
-    RegisterDestructor(classAnalyzer, processedClass);
-
-    Result::classes_.push_back(processedClass);
-}
-
-void ProcessAllClassesNew()
-{
-#if 0
-    // Old order of classes for tests
-    vector<string> classIDs;
-    classIDs.reserve(SourceData::classesByID_.size());
-    for (pair<const string, xml_node>& it : SourceData::classesByID_)
-        classIDs.push_back(it.first);
-    sort(classIDs.begin(), classIDs.end());
-
-    for (string classID : classIDs)
-    {
-        xml_node compounddef = SourceData::classesByID_[classID];
-        ClassAnalyzer analyzer(compounddef);
-        ProcessClass(analyzer);
-    }
-#else
-    InitCachedMemberSignatures();
-
-    for (auto element : SourceData::classesByID_)
-    {
-        xml_node compounddef = element.second;
-        ClassAnalyzer analyzer(compounddef);
-        ProcessClass(analyzer);
-    }
-#endif
-}
-
-} // namespace ASBindingGenerator

Source/Tools/BindingGenerator/Main.cpp

@@ -40,7 +40,6 @@ namespace ASBindingGenerator
 {
     void ProcessAllEnums();
     void ProcessAllClasses();
-    void ProcessAllClassesNew();
     void ProcessAllGlobalVariables();
     void ProcessAllGlobalFunctions();
     void SaveResult();
@@ -51,7 +50,6 @@ namespace ASBindingGenerator
     {
         ProcessAllEnums();
         ProcessAllClasses();
-        ProcessAllClassesNew();
         ProcessAllGlobalVariables();
         ProcessAllGlobalFunctions();
         SaveResult();

Source/Urho3D/AngelScript/APITemplates.h

@@ -218,17 +218,15 @@ template <class T> Vector<SharedPtr<T> > HandleArrayToVector(CScriptArray* arr)
 }
 
 /// Template function for dynamic cast between two script classes.
-template <class A, class B> B* RefCast(A* a)
+template <class From, class To> To* RefCast(From* from)
 {
-    if (!a)
+    if (!from)
         return nullptr;
 
-    B* b = dynamic_cast<B*>(a);
-
-    return b;
+    return dynamic_cast<To*>(from);
 }
 
-/// Template function for registering implicit casts between base and subclass.
+/// Template function for registering casts between base and subclass.
 // https://www.angelcode.com/angelscript/sdk/docs/manual/doc_adv_class_hierarchy.html
 template <class BaseType, class DerivedType> void RegisterSubclass(asIScriptEngine* engine, const char* baseClassName, const char* derivedClassName)
 {
@@ -241,8 +239,6 @@ template <class BaseType, class DerivedType> void RegisterSubclass(asIScriptEngi
     String declReturnBaseConst("const " + String(baseClassName) + "@+ opImplCast() const");
     engine->RegisterObjectMethod(derivedClassName, declReturnBaseConst.CString(), AS_FUNCTION_OBJLAST((RefCast<DerivedType, BaseType>)), AS_CALL_CDECL_OBJLAST);
 
-    // TODO fix all scripts to "cast(derivedClass)"
-
     //String declReturnDerived(String(derivedClassName) + "@+ opCast()");
     String declReturnDerived(String(derivedClassName) + "@+ opImplCast()");
     engine->RegisterObjectMethod(baseClassName, declReturnDerived.CString(), AS_FUNCTION_OBJLAST((RefCast<BaseType, DerivedType>)), AS_CALL_CDECL_OBJLAST);

Source/Urho3D/AngelScript/RegistrationMacros.h

@@ -71,9 +71,9 @@ namespace Urho3D
 // RegisterObjectBehaviour(obj, behaviour, decl, AS_FUNCTION_OBJLAST(f), AS_CALL_CDECL_OBJLAST)
 //     where behaviour is asBEHAVE_CONSTRUCT, asBEHAVE_ADDREF or asBEHAVE_RELEASE
 // RegisterObjectMethod(obj, decl, AS_FUNCTION_OBJFIRST(f), AS_CALL_CDECL_OBJFIRST)
-// RegisterObjectMethod(obj, decl, AS_FUNCTIONPT_OBJFIRST(f, p, r), AS_CALL_CDECL_OBJFIRST)
+// RegisterObjectMethod(obj, decl, AS_FUNCTIONPR_OBJFIRST(f, p, r), AS_CALL_CDECL_OBJFIRST)
 // RegisterObjectMethod(obj, decl, AS_FUNCTION_OBJLAST(f), AS_CALL_CDECL_OBJLAST)
-// RegisterObjectMethod(obj, decl, AS_FUNCTIONPT_OBJLAST(f, p, r), AS_CALL_CDECL_OBJLAST)
+// RegisterObjectMethod(obj, decl, AS_FUNCTIONPR_OBJLAST(f, p, r), AS_CALL_CDECL_OBJLAST)
 #ifdef AS_MAX_PORTABILITY
 	#define AS_FUNCTION_OBJFIRST(f) WRAP_OBJ_FIRST(f)
 	#define AS_FUNCTION_OBJLAST(f) WRAP_OBJ_LAST(f)