Assembler & win32 курс молодого бойца

Настройка MASM32 для Visual studio 12
Доброго всем времени суток, заранее извиняюсь если задам глупый вопрос, только приступил к изучению.

Компиляция программ exe для DOS в MASM32
помогите разобраться как создавать программы в masm32 типа exe , можете дать код который точно.

Assembler & win32 курс молодого бойца

Как я и обещал, мы с вами займемся программированием под win32. Выполняю свое обещание. Хотя, честно говоря, нижеследующий кусок текста мне уже совсем не нравится. То есть сначала он мне понравился, но потом некоторые товарищи, чье мнение я весьма уважаю и ценю, его раскритиковали в пух и перья.
А вообще-то в этом тексте дофига плагиата.
Portion by svet(R)off

#1. Однажды студент по имени Дениска Ричи сел изучать абсолютно новый для него язык программирования. Первое, что он сделал — написал программу «Hello, World», и, что самое удивительное, она у него заработала. Когда же он перелистнул следующую страницу своей умной книжки, то ни черта не понял. То есть задним умом своей головы он, конечно же, понимал, что большинство известных ему программ умеют намного больше, чем тупо приветствовать мир, однако понять, каким это извращенным образом такие здоровские штуки можно запрограммировать, он не мог.
Однако ум Дениска имел пытливый (в школе его часто драли в раздевалке — всех гениев в детстве драли в раздевалке!) и сразу же просек, что если в природе существуют программы, умеющие больше этого, то наверняка должны быть и программы, умеющие меньше.
И тогда Дениска, опасаясь быть сначала проигнорированным, потом замодерированным, и в конце концов посланным, забросил свой вопрос в одну из эх, приготовившись, если чего вдруг не так, притвориться кроликом и начать жевать морковку.
Последующие события подняли дыбом все волосы на его тщедушном тельце. Со всех концов бескрайней саванны мгновенно слетелись, сбежались (а некоторые даже и сползлись) бесчисленные гуру, сенсеи и йоды. Возникла крутейшая разборка, поднявшая большое облако пыли, из которого долго доносились рыки, ржание, визги и предсмертные хрипы, а во все стороны разлетались зубы, перья и клоки шерсти. Сначала великие считали и пересчитывали строчки в исходниках, потом буквочки в строчках, а потом даже и байтики в экзешниках, при этом постоянно гоняя получившиеся цифры между двоичным, десятичным и шестнадцатеричным радиксами.
Страшна и беспощадна была эта битва, пока, наконец, из-под обломков не выполз только что пришедший в себя Бьярни Страус (весь помятый и бледный, как труп; те, кто видели, так и начали его с тех пор обзывать — Страус-труп) и не предложил подсчитать биты, установленные в 1.
И тогда вопли стихли, ибо на всех вдруг нашло прозрение, по какой это такой причине двери в психушках открываются исключительно вовнутрь.
Вывалив языки и тяжко дыша, великие расползлись по своим кельям зализывать раны и готовиться к грядущим битвам, а посередине вытоптанной поляны, одинокий, жалкий и забытый, остался остывать трупик несчастного кролика.

#2. Между тем, вопрос о минимальном приложении — это вам не «кто идет за «Клинским» (конечно же, тот, кого в прошлый раз от «Балтики-медового» мутило), и даже не тот, «кто потом пойдет сдавать бутылки» (конечно же тот, кого систематически дерут в раздевалке!). Минимальное приложение — это есмъ альфа и омега программирования, сцилла и харибда отладки, инь и янь сопровождения и даже (давайте не будем бояться этой правды жизни!) эпос и анус раскрутки программного продукта! И именно поэтому за много-много лет никто так и не усомнился в правоте Кнута, который утверждал, что если:

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

Как свидетельствует вышеозначенная формула, вопрос о минимальном приложении (речь идет именно о приложениях, то бишь applications, а вовсе не о каких-нибудь там VxD) — совсем не простейший, и представляет отнюдь не академический интерес. Даже прибалдевшему от морковки кролику должно быть очевидно, что любое приложение обязано выполнить как минимум две не такие уж и простые задачи:

а) стартовать, получив при этом нормальный доступ к ресурсам рабочей среды,
и
б) завершиться, оставив эту рабочую среду работоспособной.

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

Ракетница — одно из самых крутых оружий в Quakе. Рокетджамп — это такой прыжок, когда из ракетницы (в прыжке!) стреляешь себе под ноги и из-за этого очень высоко подпрыгиваешь, при этом сжигая определенное количество пунктов здоровья. Мегахелс, однако, тебе их потом с лихвой восстанавливает. Quake — рулез! Каждый низкоуровневый программист должен любить Кваку!!)

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

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

#3. Итак, с криком «банзай» (восточная школа) либо «мастдай» (западная школа), открываем текстовый редактор и набираем там исходный текст (в обиходе называется сырец) минимального приложения на языке ассемблера.

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

Мясорубкой мы будем пользоваться специальной, виндозовской. Называется она MASM32, версию имеет 7.0, весит 5 Мб, а скачать ее можно здесь.
Как говорится, клик хере фор доунлоад, а пока вы будете эту мясорубку скачивать и привинчивать к столу своей камеры пыток, я прочту вам некоторые строки из прилагаемого к ней буклетика.

#4. Фирма Microsoft никогда не документировала, каким это извращенным способом можно писать приложения под Win32 на Ассемблере. Конечно же, в ее Driver Development Kit (DDK) есть парочка соответствующих топиков, но они относятся исключительно к разработке виртуальных драйверов VxD и прочих специфических штук. Ни для кого не секрет, что для программирования в среде Windows необходимо иметь многочисленные ссылки на данные, такие как прототипы функций, структуры, типы и определения констант, макросы. и так далее. Так вот, все вышеперечисленное богатство как раз и поставляется с DDK. Однако, вот беда, «заточено»-то оно под Си :(.
Естественно, маргинальная часть программирующего сообщества неоднократно задавала мелкософту вопрос на тему «assembly language programming for Win32». Но все, что могла ответить служба поддержки — это «assembly language programming for Win32 is not supported by Microsoft» — на первый бесплатный звонок, и «no, it cannot be done» — на второй. Третий же звонок уже стоил немалых денег, и находились лишь считанные единицы, решавшиеся на это.
Однако, как говорится, если гора не идет к Магомету, то Магомет идет к горе. Осознав простую народную мудрость, что «спасение утопающих — дело рук самих утопающих», некто Hutch (потом ему начала помогать целая команда во главе с Iczelion’ом), взял все вышеозначенное «богатство» и начал «перезатачивать» его под Ассемблер.
Подозреваю, что это был весьма тяжелый и тернистый путь, потребовавший от Hutch’a как огромных моральных усилий, так и определенных материальных затрат. Однако он был успешно выполнен, в результате чего мы с вами имеем огромнейшую халяву и собираемся самым бессовестным образом сберечь на этом большое число своих драгоценнейших нервных клеток ;).
Не правда ли, последнее радует? Но, тем не менее (а как же без ложки дегтя?), необходимо учесть и тот простой факт, что пакет MASM32 делался живыми людьми, и в нем могут содержаться (и они там действительно есть!) ошибки. Поэтому отнюдь не стоит брезговать время от времени проверять соответствующие заголовочные файлы ;).
Вот такая вот предыстория. Надеюсь вы уже скачали MASM32 и установили его на свой жесткий диск? Тогда давайте вернемся к нашим баранам :).

#5. Делать EXE’шник, как всегда, мы будем в два этапа. Для начала возьмем исходник minimal.asm и «заведем» нашу мясорубку следующей командной строкой (каталог с исходником должен быть текущим):

Ключ /c говорит о том, что мы хотим только оттранслировать исходный файл, но не компоновать.
Ключ /coff означает, что мы хотим создать объектный файл в формате COFF (Common Object File Format), стандартном для «Окон» формате объектных файлов (TASM, в отличие от MASM, создает объектные файлы в интеловском формате OMF (Object Module Format), который мелкософтовский линкер запросто конвертирует в COFF).
Теперь, если вы правильно набрали исходник, в той же папке, что и minimal.asm, должен появиться объектный файл minimal.obj.
Далее приступим к компоновке экзешника. Затаиваем дыхание и дергаем за стартер:

Ключ /SUBSYSTEM с параметром WINDOWS говорит линкеру о том, что мы собираемся собрать экзешник для подсистемы Windows. Другие возможные значения: CONSOLE — если мы собираемся делать программу с текстовым интерфейсом а-ля ДОС, NATIVE — если драйвер устройства, и POSIX — если мы собираемся писать программы, ориентированные на стандарты POSIX и более или менее переносимые под разные Юниксы (для которых эти стандарты и писались).
Ключ /LIBPATH указывает путь к библиотекам импорта, которые нам обязательно необходимо прилинковать к программе, если мы хотим использовать возможности, предоставляемые не только процессором, но и операционной системой. Подробнее о том, что из себя представляют библиотеки импорта, мы поговорим чуть позже.
Если вы все сделали правильно, то в нашей папке, наряду с исходным и объектным, должен появиться еще и третий файл — исполнимый. Возрадуемся же этому и перейдем к следующему пункту повестки дня — разборке исходника. Неужели вам не интересно знать, что означают эти загадочные строчки в minimal.asm?

#6. .386 — это директива ассемблера, определяющая набор инструкций процессора, которые могут быть использованы в программе (позже мы проведем четкую границу между инструкциями, директивами и командами). По умолчанию транслятор полагает, что программа пишется для процессора 8086 и сопроцессора 8087. Но, посудите сами, какая под него может быть Винда? Для приложений win32 необходимо указывать либо .386, либо выше (486, 586, 686) — в зависимости от того, собираетесь ли вы использовать возможности, предоставляемые процессорами/сопроцессорами последующих поколений или нет. Впоследствии мы будем также использовать p-версию этой директивы (486p, 586p), что даст нам доступ к страшным и ужасным привилегированным командам, которые нехороший «дядька» Микрософт подмял под себя, и выпросить их у «мелкомягких» будет не так уж и просто.

#7. .model flat, stdcall. Первый параметр — это модель памяти. Например, COM’овские программки, которые мы с вами раньше писали, соответствовали модели tiny, то есть «крошечной» — они запросто помещались в 64 Кб памяти, и никаких проблем с адресацией данных у нас не было. Однако если бы мы захотели написать под ДОС программу во много раз большую, чем 64 Кб, т.е. превышающую размер сегмента, нам пришлось бы познакомиться с таким динозавром, как оффсетно-сегментная адресация, и использовать, в зависимости от навороченности программы, модели small, medium, compact или large. Под Windows же у нас есть одна-единственная «правильная» модель памяти — flat, то бишь «плоская», позволяющая нашей программе благодаря страничной адресации легко и просто работать с 4 Гб виртуальной несегментированной памяти. И это есть хорошо! Ибо теперь, как сказал некто Вал.Ик., нам не нужно смотреть на мир сквозь замочную скважину 64 Кб-сегмента. (C)
Второй же параметр указывает на так называемое соглашение о вызове процедур. Каждый язык имеет свои «соглашения». Так, второй параметр может принимать значения: c, basic, fortran, pascal. Мы не будем вдаваться в особенности каждого, просто скажем, что при программировании под win32 на макроассемблере нужно использовать соглашение stdcall, ведущее свою родословную в части наименования ] функций — от языка С (плодовитый, однако, мужчина!), а в части передачи аргументов — от языка Pascal (курица, как говорится, не птица, но яйца мы предпочитаем куриные). Подробнее об этом соглашении будет рассказано ниже.

#8. .includelib kernel32.lib — эта директива передается компоновщику и сообщает, что наша программа должна быть слинкована с указанной библиотекой, в данном случае с kernel32.lib. Библиотека представляет собой энное количество готовых к употреблению процедур, оттранслированных в объектные файлы и собранных в большую кучу под названием «библиотека».
Если помните, есть такое понятие как программное прерывание, то бишь механизм, при помощи которого можно обратиться за обслуживанием своих запросов к операционной системе. Так вот, в среде Windows пользовательских прерываний как таковых нет, а задействование ресурсов операционной системы производится совершенно иначе — при помощи так называемых функций Windows API. А для того, чтобы получить доступ к этим ресурсам, вы должны обязательно cлинковать свою программу с соответствующей библиотекой импорта, в которой как раз и находится куча маленьких подпрограммок, собственно, эти функции и вызывающих.
Слово «слинковать» выделено не случайно. Это связано со следующей строчкой нашего исходника.

#9. Посмотрите внимательно на тело WinMain. Там есть команда call, то есть вызов подпрограммы. А где, спрашивается, сама подпрограмма ExitProcess? Ан нету ее! А почему тогда, спрашивается, транслятор на это не ругается? А вы удалите строчку ExitProcess PROTO :DWORD и попробуйте оттранслировать свой исходник. Ага, хорошо знакомое: «undefined symbol : ExitProcess»? Еще бы, такой подпрограммы в нашем исходнике действительно нет!
Посмотрите на call ExitProcess — это вызов API’шной функции, завершающей работу нашей программы (виндозный аналог хорошо нам известного INT 20h). Именно подпрограмма с таким именем будет прилинкована к нашему экзешнику, и уж она-то знает способ, как ей обратиться к DLL-ке kernel32.dll и заставить ее прервать работу нашей программы! Еще раз повторюсь, прилинкуется не сама API’шная функция, а только подпрограммка, которая умеет эту внешнюю функцию вызывать.
Но это на этапе линковки, когда соединяются все «концы» между объектными файлами. А на этапе транслирования ассемблер не имеет никакого понятия о том, что в природе существует какой-то ExitProcess. И чтобы он (транслятор) не ругался, мол, «кто такой, почему не знаю», нужно их «познакомить» — при помощи так называемого прототипа. Другими словами, прототип — это своего рода уведомление транслятора о том, что «немного попозже я собираюсь обращаться к товарищу ExitProcess, и форма вызова для него такая-то». Ну а далее следуют «паспортные данные» на этого товарища — сколько он «переваривает» параметров, и какой они должны быть размерности, дабы тот, не дай бог, не подавился.
Вообще-то говоря, существует несколько способов подобного «уведомления», однако вышеприведенный, несмотря на свою кажущуюся навороченность, является самым эффективным, так как позволяет проверять соответствие количества и типа аргументов параметрам, тем самым помогая отслеживать целый ряд трудноуловимых ошибок.

#10. Как известно, каждая программа состоит из кода и данных. Раньше мы их называли сегментами — это было связано с тем, что из-за сегментной адресации приходилось мерить мир «спичками» по 64 Кб. Теперь же мы, слава Богу, имеем единое адресное пространство, и термин сегмент, во избежание терминологической путаницы наподобие «говорим сегмент, подразумеваем 64 Кб», заменим на термин «секция», хотя, по большому счету, это одно и то же.
Определяются эти секции, а-ля сегменты, следующими упрощенными директивами:
— .data — определяет секцию инициализированных данных;
— .data? — определяет секцию неинициализированных данных, для тех случаев, когда необходимо предварительно выделить определенное количество памяти, но инициализировать ее заранее нет необходимости. Фишка заключается вот в чем — сколько бы мы ни определяли неинициализированных элементов данных, размер файла программы на диске остается неизменным. Мы просто таким образом ставим систему в известность: «когда программа загрузится, я хочу иметь в своем распоряжении такой-то объем памяти»;
— .const — определяет секцию констант, то есть элементов данных, которые наша программа не сможет (во всяком случае, не должна) изменять ни в коем разе;
— .code — собственно код, то есть последовательность инструкций, которые должен выполнить твой компьютер.
Из всех вышеперечисленных секций в нашем исходнике есть только CODE. Это единственная секция, которая обязательно должна присутствовать в любой программе. А разве может быть иначе?

#11. В секции кода у нас есть одна-единственная процедурка. На всякий случай напомню, что о ее начале свидетельствует строчка WinMain PROC, где WinMain — это «имя собственное», которое вы можете заменить любым словом, в том числе и своим любимым. А ее конец — это строчка WinMain ENDP. Кстати, настоящим ассемблерщикам должно быть приятно, что, опустив ненужную в связи с этим команду ret, мы сэкономили аж 4 байта кода!
О конце модуля транслятору сообщает директива end, и в качестве параметра у нее метка, на которую будет передано управление при старте программы. В данном случае — это имя «главной», а в нашем случае еще и единственной, процедуры WinMain.
;. — этот комментарий поставлен на месте всякой прочей мелочи, которую вы хотели бы заставить делать ваше приложение в тот примечательный момент, когда решите сделать его немного большим, чем минимальное.

#12. Как я уже говорил в п.7, вызов функций API из программы на ассемблере подчиняется соглашению «stdcall». Выражаясь официозно, «с точки зрения прикладного программиста, с учетом специфики Windows и MASM», эти соглашения заключаются в следующем:
1. Регистр символов в имени функции не имеет значения. Например, функции с именами WindowsMustDie и windowsmustdie — это одна и та же функция. Здесь мы наблюдаем отличие от требования языков C и C++, в которых идентификаторы регистро-зависимы. Зато в Паскале регистр имен не имеет значения.
2. Аргументы передаются вызываемой функции через стек. Если аргумент укладывается в 32-битное значение и не подлежит модификации, вызываемой функцией, он обычно записывается в стек непосредственно. В остальных случаях программист должен разместить значение аргумента в памяти, а в стек записать 32-битный указатель на него. Таким образом, все параметры, передаваемые функции API, представляются 32-битными величинами.
3. Вызывающая программа загружает аргументы в стек последовательно, начиная с последнего, указанного в описании функции, и кончая первым. После загрузки всех аргументов программа вызывает функцию командой call.
4. За возвращение стека в исходное состояние после возврата из функции API отвечает сама вызываемая функция. Программисту заботиться о восстановлении указателя стека esp нет необходимости. Эта идея тоже пришла из реализаций Паскаля и прилично экономит на размере кода.
5. Вызываемая функция API гарантированно сохраняет регистры общего назначения ebp, esi, edi. Регистр eax, как правило, содержит возвращаемое значение. Состояние остальных регистров после возврата из функции API следует считать неопределенным (полный набор соглашений stdcall регламентирует также сохранение системных регистров ds и ss. Однако, для flat-модели памяти, используемой в win32, эти регистры значения не имеют.)
В применении к нашему примеру это означает следующее:
— аргументы мы должны передать через стек;
— сама фунция вызывается командой call;
— не «парим» себе мозги, задаваясь вопросом, «если мы сделали PUSH, то когда же нам сделать POP?», ибо правильный ответ — никогда. Об этом позаботится сама функция.

#13. И, напоследок, топик #13
Читая эту главу, вы написали свою первую программу для Windows на языке ассемблера. Если вы уже имеете хотя бы небольшой опыт программирования, то даже беглого прочтения этой главы будет достаточно, чтобы сказать: «да, теперь я знаю, как ЭТО делается на асме». Если же вы еще совсем молоды и зелены, то просто «тупо» выполните мои инструкции, а комментарии расцените как своего рода предварительные наброски тех тем, которые мы подробно будем рассматривать впоследствии.
Более того, это единственная глава, которая действительно необходима для обучения программированию под Windows на ассемблере. Как только программист узнает, как вызывать API, все остальное он станет способен делать самостоятельно, без учебников и подсказок. Потребуется только справочник Platform SDK, да знание двух языков: C и английского (оба — в объеме церковно-приходской школы).
И да пребудет с вами сила!

Assembler & win32 курс молодого бойца

Программирование на Ассемблере я начинал с Turbo Assembler (TASM) под MS-DOS, сейчас пишу на Flat Assembler (FASM) под Windows. Это очень удобный и мощный пакет для разработки, бесплатный для любого использования. Написан полностью на самом себе, исходники прилагаются. Мне он нравится тем, что позволяет хранить код и описания ресурсов в одном ASM-файле, поддерживает макросы, генерит чистый машинный код без всякой незаявленной самодеятельности, не требует лишней рутинной работы типа прописывания каждой задействованной функции в секцию импорта и еще множество приятных мелочей, облегчающих жизнь программисту. Единственным недостатком является отсутствие достаточного количества готовых исходников, например по сравнению с тем же MASM’ом, а портирование исходников с других платформ на FASM иногда вызывает затруднения. Но на мой взгляд портирование, в отличие от копирования, помогает гораздо лучше изучить язык. Несколько исходников-примеров есть в самом дистрибутиве FASM, еще несколько примеров можно скачать с офсайта или поискать в Интернете. Ответы на многие возникающие вопросы можно найти на официальном форуме FASM. Форум англоязычный, но на нем немало наших соотечественников. К новичкам на форуме относятся хорошо и отвечают даже на самые глупые вопросы.

Для установки Flat Assembler скачайте дистрибутив с офсайта (около 800 килобайт). На момент публикации версия FASM 1.67.27, если ссылка изменится, то можете посмотреть обновление на странице загрузки. Там же можно скачать версии FASM для Linux, Unix и MS-DOS. Бесплатный add-on FASMARM к FASM для работы с ARM можно найти здесь, текущая версия FASMARM 1.12. Инсталлятора нет, программа устанавливается простым извлечением из архива в какое-нибудь удобное для вас место, например C:\FASM. Обязательно скачайте справочник Microsoft Win32 Programmer’s Reference, распакуйте его в папку с FASM’ом. Для удобства можно сделать вложенную папку \help.

Microsoft Win32 Programmer’s Reference

Техническую документацию по FASM на английском языке можно скачать с офсайта, на русском языке есть вот такие мануалы:

Основной мануал Flat Assembler 1.64

Руководство по препроцессору FASM

FASM 1.64: Руководство программиста

Для продвинутых программистов могу порекомендовать справочник Windows NT/2000 Native API Reference на английском языке:

Windows NT/2000 Native API Reference

Для общего развития можно почитать книги Ассемблер для процессоров Intel Pentium (автор Ю.С.Магда) и Ассемблер для DOS, Windows и Unix (автор С.В.Зубков), Ассемблер & Win32. Курс молодого бойца (автор и составитель Р.Аблязов), Intel Hex Opcodes And Mnemonics — общее описание ассемблерных команд Intel 80486, x86 Instruction Set Reference — перечень и описание команд x86 процессора.

Ассемблер для процессоров Intel Pentium

Ассемблер для DOS, Windows и Unix

Ассемблер & Win32. Курс молодого бойца

Учебник по основам языка Ассемблера

Учебник по языку Ассемблер в задачах и примерах

Intel Hex Opcodes And Mnemonics

x86 Instruction Set Reference

И напоследок две книги из категории «must have». Их, конечно, лучше иметь в бумажном варианте в качестве настольных справочников, но электронные версии тоже вполне подойдут. Книги залиты на файлообменник. Обе книги на русском языке, в хорошем качестве.

Соломон Д., Руссинович М. — «Внутреннее устройство Microsoft Windows 2000. Мастер-класс», формат файла: PDF, размер архива 34 Мб. Скачать

Соломон Д., Руссинович М. — «Внутреннее устройство Microsoft Windows: Windows Server 2003, Windows XP, and Windows 2000», формат файла: DjVu, размер архива 27 Мб. Скачать

При первом запуске FASM создаст файл настроек FASMW.INI, откройте его для редактирования в Блокноте. В конец файла надо будет добавить две новых секции. Сперва пропишите полный путь к Win32 Programmer’s Reference:

[Help]
path=C:\FASM\help\WIN32.HLP

Это же можно сделать и через меню редактора Help — Pick help file. Теперь, если все сделано правильно, достаточно установить в редакторе курсор на название функции API и нажать F1. Справочник сразу откроется на описании этой функции.

После этого надо установить необходимые переменные окружения и пути для подключаемых файлов. Например у меня прописаны вот такие:

[Environment]
include=»C:\FASM\INCLUDE»
music=»C:\FASM\KEYGEN\XM_FILES»
ufmod=»C:\FASM\INCLUDE\MUSIC»

Переменная include обязательная, остальные для удобства. Теперь при написании программ вместо абсолютных путей можно (и нужно) использовать относительные:

Список ресурсов для изучения Ассемблера

Доброго времени суток!
Некоторым программистам иногда приходит в голову мысль «а не изучить ли мне ассемблер?». Ведь на нем пишут самые (с некоторыми оговорками) маленькие и быстрые программы, да и охота ощутить вкус низкоуровневого программирования берет свое. Ну и для общего развития не повредит.
Мысль эта не обошла стороной и меня. Вдохновившись историей одного байта, я ринулся в бой…

… но оказалось, что найти материал по интересующей теме не так просто, как хотелось бы. Посему решено было создать на хабре пополняющийся пост-индекс статей/книг/мануалов/etc. об этом, несомненно, великом языке.
Под катом находится, собственно, список с краткими комментариями, разбитый по категориям.

UPD
В список начали добавляться ресурсы по программингу микроконтроллеров.

Для начала

• ru.wikipedia.org/wiki/Ассемблер — ассемблер (не тоже самое, что «язык ассемблера», хотя эти понятия почти слились) в википедии
• ru.wikipedia.org/wiki/Язык_ассемблера — язык ассемблера там же
• wasm.ru/article.php?article=onebyte — история одного байта
• bitfry.narod.ru/00.htm — дневники чайника, довольно простые и интересные уроки для начинающих
• www.scribd.com/doc/267365/A-Beginners-Course-In-Assembly-Language — книга об основах ассемблера на английском языке
• Programming from the Ground Up — несложная книга на английском языке. Рекомендация megabrain
• www.osinavi.ru/asm — учебник по Ассемблеру «для квалифицированных чайников»
• habrahabr.ru/blogs/asm — блог, в котором, надеюсь, будет много статей об ассемблере

Ресурсы

Книги

Для книг я выкладываю только названия, без ссылок (или с ссылкой на интернет-магазин), так как я не знаю отношения некоторых людей к скачиванию чьей-то интеллектуальной собственности. Кому надо — тот найдет, где скачать.

• kpnc.opennet.ru — архив книг Криса Касперски
• Галисеев Г. В. Ассемблер для Win 32. Самоучитель
• Зубков С. В. Ассемблер для DOS, Windows и UNIX
• Кип Ирвин. Язык ассемблера для процессоров Intel = Assembly Language for Intel-Based Computers
• Калашников О. А. Ассемблер? Это просто! Учимся программировать
• Крис Касперски. Искусство дизассемблирования
• Владислав Пирогов. Ассемблер для Windows
• Владислав Пирогов. Ассемблер и дизассемблирование
• Ричард Саймон. Microsoft Windows API Справочник системного программиста
• Фрунзе А. В. Микроконтроллеры? Это же просто!
• Юров В., Хорошенко С. Assembler: учебный курс
• Абель — Ассемблер. Язык и программирование для IBM PC
• Эндрю Таненбаум — «Архитектура компьютера» — рекомендация lefty
• Чарльз Петцольд — «Код» — рекомендация lefty
• Assembly Language Step-by-step: Programming with DOS and Linux
• Юрий Ревич «Практическое программирование микроконтроллеров Atmel AVR на языке ассемблера» — рекомендация Ryav
• Нортон П., Соухе Д. «Язык ассемблера для IBM PC» — рекомендация maotm
• Григорьев В. Л. «Микропроцессор i486. Архитектура и программирование.» — рекомендация Ghost_nsk
• Нортон П., Уилтон Р. «IBM PC и PS/2.руководство по программированию» — описана работа с прерываниями и простыми железками, рекомендация Ghost_nsk

Англоязычные ресурсы

Инструменты

• www.masm32.com — MASM32 SDK
• flatassembler.net — flat assembler (FASM)
• www.nasm.us — The Netwide Assembler (NASM)
• www.ollydbg.de — OllyDbg, отладчик для Windows
• www.hex-rays.com/products/ida/index.shtml — IDA — интерактивный дизассемблер и отладчик
• www.idapro.ru — русская страница IDA
• research.microsoft.com/en-us/projects/detours — Библиотека от Microsoft Research для инъекции Dll и перехвата управления на себя
• conus.info/gt — отладчик командной строки для выполнения простых отладочных задач

Программинг микроконтроллеров

• habrahabr.ru/blogs/controllers — тематический блог на хабре, с количеством постов несколько большим, чем в блоге по ассемблеру
• programmators.ru — сайт по контроллерам семейства PIC
• myrobot.ru/stepbystep — сайт роботостроения, по ссылке статьи о микроконтроллерах AVR
• www.123avr.com/07.htm — МК AVR
• easyelectronics.ru/category/avr-uchebnyj-kurs — AVR

Прочее

• zx.pk.ru — форум ZX Spectrum
• bbs.pediy.com — форум по reverse engineering на китайском языке (спасибо KollinZ). Чтобы можно было понять о чем речь, можно воспользоваться кнопкой «перевести» в хроме (спасибо за совет mexanism)
• old-dos.ru — крупнейший в Рунете архив старых программ

Заключение

Надеюсь эта статья будет полезна как новичкам, так и тем, кто ищет новых знаний. Если вы знаете какие-либо интересные ресурсы по теме, смело пишите в комментарии, пост создавался, чтобы пополняться.

Assembler & win32 курс молодого бойца

Программирование на ассемблере под Win32 воспринимается весьма не однозначно. Считается, что написание приложений слишком сложно для применения ассемблера. Собственно обсуждению того, насколько оправдана такая точка зрения, и посвящена данная статья.

Она не ставит своей целью обучение программированию под Win32 или обучение ассемблеру, я подразумеваю, что читатели имеют определённые знания в этих областях.

В отличие от программирования под DOS, где программы, написанные на языках высокого уровня (ЯВУ) были мало похожи на свои аналоги, написанные на ассемблере, приложения под Win32 имеют гораздо больше общего. В первую очередь, это связано с тем, что обращение к сервису операционной системы в Windows осуществляется посредством вызова функций, а не прерываний, что было характерно для DOS. Здесь нет передачи параметров в регистрах при обращении к сервисным функциям и, соответственно, нет и множества результирующих значений возвращаемых в регистрах общего назначения и регистре флагов. Следовательно, проще запомнить и использовать протоколы вызова функций системного сервиса. С другой стороны, в Win32 нельзя непосредственно работать с аппаратным уровнем, чем «грешили» программы для DOS. Вообще написание программ под Win32 стало значительно проще и это обусловлено следующими факторами:

• отсутствие startup кода, характерного для приложений и динамических библиотек написанных под Windows 3.x;
• гибкая система адресации к памяти: возможность обращаться к памяти через любой регистр общего назначения; «отсутствие» сегментных регистров;
• доступность больших объёмов виртуальной памяти;
• развитый сервис операционной системы, обилие функций, облегчающих разработку приложений;
• многообразие и доступность средств создания интерфейса с пользователем (диалоги, меню и т.п.).

Современный ассемблер, к которому относится и TASM 5.0 фирмы Borland International Inc., в свою очередь, развивал средства, которые ранее были характерны только для ЯВУ. К таким средствам можно отнести макроопределение вызова процедур, возможность введения шаблонов процедур (описание прототипов) и даже объектно-ориентированные расширения. Однако, ассемблер сохранил и такой прекрасный инструмент, как макроопределения вводимые пользователем, полноценного аналога которому нет ни в одном ЯВУ.

Все эти факторы позволяют рассматривать ассемблер, как самостоятельный инструмент для написания приложений под платформы Win32 (Windows NT и Windows 95). Как иллюстрацию данного положения, рассмотрим простой пример приложения, работающего с диалоговым окном.

Файл, содержащий текст приложения, dlg.asm

IDEAL
P586
RADIX 16
MODEL FLAT

%NOINCL
%NOLIST
include «winconst.inc» ; API Win32 consts
include «winptype.inc» ; API Win32 functions prototype
include «winprocs.inc» ; API Win32 function
include «resource.inc» ; resource consts

MAX_USER_NAME = 20
DataSeg
szAppName db ‘Demo 1’, 0
szHello db ‘Hello, ‘
szUser db MAX_USER_NAME dup (0)

CodeSeg
Start: call GetModuleHandleA, 0
call DialogBoxParamA, eax, IDD_DIALOG, 0, offset DlgProc, 0
cmp eax,IDOK
jne bye
call MessageBoxA, 0, offset szHello,
offset szAppName,
MB_OK or MB_ICONINFORMATION
bye: call ExitProcess, 0

public stdcall DlgProc
proc DlgProc stdcall
arg @@hDlg :dword, @@iMsg :dword, @@wPar :dword, @@lPar :dword
mov eax,[@@iMsg]
cmp eax,WM_INITDIALOG
je @@init
cmp eax,WM_COMMAND
jne @@ret_false

mov eax,[@@wPar]
cmp eax,IDCANCEL
je @@cancel
cmp eax,IDOK
jne @@ret_false

call GetDlgItemTextA, @@hDlg, >
offset szUser, MAX_USER_NAME
mov eax,IDOK

@@cancel: call EndDialog, @@hDlg, eax

@@ret_false: xor eax,eax
ret

@@init: call GetDlgItem, @@hDlg, IDR_NAME
call SetFocus, eax
jmp @@ret_false
endp DlgProc
end Start

Сразу после метки Start, программа обращается к функции API Win32 GetModuleHandle для получения handle данного модуля (данный параметр чаще именуют как handle of instance). Получив handle, мы вызываем диалог, созданный либо вручную, либо с помощью какой-либо программы построителя ресурсов. Далее программа проверяет результат работы диалогового окна. Если пользователь вышел из диалога посредством нажатия клавиши OK, то приложение запускает MessageBox с текстом приветствия.

Диалоговая процедура обрабатывает следующие сообщения. При инициализации диалога (WM_INITDIALOG) она просит Windows установить фокус на поле ввода имени пользователя. Сообщение WM_COMMAND обрабатывается в таком порядке: делается проверка на код нажатия клавиши. Если была нажата клавиша OK, то пользовательский ввод копируется в переменную szValue, если же была нажата клавиша Cancel, то копирования не производится. Но и в том и другом случае вызывается функция окончания диалога: EndDialog. Остальные сообщения в группе WM_COMMAND просто игнорируются, предоставляя Windows действовать по умолчанию.

Вы можете сравнить приведённую программу с аналогичной программой, написанной на ЯВУ, разница в написании будет незначительна. Очевидно те, кто писал приложения на ассемблере под Windows 3.x, отметят тот факт, что исчезла необходимость в сложном и громоздком startup коде. Теперь приложение выглядит более просто и естественно.

Написание динамических библиотек под Win32 также значительно упростилось, по сравнению с тем, как это делалось под Windows 3.x. Исчезла необходимость вставлять startup код, а использование четырёх событий инициализации/деинициализации на уровне процессов и потоков, кажется логичным.

Рассмотрим простой пример динамической библиотеки, в которой всего одна функция, преобразования целого числа в строку в шестнадцатеричной системе счисления.

Ideal
P586
Radix 16
Model flat
DLL_PROCESS_ATTACH

extrn GetVersion: proc

DataSeg
hInst dd 0
OSVer dw 0

CodeSeg
proc libEntry stdcall
arg @@hInst :dword, @@rsn :dword, @@rsrv :dword
cmp [@@rsn],DLL_PROCESS_ATTACH
jne @@1
call GetVersion
mov [OSVer],ax
mov eax,[@@hInst]
mov [hInst],eax

@@1: mov eax,1
ret
endP libEntry

public stdcall Hex2Str
proc Hex2Str stdcall
arg @@num :dword, @@str :dword
uses ebx
mov eax,[@@num]
mov ebx,[@@str]
mov ecx,7

@@1: mov edx,eax
shr eax,4
and edx,0F
cmp edx,0A
jae @@2
add edx,’0′
jmp @@3

@@3: mov [byte ebx + ecx],dl
dec ecx
jns @@1
mov [byte ebx + 8],0
ret
endp Hex2Str

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

• при проецировании библиотеки в адресное пространство процесса (DLL_PROCESS_ATTACH);
• при первом вызове библиотеки из потока (DLL_THREAD_ATTACH), например, с помощью функции LoadLibrary;
• при выгрузке библиотеки потоком (DLL_THREAD_DETACH);
• при выгрузке библиотеки из адресного пространства процесса (DLL_PROCESS_DETACH).

В нашем примере обрабатывается только первое из событий DLL_PROCESS_ATTACH. При обработке данного события библиотека запрашивает версию OS сохраняет её, а также свой handle of instance.

Библиотека содержит только одну экспортируемую функцию, которая собственно не требует пояснений. Вы, пожалуй, можете обратить внимание на то, как производится запись преобразованных значений. Интересна система адресации посредством двух регистров общего назначения: ebx + ecx, она позволяет нам использовать регистр ecx одновременно и как счётчик и как составную часть адреса.

Ideal
P586
Radix 16
Model flat

struc WndClassEx
cbSize dd 0
style dd 0
lpfnWndProc dd 0
cbClsExtra dd 0
cbWndExtra dd 0
hInstance dd 0
hIcon dd 0
hCursor dd 0
hbrBackground dd 0
lpszMenuName dd 0
lpsz > dd 0
hIconSm dd 0
ends WndClassEx

struc Point
left dd 0
top dd 0
right dd 0
bottom dd 0
ends Point

struc msgStruc
hwnd dd 0
message dd 0
wParam dd 0
lParam dd 0
time dd 0
pt Point <>
ends msgStruc

MyMenu = 0065
> = 9C41
> = 9C42
> = 9C43

CS_VREDRAW = 0001
CS_HREDRAW = 0002
> = 7F00
> = 7F00
COLOR_WINDOW = 5
WS_EX_WINDOWEDGE = 00000100
WS_EX_CLIENTEDGE = 00000200
WS_EX_OVERLAPPEDWINDOW = WS_EX_WINDOWEDGE OR WS_EX_CLIENTEDGE
WS_OVERLAPPED = 00000000
WS_CAPTION = 00C00000
WS_SYSMENU = 00080000
WS_THICKFRAME = 00040000
WS_MINIMIZEBOX = 00020000
WS_MAXIMIZEBOX = 00010000
WS_OVERLAPPEDWINDOW = WS_OVERLAPPED OR
WS_CAPTION OR
WS_SYSMENU OR
WS_THICKFRAME OR
WS_MINIMIZEBOX OR
WS_MAXIMIZEBOX
CW_USEDEFAULT = 80000000
SW_SHOW = 5
WM_COMMAND = 0111
WM_DESTROY = 0002
WM_CLOSE = 0010
MB_OK = 0

PROCTYPE ptGetModuleHandle stdcall
lpModuleName :dword

PROCTYPE ptLoadIcon stdcall
hInstance :dword,
lpIconName :dword

PROCTYPE ptLoadCursor stdcall
hInstance :dword,
lpCursorName :dword

PROCTYPE ptLoadMenu stdcall
hInstance :dword,
lpMenuName :dword

PROCTYPE ptRegister > stdcall
lpwcx :dword

PROCTYPE ptCreateWindowEx stdcall
dwExStyle :dword,
lp > :dword,
lpWindowName :dword,
dwStyle :dword,
x :dword,
y :dword,
nW > :dword,
nHeight :dword,
hWndParent :dword,
hMenu :dword,
hInstance :dword,
lpParam :dword

PROCTYPE ptShowWindow stdcall
hWnd :dword,
nCmdShow :dword

PROCTYPE ptUpdateWindow stdcall
hWnd :dword

PROCTYPE ptGetMessage stdcall
pMsg :dword,
hWnd :dword,
wMsgFilterMin :dword,
wMsgFilterMax :dword

PROCTYPE ptTranslateMessage stdcall
lpMsg :dword

PROCTYPE ptDispatchMessage stdcall
pmsg :dword

PROCTYPE ptSetMenu stdcall
hWnd :dword,
hMenu :dword

PROCTYPE ptPostQuitMessage stdcall
nExitCode :dword

PROCTYPE ptDefWindowProc stdcall
hWnd :dword,
Msg :dword,
wParam :dword,
lParam :dword

PROCTYPE ptSendMessage stdcall
hWnd :dword,
Msg :dword,
wParam :dword,
lParam :dword

PROCTYPE ptMessageBox stdcall
hWnd :dword,
lpText :dword,
lpCaption :dword,
uType :dword

PROCTYPE ptExitProcess stdcall
exitCode :dword

extrn GetModuleHandleA :ptGetModuleHandle
extrn LoadIconA :ptLoadIcon
extrn LoadCursorA :ptLoadCursor
extrn Register > :ptRegisterClassEx
extrn LoadMenuA :ptLoadMenu
extrn CreateWindowExA :ptCreateWindowEx
extrn ShowWindow :ptShowWindow
extrn UpdateWindow :ptUpdateWindow
extrn GetMessageA :ptGetMessage
extrn TranslateMessage :ptTranslateMessage
extrn DispatchMessageA :ptDispatchMessage
extrn SetMenu :ptSetMenu
extrn PostQuitMessage :ptPostQuitMessage
extrn DefWindowProcA :ptDefWindowProc
extrn SendMessageA :ptSendMessage
extrn MessageBoxA :ptMessageBox
extrn ExitProcess :ptExitProcess

UDataSeg
hInst dd ?
hWnd dd ?

IFNDEF VER1
hMenu dd ?
ENDIF

DataSeg
msg msgStruc <>
> db ‘Menu demo’, 0
wndTitle db ‘Demo program’, 0
msg_open_txt db ‘You selected open’, 0
msg_open_tlt db ‘Open box’, 0
msg_save_txt db ‘You selected save’, 0
msg_save_tlt db ‘Save box’, 0

CodeSeg
Start: call GetModuleHandleA, 0 ; не обязательно, но желательно
mov [hInst],eax

sub esp,SIZE Wnd > ; отведём место в стеке под структуру

mov [(WndClassEx esp).cbSize],SIZE WndClassEx
mov [(WndClassEx esp).style],CS_HREDRAW or CS_VREDRAW
mov [(WndClassEx esp).lpfnWndProc],offset WndProc
mov [(WndClassEx esp).cbWndExtra],0
mov [(WndClassEx esp).cbClsExtra],0
mov [(WndClassEx esp).hInstance],eax
call LoadIconA, 0, IDI_APPLICATION
mov [(WndClassEx esp).hIcon],eax
call LoadCursorA, 0, IDC_ARROW
mov [(WndClassEx esp).hCursor],eax
mov [(WndClassEx esp).hbrBackground],COLOR_WINDOW
IFDEF VER1
mov [(WndClassEx esp).lpszMenuName],MyMenu
ELSE
mov [(WndClassEx esp).lpszMenuName],0
ENDIF
mov [(WndClassEx esp).lpszClassName],offset classTitle
mov [(WndClassEx esp).hIconSm],0
call Register > esp ; зарегистрируем класс окна

add esp,SIZE Wnd > ; восстановим стек
; и создадим окно
IFNDEF VER2
call CreateWindowExA, WS_EX_OVERLAPPEDWINDOW, extended window style
offset classTitle, pointer to registered class name
offset wndTitle, pointer to window name
WS_OVERLAPPEDWINDOW, window style
CW_USEDEFAULT, horizontal position of window
CW_USEDEFAULT, vertical position of window
CW_USEDEFAULT, window width
CW_USEDEFAULT, window height
0, handle to parent or owner window
0, handle to menu, or child-window identifier
[hInst], handle to application instance
0 ; pointer to window-creation data
ELSE
call LoadMenu, hInst, MyMenu
mov [hMenu],eax
call CreateWindowExA, WS_EX_OVERLAPPEDWINDOW, extended window style
offset classTitle, pointer to registered class name
offset wndTitle, pointer to window name
WS_OVERLAPPEDWINDOW, window style
CW_USEDEFAULT, horizontal position of window
CW_USEDEFAULT, vertical position of window
CW_USEDEFAULT, window width
CW_USEDEFAULT, window height
0, handle to parent or owner window
eax, handle to menu, or child-window identifier
[hInst], handle to application instance
0 ; pointer to window-creation data
ENDIF
mov [hWnd],eax
call ShowWindow, eax, SW_SHOW ; show window
call UpdateWindow, [hWnd] ; redraw window

IFDEF VER3
call LoadMenuA, [hInst], MyMenu
mov [hMenu],eax
call SetMenu, [hWnd], eax
ENDIF

msg_loop:
call GetMessageA, offset msg, 0, 0, 0
or ax,ax
jz exit
call TranslateMessage, offset msg
call DispatchMessageA, offset msg
jmp msg_loop
exit: call ExitProcess, 0

public stdcall WndProc
proc WndProc stdcall
arg @@hwnd: dword, @@msg: dword, @@wPar: dword, @@lPar: dword
mov eax,[@@msg]
cmp eax,WM_COMMAND
je @@command
cmp eax,WM_DESTROY
jne @@default
call PostQuitMessage, 0
xor eax,eax
jmp @@ret

@@default:
call DefWindowProcA, [@@hwnd], [@@msg], [@@wPar], [@@lPar]

@@command:
mov eax,[@@wPar]
cmp eax,ID_OPEN
je @@open
cmp eax,ID_SAVE
je @@save
call SendMessageA, [@@hwnd], WM_CLOSE, 0, 0
xor eax,eax
jmp @@ret

@@open: mov eax, offset msg_open_txt
mov edx, offset msg_open_tlt
jmp @@mess

@@save: mov eax, offset msg_save_txt
mov edx, offset msg_save_tlt

@@mess: call MessageBoxA, 0, eax, edx, MB_OK
xor eax,eax
jmp @@ret
endp WndProc
end Start

Здесь мне хотелось в первую очередь продемонстрировать использование прототипов функций API Win32. Конечно их (а также описание констант и структур из API Win32) следует вынести в отдельные подключаемые файлы, поскольку, скорее всего Вы будете использовать их и в других программах. Описание прототипов функций обеспечивает строгий контроль со стороны компилятора за количеством и типом параметров, передаваемых в функции. Это существенно облегчает жизнь программисту, позволяя избежать ошибок времени исполнения, тем более, что число параметров в некоторых функциях API Win32 весьма значительно.

Существо данной программы заключается в демонстрации вариантов работы с оконным меню. Программу можно откомпилировать в трёх вариантах (версиях), указывая компилятору, ключи VER2 или VER3 (по умолчанию используется ключ VER1). В первом варианте программы меню определяется на уровне класса окна, и все окна данного класса будут иметь аналогичное меню. Во втором варианте, меню определяется при создании окна, как параметр функции CreateWindowEx. Класс окна не имеет меню и в данном случае, каждое окно этого класса может иметь своё собственное меню. Наконец, в третьем варианте, меню загружается после создания окна. Данный вариант показывает, как можно связать меню с уже созданным окном.

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

Представляет определённый интерес использование стековых фреймов и заполнение структур в стеке посредством регистра указателя стека (esp). Именно это продемонстрировано при заполнении структуры WndClassEx. Выделение места в стеке (фрейма) делается простым перемещением esp:

Теперь мы можем обращаться к выделенной памяти, используя всё тот же регистр указатель стека. При создании 16-битных приложений такой возможностью мы не обладали. Данный приём можно использовать внутри любой процедуры или даже произвольном месте программы. Накладные расходы на подобное выделение памяти минимальны, однако, следует учитывать, что размер стека ограничен, и размещать большие объёмы данных в стеке вряд ли целесообразно. Для этих целей лучше использовать «кучи» (heap) или виртуальную память (virtual memory).

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

Мне достаточно редко приходилось серьёзно заниматься разработкой макроопределений при программировании под DOS. В Win32 ситуация принципиально иная. Здесь грамотно написанные макроопределения способны не только облегчить чтение и восприятие программ, но и реально облегчить жизнь программистов. Дело в том, что в Win32 фрагменты кода часто повторяются, имея при этом не принципиальные отличия. Наиболее показательна, в этом смысле, оконная и/или диалоговая процедура. И в том и другом случае мы определяем вид сообщения и передаём управление тому участку кода, который отвечает за обработку полученного сообщения. Если в программе активно используются диалоговые окна, то аналогичные фрагменты кода сильно перегрузят программу, сделав её малопригодной для восприятия. Применение макроопределений в таких ситуациях более чем оправдано. В качестве основы для макроопределения, занимающегося диспетчеризацией поступающих сообщений на обработчиков, может послужить следующее описание.

macro MessageVector message1, message2:REST
IFNB
dd message1
dd offset @@&message1
@@VecCount = @@VecCount + 1
MessageVector message2
ENDIF
endm MessageVector

macro WndMessages VecName, message1, message2:REST
@@VecCount = 0
DataSeg
label @@&VecName dword
MessageVector message1, message2
@@&VecName&Cnt = @@VecCount
CodeSeg
mov ecx,@@&VecName&Cnt
mov eax,[@@msg]

@@&VecName&_1: dec ecx
js @@default
cmp eax,[dword ecx * 8 + offset @@&VecName]
jne @@&VecName&_1
jmp [dword ecx + offset @@&VecName + 4]

@@default: call DefWindowProcA, [@@hWnd], [@@msg], [@@wPar], [@@lPar]

@@ret_false: xor eax,eax
jmp @@ret

@@ret_true: mov eax,-1
dec eax
jmp @@ret
endm WndMessage

При написании процедуры окна Вы можете использовать макроопределение WndMessages, указав в списке параметров те сообщения, обработку которых намерены осуществить. Тогда процедура окна примет вид:

proc WndProc stdcall
arg @@hWnd: dword, @@msg: dword, @@wPar: dword, @@lPar: dword
WndMessages WndVector, WM_CREATE, WM_SIZE, WM_PAINT, WM_CLOSE, WM_DESTROY

@@WM_CREATE:
; здесь обрабатываем сообщение WM_CREATE

@@WM_SIZE:
; здесь обрабатываем сообщение WM_SIZE

@@WM_PAINT:
; здесь обрабатываем сообщение WM_PAINT

@@WM_CLOSE:
; здесь обрабатываем сообщение WM_CLOSE

@@WM_DESTROY:
; здесь обрабатываем сообщение WM_DESTROY

Обработку каждого сообщения можно завершить тремя способами:

• вернуть значение TRUE, для этого необходимо использовать переход на метку @@ret_true;
• вернуть значение FALSE, для этого необходимо использовать переход на метку @@ret_false;
• перейти на обработку по умолчанию, для этого необходимо сделать переход на метку @@default.

Отметьте, что все перечисленные метки определены в макро WndMessages и Вам не следует определять их заново в теле процедуры.

Теперь давайте разберёмся, что происходит при вызове макроопределения WndMessages. Вначале производится обнуление счётчика параметров самого макроопределения (число этих параметров может быть произвольным). Теперь в сегменте данных создадим метку с тем именем, которое передано в макроопределение в качестве первого параметра. Имя метки формируется путём конкатенации символов @@ и названия вектора. Достигается это за счёт использования оператора &. Например, если передать имя TestLabel, то название метки примет вид: @@TestLabel. Сразу за объявлением метки вызывается другое макроопределение MessageVector, в которое передаются все остальные параметры, которые должны быть ничем иным, как списком сообщений, подлежащих обработке в процедуре окна. Структура макроопределения MessageVector проста и бесхитростна. Она извлекает первый параметр и в ячейку памяти формата dword заносит код сообщения. В следующую ячейку памяти формата dword записывается адрес метки обработчика, имя которой формируется по описанному выше правилу. Счётчик сообщений увеличивается на единицу. Далее следует рекурсивный вызов с передачей ещё не зарегистрированных сообщений, и так продолжается до тех пор, пока список сообщений не будет исчерпан.

Сейчас в макроопределении WndMessage можно начинать обработку. Теперь существо обработки, скорее всего, будет понятно без дополнительных пояснений.

Обработка сообщений в Windows не является линейной, а, как правило, представляет собой иерархию. Например, сообщение WM_COMMAND может заключать в себе множество сообщений поступающих от меню и/или других управляющих элементов. Следовательно, данную методику можно с успехом применить и для других уровней каскада и даже несколько упростить её. Действительно, не в наших силах исправить код сообщений, поступающих в процедуру окна или диалога, но выбор последовательности констант, назначаемых пунктам меню или управляющим элементам (controls) остаётся за нами. В этом случае нет нужды в дополнительном поле, которое сохраняет код сообщения. Тогда каждый элемент вектора будет содержать только адрес обработчика, а найти нужный элемент весьма просто. Из полученной константы, пришедшей в сообщении, вычитается идентификатор первого пункта меню или первого управляющего элемента, это и будет номер нужного элемента вектора. Остаётся только сделать переход на обработчик.

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

Masm32 для чайников

Деление для чайников
Подскажите как правильно провести деление и потом вывести на экран (выражение y=(213 + x — c )/4).

Ошибки MASM32 — cannot open file : .\masm32\include\windows.inc
установил MASM32, прописал в патче путь, выдаёт ошибки при компиляции такого рода : Microsoft.

Ассемблер под Windows для чайников
Приветствую, помогите разобраться с 6-м уроком. Ни как не могу понять эту часть кода .

(MASM32 Editor) для новичков
Знающие люди помогите изучить асемблер много литературы но не могу понять его. Знаю только дельфи.

Компиляция программ для DOS в MASM32
проблема в том, что через командную строку код компилится но линкером link16, я пишу в radasm и.

Ассемблер для процессоров Intel Pentium
Зубков — Assembler для DOS, Windows и UNIX
Александр Крупник — Ассемблер. Самоучитель
Пирогов В. Ю. Assembler для Windows
Assembler & Win32. Курс молодого бойца
Изучаем ASM за 7 дней
Юров В. Ассемблер практикум.

Начни правильно, бери FASM. Синтаксис более лаконичный чем у остальных в частности и у masm32.