jmake - ออนไลน์ในคลาวด์

โครงการ:

ชื่อ

jmake - ตัวสร้าง makefile ทั่วไป

เรื่องย่อ

เจเมค [ ซีพี ตัวเลือก ]

DESCRIPTION

เจเมค สร้าง makefile จากคำอธิบายที่ค่อนข้างสูงในa เจเมคไฟล์ ไฟล์
ไฟล์ที่สร้างขึ้นคือ a Makefile.SH แทนที่จะเป็น makefile ธรรมดา ซึ่งหมายความว่าพร้อมแล้ว
เพื่อใช้ร่วมกับ metaconfig โดยเฉพาะอย่างยิ่ง พารามิเตอร์เช่น "ที่ที่จะ
ติดตั้งโปรแกรมปฏิบัติการ" จะถูกกำหนดโดยอัตโนมัติโดย กำหนดค่า และจำเป็นเท่านั้น
พารามิเตอร์จะถูกนำมาพิจารณา

ในการใช้งาน เจเมค คุณต้องเขียน เจเมคไฟล์ ประการแรกซึ่งบรรยายถึงสิ่งที่จะเป็น
สร้าง. ของคุณ เจเมคไฟล์ จะรวมอยู่ในเทมเพลตทั่วไปผ่านทาง C pre-
โปรเซสเซอร์ ซึ่งหมายความว่าคุณสามารถใช้ความคิดเห็น C /**/ ตามปกติได้ แต่ไม่ใช่เชลล์ #
ความคิดเห็น ความคิดเห็น C จะไม่ปรากฏในที่สร้างขึ้น Makefile.SH แต่เส้นเริ่มต้น
ด้วย ;# จะปรากฏเป็นความคิดเห็นของเชลล์ในที่สุด หากคุณต้องเขียนสตริง /* ใน
สร้าง Makefile.SH แล้วคุณต้องหนีมัน (มิฉะนั้น เจเมค จะคิดว่ามันเป็น
เริ่มต้นความคิดเห็น C) เพียงใส่ # ข้างหน้า * เช่นใน /#*

คุณมีชุดมาโครพร้อมใช้ และมาโครทั้งหมดเหล่านี้แสดงอยู่ในดัชนี
พร้อมกับส่วนของโค้ดที่จะขยายไป โดยปกติ a เจเมคไฟล์ เป็นธรรม
ขนาดเล็กและดูแลรักษาง่ายกว่าขนาดใหญ่ เมคไฟล์ คำสั่งที่ทรงพลังภายในบางส่วน
ช่วยให้คุณเขียน makefiles แบบพกพาได้อย่างง่ายดายโดยไม่ต้องใช้ความพยายามมาก
เพราะมีคนอื่นทำงานให้คุณแล้ว :-)

เมื่อคุณต้องการสร้าง makefile คุณมักจะไม่เรียกใช้ เจเมค แต่ใช้ เจเอ็มเคเอ็มเอฟ
สคริปต์ซึ่งเป็นเสื้อคลุมและจะเรียกใช้ เจเมค ด้วยตัวเลือกที่ถูกต้อง

ความรู้ทั้งหมดของ เจเมค ถูกเก็บไว้ในสองไฟล์: template Jmake.tmpl และมาโคร
ไฟล์คำจำกัดความ Jmake.กฎ ไฟล์แรกรวมถึงไฟล์ที่สองพร้อมกับ
เจเมคไฟล์ บางครั้งจำเป็นต้องรู้ว่าสิ่งต่าง ๆ ทำงานอย่างไรจึงจะสามารถใช้งานได้อย่างถูกต้อง
คุณสมบัติทั้งหมดที่มีให้ ตัวอย่างเช่น คุณอาจต้องเขียนกฎของคุณเองสำหรับ a
โครงการเฉพาะ แม้ว่าคุณจะไม่สามารถเขียนทับกฎที่กำหนดไว้ล่วงหน้าได้ แต่คุณสามารถขยายขอบเขต
Jmake.กฎ ไฟล์หรือเพียงแค่เพิ่มมาโครของคุณใน your เจเมคไฟล์ คุณอาจใช้ #include
คำสั่งเมื่อคุณต้องการแชร์มาโครเหล่านี้และไม่ต้องการทำซ้ำโค้ด

ไวยากรณ์ใน Jmake.rules นั้นไม่หรูหราเลย แต่:

- แยกวิเคราะห์ได้ง่าย (เช่นไฟล์ sendmail.cf หรือ troff)
- กฎไม่ควรเปลี่ยนแปลงบ่อยนัก
- ง่ายพอที่จะเชี่ยวชาญในห้านาที :-)

นี่คือคำอธิบายเล็กน้อย:

1) เพื่อจัดการกับสิ่งต่าง ๆ ซีพี การใช้งาน:

· Final @!\ หมายถึง สิ้นสุดบรรทัด บรรทัดถัดไปเริ่มต้นที่ระยะขอบด้านซ้าย
· สุดท้าย @@\ หมายถึง: สิ้นสุดบรรทัด บรรทัดถัดไปให้เยื้องโดยแท็บเดียว

ควรมี @!\ หรือ @@\ ตัวใดตัวหนึ่งที่ท้ายบรรทัดเสมอ เพียง
ข้อยกเว้นสำหรับมาโครที่จะใช้เป็นส่วนหนึ่งของเนื้อหากฎ (เช่น
โปรแกรม RemoveTarget). ในกรณีนั้น บรรทัดแรก (ซึ่งถือ #กำหนด) ควร
ลงท้ายด้วยแบ็กสแลชเดียว

2) คำจำกัดความของสัญลักษณ์:

· >SYMBOL: กำหนดสัญลักษณ์
· ?เครื่องหมาย: : เก็บไว้ iff SYMBOL ถูกกำหนดไว้
· %เครื่องหมาย: : เก็บไว้ iff ไม่ได้กำหนด SYMBOL

?SYM สามารถซ้อนกันได้ (ตรรกะ AND) เช่นใน:

?สัญลักษณ์:%โทเค็น:ข้อความ

ซึ่งจะเก็บข้อความไว้หากมีการกำหนด SYMBOL และไม่ได้กำหนด TOKEN เพื่อดำเนินการ a
ตรรกะ OR ดูด้านล่าง

3) การทดสอบเป้าหมาย Makefile:

-เป้า?: : เก็บไว้ iff เป้า ถูกกำหนดไว้
-เป้า%: : เก็บไว้ iff เป้า ไม่ได้กำหนดไว้

เมคไฟล์ เป้า ถูกกำหนดให้เป็นเป้าหมายแบบสแตนด์อโลน เช่น
ขึ้นอยู่กับ.local เป้าหมายซึ่งจะถูกกำหนดเป็น:

ขึ้นอยู่กับ.ท้องถิ่น:

โปรดทราบด้วยว่ามันใช้ได้เฉพาะกับเป้าหมายที่กำหนดไว้ so ไกล ในการสร้าง
เมคไฟล์ ไม่ใช่ภาคแสดงที่ใช้ทดสอบเป้าหมายที่
จะถูกกำหนดในที่สุดในภายหลังในรุ่น

4) คำสั่ง:

คำสั่งสามารถส่งผ่านไปยัง เจเมค. พวกเขาเริ่มต้นด้วย '|' นำหน้า คำสั่งที่ใช้ได้
คือ:

· |คำต่อท้าย : เพิ่ม ไปที่รายการ .SUFFIXES: ใน makefile

· |กฎ: : เพิ่ม ไปที่ส่วนกฎอาคาร

· |กฎ: : เหมือนเดิม มีแถบนำหน้า

· |skip: ข้ามข้อความจนกว่าจะพบบรรทัดที่ขึ้นต้นด้วย '-skip'

· |subst: เริ่มต้นส่วนที่บรรทัดจะถูกแทนที่ตัวแปร
จนกว่าจะพบ '-subst' ซึ่งหมายความว่าเมื่อเรียกใช้ Makefile.SH ทั้งหมด
อินสแตนซ์ของ $var ภายใน คำนาม ส่วนจะถูกแทนที่ด้วยเปลือก

· |shell: ปล่อยส่วนจนกว่าจะจับคู่ '-shell' ตามที่เป็นอยู่ในไฟล์ที่สร้างขึ้น
Makefile.SH ซึ่งจะเป็นประโยชน์ในการเตรียมตัว |กรณี ส่วนต่างๆ มันไม่ใช่
อนุญาตให้ทำรัง เปลือกหอย ส่วน

· |case: คำสั่งนี้ต้องตามด้วยชื่อตัวแปรเชลล์
นำเครื่องหมาย '$') และรูปแบบกรณีเช่นสตริง "var in
f*" มันจะสร้างการทดสอบ "case" ที่สอดคล้องกันใน Makefile.SH on
ค่า "$var" และเฉพาะในกรณีที่การทดสอบนี้เป็นจริง ส่วนจะถึง
'-case' ที่ตรงกันจะถูกสร้างขึ้นใน Makefile เมื่อเรียกใช้ Makefile.SH มัน
สามารถทำรังได้ กรณี ส่วนต่างๆ ได้อย่างอิสระ

· |ขยาย : ขยายบรรทัดจนถึง '-expand' ด้วย . สมบูรณ์
ตัวอย่างแสดงอยู่ด้านล่าง

· |ครั้งเดียว : ข้อความไม่เกิน '-ครั้งเดียว' จะปรากฏเฉพาะครั้งแรกเท่านั้น

'|' ไม่สามารถซ้อนคำสั่งได้ เว้นแต่จะระบุไว้เป็นอย่างอื่น โดยเฉพาะอย่างยิ่ง เนื่องจาก
การใช้งานอย่างง่ายของ |ข้าม, มันเป็นไปไม่ได้ที่จะวาง |ข้าม ภายในข้าม
ส่วนหนึ่ง. อย่างไรก็ตาม a |ครั้งเดียว ส่วนอาจมี |ข้าม ส่วนต่างๆ อนุญาตให้ทำรัง
|กรณี ส่วนที่จะ

นี่คือวิธีการใช้ตรรกะ OR:

/* ใช้ SYMBOL หรือไม่ใช้ TOKEN */
?SYMBOL:text /* เก็บข้อความไว้ถ้า SYMBOL */
%สัญลักษณ์:|ข้าม
%TOKEN:text /* เก็บข้อความไว้ถ้าไม่ใช่ TOKEN */
-ข้าม

อันที่จริง มันน่าเกลียดเพราะข้อความต้องปรากฏสองครั้ง โชคดีที่ฉันทำ
ไม่ใช้โครงสร้างนั้น :-)

อันที่จริง ตามที่คุณเดาไว้แล้ว วิธีที่ดีที่สุดในการใช้ตรรกะOR
คือการใช้กฎของเดอมอร์แกน:

ไม่ (p หรือ q) <=> ไม่ใช่ p และไม่ใช่ q

/* ใช้ SYMBOL หรือไม่ใช้ TOKEN (พยายาม #2) */
%สัญลักษณ์:?โทเค็น:|ข้าม
ข้อความ /* หากเป็น SYMBOL หรือไม่ใช่ TOKEN */
-ข้าม

ใครบอกว่าพวกเขาไม่สนใจตรรกะ? ;-)

การขยายเสร็จสิ้นด้วย ขยายตัว สั่งการ. มันถูกจัดเตรียมไว้เพื่อหลีกเลี่ยงบางอย่าง
งานเขียนที่ยุ่งยากใน makefiles เมื่อคุณต้องทำซ้ำบางบรรทัดโง่ ๆ เท่านั้น
ต่างกันในชื่อไฟล์ เป็นต้น มาดูตัวอย่างกันก่อน:

|ขยาย a!foo บาร์! ข!ใช่ ไม่ใช่!
!NS::
เสียงสะท้อน !a, !b
-ขยาย

จากนั้นกฎสองข้อจะถูกพิมพ์ และค่าของ (a,b) สำหรับค่าแรกจะเป็น (foo,
ใช่) สำหรับวินาที (บาร์ไม่ใช่) การเปลี่ยนตัวถูกควบคุมโดย '!' อักขระ.
หากคำที่จะแทนที่เป็นส่วนหนึ่งของคำอื่นให้แยกด้วย ^^ construct
เช่นใน: !b^^c. เป็นไปได้ที่จะใช้มาโคร Makefile ในไฟล์ , และพวกเขา
จะถูกขยายโดย jmake หากนี่ไม่ใช่สิ่งที่คุณต้องการ ให้ข้ามเครื่องหมาย '$' ตัวแรก
(นี่คือการหลบหนีของ Makefile นั่นคือคุณต้องเพิ่ม '$' เป็นสองเท่า ไม่ใช่นำหน้าด้วย a
แบ็กสแลช) A // หมายถึงค่าการแทนที่ค่า null
โครงสร้าง ^^^ มีลักษณะเหมือน ^^ คือถูกถอดออก แต่ก็ลบใด ๆ ออกด้วย
ตามช่องว่างหลัง ^^^. หากคุณเติมบางอย่างไว้ข้างหน้าอาร์กิวเมนต์แมโคร
และอาร์กิวเมนต์แมโครนั้นถูกเขียนด้วยช่องว่างก่อนหน้ามัน จะทำให้คุณ
เชื่อมบางสิ่งก่อนค่าสุดท้ายของอาร์กิวเมนต์นั้น

นี่เป็นอีกตัวอย่างหนึ่งที่แสดงวิธีการใช้มาโคร Expand มันคือ
กำหนดไว้ใน Jmake.กฎ เป็น:

#define Expand(rule, pattern) @!
|expand pattern @!
rule @!
-ขยาย

ดังนั้นเราสามารถเขียนใน เจเมคไฟล์:

|ข้าม
A = ฟูบาร์
-ข้าม

#define Rule @!
$(DIR)/!a^^.o: !a^^.o @@
$(CC) -c !a^^.c @@
$(MV) !a^^.o $(DIR)

ขยาย(กฎ, a!$(A)!)

ซึ่งจะเกิดใน Makefile.SH:

$(DIR)/foo.o: foo.o
$(CC) -c fo.c
$(MV) ฟู.โอ $(DIR)

$(DIR)/bar.o: บาร์.โอ
$(CC) -c bar.ค
$(MV) บาร์.o $$(DIR)

การประกาศ 'A' ถูกล้อมรอบด้วย ข้ามเพื่อไม่ให้ปรากฏใน
สร้าง Makefile.SH แต่จะถูกนำมาพิจารณาโดย เจเมค สำหรับ
ทดแทนในรูปแบบ

จำนวนของการขยายถูกกำหนดโดยจำนวนของค่าที่เป็นไปได้สำหรับ
เป็นครั้งแรก พารามิเตอร์. หากพารามิเตอร์อื่นมีค่าทดแทนน้อยกว่า จะได้รับ
พวกที่เป็นโมฆะ

คุณสามารถเพิ่มนิพจน์ทั่วไปที่ส่วนท้ายของ '-expand' ประจำนี้
นิพจน์จะถูกลบออกจากชุดส่วนขยายสุดท้ายที่ส่วนท้ายของแต่ละบรรทัด
นอกจากนี้ยังเป็นไปได้ที่จะทำการแทนที่ในรายการที่ขยายโดยใช้ไวยากรณ์
(ถ้า 'f' เป็นตัวแปรขยาย) !f:= ที่ไหน และ เป็นสองปกติ
นิพจน์ (ไม่มีช่องว่าง) รูปแบบ จะถูกแทนที่ด้วยรูปแบบ
(จะแทนที่เฉพาะครั้งแรกเท่านั้น)

สุดท้าย คุณอาจอ้างอิงในส่วนที่ขยายไปยังตัวแปรที่มีค่าที่คำนวณได้
ผ่านการขยายอื่นซึ่งทำให้ง่ายต่อการกำหนดทั่วไป เจเมคไฟล์.

ตัวอย่าง:

SRC = foo.c บาร์ค
OBJ =
|ขยาย f!$(SRC)!
!f:\.c=\.o
-expand \
INC =
|ขยาย f!$(OBJ)!
!f:\.o=\.h
-expand \

ซึ่งจะเกิดใน Makefile.SH:

SRC = foo.c บาร์ค
OBJ =
ฟูโอ
บาร์.โอ
INC =
ฟู
บาร์.h

อย่าลืมปกป้องอักขระพิเศษในนิพจน์ทั่วไปของคุณเช่น
แบ็กสแลช จุด ฯลฯ...

การขอ ครั้งเดียว คำสั่งถูกแท็กด้วยชื่อ ครั้งแรกที่ชื่อปรากฏขึ้นครั้งเดียว
โครงสร้างถูกละเว้นและข้อความถึง '-ครั้งเดียว' จะถูกคัดลอกในการสร้าง
Makefile.SH อย่างไรก็ตาม การเกิดขึ้นของชื่อเดียวกันในอนาคตจะถูกละเว้น (ครั้งเดียว
จะทำตัวเหมือน ข้าม).

ตัวอย่าง:

|ครั้งนี้_is_a_name

-ครั้งหนึ่ง

การขอ เปลือกหอย คำสั่งสามารถใช้เพื่อสร้างชิ้นส่วนของเชลล์ใน Makefile.SH สำหรับ
ตัวอย่าง ส่วนต่อไปนี้ใน Jmakefile:

|เปลือก
กรณี "$d_usegtk1" ใน
กำหนด) glib=1; gtk=1;;
ว่า C
-เปลือก

จะทำให้การสร้างแฟรกเมนต์ที่แนบมาใน Makefile.SH คำนวณ
ค่าของ กะล่อน และ gtk ตัวแปรตามตัวแปรคอนฟิกูเรชัน
d_usegtk1 ตั้งค่าโดยการรัน Configure

ในทางกลับกัน สามารถใช้ในภายหลังได้ กรณี ส่วนที่จะเปิดใช้งานส่วนต่างๆของ
Makefile เฉพาะเมื่อสร้างสำหรับ GTK1 โดยใช้ glib-1.x:

|case glib ใน 1
แสดง:
echo "การสร้างสำหรับ glib-1.x"
-กรณี

ส่วนนี้จะสร้างสิ่งนี้ใน Makefile.SH:

!ไม่!ซับ!
กรณี "$glib" ใน
1)
$spitshell >>Makefile <<'!NO!SUBS!'
แสดง:
echo "การสร้างสำหรับ glib-1.x"
!ไม่!ซับ!
;;
ว่า C
$spitshell >>Makefile <<'!NO!SUBS!'

และเมื่อเรียกใช้ Makefile.SH กฎ "การแสดงผล" ด้านบนจะปรากฏเฉพาะเมื่อ
สร้างสำหรับ glib-1.x รูปแบบของรอบชิงชนะเลิศ Makefile จึงสามารถพึ่งพา
ตัวเลือกการกำหนดค่าที่เลือกเมื่อ กำหนดค่า ถูกเรียกใช้

5) การเริ่มต้น:

· + : ใส่ทั้งบรรทัดในส่วนการเริ่มต้น
· ++สัญลักษณ์ : เพิ่ม ไปที่แมโคร SYMBOL

6) ตัวแปรที่ผู้ใช้กำหนด:

ผู้ใช้อาจกำหนด CFLAGS, LDFLAGS หรือ DPFLAGS เป็นแฟล็กเพิ่มเติมเพื่อใช้ใน C
การคอมไพล์ การเชื่อมโยงเฟส หรือเป้าหมายที่ขึ้นต่อกัน จึงสามารถเพิ่มความพิเศษบางอย่างได้
แฟล็ก เช่น -I หรือไลบรารีสำหรับ Makefiles ในไดเร็กทอรีย่อยเฉพาะ

ใช้ jmake ออนไลน์โดยใช้บริการ onworks.net