makepp_rules - Trực tuyến trên đám mây

CHƯƠNG TRÌNH:

TÊN

makepp_rules - Cách yêu cầu makepp xây dựng thứ gì đó

MÔ TẢ

?: &,
-,
@, B: : build_cache,
: build_check, D: :gửi đi, E: : env, I: "ignore_error",
:bao gồm, L: :cơ hội cuối cùng, M: trang điểm, N: "noecho", P: : parser,
"perl", S: :Chữ ký

Quy tắc là những gì cho makepp biết cách tạo một tệp hoặc một lớp tệp. Makepp hỗ trợ
cú pháp quy tắc tương tự như các triển khai khác của make, cộng với một số bổ sung của riêng nó.

Quy tắc có định dạng chung

target_expression: dependency_expression [: các đối số tùy chọn]
hành động

Danh sách mục tiêu không được chứa bất kỳ biến tự động nào (ngoại trừ "$ (foreach)"). Các
danh sách phụ thuộc có thể chỉ chứa các biến tự động tham chiếu đến mục tiêu (ví dụ:
"$ (đầu ra)", "$ (đầu ra)" hoặc từ đồng nghĩa của chúng). Hành động có thể chứa bất kỳ tự động nào
biến.

Nếu makepp quyết định rằng quy tắc cần được thực thi, thì mỗi dòng của quy tắc sẽ được thực thi
tuần tự, và nếu có bất kỳ trả về trạng thái khác XNUMX, phần còn lại không được thực thi (và
makepp hủy bỏ với lỗi trừ khi bạn chỉ định tùy chọn "-k" trên dòng lệnh.)
Mỗi hành động chỉ nên có một dòng. Nếu một hành động quá dài để viết thuận tiện trên
một dòng, bạn có thể chia nó thành nhiều dòng và đặt dấu gạch chéo ngược để biểu thị rằng
một số dòng nên được kết hợp thành một.

Để phân biệt các hành động với quy tắc tiếp theo, hành động đó nên được thụt lề nhiều hơn
so với dòng chứa các mục tiêu và phụ thuộc. Không giống như các triển khai khác của
make, makepp không thực sự quan tâm đến mức độ bạn thụt lề hay bạn có sử dụng các ký tự tab hay không
hơn là khoảng trắng. Để giữ khả năng tương thích ngược với cách làm truyền thống, các quy tắc
makepp sử dụng để quyết định khi nào các hành động kết thúc và quy tắc tiếp theo bắt đầu hơi phức tạp:

· Dòng hành động đầu tiên phải được thụt vào nhiều hơn dòng chứa mục tiêu.

· Nếu một dòng được thụt lề bởi một ký tự tab hoặc 8 khoảng trắng trở lên, thì nó được coi là
một dòng hành động.

· Một dòng trống hoặc một dòng chú thích với ký tự "#" ở lề phải kết thúc
quy tắc, trừ khi dòng không trống tiếp theo được thụt vào nhiều hơn 8 khoảng trắng (hoặc nhiều hơn một
chuyển hướng).

· Nếu một dòng được thụt vào nhiều hơn hoặc nhiều hơn dòng hành động đầu tiên, thì nó là
được coi là một dòng hành động bổ sung.

Có một số mục hành động đặc biệt:

& Biểu tượng này sẽ được theo sau bởi một tên lệnh và bất kỳ số lượng đối số nào. Vỏ bọc
cú pháp không được hiểu đầy đủ ở đây, chỉ có dấu ngoặc kép và dấu ngoặc kép và dấu gạch chéo ngược
các ký tự bên trong, cũng như trong suốt makepp. Tên lệnh dẫn đến một hàm
"NS_Tên" được gọi với các chuỗi còn lại làm đối số. Nếu một chức năng như vậy có thể
không được tìm thấy, điều này giống với việc gọi "run" từ một khối "perl".

Điều này cho phép gọi một cách hiệu quả một lệnh tích hợp sẵn, do makefile cung cấp hoặc lệnh bên ngoài.
Tiền tố "&" đã được chọn vì nó là hàm gọi hàm trong Perl và vì
lúc đầu nó là bất hợp pháp trong Shell.

$ (ROOT) / bao gồm /%. H:% .h
& ln $ (đầu vào) $ (đầu ra)

tiếng vọng lại
@ Thông thường, mỗi lệnh shell được in khi nó được thực thi. Tuy nhiên, nếu từ đầu tiên
của hành động là "noecho" (hoặc nếu nó bắt đầu bằng ký tự "@"), thì lệnh
không được in. Ví dụ,

% .o:% .cxx
noecho $ (LIBTOOL) --mode = biên dịch $ (CC) -c $ (đầu vào)

Điều này có nghĩa là khi lệnh libtool được thực thi, nó sẽ không được in ra. (Libtool
bản thân nó thường in lệnh đã sửa đổi mà nó thực thi, vì vậy nó là thừa để
in nó hai lần.)

bỏ qua_error
- Thông thường, nếu lệnh shell trả về trạng thái khác XNUMX, thì makepp sẽ hủy bỏ vì
lệnh không thành công. Tuy nhiên, một số chương trình đặt sai trạng thái khi thoát hoặc
có thể có một lỗi thực sự không nghiêm trọng và không nên hủy bỏ toàn bộ
biên dịch. Bạn có thể khiến makepp bỏ qua trạng thái trả lại bằng cách chỉ định
"ignore_error" là từ đầu tiên của dòng lệnh (hoặc "-" là ký tự đầu tiên).
Ví dụ,

$ (phân phối rởm):
ignore_error rm -r my_program - $ (VERSION) # Loại bỏ rác trước đó.
& mkdir my_program - $ (VERSION)
& cp $ (FILES) my_program - $ (VERSION)
tar cf my_program - $ (VERSION) .tar my_program - $ (VERSION)

Lệnh này tạo một thư mục, sao chép một loạt các tệp vào đó, sau đó đặt
mọi thứ vào một tệp tar để phân phối. Đó là một ý tưởng hay để làm sạch
nội dung trước đó của thư mục, nếu có bất kỳ thứ gì ở đó trước đây và đó là
dòng đầu tiên làm gì. "Rm" có thể không thành công, nhưng trạng thái trả về của nó bị bỏ qua.

perl
người tạo ra
Điều này về cơ bản giống với câu lệnh perl, nhưng nó được thực hiện mỗi khi
chạy quy tắc, không phải khi đọc makefile. Biến thể đầu tiên là Perl đơn giản
mã, trong khi biến thể thứ hai lần đầu tiên chuyển câu lệnh qua biến Make-style
sự bành trướng.

Đối với hai khả năng của việc đặt mắc cài của cơ thể, hãy xem giải thích tại
"perl_perlcode" trong makepp_statements. Lưu ý rằng biến thể thứ ba đã giải thích ở đó
không có nghĩa ở đây, bởi vì tất cả các dòng hành động phải được thụt lề. Bạn phải ra hiệu
thất bại trong câu lệnh Perl, bằng cách gọi "die".

Theo quy tắc, các câu lệnh Perl hiện được đánh giá trong một quy trình con chung, ngoại trừ trên
Các cửa sổ. Điều đó có nghĩa là họ chỉ có quyền đọc đối với bất kỳ biến makefile nào. Nó cũng là
quy trình thực hiện các hành động không phải Perl. Vì vậy, việc gọi thực thi hoặc thoát sẽ gây nhầm lẫn
trang điểm. Nhưng điều này có thể thay đổi trong tương lai. Để có cách gọi Perl hiệu quả
script, hãy xem mục trước "&" hoặc "run".

$ (phiên bản rởm):
noecho perl {{# $ (target) & $ (VERSION) từ Perl:
print "Đây là" .f_target (). "$ VERSION \ n";
}}
echo Bạn có thể kết hợp điều này với các lệnh Shell
-makeperl {print "Đây là $ (target) $ (VERSION) \ n"}

Có một số loại quy tắc khác nhau, mỗi loại có mục đích khác nhau.

Rõ ràng Nội quy
target1 target2: dependency1 phụ thuộc2 ...
các hành động được thực hiện

Cú pháp này chỉ định điều đó để làm cho mục tiêu1 or mục tiêu2, tất cả các tệp tin
phụ thuộc1, phụ thuộc2, v.v., phải đã được thực hiện. Sau đó, các hành động đã cho là
được thực thi bởi shell để tạo ra các mục tiêu.

Quy tắc rõ ràng đầu tiên trong tệp là mục tiêu mặc định và được thực hiện nếu bạn không chỉ định
bất kỳ mục tiêu nào trên dòng lệnh.

Không giống như các chương trình tạo truyền thống, makepp thường giả định rằng một lệnh gọi hành động
tạo tất cả các mục tiêu (trừ khi không có phụ thuộc). Ví dụ, một lời kêu gọi
của yacc tạo cả hai tệp đầu ra cho quy tắc này:

y.tab.c y.tab.h: parser.y
$ (YACC) -d parser.y

Lưu ý rằng các triển khai khác của make không có khái niệm về một lệnh duy nhất
tạo ra nhiều tệp đầu ra và vì vậy khi bạn chỉ định nhiều mục tiêu, chúng sẽ
thực hiện quy tắc một lần cho mỗi mục tiêu. Makepp sẽ hoàn nguyên về hành vi này nếu nó trông giống như
đây là một makefile kiểu cũ. Cụ thể, nó sẽ thực thi quy tắc một lần cho mỗi mục tiêu,
thay vì chỉ một lần về tổng thể, nếu tất cả những điều sau đây đều đúng:

· Hành động quy tắc đề cập đến biến tự động $ @. (Từ đồng nghĩa "$ (output)" hoặc
"$ (target)" không kích hoạt hành vi này.)

· Hành động quy tắc không đề cập đến biến tự động "$ (đầu ra)" (hoặc từ đồng nghĩa của nó
"$ (mục tiêu)").

· Đây không phải là một quy tắc khuôn mẫu, và không có mệnh đề bất thường.

Ví dụ,

tất cả cài đặt thử nghiệm:
cho subir trong $ (SUBDIRS); làm cd $$ Subir && $ (MAKE) $ @; đĩa CD ..; xong

là một thành ngữ phổ biến trong makefiles và makepp ủng hộ nó. (Lưu ý rằng bạn không bao giờ được sử dụng
đệ quy thực hiện trong bất kỳ tệp trang điểm mới nào bạn viết - sử dụng câu lệnh "load_makefile" hoặc
tải makefile ngầm thay thế.)

Nếu bạn muốn có cùng một quy tắc được thực thi một lần cho mỗi mục tiêu (ví dụ: vì các mục tiêu
có các lệnh tương tự), nên sử dụng quy tắc mẫu (xem bên dưới) hoặc
mệnh đề "foreach". Ví dụ, nếu với một chương trình tạo truyền thống, bạn sẽ viết:

A B C D:
do_something để xây dựng $ @> $ @

trong makepp, bạn có thể muốn viết nó như thế này:

$ (foreach):: foreach abcd
do_something để xây dựng $ (output)> $ (output)

Giả mạo mục tiêu

A giả mạo mục tiêu là một mục tiêu sẽ không bao giờ thực sự tồn tại trong hệ thống tệp; nó chỉ là một
cách để makepp xây dựng một số mục tiêu và có thể thực hiện một số lệnh bổ sung.

Mục tiêu giả mạo điển hình là "tất cả", thường được sử dụng để gây ra mọi thứ có thể
được xây dựng để được xây dựng, như thế này:

tất cả: prog1 prog2 subir / prog3 subir2 / libmine.a
@ & echo "Đã xong!"

Nếu bạn nhập "makepp all" hoặc nếu bạn đặt tất cả là mục tiêu rõ ràng đầu tiên trong makefile của mình
(đó là điển hình) và chỉ cần nhập "makepp", sau đó nó sẽ làm cho tất cả các phần phụ thuộc
được xây dựng, sau đó nó sẽ in "Tất cả đã xong!". Tại thời điểm này, makepp sẽ tìm kiếm tệp ./tất cả các
và sẽ phát hiện ra rằng nó không tồn tại. Nó sẽ kêu ca ầm ĩ.

Để giữ cho makepp không mong đợi tệp ./tất cả các để thoát, bạn cần nói với nó rằng đó là một
mục tiêu rởm. Chỉ cần đặt một dòng như sau vào tệp makefile của bạn (nó không có gì khác biệt
ở đâu):

.PHONY: tất cả

Một giải pháp thay thế tương đương đôi khi thuận tiện hơn là sử dụng "$ (giả mạo)"
chức năng, như thế này:

$ (tất cả giả mạo): prog1 prog2 subir / prog3 subsir2 / libmine.a

Các mục tiêu giả trong một makefile có thể tham chiếu đến các mục tiêu giả trong một makefile khác. Đây là
thường được thực hiện với mục tiêu "sạch", như sau:

# Makefile cấp cao nhất:
# rất nhiều quy tắc và nội dung ở đây
# ...
$ (sạch rởm): subir1 / sạch subir2 / sạch
& rm -fm my_program

Sau đó, trong các thư mục con, các tệp makefiles có thể đọc như thế này:

# Makefile trong một thư mục con
#...
$ (sạch rởm):
& rm -fm $ (ký tự đại diện * .o * .a)

Nhưng ngày nay bạn sẽ sử dụng lệnh "makeppclean" thay vì một mục tiêu sạch.

Ký tự đại diện

Sẽ an toàn khi chỉ định các ký tự đại diện trong danh sách phụ thuộc. Các ký tự đại diện không chỉ khớp với các tệp
tồn tại, nhưng các tệp có thể được tạo với các quy tắc trong makefile. Ví dụ,
để xây dựng một thư viện từ tất cả các tệp .o trong một thư mục, bạn có thể viết như sau:

libmine.a: * .o
& rm -f $ (đầu ra)
ar cr $ (đầu ra) $ (đầu vào)

Điều này sẽ hoạt động ngay cả khi chưa có tệp ".o" nào được tạo, vì makepp's
các ký tự đại diện khớp với các tệp chưa tồn tại nhưng có thể được tạo. Điều này thậm chí sẽ nhận
các tệp có quy tắc được phát hiện sau đó (trong cùng một makefile hoặc một tệp chưa được đọc). Trong này
điểm cuối cùng, nó khác với hàm "ký tự đại diện", được giới hạn trong các quy tắc đã biết,
vì nó phải trả về kết quả của nó khi nó được mở rộng.

Makepp hỗ trợ tất cả các ký tự đại diện shell thông thường ("*", "?", Và "[]"). Nó cũng có một
ký tự đại diện "**" khớp với bất kỳ số lượng thư mục can thiệp nào. (Ý tưởng này đã bị đánh cắp
từ zsh.) Ví dụ: "** / *. c" khớp với tất cả .c các tệp trong toàn bộ cây nguồn.
"object / ** / *. o" khớp với tất cả .o các tệp được chứa ở bất kỳ đâu trong thư mục con đối tượng
hoặc bất kỳ thư mục con nào của nó hoặc bất kỳ thư mục con nào của chúng. Ký tự đại diện "**" sẽ không
theo các liên kết mềm đến các thư mục ở bất kỳ cấp độ nào. Nó cũng sẽ không bao giờ trả lại các mục tiêu giả mạo.

Các ký tự đại diện của Makepp sẽ bỏ qua các tệp hoặc thư mục tồn tại nhưng không thể đọc được. Sau
tất cả, các tệp như vậy không thể được sử dụng trong quá trình xây dựng. Đưa các tệp không đọc được vào một
thư mục chủ yếu hữu ích để ngăn chặn việc nhập tự động tệp đã cho từ một
kho.

Khẳng định ban đầu là điều này là an toàn. Đây là lý do mà nó hoạt động cho dù
các tệp đã tồn tại hoặc cần được tạo trước. Tuy nhiên nó là không an toàn trong sence
rằng nó sẽ vẫn khớp với các tệp được tạo bởi makepp, nhưng không còn có quy tắc nữa (ví dụ:
bạn đã loại bỏ .c tệp, nhưng .o tệp vẫn ở đó.) Để ngăn điều này, hãy sử dụng
Tùy chọn "--rm-cũ".

Họa tiết quy tắc
Quy tắc mẫu là quy tắc được áp dụng dựa trên một số mẫu văn bản. Điều này được sử dụng để
áp dụng quy tắc tương tự cho toàn bộ lớp tệp. Cú pháp giống như của GNU make
quy tắc mẫu:

% .o:% .c
$ (CC) -c $ (đầu vào) -o $ (đầu ra)

Điều này nói rằng bất kỳ tệp nào trong thư mục hiện tại khớp với "* .c" đều có thể được chuyển đổi thành
tệp .o tương ứng bằng cách sử dụng lệnh đã cho.

Lưu ý rằng một số phụ thuộc mẫu có thể được cung cấp. Ví dụ, nếu xyz.o hồ sơ
phụ thuộc vào tương ứng xyz.cpp và cả trên một tệp được gọi là moc_xyz.cflags cái nào
chứa các tùy chọn trình biên dịch, điều này có thể được thể hiện bằng:

% .o:% .cpp% .cflags
$ (CXX) `cat $ (gốc) .cflags` -c $ (đầu vào) -o $ (đầu ra)

Bạn cũng có thể có một số mục tiêu mẫu. Ví dụ,

% .tab.h% .tab.c:% .y
yacc -d $ (đầu vào)
& mv y.tab.h $ (gốc) .tab.h
& mv y.tab.c $ (gốc) .tab.c

Thông thường, các quy tắc mẫu chỉ tìm kiếm các tệp trong các thư mục hiện tại. Bạn có thể buộc
chúng để tìm kiếm trong thư mục hiện tại và tất cả các thư mục bên dưới nó bằng cách thiết lập

makepp_percent_subdirs: = 1

trước quy tắc mẫu đầu tiên trong makefile của bạn hoặc trên dòng lệnh chẳng hạn.

Có sự khác biệt rõ ràng giữa "%" và ký tự đại diện "*", mặc dù cả hai đều khớp với bất kỳ
string: Ký tự đại diện trả về danh sách các tệp được sử dụng hoàn toàn tại thời điểm đó. Vì thế
điều này phụ thuộc vào tất cả .o tệp có thể xây dựng ở đây:

prog: * .o
$ (LD) $ (LDFLAGS) $ (đầu vào) -o $ (đầu ra)

Không thể đạt được điều này bằng cách thay thế "*" bằng "%", vì cái sau dành cho từng người một
đối sánh đầu vào với đầu ra, tạo ra một quy tắc nội bộ cho mỗi gốc phù hợp.

tĩnh Belt Hold quy tắc
Quy tắc mẫu tĩnh là quy tắc mẫu chỉ được áp dụng cho một nhóm tệp giới hạn:

$ (ĐẶC BIỆT_MODULES) .o:% .o:% .cpp
$ (CXX) -c $ (đầu vào) -o $ (đầu ra)

Điều này nói rằng quy tắc mẫu chỉ áp dụng cho các tệp trong "$ (ĐẶC BIỆT_MODULES) .o".

Điều này chủ yếu là để tương thích với GNU make; quy tắc foreach (xem bên dưới) là một
cách mạnh mẽ để làm điều tương tự.

Cho mỗi quy tắc
Cú pháp quy tắc mẫu ở trên đủ mạnh để hỗ trợ hầu hết các bản dựng, nhưng
đôi khi nó là cần thiết để làm một cái gì đó phức tạp hơn. Makepp cung cấp thêm
cú pháp mạnh mẽ: mệnh đề ": foreach" cho quy tắc.

target_expression: dependency_expression: foreach file-list
hành động

Loại quy tắc foreach đơn giản nhất chỉ là quy tắc mẫu có ứng dụng bị hạn chế
vào một danh sách cụ thể của các tệp. Ví dụ: giả sử bạn có một quy tắc mẫu cho biết
makepp làm thế nào để biên dịch tất cả .c các tập tin. Tuy nhiên, bạn có một danh sách .c tập tin cho bạn
muốn làm cái gì đó khác không. Bạn có thể làm điều gì đó như sau:

# Đây là quy tắc áp dụng cho mọi thứ:
% .o:% .c
$ (CC) $ (CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

% .o:% .c: foreach $ (ĐẶC BIỆT_MODULES)
$ (CC) $ (ĐẶC BIỆT_CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

Việc sử dụng quy tắc foreach thậm chí còn mạnh mẽ hơn sẽ tận dụng lợi thế của thực tế là biến
"$ (foreach)" được đặt lần lượt cho từng tệp phù hợp với danh sách tệp và mục tiêu và
biểu thức phụ thuộc được đánh giá. Danh sách tệp có thể chứa các ký tự đại diện và những
đối sánh ngay cả các tệp chưa tồn tại nhưng có thể được tạo (xem "Ký tự đại diện" trong
makepp_rules).

Đây là một cú pháp khó sử dụng nhưng nó cực kỳ linh hoạt, vì biến "$ (foreach)"
có thể xuất hiện theo bất kỳ cách nào trong biểu thức. Trước tiên, hãy lưu ý rằng các quy tắc mẫu trên thực tế là
trường hợp đặc biệt của quy tắc foreach; quy tắc mẫu

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

chính xác tương đương với:

$ (patsubst% .c,% .o, $ (foreach)): $ (foreach): foreach * .c
$ (CC) $ (CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

(Trên thực tế, nó được chuyển đổi thành xấp xỉ đó trong nội bộ.)

Ví dụ về cách bạn sẽ sử dụng mệnh đề ": foreach" trong đó quy tắc mẫu không phải là
đủ, giả sử bạn có một số .c các tệp được tạo bằng một số loại tiền xử lý
lấy làm tệp đầu vào với .k gia hạn. Bạn muốn biên dịch những .c các tập tin với một
tập hợp các tùy chọn biên dịch khác với thông thường .c các tệp là nguồn thông thường
các tập tin. Bạn có thể làm điều gì đó như sau:

# Quy tắc cho tệp .c thông thường:
% .o:% .c
$ (CC) $ (CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

# Quy tắc tạo tệp .c từ tệp .k:
% .c:% .k
$ (bộ tiền xử lý) $ (đầu vào)> $ (đầu ra)

# Quy tắc xây dựng đặc biệt cho tệp .c được tạo từ tệp .k:
$ (foreach:%. k =%. o): $ (foreach:%. c =%. k): foreach * .k
$ (CC) $ (ĐẶC BIỆT_CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

(Điều này sử dụng cú pháp tham chiếu thay thế ngắn gọn hơn một chút thay vì gọi
"patsubst" một cách rõ ràng.)

Lưu ý rằng nếu tất cả những gì bạn muốn làm là thay đổi giá trị của một biến ("CFLAGS" trong đó
case) đôi khi thuận tiện hơn khi sử dụng các biến mục tiêu cụ thể.

Legacy hậu tố quy tắc
Để tương thích ngược, makepp hỗ trợ các quy tắc hậu tố kiểu cũ.

.suffix1.suffix2:
hành động

tương đương với

% .suffix2:% .suffix1
hành động

nhưng khó nhớ hơn nhiều. (Hậu tố nào đứng trước?) Thông thường, một quy tắc sẽ xuất hiện
trong một makefile kế thừa như thế này:

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

chính xác tương đương với

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

Mâu thuẫn quy tắc
Khi có nhiều cách để tạo tệp, makepp sử dụng một thủ tục đơn giản để
xác định quy tắc nào để sử dụng.

· Đó là một lỗi khi có các quy tắc rõ ràng xung đột để xây dựng một tệp.

· Các quy tắc mẫu và quy tắc foreach với ký tự đại diện không bao giờ ghi đè các quy tắc rõ ràng. Như vậy
các quy tắc rõ ràng có thể được sử dụng để chỉ định các ngoại lệ cho các quy tắc mẫu. (Lưu ý rằng đơn giản
sử dụng mệnh đề ": foreach" không làm cho điều gì đó trở thành quy tắc mẫu. Nó phải có một
ký tự đại diện (như "*" hoặc "?") như một phần của tên tệp trong mệnh đề ": foreach". Nếu nó là
chỉ là một danh sách rõ ràng các tệp, nó được coi như một quy tắc rõ ràng cho từng
các tập tin.)

· Khi các quy tắc mẫu xung đột đến từ các tệp trang điểm khác nhau, các quy tắc từ "gần hơn"
makefiles ghi đè các quy tắc từ các makefiles "xa hơn". "Gần hơn" có nghĩa là makefile
nằm gần mục tiêu hơn trong phân cấp thư mục (tức là tên tệp của
mục tiêu liên quan đến thư mục mà makefile được chạy ngắn hơn). Nếu điều này
không phân biệt các tệp trang, sau đó quy tắc từ tệp trang được tải
mới nhất được sử dụng.

Điều này có nghĩa là bạn có thể chỉ định một quy tắc mẫu áp dụng cho tất cả các tệp trong
toàn bộ cây thư mục chỉ trong makefile cấp cao nhất, nhưng sau đó bạn có thể ghi đè nó trong
một makefile cấp thấp hơn. Ví dụ: makefile cấp cao nhất của bạn có thể chứa:

% .o:% .c: foreach ** / *. c
$ (CC) $ (CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

và bạn có thể có một tệp makefile trong một trong các thư mục con có nội dung:

% .o:% .c
$ (CC) $ (ĐẶC BIỆT_CFLAGS) -c $ (đầu vào) -o $ (đầu ra)

· Các quy tắc mẫu có chuỗi suy luận ngắn hơn được ưu tiên hơn các mẫu khác
quy tắc. Ví dụ: nếu bạn có các quy tắc sau (dựa trên một ví dụ từ
Nền tảng Linux):

% .s:% .c
$ (CC) -s $ (đầu vào) -o $ (đầu ra)

% .o:% .s
$ (AS) $ (đầu vào) -o $ (đầu ra)

% .o:% .c
$ (CC) -c $ (đầu vào) -o $ (đầu ra)

Nếu chúng ta cần tạo "xyz.o", chúng ta có thể tạo tệp ".s" trung gian và sau đó
chạy điều đó thông qua trình hợp dịch bằng cách sử dụng hai quy tắc đầu tiên hoặc chúng ta có thể đi trực tiếp đến
tệp ".o" sử dụng quy tắc cuối cùng. Quy tắc cuối cùng được ưu tiên hơn vì có ít
các bước trong chuỗi suy luận (một thay vì hai).

· Các quy tắc mẫu sau này trong makefile ghi đè các quy tắc mẫu trước đó. (Đây là
ngược với GNU make.) Điều này có nghĩa là bạn nên đặt các quy tắc chung hơn của mình
sớm hơn và các quy tắc cụ thể hơn của bạn sau này. Ví dụ,

% .o:% .c # Quy tắc biên dịch chung.
hoạt động

đặc biệt _%. o: đặc biệt _%. c # Quy tắc đặc biệt cho các tệp có
hành động khác tiền tố # "đặc biệt_".

Quy tắc lựa chọn
Đôi khi cần cung cấp các tùy chọn bổ sung để sửa đổi cách makepp thực thi
luật lệ. Các tùy chọn này được chỉ định là ": optionname value", trên dòng chứa
các phụ thuộc hoặc trên dòng tiếp theo.

Việc cung cấp các tùy chọn trên các dòng riêng biệt có thể giúp bạn có thể sử dụng cùng một
makefile với makepp và make truyền thống. Ví dụ,

target: phụ thuộc
: chữ ký target_newer
hành động

sẽ hoạt động tốt với kiểu Unix truyền thống, vì nó diễn giải dòng ": chữ ký"
dưới dạng lệnh shell và lệnh bắt đầu bằng dấu hai chấm không có tác dụng gì.

: build_cache / path / to / build / cache
target: phụ thuộc
: build_cache / put / cache / files / over / there
hành động

Chỉ định đường dẫn đến bộ đệm ẩn bản dựng sẽ được sử dụng cho các tệp do quy tắc này tạo ra. Cái này
ghi đè ảnh hưởng của câu lệnh "build_cache" hoặc lệnh "--build-cache"
tùy chọn dòng, nếu có, cho quy tắc này. Xem makepp_build_cache để biết chi tiết về bản dựng
bộ nhớ đệm.

Nếu bạn chỉ định "không có" thay vì một đường dẫn, bạn vô hiệu hóa bộ đệm ẩn bản dựng cho việc này
quy tắc cụ thể. Điều này có thể hữu ích để tránh lãng phí dung lượng đĩa trên các tệp mà bạn
biết là không hữu ích cho bộ nhớ cache, bởi vì bạn rất chắc chắn rằng chúng sẽ không bao giờ
được sử dụng lại hoặc vì chúng được xây dựng quá nhanh nên không đáng để lưu vào bộ nhớ đệm.

: build_check phương thức build_check_
target: phụ thuộc
: build_check target_newer
hành động

Điều này cho makepp biết nên sử dụng thuật toán nào để quyết định xem các mục tiêu có cần được xây dựng lại hay không.
Xem makepp_build_check để biết thêm chi tiết. Điều này ghi đè ảnh hưởng của
câu lệnh "build_check" hoặc tùy chọn dòng lệnh "--build-check-method", nếu có, cho
quy tắc này.

: env BIẾN ĐỔI hữu ích. Cảm ơn !
Thêm phần phụ thuộc vào giá trị của các biến môi trường được đặt tên. Nếu bất kỳ ai trong số họ
khác với bản dựng trước đó, thì các mục tiêu được coi là đã lỗi thời, nếu
phương thức build_check để ra lệnh. (Tất cả các phương pháp kiểm tra bản dựng được tích hợp sẵn ngoại trừ
target_newer tôn trọng điều này.)

VARIABLE có thể có dạng "tên tệp trong PATH_VARIABLE" (trong dấu ngoặc kép), trong trường hợp đó
mục tiêu được coi là đã lỗi thời nếu thư mục đầu tiên từ dấu hai chấm phân cách
giá trị của PATH_VARIABLE trong đó tên tệp tồn tại khác với bản dựng cuối cùng.
Điều này có thể được sử dụng để tránh xây dựng lại các mục tiêu khi PATH_VARIABLE thay đổi trong một
cách không liên quan.

:gửi đi lệnh hữu ích. Cảm ơn !
Bao gồm mỗi hành động shell (nhưng không phải các hành động Perl cũng như các lệnh Perl) trong một "sh -c '...'"
và đặt tiền tố nó bằng lệnh, nhưng giả sử rằng mục tiêu không phụ thuộc vào lệnh.
Điều này rất hữu ích nếu bạn muốn gửi hành động đến hệ thống xếp hàng công việc, nhưng kết quả là
giả định là độc lập với các tham số xếp hàng, cũng như việc xếp hàng
hệ thống được sử dụng ở tất cả.

:bao gồm tập tin_hoặc_pattern
Quy tắc khác nhau tùy thuộc vào trình biên dịch:

% .o:% .c
: bao gồm% .d: chữ ký C
gcc -MD -c ...

% .o:% .c
: include% .u: signature C # IBM sử dụng một hậu tố khác
xlc -M -c ...

sub dependify {# Biến câu chuyện phiếm của Microsoft thành định dạng hữu ích
s / \ $ / \ $ \ $ / g;
s / (Lưu ý: bao gồm tệp: *)? (. +?) \ r? \ n / $ 1? "'$ 2'": "" ".f_output ()." ': "/ E;
}
% .o:% .c
: bao gồm% .d: chữ ký C
cl -showIncludes -c ...> $ (gốc) .d
& sed & dependify -o + <$ (gốc) .d

Một số trình biên dịch (icc của Intel giống như gcc ở trên hoặc xlc của IBM) có thể tạo ra sự phụ thuộc
các tập tin đang bay. Đó là, trong khi biên dịch, họ viết một tệp makefile để makepp có thể
bao gồm. Ưu điểm so với máy quét của makepp là nó được đảm bảo 100%
đúng, nơi chúng ta chỉ có thể đến gần.

Tùy chọn này khai thác điều đó theo một cách đặc biệt: Nếu tệp không có, tức là
thường trong bản dựng đầu tiên, quá trình quét bình thường xảy ra. Nhưng nếu tệp có mặt, không
xảy ra quét (đó là lý do tại sao chúng tôi chỉ định một chữ ký thông minh ở trên - không quét rơi
trở lại mặc định ngu ngốc của dấu thời gian và kích thước). Thay vào đó, nó bao gồm tệp, trước đây
thực hiện quy tắc. Sau khi thực hiện thành công quy tắc, nó sẽ quên bất cứ điều gì
đọc lần đầu tiên, vì tệp có thể đã lỗi thời. Thay vào đó, nó đọc
tệp một lần nữa, nếu nó đã thay đổi, để có thông tin bản dựng cập nhật.

CẢNH BÁO: Điều này vốn không đáng tin cậy. Tệp phụ thuộc được tạo ra bởi chính
quy tắc mà nó là một phụ thuộc. Mặt khác, trình biên dịch biết về tất cả
nó là phần phụ nội bộ, mà makepp thường bỏ qua. Đây là một độ tin cậy
chỉ thuận lợi cho trường hợp bản vá trình biên dịch chỉ sửa phần bao gồm phụ. Các
giá là makepp kết thúc xem xét nhiều tệp hơn, điều này mất thời gian.

Có một vấn đề khi bạn xóa câu lệnh "#include" và tệp tương ứng:
Nó vẫn sẽ được đề cập trong tệp phụ thuộc từ lần trước, khi nó
cần thiết. Trong trường hợp như vậy, bạn phải chỉnh sửa tệp phụ thuộc để loại bỏ phụ thuộc
mà không còn khả thi.

Không thể sử dụng tính năng này với bộ đệm ẩn bản dựng vì tìm nạp tệp từ đó
yêu cầu biết mọi thứ về tệp. Nhưng một tệp phụ thuộc phụ thuộc vào những
các tệp makepp tìm hiểu bằng cách đọc nó. Sự phụ thuộc vòng tròn như vậy không phải là bình thường
có thể trong một hệ thống xây dựng đáng tin cậy. Đây là một ngoại lệ vì sau khi xây dựng lại
và đọc lại một tệp tin phụ thuộc thì mọi thứ đều chính xác trở lại.

Nếu bạn xây dựng trong kho lưu trữ của mình, makepp sẽ chọn tệp phụ thuộc từ
Kho lưu trữ thứ nhất chứa một. Điều này không giống như các tệp khác, nơi nó chiếm vị trí thứ nhất
với chữ ký dự kiến. Điều này tốt hơn so với bộ đệm bản dựng, nơi thiếu
chữ ký, nó thậm chí không thể tìm thấy tệp.

:cơ hội cuối cùng
Bật quy tắc kết thúc mở, chẳng hạn như

% .foo foo% .bar:: last_chance
& echo $ @ -o $ @
& cp $ (kết quả đầu ra)

Bởi vì một quy tắc như vậy có thể tạo ra một số lượng mục tiêu về cơ bản là vô hạn,
mục tiêu của quy tắc này sẽ không khớp với quy tắc mẫu hoặc hàm $ (ký tự đại diện) trừ khi
một cái gì đó khác đã xây dựng quy tắc bằng cách tham chiếu cụ thể đến mục tiêu.
Hơn nữa, nếu "--rm-stale" được chỉ định, thì một mục tiêu còn lại từ trước đó
makepp run sẽ có vẻ cũ nếu cách duy nhất để xây dựng nó là thông qua quy tắc last_chance
chưa được ổn định cho mục tiêu, đó là một hành vi mong muốn bởi vì
quá trình xây dựng sẽ thất bại liên tục hơn khi nó dựa vào một ký tự đại diện một cách sai lầm để
khớp các mục tiêu từ lần chạy trước.

Tùy chọn ": last_chance" nhằm kêu gọi sự chú ý đến hành vi đặc biệt của
quy tắc đối với các ký tự đại diện phù hợp.

: parser phân tích cú pháp
Điều này cho makepp biết cách phân tích cú pháp lệnh để phát hiện (bao gồm) tệp. Thông thường,
makepp đoán cách thực hiện việc này dựa trên các từ trong chính lệnh (xem
makepp_scanning để biết chi tiết). Tuy nhiên, nếu makepp đoán sai, bạn có thể muốn
chỉ ra rõ ràng trình phân tích cú pháp, như thế này:

% .o:% .abc
: phân tích cú pháp c_compilation
hành động ở đây

Điều này khiến makepp thực hiện phân tích cú pháp và quét giống như nó đối với C / C ++
xây dựng các lệnh, ngay cả khi nó không nhận ra hành động như một biên dịch C.

Trình phân tích cú pháp mặc định phụ thuộc vào lệnh. Nếu bạn không chỉ định tùy chọn ": parser",
thì từ đầu tiên của mỗi lệnh sẽ được kiểm tra. Ví dụ cho một biên dịch hoặc liên kết
lệnh makepp sẽ sử dụng trình phân tích cú pháp "c_compilation"; hoặc nếu lệnh trông giống như
Biến thể GNU, "gcc_compilation". Nếu không tìm thấy trình phân tích cú pháp, nó sẽ sử dụng trình phân tích cú pháp "none". Vì
biết thêm chi tiết về điều này, hoặc nếu bạn muốn viết trình phân tích cú pháp của riêng mình hoặc thay đổi makepp's
trình phân tích cú pháp mặc định, hãy xem makepp_scanning.

Lưu ý rằng điều này áp dụng cho mọi lệnh trong quy tắc, có thể không phải là những gì bạn muốn:

% .o:% .c: phân tích cú pháp c-compilation
@echo 'Xây dựng $ (đầu ra)'
@funny_cc...

Điều này cũng sẽ giải thích "echo" như một trình biên dịch và suy ra đối số của nó 'Tòa nhà
mymodule.o 'như một phụ thuộc ngầm định. Điều này sẽ dẫn đến khiếu nại rằng nó
không biết làm thế nào để xây dựng một tệp như vậy. Trong trường hợp này, bạn sẽ tốt hơn với
"register_parser". Ở đó bạn tìm thấy lời giải thích như thế nào phân tích cú pháp có thể được đưa ra như một
tên lớp hoặc dưới dạng tên hàm.

:Chữ ký phương thức chữ ký
target: phụ thuộc
: chữ ký md5
hành động

Điều này cho makepp biết nên sử dụng thuật toán nào để xác định xem các phần phụ thuộc có thay đổi hay không.
Xem makepp_signatures để biết thêm chi tiết. Các phương pháp chữ ký được bao gồm trong
phân phối makepp là "đơn giản", "md5", "C" hoặc "c_compilation_md5" và
"shared_object". Điều này ghi đè bất kỳ phương thức chữ ký nào được chỉ định bằng "-m" hoặc
Tùy chọn dòng lệnh "--signature-method" hoặc với câu lệnh "signature".

Reduct ® nhân vật
Makepp có thể hỗ trợ các tên tệp có các ký tự đặc biệt như dấu hai chấm hoặc dấu cách.
Giả sử, ví dụ, bạn muốn tạo một tệp có tên "a: thing" từ tệp "b: thing".
Bạn không thể viết quy tắc theo cách này:

a: thing: b: thing # Đây là lỗi cú pháp
& cat $ (đầu vào) -o $ (đầu ra)

bởi vì makepp sẽ không biết dấu hai chấm nào tách mục tiêu khỏi phần phụ thuộc và cái nào là
một phần của tên tệp. Thay vào đó, chỉ cần đặt tên trong dấu ngoặc kép, như sau:

"a: thing": "b: thing"
& cat $ (đầu vào) -o $ (đầu ra)

Bây giờ quy tắc là rõ ràng.

Cú pháp trích dẫn của Makepp khá giống với shell. Ví dụ, bạn có thể sử dụng
dấu ngoặc kép thay vì dấu ngoặc kép hoặc bạn có thể thoát các ký tự đặc biệt bằng dấu gạch chéo ngược:

a \: thing: 'b: thing'
& cat $ (đầu vào) -o $ (đầu ra)

Ví dụ: giả sử tên tệp của bạn là "'"!; \ $ ". Bây giờ tại sao bạn muốn một tên tệp như vậy
Tôi không biết, nhưng đây là một số cách bạn có thể chỉ định nó cho makepp (và shell):

\ '' "!; \ $$ '
"'\"!; \\ $$ "

Hãy chú ý đến khi nào thì makepp dải báo giá và khi nào thì shell. Makepp nhìn vào
chỉ trích dẫn trong các trường hợp sau:

· Trong họ thử nghiệm "ifeq"

· Trước và sau dấu hai chấm quy tắc

· Trong một lệnh nội trang makepp

· Trong một chức năng liên quan đến tệp

Không giống như shell, makepp không mở rộng các dấu ngoặc kép trong khi gán chúng cho một biến. Như vậy
các quy tắc sau đây giống hệt nhau:

FILE = 'tên có dấu cách'
x: = $ (print $ (FILE)) # chỉ để kiểm tra xem các dấu ngoặc kép vẫn còn ở đó
$ (FILE): # dấu ngoặc kép xung quanh một tệp duy nhất bị makepp loại bỏ
& echo hello -o $ (FILE) # dấu ngoặc kép xung quanh một tệp duy nhất bị xóa bởi makepp
echo there >> $ (FILE) # dấu ngoặc kép xung quanh một tệp duy nhất bị Shell loại bỏ
'tên có dấu cách':
& echo xin chào -o'name có dấu cách '
echo there >> '$ (output)' # dấu ngoặc kép đã bị loại bỏ ở trên, hãy thêm chúng lại

Lưu ý rằng (không giống như Shell) các biến bắt đầu bằng "$" được mở rộng ngay cả bên trong
dấu ngoặc kép. Dấu hiệu đô la không thể được bảo vệ bằng dấu ngoặc kép hoặc dấu gạch chéo ngược. Để có được một nghĩa đen
ký hiệu đô la, sử dụng ký hiệu đô la kép, ví dụ:

$ (tất cả giả mạo):
@ & echo Đây là ký hiệu đô la: $$
@ cho val trong abcd; làm echo $$ val; xong

Nói chung, bạn sẽ có thể đối phó với bất kỳ ký tự đặc biệt nào bằng cách trích dẫn nó
một cách nào đó. Điều này bao gồm dấu cách, ký tự điều khiển, v.v. Tuy nhiên, hãy lưu ý rằng tại
hiện tại, việc loại bỏ nhận xét của makepp hơi đơn giản và bất kỳ ký tự "#" nào
đứng trước khoảng trắng sẽ được hiểu là nhận xét bất kể chúng được trích dẫn như thế nào.

Khi tên đích hoặc tên phụ thuộc được đưa vào một biến tự động như "$ (output)", thì
các dấu ngoặc kép và bất kỳ dấu gạch chéo ngược nào đều bị loại bỏ. Điều này có nghĩa là nếu bạn muốn tham chiếu
tên tệp trong các hành động, bạn có thể sẽ phải trích dẫn lại nó, như thế này:

"tên tệp có khoảng trắng":
echo "Nội dung đặc biệt"> "$ @"

Nếu bạn không đặt dấu ngoặc kép quanh $ @, thì shell sẽ thấy lệnh

echo "Nội dung đặc biệt"> tên tệp có dấu cách

ghi chuỗi "Tên tệp nội dung đặc biệt có dấu cách" vào tệp được gọi a.
Đây có lẽ không phải là điều bạn muốn.

Sử dụng makepp_rules trực tuyến bằng các dịch vụ onworks.net