Russian English
   Basic.net
Суббота, 20.04.2024, 00:06
Меню сайта
Категории раздела
Basic [44]
Помощь [0]
Облако тегов
Статистика

Онлайн всего: 1
Гостей: 1
Пользователей: 0

Форма входа
Главная » Статьи » Basic

Вызов функций по указателю в Visual Basic (часть 3)
Share |
Далеко в обход...

Что может заставить нас идти дальше? Так это же интересно! Кому не интересно, остаётся на только что достигнутом результате, а мы продолжаем.

Что бросается в глаза - так это ParamArray. Вот если бы можно было задать его тип, чтобы не Variant... А так приходится делать CLng, да и вообще, Variant работает медленно. Жёстким волевым решением постановляем: Variant убрать, перейти на Long. Правда, придётся ввести дополнительный параметр, определяющий количество остальных параметров.
А как же удобно получать эти остальные параметры, спросит внимательный читатель, ведь теперь мы не можем обращаться к ним в цикле! Неужели многочисленные If ParamsCount < ... ? Конечно же нет! Вспомним, ведь наша "вызывалка" - это тоже функция! А раз так, она тоже подчиняется StdCall! А раз так, её параметры идут в стеке в обратном порядке! А раз так, мы можем их получить, если будем иметь "точку опоры"! А она у нас есть - это VarPtr первого параметра! Именно это великое число и показывает положение в стеке первого нашего "значимого" параметра. Последовательно прибавляя к нему 4, мы будем получать указатель на второй параметр, на третий...

В объектно-ориентированный обход...

Кто-то ещё в чём-то сомневается? Нет? Правильно. Возможно всё.
Знатоки технологии OLE наверняка уже в задумчивости. Функциональность любого объекта OLE определяется списком интерфейсов, которые реализует этот объект. А интерфейс – это что? Интерфейс – это указатель на таблицу указателей на функции. А вызывать функции по указателю мы уже худо-бедно умеем, разве нет? Следовательно, модифицировать CallFunction в CallInterface мы сможем очень легко. Для этого надо учесть лишь две вещи:

- указатель на интерфейс – это только первый шаг. Нужно найти, куда он указывает (а указывает он на таблицу функций), сместиться по этой таблице на нужное количество ячеек (одна ячейка – один указатель на метод) и посмотреть, что же в этой ячейке. Это и будет указатель на искомый метод.

- у каждого интерфейсного метода есть неявный первый параметр – указатель на сам интерфейс.
Теперь у нас снова достаточно информации Располагаем параметр pInterface непосредственно перед параметром p1, передаём ассемблерной вставочке не ParamsCount, а ParamsCount + 1, и не VarPtr(p1), а VarPtr(pInterface). Ну и указатель на функцию находим описанным выше способом. См. код!

"А зачем это нужно? Ведь VB может работать с объектами и просто так. Просто создаём объект через CreateObject, ставим точку и пишем имя метода – пусть списочка методов и нет, но VB разберётся!" VB, конечно, разберётся, но только если этот объект поддерживает интерфейс IDispatch. А если не поддерживает, то для работы с таким объектом позднее связывание (да, это оно работает, когда вы вызываете методы из ниоткуда) не работает. Для работы с таким объектом нужно иметь его описание – Type Library, библиотеку типов. Иметь её должен только разработчик, после компиляции она не нужна. Если же нет и библиотеки, то вызвать метод объекта можно только таким вот способом.
Ещё один промежуточный вариант. Теперь мы можем вызвать любой метод любого интерфейса, даже не имея его type library. Для этого нужно иметь указатель на интерфейс (это ObjPtr), а также знать номер вызываемого метода. Номера методов можно посмотреть в файлах .h или в документации. Лучше, конечно, иметь tlb, благо создать его не так уж сложно, но об этом я здесь не буду.

Слушайте! Идея пришла только что... А пусть получением параметров занимается сама ассемблерная вставочка! Во-первых, получится гораздо быстрее, во-вторых, можно будет сделать вставочку фиксированного размера (там будет цикл!). Подставляем только кол-во повторений, указатель на параметры и указатель на функцию! Ну-ка... Ну надо же... Нет, идея правда пришла только что!
И давайте, наконец-то, вынесем это дело в класс. Во-первых, у нас теперь есть необходимость в инициализации (вставочка-то теперь постоянного размера), а во-вторых, так мы сможем привязать экземпляр класса к библиотеке. Я не буду приводить полный код здесь, но в аттаче вы его найдёте и во всём разберётесь. А здесь - только обновлённый код CallFunction:

Код Visual Basic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
Public Function CallFunction(ByVal FuncName As String,_
 ByRef FuncPointer As Long, ByVal ParamsCount As Long,
_ Optional ByVal p1 As Long = 0,_
 Optional ByVal p2 As Long = 0, Optional _
ByVal p3 As Long = 0, _
Optional ByVal p4 As Long = 0, Optional _
ByVal p5 As Long = 0, Optional _
 ByVal p6 As Long = 0, Optional _
ByVal p7 As Long = 0, Optional ByVal _
 p8 As Long = 0, Optional_
 ByVal p9 As Long = 0, Optional ByVal _
 p10 As Long = 0) As Long
  
  'Сделаем так:
  '   - если FuncPointer = 0, то проиходит вызов FuncName, а через
  '     FuncPointer возвращается указатель на эту функцию.
  '   - если FuncPointer <> 0, то происходит вызов этого самого FuncPointer,
  '     а FuncName игнорируется.
  
  If ParamsCount < 0 Then Err.Raise 5 'invalid call
  
  If FuncPointer = 0 Then
    FuncPointer = GetProcAddress(m_hLib, FuncName)
    If FuncPointer = 0 Then Err.Raise 453 'function not found
  End If
  
  If ParamsCount = 4 Then
    CallFunction = CallWindowProc(FuncPointer, p1, p2, p3, p4)
  Else
    PutMem4 hGlobal + 1, ParamsCount
    PutMem4 hGlobal + 6, VarPtr(p1)
    PutMem4 hGlobal + 22, FuncPointer - (hGlobal + 22) - 4
    CallFunction = CallWindowProc(hGlobal, 0, 0, 0, 0)
  End If
End Function
Вот и ещё один промежуточный результат. Для вызова нужно явно указать число параметров, а затем и перечислить их. Параметры помещаются в стек ассемблерным циклом, поэтому их количество может быть любым. Если вам не хватит 10, добавляйте ещё (в форме "optional byval p# as long", где # - номер очередного параметра). Ни код функции, ни инициализация класса от этого не изменятся.
Большинство команд заполнения ассемблерной вставки перенесено в инициализацию класса, благодаря чему возросла скорость вызова.
Запомним и этот вариант; а какой где использовать, разберёмся в конце.

Сусанин отдыхает...

Что, можно придумать что-то ещё?! А вы как думали!Согласитесь, вызов функции через CallFunction довольно удобен, а поначалу просто шикарен... Но когда попривыкнешь, начинаешь думать о чём-то ещё более удобном... Вот если бы совместить обычный синтаксис VB с вот этим всем... Ну так в чём же дело?
Помещаем в модуль функцию. Задаём ей список параметров, соответствующий списку параметров вызываемой по указателю функции. В тело функции помещаем единственную команду – возвращение нуля. Берём адрес этой функции (AddressOf). Адрес функции – это место в памяти, где расположена первая команда функции. Так вот пишем в это место совсем другую команду, а именно команду безусловного перехода на нужный адрес – jmp. Команда jmp не меняет содержимого стека. В результате цепочка будет такой:
- мы пишем по адресу VB-функции команду jmp. Мы делаем это 1 раз, потом будем пользоваться сколько угодно
- вызываем эту VB-функцию (обычным синтаксисом VB, как обычную функцию модуля)
- VB думает, что мы правда хотим именно эту функцию, упаковывает параметры в стек (сам, без нас) и передаёт управление на свой модуль
- а там команда jmp! Сразу и без вопросов получается переход на тот адрес, который нам на самом деле нужен. Очень быстрый переход.
- управление переходит в действительно нужную нам функцию. С её точки зрения всё прекрасно: параметры упакованы в стек как нужно, а команда jmp не поменяла ни их, ни адрес возврата. Поэтому при завершении работы управление будет возвращено не в модульную функцию VB, а в то место, откуда была вызвана модульная функция
- VB вообще об этом не подозревает. Он думает, что модульная функция успешно завершилась.

Позвольте, а почему я решил, что в AddressOf функции хватит места для записи команды перехода и адреса перехода? А потому что я скомпилировал проект с пустой функцией с одним параметром, возвращающей ноль, и нашёл её в exe. Код следующий:
Код ASM
1
2
xor eax, eax
ret 4
Кто-то ещё сомневается в крутизне компилятора VB? Но не отвлекаемся: указанные две команды занимают ровно 5 байт. Именно столько нам и нужно. Фантастика. Даже лишних растрат памяти на функции-пустышки не будет.

Вот! Наконец-то! Вызов любых функций по указателю синтаксисом VB!

Единственная проблема – работает это только в exe по причинам, которые выходят за рамки этой статьи. Раз так, провести отладку не сможем. Потеря отладки – серьёзный недостаток, и мириться с ним я бы не стал. Но позвольте! Первые варианты прекрасно работают и в exe, и в IDE. Но они существенно медленнее и не позволяют осуществлять вызов синтаксисом VB... Но это не имеет значения, потому что мы объединим их через условную компиляцию. При работе из IDE будет использоваться медленный, но совместимый с IDE способ, а при компиляции в exe будет записан быстрый.

А как же права записи? PutMem4 тут не поможет, нет права на запись в эту часть кода. А вот WriteProcessMemory пофигист куда больший.

А как же синтаксис вызова? Он же разный? Шерстить всю программу? Ну уж нет... Тут пришлось немного постараться, но в результате вызов "совместимым" способом стал с точки зрения внешнего пользователя неотличим от вызова "несовместимым". Для настройки функции на нужный указатель используется SetFunction, а вызов настроенной функции – как всегда вызывали функцию модуля.

Логика тут такая.
Если #ReleaseBuild = False, то:
- модуль содержит коллекцию, хранящую служебную информацию, а также функцию CallFunction.
- вызов SetFunction приводит к занесению в коллекцию адреса реального вызова, ключом для которого является строковое представление адреса функции-пустышки. Переписывание тела пустышки не производится.
- Будучи вызванной, функция-пустышка извлекает из коллекции тот адрес, с которым она ассоциирована, и вызывает CallFunction по этому адресу.
- Код пустышки несколько усложняется, писать его вручную уже не с руки (об этом ниже). Не огорчайтесь, в exe попадёт единственная команда xor eax, eax...
- Да, всё это очень медленно! Но это только для отладки.

Если #ReleaseBuild = True, то:
- Модуль не содержит ничего, кроме пустышек. Пустышки не содержат ничего, кроме команды возвращения нуля.
- Вызов SetFunction приводит к прямой записи по указанному адресу, без всяких проверок (предполагается, что всё уже отлажено. Вы же не будете отлаживать в режиме ReleaseBuild = True? А раз вы всё уже отладили, зачем проверки?).
- Максимальная скорость! Серьёзно.
Вот такая вот логика

Спокойно пишем свой рулезный софт, используем вызов по указателю, всё тестируем, и т.д. и т.п. Убедившись в работоспособности, ставим ReleaseBuild = True и компилируем. Всё, опять-таки, работает, но на гораздо большей скорости.
Самые ленивые, однако, уже отметили, что придётся писать усложнённый код пустышек. Придётся! Не хотите – пожалуйста, с потерей отладки... Ну ладно, ладно В конце концов, можно переложить эту работу на IDE. Для этого нужно всего лишь написать add-in (стандартный шаблон оной есть в окне создания нового проекта). Используя события среды, надстройка будет отслеживать активное окно с кодом. Если это окно является модулем (а пустышки могут быть только там), начинается сабклассинг оного (дело в том, что у кодовых окон нет нужных нам событий). Перехватывается нажатие Enter. Если Enter нажат на строке, содержащей кодовую последовательность
Код ASM
1
#func MyFunction(paramlist)
то происходит замена этой последовательности на тело соответствующей пустышки! Paramlist – список параметров функции, по тем же правилам, что и всегда. Код пустышки будет сгенерирован с подстановкой VarPtr, ObjPtr и StrPtr в тех местах, где это необходимо. Обратите внимание – используется полное имя функции в форме ИмяМодуля.ИмяФункции. Это связано с тем, что иначе нельзя получить адрес функции из самой этой функции.

Применимость

Применять при вызове функций по указателю! Теперь чуть более подробно. Все параметры должны быть размером 4 байта. Целые числа можно передавать по значению. Целые и нецелые числа можно передавать по указателю (т.е. в качестве параметра нужно указать VarPtr).

Строки нужно передавать либо по значению (StrPtr), либо по ссылке (VarPtr). На самом деле, в обоих случаях будет передан указатель, в первом случае – на строковые данные, во втором – на переменную VB, содержащую указатель на эти строковые данные.
Объекты нужно передавать по значению (ObjPtr) или по ссылке (VarPtr). Правила те же, что и со строкой.

Неявное конвертирование из Unicode в Ansi не происходит! Поэтому если вы вызываете функцию, ожидающую Ansi, вы должны передать ей что-то вроде StrPtr(StrConv("string", vbFromUnicode)). Если же функция ожидает Unicode, передавайте StrPtr("string").
Используйте прямой вызов CallWindowProc, если у вызываемой функции ровно 4 параметра, а больше ничего вы и не вызываете. Ну бывают такие совпадения.

Используйте CallFunction с ParamArray в том случае, когда вы не хотите включать в проект модуль с пустышками, когда для вас не критична скорость, и когда вы не хотите каждый раз указывать число параметров явно.

Используйте CallFunction с явным указанием числа параметров в том случае, когда вы не хотите включать в проект модуль с пустышками, когда скорость гораздо более важна (тогда почему вы пустышки-то не хотите?) и когда вам нужна большая жёсткость при передаче параметров. В предыдущем варианте вы могли передать любое выражение в качестве параметра, а здесь – только Long. Теперь вы не забудете о том, что строки передаются через StrPtr, переменные по ссылке – через VarPtr. Иначе просто не будет компилироваться. В принципе, этот метод предпочтительнее, во избежание ошибок.

Используйте функции-пустышки, когда вы хотите вызывать что угодно по указателю синтаксисом VB или когда для вас критична скорость вызова. Не обращайте внимания на медленный вызов из IDE, он всё равно не попадёт в exe. Надстройка, следящая за вводом кодовой последовательности шаблона, будет генерировать код пустышек, подставляя VarPtr, StrPtr и ObjPtr там, где это нужно. Главное – перед компиляцией не забудьте установить ReleaseBuild = True.

И последнее
Я писал всё это в расчёте на понимающего читателя, который не будет пытаться передать пустышке Variant ByVal, или Double тем же способом. Параметры размером 4 байта все. Для работы с API этого более чем достаточно, а для передачи больших данных используются указатели (передать Variant ByRef – всегда пожалуйста). Генератор кода пустышек будет стараться исправлять ваши возможные ошибки.
Автор: Сергей Гергерт
Категория: Basic | Добавил: Admin (14.06.2012)
Просмотров: 5195 | Рейтинг: 0.0/0
Всего комментариев: 0
Добавлять комментарии могут только зарегистрированные пользователи.
[ Регистрация | Вход ]
Поиск
Наш опрос
Какую версию Basic вы предпочитаете?
Всего ответов: 2140

© Basic.ucoz.net, 2024