Набор динамически подключаемых библиотек Borland Runtime Library. Для Delphi RavComp - пакет из двух компонентов для Delphi 5, позволяющих. Скачать: [xml.tar.bz2]. Microsoft Visual C++ Runtime Library: Runtime error. This application has requested the Runtime to terminate it in an unusual way. Oct 12, 2012 - 10 января 2011 в 06:52 Почему Delphi «умирает» или «программист. И при таком подходе через 5-10-20-ть лет Embarcadero вдруг. А триал на месяц вы можете скачать в любой момент, без всяких «программ». Я по привычке часто проверяю свои идеи в Runtime, когда уже костяк.

Многие системные программисты привыкли считать delphi полным отстоем. Свое мнение они аргументируют тем, что компилятор генерирует слишком медленный и большой код, а средний размер пустой формы с кнопкой - 400 килобайт.

Впрочем, иногда никаких аргументов и вовсе не приводится. Когда на форумах сталкиваются поклонники С и delphi, первые обычно кричат о супернавороченном синтаксисе и потрясающих возможностях ООП, при этом утверждая, что в системном программировании все это необходимо, а вторые - о возможностях того же ООП на дельфи, которых нет в С, и о том, что на этом языке писать проще. Из слов и тех, и других можно заключить, что обе стороны ни про delphi, ни про c ничего толком не знают, и все это - пустая ламерская болтовня.

Эта статья посвящена приемам системного программирования на delphi. Она написана для тех, кто любит этот язык, хочет добиться максимальной эффективности кода и не боится вложить в свое дело определенный труд. Я покажу, как делать на дельфи то, что многие считают невозможным. Тем, кто занимается кодингом на С, не составит труда найти целую кучу статей по оптимизации. Если же ты пишешь на delphi, ты не найдешь на эту тему ничего хорошего. Видимо, все считают, что никакой оптимизации здесь не нужно.

Может быть, тебя устраивает 400-килобайтная пустая форма с кнопкой? А, ты думаешь, что это неизбежное зло, и уже давно с ним смирился?

Что ж, придется немного расстроить твои нервы и развеять священные заблуждения. Немного о генерируемом компилятором коде Для начала проверим утверждение, что компилятор delphi генерирует много лишнего и неэффективного кода. Для этого напишем функцию, скачивающую и запускающую файл из интернета (такие вещи обычно используют в троянах). Писать будем, естественно, с применением api. Вот что у меня получилось. source = dword ptr 8.

push ebp. mov ebp, esp. push 0; lpbindstatuscallback. push 0; dword. push offset destfile; lpcstr. mov eax, ebp+source.

push eax; lpcstr. push 0; lpunknown. call urldownloadtofilea. push 0; ucmdshow. push offset destfile; lpcmdline. call winexec.

pop ebp. retn 4. downloadandexecute endp. destfile db ′c: rojan.exe′,0 Ну и где же куча лишнего кода, о котором некоторые так любят говорить? Все просто и красиво, почти то же самое можно написать вручную на ассемблере. Тем более, что на нем некоторые умники иногда такое выдают - любые ошибки компилятора покажутся мелочью:). Почему же программы, написанные на дельфи, такие большие?

Откуда берется лишний код, если компилятор его не генерирует? Сейчас мы разберем этот вопрос подробнее. ООП - двигатель прогресса ООП - весьма модное в настоящее время направление программирования. Его цель - упростить написание программ и сократить сроки их разработки, и с нею ООП прекрасно справляется. Большинство прикладных программистов, пишущих на С или delphi, уже не мыслят своей деятельности без ООП.

Их главный принцип - быстрее сдал программу, быстрее получил деньги. В таких условиях о какой бы то ни было оптимизации просто забывают.

А ведь если взглянуть на дело глазами системного программиста, то сразу станет очевиден главный недостаток: ООП - качество генерируемого кода. Допустим, у нас есть класс, наследуемый от другого класса.

При создании объекта этого класса компилятор будет вынужден полностью включить в его состав также код родительского класса, поскольку нет возможности определить, какие методы классов использоваться не будут. Если у нас целое дерево наследования классов, как обычно и бывает в реальных программах, то весь его код войдет в программу, и от этого никуда не денешься.

Вызов методов класса производится через таблицу, что увеличивает время вызова. А когда метод наследуется от родителя в десятом поколении, то и вызов проходит через десять таблиц, прежде чем достигает обрабатывающего его кода. Получается, что вместе с кучей мертвого кода мы получаем еще низкую эффективность рабочего.

Все это хорошо видно на примере библиотеки vcl в дельфи. А вот программа, написанная на vb или на vc с применением mfc, отчего-то занимает гораздо меньше места. Все потому, что великая и ужасная компания microsoft приложила к этому свою лапу. Mfc и runtime-библиотеки в vb весят ничуть не меньше, просто они скомпилены в dll и входят в поставку windows, а значит, их код не приходится таскать с собой в программах. В защиту borland можно сказать, что такая возможность присутствует и в delphi. Нужно просто в настройках проекта поставить галочку build with runtime packages, тогда программа значительно уменьшится, но потребует наличия соответствующих runtime-библиотек.

Естественно, эти библиотеки в поставку винды не входят, но в этом надо винить не Борланд, а монопольную политику мелкософта. Любители ООП, желающие разрабатывать программы в визуальном режиме, могут использовать kol. Это попытка сделать что-то типа vcl, но с учетом ее недостатков. Средний размер пустой формы с кнопкой - 35 Кб, что уже лучше, но для серьезных приложений эта библиотека не подходит, так как часто глючит. Да и решение это половинчатое. Те, кто хочет добиться действительно высокой эффективности кода, должны идти по принципиально другому пути: забыть про ООП и все, что с ним связано, раз и навсегда. Писать программы придется только на чистом api.

Виновник номер два Создадим в delphi пустой проект, заведомо не содержащий никакого полезного кода. start:. push ebp.

mov ebp, esp. add esp, 0fffffff0h. mov eax, offset moduleid. call initexe.; здесь мог бы быть наш код.

call handlefinally. code ends Весь лишний код находится в функциях initexe и handlefinally. Дело в том, что к каждой delphi программе неявно подключается код, входящий в состав rtl (run time library). Эта либа нужна для поддержки таких возможностей языка, как ООП, работа со строками (string) и специфичные для паскаля функции (assignfile, readln, writeln, etc.). Initexe выполняет инициализацию всего этого добра, а handlefinally обеспечивает корректное освобождение ресурсов. Сделано это, опять же, для упрощения жизни программистам, и применение rtl иногда оправданно, так как может не понизить, а повысить эффективность кода. Например, в состав rtl входит менеджер кучи, который позволяет быстро выделять и освобождать маленькие блоки памяти.

По своей эффективности он в три раза превосходит системный. В плане производительности генерируемого кода работа со строками реализована в rtl тоже довольно неплохо, правда все равно, в увеличении размера файла, rtl - виновник номер два после ООП. Уменьшаем размер Если минимальный размер в 13,5 Кб тебя не устраивает, то будем убирать delphi rtl. Весь код либы находится в двух файлах: system.pas и sysinit.pas.

К сожалению, компилятор подключает их к программе в любом случае, поэтому единственное, что можно сделать, - удалить из этих модулей весь код, без которого программа может работать, и перекомпилить модули, а полученные dcu-файлы положить в папку с программой. Файл system.pas содержит основной код rtl и поддержки классов, но все это мы выбросим. Минимальное содержимое этого файла должно быть таким. interface. procedure handlefinally;. type. tguid = record.

d1: longword;. d2: word;. d3: word;.

d4: array 0.7 of byte;. end;. pinitcontext = ^tinitcontext;. tinitcontext = record.

outercontext: pinitcontext;. excframe: pointer;. inittable: pointer;.

initcount: integer;. module: pointer;. dllsaveebp: pointer;.

dllsaveebx: pointer;. dllsaveesi: pointer;.

dllsaveedi: pointer;. exitprocesstls: procedure;. dllinitstate: byte;. end;. implementation. procedure handlefinally;.

asm. end;. end. Описания структуры tguid компилятор требует в любом случае и без нее компилировать модуль отказывается.

Tinitcontext понадобится линкеру, если мы будем собирать dll. Handlefinally - процедура освобождения ресурсов rtl, компилятору она тоже необходима, хотя может быть пустой. Теперь урежем файл sysinit.pas, который содержит код инициализации и завершения работы rtl и управляет поддержкой пакетов. Нам хватит следующего. interface. procedure initexe;. procedure halt0;.

procedure initlib(context: pinitcontext);. var.

moduleislib: boolean;. tlsindex: integer = -1;.

tlslast: byte;. const.

ptrtonil: pointer = nil;. implementation. Код активации гта 5 в social club. procedure initlib(context: pinitcontext);. asm. end;. procedure initexe;. asm.

end;. procedure halt0;. asm. end;. end. Initexe - процедура инициализации rtl для exe-файлов, initlib - для dll, halt0 - завершение работы программы.

Все остальные лишние структуры и переменные, которые пришлось оставить, необходимы компилятору. Они не будут включаться в выходной файл и никак не повлияют на его размер. Теперь положим эти два файла в папку с проектом и скомпилируем их из командной строки. Dcc32.exe -q system.pas sysinit.pas -m -y -z -$d- -o Избавившись от rtl, мы получили экзешник размером в 3,5 Кб.

Борландовский линкер создает в исполняемом файле шесть секций, они выравниваются по 512 байт, к ним плюсуется pe-заголовок, что и дает эти 3,5 Кб. Но вдобавок к малому размеру мы получаем и определенные затруднения, так как теперь не сможем использовать заголовочные файлы на winapi, идущие с delphi.

Вместо них придется писать свои. Это нетрудно, поскольку описания используемых api можно брать из борландовских хедеров и переносить в свои по мере необходимости. Если в составе проекта есть несколько pas-файлов, линкер для выравнивания кода вставит в него пустые участки, и размеры опять увеличатся.

Чтобы этого избежать, нужно всю программу, включая определения api, помещать в один файл. Это весьма неудобно, поэтому лучше воспользоваться директивой препроцессора $include и разнести код на несколько inc-файлов.

Тут может встретиться еще одна проблема - повторяющийся код (когда несколько inc-файлов подключают один и тот же inc) компилятор в таких случаях компилировать откажется. Выйти из положения можно, воспользовавшись директивами условной компиляции, после чего любой inc-файл будет иметь вид. interface. procedure start;.

implementation. function messageboxa(hwnd:cardinal;lptext,lpcaption:pchar;utype:cardinal): integer;stdcall;external′user32.dll′ name ′messageboxa@16′;. procedure start;. begin.

messageboxa(0, ′hello world!′, nil, 0);. end;. end. Тип модуля unit нужен для того, чтобы компилятор генерировал в объектном файле символьные имена объявленных процедур. В нашем случае это будет процедура start - точка входа в программу. Теперь компилируем проект следующей строкой.; char text. text db ′hello world!′,0.

public start. start proc near.

push 0; utype. push 0; lpcaption. push offset text; lptext.

push 0; hwnd. call messageboxa. retn. start endp Ни байта лишнего кода! Покажи этот пример всем, кто любит говорить о большом размере программ, написанных на дельфи, и понаблюдай за их выражением лица - это прикольно:). Самые упорные промычат: А. Все равно дерьмо!, но уже никто ничего не скажет по существу.

А самые продвинутые спорщики приведут последний аргумент - на delphi нельзя написать драйвер режима ядра для windows nt. Сейчас и они присоединятся к проигравшим:). Пишем драйвер на delphi О том, как по нашей методике сделать невозможное - написать на delphi драйвер режима ядра, даже есть статья на rsdn, и всем интересующимся я рекомендую ее прочитать. Здесь же я приведу пример простейшего драйвера и содержимое make.bat для его сборки.

Dcc32.exe -jp -$a-,b-,c-,d-,g-,h-,i-,j-,l-,m-,o+,p-,q-,r-,t-,u-,v-,w+,x+,y- driver.pas link.exe /driver /align:32 /base:0x10000 /subsystem:native /force:unresolved /entry:driverentry$qqspvt1 driver.obj ntoskrnl.lib /out:driver.sys Для компиляции нам понадобится файл ntoskrnl.lib из ddk. Мы получим драйвер размером в килобайт, который выводит сообщение hello world в отладочную консоль и возвращает ошибку, а потому не остается в памяти и не требует определения функции driverunload. Для запуска драйвера используй kmdmanager от four-f.

Увидеть результаты его работы можно в софтайсе или dbgview. Главная проблема, из-за которой на delphi нельзя писать полноценные драйвера, - отсутствие ddk. Для написания драйверов нужны заголовочные файлы на api-ядра и описания большого количества системных структур.

Все это богатство есть только для С (от microsoft) и для masm32 (от four-f). Есть слух, что ddk для паскаля уже существует, но автор продает его за деньги и сильно этот факт не афиширует.

Думаю, когда-нибудь все-таки найдутся энтузиасты, которые перепишут ddk на паскаль и выложат для всеобщего использования. Другой проблемой является то, что большинство примеров, связанных с системным программированием, написаны на си, поэтому на каком бы языке ты ни писал свои программы, си знать придется. Это, конечно, не означает, что придется изучать С в полном его объеме.

Для понимания системных программ хватит базовых знаний синтаксиса, все остальное же используется только в прикладных программах, которые нас совершенно не интересуют. Переносимость кода При программировании на стандартных delphi компонентах, кроме кучи недостатков, мы получаем одно достоинство - некоторую переносимость кода. Если программа использует только возможности языка, но не возможности системы, то она будет легко компилироваться в kilix и работать в linux.

Вся проблема в том, что без использования возможностей системы мы получим настоящее глюкалово, тяжелую и неэффективную программу. Тем не менее, при написании серьезных программ по вышеописанным методикам, все-таки хочется иметь некоторую независимость от системы. Получить ее очень просто - достаточно писать код, не использующий ни api-функций, ни возможностей языка вообще. В некоторых случаях это совершенно невозможно (например, в играх), но иногда функции системы абсолютно не нужны (например, в математических алгоритмах). В любом случае, следует четко разделять машинно-зависимую и машинно-независимую (если такая есть) части кода. При соблюдении вышеописанных правил машинно-независимая часть будет совместима на уровне исходных текстов с любой системой, для которой есть компилятор паскаля (а он есть даже для pic-контроллеров). Независимый от api код можно смело компилировать в dll и использовать, например, в драйвере режима ядра.

Также такую dll не составит труда использовать и в других ОС. Для этого нужно просто посекционно отмапить dll в адресное пространство процесса, настроить релоки и смело пользоваться ее функциями.

Осуществляющий это код на паскале занимает около 80 строк. Если же dll все-таки использует некоторые api-функции, то их наличие можно проэмулировать, заполнив таблицу импорта dll адресами заменяющих их функций в своей программе. Общие приемы оптимизации Старайся везде, где можно, использовать указатели. Никогда не передавай данные в функцию таким образом. Procedure figznaet(pdata: pstructure); где pstructure = ^tstructure; Такой вызов происходит быстрее и экономит немалое количество кода.

Старайся не пользоваться типом данных string, вместо него всегда можно использовать pchar и обрабатывать строки вручную. Если нужен временный буфер для хранения строки, то его следует объявить в локальных переменных как array of char. Старайся передавать в функцию не больше трех параметров: первые три параметра согласно методу вызова fastcall (который по умолчанию применяется в delphi) передаются в регистрах, а все последующие через стек, что замедляет доступ к ним и увеличивает размер кода. Экономь память: если, например, у тебя есть массив чисел, диапазон которых укладывается в байт, то не нужно объявлять его как dword. Никогда не стоит писать повторяющийся код.

Если какие-либо действия должны повторяться, то их нужно вынести в функцию. Тем не менее, не стоит делать функцию, содержащую две строчки кода, - ее вызов может занимать куда больше места, чем она сама. И помни главное: эффективность кода в первую очередь определяется не компилятором, а примененным алгоритмом,что эффективнее!

В книге описано тестирование программных продуктов в Google: как устроены процессы, как организованы команды, какие техники используются, кто ответственен за качество. Принципы, на которых построено тестирование в Google, применимы в проектах и компаниях любого размера. Авторы книги сами работали над продуктами Google, создавая инструменты тестирования, настраивая процессы и занимаясь непосредственно тестированием. Книга рассчитана на профессионалов из индустрии разработки программного обеспечения: специалистов по тестированию, программистов, менеджеров. В этой книге вы найдете сотни практических рекомендаций о том, как:. назвать свою фирму;. привлечь внимание клиентов и сделать их постоянными приверженцами бренда;. создать свою «фишку», которая выделит фирму из толпы конкурентов;. развить свое присутствие в Интернете;. заставить рынок заговорить о вас. Автор, настоящий профессионал в области PR, в своей книге предлагает сотни конкретных идей для раскрутки бизнеса, каждая из которых вдохновляет на работу и может быть использована на деле.

Такие успешные бизнесмены, как Павел Дуров, Евгений Чичваркин, Олег Тиньков, Владимир Довгань и многие другие, делятся на ее страницах собственным опытом раскрутки. Читайте о секретах создания суперфирмы и начинайте зарабатывать! Роман Масленников уверен – даже при высокой конкуренции можно создать и вырастить мегауспешный бренд. Читайте, вдохновляйтесь и действуйте! Стартап, внимание, марш! ГЛАВА 4. Пакеты - это специальные динамически присоединяемые компоненты (аналоги DLL - динамически компонуемых библиотек Dynamic Link Library), которые используются приложениями Delphi и IDE Delphi (о компонентах Delphi и о создании собственных компонентов читайте во второй части книги).

По своему использованию пакеты делятся на: - пакеты, загружаемые во время работы приложения (Runtime Packages), мы их будем далее называть пакетами времени выполнения. Они содержат в себе код, компоненты и используются приложением во время выполнения. Если ваше приложение ссылается на отсутствующий пакет - оно не будет работать; - пакеты, используемые во время разработки приложения (Design time Packages), будем их называть пакетами разработки. Пакеты разработки содержат в себе компоненты, редакторы свойств, мастера и другие элементы, предназначенные для работы в среде Delphi; - пакеты, которые могут работать как во время разработки приложения, так и во время работы приложения; - пакеты, не являющиеся ни пакетами времени выполнения, ни пакетами разработки. Данный вид пакетов предназначен для использования их другими пакетами.

На них не могут ссылаться ни приложение, ни сама среда Delphi. Для того чтобы пакеты можно было отличить от других динамически присоединяемых библиотек, имеющих расширение DLL, для пакетов используется расширение BPL - пакет библиотеки Delphi (Borland Package Library).

Так же, как и остальные динамические библиотеки, пакеты содержат код, который может быть использован одновременно несколькими приложениями. Например, самым часто используемым пакетом Delphi 5.0 является VCL50.BPL. Когда вы создаете практически любое приложение на Delphi, вы используете этот пакет. Сама среда Delphi также использует данный па кет. При этом достаточно, чтобы в памяти компьютера находилась всего одна копия данного пакета для скольких угодно приложений, использующих VCL50.BPL. Ту же копию пакета будет использовать и сама среда Delphi. Вы можете строить ваши приложения с использованием пакетов или без них.

Но, если вы хотите включать в свое приложение самостоятельно созданные компоненты, вам придется установить пакет, используемый во время разработки приложения и содержащий данные компоненты. В этой главе мы рассмотрим, для чего нужны пакеты, как используются пакеты в приложениях, как можно динамически загружать пакеты. Рассмотрим процедуру инсталляции пакетов компонентов.

Научимся создавать новые пакеты и редактировать уже имеющиеся. Изучим общую структуру пакета.