makepp_variables - онлайн у хмарі

ПРОГРАМА:

ІМ'Я

makepp_variables -- Як використовувати змінні в makepp

ОПИС

?: $*,
$+,
$/,
$<,
$?,
$@,
$^,
=,
!=,
&=,
+=,
:=,
;=,
?=, A: AR,
АРФЛАГИ,
AS, C: DC,
CFLAGS,
"changed_dependencies",
змінені_входи,
КУРДИР,
CXX,
CXXFLAGS, D: "залежності",
"залежність", F: F77,
ФК,
"для кожного", I: вхід,
входів L: LD,
ЛЕКС,
LIBTOOL, M: ЗРОБИТИ,
ПОСТАНОВИТИ ЦІЛІ,
MAKEFLAG,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "вихід",
"виходи", P: PERL,
інвалід, R: РМ,
КОРІНЬ, S: ШЕЛЛ,
"відсортовані_залежності",
відсортовані_входи,
"стебло", T: ціль,
цілі, V: VPATH, Y: YACC

Makefile зазвичай використовують змінні в багатьох місцях. Одна важлива причина використання
змінних полягає в тому, щоб інформація містилася лише в одному місці make-файлу, тому
що якщо він зміниться, немає загрози виходу двох копій інформації
синхронізація.

Назви змінних чутливі до регістру. Теоретично, імена змінних можуть складатися з багатьох
символів, але makepp, імовірно, не зможе це зробити, якщо ви зробите щось інше
буквено-цифрові символи, «_» та «-».

Кожен make-файл має свій власний набір змінних, і встановлення змінної в одному make-файлі буде
не впливають на його значення в будь-якому іншому make-файлі. Якщо ви хочете встановити змінні
багато make-файлів, найкращий спосіб зробити це – включити в кожен із них загальні визначення
файл (див. інструкцію include) або використовуйте "глобальні" змінні.

Змінна Призначення
Змінна може приймати значення кількома різними способами:

· Змінна може бути встановлена ​​всередині make-файлу. Існує кілька різних способів зробити це
це; Дивись нижче.

· Значення змінної можна вказати в командному рядку, наприклад:

makepp CFLAGS=-O2 моя_програма

Якщо завантажено більше одного make-файлу, змінна CFLAGS поширюється на всі файли
make-файли. Змінні, встановлені в командному рядку, автоматично замінюють будь-які налаштування
змінну в будь-якому з make-файлів.

У разі потреби make-файл повинен, у свою чергу, явно перевизначати параметри командного рядка.
Намір не ігнорувати запити користувача, а спосіб змінити це.
Модифікатор "overidide" може передувати будь-якому оператору присвоєння. Але у випадку з
оператори ключових слів, порядок важливий, тому варіант перевизначення є
завжди показано нижче. Модифікатор "замінити" застосовується лише до будь-яких присвоєнь, де він
присутній і не впливає на подальші присвоєння змінної.

· Якщо змінна встановлена ​​в середовищі, на неї можна посилатися як на змінну makepp.
Зазвичай присвоєння змінних всередині make-файлу замінює налаштування з файлу
середовище, але ви можете змінити це за допомогою «-e» або «--environment-overrides»
параметр командного рядка.

Змінним присвоюється один із кількох виразів присвоєння, як це

X = 1
МОДУЛИ := abcd
CC ?= gcc
CFLAGS += -Стіна
визначити VAR
var рядок 1
var рядок 2
enddef
експорт PATH := $(PWD):$(PATH)
глобальний MYPROJECT.INFO = інформація, яка відображатиметься у всіх make-файлах

Початкові та кінцеві пробіли навколо значень завжди видаляються.

Різні оператори присвоєння мають дещо різне значення.

простий призначення Оператори

=
VARIABLE = текстовий рядок
замінити VARIABLE = текстовий рядок

Це звичайний оператор присвоєння, який підтримують усі реалізації. The
Вираз з правого боку не оцінюється, доки не буде значення "$(VARIABLE)".
насправді десь використовувався. Таким чином, якщо ви робите наступне:

X = 1
Y = $(X)
X = 2

Тоді "$(Y)" пізніше у make-файлі буде оцінюватися як "2".

Загалом, ви зазвичай хочете використовувати ":=" (див. нижче) замість "=", тому що це
забезпечує більш передбачувану оцінку змінної. Однак бувають випадки, коли вам це потрібно
відкласти оцінку змінної. Крім того, якщо ви пишете make-файл, це має бути
зворотно сумісний з якоюсь версією make, відмінною від GNU make, тоді у вас немає
вибір: ви можете використовувати лише "=".

:=
VARIABLE := вираз
замінити VARIABLE := expr

Це те саме, що "VARIABLE = expr", за винятком того, що оцінюється права частина
раз і назавжди під час виконання завдання. Таким чином, якщо

X := 1
Y := $(X)
X := 2

тоді "$(Y)" пізніше у make-файлі оцінюватиметься як "1", оскільки саме таким був "$(X)"
коли було визначено "$(Y)".

;=
ЗМІННА ;= вираз
замінити VARIABLE ;= вираз

Це те саме, що "VARIABLE := expr", за винятком того, що оцінюється права частина
тільки під час першого використання, а потім запам'ятовується. Це корисно для дорогих
команди, які завжди повертають одне й те саме значення, але які ви не хочете виконувати, коли
створення непов'язаних цілей:

VAR1 ;= $(дорогі обчислення perl)
VAR2 ;= $(зовнішня команда оболонки)

Зауважте, що старі make-файли зазвичай використовують тут ":=", щоб принаймні зробити це лише один раз.
Але з цим оператором ви можете навіть додатково цього не робити, якщо зараз цього не робите
потрібна вартість. Для значень, які ідентичні в кількох каталогах, можна
оптимізувати це далі за допомогою "global", про що йдеться нижче.

Однак це не є розумним способом примусового порядку оцінювання. Якщо
змінна, визначена таким чином, включає значення іншої змінної та іншої
має цільове значення, і перше розширення призначене для цієї цілі, а потім
цільове значення буде також зберігатися для всіх інших контекстів. Це помилка і
сподіваюся, буде виправлено в майбутньому.

+=
ЗМІННА += вираз
замінити VARIABLE += вираз

Додає рядок до попереднього вмісту змінної через пробіл. Якщо
змінній було раніше призначено ":=", потім оцінюється права частина
перед додаванням.

&=
ЗМІННА &= вираз
замінити VARIABLE &= expr

Додає рядок до попереднього вмісту змінної, розділяючи його пробілом.
Якщо змінній раніше було призначено ":=", то правий бік
оцінюється перед додаванням.

Наприклад, один із способів гарантувати, що "CFLAGS", що б ще не вставив користувач,
завжди починається з "-Wall" ці два рядки:

CFLAGS = -O2 # Можливо, замінено в командному рядку
override CFLAGS &= -Wall # Безумовно перед

У старих make-файлах зазвичай доводилося робити щось подібне, що мало сторони
ефект примусового примусу типу ":=" для запобігання нескінченної рекурсії:

VARIABLE := вираз $(VARIABLE)

?=
ЗМІННА ?= вираз
override VARIABLE ?= expr # Марно, але законно

Встановлює значення змінної, але тільки якщо змінна не вказана раніше в
makefile, у командному рядку або в середовищі. Наведене вище завдання є
точно еквівалентний

ifndef ЗМІННА
ЗМІННА = вираз
ENDIF

!=
VARIABLE != команда оболонки
перевизначити команду VARIABLE != оболонки

Запускає команду оболонки та встановлює змінну так, щоб вона містила стандартний вихід команди.
Це точно еквівалентно

VARIABLE := $(команда оболонки)

Багаторядковий змінні

Оператор "define" є багаторядковим еквівалентом простих операторів вище. The
Оператор після змінної є необов'язковим. Якщо відсутня, це еквівалентно «визначити VARIABLE
=". Оператори "&=" і "+=" тут дещо відрізняються тим, що вони приклеюють це до
старе значення з новим рядком, а не пробілом. Не повинно бути нічого, крім a
коментар після оператора, тобто значення починається з наступного рядка.

визначити VARIABLE :=
перший рядок значення змінної
другий рядок значення змінної
третій рядок значення змінної
endef

перевизначити визначення VARIABLE
...
enddef

Ключові слова перед "define" можуть бути комбінаціями одного з "експорт" або "глобальний" і
«перевизначити».

Якщо вам потрібно, щоб значення змінної містило нові рядки, ви повинні використовувати оператор "define" as
показано (або ви можете призначити значення безпосередньо в Perl). ("endef" був обраний для
сумісність з GNU make. Ви також можете використовувати "enddef".) Це в першу чергу корисно для
"консервовані послідовності команд", наприклад, щось на кшталт цього:

визначити COMPILE_C_PROGRAM
@&echo "Компіляція $(input)"
@$(CC) $(CFLAGS) $(CPPFLAGS) $(ВКЛЮЧИТЬ) -c $(вхід) -o $(вихід)
endef

Тоді ви можете використовувати цю багаторядкову змінну в кількох правилах, наприклад:

%.o : %.c
$(COMPILE_C_PROGRAM)

$(ARCH)/%.o : $(ARCH)/%.c
$(COMPILE_C_PROGRAM)

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

COMPILE_C_PROGRAM = @echo "Компіляція $(input)"; \
$(CC) $(CFLAGS) $(CPPFLAGS) $(ВКЛЮЧИТЬ) -c $(вхід) -o $(вихід)

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

Існує одна особливість при розширенні в межах "define", тобто "define X :=" або на a
змінна, яка вже була ":=", "define X &=" і "define X +=". У цьому випадку
"$(команда оболонки ...)" або вбудований "$(&command ...)" не перетворюють новий рядок у
простори.

Експорт змінні до підпроцеси

експортувати VAR ...
експортувати VAR = значення
замінити значення експорту VAR +=

Перша форма позначає дані змінні для експорту в підпроцеси з будь-яким значенням
тоді змінна має. Друга форма, яка стосується лише однієї змінної, додатково
відразу призначає значення. Допускаються всі варіанти призначення.

Поділ змінні через make-файли

глобальний VAR...
глобальний VAR = значення
замінити глобальне значення VAR &=

Перша форма позначає дані змінні як глобальні для всіх make-файлів. Якщо хтось із них
вже мав значення, це значення переміщується з локальної змінної makefile до глобальної
один. Однак якщо на момент перегляду цього оператора будь-які інші make-файли вже мали файл
значення для будь-якого з них, тоді ці make-файли не бачитимуть глобального.

Друга форма, яка застосовується лише до однієї змінної, додатково присвоює значення права
далеко. Допускаються всі варіанти призначення. Зауважте, що ":=" одразу розгорнеться
до значень у локальному make-файлі. Навпаки, змінні "=" розширяться до
значення на місці використання.

З глобальними змінними може бути складно працювати, тому що makepp може завантажувати файли make-файлів у будь-який
порядку, оскільки виникає потреба створити якусь ціль, для якої не завантажується жодне правило або файли make-файлів.
З цієї причини рекомендується мати a RootMakeppфайл і явно завантажити все
інші, які змінюють або використовують змінну з "load-makefile".

глобальний GLIBLIBS ;= $(shell pkg-config --libs glib-2.0)

Також зверніть увагу, що колись ваш проект може бути створений разом з іншими проектами. Для цього
Тому рекомендується завжди робити ім'я проекту частиною будь-якої глобальної назви змінної.

Цільові Призначення

ціль: VARIABLE = рядок
ціль: VARIABLE := рядок
ціль: замінити рядок VARIABLE +=

Встановлює цільове значення змінної. Діє цільове значення тільки
у дії, яка створює задану ціль. Це в першу чергу використовується для таких речей, як
це:

CFLAGS := -O2

my_prog: file1.o file2.o special_file.o

спеціальний_файл.o : CFLAGS := -g

%.o: %.c
$(CC) $(CFLAGS) -c $(вхід) -o $(вихід)

Тут відбувається те, що всі файли ".c" будуть скомпільовані з оптимізацією ("-O2") крім
"special_file.c", який компілюється в режимі налагодження ("-g"). Це зручний спосіб
вкажіть різні параметри компіляції лише для кількох файлів.

Призначення змінних, що стосуються цілі, подібне до цього, застосовуються лише до дій правила; Вони
не діють під час оцінки цілей або залежностей правила. Якщо правило
має більше однієї цілі, призначення змінних, специфічних для цілі, беруться лише з
перший ціль. Також зверніть увагу, що специфічні для мети змінні makepp дещо відрізняються
від GNU make в тому, що вони застосовуються лише до правила для одного згаданого файлу, а не до
будь-який з його попередників.

Розширення підстановки виконується на цілі, тому ви можете зробити щось подібне:

test_*.o : CFLAGS += -DTEST

Для сумісності з GNU make замість «*» можна використовувати «%».

Змінна Заміна
Правила заміни змінних Makepp подібні до правил інших марок, але дещо
потужніший. Як і в усіх марках, "$(CC)" або "${CC}" обоє представляють значення
змінна CC. Якщо вам потрібен буквальний знак долара, поставте подвійний знак долара ($$), наприклад
це:

ціль: dep1 dep2 dep3 dep4
&rm -f $(вихід)
для файлу в $(входи); do cat $$file >> $(output); зроблено

Крім того, makepp має синтаксис "$[VARIABLE]", який виконує те ж саме, що й інший
два, але перед тим, як makepp гратиме щось інше. Це дозволяє використовувати його для повних правил
та/або умовні:

визначити правило дужки =
ifdef SOME_VAR
дужка:
&echo це правило -o $(вихід)
ENDIF
enddef

$[bracket_rule]

rc-стиль заміна

За замовчуванням makepp використовує заміну в стилі rc (так називається, тому що вона була вперше розроблена
оболонка rc). Це найкраще проілюструвати на прикладі:

МОДУЛІ = abcd

mylib.a : module_dir/$(MODULES).o $(ІНШІ_ОБ'ЄКТИ)
$(CXX) $(залежності) -o $(ціль)

Префікс "module_dir/" додається до кожного слова в MODULES, а суфікс ".o" є
додається до кожного слова.

Ви також можете використовувати заміну в стилі rc, навіть не поміщаючи список слів у a
змінний; синтаксис "$( слово1 слово2)". Зверніть увагу на пробіл між дужками та символом
перше слово. Отже, наведений вище приклад можна було б записати так:

mylib.a : module_dir/$( abcd).o $(OTHER_OBJECTS)
$(CXX) $(залежності) -o $(ціль)

Змінна дає заміну в стилі rc тільки тоді, коли в ній міститься більше одного слова.
Одним словом це як традиційне виготовлення. На жаль, коли змінна порожня, є a
конфлікту. Традиційні засоби просто розгортають його до порожнього рядка. Але коли подумати
це як список, ви хотіли б, щоб "-I$(DIRLIST)" зник, а не давав одинокий "-I". The
рішення полягає в тому, щоб обернути його в список, який починається з пробілу: "-I$( $(DIRLIST))" дає вам
рівно стільки варіантів, скільки слів у списку.

Якщо ви помістите кілька змінних в одне слово, які розгортаються до масивів слів, rc-style
заміна фактично приймає декартовий добуток, тому ви можете зробити щось подібне, якщо
ти хочеш:

DIRS = s1 s2
МОДУЛІ = abc
СУФІКСИ = .o .c
ФАЙЛИ := $(DIRS)/$(MODULES)$(СУФІКСИ)

і FILES міститиме рядок

s1/ao s1/ac s1/bo s1/bc s1/co s1/cc s2/ao s2/ac s2/bo s2/bc s2/co s2/cc

Окрім пробілу, заміна в стилі rc зупиняється на будь-якій цитатці, будь-якій круглій, фігурній чи квадратній
дужки та будь-який із ", : ; = # @". Зауважимо, що це може здивувати, і знову ж таки знадобиться
явний список. Скажімо, ви хочете шукати заголовки за символом підстановки у всіх каталогах
починається з великої літери:

ПОГАНО := [AZ]*/**/*.$( hpp h) # [AZ]*/**/*.hpp */**/*.h
ДОБРО := $( [AZ]*/**/*.)$( hpp h) # [AZ]*/**/*.hpp [AZ]*/**/*.h

Якщо заміна в стилі rc стає на заваді, або якщо вам потрібно мати перевагу або відставання
пробіли у ваших змінних make, то ви можете вимкнути заміну в стилі rc, налаштувавши
змінна "makepp_simple_concatenation=1". Ви можете вимкнути його глобально за командою
рядок або як змінна середовища. Або на основі кожного make-файлу, встановивши змінну в
ваш make-файл. Ви повинні зробити це у верхній частині make-файлу, інакше ви можете зіткнутися з ним
смішні ситуації, коли для одних оцінок використовується заміна в стилі rc, а для інших ні.
(Усі вирази, оцінені перед призначенням, використовуватимуть заміни в стилі rc, і все
вирази, оцінені після will not. З часу оцінювання виразів в
makefiles є складним і не завжди очевидним з порядку операторів у
makefile, найкраще встановити «makepp_simple_concatenation» якомога раніше.) Ви можете
навіть встановити його лише для однієї цілі:

ціль: makepp_simple_concatenation = 1
ціль:
&echo before_first$(LIST)after_last -o $(вихід)

Оскільки "$[VARIABLE]" оцінюється раніше, ніж "$(VARIABLE)", поєднуючи обидва в rc-
заміна не дасть результату, який ви можете очікувати, якщо ви не загорнете його в явний
список:

A = ab
N = 1 2
ПОГАНО := $(A)$[N]
ДОБРО := $(A)$( $[N])

Останні рядки читаються як

ПОГАНО := $(A)1 2 # a1 b1 2
ДОБРО := $(A)$( 1 2) # a1 a2 b1 b2

Заміна посилання

Посилання на заміну має вигляд "$(VAR:A=B)", де A - це шаблон для відповідності, а B -
візерунок для його заміни. Посилання на заміну є абревіатурою для
функція "patsubst". Наприклад:

source_files = ac bc cc dc
object_files = $(source_files:%.c=%.o)

встановить для "$(object_files)" значення "ao bo co do". "%" - це відповідність спеціального символу
будь-який довільний рядок. Якщо обидва A і B починаються з "%", звичайний випадок при заміні
суфікси, їх можна опустити:

object_files = $(source_files:.c=.o)
object_files = $(source_files:c=o) # те саме, тому що . не є особливим

Пробіл in змінні

Якщо вам потрібно контролювати пробіли у змінній, ви повинні (наразі) вимкнути rc-style
підстановка (за допомогою налаштування "makepp_simple_concatenation=1"), а потім використовувати синтаксис, подібний до цього:

нуль =
T = -o $(нуль)

або, з порожньою оцінкою:

T = -o $()

Коли ви робите це, змінна "T" містить "-o", за яким слідує пробіл.

Такий метод обробки пробілів не рекомендується. Якщо вам потрібні змінні
у вашому make-файлі, щоб містити пробіли, вам слід серйозно подумати про те, що ви робите.
Якщо вам потрібно обробляти пробіли, зазвичай набагато краще помістити код Perl у ваш
makefile, щоб подбати про це (використовуючи оператори "perl_begin" або "sub"), або обробити це
в операторах оболонки в діях правил.

Такі випадки зазвичай виникають, коли люди намагаються використовувати одні й ті самі правила для різних
архітектури, які не використовують типовий синтаксис команд Unix. Наприклад, іноді бачить
такі речі в make-файлах:

ifeq ($(ARCH),weirdarch)
O := /ВИХОД=
ще
нуль :=
O := -o $(нуль)
ENDIF

%.o : %.c
$(COMPILER) $(вхід) $(O)$(вихід)

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

ifeq ($(ARCH),weirdarch)
%.o : %.c
$(WEIRD_COMPILER) $(вхід) /OUTPUT=$(вихід)
ще
%.o : %.c
$(CC) -c $(вхід) -o $(вихід)
ENDIF

Пробіли ніколи не допускаються в іменах змінних, а лише в їх значеннях. Це інше
від деяких роблять реалізації.

автоматичний Змінні
Автоматичні змінні — це змінні, які приймають різні значення залежно від правила
вони оцінюються в. Makepp підтримує більшість автоматичних змінних, які інші
версії make use. Крім того, він має менш загадкові, довші назви для більшості з них
які ви можете використовувати замість них. (Для застарілих файлів make-файлів, які перевизначають ці імена, файл
визначення в make-файлі перекриває значення за замовчуванням. Наприклад, якщо ви скажете
"target = abc" у вашому make-файлі, тоді "$(target)" завжди розгортатиметься до "abc", і не
довше бути еквівалентним $@.)

Нижче наведено повний список усіх автоматичних змінних, які підтримує makepp:

вихід
мета
$@ Ціль поточного правила. Насправді, оскільки makepp підтримує кілька цілей для
будь-яке правило, це перший ціль. Наприклад, у наступному правилі

y.tab.c y.tab.h : парсер.y
$(YACC) -o $(вихід) $(YFLAGS) $(вхід)

"$(output)" міститиме значення y.tab.c. Оскільки ці магічні змінні насправді є
функцій, ви також можете передати індекс як аргумент. Це відлік від 1 або назад
від -1. Отже, "$(вихід 2)" або "$(вихід -1)" міститиме значення y.tab.h.

Хоча всі три форми цієї змінної мають однакове значення, є різниця в
інтерпретація для багатоцільових правил. Якщо ви використовуєте загадкове ім’я старого стилю $@,
makepp інтерпретуватиме це як набір правил старого стилю, а не як сучасне правило
створює всі ці цілі за один раз:

ab: # дійсно: по одному правилу для a і b
торкніться $@

cd: # помилка: mpp скаржиться, що це не створило d
торкніться $(вихід)

виходи
цілі
Усі цілі поточного правила. Те саме, що і "$(target)", якщо їх не більше одного
ціль. У наведеному вище прикладі "$(виходи)" буде y.tab.c y.tab.h. Ви можете передати
індексний список, тож "$(виходи 2 1)" буде y.tab.h y.tab.c.

залежність
вхід
$< Перша явна залежність правила. Наприклад, у цьому правилі

%.o : %.c
$(CC) $(CFLAGS) -c $(вхід) -o $(вихід)

"$(input)" буде ім'ям .c файл, незалежно від чого .h файли makepp
відкриває. Якщо ви вкажете більше однієї залежності, ви можете отримати їх, передавши файл
індекс: "$(input $(INDEX))" - це INDEX-а залежність.

залежно
витрати
$^ Усі явні залежності цілі, не включаючи .h файли, виявлені
makepp_scanning для включень.

Наприклад, у правилі

myprog.o : *.o
$(CC) $(CFLAGS) $(входи) -o $(вихід)

"$(inputs)" буде всіма файлами .o в каталозі. Ви можете вибрати лише ті, які ви
потрібно, передаючи список індексів. Якщо ви явно вкажете різні типи файлів,
ви можете вибрати їх, як у "$(входи 2 3 4)" (але з підстановочним знаком це не надто
перспективний).

відсортовані_залежності
відсортовані_входи
$+ Усі залежності цілі, у відсортованій послідовності, з вилученими дублікатами.
Еквівалент "$(сортувати $(входи))".

змінені_залежності
змінені_входи
$? Залежності цілі, що змінилися. Це включає лише явні
залежності (тобто ті, які ви перераховуєте в make-файлі), неявно виявлені
залежності від сканування (наприклад, файли .h).

Це зазвичай використовується в таких командах:

libmine.a : $(MODULES) : build_check ignore_action
$(AR) ru $@ $?

тобто ar сказано замінити лише ті модулі, які змінилися. (Зверніть увагу на
Правило перевірки збірки "ignore_action". Якщо ви не вкажете це, makepp примусить
дію, яку потрібно виконувати щоразу, коли вона змінюється. Якщо жодних залежностей не змінилося, файл
рядок дії буде "ar ru libmine.a", що, ймовірно, відрізняється від того, що було
востаннє, коли ви його запускали, тому без "ignore_action" makepp виконає його. У цьому
у випадку, це нешкідливо, але з іншими командами це може бути проблемою. Побачити
makepp_build_check, щоб дізнатися більше про "ignore_action".)

Створення подібних архівів не є гарною ідеєю, оскільки це зменшить ваші збірки
надійний. Проблема в тому, що якщо ви створюєте архів, то видаляєте один з
модулі зі списку МОДУЛІ, модулі залишаться в архіві і
makepp

стебло
$* Основа в шаблонному правилі (тобто, незалежно від того, що відповідає '%'). Як варіант, якщо це
не є шаблонним правилом, повертає ім’я файлу без розширення (тобто це
еквівалентно "$(базова назва $(вхід))".

Це переважно для зворотної сумісності. Наприклад, у старих версіях make the
єдиний спосіб сказати йому, як компілювати будь-який .c файл у відповідний .o файл був схожий
це:

.co:
$(CC) $(CFLAGS) -c $*.c -o $*.o

Це поганий спосіб написати правило. Набагато зрозуміліше використовувати стиль GNU-make
шаблонні правила, наприклад:

%.o : %.c
$(CC) $(CFLAGS) -c $(вхід) -o $(вихід)

для кожного
Поточна назва файлу з пропозиції "foreach". речення "foreach" рідко використовуються,
але вони є найбільш універсальним типом шаблонного правила, яке підтримує makepp. Для
наприклад,

#
# Створіть файли .c за допомогою якогось спеціального препроцесора:
#
%.c : %.k
$(препроцесор) $(вхід) > $(вихід)

#
# Компілюйте файли .c у файли .o:
#
%.o : %.c
$(CC) $(CFLAGS) -c $(вхід) -o $(вихід)

#
# Спеціальні альтернативні прапори компіляції для файлів .c, які є похідними
# з файлів .k:
#
$(foreach:%.k=%.o) : $(foreach:%.k=%.c) : foreach *.k
$(CC) $(SPECIAL_K_FLAGS) -c $(вхід) -o $(вихід)

Додаткову інформацію та приклади дивіться в документації щодо положення foreach у правилах.

$/ Це, по суті, константа, або «/», або у рідній Windows «\». Вам це потрібно, якщо
ви хочете запустити програму портативно, наприклад, ту, яку ви вбудували в поточний каталог:

мій вихід:
.$/myprog >$(вихід)

Для імен файлів, які передаються як аргументи, це не так необхідно, оскільки Windows може обробляти Unix
там синтаксис.

варіант Змінні
Ви можете встановити їх усіма способами, описаними вище (за винятком випадків, коли вказано інше), щоб змінити
поведінка makepp. За замовчуванням усі вони не визначені.

MAKEPP_DEBUG
Якщо ви експортуєте це з істинним значенням перед викликом makepp, ви отримаєте більше налагодження
інформація. Це "RULE_SOURCE" файлів, створених, поки він діє під
makeppinfo, mppi та подробиці про розширення змінних і відповідність правилам
makepplog, mppl. Це також покаже вам, якщо у makepp закінчиться пам’ять або зависає,
тому що він нескінченно розширює ті самі змінні:

A = $A # відкладене оцінювання, потрібно :=
B = $C
C = $B

MAKEPP_LN_CP
Дивіться примітку під &ln.

makepp_percent_subdirs
Встановіть для цього значення певне істинне значення (наприклад, 1), щоб відповідність "%" у цілях або залежностях
в більш ніж одному каталозі.

makepp_require_phony
Встановіть для цього значення істинне (наприклад, 1), щоб запобігти неявній фальшивості (тобто якщо правило
досягає успіху, не досягаючи своєї мети). Ця змінна має бути істинною за замовчуванням, щоб
запобігти розриву ланцюжків залежностей, але це порушить зворотну сумісність з
неакуратні make-файли.

makepp_signature_C_flat
Це варіант для підпису C. Встановіть для цього значення істинне (наприклад, 1), щоб обробити ваш
джерела як зведені, тобто всі нові рядки (крім операторів препроцесора).
розглядаються як пробіли та директиви "#line" ігноруються.

makepp_simple_concatenation
Встановіть для цього значення істинне значення (наприклад, 1), щоб запобігти "підстановці в стилі rc".

PERL
Ви можете встановити це саме той perl, який ви використовуєте для запуску сценаріїв у makepp
пакет і експортуйте його. Це може допомогти запускати підскрипти з тим самим perl. Це
в основному корисний для тестового набору, встановлення та для рекурсивних збірок.

VPATH
Встановлення цієї змінної на якесь значення неявно викликає "vpath % value".

Наперед визначено Змінні
Makepp попередньо визначає кілька змінних, які ви можете замінити:

AR За умовчанням: "ар".

АРФЛАГИ
За умовчанням: "rv".

AS За умовчанням: "як".

CC За умовчанням: Перший знайдений серед "gcc", "egcc", "pgcc", "c89" або "cc" або в Windows
додатково "cl" або "bcc32".

CFLAGS
За умовчанням: Якщо "$(CC)" є компілятором GNU "-g -Wall", якщо це одна з двох Windows
компілятори нічого, інше "-g".

КУРДИР
Каталог, у якому знаходиться поточний Makefile.

CXX За умовчанням: Перший знайдений серед "g++", "c++", "pg++", "cxx", "C""C" або "aCC", або на
Windows додатково "cl" або "bcc32".

CXXFLAGS
За умовчанням: Якщо "$(CXX)" є компілятором GNU "-g -Wall", якщо це одна з двох Windows
компілятори нічого, інше "-g".

F77 За умовчанням: Перший знайдений серед "f77", "g77" або "fort77".

FC За умовчанням: "$(F77)".

LD За умовчанням: "ld".

LEX За умовчанням: Перший знайдений серед "lex" або "flex".

LIBTOOL
За умовчанням: «libtool».

ЗРОБІТЬ
Ця змінна має два різні значення, залежно від наявності чи відсутності
"--traditional-recursive-make". Makepp розпізнає, коли ця змінна використовується і
вимикає деякі функції навіть до того, як рекурсія дійсно має місце. Це може бути
небажано, поки ви поступово виключаєте його, тому спочатку конвертуйте виклики в a
makepp специфічний "$((MAKE))", який не вимикає функції. Ви не повинні його встановлювати
тому що це порушує нашу розумну рекурсію.

ПОСТАНОВИТЬ ЦІЛІ
Ця змінна встановлена, але не використовується makepp. Ви можете запитати його, щоб щось зробити, лише якщо
була запитана певна ціль.

За умовчанням: Будь-яка явна ціль, яку надає користувач (або рекурсивний виклик).
Порожній при неявному створенні цілі за замовчуванням.

ifneq $(фільтр спеціальна ціль, $(MAKECMDGOALS))
# спеціальна ціль є однією з поточних явних цілей
інакше ifeq $(MAKECMDGOALS)
# немає явних цілей
ENDIF

MAKEFLAG (експортується)
Стандартні параметри, за допомогою яких викликався makepp. Ті, що мають одну букву
форми об’єднуються на початку без провідного «-» (небо знає, чому gmake вибрав
скинути «-»).

MAKEINFO
За умовчанням: «makeinfo».

MAKEPPFLAGS (експортується)
Це значення має те саме значення, що й MAKEFLAGS, але лише якщо ця змінна присутня в
оточення makepp.

_MAKEPPFLAGS (експортовано)
Конкретні параметри makepp, необхідні для сумісності POSIX/gmake, з якими makepp
називався. Вони знаходяться в окремій змінній, тому застарілий make-файл не може зламати
сумісність, вимкнувши MAKEFLAGS. Це встановлюється лише за допомогою
"--traditional-recursive-make".

MAKEPP_VERSION
Версія makepp, з якою ви працюєте. Якщо це бета-версія, вона матиме файл
дефіс, за яким слідує РРММДД, а також деякі внутрішні дані. Ви можете використовувати це для "ifdef"
щоб приховати конкретні конструкції makepp від інших марок.

За умовчанням: Те саме значення відображається "makepp --version"

PWD Псевдонім для "CURDIR".

RM За умовчанням: "rm -f". Це призначено для застарілих Makefiles. Для нових бажано використовувати
безпосередньо вбудовану команду &rm. Якщо ви хочете написати фальшиве чисте правило, подивіться
замість цього введіть команду makeppclean -r.

ROOT
Відносний шлях до кореня вашої системи збірки, тобто до каталогу, який знаходиться далі
який у вас є "RootMakeppfile(.mk)". Якщо у вас її немає, ця змінна є
порожній.

SHELL
Ця змінна поважається, лише якщо ви її "експортуєте". У цьому випадку це Shell
який використовується для виконання невбудованих дій з деяким спеціальним символом (звичайним
які виконуються безпосередньо). На Windows Strawberry або ActiveState Perl, якщо у вас є
Unix-подібна оболонка, замість цього потрібно встановити для змінної SHELL значення, яке закінчується на "sh"
або "sh.exe" перед тим виклик makepp.

За умовчанням: Перший знайдений серед "/usr/xpg4/bin/sh" (наприклад, Solaris) або "/sbin/xpg4/sh"
(наприклад, Reliant Unix) або "/ Бен / ш".

YACC
За умовчанням: Перший знайдений серед "bison -y" або "yacc".

Змінні та Perl
Значення змінних зберігаються як звичайні скаляри Perl, тому ви можете отримати до них доступ безпосередньо з
Perl-код, якщо вам потрібно виконати якісь складні маніпуляції з ним; див. makepp_extending
for details.

Доступ до глобальних змінних з Perl досягається шляхом додавання до них префікса "Mpp::global"
пакет. Фактично будь-яка змінна, ще не присутня в поточному make-файлі, і яку ви
assign to в цьому пакеті відтепер буде глобальним, як ніби ви щойно випустили
«глобальна» заява про це.

Цей прямий доступ, однак, схильний до помилок! Можливо, користувач змінив ці змінні
в командному рядку або через середовище. Якийсь інший make-файл, завантажений до цього
можна зробити змінну глобальною або цільовою. У цих випадках ви не будете
знайти значення змінної, або, призначаючи її, може забрати її властивість
(еквівалентно модифікатору "перевизначити", за винятком особливостей цілі.)

Завдяки прямому доступу ви також обходите розширення цих змінних, якщо вони мають тип
"=" або ";=". Спеціальні змінні, такі як "$(CC)", починаються як функції, поки вони не є
присвоєно. Тому в багатьох випадках ви не побачите їх цінності.

З цих причин краще дозволити makepp визначити правильне значення. Ви можете використовувати
Варіант "makeperl", у якому змінна була оцінена до отримання коду Perl
інтерпретував:

makeperl { $$current_value = '$(MAKEFILE_VAR)' }

Якщо вам потрібна змінна в блоках perl makefile, це досягається за допомогою змінної Perl
$makefile наступним чином:

perl { $current_value = $makefile->expand_variable('MAKE_VAR')}

Функції завжди отримують об’єкт makefile, який передається як другий аргумент $_[1]:

sub f_f { $current_value = $_[1]->expand_variable('MAKE_VAR')}

Передбачається, що команди викликаються в дії правила, де знаходиться об’єкт makefile
доступний через "$Mpp::Subs::rule->{MAKEFILE}":

sub c_cmd { $current_value = $Mpp::Subs::rule->{MAKEFILE}->expand_variable('MAKE_VAR')}

Використовуйте makepp_variables онлайн за допомогою служб onworks.net