|
Часть 11
ПРИЛОЖЕНИЕ А. УТИЛИТЫ TURBO PASCAL.
Это приложение описывает пять автономных программ-утилит,
которые поставляются вместе с Турбо Паскалем: TPUMOVER, MАКЕ,
TOUCH, CREP, и BINOBJ.
Использование TPUMOVER - программы для работы с модулями.
Когда Вы пишете модули, то хотите их сделать доступными для
любой разрабатываемой Вами программы (В главе 4 "Модули и связанные
с ними возможности" объясняется что такое Модуль и говорится о том,
как создавать собственные модули.). Теперь мы покажем Вам, как
использовать TPUMOVER для удаления редко используемых модулей из
TURBO.TPL, и как поместить туда часто используемые модули.
Просмотр файлов - модулей.
Существует два типа файлов модулей: .TPU файлы и .TPL файлы.
Когда Вы компилируете модуль, Турбо Паскаль помещает результирующий
об'ектный код в .TPU (Turbo Pascal Unit - Модуль Турбо Паскаля)
файл, который всегда содержит только один модуль.
Файл .TPL (Turbo Pascal Library - Библиотека Турбо Паскаля)
может содержать много модулей. Например, все модули, находящиеся на
Вашей дистрибутивной дискете сосредоточены в файле TURBO.TPL. Файл
TURBO.TPL является библиотечным файлом из которого Турбо Паскаль
выбирает необходимые модули. Если в процессе компиляции какой-то
модуль в TURBO.TPL не найден, то Турбо Паскаль ищет файл
"имя_модуля.TPU", если же и этот файл не будет обнаружен, тогда
компиляция заканчивается с выдачей ошибки. Если Вы используете
опцию Build, Турбо Паскаль сначала ищет файл "имя_модуля.PAS" и
перекомпилирует его, формируя результирующий .TPU файл. Если Вы
используете опцию Make, Турбо Паскаль просматривает оба файла "имя_
модуля.PAS" и "имя_модуля.TPU", сравнивая их даты и время последней
модификации и перекомпилирует .PAS файл, если он модифицирован
после создания . TPU файла. Обычно, когда Вы пишете свой модуль, он
хранится в .TPU файле, а для его использования, Вы должны сообщить
Турбо Паскалю, где его искать. Если Вы используете интегрированную
среду, то должны специфицировать опцию Unit Directories (Справочник
модулей) в меню Oрtions/Directories (Опции/ Справочники).
(Turbo.TPL загружается из справочника Turbo в этом же меню). Если
Вы используете среду компилятора коммандной строки, то должны
применять опцию /U (Используйте опцию /Т для загрузки библиотеки
Турбо Паскаля из другого справочника в случае применения
компилятора командной строки).
Наверное Вы уже заметили, что можно использовать стандартные
модули Турбо Паскаля - без указания имени файла. Это происходит
потому, что эти модули хранятся в стандартном модуле Турбо Паскаля
- TURBO.TPL, который помещен на дистрибутивной дискете. Поскольку
стандартные модули находятся в этом файле, то любая программа может
использовать их без "знания" их местоположения.
Предположим у Вас есть модуль TOOLS.TPU, и Вы используете его
во многих различных программах. Хотя добавление модуля TOOLS в
библиотеку TURBO.TPL требует дополнительной оперативной памяти
(TURBO. TPL автоматически загружается компилятором в оперативную
память), наличие этого модуля в резидентной библиотеке делает
использование модуля TOOLS более доступным, из-за того, что модуль
находится в памяти, а не на диске.
В TURBO.TPL уже имеются пять стандартных модулей: System,
Overlay, Printer, Crt и Dos.
Использование TPUMOVER.
TPUMOVER - диалоговая программа, очень похожая на
интегрированную среду Турбо Паскаля. Она показывает Вам модули,
содержащиеся в двух различных файлах и позволяет Вам перебрасывать
модули между этими файлами или удалять их. TPUMOVER используется
главным образом для работы с файлами в TURBO.TPL, но также имеет и
другие полезные функции.
Заметьте, что TPUMOVER отображает содержимое файлов в двух
окнах. Вверху окна появляется имя файла, после чего отображается
список модулей в этом файле. Каждая строка окна представляет
информацию об одном модуле: имя модуля, размер кода, размер данных,
размер таблицы символов и имена модулей, используемых данным
модулем. Все размеры приводятся в байтах, а имена модулей усекаются
до семи символов. Если список используемых модулей слишком большой
и не вмещается в окно, то он оканчивается тремя точками, нажатие
клавиши F4 приводит к выдаче верхнего под-окна с именами других
модулей. И, наконец, в окне отведены две строки для отображения (в
байтах) текущего размера файла и количества свободного пространства
на диске, где этот файл расположен.
В любой момент времени, одно из окон является "активным". Об
этом свидетельствует двойная линия вокруг активного окна. Кроме
того, только в активном окне имеется подсвеченное поле, которое
появляется в списке модулей файла, это поле может перемещаться
вверх и вниз с использованием клавиш управления. Все вводимые
команды относятся только к активному окну, нажатие клавиши F6
переключает окна из активного состояния в пассивное и наоборот. Для
включения TPUMOVER наберите:
TPUMOVER файл1 файл2.
где файл1 и файл2 - .TPL или .TPU файлы. Расширение .TPU
предполагается по умолчанию, поэтому Вы должны явно добавлять .TPL
для .TPL файлов.
TPUMOVER загружается и отображает два окна - с файлом 1 в
левом окне и файлом 2 в правом окне. Заметьте, что если Вы укажете
только файл 1, правое окно по умолчанию будет иметь имя NОNAME.TPU.
Если Вы вообще не укажете файлов, TPUMOVER будет пытаться загрузить
TURBO.TPL (в левом окне, с пустым правом окном). Если этот файл не
будет обнаружен, TPUMOVER отобразить содержимое справочника всех
фалов с расширением .TPL.
Команды TPUMOVER.
Основные команды перечислены снизу экрана. Ниже приводится
краткое описание каждой из них:
- F1 - вызывает выдачу подсказки на экран.
- F2 - сохраняет текущий файл (файл связанный с активным
окном).
- F3 - позволяет выбрать новый файл для активного окна.
- F4 - отображает верхнее подокно, показывающее все вхождения
модулей в данный модуль. В главном окне показывается только первое
вхождение. Если снизу имеются три точки, то существуют еще
вхождения, для отображения которых необходимо нажать клавишу F4.
- F6 - позволяет Вам переключать окна, переводя их попеременно
из активного в пассивное состояние (и наоборот).
- + (знак плюс) маркирует модуль (для последующего копирования
или удаления). Вы можете одновременно маркировать несколько
модулей, Вы можете также аннулировать маркирование модуля повторным
нажатием клавиши (+).
- Ins - копирует все маркированные модули из активного окна в
пассивное.
- Del - удаляет все маркированные модули из активного окна.
- Esc - позволяет осуществить выход из TPUMOVER. Заметьте, что
эта операция не сохраняет автоматически все проделанные изменения,
Вы должны явно задавать F2 для сохранения модификаций перед выходом
из TPUMOVER.
Помещение модулей в TURBO.TPL.
Предположим Вы создали модуль Tools, который откомпилирован и
помещен в файл TOOLS.TPU. Вы хотите поместить этот модуль в
TURBO.TPL. Как это сделать? Прежде всего наберите команду:
TPUMOVER TURBO TOOLS
Эта команда вызовет отображение экрана TPUMOVER с TURBO.TPL в
левом окне (активное) и TOOLS.TPU в правом окне. Заметьте, что в
этом примере предполагается что TURBO.TPL и TOOLS.TPU находятся
оба в текущем справочнике, если это не так, Вам необходимо задать
соответствующий путь для каждого файла. Теперь выполните следующие
действия:
1. Нажмите F6 для активизации правого окна (TOOLS.TPU).
2. Нажмите + для маркирования TOOLS (единственный модуль в
правом окне).
3. Нажмите Ins для копирования TOOLS в TURBO.TPL.
4. Нажмите F6 для активизации левого окна (TURBO.TPL).
5. Нажмите F2 для сохранения изменений в TURBO.TPL на диске.
6. Нажмите Esc для выхода из TPUMOVER.
Модуль TOOLS теперь будет являться частью TURBO.TPL и будет
автоматически загружаться при использовании Турбо Паскаля.
Если Вы захотите добавить другие модули в TURBO.TPL, Вы можете
это сделать без выхода из TPUMOVER. После нажатия на F2, для
сохранения TURBO.TPL на диске, выполните следующие действия:
1. Нажмите клавишу F6 для активизации правого окна.
2. Нажмите клавишу F3 для выбора нового файла в правом окне.
3. Повторите шаги 2 - 5 предыдущего примера для маркирования
соответствующего модуля, копирования его в TURBO.TPL, активизации
левого окна, и сохранения TURBO.TPL на диске.
Вы можете повторять это столько раз, сколько необходимо для
построения Вашей библиотеки.
Удаление модулей из TURBO.TPL.
Предположим, что большинство из Ваших программ не используют
модули Overlay или Printer, поэтому давайте удалим их из TURBO.TPL,
для чего наберите команду:
TPUMOVER TURBO
Это вызовет загрузку TPUMOVER с TURBO.TPL в левом окне и
NONAME.TPU (имя по умолчанию) в правом. Левое окно активное, поэто-
му выполняем следующие действия:
- Используйте клавишу "стрелка вниз" для перемещения светового
поля на модуль Overlay.
- Нажмите + для выбора модуля Overlay.
- Нажмите клавишу Del для удаления модуля Overlay.
- Нажмите клавишу F2 для сохранения изменений в TURBO.TPL.
- Нажмите Esc для выхода из TPUMOVER.
Вы можете повторить процедуру для удаления модуля Printer.
Перемещение файлов между .TPL библиотеками.
Предположим, что Ваш товарищ написал ряд модулей и передал Вам
файл (MYSTUFF.TPL) в котором содержатся эти модули. Вы хотите
скопировать только модули GameStuff и RandStuff в TURBO.TPL. Как
это сделать? Ваша командая строка должна выглядеть следующим
образом:
TPUMOVER MYSTUFF.TPL TURBO.TPL
Это приведет к загрузке TPUMOVER с MYSTUFF.TPL в левом
(активном) окне и TURBO.TPL в правом окне. Далее, используйте
следующие команды:
- Используйте клавиши "стрелка вверх" и "стрелка вниз" для
перемещения светового поля на GaveStuff.
- Нажмите клавишу + для выбора GameStuff.
- Используйте клавиши "стрелка вверх" или "стрелка вниз" для
перемещения светового поля на RandStuff.
- Нажмите клавишу + для выбора RandStuff.
- Нажмите клавишу Ins для копирования GameStuff и RandStuff в
Turbo.TPL.
- Нажмите клавишу F6 для активизации окна с TURBO.TPL.
- Нажмите F2 для сохранения изменений в TURBO.TPL.
- Нажмите Esc для выхода из TPUMOVER.
Сокращения, употребляемые в командной строке.
Вы можете использовать несколько параметров командной строки,
которые позволяют Вам быстро манипулировать модулями. Параметры
имеют следующий формат.
TPUMOVER TURBO /параметр имя модуля
где параметром является или +, или -, или *.
Эти команды выполняют следующие функции без отображения в
окнах:
/+ добавляет названный модуль в TURBO.TPL
/- Удаляет названный модуль из TURBO.TPL
/* Извлекает (копирует) названный модуль из TURBO.TPL и
сохраняет его в файле с именем "имя модуля .TPU".
/? Отображает окно подсказки.
Автономная утилита Make.
Этот раздел содержит полную документацию по созданию
конфигурационных файлов и использованию программы Make.
Создание конфигурационных файлов.
Конфигурационный файл содержит определения и связи
необходимые для программы Make с целью поддержания Ваших программ
в актуальном состоянии. Вы можете создавать сколь угодно много
конфигурационных файлов с любыми именами. Если Вы не зададите
конфигурационный файл при запуске программы Make (используя опцию -
f), то в этом случае Make будет искать файл с именем по умолчанию
Makefile.
Вы можете создавать конфигурационный файл с помощью любого
текстового редактора, например, встроенного редактора Турбо-Паскаля.
Все определения и директивы заканчиваются символом возврата
каретки, если строка слишком длинна, то Вы можете ее продолжить на
следующей строке, поместив обратную наклонную черту (\) в качестве
последнего символа строки.
Пробелы и знаки табуляции используются для отделения смежных
идентификаторов и соблюдения синтаксических правил в командах.
Создание конфигурационного файла во многом напоминает
написание программы - с определениями, командами и директивами.
Ниже приводится список конструкций, разрешенных в конфигурационном
файле.
- комментарии.
- явные правила.
- неявные правила.
- макроопределения.
- директивы: включение файла, условное выполнение, обнаружение
ошибок, аннулирование макроопределения.
Давайте рассмотрим более детально каждую из этих конструкций.
Комментарии.
Комментарии начинаются с символа (#), все что следует за этим
символом до конца строки программой Make игнорируется. Комментарии
могут помещаться в любом месте. Обратная наклонная черта не
продолжает комментарий на следующую строку, вместо этого Вы должны
использовать символ (#) на каждой строке. Обратную наклонную черту
нельзя использовать в качестве символа продолжения комментария по
той причине, что если черта предшествует символу #, она не является
последним символом в строке, если же она стоит после знака #, она
является частью самого комментария.
Ниже приводится ряд примеров комментариев в конфигурационном
файле.
# makefile fo GETSTA .
# does compile project maintenance
# implicit rule
.asm.obj: #.OBJ файлы зависят от входных ASM файлов
tasm $*.asm,$*.obj: # команда для их создания
# unconditional rule
getstars.exe: всегда создается GETSTARS.EXE
tpc getstars /m
# dependencies
slib2.obj: slib2.asm # команда для его создания.
# Используется приведенное выше неявное правило
slib1.obj: slib1.asm # приведение в соответствие как
в явном правиле
tasm slib1.asm,slib1.obj:
# end of makefile
Явные правила.
Явные правила принимают форму:
target [target ... ]: [source source ... ]
[command]
[command]
...
где target - файл, который подлежит модифицированию, source -
файл от которого зависит target, а command - любая допустимая
команда MS-DOS (включая запуск .BAT файлов и выполнение .COM и .EXE
файлов).
Явные правила определяют один или более результирующих имен,
отсуствие или наличие нескольких исходных файлов, и необязательный
список команд, подлежащих выполнению. Имена результирующего и
исходного файлов, перечисленных в явных правилах, могут содержать
имя устройства и спецификации справочника, но они не могут
содержать шаблоны имен файлов (например *.OBJ).
Синтаксис команды является важным элементом, результирущий
файл должен начинаться с начала строки (колонка 1), и каждая
команда должна быть отделена по крайней мере, одним пробелом или
знаком табуляции. Как уже упоминалось ранее, обратная наклонная
черта может использоваться в качестве символа продолжения если
список исходных файлов или команд не умещается в одной строке.
И, наконец, как исходные файлы, так и команды не являются
обязательными параметрами, возможно существование явного правила,
содержащего только результирующий файл target [target..] с
последующим символом двоеточия(:).
Идея применения явного правила состоит в том, что
перечисленные команды будут создавать или модифицировать
результирующий файл target, обычно используя для этого исходные
файлы. Когда программа Make обнаруживает явное правило, то прежде
всего она проверяет наличие результирующего и исходных файлов. Если
результирующий файл существует, то его время и дата пследней
модификации сравниваются с временем и датой каждого исходного
файла. Если любой из исходных файлов модифицирован после создания
результирующего файла, список команд выполняется. В задании для
программы MAKE имя файла в левой части явного правила должно
встречаться не более одного раза.
Каждая командная строка в явном правиле должна начинаться с
раделителя (пробела). Make рассматривает все строки после явного
правила как часть списка команд вплоть до строки, начинающейся с
колонки 1 (без предшествующих разделителей) и до конца файла.
Пустые строки игнорируются.
Явное правило, не содержащее после себя командные строки
трактуется несколько иначе, нежели правило с командными строками.
- Если явное правило для результирующего файла имеет команды,
то формирование этого результирующего файла зависит только от
перечисленных в правиле файлов.
- Если явное правило не содержит команд, результирующий файл
зависит от файлов заданных в явном правиле, и он также зависит от
любого файла соответствующего неявному правилу для данного
результирующего файла.
Ниже представлен конфигурационный файл с примером явных
правил:
myutil.obj: myutil.asm
tasm myutil.asm,myutil.obj;
myapp.exe: myapp.pas myglobal.tpu myitils.tpu
tpc myapp /Tc:\tp5\bin
myglobal.tpu: myglobal.pas
tpc myglobal /Tc:\tp5\bin
myutils.tpu: myutils.pas myglobal.tpu myutil.obj
tpc myutils /Tc:\tp5\bin
- Первое явное правило означает, что MYUTIL.OBJ зависит от
MYUTIL.ASM, и что MYUTIL.OBJ создается выполнением заданной команды
TASM. (опция /Т плюс имя пути во всех этих примерах будет об'яснена
позже).
- Второе правило означает, что MYAPP.EXE зависит от MYAPP.PAS,
MYGLOBAL.TPU и MYUTIL.OBJ, и создается заданной командой TPC.
- Если Вы измените порядок следования правил таким образом,
что правило для формирования MYAPP.EXE будет стоять первым, Make
перекомпилирует ( или переассемблирует) только необходимые файлы.
Это произойдет потому, что Make без заданного результирующего файла
в командной строке будет пытаться выполнить первое явное правило,
которое будет обнаружено в конфигурационном файле.
- На практике, Вам следует опускать два последних явных
правила и просто добавлять директиву /М в команду в явном правиле
для MYAPP.EXE. Однако Вам необходимо добавить все зависимости
исходных файлов из MYGLOBAL.TPU и MYUTOL.TPU.
Неявные правила.
Make также позволяет Вам определять неявные правила, которые
являются обобщением явных правил. Ниже приводится пример
иллюстрирующий зависимость между этими двумя типами правил.
Рассмотрим явное правило из программы в предыдущем примере.
myutil.obj:myutil.asm
tasm myutil.asm.myutil.obj;
Это правило является общим, потому, что оно придерживается
общего принципа: .OBJ файл зависит от .ASM файла с тем же самым
именем и создаетя выполнением программы TASM (Турбо Ассемблер).
Действительно, Вы можете иметь конфигурационный файл с несколькими
(или даже несколькими десятками) явных правил, придерживающихся
этого формата.
Для переопределения явного правила неявным, Вы можете
сократить все явные правила одинаковой формы. В качестве неявного
правила, конструкция
.asm.obj:
tasm $*.asm, $*.obj;
Это правило означает, что "любой файл оканчивающийся на .OBJ
зависит от файла с тем же именем, с расширением .ASM, и .OBJ файл
создается с использованием команды tasm $*.ASM, $*.obj, где $*
представляет собой имя файла без расширения". (символ $* является
специальным макроопределением и рассматриваются в следующем
разделе).
Неявное правило имеет следующий синтаксис:
.source_extension.target_extension:
(command)
(command)
...
Заметьте, что команды не являются обязательными и должны
начинаться не с начала строки. Source_extension - расширение
исходного файла (которое должно начинаться с первой колонки)
представляет собой расширение любого файла удовлетворяющего
формату:
имя_файла.расширение_исходного файла
Аналогично, target_extension (расширение результирующего
файла) относится к файлу
"имя_файла.расширение_результирующего_файла", где "имя_файла"
одинаковое для исходного и результирующего файлов. Другими словами,
это неявное правило заменяет все явные правила имеющие формат
fname.target_extension:fname.source_extension
(command) (command)
...
для любого fname (имени файла).
Неявные правила используются в том случае, если для данного
результирующего файла не найдено явного правила или если явное
правило для этого файла не имеет команд.
Расширение файла используется для определения того, каким
неявным правилом пользоваться. Неявное правило применяется в том
случае, если найден файл с тем же именем, что и результирующий, но
с упомянутым расширением исходного файла. Для примера, предположим,
что у Вас есть конфигурационный файл (с именем Makefile) содержание
которого следующее:
.asm.obj:
tasm $*.asm,$*.obj;
Если у Вас есть подпрограмма на языке ассемблера с именем
RATIO.ASM, которую Вы хотите откомпилировать в RATIO.OBJ, Вы должны
использовать команду
make ratio.obj
Программа Make будет считать RATIO.OBJ результирующим файлом.
Поскольку для создания RATIO.OBJ явного правила нет, Make применяет
неявное правило и генерирует команду
tasm ratio.asm,ratio.obj;
которая конечно использует для создания RATIO.OBJ Турбо
Ассемблера.
Неявные правила также используются, если задано явное правило
без команд. Предположим, в начале Вашего конфигурационного файла, о
котором упоминались ранее, имеется следующее неявное правило.
.pas.tpu:
tpc $<
Тогда Вы можете переписать последние два явных правила
следущим образом:
myglobal.tpu: myglobal.pas myutils.tpu: myutils.pas
myglobal.tpu myutil.obj
Поскольку у Вас нет явной информации о том, как создавать эти
.TPU файлы, Make применяет неявное правило, определенное ранее.
Несколько неявных правил могут быть написаны с одинаковым
расширением результирующего файла, но в определенный момент времени
применяется только одно такое правило. Если для заданного
расширения результирующего файла существует более одного неявного
правила, то каждое правило проверяется в том порядке, как правила
располагаются в конфигурационном файле.
Программа Make использует первое неявное правило, обнаруженное
для файла с исходным расширением. Даже если команды этого правила
не выполняются, проверка других неявных правил не производится.
Все последующие строки неявного правила рассматриваются как
часть списка команд, вплоть до строки, которая начинается без
разделителей или до конца файла. Пустые строки игнорируются.
Синтаксис командной строки приводится далее в этом приложении.
В отличие от явных правил, программа Make в случае неявного
правила не знает полного имени файла. По этой причине Make может
задавать специальные макросы, позволяющие Вам включать имя файла,
которое строится по этому правилу (Детальная информация по
макроопределениям приводится в этом приложении). Вот несколько
примеров неявных правил:
.pas.exe:
tpc $<
.pas.tpu:
tpc $<
.asm.obj:
tasm $* /mx;
В предыдущем примере, в качестве результирующих файлов исполь-
зовались .EXE файлы, а в качестве исходных - .PAS файлы. В этом
примере имеется одна командная строка (синтаксис командной строки
рассматривается ниже в этом приложении).
Второе неявное правило создает .TPU файлы из .PAS файлов.
Последний пример указывает программе Make на ассемблирование
заданного файла из исходного .ASM файла, используя Турбо Ассемблер
TASM с опцией /mx.
Списки команд.
До сих пор Вы обсуждали явные и неявные правила, и то как они
используют списки команд. Теперь давайте рассмотрим сами команды и
опции для их установки.
Команды в списке команд должны иметь отступ - т.е. иметь или
знаки табуляции или предшествующие пробелы в строке. Команды
представляются в следующем формате:
[префикс...] тело команды
Каждая командая строка в списке команд состоит из
(необязательного) списка префиксов, с последующим телом команды.
Префиксы, разрешенные в команде, модифицируют интерпретацию
команды программой MAKE. Префикс представляет собой знак (@) или
(-), после чего следует число.
@ Отменяет отображение команды перед выполнением.
Отображения не происходит даже если не задана опция - S в
командной строке. Действие этого префикса распространяется только
на команду в которой он имеется.
- num устанавливает реакцию программы MAKE на коды выхода.
Если число (num) определено, MAKE прекратит обработку, только в том
случае, если статус выхода будет превышать заданное значение. В
этом примере, MAKE прекращает обработку только если статус выхода
больше 4-х:
-4 myprog sample.x
Если префикса - num не задано, MAKE проверяет статус выхода
для команды. Если статус не нулевой, MAKE останавливает выполнение
текущий результирующий файл.
(-) Если задан дефис без числа, MAKE вообще не будет проверять
статус выхода. Независимо от кода выхода, работа MAKE будет
продолжена.
Тело команды интерпретируется точно также, если бы Вы ввели
строку для COMMAND.COM, за исключением того, что не поддерживаются
переопределение устройств ввода/вывода и связь через каналы. MAKE
выполняет следующие встроенные команды, активизируя копию
COMMAND.COM для их выполнения:
BREAK CD CHDIR CLS COPY
MD MKDIR PATH PROMPT REN
RENAME SET TIME TYPE VER
VERIFY VOL
MAKE осуществляет поиск любого другого имени команды,
используя алгоритм поиска MS-DOS:
- Сначала осуществляется поиск в текущем справочнике, после
чего выполняется поиск в справочнике указанных в пути.
- В каждом справочнике сначала проверяется наличие файла с
расширением .COM, затем .EXE и наконец .BAT.
- Если обнаружен .BAT файл, активизируется копия COMMAND.COM
для выполнения.
Конечно, если в командной строке задано расширение файла, то
поиск файла осуществляется только с этим расширением. Следующая
команда вызовет выполнение программой COMMAND.COM команды смены
справочника
cd c:\include
Эта команда будет осуществлять поиск для выполнения, используя
полный поисковый алгоритм:
tpc myprog.pas /$B+, R+,I+
Эта команда будет осуществлять поиск только используя
расширение .COM:
myprog.com geo.xyz
Эта команда будет выполняться с использованием явного
определения имени файла и устройства.
c:\myprogs\fil.exe -r
Макросы.
Часто определенные команды, имена файлов или опции
используются в конфигурационном файле несколько раз. В приведенном
ранее примере этого приложения, все команды TPC использовали ключ /
TC:\tp5\bin, что означало, что файлы TPC.CFG и TURBO.TPL
расположены в справочнике C:\TP5\BIN. Предположим, Вы хотите
подключить другой справочник, что для этого необходимо сделать?
Вы можете изменить все опции /Т, вставив необходимое имя пути
файла. Или Вы можете определить макрос (макроопределение). Макрос -
- это имя , которое определяет некоторую строку символов (букв или
цифр). Макроопределение задает имя макроса и текст расширения. В
результате, если программа Make обнаружит имя, соответствующее
макросу, она заменит это имя на макро-расширение.
Предположим, Вы определили следующий макрос в самом начале
своего конфигурационного файла:
TYRBO = C:\tp5\bin
Вы определили макрос TURBO, который эквивалентен строке c:\tp\
bin. Теперь Вы можете переписать конфигурационный файл следующим
образом:
TURBO=c:\tp5\bin
myapp.exe: myapp.pas mygobal.tpu myutils.tpu
tpc myapp /T$(TURBO)
myurils.tpu: myutil.pas myglobal.tpu myytil.obj
tpc myutils /T$(TURBO)
myglobal.tpu: myglobal.pas
tpc myglobal; /T$(TURBO)
myutil.obj: myutil.asm
tasm myutil.asm,myutil.obj;
Везде где специфицирован справочник Turbo, Вы используете
вызов макроса $(TURBO). Когда Вы запускаете MAKE, $(TURBO)
заменяется расширением с:\TP5.BIN. В результате Вы имеете тот же
самый набор команд. Так в чем же здесь выигрыш? Ваш
конфигурационный файл стал более гибким. Изменив теперь первую
строку на
TURBO = c:\tp5\project
Вы измените все команды для использования конфигурационными и
библиотечными файлами другого справочника.
Если же Вы вынесете первую строку из конфигурационного файла и
будете вводить ее вместе с вызовом программы MAKE, используя при
этом опцию - D (определить), Вы можете задавать каждый раз новый
справочник:
make -DTURBO=c:\tp5\project
Это задает программе MAKE режим интерпретации TURBO как
макроса с расширением текста c:\tp5\project.
Макроопределения имеют форму
имя_макроса = расширение_текста.
где "имя_макроса" - строка, составленная из букв и цифр без
использования разделителей, хотя Вы можете иметь разделители между
именем макроса и знаком равенства (=). Расширение_текста - любая
произвольная строка, содержащая буквы, цифры, разделители и знаки
пунктуации, заканчивающаяся символом возврата каретки.
Если имя макроса уже было определено, то, или
макроопределением в конфигурационном файле, или опцией -D в
командной строке запуска программы MAKE, новое определение заменит
старое. Использование строчных или прописных букв в макросе
является существенным; это означает, что имена макросов turbo,
Turbo и TURBO будут считаться различными.
Макрос в конфигурационном файле активизируется следующим
образом:
$(имя макроса)
Скобки являются обязательными, даже если имя макроса состоит
из одного символа, исключая шесть специальных предопределенных
макросов о которых речь пойдет немного позднее. Эта конструкция - $
(имя макроса) - носит название макровызова.
Когда Make обнаруживает макровызов она заменяет макрос на
расширение. Если макрос не определен, Make заменяет его нулевой
строкой.
Макросы в макросах: Макросы не могут активизироваться в левой
части (имя макроса) макроопределения. Они могут использоваться в
правой части (расширение текста), но они не расширяются до тех пор,
пока определенный макрос не будет активизирован.
Другими словами, когда макровызов расширяется, любые макросы,
имеющиеся в его расширении также расширяются.
Макросы в правилах: Макросы в строках правила расширяются.
Макросы в директивах: Макровызовы расширяются в директивах !if
и !elif. Если макрос активизированный в директивах !if или !elif не
определен, он расширяется до значения 0 (False - Ложно).
Макросы в командах: Макровызовы в командах расширяются во
время выполнения команды.
Прграмма MAKE имеет несколько специальных предопределенных
встроенных макросов: $d, $*, $<, $:, $., и $&. Первый является
проверочным макросом, используемым в условных директивах !if и
!elif, другие являются макросами имени файла, используемого в явных
и неявных правилах. Различные макросы имен файлов работают
аналогичным образом, расширяясь до некоторых вариаций полного пути
имени создаваемого файла. Кроме того, строки окружения операционной
системы SET автоматически загружаются в качестве макросов, а макрос
_MAKE_ определяется как 1 (единица).
Макрос условного тестирования ($d).
Этот макрос расширяется в 1, если заданное имя макроса
определено, и в 0, если не определено. Содержание расширения текста
макроса не имеет значения. Этот специальный макрос расширяется
только в том случае, если заданы директивы !if и !elif. Например,
если Вы хотите изменить Ваш конфигурационный файл таким образом,
чтобы он использовал специфический справочник для Турбо Паскаля,
если он не задан, Вы можете поместить следующие строки в начале
своего конфигурационного файла:
!if !elif # Если TURBO не определен
TURBO=c:\tp5\bin # Определяем его на с:\tp5\bin
!endif
Если Вы активизируете MAKE в командной строке
make -DTURBO=c:\tp5\project
То TURBO будет определяться как c:\tp5\project. Однако, если Вы
активизируете только один MAKE:
make
то TURBO будет определен как c:\tp5\bin - это Ваш справочник
"по умолчанию".
Макрос имени основного файла ($*).
Этот макрос разрешается в командах для явного и неявного
правила. Макрос расширяется до имени создаваемого файла, исключая
всякое расширение:
Имя файла A:\P\TESTFILE.PAS
$* расширяется до A:\P\TESTFILE
Например, Вы можете модифицировать явное правило для
MYAPP.EXE:
myapp.exe: myapp.pas myglobal.tpu myutils.tpu
tpc $* /TS(TURBO)
Когда команда в этом правиле выполняется, макрос $* заменяется
на имя результирующего файла (без расширения) - MYAPP. Этот макрос
очень удобен для неявных правил. Например, неявное правило для
TPC может выглядеть следующим образом (допуская, что макрос TURBO
уже определен или будет определен):
.pas.exe:
tpc $* /TS(TURBO)
Макрос имени полного файла ($<).
Макрос имени полного файла ($<) также используется в командах
для явного и неявного правила. В явном правиле, $< расширяется до
полного имени результирующего файла (включая расширение), подобно
следующему примеру:
Имя файла A:\P\TESTFILE.PAS
$< расширяется до A:\P\TESTFILE.PAS
Например, правило
starlib.tpu: starlib.pas
copy $< \oldtpus
tpc $* /TS(TURBO)
будет копировать STARLIB.TPU в справочник \OLDTPUS перед
компиляцией STARLIB.PAS.
В неявном правиле, $< принимает значение имени файла плюс
расширение исходного файла. Например, предыдущее неявное правило
.asm.obj:
tasm $*.asm,$*.obj;
может быть переделано в
.asm.obj:
tasm $<,$*.obj;
Макрос имени пути файла ($:).
Этот макрос расширяется до имени пути (без имени файла),
например:
имя файла A:\P\TESTFILE.PAS
$. расширяется до A:\P\
Макрос имени файла и расширения ($.)
Этот макрос расширяется до имени файла с расширением,
например:
имя файла A:\P\TESTFILE.PAS
$. расширяется до TESTFILE.PAS
Макрос имени файла ($&).
Этот макрос расширяется только до имени файла, без пути или
расширения, например:
имя файла A:\P\TESTFILE.PAS
$& расширяется до TESRFILE
Директивы.
Версия программы MAKE, поставляемая с Турбо Паскалем позволяет
делать то, что не могут другие версии MAKE - применять условные
директивы, подобно директивам в Турбо Паскале. Вы можете
использовать эти директивы для подключения других конфигурационных
файлов, создания правил и команд для выдачи сообщений об ошибках, и
отмены макроопределений.
Директивы в конфигурационном файле начинаются с
восклицательного знака (!). Ниже приводится полный список директив
программы MAKE.
!include
!if
!else
!elif
!endif
!error
!undef
Директива включения файла (!include) определяет файл, который
будет подключаться в конфигурационный файл для последующей
интерпретации. Директива имеет следующий вид:
!include "имя файла"
или
!include <имя файла>
Эти директивы могут вкладываться до произвольной глубины
вложенности. Если директива подключения пытается подключить файл,
который уже находится в более верхнем уровне вложенности,
(зацикливание вложенности), внутренняя директива подключения
отвергается как ошибочная.
Как использовать эту директиву? Предположим Вы создали файл
PATH.MAC таким образом, что он содержит следующее:
!if !$d(TURBO)
TURBO=c:\tp5\bin
!endif
То в этом случае Вы можете использовать это условное
макроопределение в любом конфигурационном файле, применяя директиву
!include "PATH.MAC"
Когда программа MAKE обнаруживает директиву !include, она
открывает указанный файл и считывает содержимое, как будто бы этот
файл является частью конфигурационного файла.
Условные директива (!if, !elif, !else, и !endif) представляют
программисту определенную степень гибкости при конструировании
конфигурационных файлов. Правила и макросы могут в зависимости от
условий интерпретировать макроопределения командной строки
(используя опцию - D) таким образом, что будет разрешаться или
запрещаться отдельные команды конфигурационного файла.
Формат этих директив анологичен формату условных директив
Турбо Паскаля, но является более расширенным:
!if выражение
[строки]
!endif
!if выражение
[строки]
!else
[строки]
!endif
!if выражение
[строки]
!elif выражение
[строки]
!endif
Заметьте: [строки] могут быть следующими:
макроопределение
явное правило
неявное правило
директива подключения
группа if
директива ошибки
директива отмены определения.
Условные директивы формируют группу, включающую, по крайней
мере, директиву !if начинающую группу и директиву !endif,
заканчивающую группу.
- В состав группы может быть включена одна директива !else.
- Директивы !elif могут находиться между директивами !if и
!else.
- Правила, макросы, и другие директивы могут находиться между
различными условными директивами в любом количестве. Заметьте, что
полные правила, со своими командами, не могут расщепляться между
условными директивами.
- Группы условных директив могут быть вложенными до
произвольной глубины.
Любые правила, команды, и директивы должны быть полными в
границах отдельного исходного файла.
Любые директивы !if должны иметь соответствующие директивы
!endif в границах того же исходного файла. Поэтому следующий
подключаемый файл является некорректным, независимо от того, что он
содержит, потому что он не имеет соответствующей директивы !endif.
!if $(FILE_COUNT) > 5
некоторые правила
!else
другие пррравила
|