Глава 11 автоматизированная разработка программ с помощью утитлиты make


Содержание

Использование программы MAKE

При создании больших программ разработчиков подстерегает ошибка иного рода, которая проявляется в основном на стадии разработки, но может завести такой проект почти в глухой тупик. Такая ошибка возникает в тех случаях, когда при компиляции и компоновке программы один или несколько файлов ресурсов оказываются устаревшими по сравнению с соответствующими объектными файлами. Если такое случится, то полученная в результате исполняемая программа не будет функционировать так, как предусмотрено в последней реализации исходного кода. Наверно каждый, кто когда-либо участвовал в создании или сопровождении большого программного проекта, сталкивался с подобной проблемой. Чтобы помочь избежать обескураживающих ошибок подобного типа, большинство компиляторов С имеют в своем составе утилиту под названием МАКЕ, которая помогает синхронизировать файлы ресурсов и объектные файлы. (Точное название МАКЕ-утилиты, соответствующей вашему компилятору, может немного отличаться от МАКЕ, поэтому для большей уверенности проверьте себя по документации, прилагаемой к компилятору.)

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

Примеры, приведенные в этом разделе, совместимы с программами МАКЕ, поставляемыми вместе с Microsoft C/C++. На сегодняшний день, Microsoft-версия программы МАКЕ носит название NMAKE. Эти примеры будут также работать со многими другими широко распространенными МАКЕ-утилитами, а общие концепции, описанные здесь, применимы для всех МАКЕ-программ.

На заметку В последние годы программы МАКЕ стали очень изощренными. Примеры, приведенные здесь, иллюстрируют только основные возможности МАКЕ. Стоит подробнее изучить утилиту МАКЕ, поддерживаемую вашим компилятором. Она может содержать такие функциональные особенности, которые окажутся исключительно полезными в вашей среде разработки.

В своей работе утилита МАКЕ руководствуется сборочным файлом проекта или так называемым make-файлом , который содержит перечень выходных файлов (target files), зависимых файлов (dependent files) и команд. Для генерации выходного файла необходимо наличие файлов, от которых он зависит . Например, от Т.С зависит файл T.OBJ, поскольку Т.С необходим для создания T.OBJ. В процессе работы утилиты МАКЕ производится сравнение даты выходного файла с датой файла, от которого он зависит. (В данном случае под термином «дата» подразумевается и календарная дата, и время.) Если выходной файл старше, т.е. имеет более позднюю дату создания, чем файл, от которого он зависит (или если выходной файл вообще отсутствует), выполняется указанная последовательность команд. Если эта последовательность команд использует выходные файлы, при построении которых используются файлы, от которых они зависят, то при необходимости модифицируются также и эти используемые файлы [1] . Когда процесс МАКЕ завершится, все выходные файлы будут обновлены. Следовательно, в правильно построенном сборочном файле проекта все исходные файлы, которые требуют компиляции, автоматически компилируются и компонуются, образуя новый исполняемый модуль. Таким образом, данная утилита следит, чтобы все изменения в исходных файлах были отражены в соответствующих им объектных файлах.

В общем виде make-файл выглядит следующим образом:

Имя выходного файла должно начинаться в крайней левой позиции; за ним должно следовать двоеточие и список файлов, от которых он зависит. Последовательность команд, соответствующая каждому выходному файлу, должна предваряться как минимум одним пробелом или одним знаком табуляции. Перед комментариями должен стоять знак #, а сами комментарии могут следовать за списком зависимых файлов и/или последовательностью команд. Кроме того, их можно написать в отдельных строках. Спецификации выходных файлов должны отделяться друг от друга по крайней мере одной пустой строкой.

Самое главное при работе с make-файлом — учитывать следующую особенность: выполнение make-файла заканчивается сразу после того, как удастся обработать первую же цепочку зависимостей. Это означает, что необходимо разрабатывать свои make-файлы таким образом, чтобы зависимости составляли иерархическую структуру. Запомните, что ни одна зависимость не будет считаться успешно обработанной до тех пор, пока все подчиненные ей зависимости (т.е. зависимости более низкого уровня) не будут разрешены.

Чтобы лучше понять, как работает утилита МАКЕ, давайте рассмотрим очень простую программу. Она состоит из четырех файлов под названием TEST.H, TEST.C, TEST2.C и TEST3.C. Рис. 27.2 иллюстрирует данную ситуацию. (Чтобы лучше понять, о чем идет речь, введите каждую часть программы в указанные файлы.)

Если в своей работе вы используете Visual C++, следующий make-файл перекомпилирует данную программу после того, как вы внесете в них какие-нибудь изменения:

По умолчанию программа MAKE выполняет директивы, содержащиеся в файле под названием MAKEFILE. Однако, как правило, разработчики предпочитают применять другие имена для своих сборочных файлов проекта. Задать другое имя make-файла можно с помощью опции -f в командной строке. Например, если упоминавшийся ранее make-файл называется TEST, то, чтобы с помощью программы NMAKE фирмы Microsoft скомпилировать необходимые модули и создать исполняемый модуль, в командной строке следует набрать нечто подобное следующей строке:

(Эта команда подходит для программы NMAKE фирмы Microsoft. Если вы пользуетесь другой утилитой МАКЕ, возможно, придется использовать другое имя опции.)

Очень большое значение в сборочном файле проекта имеет очередность спецификаций, поскольку, как уже упоминалось ранее, МАКЕ прекращает выполнение содержащихся в файле директив сразу после того, как она полностью обработает первую зависимость [2] . Например, допустим, что ранее упоминавшийся make-файл был изменен, так что он стал выглядеть следующим образом:

Теперь работа будет выполнена неправильно, если файл TEST.H (или любой другой исходный файл) будет изменен. Это происходит потому, что последняя директива (которая создает новый TEST.EXE) больше не будет выполняться.

Использование макросов в MAKE

МАКЕ позволяет определять макросы в make-файле. Имена этих макросов являются просто метками-заполнителями информации, которая в действительности будет определена или в командной строке, или в макроопределении из make-файла. Общая форма определения макроса следующая:

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

После определения макроса его можно использовать в make-файле следующим образом:

Вместо каждого вхождения такого оператора подставляется его макроопределение. Например, в следующем make-файле макрос LIBFIL позволяет указать редактору связей библиотеку:

Многие МАКЕ-программы имеют дополнительные функциональные возможности, поэтому очень важно внимательно познакомиться с документацией, поставляемой вместе с компилятором.

[1] Все происходит как при вычислении сложной функции: сначала вычисляются аргументы, от которых она зависит, а если они, в свою очередь, являются сложными функциями, то при необходимости сначала вычисляются их аргументы и т.д.

[2] Т.е. как только построит первый зависимый файл.

Программирование: Разработка и отладка программ

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

Программа make особенно полезна при создании программ среднего размера. Данная программа не предназначена для решения задач, связанных с поддержкой нескольких версий исходного кода и с описанием больших программ (см. описание команды sccs ).

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

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

Команда make позволяет упростить процедуру повторной компиляции и компоновки программ. Связи между файлами достаточно определить только один раз. После этого команда make будет автоматически выполнять обновление.

С помощью команды make можно выполнить следующие задачи:

  • Сохранить инструкции по созданию большой программы в одном файле.
  • Задать макроопределения в файле описания команды make .
  • Определить способ создания файла с помощью команд оболочки, либо создать набор базовых типов файлов с помощью программы make .
  • Создать библиотеку.

Для работы команде make необходимы файл описания, список имен файлов, а также правила, по которым программа make должна создавать стандартные типы файлов, и временные метки всех системных файлов.

Для создания целевого файла, содержащего весь исполняемый код, программа make использует информацию из пользовательского файла описания ( целевого файла). На основе этой информации программа make определяет способ компоновки целевого файла, список файлов для компоновки и их связь с другими файлами. Файл описания содержит следующую информацию:

  • Имя целевого файла
  • Имена родительских файлов, на основе которых создается целевой файл
  • Команды создания целевого файла из родительских
  • Макроопределения в файле описания
  • Пользовательские правила компоновки целевых файлов

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

Если файлу описания присвоено имя makefile или Makefile , и этот файл расположен в целевом каталоге, то для обновления целевого файла и его родительских файлов введите следующую команду:

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

Если вы собираетесь хранить в одном каталоге несколько файлов описаний, присвойте им разные имена. Команда

присваивает файлу описания имя, указанное в параметре файл-описания .

Ниже приведен общий формат записи:

Элементы в квадратных скобках — необязательные. Имена целевых и родительских файлов — это символьные строки, которые могут содержать буквы, цифры, точки и символы косой черты. Команда make позволяет указывать символы подстановки, такие как * (звездочка) и ? (знак вопроса). Строка файла описания, содержащая имя целевого файла, называется строкой взаимосвязей . Строки, содержащие команды, должны начинаться с символа табуляции.

Примечание: в команде make символ $ (знак доллара) применяется для обозначения макроопределения. Не используйте этот символ в именах целевых или родительских файлов и в командах файла описания, если вы не применяете макроопределение make .

Комментарии в файле описания должны начинаться со знака фунта (#). Программа make игнорирует символ # и все следующие за ним символы. Кроме того, программа make игнорирует пустые строки.

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

Команда — это любая строка символов, кроме строк, начинающихся с символа # (знака фунта) или с символа новой строки. Символ # можно использовать в команде только в кавычках. Команды могут задаваться либо в строке взаимосвязей после двоеточия, либо в строках, начинающихся с символа табуляции, которые следуют непосредственно за строкой взаимосвязей.

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

Если для создания целевого файла будет применяться одна последовательность команд, укажите одно двоеточие после имени целевого файла в строке взаимосвязей. Например:

задается имя целевого файла ( test ), набор родительских файлов и набор команд для создания файла. Для целевого файла test может быть задан и другой список взаимосвязей.

Однако для этого имени нельзя будет указать другой список команд. Если будет изменен один из файлов, от которых зависит файл test , команда make создаст целевой файл test , выполнив команды из заданного списка.

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

Этот файл определяет два способа создания целевого файла с именем test . При изменении файлов из списка-взаимосвязей-1 команда make выполняет команды из списка-команд-1 . При изменении файлов из списка-взаимосвязей-2 команда make выполняет команды из списка-команд-2 . Во избежание конфликтов родительский файл не должен присутствовать ни в одном из списков взаимосвязей.

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

Для объединения двух строк файла в одну командную строку, укажите в конце первой строки файла символ \ (обратную косую черту). Команда make объединит две строки в одну и передаст их в одну и ту же оболочку.

Для создания вложенного вызова команды make в файле описания, укажите в командной строке этого файла макроопределение $(MAKE) .

Если указан флаг -n и было найдено макроопределение $(MAKE) , то новая копия команды make не будет выполнять никаких команд, за исключением другой команды макроопределения $(MAKE) . Эту возможность можно использовать для тестирования набора файлов описания программы. Введите команду:

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

Существует несколько способов подавления вывода команды make :

  • Вызовите команду make с флагом -s .
  • Задайте в строке взаимосвязей файла описания имя фиктивного целевого файла .SILENT . Поскольку целевой файл .SILENT реально не существует, он называется фиктивным. Если вместе с .SILENT указаны предварительные условия, то команда make не будет выводить на экран связанные с ним команды.
  • Укажите символ @ в первой позиции всех строк файла описания, которые программа make не должна отправлять на устройство вывода.

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

Для того чтобы предотвратить завершение программы make при возникновении ошибки, выполните одно из следующих действий:

  • Введите команду make с флагом -i .
  • Задайте в строке взаимосвязей файла описания имя фиктивного целевого файла .IGNORE . Поскольку целевой файл .IGNORE реально не существует, он называется фиктивным. Если вместе с .IGNORE указаны предварительные условия, то связанные с ними ошибки команда make будет игнорировать.
  • Укажите знак — (минус) в первой позиции всех строк файла описания, ошибки в которых должны игнорироваться.

Допустим, после компиляции и компоновки трех файлов на языке C ( x.c , y.c и z.c ) создается программа с именем prog . Общие объявления для файлов x.c и y.c заданы в файле с именем defs . В файле z.c эти объявления не используются. Ниже приведен пример файла описания, который создает программу prog :


Если присвоить этому файлу имя makefile , то достаточно будет ввести следующую команду:

При этом в случае изменения одного из исходных файлов ( x.c , y.c , z.c и defs ) программа prog будет обновлена.

Для упрощения файла описания можно воспользоваться внутренними правилами программы make . В соответствии с соглашениями о присвоении имен в файловой системе, команда make распознает три файла .c , соответствующие нужным файлам .o . С помощью команды cc -c эта программа может создать объектный файл из исходного.

С учетом этих правил файл описания примет следующий вид:

Внутренние правила программы make хранятся в файле, аналогичном файлам описания. Если указать флаг -r , программа make не будет использовать файл внутренних правил. В этом случае необходимо определить правила создания файлов в файле описания. Файл внутренних правил содержит список расширений имен файлов (таких как .o или .a ), которые распознаются командой make , и правила, указывающие команде make способ создания файла с одним расширением из файла с другим расширением. По умолчанию команда make распознает следующие расширения имен:

.a Архивная библиотека.
.C Исходный файл на языке C++.
.C\

Файл SCCS, содержащий исходный файл на языке C++.
.c Исходный файл на языке C.
.c

Файл системы управления исходным кодом (SCCS), содержащий исходный файл на языке C.
.f Исходный файл на языке FORTRAN.
.f

Файл SCCS, содержащий исходный файл на языке FORTRAN.
.h Заголовочный файл на языке C.
.h

Файл SCCS, содержащий заголовочный файл на языке C.
.l Исходная грамматика lex .
.l

Файл SCCS, содержащий исходную грамматику lex .
.o Объектный файл.
.s Исходный файл на ассемблере.
.s

Файл SCCS, содержащий исходный файл на ассемблере.
.sh Исходный файл команд оболочки.
.sh

Файл SCCS, содержащий исходный файл команд оболочки.
.y Исходная грамматика yacc-c .
.y

Файл SCCS, содержащий исходную грамматику yacc-c .

Список расширений имен файлов аналогичен списку взаимосвязей в файле описания и следует за фиктивным именем целевого файла .SUFFIXES . Команда make просматривает список расширений имен файлов слева направо, поэтому последовательность записей существенна.

Программа make будет использовать первую же запись из списка, которая удовлетворяет следующим двум требованиям:

  • Запись совпадает с требованиями к расширению имени входного или выходного файла для текущих целевого файла и файла зависимостей.
  • С данной записью связано правило.

Из двух расширений имен файлов, определяемых правилом, программа make создает имя правила. Например, имя правила для преобразования файла .c в файл .o — .c.o .

Для того чтобы добавить в список другие расширения имен файлов, добавьте в файл описания запись для фиктивного целевого имени .SUFFIXES . Если задать в файле описания строку .SUFFIXES без расширений имен файлов, команда make сотрет текущий список. Для изменения порядка имен в списке, сотрите текущий список, а затем укажите в строке .SUFFIXES новый набор значений.

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

В программе make существует набор правил с одним расширением, позволяющий создавать из исходного файла целевой файл без расширения (например, командный файл). Существуют также правила, в соответствии с которыми программа make создает объектные файлы с именами без расширений из следующих исходных файлов:

.C: Из исходного файла на языке C++.
.C\

:

Из исходного файла SCCS на языке C++.
.c: Из исходного файла на языке C.
.c

:

Из исходного файла SCCS на языке C.
.sh: Из файла команд оболочки.
.sh

:

Из файла SCCS, содержащего команды оболочки.

Например, если все исходные файлы программы cat находятся в текущем каталоге, то команда

создаст исполняемый файл.

С помощью команды make можно создавать библиотеки и библиотечные файлы. Файлы с расширением .a рассматриваются программой make как библиотечные файлы. Существуют следующие внутренние правила преобразования исходных файлов в библиотечные файлы:

.C.a Исходный файл C++ в архивный.
.C\

.a

Исходный файл C++ SCCS в архивный.
.c.a Исходный файл C в архивный.
.c

.a

Исходный файл C SCCS в архивный.
.s

.a

Исходный ассемблерный файл SCCS в архивный.
.f.a Исходный файл на Фортране в архивный.
.f

.a

Исходный файл SCCS на Фортране в архивный.

Программа make использует макроопределения из файла правил. Для изменения этих макроопределений укажите новые определения в командной строке или в файле. Программа make применяет следующие имена макроопределений для компиляторов, которые она поддерживает:

AS Для Ассемблера.
CC Для компилятора C.
CCC Для компилятора C++.
YACC Для команды yacc .
LEX Для команды lex .

Программа make применяет для поддерживаемых компиляторов следующие макроопределения:

CFLAGS Для флагов компилятора C.
CCFLAGS Для флагов компилятора C++.
YFLAGS Для флагов команды yacc .
LFLAGS Для флагов команды lex .

указывает программе make , что вместо обычного компилятора C необходимо вызвать программу NEWCC . Аналогично, команда

указывает команде make , что объектный код, созданный компилятором C, должен быть оптимизирован.

Внутренние правила команды make хранятся в файле /usr/ccs/lib/make.cfg .

Если при создании целевого файла команда make не может найти в файле описания необходимые команды или внутренние правила, она применяет указанные в файле команды по умолчанию. Команды, которые команда make будет выполнять в этом случае, перечисляются после целевого имени .DEFAULT :

Поскольку целевой файл .DEFAULT реально не существует, он называется фиктивным . Фиктивный целевой файл .DEFAULT применяется для задания функции исправления ошибок или общей процедуры, которая применяется для создания всех файлов, не определенных во внутренних правилах программы make .

С помощью директивы include в файл описания можно включать другие файлы. Эту директиву можно указывать в любой строке файла. После слова include указывается пробел или символ табуляции, за которым должно следовать имя файла, который будет включен командой make .

Примечание: В директиве include можно задать только одно имя файла.

указывают команде make , что для создания целевого файла необходимо использовать файлы temp , sample и файл описания.

Не следует использовать файлы описания с уровнем вложенности больше 16.

Макроопределение задает имя или метку, которая будет использоваться вместо нескольких других имен. Макроопределения позволяют кратко записывать длинные выражения. Для создания макроопределения:

  1. В начале новой строки введите имя макроопределения.
  2. После имени введите знак равенства (=).
  3. Справа от знака равенства (=) введите строку символов, которую должно заменять указанное имя.

До и после знака равенства (=) в макроопределении могут стоять пробелы; они ни на что не влияют. Перед знаком равенства не должно стоять двоеточие (:) или символ табуляции.

Ниже приведены примеры макроопределений:

Если задано имя макроопределения, но не указано его значение, то оно считается пустым.

После того как вы зададите макроопределение в файле описания, имя этого макроопределения можно использовать в командах файла описания, указывая перед ним символ $ (знак доллара). Если длина имени больше одного символа, его необходимо заключить в круглые () или фигурные <> скобки. Ниже приведены примеры использования макроопределений:

Последние два примера в этом списке эквивалентны.

Ниже приведен пример файла описания, в котором задаются и используются макроопределения:

С помощью этого файла описания программа make компонует и загружает три объектных файла ( x.o , y.o и z.o ) и библиотеку libc.a .

Макроопределение, которое вводится в командной строке, переопределяет макроопределение с тем же именем, заданное в файле описания. Следовательно, команда

загружает файлы и библиотеку lex (-11) .

Примечание: Если внутри макроопределения есть пробелы, его необходимо заключить в двойные кавычки (» «). В противном случае оболочка будет воспринимать эти пробелы не как часть макроопределения, а как разделители параметров.

Команда make поддерживает до 10 уровней вложенности макроопределений. Например, если задать последовательность макроопределений:

то значение выражения $($(macro2)) будет равно value1 .

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

может быть разным, если оно вызывается в разные моменты времени в процессе создания или удаления объектных файлов. Результат обработки такого макроопределения не совпадает с результатом вызова команды ls во время создания макроопределения OBJS .

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

$@ Имя текущего целевого файла.
$$@ Имя метки в строке взаимосвязей.
$? Имена устаревших файлов (т.е. тех, которые были изменены уже после создания целевого файла).
$ Имя измененного родительского файла, из-за которого требуется повторно создать целевой файл.
$* Имя текущего родительского файла без расширения.
$% Имя компонента архивной библиотеки.

Если в последовательности команд файла описания задано имя $@ , то перед тем, как передать очередную команду оболочке, программа make заменит это имя на имя текущего целевого файла. Программа make выполняет такую подстановку только в том случае, если при создании целевого файла она выполняет команды из файла описания.

Если в строке взаимосвязей файла описания указано имя $$@ , то программа make подставляет вместо него имя метки, которое стоит в этой строке слева от двоеточия. Например, строку взаимосвязей

программа make преобразует в

после обработки. Это макроопределение можно использовать для создания группы файлов, каждому из которых соответствует только один исходный файл. Например, для обновления каталога системных команд можно создать такой файл описания:


При выполнении программы make вместо $$(@F) будет подставлено $@ . Это макроопределение можно использовать для обновления каталога usr/include , когда файл описания находится в другом каталоге. Ниже приведен пример такого файла описания:

Этот файл описания создает файл в каталоге /usr/include , если был изменен соответствующий файл в текущем каталоге.

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

Если в последовательности команд файла описания задано макроопределение $ , то команда make подставляет вместо него имя файла, с которого начинается создание целевого файла. Это имя родительского файла, который был изменен после создания целевого файла, что и послужило причиной вызова команды make .

Если указать символ D или F , то вместо этой конструкции будет подставлено имя каталога или имя первого устаревшего файла, соответственно. Например, если имя первого устаревшего файла

то в результате подстановки, выполняемой командой make , он будет заменен на

Программа make выполняет эту подстановку только в том случае, если она выполняет команды из своих внутренних правил или из списка .DEFAULT .

Если в последовательности команд файла описания задано макроопределение $* , то команда make подставляет вместо него имя текущего родительского файла (без расширения), который применяется для создания целевого файла. Например, если команда make использует файл

то вместо $* будет подставлено имя test .

Если после звездочки (*) указать букву D или F , то будет подставляться имя каталога или имя текущего файла, соответственно.

Допустим, что для создания целевого файла программа make использует несколько файлов (заданных в файле описания или во внутренних правилах). В каждый момент времени применяется только один из этих файлов (он называется текущим). Если этот текущий файл

то результат подстановки, выполняемой командой make , будет выглядеть так:

Программа make выполняет эту подстановку только в том случае, если она выполняет команды из своих внутренних правил или из списка .DEFAULT , а не из файла описания.

Если в последовательности команд файла описания задано макроопределение $% , а целевой файл представляет собой компонент архивной библиотеки, то программа make подставляет имя библиотечного компонента. Например, если целевой файл — это

то команда make подставляет вместо $% имя компонента, то есть file.o .

Если в командах оболочки файла описания применяются макроопределения, то вы можете изменить текст, который будет подставлен вместо них командой make . Для изменения текста замещения после имени макроопределения нужно поставить двоеточие (:), а затем указать новый текст. Ниже приведен общий вид этой команды:

Когда команда make обнаруживает имя макроопределения, вместо строки1 она подставляет строку2 . Например, если файл описания содержит макроопределение

то с помощью макроопределения в команде файла описания можно заменить файл form.o на input.o :

Такое изменение макроопределения можно использовать при обновлении архивных библиотек. Дополнительная информация приведена в описании команды ar .

Программа make создает целевой файл поэтапно.

Программа make выполняет следующие действия:

  1. Находит имя целевого файла в файле описания или в команде вызова программы make
  2. Проверяет, существуют ли файлы, от которых зависит целевой файл, и не устарели ли они
  3. Проверяет, совпадает ли версия целевого файла с версией файлов, от которых он зависит.

Если целевой файл или один из родительских файлов устарел, программа make создает целевой файл с помощью одного из следующих наборов команд:

  • Команды из файла описания
  • Внутренние правила создания файла (если они применимы)
  • Команды по умолчанию из файла описания.

Если все файлы уже были обработаны программой make , то она выдаст сообщение о том, что ни один файл не изменен, и завершит свою работу. Если после последнего запуска команды make некоторые файлы были изменены, то команда make обновит только устаревшие файлы. Файлы, которые не были изменены, заново не создаются.

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

Команды и файлы SCCS применяются для управления доступом к файлу и отслеживания изменений, внесенных в файл. Файл SCCS — это любой текстовый файл, который применяется командами SCCS. При обработке файлов SCCS командами, отличными от SCCS, эти файлы могут быть повреждены. Дополнительная информация об SCCS приведена в разделе Глава 23, Система контроля исходного кода (SCCS).

У всех файлов SCCS есть префикс s. , отличающий их от обычных текстовых файлов. Программа make не распознает ссылки на префиксы имен файлов. Из-за этого в файле описания команды make нельзя ссылаться на файлы SCCS напрямую. Для представления файлов SCCS программа make использует расширение

(тильду). Следовательно, .c

.o — это имя правила, которое преобразует файл SCCS, содержащий исходный код на языке C, в объектный файл. Ниже приведено внутреннее представление этого правила:

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

Программа make распознает следующие расширения имен SCCS:

.C\

Исходный файл C++
.c

Исходный файл c
.y

Исходная грамматика yacc
.s

Исходный файл ассемблера
.sh

Файл команд оболочки
.h

Заголовочный файл
.f

Файл на Фортране
.l

Исходная грамматика lex

В программе make применяются следующие правила преобразования файлов SCCS:

Если в текущем каталоге хранится файл описания (файл с именем makefile или Makefile ), то команда make не будет искать файл описания в SCCS. Если в текущем каталоге нет файла описания, то команда make попытается найти в SCCS файл с именем s.makefile или s.Makefile . Если команда make найдет один из этих файлов, она вызовет команду get для создания файла описания на базе найденного файла с помощью SCCS. После того как SCCS создаст файл описания, он будет обработан командой make как обычный файл описания. Когда команда make завершит свою работу, она удалит из текущего каталога созданный файл описания.

Запустите программу make из каталога, в котором находится файл описания для создаваемого файла. Имя этого файла описания указывается в параметре файл-описания . Введите команду

в командной строке. Если файл описания называется makefile или Makefile , флаг -f указывать не нужно. Введите в командной строке вместе с командой make макроопределения, флаги, имена файлов описания и имена целевых файлов:

С помощью параметров, заданных в командной строке, программа make определяет, что ей нужно сделать. Во-первых, она просматривает все макроопределения, указанные в командной строке (т.е. записи, которые заключены в кавычки и содержат знак равенства), и выполняет макроподстановку. Если программа make обнаружит одно и то же макроопределение в командной строке и в файле описания, то она будет применять макроопределение, заданное в командной строке.

После этого программа make просматривает флаги. Для получения дополнительной информации просмотрите список флагов, поддерживаемых командой make .

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

При запуске программа make считывает текущие значения переменных среды и добавляет их в свои макроопределения. С помощью макроопределений MAKEFLAGS и MFLAGS пользователь может задать флаги, которые должны быть переданы команде make . Если заданы оба макроопределения, то MAKEFLAGS переопределяет значения MFLAGS . С флагами, заданными с помощью этих переменных, в команду make передаются все опции из командной строки. Если команда make вызывается рекурсивно с помощью макроопределения $(MAKE) в файле описания, то при каждом вызове make передает все флаги.

Программа make выполняет макроподстановку в следующем порядке:


    Считывает переменную среды MAKEFLAGS .

Если переменная среды MAKEFLAGS не задана, команда make проверяет значение переменной среды MFLAGS . Если для одной из этих переменных задано непустое значение, команда make рассматривает каждый символ этого значения как входной флаг. Эти флаги (кроме флагов -f , -p и -d , которые нельзя задать с помощью MAKEFLAGS и MFLAGS ), задают среду выполнения команды make .

  • Считывает и устанавливает флаги, заданные в командной строке. Эти флаги добавляются к флагам, установленным ранее с помощью переменной среды MAKEFLAGS или MFLAGS .
  • Считывает макроопределения, заданные в командной строке. Все другие макроопределения с таким же именем команда make будет игнорировать.
  • Считывает внутренние макроопределения.
  • Считывает значения переменных среды. Программа make рассматривает переменные среды как макроопределения и передает их в другие программы оболочки.
  • Ниже приведен файл описания для обновления программы make . Исходный код команды make включает несколько файлов на языке C и грамматику yacc .

    Обычно перед выполнением команды программа make отправляет ее на стандартное устройство вывода.

    Ниже показан пример вывода, полученного при вызове простой команды make из каталога, содержащего только исходный файл и файл описания:

    В файле описания не задано ни одного исходного файла или файла грамматики. Для их определения команда make использует свои правила расширения имен, а затем выполняет необходимые команды. Числа в последней строке приведенного примера — это результат выполнения команды size make . Поскольку в файле описания перед командой size стоит символ @, то вывод самой команды подавляется, а выводятся только ее результаты (размеры файлов).

    Вывод можно отправить на принтер или в файл, изменив макроопределение P в командной строке. Например:

    Самостоятельная работа 3: Разработка приложения с использованием математических функций и библиотек»


    6.3.1. Цель лабораторной работы

    Научиться подготавливать среду кросс-компиляции для конкретных автономных устройств.

    6.3.2. Введение

    Набор инструментов Cygwin

    Cygwin (произносится /sIgwIn/ ), набор свободных программных инструментов разработанных фирмой Cygnus Solutions, позволяющих превратить Microsoft Windows и Windows NT различных версий в некоторое подобие UNIX-системы. Изначально Cygwin задумывался как среда для переноса программ из POSIX-совместимых операционных систем (таких как GNU/Linux, BSD и UNIX) в Windows. Программы, портированные с помощью Cygwin, работают лучше всего в Windows NT, но в некоторых случаях годятся и Windows 9x. В настоящее время проект Cygwin разрабатывается сотрудниками Red Hat и другими программистами. Подобные функциональные возможности предлагает также и Microsoft в своем пакете Services for UNIX, включающем в себя подсистему Interix.

    Cygwin представляет собой библиотеку, которая реализует интерфейс прикладного программирования POSIX на основе системных вызовов Win32. Кроме того, Cygwin включает в себя инструменты разработки GNU для выполнения основных задач программирования, а также и некоторые прикладные программы, эквивалентные базовым программам UNIX.

    Замечание! Red Hat реализует библиотеку Cygwin под лицензией GNU GPL, с оговоркой, что разрешается ее свободное использование с любым свободным программным обеспечением с открытым кодом. (Для распространения коммерческих программ, использующих библиотеку Cygwin, необходимо приобретение лицензии у RedHat).

    В нашей задаче Cygwin используется как среда работы инструментов GNU Make, GCC И GNU ARM.

    GNU Compiler Collection (обычно используется сокращение GCC) — набор компиляторов для различных языков программирования, разработанный в рамках проекта GNU. GCC является свободным программным обеспечением, распространяется фондом свободного программного обеспечения (FSF) на условиях GNU GPL и GNU LGPL и является ключевым компонентом GNU toolchain. Он используется как стандартный компилятор для свободных Unix-подобных операционных систем, и в нескольких проприетарных операционных системах, в том числе Apple Mac OS X.

    Изначально названный GNU C Compiler, он поддерживал только язык C. Позднее, GCC был расширен для компиляции исходных кодов на таких языках программирования как C++, Objective-C, Java, Fortran, и Ada.

    GNU C состоит из двух частей — набора компиляторов с разных языков в абстрактное дерево, независимое от языка и процессора (такие компиляторы называются front ends) и набора «компиляторов», превращающих дерево в объектный код для разных процессоров (такие программы называются back ends). Такая схема позволяет делать код универсальнее: некоторый код, скомпилировавшийся для одного процессора, должен скомпилироваться и для остальных. Сейчас написаны front ends для самых разных языков программирования и back ends для всех основных процессоров, включая используемые в PDA (КПК — карманный персональный компьютер).

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

    Процесс компиляции кода основывается на GNU toolchain, базирующихся на back ends. GNU toolchain — набор необходимых пакетов программ для компиляции и генерации выполняемого кода из исходных текстов программ. Т.е. для каждой платформы необходим свой набор программ. В нашем случае в качестве toolchain выступает GNU ARM.

    GNU make — утилита, автоматизирующая процесс преобразования файлов из одной формы в другую. Чаще всего это компиляция исходного кода в объектные файлы и последующая компоновка в исполняемые файлы или библиотеки. В нашем случае она используется для создания объектных файлов для встроенных систем (байткода).

    GNU ARM

    GNU ARM — это набор пакетов программ для компиляции и генерации выполняемого кода (т.е. toolchain) для устройств на базе процессора ARM7. Существует множество альтернативных toolchain для устройств на базе процессора ARM7: официальный — CodeSourcery GNU Toolchain for ARM Processors, YAGARTO — Yet Another GNU ARM Toolchain, WinARM, devkitARM, HPGCC.

    Такое обилие ПО объясняется обилием применения процессоров ARM в технике. ARM Ltd. (название происходит от Advanced RISC Machines) (LSE: ARM, NYSE: ARMHY) — британская корпорация, являющаяся одним из крупнейших разработчиков и лицензиаров современной архитектуры 32-х разрядных RISC-процессоров, специально ориентированных для использования в портативных и мобильных устройствах (таких, как мобильные телефоны, персональные органайзеры, пр.). ARM не является производителем микропроцессоров как таковым, однако лицензирует собственную технологию третьим фирмам, таким как Atmel, Cirrus Logic, Intel, Marvell, NXP, Samsung, Qualcomm, Sony Ericsson, Texas Instruments которые, собственно, и воплощают ее в чипах.

    Технология ARM оказалась весьма успешной и в настоящее время является широкораспространённой микропроцессорной архитектурой для портативных цифровых устройств. ARM утверждает, что общий объем микропроцессоров, произведенных по их лицензии, превышает 2,5 миллиарда штук.

    В настоящее время известны несколько семейств микропроцессоров ARM — ARM7 (обычно с тактовой частотой около 50 МГц, предназначенные, например, для недорогих мобильных телефонов), ARM9 (с частотами порядка 200 МГц для продвинутых телефонов и карманных компьютеров) и ARM9E. Новейшим семейством является ARM11 с тактовой частотой до 1ГГц и расширенными мультимедийными возможностями.

    ОС nxtOSEK

    nxtOSEK — операционная система реального времени (Real-Time Operating System, RTOS) основанная на модификации ОС для встраиваемых систем OSEK Пакет nxtOSEK содержит модифицированную ОС TOPPERS OSEK RTOS, драйвера от LeJos NXJ — одного из альтернативных вариантов прошивки для NXT, кода, связывающего эти две части, и набора библиотек. В результате этот пакет при использовании на NXT предоставляет возможность выполнять на устройстве программы написанные на ANSI-С/С++ и скомпилированные с помощью toolchain GNU ARM и библиотек пакета. Начиная с версии 2.0 nxtOSEK совместим с интерфейсом «стандартной» прошивки. Это значит, что можно загружать несколько написанных для nxtOSEK программ во флэш память NXT на котором установлена «расширенная» прошивка LEGO. Использование этой прошивки позволяет запускать так же программы написанные на NXT-G, NXC/NBC.

    6.3.3. Инструкция по выполнению лабораторной работы

    6.3.1. Подготовка

    Установка Cygwin / GNU Make

    В первую очередь, что бы обеспечить многокомпонентную среду компиляции необходимо установить Cygwin / GNU Make. Для этого необходимо выполнить следующие шаги:

    Программы для автоматизации процессов. Часть 1

    Официальный сайт: www.orionsoftlab.com
    Размер: 814 КБ
    Цена: 15.00 $
    Назначение: планировщик заданий

    Многие действия нам приходится совершать регулярно. Наши будни — зарядка, завтрак, душ, поездка в офис. У многих людей весь рабочий день расписан по минутам. Вы можете случайно забыть о чем-либо или умышленно пропустить некоторые привычные действия.

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

    Active Task Manager – это утилита для автоматического выполнения разнообразных заданий, с помощью которой вы можете спланировать работу программ, требующих регулярного запуска. Суть работы утилиты сводится к ответу на два извечных вопроса – «что?» и «когда?».

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

    В качестве планируемых задач могут выступать исполняемые файлы EXE, COM, а также пакетные модули BAT. Кроме того, программа может выводить разнообразные предупреждения, осуществлять резервное копирование с помощью Active Backup Expert, а также выключать компьютер.

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

    Создание новой задачи осуществляется с помощью кнопки Add Task. При этом открывается довольно простой, понятный мастер. Сначала вам необходимо ввести название будущей задачи. Затем вы должны указать тип задачи – выполнение приложения, напоминание, резервное копирование или выключение компьютера. Напоминания могут представлять собой как текстовые сообщения, так и звуковые сигналы.

    В случае выбора запуска задачи, от вас потребуется выбрать путь к исполняемому модулю и указать ключи запуска. Далее, вы задаете периодичность выполнения задачи. Работа закончена.

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

    Резервное копирование работает только при наличии в системе модуля Active Backup Expert, и вы можете лишь указать тип создания копии данных – полная копия или инкрементальное дополнение.

    Под понятием «выключение компьютера» подразумевается завершение текущего сеанса, полное выключение рабочей станции, перезагрузка, а также приведение системы в такое состояние, при котором можно безопасно отключить компьютер от сети (электрической). Выключение ПК может быть осуществлено традиционным способом, а также в режиме принуждения (force).

    После завершения настройки программы вы будете видеть лишь маленький колокольчик в системном лотке. Если вы наведете на него курсор мыши – то увидите стандартное всплывающее окно (baloon) с информацией о статусе грядущих задач.

    Программа работает как стандартная служба Windows, которая, согласно информации с официального сайта, занимает лишь 180КБ в оперативной памяти. Active Task Manager – простая, компактная утилита для планирования процессов, серьезно придраться к которой за все время тестирования так и не получилось. Все запланированные вручную задачи выполнились именно так, как и описывалось в Справке.

    К содержанию Almeza MultiSet 3.1

    Официальный сайт: www.almeza.com
    Размер: 2299 КБ
    Цена: 300 руб.
    Назначение: автоматическая установка программного обеспечения

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

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

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

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

    Разработчики предупреждают, что пользователю не стоит спешить в режиме записи операций. Все действия должны выполняться с небольшой задержкой. Впрочем, законные опасения не подтвердились. MultiSet отлично запоминает операции, выполненные даже с помощью ловкого жонглирования мышью и клавиатурой. Минимально доступный для восприятия программой интервал между двумя пользовательскими операциями – 20мс в любом случае простым человеком (не суперменом) не достигается.

    После завершения инсталляции продукта, MultiSet запоминает все ваши действия и формирует пакет его автоматической установки. Когда вам снова потребуется установить приложение, достаточно будет выбрать его в списке и нажать кнопку «Установить».

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

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

    К содержанию AutoTask 2000 3.71

    Официальный сайт: www.cypressnet.com
    Размер: 3733 КБ
    Цена: 59.95 $
    Назначение: многофункциональный планировщик задач

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

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

    Одно из главных отличий данной программы от многих конкурентов заключается в возможности задания нескольких команд внутри одной задачи. Довольно часто на практике случаются ситуации, когда для достижения цели требуется осуществить сложную последовательность операций. Работая в ручном режиме, без специализированного программного обеспечения, вы выполняете первый этап, за ним второй, следом третий и так далее, до тех пор, пока не будет достигнута конечная цель. Используя AutoTask 2000, вы можете один раз прописать всю последовательность действий внутри отдельной задачи. Старт и остановка программ, отправка значений нажатых клавиш отдельным рабочим окнам, передача команд DDE – это лишь малая часть внушительного списка доступных опций во время описания задачи. Логические команды «пауза» и «подождать окончания выполнения приложения» позволяют осуществлять дополнительный контроль над вашими задачами.

    AutoTask 2000 позволяет запускать приложения, основываясь на выполнении определенных условий. Как только заданные в условии факторы приобретают значение «истина», происходит запуск программы. В качестве условий, критериев может выступать наличие или отсутствие какого-либо файла, состояние активности определенного приложения, наличие видимости рабочего окна приложения и многие другие примеры. Все вышесказанное позволяет говорить о наличие некого логического языка, встроенного в ваши задачи.

    AutoTask 2000 обладает гибким инструментарием планирования событий. Разумеется, вы можете использовать примитивные временные характеристики запуска задач – ежедневно, еженедельно, ежемесячно. Однако в программе доступны и более изощренные способы планирования. Например, вы можете назначать выполнение задач каждые 5 минут, каждый третий рабочий день недели, каждый второй Вторник месяца, два раза в год и так далее. Помимо задания временных интервалов, вы можете указывать сроки выполнения задач. Например, можно запланировать событие, которое будет выполняться каждые 5 минут с 8:00 до 17:00. Еще один пример – задача, выполняемая только по праздничным дням.

    Программа может запускаться как служба и работать в фоновом режиме.

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

    Официальный сайт: www.tfm.ro
    Размер: 483 КБ
    Цена: бесплатный
    Назначение: выключение компьютера при низкой загрузке процессора

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


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

    Пауза, в течение которой загрузка процессора не должна превышать определенное пользователем значение, по умолчанию равняется 600 секундам. Программа может выполнять два действия – выключать компьютер и перегружать систему. Активизация процесса происходит по нажатию кнопки Start.

    Программа постоянно находится в системном лотке, показывая во всплывающем окне текущий уровень загрузки процессора. CPUsage может конфликтовать с некоторыми резидентными модулями, например, с Shadow User. Кроме того, компьютер не выключится, если в системе присутствуют открытые, но не сохраненные документы.

    Официальный сайт: http://alex-co.org
    Размер: 1326 КБ
    Цена: бесплатный
    Назначение: создание базы установочных пакетов

    Наверняка вам знакома ситуация, когда во время переустановки системы приходится подолгу перебирать оптические диски на полках в поисках нужного программного обеспечения. Даже если его весомая часть находится на винчестерах, постоянно подключенных к системному блоку, все равно процесс массовой установки ПО надолго затягивается из-за массы лишних, скучных операций. А представьте себе, какова доля системного администратора, несущего тяжелый крест забот о сотнях рабочих станций, постоянно оформляющего закупки новых партий оргтехники? «Сегодня вы должны подготовить к работе все 10 компьютеров» — командует строгий начальник, «завтра бухгалтерия должна выдавать годовые отчеты». И никаких возражений. Вы – важный ответственный сотрудник, и вы обязаны выполнить свою часть работы.

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

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

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

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

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

    Программа довольно легко справляется с традиционными операциями последовательной установки продуктов. Однако более глубокие настройки программы, связанные с описанием сценариев установки, вызывают некоторое разочарование. Вместо того чтобы просто записывать в макросы последовательность действий пользователя (пример — Almeza MultiSet), от пользователя начинают требовать ручного ввода текста каждого сценария. Список заранее подготовленных шаблонных действий ограничен коротким списком и, конечно, не может включить в себя, например, ввод серийного номера. InstallBase – полезная, но не совсем логически выверенная программа.

    К содержанию Macro Recorder 4.1

    Официальный сайт: www.aldostools.com
    Размер: 377 КБ
    Цена: 8.95 $
    Назначение: запись и выполнение последовательности команд

    Macro Recorder – простая, компактная утилита, предназначенная для записи и воспроизведения макросов. Если вам приходится регулярно совершать за компьютером набор однообразных действий, то инструмент, способный запомнить всю последовательность, а позже воспроизвести ее, окажется полезным помощником в повседневной работе. В качестве примеров рутины можно упомянуть о запуске отдельных приложений, наборе текста, некоторых шаблонных операциях в работе с программным обеспечением. Macro Recorder позволяет автоматизировать все подобные действия.

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

    Для начала процедуры записи последовательности команд необходимо нажать клавишу Scroll Lock. По окончанию записи макроса, достаточно произвести повторное нажатие – работа окончена.

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

    Переключение между макросами осуществляется с помощью инструмента Marco List Manager. По каждому из элементов списка выводится краткая служебная информация.

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

    Запуск текущего макроса выполняется с помощью клавиши F12.

    Программа содержит несколько полезных инструментов, не относящихся напрямую к автоматизации процессов. Во-первых, вы можете переключаться между восьмью виртуальными рабочими столами с помощью клавиатурных сочетаний Ctrl+[1. 8]. Честно говоря, было весьма неожиданным увидеть в маленькой, скромной программе столь серьезный модуль, связанный с улучшением интерфейса операционной системы.

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

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

    Несмотря на миниатюрный размер дистрибутива и примитивный интерфейс, не отягощенный множеством панелей и меню, Macro Recorder является весьма мощным инструментом для решения разнообразных задач.

    К содержанию Macro Scheduler 8.1

    Официальный сайт: www.mjtnet.com
    Размер: 3218 КБ
    Цена: 59.95 $
    Назначение: автоматизация разнообразных действий

    Macro Scheduler позволяет создавать макросы для управления приложениями Windows, автоматизировать повседневные задачи, связав запуск сценариев с событиями, ярлыками или горячими клавишами. Программа позволяет выполнять отдельные наборы операций, а также целые комплексы задач путем запуска одной команды, например, с помощью щелчка кнопки мыши. Вы также можете запрограммировать систему так, чтобы она выполняла определенные операции по расписанию, в ваше отсутствие.

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

    MacroScript, язык сценариев Macro Scheduler, поддерживает подпрограммы и переменные типа «массив». Сценарии также могут содержать код VBScript, совмещающий в себе мощность и простоту использования движка Macro Scheduler с синтаксисом VBScript. Все это повышает гибкость работы и открывает возможность использования OLE/ActiveX в целях автоматизации.

    Macro Scheduler позволяет создавать сценарии и записывать макросы для автоматизации многих задач. Вы можете использовать более 200 разнообразных команд и стандартных конструкций программирования. Например, имеется возможность посылать сообщения о нажатиях клавиш и операциях мышью другим приложениям, ожидать открытия и закрытия окон. Кроме того, синтаксис позволяет осуществлять передачу фокуса определенному окну, выполнение операций в интернете, запуск программ и выполнение команд, чтение, запись, копирование, перемещение, удаление и выполнение файлов, управление приложениями через DDE.

    Разработчики утверждают, что для использования их продукта необязательно быть программистом. Хочется поставить данный тезис под сомнение. Программа, рассчитанная на неподготовленного пользователя, не будет содержать такое обилие возможностей, нацеленных исключительно на квалифицированного специалиста, имеющего опыт и навыки программирования. Продукты, рассчитанные на новичков, имеют удобные Мастера, под управлением которых, пройдя нескольких шагов, можно выполнить практически любую операцию, доступную с помощью программного продукта. Преимущества Macro Scheduler кроются именно в его мощи, гибкости, в возможности творить, созидать, используя макросы. Человеку, незнакомому с профессией программирования, все это не нужно – он выберет простую программу с красивым эргономичным интерфейсом и будет прав.

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

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

    Однако ничто не может отнять у Macro Schedule главного – это мощнейший инструмент автоматизации процессов.

    PartMaker: автоматизированная разработка управляющих программ для современного оборудования с ЧПУ

    Будущее за автоматизированным производством

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

    Увеличение парка станков с ЧПУ приводит к повышению требований к технологической подготовке производства, в том числе к качеству разработки управляющих программ (УП).

    Сегодня все основные разработчики САПР в составе своих программных комплексов предлагают модули для разработки УП для станков с ЧПУ. К достоинствам этих модулей можно отнести то, что, будучи интегрированными в системы автоматизированного проектирования и соответственно обеспечивая корректный обмен моделями между конструкторскими и технологическими модулями, они позволяют успешно разрабатывать УП для основных видов металлообрабатывающего оборудования со стандартными технологическими возможностями — для фрезерных, токарных и электроэрозионных станков. Недостатками же многих систем являются необходимость в высокой квалификации технологов для работы в CAM-системе, зачастую неинформативный интерфейс пользователя, необходимость выполнения многочисленных ручных операций, недостаточно развитые функции диагностики программ на предмет выявления ошибок, ограниченные возможности создания УП для наиболее современных или уникальных видов оборудования.

    Решить все эти проблемы взялись разработчики специализированного программного обеспечения (ПО). Например, для проверки и оптимизации УП инженерно-консалтинговая компания СОЛВЕР (SOLVER) предлагает применять программный комплекс Vericut фирмы CGTech (США), позволяющий сократить время обработки на 30-50% 1 .

    Кроме того, на рынке программных продуктов для производства предлагается ПО для автоматизированной подготовки УП, о котором мы расскажем подробнее.

    PartMaker: автоматизированная разработка УП

    Для автоматизированной разработки УП для металлообрабатывающего оборудования с ЧПУ фирма СОЛВЕР предлагает (впервые в России) использовать программный комплекс PartMaker от компании IMCS (США). Наряду с подготовкой УП для традиционной группы металлообрабатывающих станков (токарных, фрезерных и электроэрозионных) это современное и эффективное ПО дает возможность разрабатывать программы для наиболее современного и уникального оборудования, в том числе для станков-автоматов продольного точения (SwissType) и многоцелевых токарно-фрезерных центров.

    Модульная структура PartMaker позволяет приобретать лишь то ПО, которое является для предприятия актуальным на данный момент, и дооснащать программный комплекс новыми модулями по мере необходимости. В ПО входят пять основных модулей для разработки УП:

    • для станков-автоматов продольного точения — SwissCAM;

    • для токарно-фрезерных станков — Turn-Mill;

    • для токарных станков — Turn;

    • для фрезерных станков — Mill;

    • для электроэрозионных станков — Wire EDM.

    Удобный интерфейс пользователя: легкое освоение ПО, быстрая разработка УП

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

    Для программирования в PartMaker применяется современная методика визуального программирования. Детали со сложной обработкой разбиваются на группы плоскостей и поверхностей вращения, а при помощи картинок-подсказок выбирается нужный вид обработки. Стратегия обработки устанавливается пользователем. Например, можно выполнить полный цикл обработки одной поверхности, а затем перейти к обработке другой или же обработать все поверхности одним инструментом, заменить его следующим (согласно разработанной технологии) и снова обработать все поверхности.

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

    В PartMaker есть свой встроенный графический редактор для создания математических моделей обрабатываемых деталей с помощью графических примитивов (точек, линий, дуг, фасок и т.п.). Интерфейс пользователя разработан таким образом, чтобы максимально облегчить и ускорить процесс создания геометрии моделей. Этому способствуют и стандартные команды Windows: «Копировать», «Вырезать», «Вставить» и т.д. Предусмотрена возможность выполнения таких корректирующих операций, как сдвиг и поворот изображения. Кроме того, возможен импорт в PartMaker двумерных моделей в формате DXF и трехмерных моделей из любой системы CAD/CAM, включая Pro/Engineer, AutoCAD, SolidWorks, Unigraphics и др. При необходимости импортированные модели могут быть доработаны технологом, а затем возвращены обратно в систему конструирования.

    Разработка УП для механической обработки

    Программирование механической обработки в PartMaker ведется по технологическим переходам в зависимости от вида обработки (токарной или фрезерной), в том числе для токарно-фрезерных центров и автоматов продольного точения, и включает следующие возможности:

    • 2-осевое фрезерование с 3-осевым позиционированием инструмента, обработка карманов с любым количеством выступов, с учетом попутного или встречного фрезерования, а также с введением режима коррекции;

    • 4-осевое фрезерование — как непрерывное, так и с индексным поворотом детали;

    • фрезерование в системе линейных, цилиндрических или полярных координат;

    • гравирование вогнутых и выпуклых изображений и надписей на плоскостях и поверхностях вращения;

    • точение по внешнему и внутреннему диаметру согласно установленным пользователем параметрам черновой и чистовой обработки с выбором инструмента для каждой обработки в рамках одного цикла;

    • контурную токарную обработку канавочным инструментом с компенсацией ширины резца при расчете траектории движения инструмента;


    • сверление отверстий по циклам пользователя, включая операции центрования, растачивания, развертывания, фрезерования отверстий, создания фасок и нарезания резьбы метчиком;

    • точение канавок любой формы канавочным инструментом или по методу контурной обработки;

    • нарезание резьбы любого профиля;

    • программирование работы устройств подачи пруткового материала;

    • программирование передачи детали из шпинделя в противошпиндель;

    • отрезные операции с синхронизацией передачи детали из шпинделя в противошпиндель;

    • программирование выдвижения детали из шпинделя зажимным устройством или противошпинделем;

    • программирование передачи детали из шпинделя или из противошпинделя в зажимное устройство, расположенное в револьверной головке;

    • программирование операций перезахвата детали для обработки длинных деталей за счет выдвижения их через противошпиндель (для станков SwissType) и др.

    Диагностика УП: надежная защита от ошибок программирования

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

    Оптимизация УП: станки будут работать эффективнее

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

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

    Генерация УП

    Генерация УП в G-кодах осуществляется в PartMaker в полном соответствии с требованиями к конкретной системе ЧПУ используемого оборудования. Возможна разработка новых постпроцессоров или модификация уже имеющихся в предлагаемой библиотеке. Постпроцессоры, содержащиеся в ней, сопровождаются подробной информацией о возможностях станка и списком доступных операций обработки, что позволяет осуществлять программирование даже специалисту, незнакомому с особенностями оборудования. В библиотеку входят постпроцессоры для таких станков с ЧПУ, как Hardinge, Romi, Fadal, Okuma, Miyano, Haas, Daewoo, Hitachi Seiki, Mori Seiki, Mazak, Nakamura, Index, Eurotech, OmniTurn и др. Управляющие программы, разработанные в PartMaker для станков-автоматов продольного точения (таких как Citizen, Star, Tsugami, Hardinge и др.), содержат специализированные машинные коды синхронизации и ожидания.

    СОЛВЕР предлагает

    Специалисты СОЛВЕР, прошедшие обучение и сертификацию в компании IMCS в США, осуществляют поставку ПО и проводят обучение специалистов. Комплексно подходя к решению производственных проблем машиностроительных предприятий, фирма СОЛВЕР предлагает комплексную автоматизацию управления жизненным циклом изделий, решений конструкторских и технологических задач, а также оснащение предприятий высокоэффективным технологическим оборудованием, инструментом и оснасткой.

    1 Более подробно о программном комплексе Vericut см.: Как сохранить дорогостоящее оборудование и инструмент от поломки и сократить время подготовки нового изделия к производству? // САПР и графика. 2003. № 4. С. 6.

    GNU Make: управляйте процессом сборки своего программного обеспечения

    Оригинал: GNU Make: Manage Your Software Builds
    Автор: Mihalis Tsoukalos
    Дата публикации: 14 декабря 2020 г.
    Перевод: А.Панин
    Дата перевода: 30 января 2020 г.

    Компилируете программное обеспечение из исходного кода? Если это так, вам просто необходимо разобраться с Make-файлами.

    Для чего это нужно?

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

    Make является мощной системой для автоматизации процесса сборки программного обеспечения, разработанной Стюартом Фельдманом из Bell Labs в апреле 1976 года. GNU Make является стандартной реализацией Make, используемой в Linux и Mac OS X с множеством улучшений, которая, в том числе, необходима для компиляции ядра Linux. Ее основной задачей является автоматическое выявление модифицированных файлов исходного кода сложных приложений и исполнение команд, направленных на их повторную компиляцию.

    Для конфигурации make используются так называемые Make-файлы, которые позволяют сохранить группы команд для их последующего исполнения. Давайте рассмотрим содержимое Make-файла более подробно. Но перед этим вы должны принять к сведению тот факт, что GNU Make трактует отступы различных форматах по-разному, то есть, в представлении данного инструмента символ табуляции отличается от 4 или 8 последовательных символов пробела, следовательно, вам придется отнестись к форматированию рассматриваемых файлов с особым вниманием. Это особенно важно, так как каждая строка Make-файла с новой командой должна начинаться с символа табуляции.

    Make-файлы могут управлять процессом компиляции программного обеспечения благодаря наличию зависимостей, целей и правил. Правила сообщают GNU Make о том, когда, почему и как нужно исполнять заданные последовательности команд для генерации результирующих файлов на основе файлов исходного кода. Целями являются файлы, которые должны генерироваться с участием GNU Make, причем их имена располагаются слева от символов двоеточий в описаниях правил. Чаще всего каждое из правил имеет по одной цели; однако, в рамках одного правила допускается использование сразу нескольких целей. Зависимости располагаются справа от символов двоеточий в описаниях правил и указывают на то, какие файлы или другие цели могут инициировать исполнение команд, описанных в рамках правила, по причине модификаций.

    Я создал простой пример проекта, состоящий из четырех файлов исходного кода на языке C++ (вы можете загрузить исходный код проекта по ссылке www.linuxvoice.com/make23.tar.gz ). Этот архив содержит исходный код всех примеров, которые будут рассматриваться в данной статье. Файлы первого проекта расположены в директории simple . А это содержимое Make-файла этого проекта:

    Впоследствии вы можете переместиться в данную директорию и просто выполнить в ней команду make .

    Что же должно случиться?

    Теперь вы готовы к исполнению команды make . В случае исполнения команды make program вы должны увидеть аналогичный вывод:

    Приведенный в конце вывод утилиты ls позволяет убедиться в том, что все работает в точности так, как ожидалось и был получен желаемый результат.

    В случае исполнения команды make clean , позволяющей удалить сгенерированные файлы, должен быть получен аналогичный вывод:

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

    Реализация функции main() находится в файле исходного кода file1.cpp ; исходя из этого, последними компилируемыми файлами должны быть файлы file1.cpp и file1.h . Рассматриваемый проект является настолько простым, что каждый файл с расширением .cpp , за исключением файла file1.cpp , содержит реализацию лишь одного класса, описанного в рамках соответствующего файла с расширением .h , которая используется в рамках файла file1.cpp . Это обстоятельство обуславливает наличие зависимостей, которые описываются в рамках Make-файла.

    Важная информация: утилита Make не исследует содержимое файлов проекта для принятия решения о том, стоит ли осуществлять их повторную компиляцию — она всего лишь проверяет метки времени модификации этих файлов.

    Страница руководства утилиты make является источником полезной информации

    Отладка Make-файлов

    Make-файл может содержать синтаксические или логические ошибки, препятствующие его корректному функционированию. Наиболее полезным в плане отладки Make-файлов параметром утилиты make является параметр -n , который позволяет утилите просто выводить предназначенные для исполнения команды, но не исполнять их. Еще одним полезным параметром является параметр -d , который позволяет утилите выводить большой объем отладочной информации в процессе обычной обработки файла (хотя эта информация и может показаться интересной, она не всегда является полезной).

    Последним полезным параметром для отладки Make-файлов является параметр -p , который позволяет утилите make выводить содержимое базы данных, а именно, все правила и значения переменных, извлеченные из Make-файла, перед выполнением необходимых пользователю действий. Если вы хотите получить содержимое базы данных без обработки каких-либо правил и файлов, вам придется воспользоваться следующей командой:

    Это наглядная иллюстрация процесса обработки Make-файла, благодаря которой изящность технического решения, положенного в основу утилиты make, становится вполне очевидной

    Золотые правила разработки Make-файлов

    При разработке нового Make-файла в первую очередь следует описать все макросы (переменные), которые должны содержать полные пути ко всем используемым бинарным файлам системных команд. Это объясняется тем, что вы должны четко знать, какие команды исполняются в процессе сборки проекта, а не полагаться на наличие путей к директориям с необходимыми бинарными файлами системных команд в значении переменной окружения PATH .

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

    Не пытайтесь использовать утилиту GNU Make в рамках крупного проекта, если вы все еще изучаете ее возможности; попробуйте внедрить ее в проекты меньшего масштаба перед тем, как начинать работу с более сложными проектами. И наконец, уясните, что переменные полезны и могут существенно сэкономить ваше время, поэтому вам определенно стоит использовать их всегда, когда это возможно.

    А это пример практического использования сложного Make-файла в рамках программного проекта на языке C

    Различные полезные параметры утилиты make

    Если вам понадобится использовать Make-файл с именем, отличающимся от makefile или Makefile , вы можете воспользоваться параметром -f , передав после него имя этого файла. Параметры —file=ИМЯ_ФАЙЛА и —makefile=ИМЯ_ФАЙЛА полностью эквивалентны параметру -f . Параметр -k сообщает утилите make о необходимости осуществления сборки проекта так долго, как это возможно вне зависимости от обнаруженных ошибок. Параметр -t позволяет изменить метки времени модификации файлов вместо выполнения команд для сборки проекта; данный режим работы предназначен для симуляции полной пересборки проекта, что соответствующим образом отразится на результате последующего запуска утилиты make . Параметр —trace позволяет получить информацию о том, почему заданная цель требует пересборки проекта и какие команды будут выполнены в ходе этой операции. Параметр —trace также может использоваться для отладки файлов GNU Make.

    Вы можете без каких-либо сложностей прочитать или изменить значение существующей переменной окружения, объявив ее в рамках своего Make-файла. Если вы захотите отключить данный механизм, вы можете просто вызвать утилиту make , передав ей параметр -e .

    Пример вывода утилиты GNU Make с параметрами -n, -p и -d, которые используются главным образом для целей отладки Make-файлов

    Внутри Make-файла

    В первой строке рассматриваемого Make-файла описывается переменная RM , значением которой является полный путь к бинарному файлу утилиты rm , которая используется для удаления файлов. Для того, чтобы получить значение переменной RM и использовать его в рамках вашего Make-файла, вам придется использовать нотацию $(RM) . Мы поговорим о переменных более подробно в следующем разделе.

    В строке 3 описывается цель program , имеющая пять зависимостей, причем тремя ее зависимостями являются другие цели ( file2.o , file3.o и file4.o ), а остальными двумя — файл исходного кода на языке C++ и соответствующий заголовочный файл. Цель program имеет лишь одну ассоциированную команду, которая приведена в строке 4. Однако, как становится очевидно при рассмотрении цели clean (также из приведенного выше Make-файла), с любой целью может ассоциироваться более одной команды. В строках с 6 по 10 приведены инструкции по созданию объектных файлов на основе трех классов из файлов с исходным кодом на языке С++ с именами file2.cpp , file3.cpp и file4.cpp соответственно. Последнее правило предназначено для удаления всех временных файлов — использование цели clean является обычной практикой для Make-файлов, так как подобная цель, осуществляющая удаление всех временных файлов без какой-либо модификации основных файлов проекта, позволяет осуществлять полную пересборку проекта.

    Параметр -с компилятора из набора GCC используется главным образом для обработки файлов, которые не содержат реализации функции main() , так как он сообщает компилятору C++ из состава GCC о том, что нужно осуществлять лишь предварительную обработку, компиляцию и ассемблирование исходного кода. Параметр -o , используемый в рамках цели program сообщает g++ и gcc о необходимости сохранения результирующего бинарного файла под именем . Если вы попытаетесь задействуете цель, соответствующую файлам в актуальном состоянии, вы получите аналогичный вывод:

    Давайте рассмотрим более сложный пример проекта на языке C. Файлы этого проекта находятся в директории advanced архива, доступного по ссылке www.linuxvoice.com/make23.tar.gz . Make-файл позволяет скомпилировать исходный код проекта и сгенерировать исполняемый файл таким же образом, как и в предыдущем проекте, причем в данном случае также осуществляется копирование сгенерированного исполняемого файла в другую директорию с помощью цели install . Директория /tmp используется в качестве примера для того, чтобы вам не приходилось захламлять системные директории при тестировании примера, на самом же деле бинарные файлы обычно сохраняются в директории /usr/local/bin .

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

    Другие переменные используются для формирования имен новых файлов на основе различных параметров, таких, как дата и путь к резервной копии файла. Например:

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

    Рассматриваемый Make-файл содержит переменную, хранящую номер версии вашей программы. Значение этой переменной может изменяться либо с помощью параметра командной строки, либо путем редактирования самого Make-файла. Если вы желаете использовать значение переменной, отличное от объявленного в Make-файле (в данном случае это переменная VERSION), вы можете осуществить аналогичный вызов GNU Make:

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

    Переменные GNU Make также называются макросами. Следующее правило является реализацией цели make all :


    Это простая цель, которая позволяет создать программный продукт на основе его исходного кода путем передачи управления другому правилу ( executable ). Все программы проекта GNU должны в обязательном порядке поддерживать цель all .

    Следующее правило реализует команду make clean , позволяющую удалить все файлы, которые были сгенерированы при предыдущих сборках проекта:

    Это очень простое правило, удаляющее все файлы, сгенерированные при предыдущих сборках проекта. Символ @ сообщает GNU Make о том, что в процессе исполнения команды ее вывод не должен отображаться с помощью терминала.

    Правило install просто копирует скомпилированные файлы в нужное место. Его реализация выглядит следующим образом:

    Цель target должна зависеть от цели executable , так как при отсутствии исполняемого файла вы не сможете установить его в систему!

    Для копирования файла в директорию, расположенную за пределами домашней директории, обычно требуются особые привилегии. Директория /tmp является исключением из данного правила; однако, директория /tmp обычно очищается после перезагрузки системы. Если вам нужно установить бинарный файл в директорию /usr/local/bin , которая обычно используется для хранения исполняемых файлов, вам придется выполнить команду make install либо от лица пользователя root, либо с помощью утилиты sudo .

    Следующие команды реализуют команду make backup , генерируя архив с резервной копией файлов проекта, уникально идентифицируемый с помощью времени и даты создания:

    Хранение резервной копии файлов проекта за пределами его директории является разумной практикой. В приведенном выше Make-файле файл архива сохраняется в директории /tmp , но вы можете использовать вместо нее любую другую директорию.

    Другой переменной, практически всегда используемой в процессе компиляции кода на языках C и C++, является переменная CFLAGS , которая хранит флаги, используемые в процессе компиляции. Например, вы можете активировать режим вывода всех предупреждений компилятора и включить информацию о символах в результирующий бинарный файл для упрощения процесса отладки с помощью следующих флагов:

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

    Для того, чтобы избавить разработчиков от создания огромного количества аналогичных правил в make была добавлена поддержка шаблонов. Например, символ % соответствует любой последовательности символов. Этот механизм может пригодится, к примеру, в том случае, если вам понадобится скомпилировать все файлы с исходным кодом на языке C и сохранить объектный код в файлах с соответствующими именами:

    В данном случае вам также следует обратить внимание на типичный пример использования переменной CFLAGS . Вы должны самостоятельно принять решение о том, обоснованно ли написание отдельных правил для генерации объектных файлов в ручном режиме или проще воспользоваться соответствующим шаблоном. Вообще говоря, подход с использованием шаблонов является предпочтительным тогда, когда приходится обрабатывать большое количество файлов. Конечно же, в случае использования шаблона вам придется также изменить вашу реализацию команды make clean на аналогичную приведенной ниже:

    Следующая цель позволяет вывести список значений всех переменных Make-файла:

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

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

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

    Make масштабируется практически до любого уровня сложности проекта. Даже исходный код ядра Linux содержит Make-файлы

    Несмотря на то, что основным предназначением утилиты make является автоматизация процесса сборки программных проектов, администраторы Unux-систем, а также их обычные пользователи могут использовать ее и для своих целей. Вы можете использовать данную утилиту для создания резервных копий файлов конфигурации после их обновления, установки новых версий сценариев командной оболочки, генерации новых таблиц поиска Postfix с последующим перезапуском соответствующей службы, создания заданной структуры директорий для каждого из новых пользователей системы, генерации документации и выполнения других подобных действий — ее возможности безграничны; конечно же, вы также можете выработать новые методики использования утилиты GNU Make.

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

    Презентация была опубликована 6 лет назад пользователемАльбина Тришкина

    Похожие презентации

    Презентация на тему: » MAKE и другие утилиты. Make Утилита make автоматически определяет какие части большой программы должны быть перекомпилированы, и выполняет необходимые.» — Транскрипт:

    1 MAKE и другие утилиты

    2 Make Утилита make автоматически определяет какие части большой программы должны быть перекомпилированы, и выполняет необходимые для этого действия. В примерах будут фигурировать программы на языке Си, однако, можно использовать make с любым языком программирования для которого имеется компилятор, работающий из командной строки. На самом деле, область применения make не ограничивается только сборкой программ. Вы можете использовать ее для решения любых задач, где одни файлы должны автоматически обновляться при изменении других файлов. Перед тем, как использовать make, вы должны создать так называемый make-файл (makefile), который будет описывать зависимости между файлами вашей программы, и содержать команды для обновления этих файлов. Как правило, исполняемый файл программы зависит от объектных файлов, которые, в свою очередь, получаются в результате компиляции соответствующих файлов с исходными текстами.

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

    4 Знакомство с make-файлами (makefiles) Для работы с утилитой make, вам понадобится так называемый make-файл (makefile), который будет содержать описание требуемых действий. Как правило, make-файл описывает, каким образом нужно компилировать и компоновать программу. Обсудим простой make-файл, который описывает, как скомпилировать и скомпоновать программу — текстовой редактор. текстовой редактор будет состоять из восьми файлов с исходными текстами на языке Си и трех заголовочных файлов. Make-файл также может инструктировать make, как выполнять те или иные действия, когда явно будет затребовано их выполнение (например, удалить определенные файлы в ответ на команду «очистка»). При компиляции текстового редактора, любой файл с исходным текстом, который был модифицирован, должен быть откомпилирован заново. Если был модифицирован какой-либо из заголовочных файлов, то, во избежание проблем, должны быть перекомпилированы все исходные файлы, которые включали в себя этот заголовочный файл.

    5 Знакомство с make-файлами (makefiles) Каждая компиляция исходного файла породит новую версию соответствующего ему объектного файла. И, наконец, если какие-либо из исходных файлов были перекомпилированы, то все объектные файлы (как «новые», так и оставшиеся от предыдущих компиляций) должны быть заново скомпонованы для получения новой версии исполняемого файла нашего текстового редактора. Простой make-файл состоит из «правил» (rules) следующего вида: цель. : пререквизит. команда Обычно, цель (target) представляет собой имя файла, который генерируется в процессе работы утилиты make. Примером могут служить объектные и исполняемый файлы собираемой программы. Цель также может быть именем некоторого действия, которое нужно выполнить (например, `clean’ — очистить).

    6 Знакомство с make-файлами (makefiles) Пререквизит (prerequisite) — это файл, который используется как исходные данные для порождения цели. Очень часто цель зависит сразу от нескольких файлов. Команда — это действие, выполняемое утилитой make. В правиле может содержаться несколько команд — каждая на свое собственной строке. Важное замечание: строки, содержащие команды обязательно должны начинаться с символа табуляции! Это — «грабли», на которые наступают многие начинающие пользователи. Обычно, команды находятся в правилах с пререквизитами и служат для создания файла-цели, если какой-нибудь из пререквизитов был модифицирован. Однако, правило, имеющее команды, не обязательно должно иметь пререквизиты. Например, правило с целью `clean’ («очистка»), содержащее команды удаления, может не иметь пререквизитов.

    7 Знакомство с make-файлами (makefiles) Правило (rule) описывает, когда и каким образом следует обновлять файлы, указанные в нем в качестве цели. Для создания или обновления цели, make исполняет указанные в правиле команды, используя пререквизиты в качестве исходных данных. Правило также может описывать, каким образом должно выполняться некоторое действие. Помимо правил, make-файл может содержать и другие конструкции, однако, простой make-файл может состоять и из одних лишь правил. Правила могут выглядеть более сложными, чем приведенный выше шаблон, однако все они более или менее соответствуют ему по структуре.

    8 Пример простого make-файла Вот пример простого make-файла, в котором описывается, что исполняемый файл edit зависит от восьми объектных файлов, которые, в свою очередь, зависят от восьми соответствующих исходных файлов и трех заголовочных файлов. В данном примере, заголовочный файл `defs.h’ включается во все файлы с исходным текстом. Заголовочный файл `command.h’ включается только в те исходные файлы, которые относятся к командам редактирования, а файл `buffer.h’ — только в «низкоуровневые» файлы, непосредственно оперирующие буфером редактирования. edit : main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o cc -o edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o main.o : main.c defs.h cc -c main.c

    9 Пример простого make-файла kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c search.o : search.c defs.h buffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c

    10 Пример простого make-файла clean : rm edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o Для повышения удобочитаемости, мы разбили длинные строки на две части с помощью символа обратной косой черты, за которым следует перевод строки. Для того, чтобы с помощью этого make-файла создать исполняемый файл `edit’, наберите: $make Для того, чтобы удалить исполняемый и объектные файлы из директории проекта, наберите: make clean В приведенном примере, целями, в частности, являются объектные файлы `main.o’ и `kbd.o’, а также исполняемый файл `edit’. К пререквизитам относятся такие файлы, как `main.c’ и `defs.h’. Каждый объектный файл, фактически, является одновременно и целью и пререквизитом. Примерами команд могут служить `cc -c main.c’ и `cc -c kbd.c’.

    11 Пример простого make-файла В случае, если цель является файлом, этот файл должен быть перекомпилирован или перекомпонован всякий раз, когда был изменен какой-либо из его пререквизитов. Кроме того, любые пререквизиты, которые сами генерируются автоматически, должны быть обновлены первыми. В нашем примере, исполняемый файл `edit’ зависит от восьми объектных файлов; объектный файл `main.o’ зависит от исходного файла `main.c’ и заголовочного файла `defs.h’. За каждой строкой, содержащей цель и пререквизиты, следует строка с командой. Эти команды указывают, каким образом надо обновлять целевой файл. В начале каждой строки, содержащей команду, должен находится символ табуляции. Именно наличие символа табуляции является признаком, по которому make отличает строки с командами от прочих строк make-файла. Утилита make просто исполняет указанные в правиле команды, если цель нуждается в обновлении.

    12 Пример простого make-файла Цель `clean’ является не файлом, а именем действия. Поскольку, при обычной сборке программы это действие не требуется, цель `clean’ не является пререквизитом какого-либо из правил. Следовательно, make не будет «трогать» это правило, пока вы специально об этом не попросите. Заметьте, что это правило не только не является пререквизитом, но и само не содержит каких-либо пререквизитов. Таким образом, единственное предназначение данного правила — выполнение указанных в нем команд. Цели, которые являются не файлами, а именами действий называются абстрактными целями (phony targets).

    13 Как make обрабатывает make-файл По умолчанию, make начинает свою работу с первой встреченной цели (кроме целей, чье имя начинается с символа `.’). Эта цель будет являться главной целью по умолчанию (default goal). Главная цель (goal) — это цель, которую стремится достичь make в качестве результата своей работы. В примере главная цель заключалась в обновлении исполняемого файла `edit’, поэтому мы поместили данное правило в начало make-файла. Таким образом make читает make-файл из текущей директории и начинает его обработку с первого встреченного правила. В нашем примере это правило обеспечивает перекомпоновку исполняемого файла `edit’. Однако, прежде чем make сможет полностью обработать это правило, ей нужно обработать правила для всех файлов, от которых зависит `edit’. В данном случае — от всех объектных файлов программы. Каждый из этих объектных файлов обрабатывается согласно своему собственному правилу.

    14 Как make обрабатывает make-файл Эти правила говорят, что каждый файл с расширением `.o’ (объектный файл) получается в результате компиляции соответствующего ему исходного файла. Такая компиляция должна быть выполнена, если исходный файл или какой-либо из заголовочных файлов, перечисленных в качестве пререквизитов, являются «более новыми», чем объектный файл, либо объектного файла вообще не существует. Другие правила обрабатывается потому, что их цели прямо или косвенно являются пререквизитами для главной цели. Если какое-либо правило никоим образом не «связано» с главной целью (то есть ни прямо, ни косвенно не являются его пререквизитом), то это правило не обрабатывается. Чтобы задействовать такие правила, придется явно указать make на необходимость их обработки (подобным, например, образом: make clean).

    15 Как make обрабатывает make-файл Перед перекомпиляцией объектного файла, make рассматривает необходимость обновления его пререквизитов, в данном случае — файла с исходным текстом и заголовочных файлов. В нашем make-файле не содержится никаких инструкций по обновлению этих файлов — файлы с расширениями `.c’ и `.h’ не являются целями каких-либо правил. Таким образом, утилита make не предпринимает никаких действий с этими файлами. После перекомпиляции объектных файлов, которые нуждаются в этом, make принимает решение — нужно ли перекомпоновывать файл `edit’. Это нужно делать, если файла `edit’ не существует или какой-нибудь из объектных файлов по сравнению с ним является более «свежим». Если какой-либо из объектных файлов только что был откомпилирован заново, то он будет «моложе», чем файл `edit’. Соответственно, файл `edit’ будет перекомпонован.

    16 Как make обрабатывает make-файл Так, если мы модифицируем файл `insert.c’ и запустим make, этот файл будет скомпилирован заново для обновления объектного файла `insert.o’, и, затем, файл `edit’ будет перекомпонован. Если мы изменим файл `command.h’ и запустим make, то будут перекомпилированы объектные файлы `kbd.o’, `command.o’ и `files.o’, а затем исполняемый файл `edit’ будет скомпонован заново. В приведенном выше примере, в правиле для `edit’ нам дважды пришлось перечислять список объектных файлов программы: edit : main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o cc -o edit main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o Подобное дублирование чревато ошибками. При добавлении в проект нового объектного файла, можно добавить его в один список и забыть про другой. Мы можем устранить подобный риск, и, одновременно, упростить make-файл, используя переменные.

    17 Упрощение make-файла с помощью переменных Переменные (variables) позволяют, один раз определив текстовую строку, затем использовать ее многократно в нужных местах. Обычной практикой при построении make-файлов является использование переменной с именем objects, OBJECTS, objs, OBJS, obj, или OBJ, которая содержит список всех объектных файлов программы. Мы могли бы определить подобную переменную с именем objects таким образом: objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o Далее, всякий раз, когда нам нужен будет список объектных файлов, мы можем использовать значение этой переменной с помощью записи `$(objects)’. Вот как будет выглядеть наш простой пример с использованием переменной для хранения списка объектных файлов:

    18 Упрощение make-файла с помощью переменных objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) main.o : main.c defs.h cc -c main.c kbd.o : kbd.c defs.h command.h cc -c kbd.c command.o : command.c defs.h command.h cc -c command.c display.o : display.c defs.h buffer.h cc -c display.c insert.o : insert.c defs.h buffer.h cc -c insert.c

    19 Упрощение make-файла с помощью переменных search.o : search.c defs.h buffer.h cc -c search.c files.o : files.c defs.h buffer.h command.h cc -c files.c utils.o : utils.c defs.h cc -c utils.c clean : rm edit $(objects) На самом деле, нет необходимости явного указания команд компиляции отдельно для каждого из исходных файлов. Утилита make сама может «догадаться» об использовании нужных команд, поскольку у нее имеется, так называемое, неявное правило (implicit rule) для обновления файлов с расширением `.o’ из файлов с расширеним `.c’, с помощью команды `cc -c’. Таким образом, можно убрать явное указание команд компиляции из правил, описывающих построение объектных файлов.

    20 Упрощение make-файла с помощью переменных Когда файл с расширением `.c’ автоматически используется подобным образом, он также автоматически добавляется в список пререквизитов «своего» объектного файла. Таким образом, мы вполне можем убрать файлы с расширением `.c’ из списков пререквизитов объектных файлов. Вот новый вариант нашего примера, в который были внесены оба описанных выше изменения, а также используется переменная objects: objects = main.o kbd.o command.o display.o \ insert.o search.o files.o utils.o edit : $(objects) cc -o edit $(objects) main.o : defs.h kbd.o : defs.h command.h command.o : defs.h command.h display.o : defs.h buffer.h

    21 Упрощение make-файла с помощью переменных insert.o : defs.h buffer.h search.o : defs.h buffer.h files.o : defs.h buffer.h command.h utils.o : defs.h. PHONY : clean clean : -rm edit $(objects) Правило для очистки каталога Компиляция программы — не единственная вещь, для которой вы, возможно, захотите написать правила. Часто, в make-файле указывается, каким образом можно выполнить некоторые другие действия, не относящиеся к компиляции программы. Таким действием, например, может быть удаление все объектных и исполняемых файлов программы для очистки каталога.

    22 Упрощение make-файла с помощью переменных Вот как можно было бы написать правило для очистки каталога в нашем проекте текстового редактора: clean: rm edit $(objects) На практике, скорее всего, мы бы записали это правило чуть более сложным способом, предполагающим возможность непредвиденных ситуаций:.PHONY : clean clean : -rm edit $(objects) Такая запись предотвратит возможную путаницу если, вдруг, в каталоге будет находится файл с именем `clean’, а также позволит make продолжить работу, даже если команда rm завершится с ошибкой.

    23 Упрощение make-файла с помощью переменных Подобное правило не следует помещать в начало make-файла, поскольку мы не хотим, чтобы оно запускалось «по умолчанию»! В нашем примере, мы помещаем данное правило в конец make- файла, чтобы главной целью по умолчанию оставалась сборка файла edit. Поскольку clean не является пререквизитом цели edit, это правило не будеть выполняться, если вызывать `make’ без аргументов. Для запуска данного правила, нужно будет набрать `make clean’.

    24 Конфигурирование Факт создания авторами исходных кодов представляет собой чисто технический интерес для портирования программ. Свободное программное обеспечение, разработанное для UNIX®-систем, может быть использовано во всех существующих системах UNIX® (как свободных, так и собственнических) с незначительными изменениями или вообще без изменений. Для этого требуется сконфигурировать ПО непосредственно перед его компиляцией. Существует несколько систем конфигурирования. Вы должны использовать ту, которую требует автор программного обеспечения (а иногда и несколько). Обычно вы можете: Использовать AutoConf, если в родительском каталоге дистрибутива имеется файл с именем configure. Использовать imake, если в родительском каталоге дистрибутива имеется файл с именем Imakefile. Запустить shell-скрипт (например, install.sh) согласно содержимому файла INSTALL (или файла README).

    25 Autoconf Программа AutoConf используется для корректной настройки ПО. Она создcт необходимые для компиляции файлы (например, Makefile) и иногда изменяет непосредственно сами исходные тексты (например, при помощи файла config.h.in). Принцип AutoConf прост: Разработчик ПО знает, какие проверки необходимы для настройки его программы (например: «какую версию этой библиотеки вы используете?»). Он записывает их в файл с именем configure.in, используя определённый синтаксис. Он запускает AutoConf, которая создcт из файла configure.in конфигурационный скрипт с именем configure. Этот скрипт выполняет тесты, необходимые при настройке программы. Конечный пользователь запускает скрипт и AutoConf настраивает всё, что необходимо для компиляции.

    26 Autoconf Пример использования AutoConf: $./configure loading cache./config.cache checking for gcc. Gcc checking whether the C compiler (gcc ) works. Yes checking whether the C compiler (gcc ) is a cross-compiler. No checking whether we are using GNU C. Yes checking whether gcc accepts -g. yes checking how to run the C preprocessor. gcc -E checking for ANSI C header files. yes checking for unistd.h. yes checking for working const. yes updating cache./config.cache creating./config.status creating lib/Makefile

    27 Autoconf creating src/Makefile creating Makefile Для лучшего управления информацией, генерируемой configure, из командной строки или через переменные окружения могут быть добавлены некоторые опции. Пример: $./configure —with-gcc —prefix=/opt/GNU или (при помощи bash): $ export CC=`which gcc` $ export CFLAGS=-O2$./configure —with-gcc или: $ CC=gcc CFLAGS=-O2./configure

    28 Autoconf Обычны ошибки подобного вида: configure: error: Cannot find library guile. Это означает, что скрипт configure не смог найти библиотеку (в этой примере библиотеку guile). Принцип заключается в том, что скрипт configure компилирует небольшую тестовую программу, использующую эту библиотеку. Если компиляция этой программы завершится неудачей, то невозможно будет откомпилировать и весь программный пакет. Затем возникает ошибка. Причину ошибки ищите в конце файла config.log, содержащего отчёт обо всех этапах конфигурирования. Компилятор C выводит довольно чёткие сообщения об ошибках. Обычно это поможет вам при решении возникающих проблем. Проверьте, правильно ли установлена названная библиотека. Если это не так — установите её (из исходных кодов или в виде откомпилированного бинарного файла) и ещё раз запустите configure.

    29 Autoconf Эффективным способом проверки является поиск файла, содержащего символы библиотеки, коим всегда будет lib.so. Например, $ find / -name ‘libguile*’ или, как вариант: $ locate libguile Проверьте, доступна ли библиотека для компилятора. Это означает, что она находится в одном из каталогов: /usr/lib, /lib, /usr/X11R6/lib (или в одном из тех, что определены переменной окружения LD_LIBRARY_PATH). Проверьте, является ли этот файл библиотекой, набрав file libguile.so. Проверьте, правильно ли установлены заголовочные файлы библиотеки (обычно в /usr/include, /usr/local/include или /usr/X11R6/include). Если вы не знаете, какие файлы заголовков вам нужны, проверьте, установлена ли у вас development- версия (для разработки) требуемой библиотеки (например, libgtk+2.0-devel вместо libgtk+2.0). Версия библиотеки для разработки предоставляет файлы «include», необходимые для компиляции ПО, использующего эту библиотеку.

    30 Autoconf Проверьте, достаточно ли у вас свободного дискового пространства (для скрипта configure требуется некоторый объём для временных файлов). Воспользуйтесь командой df -h для вывода списка разделов вашей системы и обратите внимание на заполненные или почти заполненные разделы. Если вы не понимаете сообщения, сохранённые в файле config.log, не стесняйтесь попросить помощи у сообщества свободного ПО. Кроме того, проверьте, существует ли библиотека, даже если configure говорит, что её нет. В этом случае, вероятно, повреждена переменная окружения LD_LIBRARY_PATH!

    31 Создание скриптов configure Для создания скриптов Autoconf требует наличия программы GNU m4. Он пользуется возможностями, которых нет в некоторых UNIX-версиях программы m4. Он также превышает внутренние ограничения некоторых версий m4, включая GNU m4 версии 1.0. Вам необходимо использовать версию 1.1 (или более позднюю) программы GNU m4. Версии 1.3 и более поздние будут работать гораздо быстрее, чем версии 1.1 или 1.2. Скрипты конфигурации, создаваемые Autoconf, по принятым соглашениям называются configure. При запуске configure создает несколько файлов, заменяя в них параметры конфигурации на соответствующие системе значения. configure создает следующие файлы: один или несколько файлов `Makefile’, по одному на каждый подкаталог пакета; если задано, создается заголовочный файл для языка C, имя которого можно задать при создании скрипта и который содержит директивы #define;

    32 Создание скриптов configure скрипт командного процессора с именем `config.status’, который при запуске заново создаст вышеперечисленные файлы; скрипт командного процессора с именем `config.cache’, который сохраняет результаты выполнения многих тестов; файл с именем `config.log’, который содержит все сообщения, выданные компиляторами. Этот файл может использоваться при отладке, если configure работает неправильно. Для того, чтобы с помощью Autoconf создать скрипт configure, вам необходимо написать входной файл с именем `configure.in’ и выполнить команду autoconf. Если вы напишите собственный код тестирования возможностей системы, в дополнение к поставляемым с Autoconf, то вам придется записать его в файлы с именами `aclocal.m4′ и `acsite.m4′. Если вы используете заголовочный файл, который содержит директивы #define, то вы также должны создать файл `acconfig.h’, и вы сможете распространять с пакетом созданный с помощью Autoconf файл `config.h.in’.

    33 Automake Automake читает файл `Makefile.am’ и создает на его основе файл `Makefile.in’. Специальные макросы и цели, определенные в `Makefile.am’, заставляют Automake генерировать более специализированный код; например, макроопределение `bin_PROGRAMS’ заставит создать цели для компиляции и компоновки программ. Давайте предположим, что мы только что закончили писать zardoz — программу, от которой у всех кружится голова. Вы использовали Autoconf для обеспечения переносимости, но ваш файл `Makefile.in’ был написан бессистемно. Вы же хотите сделать его пуленепробиваемым, и поэтому решаете использовать Automake. Сначала вам необходимо обновить ваш файл `configure.in’, чтобы вставить в него команды, которые необходимы для работы automake. Проще всего для этого добавить строку AM_INIT_AUTOMAKE сразу после AC_INIT:

    34 Automake AM_INIT_AUTOMAKE(zardoz, 1.0) Поскольку ваша программа не имеет никаких осложняющих факторов (например, она не использует gettext и не будет создавать разделяемые библиотеки), то первая стадия на этом и заканчивается. Это легко! Теперь вы должны заново создать файл `configure’. Но для этого нужно сказать autoconf, где найти новые макросы, которые вы использовали. Для создания файла `aclocal.m4′ удобнее всего будет использовать программу aclocal. Программа aclocal позволяет вам поместить ваши собственные макросы в файл `acinclude.m4′, так что для сохранения вашей работы просто переименуйте свой файл с макросами, а уж затем запускайте программу aclocal:

    35 Automake mv aclocal.m4 acinclude.m4 aclocal autoconf Теперь пришло время написать свой собственный файл `Makefile.am’ для программы zardoz. Поскольку zardoz является пользовательской программой, то вам хочется установить ее туда, где располагаются другие пользовательские программы. Вдобавок, zardoz содержит в комплекте документацию в формате Texinfo. Ваш скрипт `configure.in’ использует AC_REPLACE_FUNCS, так что вам необходимо скомпоновать программу с Вот что вам необходимо написать в `Makefile.am’. bin_PROGRAMS = zardoz zardoz_SOURCES = main.c head.c float.c vortex9.c gun.c zardoz_LDADD = info_TEXINFOS = zardoz.texi

    36 GNU Autotools — инфраструктура для сборки программ Ранее мы обсуждали два «основных» пакета: Automake и Autoconf. Здесь мы кратко обсудим оставшихся два пакета: Libtool и Shtool. Libtool — разделяемые библиотеки Необходимость появления пакета Libtool стала очевидной после того, как доказали свою жизнеспособность пакеты Autoconf и Automake. Разработчики проекта GNU постоянно вставали перед проблемой создания разделяемых библиотек (shared libraries) на различных платформах. К сожалению, практически каждый из производителей UNIX- совместимых операционных систем изобретал свой собственный способ создания разделяемых библиотек.. После того, как несколько существующих к тому времени пакетов были признаны неудовлетворительными, началась работа над пакетом Libtool, который и является на текущий момент самым функциональным.

    37 Libtool — разделяемые библиотеки Для иллюстрации использования Libtool мы будем использовать многострадальную программу Hello, world. Надо разбить эту программу на два файла, в одном из которых находится наша функция print_hello(). Нашей задачей будет превратить этот файл в полноценную разделяемую библиотеку libhello. Создадим основной каталог проекта, а в нем подкаталог src/. Создадим src/hello.c, содержащий коротенькую функцию print_hello(): === src/hello.c === #include #include «hello.h« vo >

    38 Libtool — разделяемые библиотеки === src/main.c === #include «hello.h» int main(vo >

    39 Libtool — разделяемые библиотеки Два файла hello.c и main.c будут компилироваться в объектные файлы hello.o и main.o, соответственно, которые будут слинкованы в исполняемый файл, который называется просто hello. Вообще, Libtool создает так называемые Libtool-библиотеки — это целый набор файлов. Главный файл, содержащий описание библиотеки, имеет расширение.la. Объектные файлы, используемые при компиляции, а также результирующие статические и динамические библиотеки, помещаются в подкаталог.libs/. При установке Libtool автоматически обрабатывает эти файлы, помещая их в нужные каталоги. Заметьте, что некоторые устаревшие операционные системы не поддерживают динамических библиотек Libtool автоматически будет создавать при этом только статические библиотеки.


    40 Libtool — разделяемые библиотеки Для того, чтобы добавить поддержку Libtool в вашем проекте, используется макрос AC_PROG_LIBTOOL в файле configure.in: === configure.in === AC_INIT([hello.c]) AM_INIT_AUTOMAKE([hello], [0.3]) AC_PROG_CC AC_PROG_LIBTOOL AM_CONFIG_HEADER(config.h) AC_OUTPUT([Makefile src/Makefile]) === configure.in === Этот макрос не входит в стандартную поставку Autoconf, поэтому его нужно добавить в пакет с помощью программы aclocal. Кроме того, для поддержки Libtool требуется еще несколько файлов, которые можно автоматически установить с помощью программы automake:

    41 Libtool — разделяемые библиотеки $ aclocal $ autoconf $automake -ac В дистрибутив добавятся следующие файлы: config.guess, config.sub, ltmain.sh, ltconfig. В процессе работы скрипта configure будет создан файл libtool, который и будет обеспечивать всю поддержку сборки. Для создания Libtool-библиотек используется основная переменная Automake _LTLIBRARIES. Для того, чтобы создать разделяемую библиотеку libhello, напишем в src/Makefile.am: === src/Makefile.am === lib_LTLIBRARIES = libhello.la libhello_la_SOURCES = hello.c hello.h === src/Makefile.am === Эта запись означает, что будет создана Libtool-библиотека, которая называется libhello.la и компилируется из двух исходных файлов: hello.c и hello.h.

    42 Libtool — разделяемые библиотеки Выполним программы automake, autoconf, затем выполним скрипт./configure. Теперь попробуем собрать библиотеку (несколько строчек из выдачи программы make удалено для краткости): $cd src/ $make libhello.la Заглянув в каталог.libs/, можно увидеть там как статическую библиотеку c расширением.a, так и динамические библиотеки с расширением.so, со всеми необходимыми символьными ссылками. Сборка программ с Libtool-библиотеками Довольно часто ваш пакет состоит не только из разделяемой библиотеки, но также и из набора программ, использующих эту библиотеку. Libtool автоматически обрабатывает этот распространенный случай. Давайте сделаем так, чтобы программа hello использовала разделяемую библиотеку libhello:

    43 Сборка программ с Libtool- библиотеками === src/Makefile.am === bin_PROGRAMS=hello hello_SOURCES=main.c hello_LIBADD = $(top_builddir)/src/libhello.la === src/Makefile.am === Переменная $(top_builddir) содержит каталог сборки верхнего уровня. Есть еще похожая переменная $(top_srcdir), содержащая верхний уровень каталога с исходными текстами. Если вам нужно обратиться к собираемому объекту, используйте первую из них; в противном случае, чтобы обратиться к объекту, существующему в дистрибутиве (например, файлу данных или каталогу с заголовочными файлами), используйте вторую переменную. Итак, мы опять обновляем файлы Makefile.in и Makefile, собираем библиотеку libhello.la, затем собираем программу hello:

    44 Сборка программ с Libtool- библиотеками $ cd src/ $ make libhello.la $ make hello Если мы посмотрим на файл hello, то увидим, что он на самом деле представляет собой shell-скрипт. Настоящий исполняемый файл находится в подкаталоге.libs/. Он будет установлен как следует, при выполнении make install. Впрочем, этот скрипт можно запустить прямо из каталога сборки, как если бы это была обычная программа: $./hello Hello, world!

    45 Дополнительные возможности Если вы хотите отладить вашу программу, то не сможете сделать это простым наивным методом: $gdb hello «/home/hello/src/hello»: not in executable format: File format not recognized Libtool обеспечивает специальный режим для отладки: $ libtool gdb helloThis GDB was configured as «i686-pc-linux- gnu». (gdb) run Starting program: /home/hello/src/.libs/lt-hello Hello, world! Program exited normally.

    46 Shtool Shtool является одним большим shell-скриптом, который умеет выполнять полтора десятка подкоманд разного назначения. Основная причина использования этого скрипта — невероятная переносимость. Shell-код, который используется внутри этих скриптов, работает на огромном количестве командных интерпретаторов различных операционных систем, каждая из которых, как всегда, имеет свои, скажем так, особенности. Вообще, в системах сборки пакетов, использующих Automake и Autoconf, почти нет места, где можно было бы использовать Shtool: разве что можно использовать подкоманды mkdir и install. Зачем бы это было нужно? — спросите вы, ведь команды mkdir и install есть на всякой системе? Нет. Например, команда mkdir имеет флаг -p только в GNU-версии и еще в некоторых. Ощутимое количество коммерческих операционных систем не умеют создавать каталоги, только если все его родительские каталоги уже существуют. Некоторые программы install также не поддерживают ряда полезных ключей.

    47 Shtool Скрипты shtool проявляют себя в полной мере, когда их используют для различных дополнительных, нестандартных целей. В этой статье мы лишь кратко опишем подкоманды, которые обеспечивает Shtool, чтобы вы представляли себе, что можно не реализовывать снова и снова, а взять уже готовое. Подробности, как обычно, можно найти на великолепной странице руководства к Shtool. Вывод на экран: — echo: выдает на экран строку, в которой можно использовать служебные конструкции; поддерживает ключ -n, который умеет не всякая программа echo; — mdate: печатает в указанном формате время последней модификации файла или каталога; — table: печатает список значений в виде таблицы; — prop: рисует красивый «пропеллер» во время выполнения длинной операции;

    48 Shtool Работа с файлами: — move: позволяет переименовывать файлы с поддержкой маски: например, shtool move -e %.txt %.asc переименует все файлы с расширением.txt в.asc; такой возможности обычно не хватает многим, привыкшим к досовской команде rename; — install: устанавливает программу, скрипт или обычный файл; обеспечивает все флаги BSD-версии программы install, даже если системная программа install их не поддерживает или вообще не существует; — mkdir: создает каталог; позволяет также создать все необходимые родительские каталоги — эта возможность часто отсутствует в системных программах mkdir; — mkln: создает ссылку (жесткую или символьную) на файл; при создании символьной ссылки старается, чтобы ссылка была относительной;

    49 Shtool — mkshadow: создает копию дерева исходных текстов с помощью символьных ссылок; полезно, если хочется внести несколько исправлений в существующее дерево, чтобы потом создать diff- файл; — fixperm: «исправляет» права доступа к файлам перед созданием дистрибутива; обычно при этом устанавливаются недостающие права доступа и выполнения для «группы» и для «всех остальных»; — tarball: создает правильный tar-файл с дистрибутивом. Этот tar-файл будет распаковываться в отдельный подкаталог; список файлов в этом tar-файле будет отсортирован, чтобы можно было пользоваться командой tar tvf; Системные возможности: — guessos: определяет операционную систему и архитектуру; обычно лучше использовать стандартный GNU-скрипт config.guess; — arx: расширенный вариант команды ar;

    50 Shtool — slo: специальная обертка к системному компоновщику, позволяющая удобно работать со специальными динамическими библиотеками; — scpp: специальная обертка к препроцессору языка C, облегчающая написание библиотек на ANSI C; — version: обеспечивает создание файлов описания версии пакета для нескольких различных языков программирования; — path: утилита для работы с переменной окружения $PATH. С помощью программы shtoolize можно создать скрипт shtool, содержащий необходимое подмножество подкоманд. Учтите, лицензия на все эти пакеты позволяет использовать их даже в коммерческих программных продуктах. Документация, а также списки рассылки и группы новостей помогут вам добиться эффективного использования Autotools в повседневной практике.

    51 Shtool Ссылки Основная страница проекта Libtool: Основная страница проекта Shtool: Русская страница по Autotools: Книга «GNU Autoconf, Automake, and Libtool»: automake-an. automake-an.

    Глава 11 автоматизированная разработка программ с помощью утитлиты make

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

    11.1 Вызов компиляторов

    В системе UNIX имеются компиляторы с языков C, ФОРТРАН-77 и ПАСКАЛЬ и другие. Команды вызова компилятора имеют вид cc, f77 или fc, pc и т.п.

    Параметрами этих команд являются файлы с текстами программ на исходных языках, имена которых должны оканчиваться на .c, .f, .p и т.п. соответственно.

    Результатом работы компилятора является файл исполняемого кода, имеющий по умолчанию имя a.out. Если вы хотите другое имя, его можно указать явно ключом -o при вызове компилятора.

    На практике программы создаются из множества раздельно транслируемых модулей, каждый из которых занимает отдельный файл. Результатом компиляции каждого модуля является файл объектного (перемещяемого) кода, имя которого получается заменой .c (или .f, .p и т.д.) на .c. Затем все объектные файлы объединяются в единую программу, помещаемую в файл исполняемого кода, посредством линкера. Линкер может вызываться как независимой командой ld, так и автоматически при выполнении команд вызова компилятора cc, fc, pc и т.д. В последнем случае эти команды могут иметь несколько параметров-файлов, имена которых могут оканчиваться не только на .c, .f, .p, . но и на .o. Файлы исходного текста компилируются, а затем все файлы объектного кода, как полученные в результате компиляции, так и параметры команды вызова компилятора, передаются линкеру. Результатом по-прежнему является файл с именем по умолчанию a.out, если вы не указали явно другое имя.

    При этом, как правило, объектные файлы уничтожаются. Чтобы сохранить их, можно подавить автоматический вызов линкера ключом -c (только компиляция) в команде вызова компилятора.

    Здесь добавлены файл /lib/frt0.o стартового модуля для программы на ФОРТРАНе (для C /lib/crt0.o) и библиотека lF77 подпрограмм для ФОРТРАНа (для C — lc); могут быть добавлены и другие библиотеки. Обозначение -lx является сокращением для /lib/libx.a для любого x. Следует заметить, что библиотеки указываются последними (не являются ключами команды ld). При автоматическом вызове линкера стартовый модуль и ряд библиотек вызываются по умолчанию. Чтобы их увидеть, следует применить ключ -v в командах вызова компилятора.

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

    Имя библиотечного файла обычно оканчивается на .a. Имеется команда ar (архив) для создания, пополнения и просмотра библиотечных файлов.

    Пример создания библиотеки из трех объектных файлов:

    Здесь ключи команды ar означают:

    Теперь мы можем распечатать содержимое библиотеки командой ar с ключом t (table of content):

    и ссылаться на библиотеку в командах вызова компиляторов или линкера, например:

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

    Например, если подпрограмма test вызывает подпрограмму check, то test.o должен предшествовать check.o в библиотеке. Для выявления и печати таких зависимостей предназначена команда lorder.

    11.4. Символьный отладчик

    Как правило, имеется единый символьный отладчик для программ на нескольких языках программирования, компиляторы которых вырабатывают объектный код и таблицы символов в единеом формате. Символьный отладчик обычно имеет альтернативные имена для разных языков, например, cdb, fdb и pdb для языков C, ФОРТРАН-77 и PASCAL соответственно. Вызов отладчика производится одноименной командой, в которой указывается файл кода отлаживаемой программы, по умолчанию a.out. Для генерации и сохранения отладочной информации (таблиц символов и т.п.) компиляция программы должна производиться с ключом -g.

    Знак > — подсказка отладчика, приглашающая вводить команды отладчика. Команды отладчика позволяют:

    • посмотреть текущие значения переменных выполняемого оператора, строки исходного текста, процедуры, файла в указанном формате;
    • устанавливать и сбрасывать точки прерывания для пошагового выполнения отлаживаемой программы между точками прерывания и/или с постоянным шагом;
    • задавать утверждения, проверяемые перед выполнением каждого оператора для останова перед теми операторами, для которых утверждение истинно;
    • копировать все сигналы, связанные с отлаживаемой программой;
    • записывать и повторно использовать команды сеанса отладки (командный файл на входе отладчика).

    Более подробную информацию о символьном отладчике можно найти в руководстве по команде cdb.

    11.5. Средства оценки эффективности исполнения программы

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

    Команда time позволяет выяснить три значения потраченного на решение указанной программы времени в секундах: реального, равного времени, замеренному по секундомеру, зависящего от количества пользователей в данный момент; пользовательского, равного времени счета программы по командам пользователя, и системного, равного времени системы при обслуживании этой программы. Команда time в Shell и в C-Shell имеет разные формы выдачи.

    Команда size показывает размер памяти в байтах трех различных частей программы: выполняемого кода (называемого текстом), области инициируемых данных и области неинициируемых данных.

    Общий размер программы test равен 4265 байтов.

    Если имя оцениваемого файла отсутствует, подразумевается a.out.

    Для программы на языке C есть более тонкое средство, позволяющее получить профиль программы, показывающий для каждой подпрограммы долю времени ее выполнения в процентах (% time), суммарное время ее выполнения в секундах (cumsecs), количество ее вызовов (# call) и время, потраченное на один вызов в миллисекундах (ms/call). Для получения профиля следует перетранслировать программу с ключом -p (профиль), а после запуска программы, во время которого статистическая информация будет собрана в файле mon.out, выполнить команду prof для обработки указанного файла.

    11.6. Сопровождение программ: make

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

    Утилита make работает с файлом Makefile, в который записывается необходимая информация о всех файлах программы и связях между ними.

    Как видно из примера, в файле Makefile помещаются макроопределения, имеющие вид:

    и правила, имеющие вид:

    Первая строка правила называется зависимостью. Зависимость указывает, что конечный файл является результатом работы команды, указанной во второй строке правила, над исходными файлами. Внутри зависимости можно ссылаться на макроопределения в форме $(строка1).

    Подготовив такой Makefile, можно модифицировать программу test одним вызовом команды make, например:

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

    Возможно изменить только часть программы, например:

    В данном случае утилита make по умолчанию «знает», что файл prove.o зависит от файла prove.f и реализация этой зависимости есть указанный вызов компилятора.

    Полезный ключ -n утилиты make позволяет не выполняя предписанных действий предварительно посмотреть, что было бы выполнено, если бы ключ не был подан.

    Подробнее о make можно узнать из руководства по команде make и книг [7,8].

    11.7. Средства реализации языков программирования

    До сих пор речь шла о разработке программ на языках программирования, реализованных в системе (т.е. имеющих компилятор и линкер). Если вас, как опытного пользователя, не устраивают эти предопределенные языки и вы хотите реализовать свой язык, то и в этом вам поможет система UNIX, предоставляя утилиты lex и yacc.

    Утилита lex является текстовым процессором, реализующим лексический анализ, необходимый при создании компиляторов и других языковых процессоров.

    Утилита yacc (yet another compiler compiler) конвертирует безконтекстную грамматику в таблицы, управляющие грамматическим разбором посредством LR(1)-автомата. Формируемые при этом правила предшествования позволяют избавиться от двусмысленностей исходной грамматики.

    Совместное использование утилит lex и yacc является мощным подспорьем для быстрой реализации языковых процессоров в среде системы UNIX [9,10,11].

    Разработка автоматизированных учебных курсов

    Читайте также:

    1. VI. Разработка теории систем и теории компромиссов
    2. VI. Разработка теории систем и теории компромиссов
    3. Администрирование и разработка баз данных
    4. Базовых учебных навыков письма и чтения. Анализ существующих методических подходов, их адекватность возрастным особенностям
    5. Бухгалтерский учет курсовых разниц
    6. Быстрая разработка и модификация
    7. Виды валютных курсов в зависимости от степени гибкости
    8. Виды испытаний автоматизированных систем и состав документации.
    9. Внедрение автоматизированных ИР в сферу социальной зашиты населения РФ
    10. Вопрос 3. Виктимология в системе других наук и учебных дисциплин
    11. Вопрос 4. Разработка и принятие конституции РФ 1993 г.
    12. Вопрос 49. Курсовая устойчивость и действие внешних сил.


    Главная задача автоматизированного обучения (АО) на базе имеющихся АОС заключается в организации и проведении автоматизированного учебного занятия (АУЗ) по некоторому ранее разработанному автоматизированному учебному курсу (АУК) Рассмотрим вопросы разработки АУК, уделяя внимание общим определениям и основным понятиям теоретических основ разработки АУК.

    Основные понятия и определения

    Обучающая программа (ОП) — это логически объединенный набор квaнтов учебной информации, предназначенный для формирования требуемой совокупности знаний у обучаемого в режиме диалога «ЧЕЛОВЕК — ЭВМ», умений навыков по заданной теме дисциплины.

    Кванты учебной информации (КУИ) — это элементарные порции информации (тексты заданий, ответы, комментарии и т.д.).

    Автоматизированный учебный курс (АУК) — это комплекс взаимосвязанных обучающих программ (ОП) по определенной дисциплине.

    В любой АОС изучение отдельной темы учебной дисциплины осуществляется согласно сценарию обучения, реализованному с помощью ОП, а изучение тем всей дисциплины предмета осуществляется с помощью АУК.

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

    — разомкнутое — это управление по заданному алгоритму без диагностики;

    — замкнутое — это слежение за процессом, его коррекция, наличие обратной связи от обучаемого к АУК, текущий контроль хода обучения;

    — смешанное — это комбинация первых двух.

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

    В рассеянном информационном процессе информация от АОС направляется сразу ко всем обучаемым без учета их восприятия. В направленном информационном процессе информация от АОС направляется обучаемому с учетом его индивидуальности.

    Как правило, наивысшую дидактическую эффективность дает использование АУК, реализующего замкнутое управление с направленным информационным процессом.

    Классификация обучающих программ

    В зависимости от набора и использования квантов (кадров) информации, различают четыре типа обучающих программ:

    — собственно обучающие программы, в которых присутствуют информационные и вопросные кадры с комментариями-разъяснениями ответов обучаемого;

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

    — контролирующие программы, которые содержат вопросные кадры с комментариями правильности ответа обучаемого;

    — информационные обучающие программы, которые содержат только информационные кадры.

    В зависимости от последовательности проработки кадров, включенных в ОП, различают три вида обучающих программ:

    — линейные ОП — жестко установленная последовательность кадров, одинаковая для всех обучаемых;

    — разветвленные ОП — последовательность кадров, при которой обучаемые разной степени подготовленности продвигаются по ОП различными путями;

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

    В современных АОС целесообразно разрабатывать АУК, которые используют разветвленные или многоуровневые ОП.

    Этапы разработки обучающих программ

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

    Учитывая мнение специалистов, можно рекомендовать для включения в АУК следующие разновидности тем:

    — темы для приобретения навыков и умений;

    — темы для моделирования объектов и явлений.

    Основные этапы разработки ОП включают следующее:

    — определение цели обучения;

    — подбор контрольных заданий;

    — выбор типа и вида ОП;

    — определение последовательности изучения понятий, входящих в тему;

    — подбор квантов информационных кадров;

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

    — подбор вспомогательных кадров для неточных и неправильных ответов, подготовка комментариев;

    — составление графовой модели сценария диалога путем объединения отдельных квантов;

    — запись квантов информации на специальные бланки;

    — составление ОП на выбранном языке;

    — тестирование и отладка ОП;

    — организация опытной эксплуатации.

    Указанные этапы разработки ОП не зависят от используемого составителем языка программирования и являются достаточно универсальными.

    Дата добавления: 2014-01-20 ; Просмотров: 1060 ; Нарушение авторских прав? ;

    Нам важно ваше мнение! Был ли полезен опубликованный материал? Да | Нет

    Этапы разработки программ. Тестирование и отладка. Документирование программ (стр. 1 из 3)

    МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ

    ФЕДЕРАЛЬНОЕ АГЕНТСТВО ПО ОБРАЗОВАНИЮ

    ГОСУДАРСТВЕННОЕ ОБРАЗОВАТЕЛЬНОЕ УЧРЕЖДЕНИЕ
    ВЫСШЕГО ПРОФЕССИОНАЛЬНОГО ОБРАЗОВАНИЯ

    ТЮМЕНСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ

    Институт математики и компьютерных наук

    Кафедра математики и информатики

    По дисциплине: «Основы программирования»

    Этапы разработки программ. Тестирование и отладка. Документирование программ

    Глава 1. Этапы разработки программ

    1.1 Постановка задачи

    1.1.1 Формулировка и анализ физической задачи

    1.1.2. Составление математической модели

    1.1.3 Составление алгоритма задачи

    1.2 Создание программы

    1.2.1 Составление текста программы

    1.2.2 Синтаксическая отладка программы


    1.2.3 Тестирование и семантическая отладка

    1.3 Документирование программы

    1.3.1 Пользовательская документация программы

    1.3.2 Документация по сопровождению программы

    1.4 Запуск готовой программы и анализ полученных результатов

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

    Сейчас компьютер является неотъемлемой частью работы людей. Компьютеры используются в школах и университетах. Они помогают систематизации полученные данных, как в рабочих целях, так и в учебных. Но, ни один компьютер не обходится без программ и программных обеспечений.

    Целью данной курсовой работы является рассмотрение не маловажной, для начинающих программистов, темы — «Этапы создания программы». Практическое применение теоретических навыков было опробовано в процессе написания программного приложения — игра «Виселица». Что также стало целью данной курсовой.

    Разработка программы – это не только написание программы. Написание программы является одним из этапов. Для начала перечислим все этапы разработки программ, а затем подробно расскажем о них.

    Этапы разработки программ:

    1. Постановка задачи

    1. Формулировка и анализ физической задачи

    2. Составление математической модели

    3. Составление алгоритма задачи

    2. Создание программы

    1. Составление текста программы

    2. Ввод текста программы в компьютер

    3. Синтаксическая отладка программы

    4. Тестирование и семантическая отладка

    5. Документирование программы

    3. Запуск готовой программы и анализ полученных результатов

    Рассмотрим подробно каждый этап.

    1.1 Постановка задачи

    Первый этап — это этап разбора задачи по кусочкам, для упрощения написания программы. Его ещё называют математическим этапом.

    1.1.1Формулировка и анализ физической задачи

    Формулировка задачи – это само её объявление, её постановка.

    Но просто формулировка ничем не поможет программистам. Для этого и существует второй подэтап – это анализ задачи.

    Анализ задачи – это подробный просмотр задачи с определением и выявлением входной и выходной информации. (Входная информация по задаче — это данные, поступающие на вход задачи и используемые для её решения. Выходная информация – это результат.)

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

    1.1.2 Составление математической модели

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

    «Математическая модель — система уравнений и концепций, используемых для описания и прогнозирования данного феномена или поведения объекта. Математические модели находят как практическое, так и теоретическое применение (иногда одновременно). Практические задачи, в которых используются математические модели, включают создание новых материалов, предсказание погоды, проверку прочности мостов, самолетов и тому подобного» — это определение используется в физике, химии и математической биологии.

    «Математическая модель — это упрощенное описание реальности с помощью математических понятий. Существует два основных класса задач, связанных с математическими моделями: прямые и обратные. В первом случае все параметры модели считаются известными, и нам остается только исследовать её поведение. А во втором какие-то параметры модели неизвестны, и требуется их найти, сопоставляя поведение реальной системы с её моделью.» — данное определение используется в основном в экономике.

    «Математическая модель — это математическое представление реальности» — это определение созданное математиками.

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

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

    1.1.3 Составление алгоритма задачи

    Изначально появление алгоритма связывают с возникновением математики. Алгоритм – описание последовательности действий (план), строгое исполнение которых приводит к решению поставленной задачи за конечное число шагов.

    У алгоритма есть 2 обязательных условия:

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

    · Алгоритм должен быть представлен в форме, понятной тому объекту (в том числе и человеку), который будет выполнять описанные в алгоритме действия.

    Так же у алгоритмов есть свойства:

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

    2. Детерминированность, т. е. любое действие должно быть строго и недвусмысленно определено в каждом случае.

    3. Конечность, т. е. каждое действие и алгоритм в целом должны иметь возможность завершения.

    4. Массовость, т. е. один и тот же алгоритм можно использовать с разными исходными данными.

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

    В мире существует несколько видов алгоритмов:

    · Линейный алгоритм (описание действий, которые выполняются однократно в заданном порядке);

    · Циклический алгоритм (описание действий, которые должны повторятся указанное число раз или пока не выполнено условие);

    · Разветвляющий алгоритм (алгоритм, в котором в зависимости от условия выполняется либо одна, либо другая последовательность действий);

    1.2 Создание программы

    Процесс создание программы, а точнее разработка программного обеспечения – это второй этап создания программы.

    1.2.1 Составление текста программы

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

    1.2.2 Синтаксическая отладка программы

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

    Синтаксическая отладка – поиск синтаксических ошибок в тексте программы. Обнаружив ошибку, транслятор выводит сообщение, указывая на место ошибки в программе и ее характер. Получив такое сообщение, программист должен исправить ошибку и снова повторить трансляцию. Так продолжается до тех пор, пока не будут исправлены все синтаксические ошибки.

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

    1.2.3 Тестирование и семантическая отладка

    Тестирование – это динамический контроль программы, т.е. проверка правильности программы при ее выполнении на компьютере.

    Каждому программисту известно, сколько времени и сил уходит на отладку и тестирование программ. На этот этап приходится около 50% общей стоимости разработки программного обеспечения. Но не каждый из разработчиков программных средств может верно, определить цель тестирования. Нередко можно услышать, что тестирование — это процесс выполнения программы с целью обнаружения в ней ошибок. Но эта цель недостижима: ни какое самое тщательное тестирование не дает гарантии, что программа не содержит ошибок. Другое определение: это процесс выполнения программы с целью обнаружения в ней ошибок. Отсюда ясно, что “удачным” тестом является такой, на котором выполнение программы завершилось с ошибкой. Напротив, “неудачным” можно назвать тест, не позволивший выявить ошибку в программе. Определение также указывает на объективную трудность тестирования: это деструктивный ( т.е. обратный созидательному ) процесс. Поскольку программирование — процесс конструктивный, ясно, что большинству разработчиков программных средств сложно “переключиться” при тестировании созданной ими продукции. Основные принципы организации тестирования:

    Илон Маск рекомендует:  Что такое код ncurses_nocbreak
    Понравилась статья? Поделиться с друзьями:
    Кодинг, CSS и SQL