Здравствуйте, yxiie, Вы писали:

E>>Так вот и я об этом же. Что из скрипта будет вызываться некий Invoke, а уже в Invoke будет код, который приведен выше. Так?

Y>зачем? в байнд-объекте мы уже имеем адрес метода и информацию о параметрах. единственное, что нужно — обработать и преобразовать переданные
Y>скриптом параметры в подходящие для этого метода и сделать вызов.

Но КАК? (Торможу я что-то). Приведи, пожалуйста код по организации вызова метода, сигнатура которого заранее была неизвестна.

E>>Так вот, если объекты, которые ты делаешь доступными для скрипта и методы этих объектов заранее определены, то зачем огород с reflection?

E>>Почему просто не сделать BindedMethod->Invoke оберткой сразу над конкретным C++ классом/интерфейсом? А уже нужные тебе C++ классы/интерфейсы инстанциировать посредством фабрики?

Y>потому, что если мы обойдемся только байндом, то из скрипта мы сможем оперировать объектами С++, а из С++ оперировать объектами скрипта — нет.

Ну это ты зря. Это уж как напишешь.

Здравствуйте, eao197, Вы писали:

E>Здравствуйте, yxiie, Вы писали:

E>>>Так вот и я об этом же. Что из скрипта будет вызываться некий Invoke, а уже в Invoke будет код, который приведен выше. Так?

Y>>зачем? в байнд-объекте мы уже имеем адрес метода и информацию о параметрах. единственное, что нужно — обработать и преобразовать переданные
Y>>скриптом параметры в подходящие для этого метода и сделать вызов.

E>Но КАК? (Торможу я что-то). Приведи, пожалуйста код по организации вызова метода, сигнатура которого заранее была неизвестна.

почему же неизвестна? посмотри в исходниках Batiskaf-a как у него сделана регистрация метода — BindMethod. если все-равно будет неясно, тогда попробую объяснить.

E>>>Так вот, если объекты, которые ты делаешь доступными для скрипта и методы этих объектов заранее определены, то зачем огород с reflection?

E>>>Почему просто не сделать BindedMethod->Invoke оберткой сразу над конкретным C++ классом/интерфейсом? А уже нужные тебе C++ классы/интерфейсы инстанциировать посредством фабрики?

Y>>потому, что если мы обойдемся только байндом, то из скрипта мы сможем оперировать объектами С++, а из С++ оперировать объектами скрипта — нет.

E>Ну это ты зря. Это уж как напишешь.

ну и какая тогда будет разница между такими наворотами продвинутого байнда и рефлексией?

Здравствуйте, yxiie, Вы писали:

E>>Но КАК? (Торможу я что-то). Приведи, пожалуйста код по организации вызова метода, сигнатура которого заранее была неизвестна.

Y>почему же неизвестна? посмотри в исходниках Batiskaf-a как у него сделана регистрация метода — BindMethod. если все-равно будет неясно, тогда попробую объяснить.

Объясняй сразу. Ведь мне не интересны внутренности регистрации метода через BindMethod. Мне интересно, как ты будешь через reflection вызывать метод, сигнатуру которого ты до этого не знал. Ведь в примере, который привел Batiskaf показано, что сигнатура должна быть известна (привел бы оттуда фрагмент с GetMethod, но у того метода простая сигнатура):

typedef    TYPELIST_4(    const std_string&, 
                        unsigned char, 
                        const std_string&,
                        unsigned int )                ConstructorParamList;
typedef    Loki::Functor<    TheObject*, 
                        ConstructorParamList >            Constructor;

//В случае отстутствия конструктора с таким прототипом будет выброшено исключение 
//подобная стратегия применяется для всех запросов к метаклассу
Constructor    ctor = 
                        pClass->GetConstructor<    ConstructorParamList>();

//Создание экземпляра обьекта с вызовом полученного конструктора
TheObject* pObj = ctor("Vasya", 27, "London", 12 );

Здравствуйте, eao197, Вы писали:

E>Объясняй сразу. Ведь мне не интересны внутренности регистрации метода через BindMethod. Мне интересно, как ты будешь через reflection вызывать метод, сигнатуру которого ты до этого не знал. Ведь в примере, который привел Batiskaf показано, что сигнатура должна быть известна (привел бы оттуда фрагмент с GetMethod, но у того метода простая сигнатура):

...

лучше бы ты посмотрел. там у него BindMethod — это переопрделенное имя:

...
            template<    typename RType, 
                        typename Param1,
                        typename Param2,
                        typename Obj
            >void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2))
...

            template<    typename RType, 
                        typename Param1,
                        typename Param2,
                        typename Param3,
                        typename Obj
            >void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2, 
                                                        Param3))
...
            template<    typename RType, 
                        typename Param1,
                        typename Param2,
                        typename Param3,
                        typename Param4,
                        typename Param5,
                        typename Param6,
                        typename Obj
            >void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2, 
                                                        Param3, 
                                                        Param4, 
                                                        Param5, 
                                                        Param6))

таким образом мы знаем сигнатуру и можем сгенерировать соответствующий объект, который будет принимать
параметры из скрипта и на основе их делать вызов.

Здравствуйте, eao197, Вы писали:

E>>>ИМХО, создание таких proxy -- это не есть механизм reflection.

Y>>не понял, объясни, что ты хочешь сказать.

E>Ok. Но мне нужно некоторое время, чтобы восстановить в памяти информацию по reflection в Java. Тогда попробую объяснить.

Просто, как я понял твою задачу, тебе нужна только одна возможность из reflection -- вызов метода. Все остальное ты проигнорируешь.

Здравствуйте, eao197, Вы писали:

E>Просто, как я понял твою задачу, тебе нужна только одна возможность из reflection -- вызов метода. Все остальное ты проигнорируешь.

опиши мне все возможности reflection и я скажу, какие я проигнорирую, какие нет.

Здравствуйте, yxiie, Вы писали:

Y>Здравствуйте, eao197, Вы писали:

E>>Объясняй сразу. Ведь мне не интересны внутренности регистрации метода через BindMethod. Мне интересно, как ты будешь через reflection вызывать метод, сигнатуру которого ты до этого не знал. Ведь в примере, который привел Batiskaf показано, что сигнатура должна быть известна (привел бы оттуда фрагмент с GetMethod, но у того метода простая сигнатура):

Y>...

Y>лучше бы ты посмотрел. там у него BindMethod — это переопрделенное имя:

Y>

Y>...
Y>            template<    typename RType, 
Y>                        typename Param1,
Y>                        typename Param2,
Y>                        typename Obj
            >>void    BindMethod(    const std_string&    name,
Y>                                RType    (Obj::*method)(    Param1, 
Y>                                                        Param2))
...
Y>

Да понимаю я это, ты мне вот что покажи:

Y>таким образом мы знаем сигнатуру и можем сгенерировать соответствующий объект, который будет принимать
Y>параметры из скрипта и на основе их делать вызов.

Как???

E>Как???

void *fptr=find_function_ptr(function_name);
int param,size,params_size;
while(get_next_param(param,size)) {
    asm {
        mov edi,esp

        sub esp,size

        mov ecx,size
        mov esi,param
        cld
        rep stosb
    }

    params_size+=size;
}

asm {
    call fptr
    add esp,params_size
}

Как сделать это на C++ не представляю...

Здравствуйте, sch, Вы писали:

E>>Как???

sch>

sch>void *fptr=find_function_ptr(function_name);
sch>int param,size,params_size;
sch>while(get_next_param(param,size)) {
sch>    asm {
sch>        mov edi,esp

sch>        sub esp,size

sch>        mov ecx,size
sch>        mov esi,param
sch>        cld
sch>        rep stosb
sch>    }

sch>    params_size+=size;
sch>}

sch>asm {
sch>    call fptr
sch>    add esp,params_size
sch>}
sch>

sch>Как сделать это на C++ не представляю...

Так вот и я о том же!

E>Так вот и я о том же!
Интересно, а вот так получится? Только придется варианты использовать, а это уже медленно...

class abstract_function {
public:
    virtual ~abstract_function()=0 {}
    virtual variant call(vector<variant> args)=0;
};

template<class R,class P1>
class function1: public abstract_function {
public:
    R (*fptr)(P1 p1);
    variant call(vector<variant> args) {
        return fptr((P1) args[0]);
    }
}

template<class R,class P1,class P2>
class function2: public abstract_function {
public:
    R (*fptr)(P1 p1,P2 p2);
    variant call(vector<variant> args) {
        return fptr((P1) args[0], (P2) args[1]);
    }
}

Здравствуйте, eao197, Вы писали:

E>Да понимаю я это, ты мне вот что покажи:

Y>>таким образом мы знаем сигнатуру и можем сгенерировать соответствующий объект, который будет принимать
Y>>параметры из скрипта и на основе их делать вызов.

E>Как???

class InvokeFromScript {
public:
    virtual Object* Invoke(Object* self, ScriptArgumentsClass* args);
}

template<    typename RType, 
                    typename Param1,
                    typename Param2,
                    typename Obj >
class InvokeFromScriptImpl2 {
public:
    typedef RType    (Obj::*Method)(    Param1, Param2);

    InvokeFromScriptImpl2(Method mth): method(mth) {}
    
    virtual Object* Invoke(Object* self, ScriptArgumentsClass* args) {
        return ObjectFromType(((Obj*)self)->*method(args->GetArgument<Param1>(0), args->GetArgument<Param2>(1)));        
    }    
    
protected:
    Method method;
}

...
void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2)) {
...
// тут сохраняем InvokeFromScript<Rtype, Param1, Param2, Obj>(method)
...

конечно это все быстрый набросок, но надеюсь идея ясна.

Здравствуйте, sch, Вы писали:

E>>Так вот и я о том же!
sch>Интересно, а вот так получится? Только придется варианты использовать, а это уже медленно...
<...>

Получится. А чем variant медленно?

Здравствуйте, yxiie, Вы писали:

ошибочек пару исправил:

Y>

Y>class InvokeFromScript {
Y>public:
Y>    virtual Object* Invoke(Object* self, ScriptArgumentsClass* args);
Y>}

Y>template<    typename RType, 
Y>                    typename Param1,
Y>                    typename Param2,
Y>                    typename Obj >
Y>class InvokeFromScriptImpl2:public InvokeFromScript {
Y>public:
Y>    typedef RType    (Obj::*Method)(    Param1, Param2);

Y>    InvokeFromScriptImpl2(Method mth): method(mth) {}
    
Y>    virtual Object* Invoke(Object* self, ScriptArgumentsClass* args) {
Y>        return ObjectFromType(((Obj*)self)->*method(args->GetArgument<Param1>(0), args->GetArgument<Param2>(1)));        
Y>    }    
    
Y>protected:
Y>    Method method;
Y>}

Y>...
Y>void    BindMethod(    const std_string&    name,
Y>                                RType    (Obj::*method)(    Param1, 
Y>                                                        Param2)) {
Y>...
Y>// тут сохраняем InvokeFromScript2<Rtype, Param1, Param2, Obj>(method)
Y>...                                                        
                                                        

Y>

SS>Получится. А чем variant медленно?
Это мой маленький пунктик, если я где вижу лишний malloc() то меня тут же начинает передергивать

Здравствуйте, sch, Вы писали:

SS>>Получится. А чем variant медленно?
sch>Это мой маленький пунктик, если я где вижу лишний malloc() то меня тут же начинает передергивать

???
где?

SS>где?
Это я пример привел такой, абстрактный так сказать.
Все конечно зависит от реализации variant, возможно есть другое решение?

Здравствуйте, yxiie, Вы писали:

Y>Здравствуйте, eao197, Вы писали:

E>>Да понимаю я это, ты мне вот что покажи:

Y>>>таким образом мы знаем сигнатуру и можем сгенерировать соответствующий объект, который будет принимать
Y>>>параметры из скрипта и на основе их делать вызов.

E>>Как???

Y>

...
Y>

Y>конечно это все быстрый набросок, но надеюсь идея ясна.

Да, что-то такое я предполагал с самого начала.

ИМХО, в системе интеграции Ruby с C гораздо проще все сделано. "Чего только русские не придумают, чтобы нормальные дороги не строить"

Здравствуйте, yxiie, Вы писали:

Y>Здравствуйте, eao197, Вы писали:

E>>Просто, как я понял твою задачу, тебе нужна только одна возможность из reflection -- вызов метода. Все остальное ты проигнорируешь.

Y>опиши мне все возможности reflection и я скажу, какие я проигнорирую, какие нет.

Вот, коротко, что об этом говорится в JDK:

Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts on objects, within security restrictions. The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class.

ИМХО, доступ к атрибутам тебе не потребуется.

Кстати, можешь посмотреть там еще и Dynamic Proxy. Вся мошь этого в Java проявляется из-за того, что в классе Method есть метод invoke, который получает список аргументов в виде Object[] (нетипизированный!). Как в C++ этого достичь портабильным способом?

Здравствуйте, eao197, Вы писали:

Y>>опиши мне все возможности reflection и я скажу, какие я проигнорирую, какие нет.

E>Вот, коротко, что об этом говорится в JDK:
E>

E>Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts on objects, within security restrictions. The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class.

E>ИМХО, доступ к атрибутам тебе не потребуется.

почему? по крайней мере не помешает. особенно при отладке не выходя в IDE-debugger.

E>Кстати, можешь посмотреть там еще и Dynamic Proxy. Вся мошь этого в Java проявляется из-за того, что в классе Method есть метод invoke, который получает список аргументов в виде Object[] (нетипизированный!). Как в C++ этого достичь портабильным способом?

я с жавой близко не знаком, так что ничего сказать не могу.

Здравствуйте, yxiie:

имхо вы хотите того чего не нужно никому и никогда.
зачем тут нужна рефлексия?
чтобы скрипт вызвал нужный метод достаточно зарегистрировать в виртуальной машине как его вызывать.
Самый простой способ — автоматическая регистрация : те
*при компиляции с++ создаются заглушки, которые преобразовывают аргументы пришедшие из скрипта в нормальный вызов с++ метода
*при компиляции с++ создается код который регистрирует заглушки в скрипте при старте vm

после этого юзер может скриптить сколько угодно.
Главная проблема — интерфейсы менять уже будет нельзя или скрипты придется выкинуть и писать наново.

wbr

зы поделитесь идеями vm а то уже интересно ради чего весь сыр-бор