นี่คือคำสั่ง metaconfig ที่สามารถเรียกใช้ในผู้ให้บริการโฮสต์ฟรีของ OnWorks โดยใช้เวิร์กสเตชันออนไลน์ฟรีของเรา เช่น Ubuntu Online, Fedora Online, โปรแกรมจำลองออนไลน์ของ Windows หรือโปรแกรมจำลองออนไลน์ของ MAC OS
โครงการ:
ชื่อ
metaconfig - ตัวสร้างสคริปต์กำหนดค่า
เรื่องย่อ
เมตาคอนฟิก -dhkmostvwGMV -L dir ]
DESCRIPTION
เมตาคอนฟิก เป็นโปรแกรมที่สร้างสคริปต์ Configure ถ้าคุณไม่รู้ว่า a . คืออะไร
สคริปต์กำหนดค่าคือ โปรดข้ามไปที่ การสอน ของหน้าคู่มือนี้ ถ้าคุณต้องการ
คำอธิบายแบบเต็ม (เป็นทางการ) ของวิธีการใช้ เมตาคอนฟิก และหน่วยต่างๆ โปรดดูที่
อ้างอิง ส่วน. ต่อไปนี้เป็นการแนะนำและอ้างอิงอย่างรวดเร็วสำหรับผู้มีความรู้
ผู้ใช้
เมตาคอนฟิก ทำงานจากชุดของ หน่วย ซึ่งกำหนดทุกอย่างที่ metaconfig รู้เกี่ยวกับ
การพกพา แต่ละยูนิตมีแบบในตัวและไม่ต้องลงทะเบียนที่ไหนเลย
นอกเหนือจากการรวมไว้ในไดเร็กทอรี U สาธารณะหรือไดเร็กทอรี U ส่วนตัวของคุณ ถ้า
แพ็คเกจ dist (ซึ่ง metaconfig เป็นส่วนหนึ่ง) ได้รับการติดตั้งใน LIB จากนั้น U . สาธารณะ
ไดเร็กทอรีคือ LIB/dist/mcon/U บนเครื่องนี้ ไดเร็กทอรี LIB คือ /usr/share/dist ของคุณ
ไดเร็กทอรี U ส่วนตัว ถ้าคุณมีอยู่ในไดเร็กทอรีระดับบนสุดของแพ็คเกจของคุณ
ก่อนจะวิ่งได้ เมตาคอนฟิก คุณต้องทำหลายอย่าง:
· สร้างไฟล์ .package ในไดเร็กทอรีระดับบนสุดของแพ็คเกจโดยเรียกใช้ แพ็คกินิต.
โปรแกรมนี้จะถามคุณเกี่ยวกับแพ็คเกจของคุณและจำสิ่งที่คุณบอกไว้เพื่อที่
โปรแกรม dist ทั้งหมดสามารถฉลาดได้
· ศึกษาอภิธานศัพท์ (ใน LIB/dist/mcon) และเขียนเชลล์สคริปต์และโปรแกรม C
ในแง่ของสัญลักษณ์ที่ metaconfig รู้วิธีกำหนด ไม่ต้องบอก
metaconfig คุณใช้สัญลักษณ์ใด เนื่องจาก metaconfig จะค้นหาให้คุณเอง
· สร้างสคริปต์ .SH ที่จำเป็นในการเขียน Makefiles หรือเชลล์สคริปต์ที่จะขึ้นอยู่กับ
ตามค่าที่กำหนดโดย Configure มีโปรแกรมชื่อว่า ทำให้SH ที่จะช่วยคุณ
แปลงสคริปต์ธรรมดาเป็นเทมเพลต script.SH; การแก้ไขบางอย่างยังคงต้องมี
ดำเนินการกับไฟล์ .SH ที่เป็นผลลัพธ์เพื่อย้ายส่วนการกำหนดค่าตัวแปรใน
ส่วนบนของสคริปต์ (ดูความคิดเห็นแบบอินไลน์ที่สร้างโดย ทำให้SH ภายใน .SH . ของคุณ
แฟ้ม)
· สร้างไฟล์ MANIFEST.new ในไดเร็กทอรีระดับบนสุดของคุณที่แสดงรายการไฟล์ทั้งหมดใน
แพ็คเกจของคุณ ไฟล์นี้จะยังคงเป็นแบบส่วนตัวและจะไม่เป็นส่วนหนึ่งของรอบชิงชนะเลิศ
การกระจาย. (เพื่อความสะดวก ไฟล์ MANIFEST จะถูกใช้โดย เมตาคอนฟิก if
ยังไม่มีไฟล์ MANIFEST.new) ชื่อไฟล์ควรเป็นฟิลด์แรกในแต่ละไฟล์
ไลน์. หลังจากเว้นวรรค คุณสามารถเพิ่มความคิดเห็นสั้นๆ ที่อธิบายไฟล์ของคุณได้ เท่านั้น
ไฟล์ต้นฉบับควรอยู่ในนั้น ไฟล์พิเศษ patchlevel.h (ซึ่งเป็น
จัดการและดูแลโดยเครื่องมือแก้ไข -- ดู ลูบ(1)) ควรเป็นส่วนหนึ่งของ
MANIFEST.new ไฟล์ แต่เครื่องมือบางอย่างอาจถูกละเว้นอย่างเงียบๆ ตามหลักธรรมที่ว่า
เฉพาะไฟล์ที่ดูแลโดย RCS เท่านั้นที่ควรระบุไว้ในนั้น patchlevel.h ไฟล์เป็น
ข้อยกเว้นที่สำคัญอย่างหนึ่ง
· หรือคุณอาจต้องการสร้างไฟล์ MANIFEST ซึ่งจะเป็นเวอร์ชันที่ส่งออก
ของ MANIFEST.new ของคุณ ไฟล์นั้นจะต้องเป็นส่วนหนึ่งของการเปิดตัว กล่าวคืออยู่ในทั้งสองรายการ
MANIFEST.new และ MANIFEST ของคุณ หนึ่งใน เมตาคอนฟิก หน่วยรู้เรื่องนี้
file และจะบังคับให้ Configure ทำการตรวจสอบ Release เพื่อให้มั่นใจว่าไฟล์ทั้งหมด
ระบุว่าเป็นส่วนหนึ่งของการแจกจ่าย ไฟล์ MANIFEST และ MANIFEST.new ควร
ให้ชัดเจน ไม่ใช่ลิงก์
· คัดลอกไฟล์ .U ใดๆ ที่คุณต้องการแก้ไขไปยังไดเร็กทอรี U ส่วนตัวของคุณ ไฟล์ .U ใดๆ
ในไดเร็กทอรี U ส่วนตัวของคุณจะถูกใช้มากกว่าไดเร็กทอรี U . สาธารณะ
ไดเร็กทอรี ตัวอย่างเช่น วิธีหนึ่งในการบังคับให้รวมหน่วยใด ๆ เข้าด้วยกันคือการคัดลอก End.U
ไฟล์ไปยังไดเร็กทอรี .U ของคุณ และเพิ่มชื่อหน่วยที่คุณต้องการให้พึ่งพา
จุดสิ้นสุดของ ?MAKE: บรรทัด บางหน่วยบังคับได้ด้วยวิธีนี้เท่านั้น คือ
ที่อยู่ในรูปแบบ Warn_*.U และ Chk_*.U คุณยังสามารถปรับแต่งค่าเริ่มต้นบางอย่างได้
กำหนดค่าตัวแปรโดยคัดลอก Myinit.U ไปยังไดเร็กทอรี U ส่วนตัวของแพ็คเกจและ
การตั้งค่าตัวแปรในหน่วยนั้น
ตอนนี้คุณพร้อมที่จะวิ่งแล้ว เมตาคอนฟิก. ที่จะทำให้เกิด กำหนดค่า ไฟล์ และตัวเลือก a
config_h.SH ไฟล์ (หากแหล่งที่มาของคุณใช้สัญลักษณ์ C) ไฟล์ที่สร้างขึ้นจะ
จะถูกเพิ่มใน MANIFEST.new ของคุณโดยอัตโนมัติหากจำเป็น อย่าลืมอัปเดตของคุณ
MANIFEST ไฟล์แม้ว่า
ในการสร้างหน่วยใหม่ให้ทำดังต่อไปนี้:
· คัดลอกหน่วยที่คล้ายกันไปยังไฟล์ .U ใหม่ ชื่อที่คุณเลือกควรเป็นชื่อของ a
ตัวแปรที่สร้างขึ้นโดยหน่วยแม้ว่าจะเป็นเพียงความสะดวกสำหรับคุณไม่ใช่
ความต้องการ. ควรมีอักขระไม่เกิน 12 ตัวเพื่อป้องกันการตัดชื่อไฟล์
อันที่จริงน่าจะ 10 หรือน้อยกว่านั้นเพื่อให้ผู้ที่ต้องการใช้ RCS ได้
a .U,v ในตอนท้ายโดยไม่ต้องสับ Metaconfig ใช้ตัวพิมพ์ของตัวอักษรตัวแรกถึง
ตรวจสอบว่าตัวแปรใดถูกสร้างโดยหน่วยนี้จริง ๆ ดังนั้นอย่าใช้ตัวพิมพ์ใหญ่ของคุณ
ชื่อหน่วยถ้ามันควรจะสร้างตัวแปรเชลล์
· แก้ไขไฟล์ .U ใหม่เพื่อทำสิ่งที่คุณต้องการ ?MAKE ตัวแรก: บรรทัดบ่งชี้ว่า
การพึ่งพาอาศัยกัน; ก่อนโคลอนรายการสุดท้าย ตัวแปรทั้งหมดที่หน่วยนี้กำหนดและ
หลังจากโคลอนสุดท้าย ตัวแปรทั้งหมด (หรือหน่วยอื่น ๆ ) ที่หน่วยนี้ขึ้นอยู่กับ
เป็นสิ่งสำคัญมากที่รายการเหล่านี้ต้องถูกต้อง หากการพึ่งพานั้นเป็นทางเลือกและ a
สามารถใช้ค่าเริ่มต้นได้ คุณควรนำหน้าการขึ้นต่อกันด้วยเครื่องหมาย '+' NS
หน่วยที่เกี่ยวข้องจะไม่ถูกโหลดเพื่อคำนวณสัญลักษณ์เว้นแต่จำเป็นจริงๆ
โดยหน่วยอื่น
· ในขอบเขตที่เป็นไปได้ กำหนดพารามิเตอร์หน่วยของคุณตามตัวแปรเชลล์ที่กำหนดไว้บน
?INIT: เส้น. สิ่งนี้จะย้ายคำจำกัดความของตัวแปรไปยังหน่วย Init.U โดยที่
สามารถแทนที่ได้ด้วยคำจำกัดความใน Myinit.U ซึ่งรวมอยู่หลัง Init.U
· เพิ่มคำจำกัดความของสัญลักษณ์ C ที่ต้องการเป็น ?H: บรรทัด บรรทัดที่ขึ้นต้นด้วย
?H:?%<: ในไฟล์ .U จะถูกเพิ่มไปยังไฟล์ config.h ในท้ายที่สุดก็ต่อเมื่อ
metaconfig ตัดสินใจว่าจำเป็นต้องใช้หน่วยนี้ %< หมายถึงชื่อหน่วย
ซึ่งเป็นชื่อของไฟล์ด้วย (ไม่มี .U) หากคุณทำตาม
การประชุม ใส่ความคิดเห็นในแต่ละ ?H: บรรทัดในกรณีตัวแปร
การเปลี่ยนตัวก่อนหน้าในบรรทัดเริ่มต้นความคิดเห็นโดยไม่ทำให้เสร็จ เปลือกใดก็ได้
ตัวแปรที่ขึ้นต้นด้วย d_ อาจทำเช่นนี้ได้ ดังนั้นจงระวัง หากคุณละเว้น ?%<: แล้ว
metaconfig จะพยายามเรียกสัญลักษณ์ที่ต้องการคำจำกัดความก่อนใดๆ
รวมอยู่ใน config.h
เพิ่มคำจำกัดความอภิธานศัพท์เป็น ?S: บรรทัดสำหรับตัวแปรเชลล์ และ ?C: บรรทัดสำหรับ C
ตัวแปรตัวประมวลผลล่วงหน้า ดูหน่วยปัจจุบันสำหรับตัวอย่าง มันสำคัญมากที่จะ
เริ่มแต่ละรายการด้วยชื่อสัญลักษณ์ชิดซ้าย และสิ้นสุดแต่ละรายการด้วย ?C: หรือ
?NS:. ไลน์. อัลกอริทึมที่แปลรายการสัญลักษณ์ตัวประมวลผลล่วงหน้า C สำหรับ
อภิธานศัพท์ในความคิดเห็นสำหรับ config.h ขึ้นอยู่กับสิ่งนี้
· ตรวจสอบให้แน่ใจว่าคำสั่งซื้อทั้งหมดของคุณ ? เส้นถูกต้อง ลำดับที่ถูกต้องคือ:
?RCS: และ ?X: โดยทั่วไปก็แค่ความคิดเห็น
?สร้าง: การพึ่งพา metaconfig
?Y: คำสั่งเค้าโครงหน่วย
?S: คำจำกัดความของเชลล์อภิธานศัพท์
?C: อภิธานศัพท์ C คำจำกัดความ
?H: คำจำกัดความ config.h
?M: คำจำกัดความ confmagic.h
?W: ต้องการสัญลักษณ์
?V: สัญลักษณ์ที่มองเห็นได้
?F: ไฟล์ที่สร้างโดยหน่วยนี้
?T: ใช้สัญลักษณ์เชลล์ชั่วคราว
?D: ค่าดีฟอลต์ของการอ้างอิงทางเลือก
?O: ใช้เพื่อทำเครื่องหมายหน่วยที่ล้าสมัย
?LINT: คำใบ้โลหะ
?INIT: การเริ่มต้นสัญลักษณ์เชลล์
ต่อไปนี้คือตัวอย่างเพื่อแสดงลำดับของบรรทัดและรูปแบบต่างๆ ที่อนุญาต:
?RCS: $RCS-รหัส$
?RCS: ข้อมูลลิขสิทธิ์
?RCS: $RCS-บันทึก$
?NS:
?X: ตัวอย่างที่ประดิษฐ์ขึ้น
?NS:
?MAKE:d_one สอง: สาม +สี่ Five
?MAKE: - เลือกเพิ่ม $@ %
?Y:ค่าเริ่มต้น
?ส:d_one:
?S: สัญลักษณ์เชลล์ตัวแรก กำหนดเงื่อนไข ONE
?NS:.
?S:สอง:
?S: สัญลักษณ์เชลล์ที่สอง ค่าสำหรับ TWO
?NS:.
?C:หนึ่ง:
?C: สัญลักษณ์ C ตัวแรก
?ค:.
?C:สอง:
?C: สัญลักษณ์ C ที่สอง
?ค:.
?H:#$d_one หนึ่ง /**/
?H:#define TWO "$two"
?H:#$d_one ONE_TWO "$two"
?ชม:.
?M:พลิก: HAS_FLIP
?M:#ifndef HAS_FLIP
?M:#define ฟลิป(x) ฟล็อป(x)
?ม:#จบดิฟ
?NS:.
?W:%<:one_two
?V:p_one p_two:p_three
?F:ไฟล์ ./ftest !tmp
?T:tmp วา
?D:two='undef'
?LINT:เปลี่ยนสาม
?INIT:two_init='2'
: รหัสเชลล์ที่ใช้หน่วยดังต่อไปนี้
p_one='หนึ่ง'
p_two='สอง'
p_three=""
ให้ฉันพูดอีกครั้ง: คำจำกัดความของหน่วยข้างต้นคือ a เทียม หนึ่งเดียวเพื่อแสดง
ความเป็นไปได้ที่แตกต่างกัน หน่วยดังกล่าวจะมีประโยชน์เพียงเล็กน้อยอยู่แล้ว... อีกหน่อย
คุณสมบัติขั้นสูงไม่ได้อธิบายไว้ที่นี่ โปรดดูที่ อ้างอิง ส่วนเพิ่มเติม
ข้อมูลที่สมบูรณ์
· ใส่หน่วยลงในไดเร็กทอรี U สาธารณะหรือส่วนตัวตามความเหมาะสม
· ฉายซ้ำ เมตาคอนฟิก.
·ส่งหน่วยของคุณไปที่ [ป้องกันอีเมล] (ราฟาเอล มันเฟรดี) เพื่อรวมไว้ในสำเนาต้นแบบ
ถ้าคุณคิดว่ามันเป็นที่สนใจทั่วไป
เพื่อที่จะเพิ่มโปรแกรมใหม่ที่จะอยู่:
· แก้ไข Loc.U และเพิ่มชื่อของโปรแกรมทั้งสองลงในบรรทัด ?MAKE: (ระหว่าง
ทวิภาคสองอัน) และไปยัง loclist หรือ trylist (ขึ้นอยู่กับว่าโปรแกรมนั้นเป็น
บังคับหรือไม่)
· รัน metaconfig อีกครั้ง
· ส่งหน่วยของคุณมาให้ฉันเพื่อรวมไว้ในสำเนาต้นแบบ ถ้าคุณคิดว่ามันเป็นแบบทั่วไป
ดอกเบี้ย
หมายเหตุสำหรับการเขียนไฟล์ .U:
* ใช้ "rm -f" เสมอ เพราะมีระบบที่ rm โต้ตอบโดยค่าเริ่มต้น
* อย่าใช้ "set -- ..." เพราะ '--' ใช้ไม่ได้กับทุกเชลล์ ใช้ "set x ...;
กะ".
* อย่าใช้ "unset ENV" เนื่องจาก unset นั้นไม่สามารถพกพาได้อย่างเต็มที่ พูดว่า "ENV=''" แทน
* ใช้ echo " " (เว้นวรรค) เสมอ เพราะระบบ Eunice
* ใช้เท่านั้น ทดสอบ ด้วย -r, -w, -f หรือ -d เนื่องจากเป็นสวิตช์แบบพกพาเพียงตัวเดียว ใน
โดยเฉพาะหลีกเลี่ยง "test -x"
* ใช้เฉพาะโปรแกรมที่มากับ V7 เท่านั้น จะได้รู้ว่าทุกคนมี
* ใช้ $contains เมื่อคุณต้องการ grep แบบมีเงื่อนไข เนื่องจากไม่ใช่ทุก grep จะคืนค่า a
สถานะที่สมเหตุสมผล อย่าลืมเปลี่ยนเส้นทางเอาต์พุตไปที่ /dev/null โดยใช้ '>/dev/null
2>&1'.
* ใช้ "if test" แทน "if [...]" เนื่องจากไม่ใช่ทุก sh ที่รู้โครงสร้างหลัง
* ใช้สคริปต์ myread สำหรับอินพุตเพื่อให้สามารถทำการหลบหนีของเชลล์และค่าเริ่มต้นได้
การประเมิน. รูปแบบทั่วไปคือ
กรณี "$grimble" ใน
'') dflt=452;;
*) dflt="$grimble";;
ว่า C
rp='คุณมี grimbles กี่ตัว?'
. ./มายเรด
grimble="$ans"
* ใช้สคริปต์ getfile เมื่อขอชื่อพาธของไฟล์เพื่อให้มีตัวเลือก
~ขยายชื่อและตรวจสุขภาพจิต ดูหน่วย Getfile.U สำหรับคำอธิบายแบบเต็ม
* ใส่ .เสมอ
$เริ่มต้น
ที่ด้านบนสุดของทุกสคริปต์ที่สร้างขึ้นที่จะเปิดตัวหรือจัดหาโดย
กำหนดค่า.
* อย่าถือว่า UNIX-isms ทั่วไปเหมือนกับความจริงที่ว่าไฟล์อ็อบเจ็กต์ลงท้ายด้วย a .o และ
ที่ชื่อห้องสมุดลงท้ายด้วย .a. ใช้ $_o และ $_ก ตัวแปรแทน (ดู
ยูนิกซ์.ยู).
* เมื่อทำการทดสอบ compile-link-execute ให้เขียนดังนี้:
$cc $ccflags $ldflags try.c -o ลอง $libs
เพราะบางระบบต้องการให้ระบุแฟล็กการลิงก์ก่อนคอมไพล์
เป้าหมาย (ยกเว้นไลบรารีลิงก์ต่อท้าย)
* ออกข้อความสำคัญใน file descriptor #4 โดยใช้ '>&4' เพื่อเปลี่ยนเส้นทางเอาต์พุต
เฉพาะข้อความเหล่านั้นเท่านั้นที่จะปรากฏเมื่อ -s สวิตช์มอบให้ กำหนดค่า บน
บรรทัดคำสั่ง (โหมดเงียบ)
* พยายามตรวจสอบว่าคุณลักษณะมีอยู่ในลักษณะที่เฉพาะเจาะจงที่สุดหรือไม่ - อย่า
พูดว่า "if bsd" เมื่อคุณสามารถ grep libc มีระบบไฮบริดมากมายและ
คุณลักษณะแต่ละอย่างควรยืนหรือตกด้วยตัวเอง
* พยายามกำหนดอยู่เสมอว่าคุณลักษณะนั้นมีอยู่ในลักษณะทั่วไปที่สุดหรือไม่ ดังนั้น
แพ็คเกจอื่นๆ สามารถใช้ยูนิตของคุณได้
* หากมีข้อสงสัย ให้ตั้งค่าเริ่มต้นและถาม อย่าถือสาอะไร
* หากคุณคิดว่าผู้ใช้ผิด ให้ยอมรับข้อเท็จจริงว่าเขาอาจจะถูก สำหรับ
ตัวอย่าง เขาสามารถเรียกใช้ Configure บนระบบอื่นที่ไม่ใช่ของเขาได้
ผลิตภัณฑ์สุดท้ายบน.
Metaconfig ขอสงวนชื่อต่อไปนี้ในไดเร็กทอรีของคุณ และหากคุณใช้ชื่อดังกล่าว ก็
อาจถูกปิดบังหรือมีผลกระทบที่ไม่คาดฝันอื่น ๆ :
.เอ็มที/*
กำหนดค่า
อยาก
ล้าสมัย
กำหนดค่า
config_h.SH
confmagic.h
ยู/*
MANIFEST.ใหม่
นอกจากนี้ การกำหนดค่าอาจปิดบังชื่อเหล่านี้ในไดเร็กทอรีที่เรียกใช้ใน:
อ./*
config.sh
config.h
OPTIONS
ตัวเลือกต่อไปนี้ได้รับการยอมรับโดย เมตาคอนฟิก:
-d เปิดโหมดแก้ไขข้อบกพร่อง ไม่มีประโยชน์จริง ๆ เว้นแต่ว่าคุณกำลังดีบั๊ก เมตาคอนฟิก
ตัวเอง
-h พิมพ์ข้อความช่วยเหลือและออก
-k เก็บไดเร็กทอรีชั่วคราวไว้ เพื่อที่คุณจะได้ตรวจสอบไฟล์งานที่ใช้โดย
เมตาคอนฟิก เพื่อสร้างของคุณ กำหนดค่า สคริปต์ มีประโยชน์เฉพาะเมื่อทำการดีบั๊ก
หน่วย
-m สมมติว่ามีหน่วยความจำจำนวนมากและพื้นที่สว็อป สิ่งนี้จะเร่งการค้นหาสัญลักษณ์ใน
ไฟล์ต้นฉบับโดยใช้เวลาพอสมควรโดยเสียหน่วยความจำ
การบริโภค...
-o ทำแผนที่สัญลักษณ์ที่ล้าสมัยกับสัญลักษณ์ใหม่ ใช้สวิตช์นี้หากคุณยังมีอยู่บ้าง
สัญลักษณ์ที่ล้าสมัยในซอร์สโค้ดของคุณและไม่ต้องการ (หรือไม่สามารถ) ลบออก
พวกเขาในตอนนี้ สัญลักษณ์ที่ล้าสมัยจะถูกละเว้นเป็นอย่างอื่นแม้ว่า
จะเตือนคุณจาก เมตาคอนฟิก.
-s เปิดโหมดเงียบ
-t ติดตามสัญลักษณ์ตามที่พบ
-v เปิดโหมด verbose
-w สมมติว่าต้องการไฟล์เป็นปัจจุบัน นี้จะข้ามเวลาและหน่วยความจำ
ขั้นตอนการใช้การสแกนซอร์สโค้ดโดยมองหาสัญลักษณ์ที่รู้จัก ใช้มัน
เฉพาะเมื่อคุณรู้ว่าไฟล์ต้นฉบับของคุณไม่ได้เปลี่ยนแปลงในส่วนที่เกี่ยวกับ
สระว่ายน้ำของ เมตาคอนฟิก สัญลักษณ์ที่ใช้
-G ยังให้ GNU กำหนดค่า- เหมือนส่วนหน้ากับที่สร้างขึ้น กำหนดค่า
สคริปต์ที่จะรวมอยู่ในการแจกจ่ายเช่นกัน นี้เป็นเพียงกระดาษห่อ
around the กำหนดค่า สคริปต์เป็นธรรมชาติ แต่ช่วยให้ผู้คนคุ้นเคยกับ
เครื่องมือ GNU จะไม่สูญหายเมื่อเผชิญกับการแจกจ่ายใหม่
-L dir แทนที่ตำแหน่งห้องสมุดเริ่มต้น โดยปกติมีประโยชน์สำหรับ metaconfig . เท่านั้น
ผู้ดูแลใช้หน่วยที่พัฒนาในพื้นที่แทน
ที่เปิดเผยต่อสาธารณะ NS dir ระบุเป็นหน่วยที่มีหน่วย
U ไดเรกทอรี
-M อนุญาตให้ผลิต a confmagic.h ไฟล์เพื่อทำการแมปใหม่โดยอัตโนมัติ
สัญลักษณ์ที่รู้จักเป็นทางเลือกอื่นเช่น สำเนา() กำลังทำการแมปใหม่
อย่างโปร่งใสถึง เมมปี้() เมื่อไม่พร้อมใช้งาน ตัวเลือกนี้เปิดอยู่
โดยอัตโนมัติเมื่อ a confmagic.h ไฟล์มีอยู่ในไดเร็กทอรีระดับบนสุด
เพียงลบไฟล์นั้นหากคุณต้องการปิดการใช้งานตัวเลือกนี้อย่างถาวร
-V พิมพ์หมายเลขเวอร์ชันและออก
การสอน
ส่วนนี้ (ยาว) เป็นบทนำสู่ เมตาคอนฟิกซึ่งเราจะเรียนรู้ทั้งหมด
พื้นฐาน ถ้าคุณรู้วิธีใช้แล้ว เมตาคอนฟิก, คุณสามารถข้ามไปที่ถัดไปได้อย่างปลอดภัย
มาตรา.
ขององค์กร
โดยปกติเมื่อคุณต้องการรับแพ็คเกจต้นทางเพื่อคอมไพล์บนแพลตฟอร์มที่กำหนดคุณมี
หากต้องการแก้ไข Makefile หลัก (ถ้ามีอยู่!) ให้เลือกคอมไพเลอร์ C ตรวจสอบให้แน่ใจว่าคุณ
มีไลบรารี่ที่เหมาะสม จากนั้นจึงเปิดไฟล์ ทำ สั่งการ. ถ้าแพ็กเก็จสมเหตุสมผล
เขียนได้ดีก็จะรวบรวม (โดยไม่มีคำเตือนเป็นตัวเลือก :-) ในตัวเองสุดท้าย
ประโยคคือประสิทธิภาพที่แท้จริง เนื่องจากได้รับความหลากหลายของแพลตฟอร์ม UNIX ที่มีอยู่ในปัจจุบัน
และความหลากหลายของรสชาติ นั่นหมายความว่าผู้เขียนแพคเกจได้ลงลึกถึง
มีปัญหาในการหาทางเลือกที่เหมาะสมจากการลองผิดลองถูก คาดเดา และสับสน
รอบ ๆ กับระบบรวมถึงและประเภท
อย่างไรก็ตาม แม้จะมีความสามารถทั้งหมดของเขา ผู้เขียนก็ไม่สามารถรู้ได้ว่าระบบบางระบบมี
การเรียกระบบที่ใช้งานไม่ได้ หรือโครงสร้างระบบบางส่วนขาดฟิลด์มาตรฐานอย่างใดอย่างหนึ่งหรือ
ไม่ว่าไฟล์รวมที่กำหนดจะมีอยู่หรือไม่ก็ตาม และฉันไม่ได้พิจารณาโดยปริยาย
สมมติฐานเช่นประเภทที่ส่งคืนโดย มัลลอค () หน้าที่หรือการมีอยู่ของ
เปลี่ยนชื่อ () ระบบเรียกชื่อไม่กี่ แต่ความรู้นั้นจำเป็นเพื่อให้บรรลุตามความเป็นจริง
ความเบา
ตอนนี้อย่าทำร้ายตัวเอง การใช้ข้อมูลนั้นต้องใช้ทักษะที่มากขึ้น แต่ก็สามารถ
นำไปสู่โปรแกรมแบบพกพามากขึ้นเนื่องจากมันถูกเขียนในลักษณะที่ไม่ขึ้นกับระบบ
และอาศัยเพียงความจริงที่ว่าสมมติฐานบางอย่างเป็นจริงหรือเท็จในระบบใดระบบหนึ่ง
สมมติฐานแต่ละข้อไม่เกี่ยวข้องกัน กล่าวคือ เราไม่ได้พูดว่า: We're on a
ระบบ BSD หรือเราอยู่ในระบบ USG ทุกวันนี้มันก็คลุมเครือเกินไป ไม่ เราต้องการ
พูดกับซอร์สโค้ด: ระบบนี้ไม่มี เปลี่ยนชื่อ () ระบบเรียกและ มัลลอค ()
ส่งคืน a (โมฆะ *) มูลค่า
Metaconfig เป็นเครื่องมือที่จะช่วยให้คุณทำอย่างนั้นได้ โดยมีประโยชน์เพิ่มเติมของการไม่
ต้องแก้ไข Makefile ด้วยมือหากทุกอย่างเป็นไปด้วยดี โดยการวิ่ง เมตาคอนฟิก, คุณสร้าง
เชลล์สคริปต์ชื่อ กำหนดค่า. ได้ทุ่มเทความพยายามอย่างมากให้กับสคริปต์กำหนดค่า
ภายในเพื่อให้แน่ใจว่าจะทำงานบน 99% ของเชลล์ที่มีอยู่ ณ ตอนนี้
การเขียน. กำหนดค่าจะตรวจสอบระบบเป้าหมาย ถามคำถามเมื่อมีข้อสงสัยและ
รวบรวมคำตอบทั้งหมดไว้ในไฟล์เชลล์ไฟล์เดียว ซึ่งสามารถใช้เพื่อ
สร้าง Makefiles ที่กำหนดค่าโดยอัตโนมัติและ C รวมไฟล์
มีชุดสัญลักษณ์จำกัด (แต่ค่อนข้างใหญ่) สำหรับเชลล์สคริปต์ของคุณ
และโปรแกรมซี ทั้งหมดได้รับการบันทึกไว้ในไฟล์อภิธานศัพท์ สิ่งที่คุณต้องทำคือเรียนรู้
และเริ่มใช้งานเพื่อแก้ไขปัญหาการพกพาและการกำหนดค่า แล้ว,
โดยการวิ่ง เมตาคอนฟิกสคริปต์ Configure ที่เหมาะสมจะถูกสร้างขึ้นสำหรับแพ็คเกจของคุณ
สคริปต์กำหนดค่าถูกสร้างขึ้นจากหลายหน่วย (มากกว่า 300) แต่ละหน่วยเป็น
รับผิดชอบในการกำหนดสัญลักษณ์เชลล์และ/หรือ C จำนวนเล็กน้อย ประกอบหน่วย
ร่วมกันในขั้นตอนสุดท้ายเคารพกราฟการพึ่งพา (หน่วยหนึ่งอาจต้องการผลลัพธ์
ของหน่วยอื่น ๆ หลายหน่วยซึ่งถูกวางไว้ก่อนหน้าในสคริปต์)
สัญลักษณ์
สัญลักษณ์เป็นสิ่งที่สำคัญที่สุดใน เมตาคอนฟิก โลก. พวกมันเล็กที่สุด
เอนทิตีที่รู้จัก มักจะเป็นคำ และสามารถให้ค่าที่ส่วนท้ายของการกำหนดค่า
การดำเนินการ ตัวอย่างเช่น สัญลักษณ์ตัวประมวลผลล่วงหน้า C HAS_RENAME คือ เมตาคอนฟิก สัญลักษณ์ว่า
ได้รับการรับประกันว่าจะถูกกำหนดหากและเฉพาะในกรณีที่ เปลี่ยนชื่อ () มีการเรียกของระบบ เช่นเดียวกัน,
$รันลิบ ตัวแปรเชลล์จะถูกตั้งค่าเป็น ':' หรือ 'ranlib' ขึ้นอยู่กับว่า
โทรไปที่ วิ่ง จำเป็นต้องใช้โปรแกรมเพื่อสั่งไฟล์ไลบรารี วิธีการทำงานนี้ไม่ได้
สำคัญสำหรับตอนนี้ สิ่งสำคัญคือต้องเข้าใจว่าสัญลักษณ์เหล่านั้นได้รับ a ชีวิต
(เช่นค่า) เมื่อ กำหนดค่า การดำเนินการ
การใช้สัญลักษณ์ค่อนข้างตรงไปตรงมา ในไฟล์ต้นฉบับ C คุณเพียงแค่ใช้สัญลักษณ์
ค่าเป็นคำสั่งก่อนโปรเซสเซอร์ (เช่น: #ifdef HAS_RENAME) หรือหากเป็นสัญลักษณ์
ค่าเป็นสตริงโดยตรงเหมือนกับที่คุณใช้มาโครใน C และในไฟล์เชลล์หรือa
Makefile คุณสามารถอ้างอิงสัญลักษณ์เชลล์ได้โดยตรง
อันที่จริงฉันโกหกเพราะนั่นไม่วิเศษเท่าวรรคก่อน
สามารถส่งเสียง ในไฟล์ C คุณต้องรวม Configure-produced config.h ไฟล์และ
คุณต้องห่อเชลล์สคริปต์หรือ Makefile ในไฟล์ .SH และคุณสามารถอ้างอิงเชลล์
สัญลักษณ์เฉพาะในส่วนการแทนที่ตัวแปรของไฟล์ .SH นั้น เพิ่มเติมเกี่ยวกับเรื่องนี้ในภายหลัง
แหล่ง ไฟล์
สัญลักษณ์อาจปรากฏในชุดไฟล์ต้นฉบับที่จำกัดเท่านั้น เนื่องจาก เมตาคอนฟิก จะเท่านั้น
สแกนสิ่งเหล่านั้นเมื่อมองหาสัญลักษณ์ที่รู้จัก พยายามค้นหาว่าต้องใช้หน่วยใด
คุณสามารถใช้สัญลักษณ์ C ในไฟล์ต้นฉบับ C ได้ เช่น ไฟล์ที่มี a .c, .h, .y or .l นามสกุลและ
สัญลักษณ์เชลล์ค้นหาเฉพาะในไฟล์ .SH
เพื่อให้ได้ค่าของสัญลักษณ์ ไฟล์ C จำเป็นต้องมีไฟล์พิเศษ config.h
ไฟล์ซึ่งผลิตโดย กำหนดค่า เมื่อมีสัญลักษณ์ C และไฟล์ .SH ถูกเรียกใช้
ผ่านเชลล์สร้างไฟล์ใหม่ อย่างไรก็ตาม ในส่วนบนของไฟล์ .SH ไฟล์
พิเศษ config.sh ไฟล์ (ผลิตโดยการรัน .ด้วย กำหนดค่า) เป็นแหล่งที่มาและตัวแปร
ใช้การทดแทน จริงๆแล้ว, config.h ผลิตโดยเรียกใช้ เมตาคอนฟิก-produced
config_h.SH ไฟล์อีกครั้งโดยใช้การแทนที่ตัวแปร เราจะมาดูกันว่า
ใกล้กันอีกนิด เพราะนี่คือหัวใจของทั้งมวล องค์ประกอบ โครงการ...
ตัวแปร การแทน
มีโครงสร้างเปลือกเรียกว่า โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม เอกสาร ซึ่งช่วยให้คำสั่งรับอินพุต
ระบุไว้ในสคริปต์เอง อินพุตนั้นถูกตีความโดยเชลล์เป็น double-
สตริงที่ยกมาหรือสตริงที่เสนอราคาเดียวขึ้นอยู่กับรูปแบบของเอกสารที่นี่
สเปค
ในการระบุเอกสารที่นี่ โทเค็น '<<' จะถูกใช้ ตามด้วยตัวระบุเดียว จาก
จากนั้นบนบรรทัดสคริปต์ที่เหลือจะสร้างอินพุตสำหรับคำสั่งจนถึง here
เอกสารถูกพบในบรรทัดด้วยตัวเอง การแทนที่เชลล์ (รวมถึงตัวแปรเชลล์
การแทนที่) เสร็จสิ้นเว้นแต่ตัวระบุถูกล้อมรอบด้วยเครื่องหมายคำพูดเดี่ยว ตัวอย่างเช่น:
var='แรก'
tar='วินาที'
echo "--> เอกสารแรกที่นี่:"
แมว <
var='$var'
tar='$tar'
EOM
echo "--> วินาทีที่นี่ เอกสาร:"
แมว <<'EOM'
เสียงสะท้อน $var
สะท้อน $tar
EOM
echo "--> จบ"
จะสร้างเมื่อวิ่งผ่านเชลล์:
-> เอกสารแรกที่นี่:
var='แรก'
tar='วินาที'
-> เอกสารที่สองที่นี่:
เสียงสะท้อน $var
สะท้อน $tar
--> จบ.
เอกสารฉบับแรกในที่นี้มีการตีความเนื้อหาในขณะที่เอกสารฉบับที่สองแสดงผลตามที่เป็นอยู่
ทั้งสองมีประโยชน์ในสคริปต์ .SH อย่างที่เราจะได้เห็นกัน
การใช้ .NS สคริปต์
สคริปต์ .SH มักจะสร้างโดยการเรียกใช้ ทำให้SH สคริปต์อื่น ๆ ไฟล์ที่มีอยู่
การเปลี่ยนแปลง ไฟล์ ลง ไฟล์.SH. ลองมาดูตัวอย่างกัน นี่สคริปหน่อย
(เรียกมันว่า ขยายขนาด) ซึ่งพิมพ์ข้อความเดียวขนาดของ int ประเภทข้อมูลใน C.
น่าเสียดายที่มันมีค่าเดินสายอยู่ในนั้นดังนั้น:
#!bin / sh /
intsize='4'
echo "ในเครื่องนี้ ชนิด int คือ $intsize bytes"
มาวิ่งกันเถอะ ทำให้SH บนมันโดยพิมพ์ 'ทำให้SH ขยายขนาด'. รับซิงเกิ้ลค่ะ intsize.SH ไฟล์ที่
มีลักษณะเช่นนี้:
กรณี $CONFIG ใน
'')
ถ้า test -f config.sh; แล้ว TOP=.;
elif test -f ../config.sh; แล้ว TOP=..;
elif test -f ../../config.sh; แล้วท็อป=..-;
elif test -f ../../../config.sh; แล้วท็อป=..-;
elif test -f ../../../../config.sh; แล้วท็อป=..-;
อื่น
echo "ไม่พบ config.sh"; ทางออก 1
fi
- $TOP/config.sh
;;
ว่า C
: สิ่งนี้บังคับให้ไฟล์ SH สร้างเป้าหมายในไดเรกทอรีเดียวกับไฟล์ SH
: เพื่อให้การพึ่งพารู้อยู่เสมอว่าจะหาอนุพันธ์ของ SH ได้ที่ไหน
กรณี "$ 0" ใน
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
ว่า C
echo "การแยกขนาด (พร้อมการแทนที่ตัวแปร)"
: ส่วนนี้ของไฟล์จะมีการแทนที่ตัวแปร
: ย้ายอะไรก็ได้ที่ต้องการ config subs จาก !NO!SUBS! ไปที่ !GROK!THIS!.
: ปกป้องเครื่องหมายดอลลาร์และ backticks ใด ๆ ที่คุณไม่ต้องการให้ตีความ
: โดยใส่แบ็กสแลชข้างหน้า คุณสามารถลบความคิดเห็นเหล่านี้
$spitshell > intsize <
$เริ่มต้น
!GROK!นี่!
: ในดอลลาร์และ backticks ต่อไปนี้ไม่จำเป็นต้องมีแบ็กสแลชพิเศษ
$spitshell >>intsize <<'!NO!SUBS!'
intsize='4'
echo "ในเครื่องนี้ ชนิด int คือ $intsize bytes"
!ไม่!ซับ!
chmod 755 ขนาดไม่ใหญ่นัก
$eunicefix ขนาด
ส่วนแรกของสคริปต์นี้ (ใน กรณี คำสั่ง) กำลังพยายามค้นหา config.sh
ไฟล์เพื่อที่จะแหล่งที่มามัน NS $กำหนดค่า ตัวแปรเป็นเท็จโดยค่าเริ่มต้น โดยเป็นจริงเมื่อ
config.sh ได้รับแหล่งที่มาแล้ว (ซึ่งจะเป็นกรณีถ้าไฟล์นี้ถูกเรียกใช้จาก
ภายใน กำหนดค่า เอง แต่อย่าสับสนในประเด็นนี้)
เมื่อ config.sh ไฟล์ได้รับแหล่งที่มาทุกสัญลักษณ์เชลล์ที่กำหนดโดย กำหนดค่า เป็น
ชุด. เราทราบถึงคำสั่ง case ที่สอง ซึ่งใช้ในการเปลี่ยนไดเร็กทอรีปัจจุบันควร a
เส้นทางที่ใช้ในการเข้าถึงโปรแกรมนี้ (เช่น ถ้าเราบอกว่า 'sh ../scripts/insize.SH', เรา
จะวิ่งก่อน'cd ../สคริปต์' ก่อนดำเนินการต่อ) หากคุณไม่เข้าใจสิ่งนี้อย่า
กังวลเกี่ยวกับมัน
นี่คือสิ่งที่น่าสนใจ สคริปต์นี้ใช้ $น้ำลาย ตัวแปรและไม่ใช่
สิ่งที่เรารู้เกี่ยวกับ...ยัง ถ้าคุณดูไฟล์อภิธานศัพท์ คุณจะเห็นว่า
นี่คือตัวแปรที่รู้จักโดย เมตาคอนฟิก. หากคุณทำให้ไฟล์นี้เป็นส่วนหนึ่งของการแจกจ่ายของคุณ
(โดยรวมไว้ในไฟล์ MANIFEST.new เราจะกลับมาที่นี้ในภายหลัง) และเรียกใช้
เมตาคอนฟิกแล้ว กำหนดค่า สคริปต์จะกำหนดค่าที่เหมาะสมสำหรับตัวแปรนี้
และจะถูกตั้งไว้ใน config.sh. เหมือนกันสำหรับ $เริ่มต้น และความลึกลับ $ยูนิซฟิกซ์ at
ตอนจบ. ในระบบที่เหมาะสม ส่วนที่เกี่ยวข้องของ config.sh จะมีลักษณะเช่นนี้:
spitshell = 'แมว'
startsh='#!bin / sh /'
eunicefix=':'
อา! เรากำลังไปถึงที่นั่น ตอนนี้มันดูคุ้นเคย เรากำลังเผชิญหน้าคนโสด แมว คำสั่งของใคร
อินพุตมาจากเอกสารที่มีการสอดแทรกตัวแปรที่นี่และเอาต์พุตจะถูกเปลี่ยนเส้นทางไปที่
ขยายขนาด. ค่าจะเป็นของ $เริ่มต้น, เช่น '#!bin / sh /'. สบายดีจนถึงตอนนี้
จากนั้นเราก็มาถึงส่วนที่สองของการขยายเอกสารเพื่อรับส่วนที่เหลือของสคริปต์ นี้
เวลา สัญลักษณ์เอกสาร here ล้อมรอบด้วยเครื่องหมายคำพูดเดี่ยว ดังนั้นเนื้อหาจะเป็น
ต่อท้ายคำต่อท้าย ขยายขนาด ไฟล์. ดังนั้นโดยการวิ่ง 'sh intsize.SH' เราได้รับ
ผลลัพธ์ต่อไปนี้:
การแยก intsize (ด้วยการแทนที่ตัวแปร)
และเมื่อดูที่ไฟล์ intsize ที่สร้าง เราจะเห็น:
#!bin / sh /
intsize='4'
echo "ในเครื่องนี้ ชนิด int คือ $intsize bytes"
ซึ่งเป็นสิ่งที่เรามีในตอนเริ่มต้น จนถึงตอนนี้ก็ยังเป็นขั้นตอนที่ไม่ดำเนินการ...
แต่ช่างวิเศษเหลือเกิน! มันจึงเกิดขึ้น (เรื่องบังเอิญล้วนๆ เชื่อฉันสิ!) ว่า เมตาคอนฟิก รู้
เกี่ยวกับ $insize สัญลักษณ์เปลือก โดยการย้ายการเริ่มต้นของ intsize ไปยังตัวแปร-
พื้นที่สอดแทรกของสคริปต์ .SH และเริ่มต้นด้วย กำหนดค่า- ค่าที่คำนวณได้
และลบความคิดเห็นที่ไร้ประโยชน์ตอนนี้ที่เพิ่มโดย ทำให้SH, เราได้รับ:
กรณี $CONFIG ใน
'')
ถ้า test -f config.sh; แล้ว TOP=.;
elif test -f ../config.sh; แล้ว TOP=..;
elif test -f ../../config.sh; แล้วท็อป=..-;
elif test -f ../../../config.sh; แล้วท็อป=..-;
elif test -f ../../../../config.sh; แล้วท็อป=..-;
อื่น
echo "ไม่พบ config.sh"; ทางออก 1
fi
- $TOP/config.sh
;;
ว่า C
กรณี "$ 0" ใน
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
ว่า C
echo "การแยกขนาด (พร้อมการแทนที่ตัวแปร)"
$spitshell > intsize <
$เริ่มต้น
intsize='$intsize'
!GROK!นี่!
$spitshell >>intsize <<'!NO!SUBS!'
echo "ในเครื่องนี้ ชนิด int คือ $intsize bytes"
!ไม่!ซับ!
chmod 755 ขนาดไม่ใหญ่นัก
$eunicefix ขนาด
แน่นอนว่าการเรียกใช้สคริปต์นี้ผ่านเชลล์จะส่งออกสคริปต์เดิมอีกครั้ง แต่ถ้า
พวกเราวิ่ง กำหนดค่า บนเครื่องที่ int ถูกเก็บไว้เป็นปริมาณ 64 บิต config.sh จะ
ชุด ขยายขนาด ถึง 8 และ ขยายขนาด สคริปต์จะแบกรับค่าที่ถูกต้องและพิมพ์:
ในเครื่องนี้ ชนิด int คือ 8 ไบต์
ซึ่งถูกต้อง ยินดีด้วย! เราเพิ่งกำหนดค่าเชลล์สคริปต์!!
การผลิต config.h
ไปดูเส้นทางกันได้เลย config.h ผลิตจาก config_h.SH. เรารู้ว่า
วิ่ง กำหนดค่า ผลิต config.sh สคริปต์ (วิธีการทำสิ่งนี้ไม่ได้เคร่งครัด
ที่เกี่ยวข้องที่นี่ แต่สำหรับคนที่อยากรู้อยากเห็น มันเป็นอีกเอกสารแทนภายใน
กำหนดค่า เอง) NS config_h.SH ตัวมันเองถูกสร้างขึ้นโดย เมตาคอนฟิก ในขณะเดียวกัน
กำหนดค่า คือ หากคุณใช้สัญลักษณ์ C อย่างน้อยหนึ่งตัวในแหล่งที่มาของคุณ
มาสุ่มดูกันจ้า config_h.SH file เพื่อดูว่าเกิดอะไรขึ้น:
กรณี $CONFIG ใน
'')
ถ้า test -f config.sh; แล้ว TOP=.;
elif test -f ../config.sh; แล้ว TOP=..;
elif test -f ../../config.sh; แล้วท็อป=..-;
elif test -f ../../../config.sh; แล้วท็อป=..-;
elif test -f ../../../../config.sh; แล้วท็อป=..-;
อื่น
echo "ไม่พบ config.sh"; ทางออก 1
fi
- $TOP/config.sh
;;
ว่า C
กรณี "$ 0" ใน
*/*) cd `expr X$0 : 'X\(.*\)/'` ;;
ว่า C
echo "กำลังแยก config.h (พร้อมการแทนที่ตัวแปร)"
เซด < config.h -e 's!^#undef!/define!' -e 's!^#un-def!#undef!'
/*
* ไฟล์นี้สร้างโดยการรันสคริปต์ config_h.SH ซึ่ง
* รับค่าจาก config.sh ซึ่งโดยทั่วไปผลิตโดย
* วิ่งกำหนดค่า
*
* อย่าลังเลที่จะแก้ไขสิ่งเหล่านี้ตามความจำเป็น หมายเหตุ อย่างไรก็ตาม
* การรัน config.h.SH อีกครั้งจะล้างการเปลี่ยนแปลงที่คุณทำไว้
* สำหรับการเปลี่ยนแปลงอย่างถาวร ให้แก้ไข config.sh และรัน config.h.SH อีกครั้ง
*/
/* เวลาการกำหนดค่า: $cf_time
* กำหนดโดย: $cf_by
* ระบบเป้าหมาย: $myuname
*/
#ifndef _config_h_
#กำหนด _config_h_
/* สำเนาสำเนา:
* สัญลักษณ์นี้ถูกแมปกับ memcpy หากรูทีน bcopy() ไม่ใช่
* มีให้คัดลอกสตริง
*/
/* HAS_BCOPY:
* สัญลักษณ์นี้ถูกกำหนดหากรูทีน bcopy() พร้อมใช้งานสำหรับ
* คัดลอกบล็อกของหน่วยความจำ คุณไม่ควรใช้สัญลักษณ์นี้ภายใต้
* สถานการณ์ปกติและใช้ bcopy() โดยตรงแทนซึ่ง
* จะได้รับการแมปกับ memcpy() หากไม่มี bcopy
*/
#$d_bcopy HAS_BCOPY /**/
#ifndef HAS_BCOPY
#ifdefสำเนา
#un-def bcopy
#เอนดิฟ
#define bcopy(s,d,l) memcpy((d),(s),(l)) /* แมปกับ memcpy */
#เอนดิฟ
/* HAS_DUP2:
* สัญลักษณ์นี้ หากกำหนดไว้ แสดงว่ารูทีน dup2 คือ
* มีให้สำหรับตัวอธิบายไฟล์ที่ซ้ำกัน
*/
#$d_dup2 HAS_DUP2 /**/
/* I_STRING:
* สัญลักษณ์นี้ หากกำหนดไว้ แสดงว่าโปรแกรม C ควร
* รวม (ระบบ USG) แทน (ระบบบีเอสดี).
*/
#$i_string I_STRING /**/
#เอนดิฟ
!GROK!นี่!
ที่ด้านบนของไฟล์ เรารู้จักโครงสร้าง .SH มาตรฐานที่เรามีอยู่แล้ว
ได้ศึกษาอย่างละเอียด ถัดมาการแตกไฟล์เองโดยใช้เอกสารที่นี่กับ
การแทนที่ตัวแปร อย่างไรก็ตาม ที่นี่เราไม่ใช้แบบธรรมดา แมว แต่ a ความกระหายน้ำ แทน เนื่องจาก
เราจำเป็นต้องทำการแก้ไขเพิ่มเติมทันที มาดูกันว่าทำไมในภายหลังจึงลืม
เกี่ยวกับมันในขณะนี้
ตอนนี้เรามาถึงความคิดเห็นชั้นนำแล้ว และไฟล์ถูกแท็กด้วยเวลาการกำหนดค่า the
ระบบเป้าหมาย ฯลฯ ... (ตัวแปรเหล่านั้นมาจากแหล่งที่มา config.sh ไฟล์ได้รับ
ตั้งค่าโดย กำหนดค่า). ส่วนหัวของความคิดเห็นนั้นตามด้วยการป้องกัน '#ifndef' เพื่อป้องกัน
กับการรวมหลาย ๆ ไฟล์นี้ แล้วก็มาถึงหัวใจของไฟล์...
ช่วยให้รู้ว่า $d_* และ $i_* ตัวแปรถูกตั้งค่าเป็น 'กำหนด' หรือ 'ไม่แน่นอน' โดย
กำหนดค่าขึ้นอยู่กับว่ามีฟังก์ชั่นหรือไฟล์รวมอยู่ในระบบหรือ
ไม่. นั่นหมายถึง:
#$d_bcopy HAS_BCOPY /**/
บรรทัดจะถูกขยายเป็นอย่างใดอย่างหนึ่ง:
#กำหนด HAS_BCOPY /**/
หากตัวแปร $d_bcopy ถูกตั้งค่าเป็น 'define' หรือ:
#undef HAS_BCOPY /**/
หาก $d_bcopy ถูกตั้งค่าเป็น 'undef' เนื่องจากไม่มีคุณสมบัติดังกล่าว อย่างไรก็ตาม นั่นไม่ใช่
สิ่งที่เขียนใน config.h ไฟล์เนื่องจาก ความกระหายน้ำ ตัวกรองที่เราได้เห็นแล้ว
ซึ่งจะแปลงร่างที่สองเป็น:
/*#กำหนด HAS_BCOPY /**/
นั่นเป็นแบบฟอร์มที่สะดวกสำหรับการแก้ไขในภายหลังของ config.h เพราะคุณเพียงแค่ต้องลบ
นำ '/*' หากคุณต้องการแทนที่ กำหนดค่าทางเลือกของ ในทำนองเดียวกันคุณสามารถเพิ่มซิงเกิ้ล
'/*' ที่จุดเริ่มต้นของบรรทัด '#define' เพื่อหลีกเลี่ยงการกำหนดสัญลักษณ์เฉพาะ
นี่คือเหตุผลที่คำจำกัดความสัญลักษณ์แต่ละอันได้รับการป้องกันโดย '/**/' ต่อท้ายเพื่อปิดการนำหน้า
ความคิดเห็นที่เปิดโดย '/*' (ความคิดเห็นไม่ได้ซ้อนอยู่ใน C)
ตอนนี้การแปลง '#undef' เป็น '/*#define' เป็นเรื่องที่ดี แต่ถ้าเราต้องการเขียน a จริงๆ
'#undef' เราติดอยู่... เว้นแต่เราจะเขียนเป็น '#un-def' แล้วปล่อยให้ ความกระหายน้ำ แก้ไขให้เป็น '#undef'
ขณะผลิต config.hซึ่งเป็นสิ่งที่ทำจริงที่นี่
การใช้เหตุผลแบบเดียวกันนี้ใช้กับสองบรรทัดนั้น:
#$d_dup2 HAS_DUP2 /**/
#$i_string I_STRING /**/
และสมมติว่า config.sh กำหนด:
d_dup2='กำหนด'
i_string='undef'
เราจะเข้าสู่การผลิต config.h:
#กำหนด HAS_DUP2 /**/
/*#กำหนด I_STRING /**/
ใสเหมือนน้ำไหล? ดี!
ตอนนี้มันควรจะชัดเจนว่าโดยการรวม config.h ในไฟล์ต้นฉบับ C ทั้งหมดของคุณ คุณจะไปที่
รู้อะไร กำหนดค่า ได้เดาในระบบของคุณ โดยการใช้สัญลักษณ์เหล่านั้น คุณคือ
กำลังเขียนโค้ด C ที่กำหนดค่าไว้ตั้งแต่ เมตาคอนฟิก จะรู้ว่าคุณต้องการสัญลักษณ์เหล่านั้นและจะ
สร้างความเหมาะสม config_h.SH ไฟล์รวมถึงรหัสที่จำเป็นทั้งหมดใน กำหนดค่า ไปยัง
คำนวณค่าที่เหมาะสมสำหรับพวกมัน (โดยการกำหนดค่าให้กับตัวแปรเชลล์ที่เกี่ยวข้อง)
เล่น เมตาคอนฟิก
มาโฟกัสกันที่ เมตาคอนฟิก โปรแกรมสักครู่เพื่อทำความเข้าใจวิธีการใช้หน่วยและ
ซอร์สโค้ดของคุณเพื่อสร้างไฟล์การกำหนดค่าที่จำเป็นทั้งหมด ถ้าคุณตั้งใจจะเขียนใหม่
หน่วยคุณควรมีความเข้าใจที่ดีของโครงการทั้งหมด
หากไม่มีไฟล์ MANIFEST.new เมตาคอนฟิก จะพยายามใช้ไฟล์ MANIFEST แทน
เพื่อความสะดวก. ทุกที่ที่เราพูดถึง MANIFEST.new สามารถเข้าใจได้ว่า MANIFEST
หากไม่มีไฟล์ MANIFEST.new อยู่ที่รูทของแพ็คเกจของคุณ
สมมติว่าไฟล์ MANIFEST.new ของคุณได้รับการตั้งค่าอย่างเหมาะสมและแสดงรายการไฟล์ต้นฉบับทั้งหมดที่คุณต้องการ
กำหนดค่าและคุณได้เรียกใช้ บรรจุ ในไดเร็กทอรีต้นทางของคุณเพื่อสร้าง a
.บรรจุุภัณฑ์ file คุณสามารถเรียกใช้ เมตาคอนฟิก และคุณจะได้รับสิ่งต่อไปนี้:
$ เมตาคอนฟิก
กำลังค้นหาหน่วย...
กำลังแยกรายการพึ่งพาจาก 312 หน่วย...
กำลังแยกชื่อไฟล์ (*.[chyl] และ *.SH) จาก MANIFEST.new...
กำลังสร้างไฟล์ที่ต้องการ...
กำลังสแกนไฟล์ .[chyl] เพื่อหาสัญลักษณ์...
กำลังสแกนไฟล์ .SH เพื่อหาสัญลักษณ์...
กำลังคำนวณกราฟการพึ่งพาที่เหมาะสมที่สุด...
กำลังสร้างไฟล์ make ส่วนตัว...
กำลังหาหน่วยที่โหลดได้...
กำลังอัปเดตไฟล์ make...
การกำหนดลำดับที่ถูกต้องสำหรับหน่วย...
กำลังสร้างการกำหนดค่า...
เสร็จสิ้น
เฟสแรกค้นหาไฟล์หน่วยทั้งหมด (ลงท้ายด้วย .U) ในไดเรกทอรีสาธารณะ
ก่อนแล้วในส่วนตัวของคุณ หากคุณคัดลอกไฟล์สาธารณะในไดเร็กทอรี U ส่วนตัวของคุณ
(เช่นไดเร็กทอรีชื่อ U ที่ระดับบนสุดของแพ็คเกจของคุณ) มันจะแทนที่ public
รุ่น เมื่อมีรายการของหน่วยที่มีอยู่ทั้งหมด มันจะแยกวิเคราะห์และแยกทั้งหมด
?MAKE: บรรทัดสำหรับทราบเกี่ยวกับการขึ้นต่อกันและสัญลักษณ์เชลล์ที่รู้จัก นอกจากนี้ยัง
เน้นที่เส้น ?H: เพื่อเรียนรู้เกี่ยวกับสัญลักษณ์ C และสัญลักษณ์เปลือกใดที่จำเป็นต้องเป็น
คำนวณเพื่อให้ได้ค่าที่เหมาะสมสำหรับสัญลักษณ์ C นั้น (ดังนั้นเราจึงมีการพึ่งพาอีกระดับหนึ่ง
ที่นี่)
ถัดไป ชื่อไฟล์ที่เหมาะสมจะถูกแยกจากไฟล์ MANIFEST.new และ a อยาก ไฟล์คือ
สร้าง: ไฟล์นั้นแสดงสัญลักษณ์ C ทั้งหมดและสัญลักษณ์เชลล์ที่จำเป็นสำหรับแพ็คเกจนั้น เรา
ขั้นแรกให้สแกนไฟล์ประเภท C เพื่อหาสัญลักษณ์ C จากนั้นจึงเผยแพร่การพึ่งพาไปยัง
สัญลักษณ์เชลล์ที่เกี่ยวข้อง (รวบรวมจาก ?H: เส้น) ไฟล์ .SH ถัดไปจะถูกสแกนและสุดท้าย
สัญลักษณ์เชลล์ทั้งหมดเป็นที่รู้จัก
Makefile ชั่วคราวถูกสร้างขึ้นและ metaconfig พยายาม ทำ สัญลักษณ์เปลือกทั้งหมดเพื่อดู
คำสั่งใด (อยู่ในรายการที่สอง ?MAKE: บรรทัด) ที่ดำเนินการ และหน่วยใดจึงถูก
จำเป็นจริงๆ หน่วยเสริมที่ไม่จำเป็นจะถูกลบออกและ Makefile ที่สองคือ
สร้างขึ้น คราวนี้เรารู้เกี่ยวกับหน่วยทั้งหมดและคำสั่งซื้อตามลำดับหรือไม่ก็ได้
หน่วยที่ถูกลบออกและค่าดีฟอลต์ที่คำนวณสำหรับสัญลักษณ์เชลล์ NS
กำหนดค่า สามารถสร้างสคริปต์พร้อมกับ config_h.SH. เราเสร็จแล้ว
การประชุม
ต้องปฏิบัติตามข้อตกลงที่เหมาะสมเพื่อให้กระบวนการทั้งหมดมีเสียง มีคดี
แบบแผนสำหรับหน่วยและแบบแผนการตั้งชื่อตัวแปร
ทุกหน่วยควรมีอักษรตัวแรกเป็นตัวพิมพ์เล็ก เว้นแต่จะเป็นหน่วยพิเศษ โดย
พิเศษ เราหมายความว่าพวกเขาไม่ได้กำหนดตัวแปรเชลล์ใหม่ที่สามารถใช้ได้โดย
ผู้ใช้ในไฟล์ .SH ของเขา แต่เป็นหน่วยที่สร้างสคริปต์หรือตัวแปรเชลล์ที่เป็นto
ใช้ภายในโดย กำหนดค่า สคริปต์ ตัวอย่างทั่วไปคือ Init.U ไฟล์ซึ่งก็คือ
การเริ่มต้นตัวแปรหลักหรือ Myread.U ซึ่งผลิต อ่านของฉัน สคริปต์ที่ใช้เกือบ
ทุกที่ใน กำหนดค่า เมื่อมีการถามคำถามกับผู้ใช้
หน่วยที่ไม่เฉพาะเจาะจงจะแบ่งออกเป็นสองกลุ่มที่แตกต่างกัน: หน่วยกำหนดตัวแปร
เกี่ยวข้องกับสัญลักษณ์ C และหน่วยที่กำหนดตัวแปรเชลล์ของตนเอง กลุ่มแรก
ถูกแบ่งเพิ่มเติมในตัวแปรที่เกี่ยวข้องกับการรวมไฟล์ (ชื่อของพวกเขาขึ้นต้นด้วย i_) and
ตัวแปรที่เกี่ยวข้องกับคำจำกัดความอื่น ๆ (ชื่อที่ขึ้นต้นด้วย d_). กลุ่มที่สองมี
ชื่อแทนตัว เช่น ซีซียู กำหนด $ซีซี ตัวแปรเชลล์ที่มีค่าเป็น
คอมไพเลอร์ C ที่จะใช้
หน่วยพิเศษบางครั้งสำรองตัวแปรที่กำหนดไว้ล่วงหน้าบางส่วนและส่งคืน "ผลลัพธ์"
ในตัวแปรอื่น ๆ ที่รู้จักกันดี ตัวอย่างเช่น อ่านของฉัน สคริปต์ที่ผลิตโดย Myread.U
คาดว่าจะได้รับแจ้งใน $rp, คำตอบเริ่มต้นใน $dflt และใส่คำตอบของผู้ใช้ใน $ ตอบ.
สิ่งนี้ไม่มีในคู่มือนี้: คุณต้องไปดูตัวเครื่องเองถึง
ทำความเข้าใจว่าตัวแปรใดถูกใช้และจะใช้หน่วยอย่างไร
การใช้ พื้นที่ อภิธานศัพท์
ไฟล์อภิธานศัพท์ถูกสร้างขึ้นโดยอัตโนมัติโดย ลิปกลอส สคริปต์ซึ่งแยก
ข้อมูลจาก ?S:, ?C: และ ?MAKE: เรียงเส้นและฟอร์แมตใหม่เป็นตัวอักษร
เรียงความอภิธานศัพท์ สิ่งสำคัญคือต้องอ่านอภิธานศัพท์เพื่อทราบเกี่ยวกับสัญลักษณ์ที่คุณเป็น
อนุญาตให้ใช้ อย่างไรก็ตาม อภิธานศัพท์จะไม่บอกคุณถึงวิธีการใช้งาน โดยปกติแล้ว นั่นก็คือ
แล้วแต่คุณ.
วันหนึ่งคุณอาจจะเขียนหน่วยการเรียนรู้ของตัวเองและคุณจะรู้เพียงพอเกี่ยวกับ เมตาคอนฟิก
ได้อย่างรวดเร็วและมีประสิทธิภาพ อย่างไรก็ตาม อย่าลืมบันทึกงานของคุณอย่างถูกต้องใน
เครื่องหมาย ?S: และ ?C: หรือบุคคลอื่นจะไม่สามารถใช้ซ้ำได้ จำเกี่ยวกับ
เวลาที่คุณมีเพียงอภิธานศัพท์และหน้าคู่มือนี้เพื่อเริ่มต้น
สรุป
ตอนนี้คุณก็รู้ เมตาคอนฟิก พื้นฐานคุณควรอ่าน DESCRIPTION ส่วนแล้ว
ข้ามไปที่ อ้างอิง ส่วนที่จะเรียนรู้เกี่ยวกับรายละเอียดเลือดทั้งหมดเช่นได้รับอนุญาต
ไวยากรณ์สำหรับบรรทัดควบคุมหน่วย (บรรทัดที่ขึ้นต้นด้วย '?') หรือคำสั่ง MAKE ที่แตกต่างกัน
คุณได้รับอนุญาตให้ใช้
อ้างอิง
ส่วนนี้จัดทำเอกสารภายในของ เมตาคอนฟิกโดยพื้นฐานแล้ว ไวยากรณ์หน่วย พิเศษ
หน่วยที่คุณควรรู้และไฟล์คำใบ้
General Unit วากยสัมพันธ์
หน่วย metaconfig แบ่งออกเป็นสองส่วนที่แตกต่างกัน ส่วนหัว (บรรทัดเริ่มต้น
ด้วย '?') และส่วนเชลล์ (รหัสที่จะรวมอยู่ใน กำหนดค่า สคริปต์) มันคือ
เป็นไปได้ที่จะเพิ่ม '?X:' ความคิดเห็นที่ใดก็ได้ภายในหน่วย แต่อีก '?' เส้น (ด้วย
ที่เรียกว่า ควบคุม เส้น) มีนโยบายการสั่งซื้อที่เข้มงวด
หากสายควบคุมยาวเกินไป สามารถใช้ความต่อเนื่องได้โดยหนีเส้นสุดท้าย
ขึ้นบรรทัดใหม่ด้วยแบ็กสแลชและดำเนินการต่อในบรรทัดถัดไป (ซึ่งควรเยื้อง
ตามช่องว่างหรือแท็บ)
ต่อไปนี้คือคำอธิบายอย่างเป็นทางการของสายควบคุมแต่ละสาย เว้นแต่จะระบุไว้
มิฉะนั้น ลำดับของการนำเสนอนี้คือลำดับที่จะใช้ภายในหน่วยการเรียนรู้
?อาร์ซีเอส: ฟรี ข้อความ
ใช้สำหรับแสดงความคิดเห็น RCS ที่ด้านบนของหน่วย
?NS: ใด ข้อความ
ความคิดเห็นวัตถุประสงค์ทั่วไป อาจปรากฏที่ใดก็ได้ในหน่วย แต่ต้องปล่อยไว้อย่างยุติธรรม
สำหรับความคิดเห็น RCS โปรดใช้แบบฟอร์มความคิดเห็น ?RCS:
?ทำ:เครื่องหมาย รายการ: เมืองขึ้น รายการ [+ตัวเลือก]
นี่คือบรรทัดการพึ่งพาแรก ครั้งแรก เครื่องหมาย รายการ ควรแสดงรายการสัญลักษณ์ทั้งหมด
สร้างโดยยูนิตนี้ (เช่น ค่าที่คำนวณโดยส่วนเชลล์ของยูนิต)
สัญลักษณ์ควรเว้นวรรค หากสัญลักษณ์ที่กำหนดมีไว้สำหรับใช้ภายในเท่านั้นและ
ไม่ควรปรากฏในไฟล์ที่สร้างขึ้น config.sh ไฟล์แล้วควรนำหน้าด้วย a
'+' (เพื่อไม่ให้สับสนกับการพึ่งพาที่เป็นทางเลือกที่กำหนดไว้หลังจากนี้) ที่สอง
ส่วนหนึ่งของรายการ (หลังตรงกลาง ':') เป็นการพึ่งพาหน่วย ควรแสดงรายการทั้งหมด
หน่วยพิเศษที่จำเป็น เช่นเดียวกับสัญลักษณ์ทั้งหมดที่ใช้โดยเชลล์
การดำเนินการ หากสัญลักษณ์ถูก nedded แต่ค่าคอนฟิกูเรชันไม่สำคัญ มัน
สามารถนำหน้าด้วย '+' ซึ่งในกรณีนี้เรียกว่าการพึ่งพาแบบมีเงื่อนไข: its
หน่วยที่เกี่ยวข้องจะถูกโหลดหากและเฉพาะในกรณีที่สัญลักษณ์นั้นเป็นอย่างอื่นจริงๆ
ต้องการ; มิฉะนั้นจะใช้ค่าเริ่มต้น
?ทำ:แถบ คำสั่ง
สามารถมีบรรทัดคำสั่งได้ตั้งแต่หนึ่งบรรทัดขึ้นไปตามบรรทัดการพึ่งพาเริ่มต้น เหล่านั้น
คำสั่งจะถูกดำเนินการเมื่อต้องการโหลดยูนิตลงใน กำหนดค่า. ดู
ย่อหน้าเกี่ยวกับ make command สำหรับข้อมูลเพิ่มเติม โปรดทราบว่าชั้นนำ แถบ
ต้องระบุอักขระก่อน คำสั่ง.
?ย:แบบ
ประกาศคำสั่งเค้าโครงสำหรับหน่วยนี้ คำสั่งนั้นอาจเป็นหนึ่งในสตริง
ด้านบน, ผิดนัด or ก้น (กรณีไม่สำคัญ สไตล์แนะนำคือสะกดให้
ตัวพิมพ์ใหญ่) หากละเว้น ผิดนัด สันนิษฐาน
คำสั่งนี้จำเป็นเฉพาะในกรณีที่คุณต้องการบังคับหน่วยที่ด้านบนหรือด้านล่าง
ของที่สร้างขึ้น กำหนดค่า สคริปต์เนื่องจากการพึ่งพาหน่วยอนุญาต สำคัญ
คำถามอาจถูกบังคับในตอนเริ่มต้น ภายในคลาสเลย์เอาต์เดียวกัน หน่วย
เรียงตามตัวอักษรโดยมีกรณีพิเศษสองกรณีสำหรับหน่วย d_* และ i_* บังคับ
ตามลำดับที่ด้านบนและด้านล่างของชั้นเรียน (แต่สิ่งเหล่านี้ควรเป็นของ
คลาสเริ่มต้น)
คุณบังคับที่ด้านบนสุดของยูนิตที่มีการขึ้นต่อกันของยูนิตอื่นๆ ทั้งหมดเพื่อ
ก่อนหน้านั้นคุณไม่มีอะไรน่าสนใจ ดังนั้น คำสั่งนั้นจึงควร
ใช้เพื่อเพิ่มลำดับความสำคัญของหน่วยโต้ตอบบางหน่วยที่ไม่ขึ้นอยู่กับหลาย ๆ
สัญลักษณ์อื่นๆ ที่ผู้ใช้มองเห็นได้ เช่น คำถามเกี่ยวกับเส้นทาง
?NS:สัญลักษณ์_ชื่อ [(ล้าสมัย เครื่องหมาย รายการ-
แนะนำสัญลักษณ์เชลล์ บรรทัดแรกนี้ตั้งชื่อสัญลักษณ์ ตามด้วย a . หรือไม่ก็ได้
รายการอยู่ระหว่างวงเล็บและให้เทียบเท่าที่ล้าสมัย ที่ล้าสมัย
สัญลักษณ์จะถูกทำการรีแมปใหม่ สัญลักษณ์_ชื่อ ถ้า -o มีตัวเลือกให้
เมตาคอนฟิก.
?NS:ใด ข้อความ, for อภิธานศัพท์
โดยทั่วไปความคิดเห็นที่อธิบายสัญลักษณ์เชลล์ซึ่งจะถูกแยกโดย ลิปกลอส
ลงในไฟล์อภิธานศัพท์
?NS:. ปิดความคิดเห็นสัญลักษณ์เชลล์
?ค:สัญลักษณ์_ชื่อ [~ นามแฝง-ล้าสมัย เครื่องหมาย รายการ-
แนะนำสัญลักษณ์ C ใหม่ NS นามแฝง ชื่อคือชื่อที่สัญลักษณ์ C จะ
ถูกควบคุม กล่าวคือ ถ้า นามแฝง ต้องการสัญลักษณ์ จากนั้นสัญลักษณ์ C จะถูกเขียน
ใน config_h.SH ไฟล์. โดยปกตินามแฝงจะเป็นเพียง '%<' (ย่อมาจากชื่อหน่วย)
และยังมี ?W: line mapping a C symbol to the นามแฝง. รวมถึงส่วนที่เกี่ยวข้อง
ของบรรทัด ?H: ได้รับการคุ้มครองอย่างชัดเจนโดยเงื่อนไข '?%<' ดูสัญลักษณ์
นามแฝงย่อหน้าสำหรับรายละเอียดเพิ่มเติม ส่วนที่เหลือของบรรทัดเป็นตัวเลือก
ล้าสมัย เครื่องหมาย รายการซึ่งแสดงรายการเทียบเท่าเก่าสำหรับใหม่ สัญลักษณ์_ชื่อ.
?ค:ใด ข้อความ, for อภิธานศัพท์ และ config_h.SH
โดยทั่วไปความคิดเห็นที่อธิบายสัญลักษณ์ C ซึ่งจะถูกแยกโดย ลิปกลอส
ลงในไฟล์อภิธานศัพท์และโดย เมตาคอนฟิก เข้าไปใน config_h.SH ไฟล์ถ้าสัญลักษณ์คือ
ต้องการ (หรือหากต้องการนามแฝงเมื่อใช้นามแฝงสัญลักษณ์)
?ค:. ปิดความคิดเห็นสัญลักษณ์ C
?ชม:?เครื่องหมาย:config_h.SH สิ่งที่
นี่คือคำขอรวมทั่วไปใน config_h.SH. บรรทัดนี้เขียนเฉพาะเมื่อ
ยาม เครื่องหมาย เป็นที่ต้องการจริงๆ แบบฟอร์มทั่วไปนี้จำเป็นเมื่อสัญลักษณ์ C
มีการใช้นามแฝง มิฉะนั้น หากคุณใช้รูปแบบ "มาตรฐาน" อื่น
การป้องกันจะทำโดยอัตโนมัติโดย เมตาคอนฟิก ตัวเอง
?ชม:#$d_var VAR "$var"
กำหนดเงื่อนไข VAR สัญลักษณ์ C เป็น $var เมื่อถูกตั้งค่าเป็น 'กำหนด'. แปลว่า a
'?VAR:' สภาพการคุ้มกันและ เมตาคอนฟิก ลิงค์อัตโนมัติ VAR สู่เปลือกสองของมัน
การพึ่งพาตัวแปร (เช่น both $d_var และ $var จะถูกตั้งค่าสถานะเป็น อยาก if VAR is
ใช้ในแหล่ง C)
?H:#กำหนด VAR [ไม่จำเป็น ข้อความ]
กำหนด .เสมอ VAR สัญลักษณ์ C เป็นค่าบางอย่าง หมายถึง '?VAR:' สภาพคุ้มกัน.
มีการพึ่งพาเชลล์อัตโนมัติกับตัวยูนิตเอง
?H:#กำหนด วีเออาร์(x,y,z) $var
กำหนดมาโครเสมอ VAR ให้เป็นค่าของ $var ตัวแปร. มันขึ้นอยู่กับ
หน่วยเพื่อให้แน่ใจว่า $var มีค่าที่สมเหตุสมผล การพึ่งพาอัตโนมัติระหว่าง C
แมโคร VAR และตัวแปรเชลล์ถูกสร้างขึ้นและทั้งบรรทัดได้รับการปกป้องโดย
โดยนัย '?VAR:'.
?ชม:#$d_var VAR
กำหนดตามเงื่อนไข VAR if $d_var ถูกตั้งค่าเป็น 'กำหนด'. หมายถึง '?VAR:'เฝ้า
สภาพ. การสร้างการพึ่งพาเชลล์อัตโนมัติจะถูกสร้างขึ้นต่อ $d_war.
?H:#กำหนด VAR "$var"
กำหนดค่าการกำหนดค่าให้กับ VAR สัญลักษณ์ซี หมายถึง '?VAR:' สภาพน่าติดตาม.
การสร้างการพึ่งพาเชลล์อัตโนมัติเพื่อเชื่อมโยง VAR และ $var.
?ชม:. ปิด config_h.SH คำขอรวม
?NS:C เครื่องหมาย: C การอ้างอิง
แนะนำคำจำกัดความมายากลเกี่ยวกับสัญลักษณ์ C สำหรับ confmagic.hและกำหนด
สัญลักษณ์พิทักษ์ที่เหลือ ?M: คำจำกัดความ บรรทัดนี้หมายถึงอย่างเงียบ ๆ
'?ว:%<:C เครื่องหมาย' คือเครื่องจะโหลดเข้า Configure ถ้าสัญลักษณ์ C ปรากฏขึ้น
ภายในแหล่ง C ไม่ว่าจะใช้เวทมนตร์หรือไม่ก็ตาม การพึ่งพา C ถูกเปิดใช้งาน
เมื่อใช้เวทย์มนตร์เพื่อบังคับคำจำกัดความใน config_h.SH. อย่างไรก็ตามหาก
เวทมนตร์คือ ไม่ ใช้แล้ว แต่สัญลักษณ์ C ปรากฏในแหล่งที่มาโดยไม่จำเป็นต้องใช้ C
การพึ่งพา คุณจะได้รับคำเตือนทุกครั้งที่สร้างไฟล์ Wanted เนื่องจากอาจเป็น
ปัญหาการพกพา (และเนื่องจากตัวเครื่องถูกโหลดเข้า .อย่างไม่มีเงื่อนไข
กำหนดค่าทุกครั้งที่ใช้สัญลักษณ์ C โดยไม่คำนึงถึงบรรทัดอื่น ?C: จาก
หน่วย).
?NS:ซีพี defs
กำหนด magic cpp mapping ที่จะนำมาใช้ใน confmagic.h เมื่อใดก็ตามที่เกี่ยวข้อง
มีการใช้สัญลักษณ์ มีนัย '?ซิม' เฝ้าที่ไหน ซิม เป็นชื่อสัญลักษณ์
กำหนดโดยเส้นนำ ?M:
?NS:. ปิด confmagic.h คำขอรวม
?ว:เปลือก เครื่องหมาย รายการ:C เครื่องหมาย รายการ
ผูกดวงชะตาของสัญลักษณ์เปลือกหอยกับสัญลักษณ์ C: หากมี C
ต้องการสัญลักษณ์ที่แสดงไว้ จากนั้นสัญลักษณ์เปลือกทั้งหมดจะถูกทำเครื่องหมายว่าต้องการ มีประโยชน์ต่อ
บังคับให้รวมหน่วย (รายการสัญลักษณ์เชลล์ตั้งค่าเป็น '%<') เมื่อมี C . บางตัว
ตรวจพบสัญลักษณ์ รายการสัญลักษณ์เปลือกหอยอาจเว้นว่างไว้เพื่อรับประโยชน์จากด้านข้าง
ผลกระทบของตำแหน่งสัญลักษณ์ C ภายในตัวประมวลผลล่วงหน้า (สัญลักษณ์เป็น กำหนด
สำหรับพรีโปรเซสเซอร์นั้นหากอยู่ในแหล่งที่มา) เพื่อค้นหาลวดลายที่มีช่องว่าง
ในนั้นคุณต้องอ้างอิงสัญลักษณ์ C ภายในเครื่องหมายคำพูดอย่างง่ายเช่นใน 'struct
เขตเวลา'.
?วี:อ่านอย่างเดียว สัญลักษณ์:อ่านเขียน สัญลักษณ์
มันคือ โลหะ คำใบ้และควรใช้เฉพาะในหน่วยพิเศษที่ส่งออกบางเชลล์
ตัวแปร ตัวแปรที่อยู่หน้า ':' ตรงกลางจะถูกส่งออกแบบอ่านอย่างเดียว (เปลี่ยนพวกมัน
จะออกคำเตือน) ในขณะที่สัญลักษณ์อื่น ๆ สามารถอ่านและเปลี่ยนแปลงได้อย่างอิสระ
?NS:ไฟล์ ที่สร้างขึ้น
บรรทัดนี้มีวัตถุประสงค์สองประการ: มันคือ a โลหะ คำใบ้และยังเป็นตัวยึดสำหรับ
อนาคต เจเมค ใช้. จะต้องแสดงรายการไฟล์สามประเภท: ไฟล์ชั่วคราวคือ
สร้างขึ้นสำหรับการทดสอบ UU ส่วนตัวที่สร้างขึ้นในไดเร็กทอรี UU สำหรับภายหลัง
การตรวจและคนทั่วไปที่เหลืออยู่ในไดเร็กทอรีรากของแพ็คเกจ ชั่วคราว
ไฟล์ต้องมีเครื่องหมาย '!' นำหน้า ตัวอักษร (หมายถึง "ไม่! พวกเขาไม่ได้ใช้ซ้ำ
ภายหลัง!") ไฟล์ UU ส่วนตัวควรนำหน้าด้วย './' (ความหมาย: หากต้องการใช้ ให้พูด
./ไฟล์ไม่เพียง ไฟล์) และชื่อสาธารณะควรตั้งชื่อตามที่เป็นอยู่
?NS:เปลือก ชั่วคราว
อื่น โลหะ คำใบ้. บรรทัดนี้แสดงรายการตัวแปรเชลล์ทั้งหมดที่ใช้ชั่วคราว
ภายในส่วนเปลือกของหน่วยนี้
?NS:เครื่องหมาย='ความคุ้มค่า'
ค่าเริ่มต้นสำหรับสัญลักษณ์ที่ใช้เป็นการขึ้นต่อกันแบบมีเงื่อนไข ถ้าไม่มี ?D: บรรทัด is
พบแล้วจึงใช้ค่า null แทน NS โลหะ โปรแกรมจะเตือนคุณหาก a
สัญลักษณ์ถูกใช้อย่างน้อยหนึ่งครั้งเป็นการพึ่งพาแบบมีเงื่อนไขและไม่มีค่าที่เหมาะสม
?D: การเริ่มต้น เป็นการดีที่จะเพิ่มบรรทัดเหล่านั้นแม้จะเป็นค่าว่าง
การเริ่มต้นเนื่องจากเน้นที่ลักษณะทางเลือกของสัญลักษณ์
?โอ:ใด ข่าวสาร เธอ ต้องการ
คำสั่งนี้บ่งชี้ว่าหน่วยนี้ล้าสมัยโดยรวม เมื่อใดก็ตามที่ใช้ใดๆ
ของสัญลักษณ์ถูกสร้างขึ้น (หรือการใช้ทางอ้อมผ่านการพึ่งพา) ข้อความจะถูกส่งออกบน
หน้าจอ (บน stderr) คุณสามารถใส่มากกว่าหนึ่งหรือมากกว่าหนึ่งบรรทัด ซึ่งในกรณีนี้แต่ละบรรทัดจะ
จะพิมพ์ตามลำดับ
?ผ้าสำลี:โลหะ คำแนะนำ
ดู โลหะ หน้าคู่มือสำหรับคำอธิบายของคำใบ้ที่ชัดเจนที่สามารถ
มือสอง
?ในนั้น:การเขียนอักษรย่อ รหัส
รหัสเริ่มต้นที่ระบุโดยบรรทัดนี้จะถูกโหลดที่ด้านบนของ
กำหนดค่า สคริปต์ให้หน่วยที่จำเป็น
C สัญลักษณ์ นามแฝง
บางครั้งก็พึ่งไม่ได้ เมตาคอนฟิกการเลือกเริ่มต้นของตัวเองสำหรับ config_h.SH
ความคิดเห็นและคำจำกัดความสัญลักษณ์ C นั่นคือสิ่งที่นามแฝงเข้ามาเล่น เพราะมันค่อนข้าง
อธิบายยาก เราจะศึกษาตัวอย่างเพื่อทำความเข้าใจกลไกที่อยู่เบื้องหลัง
หน่วย d_const.U พยายามตรวจสอบว่าคอมไพเลอร์ C ของคุณรู้เรื่อง const
คำสำคัญ. หากไม่ใช่ เราต้องการทำการแมปคีย์เวิร์ดนั้นใหม่กับสตริงว่าง เพื่อให้
โปรแกรมคอมไพล์. ยิ่งกว่านั้น เราต้องการเรียกใช้การทดสอบโดยอัตโนมัติเมื่อ const word
ถูกนำมาใช้.
นี่คือส่วนที่เกี่ยวข้องของหน่วย d_const.U:
?ทำ:d_const: cat cc ccflags Setvar
?MAKE: - เลือกเพิ่ม $@ %
?ส:d_const:
?S: ตัวแปรนี้กำหนดสัญลักษณ์ HASCONST ตามเงื่อนไข ซึ่ง
?S: หมายถึงโปรแกรม C ที่คอมไพเลอร์ C นี้รู้เกี่ยวกับ
?S: ประเภท const.
?NS:.
?C:HASCONST ~ %<:
?C: หากกำหนดสัญลักษณ์นี้แสดงว่าคอมไพเลอร์ C รู้เกี่ยวกับ
?C: ประเภท const ไม่จำเป็นต้องทดสอบสัญลักษณ์นั้นจริง ๆ
?C: ภายในโปรแกรมของคุณ การใช้คำสำคัญ "const" เพียงอย่างเดียว will
?C: เรียกการทดสอบที่จำเป็น
?ค:.
?H:?%<:#$d_const HASCONST /**/
?H:?%<:#ifndef HASCONST
?H:?%<:#define const
?H:?%<:#endif
?ชม:.
?W:%<:const
?LINT:ตั้งค่า d_const
?LINT:const ที่รู้จัก
: ตรวจสอบคำหลัก const
เสียงสะท้อน " "
echo 'กำลังตรวจสอบว่าคอมไพเลอร์ C ของคุณรู้เรื่อง "const"...' >&4
/ถังขยะ/แมว >const.c <<'EOCP'
() หลัก
{
ถ่าน const *foo;
}
ศอ.บต
ถ้า $cc -c $ccflags const.c >/dev/null 2>&1 ; แล้ว
val="$define"
echo "ใช่ครับ"
อื่น
val="$undef"
ก้อง "ไม่มันไม่ได้"
fi
ตั้งค่า d_const
ประเมิน $setvar
อันดับแรก เราสังเกตเห็นการใช้เส้น ?W: ซึ่งโดยทั่วไปจะระบุว่า: "หน่วยนี้เป็นที่ต้องการเมื่อ
const คีย์เวิร์ดถูกใช้ในไฟล์ C". เพื่อที่จะทำการแมปใหม่แบบมีเงื่อนไข const เป็นโมฆะ
สตริงใน config.h, ฉันเลือกที่จะกำหนดแบบมีเงื่อนไข ฮัสคอนสท์ ผ่านทาง $d_const.
อย่างไรก็ตาม สิ่งนี้ทำให้เกิดปัญหาเพราะว่า ฮัสคอนสท์ สัญลักษณ์จะไม่ถูกใช้ใน
แหล่งที่มาเท่านั้น const โทเค็นคือ และ ?H: การกำหนดเส้น ฮัสคอนสท์ เป็นโดยปริยาย
ปกป้องโดย '?HASCONST' ดังนั้น เราต้องเพิ่มข้อจำกัดที่ชัดเจน '?%<' เพื่อบอก
เมตาคอนฟิก ที่ควรรวมบรรทัดเหล่านั้นใน config_h.SH เมื่อใดก็ตามที่สัญลักษณ์ '%<'
ได้รับที่ต้องการ (%< หมายถึงชื่อหน่วยที่นี่ d_const).
เกือบจะสมบูรณ์แบบแล้วเพราะว่า ?W: บรรทัดจะต้องการ d_const เมื่อไรก็ตาม const ใช้แล้ว
?H: บรรทัดจะรวมอยู่ใน config_h.SH ไฟล์. อย่างไรก็ตาม ความคิดเห็นนำ (?C:
เส้น) แนบมากับ ฮัสคอนสท์ ตัวมันเองยังได้รับการปกป้องโดย ฮัสคอนสท์, กล่าวคือมีนัย
'?HASCONST' ข้อจำกัด จึงมีความจำเป็น นามแฝง ฮัสคอนสท์ สัญลักษณ์ '%<'
ส่วนที่เหลือของหน่วย (ส่วนเปลือก) ตรงไปตรงมาจริงๆ มันง่าย
พยายามรวบรวมโปรแกรม C ตัวอย่างโดยใช้ const คำสำคัญ. ถ้าทำได้ก็จะ
กำหนด $d_const เมื่อ $setvar fonction (กำหนดโดย เซทวาร์.ยู หน่วย). ดูย่อหน้า
เกี่ยวกับหน่วยพิเศษเพื่อดูรายละเอียดเพิ่มเติม
ทำ คำสั่ง
บนบรรทัดรับคำสั่ง ?MAKE: คุณอาจเขียนคำสั่งเชลล์เพื่อดำเนินการตามที่เป็นหรือ a
พิเศษ - เลือก คำสั่งที่ติดกับดัก เมตาคอนฟิก และแยกวิเคราะห์เพื่อดูว่าควรเป็นอย่างไร
เสร็จแล้ว. เครื่องหมาย '-' ชั้นนำมีไว้เพื่อป้องกัน ทำ จากความล้มเหลวเมื่อคำสั่งส่งคืน
สถานะที่ไม่ใช่ศูนย์ -- ไม่จำเป็นจริงๆ เนื่องจากเราใช้ 'ทำ -n' เพื่อแก้ไข
การพึ่งพา แต่ฉันแนะนำให้คุณเก็บไว้ในกรณีที่จำเป็นในเวอร์ชันต่อ ๆ ไป
ไวยากรณ์ของ เลือก คำสั่งคือ:
- เลือก cmd $@ target_file
ที่ไหน $@ เป็นมาโครมาตรฐานภายใน Makefiles แทนเป้าหมายปัจจุบัน (ชื่อ
ของยูนิตที่กำลังสร้าง โดยถอดส่วนขยาย .U สุดท้ายออก) NS cmd ส่วนหนึ่งคือ
ที่เกิดขึ้นจริง เมตาคอนฟิก คำสั่งให้เรียกใช้และ target_file เป็นอีกพารามิเตอร์หนึ่งซึ่ง
การตีความขึ้นอยู่กับ cmd ตัวเอง. นอกจากนี้ยังมีส่วนขยาย .U สุดท้ายที่ถูกถอดออกและ
โดยปกติหมายถึงไฟล์หน่วยเว้นแต่จะขึ้นต้นด้วย './' ซึ่งในกรณีนี้จะอ้างอิงหนึ่ง
ของ เมตาคอนฟิก ควบคุมไฟล์ใน '.มท ไดเรกทอรี
คำสั่งที่ใช้ได้คือ:
เพิ่ม เพิ่ม target_file ไปยัง กำหนดค่า.
เพิ่ม Config_sh
เติมในส่วนนั้นของ กำหนดค่า ผลิต config.sh ไฟล์. ใช้แล้วเท่านั้น
มีการเพิ่มตัวแปร ตัวแปรตามเงื่อนไข (จากการพึ่งพาตามเงื่อนไข) คือ
ข้ามไป
add.Null เพิ่มส่วนที่เริ่มต้นตัวแปรเชลล์ทั้งหมดที่ใช้กับสตริงว่าง
c_h_weed ผลิต config_h.SH ไฟล์. พิมพ์เฉพาะบรรทัดที่จำเป็นเท่านั้น
cm_h_weed ผลิต confmagic.h ไฟล์. พิมพ์เฉพาะบรรทัดที่จำเป็นเท่านั้น นี้
คำสั่งจะเปิดใช้งานก็ต่อเมื่อคำสั่ง -M ให้สวิตช์หรือเมื่อ a confmagic.h ไฟล์
มีอยู่แล้ว.
ปิด Config_sh
เพิ่มสัญลักษณ์ 'EOT' สุดท้ายในบรรทัดด้วยตัวเองเพื่อสิ้นสุดเอกสารที่นี่
สร้างการผลิต config.sh ไฟล์
นำหน้าเนื้อหาของเป้าหมายไปที่ target_file ถ้าไฟล์นั้นไม่ว่างเปล่า
วัชพืช เพิ่มหน่วยไปที่ กำหนดค่า เหมือน เพิ่ม คำสั่ง แต่ทำการทดสอบเพิ่มเติมบางอย่าง
เพื่อลบ '?เครื่องหมาย' และ '%เครื่องหมาย' บรรทัดจาก target_file ถ้าสัญลักษณ์
ไม่เป็นที่ต้องการหรือต้องการตามเงื่อนไข แบบฟอร์ม '%' ใช้เป็นการภายในโดย .เท่านั้น
เมตาคอนฟิก ในขณะที่สร้างไฟล์ .U ของตัวเองใน '.มท' ไดเร็กทอรี.
เช็ดเหมือน เพิ่ม จริงๆ แต่ทำการแทนที่มาโครเพิ่มเติม NS
มาโครที่มีอยู่มีอธิบายไว้ใน เดินสาย แมโคร ย่อหน้า
ในฐานะที่เป็นบันทึกด้าน เมตาคอนฟิก สร้าง -เงื่อนไข คำสั่งภายในเพื่อจัดการกับเงื่อนไข
การพึ่งพา คุณไม่ควรใช้ด้วยตัวเอง แต่คุณจะเห็นได้หากสแกน
สร้าง Makefile ใน .มท ไดเรกทอรี
เดินสาย แมโคร
มาโครต่อไปนี้ได้รับการยอมรับโดย เช็ด คำสั่งและแทนที่ก่อนรวมใน
กำหนดค่า:
หมายเลขการแก้ไขพื้นฐานของแพ็คเกจ ได้มาจาก .บรรจุุภัณฑ์.
วันที่ปัจจุบัน.
ที่อยู่อีเมลของผู้ดูแลแพ็คเกจนี้ ซึ่งได้มาจาก your
.บรรจุุภัณฑ์.
ชื่อของแพ็คเกจตามมาจาก your .บรรจุุภัณฑ์ ไฟล์
ระดับแพทช์ของ เมตาคอนฟิก โปรแกรม (เลิกใช้เพื่อสนับสนุน ).
ระดับการแก้ไข SVN ของ เมตาคอนฟิก โครงการ
หมายเลขเวอร์ชันของ เมตาคอนฟิก โครงการ
มาโครเหล่านี้ส่วนใหญ่ใช้เพื่อระบุ เมตาคอนฟิก รุ่นที่สร้าง a
ในสิ่งที่สนใจ กำหนดค่า สคริปต์และแพ็คเกจที่ทำเสร็จแล้ว ที่อยู่อีเมลของ
ผู้ดูแลเดินสายในคำแนะนำชั้นนำที่ กำหนดค่า พิมพ์เมื่อเริ่มต้น
เมื่อเร็ว ๆ นี้ เมตาคอนฟิก เวอร์ชันเข้าใจไวยากรณ์ทั่วไปของแบบฟอร์มมากขึ้น:
<$ตัวแปร>
ซึ่งจะถูกแทนที่ในเวลา Configure-generation ด้วยค่าของ ตัวแปร นำมาจากคุณ
.บรรจุุภัณฑ์ ไฟล์. ในที่สุด รูปแบบมาโครแบบเดินสายแบบเก่าจะหายไปและ <$baserev>
จะเข้ามาแทนที่ ในหน่วยที่จัดมาให้ทั้งหมด
พิเศษ หน่วย
หน่วยพิเศษต่อไปนี้ใช้เพื่อแยกตัวประกอบรหัสและให้ระดับที่สูงขึ้น
ฟังก์ชันการทำงาน พวกเขาสร้างเชลล์สคริปต์ที่สามารถแหล่งที่มาหรือเชลล์
ตัวแปรที่สามารถ ประเมินเอ็ด การส่งผ่านพารามิเตอร์ทำได้โดยใช้ตัวแปรที่ทราบดีเช่นกัน
ระบุชื่อหรือไม่ระบุชื่อ เช่น $1, $2, ฯลฯ... (ซึ่งสามารถตั้งค่าได้ง่ายๆ ผ่าน shell ชุด
โอเปอเรเตอร์) เมื่อไหร่ กำหนดค่า ดำเนินการ มันสร้างและเข้าสู่ a UU ไดเร็กทอรี ดังนั้น every
สคริปต์ที่ผลิตอยู่ในนั้นและไม่รบกวนไฟล์จากแพ็คเกจของคุณ
ต่อไปนี้คือหน่วยพิเศษที่คุณควรรู้และวิธีใช้งาน
Cppsym.U
หน่วยนี้สร้างเชลล์สคริปต์ที่เรียกว่า ซีพีซิมซึ่งสามารถใช้เพื่อกำหนด
ไม่ว่าสัญลักษณ์ใดในรายการถูกกำหนดโดยตัวประมวลผลล่วงหน้า C หรือคอมไพเลอร์ C ที่คุณมี
ระบุไว้ สามารถกำหนดสถานะของสัญลักษณ์ใด ๆ แม้ว่าสัญลักษณ์ใน
(รายการแอตทริบิวต์) จะกำหนดได้ง่ายขึ้น
ซีซิม.ยู
สิ่งนี้ตั้งค่าตัวแปรเชลล์ $csym ใช้ภายในโดย กำหนดค่า เพื่อตรวจสอบว่า a
กำหนดให้สัญลักษณ์ C ถูกกำหนดหรือไม่ การใช้งานทั่วไปคือ:
ตั้งค่าสัญลักษณ์ผลลัพธ์ [-fva] [ก่อนหน้า]
ประเมิน $csym
ที่จะตั้ง ผล ตัวแปรเป็น 'จริง' หากฟังก์ชัน [-f], ตัวแปร [-v] หรือ
อาร์เรย์ [-a] ถูกกำหนด 'เท็จ' มิฉะนั้น หากมีการให้ค่าก่อนหน้าและ -r
สวิตช์ถูกจัดเตรียมให้กับ กำหนดค่า (โปรดดู กำหนดค่า Options วรรค) แล้วนั่น
ค่าจะถูกใช้ซ้ำโดยไม่ต้องตั้งคำถาม
วิธีคำนวณนี้ขึ้นอยู่กับคำตอบที่ผู้ใช้ให้กับคำถาม
กำหนดค่า จะถามถึงว่าควรปฏิบัติ . หรือไม่ nm สกัดหรือไม่ ถ้า
ทำการสกัดหน่วยเพียงแค่ดูผ่านรายการสัญลักษณ์มิฉะนั้น
มันทำการทดสอบคอมไพล์ลิงค์ เว้นแต่ -r ให้นำการคำนวณที่คำนวณไว้ก่อนหน้านี้มาใช้ซ้ำ
คุณค่าธรรมชาติ...
เอ็น.ยู
โดยการคัดลอกยูนิตนี้ไปยังห้องส่วนตัวของคุณ U ไดเร็กทอรีและการพึ่งพาต่อท้ายบน
?MAKE: ไลน์ คุณสามารถบังคับให้โหลดยูนิตที่กำหนดเข้าสู่ กำหนดค่า แม้ว่าจะไม่ใช่
ต้องการอย่างอื่น บางหน่วยบังคับเข้าได้เท่านั้น กำหนดค่า ทางนั้น.
Filex.U
หน่วยนี้สร้างเชลล์สคริปต์ fileexp ซึ่งจะขยายชื่อไฟล์ที่ขึ้นต้นด้วย
ตัวหนอน การใช้งานทั่วไปคือ:
exp_name=`./filex $name`
เพื่อกำหนดชื่อไฟล์ที่ขยายใน exp_name.
Findhdr.U
หน่วยนี้ผลิต a ค้นหา สคริปต์ที่ใช้ค้นหาไฟล์ส่วนหัวใน
$usrinc หรือสถานที่แปลก ๆ อื่น ๆ ที่ใช้ความสามารถ cpp สคริปต์จะได้รับ
รวมชื่อฐานไฟล์เช่น 'stdio.h' หรือ 'sys/file.h' และส่งคืนเส้นทางแบบเต็มของ
ไฟล์ inlcude และสถานะศูนย์หากพบ หรือสตริงว่างและสถานะที่ไม่ใช่ศูนย์
หากไม่พบไฟล์
Getfile.U
หน่วยนี้สร้างรหัสเชลล์เล็กน้อยที่ต้องจัดหาเพื่อรับไฟล์
ระบุชื่อและตรวจสุขภาพจิต หรือจะทำการขยาย ~name
ในการใช้เครื่องนี้ $rp และ $dflt ต้องถือคำถามและคำตอบเริ่มต้นซึ่ง
จะถูกส่งต่อไปยัง อ่านของฉัน สคริปท์ (ดูตอนต่อไป Myread.U) $fn
ตัวแปรควบคุมการทำงานและผลลัพธ์จะถูกส่งกลับเป็น $ ตอบ.
หากต้องการค้นหาไฟล์หรือไดเร็กทอรี ให้ใส่ 'f' หรือ 'd' ใน ฉ~/. หาก '~' ปรากฏขึ้น แสดงว่า ~name
อนุญาตให้ใช้แทนกันได้ หาก '/' ปรากฏขึ้น จะยอมรับเฉพาะชื่อพาธสัมบูรณ์เท่านั้นและ
~การแทนที่ชื่อจะถูกขยายก่อนจะส่งคืนเสมอ หากระบุ '+'
การตรวจสอบการดำรงอยู่จะถูกข้ามไป หาก 'n' ปรากฏขึ้นภายใน $fnจากนั้นผู้ใช้จะได้รับอนุญาตให้
ตอบ 'ไม่มี'
โดยปกติ เว้นแต่คุณจะขอการพกพา ~name การแทนที่จะเกิดขึ้นเมื่อมีการร้องขอ
อย่างไรก็ตาม มีบางครั้งที่คุณต้องการเลี่ยงการพกพาและบังคับให้
การแทน. คุณสามารถใช้ตัวอักษร 'e' (ขยาย) เพื่อดำเนินการดังกล่าวได้
หากใช้ประเภท 'l' (ระบุตำแหน่ง) พิเศษ แสดงว่า $fn ตัวแปรต้องลงท้ายด้วย ':',
ตามด้วยชื่อฐานของไฟล์ หากคำตอบคือไดเร็กทอรี ชื่อฐานของไฟล์จะเป็น
ต่อท้ายก่อนการทดสอบการมีอยู่ของไฟล์ สิ่งนี้มีประโยชน์ในคำถามแบบค้นหาตำแหน่ง
อย่างนี้:
dflt='~news/lib'
: ไม่จำเป็นต้องระบุ 'd' หรือ 'f' เมื่อใช้ 'l'
fn='l~:ใช้งานอยู่'
rp='ไฟล์ที่ใช้งานอยู่อยู่ที่ไหน'
- ./getfile
ใช้งานอยู่="$ans"
นอกจากนี้ อาจใช้อักษร 'p' (เส้นทาง) ร่วมกับ 'l' เพื่อบอก
รับไฟล์ ว่าคำตอบที่ไม่มี '/' อยู่ในนั้นควรเป็นที่ยอมรับ สมมติว่ามันจะ
อยู่ใน PATH ของทุกคนในเวลาที่ต้องการค่านี้
มีประโยชน์อีกอย่างคือความเป็นไปได้ในการระบุรายการคำตอบที่ควรยอมรับ
คำต่อคำโดยผ่านการตรวจสอบทั้งหมด รายการนี้ต้องอยู่ในวงเล็บและรายการ
ต้องคั่นด้วยเครื่องหมายจุลภาค โดยไม่มีช่องว่างระหว่างกัน อย่าลืมอ้างอิง
สตริงผลลัพธ์เนื่องจากวงเล็บมีความหมายต่อเชลล์ ตัวอย่างเช่น:
dflt='/bin/install'
fn='/fe~(ติดตั้ง,./ติดตั้ง)'
rp='ใช้โปรแกรมติดตั้งตัวไหน'
- ./getfile
ติดตั้ง="$ans"
จะอนุญาตให้ผู้ใช้ระบุเฉพาะพา ธ แบบเต็มที่อ้างถึงไฟล์ที่มีอยู่
แต่ยังอนุญาตให้คำตอบ "ติดตั้ง" และ "./ติดตั้ง" พิเศษตามที่เป็นอยู่ (สมมติว่า
แน่นอนว่าบางสิ่งบางอย่างจะจัดการกับพวกเขาโดยเฉพาะในภายหลังในห่วงโซ่เนื่องจากพวกเขาทำ
ไม่เป็นไปตามกรอบคาดทั่วไป)
หากคำตอบคือ 'ไม่มี' ให้ข้ามการตรวจสอบการมีอยู่และ
สตริงที่ว่างเปล่าจะถูกส่งกลับ โปรดทราบว่าตั้งแต่ รับไฟล์ โทร อ่านของฉัน ภายในทั้งหมด
คุณสมบัติที่มาพร้อมกับ อ่านของฉัน สมัครได้ที่นี่.
หากต้องการค่าที่ขยายอย่างสมบูรณ์ (เช่นใน Makefile) คุณสามารถใช้
$anexp ตัวแปรที่ตั้งค่าไว้อย่างถูกต้องโดย รับไฟล์ ในขณะที่ขยาย
รุ่นของ $ ตอบ. แน่นอน มันจะไม่ขยาย ~name หากคุณไม่อนุญาตใน
อันดับหนึ่งใน $fn ตัวแปร
อินห์ดร.ยู
หน่วยนี้ผลิต $inhdr ตัวแปรเชลล์ ใช้ภายในโดย กำหนดค่า ในการตรวจสอบ
ไม่ว่าชุดของส่วนหัวจะมีอยู่หรือไม่ก็ตาม การใช้งานทั่วไปคือ:
ตั้งค่าส่วนหัว i_header [ ส่วนหัว 2 i_header2 ... ]
ประเมิน $inhdr
ที่จะพิมพ์ข้อความระบุว่าพบส่วนหัวหรือไม่และตั้งค่า
i_header แปรผันตามนั้น หากมีการระบุส่วนหัวมากกว่าหนึ่งรายการและรายการแรก
ไม่พบส่วนหัว เราลองหัวข้อถัดไป จนกว่ารายการจะว่างเปล่าหรือพบรายการใดรายการหนึ่ง
อินลิบซี.ยู
หน่วยนี้ผลิต $inlibc ตัวแปรเชลล์ ใช้ภายในโดย กำหนดค่า ในการตรวจสอบ
ไม่ว่าจะกำหนดฟังก์ชัน C ที่กำหนดหรือไม่ การใช้งานทั่วไปคือ:
ตั้งค่าฟังก์ชัน d_func
ประเมิน $inlibc
ที่จะพิมพ์ข้อความว่าพบฟังก์ชันหรือไม่และตั้งค่า
$d_func ตามนั้น ภายในมันใช้ $csซิม กิจวัตรประจำวัน
ล็อก ยู
หน่วยสำคัญนี้สร้างเชลล์สคริปต์ loc ซึ่งสามารถนำไปใช้ค้นหาได้ว่าที่ไหน
ในรายการไดเร็กทอรีไฟล์ที่ระบุอยู่ อาร์กิวเมนต์แรกระบุไฟล์to
อาร์กิวเมนต์ที่สองคือสิ่งที่จะถูกส่งกลับหากการค้นหาล้มเหลวและ
reamining อาร์กิวเมนต์คือรายการของไดเร็กทอรีที่จะค้นหาไฟล์ สำหรับ
ตัวอย่าง:
dflt=`./loc sendmail.cf X / usr / lib /var/lib/sendmail / lib`
จะตั้ง $dflt ไปยัง X ถ้าไม่ sendmail.cf พบไฟล์ภายใต้ไดเร็กทอรีที่แสดงรายการ
หรือสิ่งที่ชอบ /usr/lib/sendmail.cf ในบางระบบ ดูสิ่งนี้ด้วย Getfile.U.
MailAuthor.U
ยูนิตนี้ต้องรวมอยู่ใน ?MAKE: line ของ End.U ส่วนตัวของคุณเองเพื่อสร้าง
มันเข้าไป กำหนดค่า. เสนอให้ผู้ใช้ลงทะเบียนตัวเองกับผู้เขียนหรือไม่ก็ได้
ได้รับแจ้งเมื่อแพทช์ใหม่มาถึงหรือได้รับโดยอัตโนมัติเมื่อออก
คุณต้องติดตั้ง ตัวแทนไปรษณีย์ เพื่อทำสิ่งนี้ (อย่างน้อยเวอร์ชัน 3.0)
MailList.U
ยูนิตนี้ต้องรวมอยู่ใน ?MAKE: line ของ End.U ส่วนตัวของคุณเองเพื่อสร้าง
มันเข้าไป กำหนดค่า. เสนอให้ผู้ใช้สมัครหรือยกเลิกการสมัครรับจดหมายข่าว
มีการอภิปรายเกี่ยวกับแพ็คเกจเกิดขึ้น คุณต้องวิ่ง แพ็คกินิต
และตอบคำถามที่เกี่ยวข้องกับรายชื่อผู้รับจดหมายเพื่อตั้งค่าตัวแปรที่เหมาะสมในของคุณ
.บรรจุุภัณฑ์ ก่อนที่เครื่องนี้จะใช้งานได้
มีนิต.ยู
คัดลอกยูนิตนี้ไปยังห้องส่วนตัวของคุณ U ไดเร็กทอรีเพื่อเพิ่มค่าดีฟอลต์ของคุณเองให้กับ some
ตัวแปรภายใน หน่วยนี้ถูกโหลดเข้าสู่ กำหนดค่า หลังจากทั้งหมดเริ่มต้น
การกำหนดค่าเริ่มต้นเสร็จเรียบร้อยแล้ว
Myread.U
หน่วยนี้ผลิต อ่านของฉัน เชลล์สคริปต์ที่ต้องมีที่มาเพื่อทำ a
อ่าน. อนุญาตให้ใช้การหลบหนีของเชลล์ การกำหนดค่าเริ่มต้น และการประเมินพารามิเตอร์ เช่น
บันทึกไว้ในหน่วย Instruct.U นอกจากนี้ยังช่วยให้การตั้งค่าไดนามิกของ -d ตัวเลือก
ซึ่งจะใช้สำหรับการประมวลผลสคริปต์ที่เหลือ
ในการใช้เครื่องนี้ $rp ต้องถือคำถามและ $dflt ควรมีค่าเริ่มต้น
คำตอบ. สคริปต์จะพิมพ์คำถามเองและส่งคืนผลลัพธ์
ใน $ ตอบ ตัวแปร
นี่คือการใช้งานทั่วไป:
dflt='y'
rp='คำถาม?'
. ./มายเรด
ค่า = "$ น"
ดูยูนิตสำหรับข้อมูลเพิ่มเติม
Oldconfig.U
หน่วยนี้ต้องเป็นส่วนหนึ่งของการพึ่งพาของคุณ ?MAKE: บรรทัดเมื่อบางหน่วยของคุณพยายาม
เพื่อนำค่าสัญลักษณ์เก่ามาใช้ใหม่ หน่วยนี้มีหน้าที่รับคำตอบเก่า
ราคาเริ่มต้นที่ config.sh หรือให้คำแนะนำที่เป็นประโยชน์เมื่อทำงานบนแพลตฟอร์มที่กำหนดสำหรับ
ครั้งแรก. ดู กำหนดค่า คำแนะนำ ย่อหน้าสำหรับข้อมูลเพิ่มเติมเกี่ยวกับคำแนะนำ
คำนำหน้า U
จุดประสงค์ของหน่วยนี้คือเพื่อตรวจหาการเปลี่ยนแปลงในไดเร็กทอรีคำนำหน้าการติดตั้งเป็น
คำนวณค่าเริ่มต้นที่เหมาะสมโดยอัตโนมัติจากคำตอบก่อนหน้า มันขึ้นอยู่กับ
มูลค่าของ $คำนำหน้าเก่า ตัวแปรซึ่งเก็บไดเร็กทอรีคำนำหน้าก่อนหน้าเมื่อมัน
เปลี่ยนและว่างเปล่าเป็นอย่างอื่น ตัวอย่างเช่น หากคำนำหน้าเปลี่ยนจาก /เลือก ไปยัง
/ usr / localจากนั้นไดเร็กทอรีการติดตั้งไบนารีก่อนหน้าจะเปลี่ยนจาก
/เลือก/bin ไปยัง / usr / local / binหรือจะไม่เปลี่ยนแปลงหากเป็นเช่นว่า / bin.
คุณต้องโทร ชุด ก่อนออกคำสั่ง ประเมิน on $ คำนำหน้าเช่น:
ตั้งค่า dflt var [dir]
ประเมิน $prefixit
ซึ่งจะกำหนด $dflt ไปยัง $var or $คำนำหน้า/dir ขึ้นอยู่กับว่าคำนำหน้ายังคงอยู่
เหมือนกันหรือไม่ ถ้า dir เป็นสตริง ไม่มี, ค่าช่องว่างเดียวใน $dflt ถูกเก็บไว้เป็น-
คือแม้ว่าคำนำหน้าจะเปลี่ยน ถ้า dir ละเว้นแล้ว $dflt ถูกกำหนดให้ว่างเปล่า
สตริงถ้าคำนำหน้าเปลี่ยนเป็น $var มิฉะนั้น.
คำนำหน้า U
เจตนาของหน่วยนี้คล้ายกับของ Prefixit.U คือช่วยแก้ไข
สตริงเริ่มต้นเพื่อรองรับการเปลี่ยนแปลงคำนำหน้า อย่างไรก็ตาม ตัวแปรเชลล์ $ คำนำหน้า,
เมื่อประเมินแล้ว จะกู้คืนเฉพาะส่วนขยาย ~name เท่านั้น หากคำนำหน้าใช้ Escape . ดังกล่าว
กลไก. ใช้เป็น:
ตั้งค่า dflt
ประเมิน $prefixup
ก่อนที่จะแจ้งผ่าน รับไฟล์ ตัวอย่างเช่น หากคำนำหน้าไม่ได้ใช้ ~name
การขยายจากนั้นข้างต้นจะไม่มีการปฏิบัติการบน y ตัวแปรโดยธรรมชาติ
Typedef.U
หน่วยนี้ผลิต $typedef ตัวแปรเชลล์ ใช้ภายในโดย กำหนดค่า ในการตรวจสอบ
มี typedef อยู่หรือไม่ การใช้งานทั่วไปคือ:
ตั้งค่าเริ่มต้นของ typedef val_t [ รวม ]
ประเมิน $typedef
สิ่งนี้จะตั้งค่าตัวแปร val_t ถึงค่าของ ผิดนัด หากไม่พบ typedef
ในรายการรวมถึงไฟล์หรือto พิมพ์ดีฟ ถ้าพบ หากไม่มีไฟล์รวมอยู่
ระบุหน่วยมีลักษณะเป็น เท่านั้น. หากคุณระบุบางส่วนรวมถึงเท่านั้น
ที่ถูกมองว่า
ยูนิกซ์.ยู
จุดประสงค์ของหน่วยนี้คือการกำหนด UNIX-isms ทั่วไปบางส่วนผ่านตัวแปร
ซึ่งสามารถเปลี่ยนแปลงได้จากบรรทัดคำสั่งหรือผ่านไฟล์คำใบ้ที่เหมาะสม โดยเฉพาะอย่างยิ่ง,
$_exe, $_o และ $_ก มีการตั้งค่า. หน่วยทั้งหมดควรอ้างถึง $_o และไม่ .o โดยตรง.
NS '.' เป็นส่วนหนึ่งของตัวแปรเหล่านี้
เซทวาร์.ยู
หน่วยนี้สร้างตัวแปรซึ่งใช้ภายในโดย กำหนดค่า ตั้งค่า a
กำหนด/undef เป็นสัญลักษณ์ที่กำหนดโดยส่งคำเตือนเมื่อมีการเปลี่ยนแปลงอย่างกะทันหัน
จากค่าที่แล้ว ตัวอย่างเช่น:
val="$define"
ตั้งค่า d_variable
ประเมิน $setvar
ถ้าก่อนหน้านี้ $d_ตัวแปร ค่าไม่เป็นโมฆะและ $วาล ต่างกัน "โว้ว"
มีการออกคำเตือน
โว้ว.ยู
หน่วยนี้ผลิต โว้ว สคริปต์ซึ่งส่งเสียงเตือนเมื่อ ความคุ้มค่า ในตัวแปร
ที่ชื่อ $var ไม่เหมือนกับค่าเดิมที่ถือใน $ถูก. เมื่อ
กลับ, $td และ $tu ถือค่าที่เหมาะสมเพื่อ กำหนด or ไม่แน่นอน ตัวแปร ดู
ตัวอย่างใน อินลิบซี.ยู.
ในตัว พรีโปรเซสเซอร์
แต่ละหน่วยที่จะรวมอยู่ใน กำหนดค่า ถูกรันผ่านพรีโปรเซสเซอร์ในตัว ก่อน-
คำสั่งโปรเซสเซอร์ถูกนำมาใช้โดยอักขระ '@' ('#' คือความคิดเห็นของเชลล์
อักขระ). มันทำงานเหมือนกับที่ตัวประมวลผลล่วงหน้าของ C ทำ แต่อนุญาตให้เชลล์และ perl
หลบหนี นี่คือฟังก์ชันที่ใช้ได้:
@ถ้า การแสดงออก
If การแสดงออก เป็นจริง ให้โหลดโค้ดต่อจนถึง @end, @elsif หรือ @else
@เอลซิฟ การแสดงออก
ทางเลือกทางเลือก. ถ้า การแสดงออก เป็นจริง โหลดโค้ดต่อจนถึง @end
@elsif หรือ @else อื่น
@else รหัสเริ่มต้นที่จะโหลดหาก @if การแสดงออก เป็นเท็จและไม่มีของ
ไม่บังคับ @elsif ที่ตรงกัน โหลดจนถึง @end
@end ปิดคำสั่งการโหลดตามเงื่อนไขที่เปิดโดย @if
@กำหนด เครื่องหมาย
บอกพรีโปรเซสเซอร์ว่า เครื่องหมาย กำหนดไว้ตั้งแต่บัดนี้เป็นต้นไป
เงื่อนไข การแสดงออก สามารถใส่ชื่อสัญลักษณ์ได้ (ค่าเป็นจริงหากต้องการใช้สัญลักษณ์หรือ
กำหนดโดย @กำหนด หรือเชลล์/perl หลบหนี อะตอมเหล่านั้นสามารถรวมกันได้โดยใช้
ตัวดำเนินการบูลีนแบบดั้งเดิม '!' สำหรับการปฏิเสธ '&&' สำหรับตรรกะและและ '||' สำหรับตรรกะ
หรือ
ข้อความที่อยู่ในวงเล็บเดียวคือการทดสอบเชลล์ ขณะที่ข้อความระหว่างเบรกคู่คือ
การทดสอบ Perl กล่าวคือนิพจน์:
{ เปลือก ข้อความ }
{{ Perl ข้อความ }}
ได้รับการแปลเป็น:
if เปลือก ข้อความ >/dev/null 2>&1; จากนั้นออก 0; อื่น ทางออก 1; fi
ถ้า (Perl ข้อความ) {exit 0;} อื่น {exit 1;}
และสถานะการออกจะใช้ในวิธีมาตรฐานเพื่อรับค่าบูลีนเช่น 0 เป็นจริงและ
ทุกสิ่งทุกอย่างเป็นเท็จ โปรดทราบว่ามีเพียงเงื่อนไขง่าย ๆ เท่านั้นที่สามารถแสดงเป็น Perl ได้จนถึง
รหัสที่ซับซ้อนบางอย่างสามารถโหลดได้ภายใน เมตาคอนฟิก และดำเนินการ
สามารถใช้พรีโปรเซสเซอร์ในตัวเพื่อปรับแต่งบางยูนิตได้อย่างละเอียด (ดู d_getname.U สำหรับ
ตัวอย่างที่ซับซ้อน) ขึ้นอยู่กับสัญลักษณ์ที่ใช้จริงโดยโปรแกรมหรือไฟล์
ที่มีอยู่ในการกระจาย ตัวอย่างเช่น Oldconfig.U ใช้การทดสอบเช่น:
@if {ทดสอบ -d ../คำแนะนำ}
และ กำหนดค่า จะมีรหัสที่ขึ้นกับคำใบ้ก็ต่อเมื่อมี a คำแนะนำ ไดเรกทอรีใน
ไดเรกทอรีระดับบนสุดของแพ็คเกจ โปรดทราบว่าการทดสอบจะดำเนินการจากภายใน '.มท' ไดเรกทอรี
ดังนั้น '../' ที่จำเป็นในการทดสอบ
พรีโปรเซสเซอร์สามารถใช้เพื่อหลีกเลี่ยงการใส่รหัสที่ไม่มีประโยชน์เมื่อไม่มีสัญลักษณ์
กำหนดไว้ หน่วยที่กำหนดมากกว่าหนึ่งสัญลักษณ์สามารถป้องกันได้ด้วยวิธีนี้ (เนื่องจากหน่วยเป็น
โหลดโดยรวม) โดยการรวบรวมรหัสที่ขึ้นกับสัญลักษณ์ภายในคู่ @if/@end สำหรับ
ตัวอย่าง:
@ถ้า I_TIME || I_SYS_TIME || I_SYS_TIME_KERNEL
need_time_h='จริง'
@อื่น
need_time_h='เท็จ'
@จบ
จะทดสอบว่าซอร์สโค้ดใช้หนึ่งในสามสัญลักษณ์ที่ควบคุมหรือไม่
เวลา h or sys/time.h รวมและกำหนดสัญลักษณ์เชลล์ตามลำดับ ที่ให้
กำหนดค่า ข้อเสนอแนะเกี่ยวกับสิ่งที่แหล่งที่มาต้องการและหลีกเลี่ยงข้อเสียของการแก้ไข
หน่วยแช่แข็ง
ผ่านบรรทัด '?W:' คุณสามารถรับชุดค่าผสมที่คั่นระหว่างหน้าได้ ตัวอย่างเช่น i_time.U หน่วย
จำเป็นต้องรู้ว่าแหล่ง C ใช้ประโยชน์จาก .หรือไม่ โครงสร้าง เขตเวลา พิมพ์. ดังนั้น,
เส้น:
?W::เขตเวลา
ใช้สำหรับผลข้างเคียงของการกำหนดสัญลักษณ์ เขตเวลา สำหรับพรีโปรเซสเซอร์ NS
รหัสหน่วยสามารถพูดได้ว่า:
@ถ้าเขตเวลา
สำหรับ s_timezone ใน '-DS_TIMEZONE' ''; ทำ
@อื่น
s_timezone=''
@จบ
... รหัสโดยใช้ s_timezone ...
@ถ้าเขตเวลา
ทำ
@จบ
และมีลูปพิเศษลองสองค่าต่อเนื่องกันสำหรับ s_เขตเวลา ตัวแปรแต่เท่านั้น
หากมีความจำเป็น.
ล้าสมัย สัญลักษณ์
สัญลักษณ์ที่ล้าสมัยจะได้รับการเก็บรักษาไว้เพื่อความสะดวกในการเปลี่ยนกับรุ่นเก่า เมตาคอนฟิก หน่วย เว้นแต่
-o สวิตช์ถูกส่งไปที่ เมตาคอนฟิก พวกเขาจะถูกละเลย อย่างไรก็ตาม an ล้าสมัย ไฟล์จะ
ถูกสร้างขึ้นโดยบอกคุณว่าไฟล์ใดใช้สัญลักษณ์ที่ล้าสมัยเหล่านั้นและอะไร
เป็นสัญลักษณ์ใหม่ที่จะใช้
อายุการใช้งานสำหรับสัญลักษณ์ที่ล้าสมัยคือการแก้ไขหนึ่งครั้ง กล่าวคือ จะถูกลบออกเมื่อ
มีการออกการแก้ไขพื้นฐานครั้งถัดไป (แน่นอนว่าการอัปเกรดแพตช์ไม่นับรวม) ดังนั้นจึงเป็น
ฉลาดที่จะแปลแหล่งที่มาของคุณและเริ่มใช้สัญลักษณ์ใหม่โดยเร็วที่สุด
กำหนดค่า คำแนะนำ
อาจเกิดขึ้นได้ว่าตรรกะการกำหนดค่าภายในทำให้ตัวเลือกไม่ถูกต้อง สำหรับ
ตัวอย่างเช่น ในบางแพลตฟอร์ม วีฟอร์ค() มีการเรียกของระบบแต่เสีย ดังนั้นจึงควร
ไม่ได้ใช้ เป็นไปไม่ได้ที่จะรวมความรู้นั้นไว้ในหน่วยการเรียนรู้เพราะ
นั่นอาจเป็นปัญหาชั่วคราวซึ่งผู้ขายจะแก้ไขในที่สุดหรือบางอย่างที่
ได้รับการแนะนำโดยการอัพเกรดระบบปฏิบัติการใหม่
อย่างไรก็ตาม สำหรับปัญหาเล็กๆ น้อยๆ ที่เจาะจงระบบมากเกินไป เมตาคอนฟิก
ให้การสนับสนุนไฟล์คำใบ้ หากต้องการใช้งาน คุณต้องสร้าง a คำแนะนำ ไดเรกทอรีใน
ไดเร็กทอรีระดับบนสุดของแพ็คเกจและมีไว้เมื่อคุณเรียกใช้ เมตาคอนฟิก. ที่จะโหลด
ส่วนที่เกี่ยวข้องกับคำใบ้จาก Oldconfig.U.
จากนั้น คุณสามารถตั้งค่าตัวแปรเชลล์บางตัวล่วงหน้าได้ กำหนดค่า ใช้ในระบบปฏิบัติการเฉพาะ
ไฟล์ .sh มีรหัสใน Oldconfig.U ที่พยายามเดาว่าไฟล์คำใบ้ใดที่จำเป็นโดย
คำนวณชื่อมาตรฐานตามชื่อระบบปฏิบัติการ ชื่อเคอร์เนล รีลีส
หมายเลข ฯลฯ... เนื่องจากข้อมูลนี้มีแนวโน้มที่จะเปลี่ยนแปลงอย่างรวดเร็ว ฉันไม่ได้จัดทำเป็นเอกสารไว้
ที่นี่. คุณต้องทำวิศวกรรมย้อนกลับรหัสจาก Oldconfig.U.
เมื่อคุณเปิดตัวแพ็คเกจครั้งแรก ไดเร็กทอรีไฟล์คำใบ้ของคุณควรว่างเปล่า ถ้า
ผู้ใช้แพ็คเกจของคุณบ่นว่าพวกเขามีปัญหากับ กำหนดค่า ค่าเริ่มต้นในa
ระบบเฉพาะ คุณต้องดูว่านี่เป็นปัญหาเฉพาะแพลตฟอร์มหรือ
ทั่วไป ในกรณีก่อนหน้านี้ถึงเวลาแนะนำไฟล์คำใบ้ใหม่ในขณะที่อยู่ใน
หลังควรแก้ไขหน่วยที่เกี่ยวข้อง
ตัวอย่างเช่น ระบบ SGI เป็นที่ทราบกันดีว่ามีข้อบกพร่อง วีฟอร์ค() ระบบเรียก ณ บัดนี้
การเขียน. และชื่อไฟล์คำใบ้ที่สอดคล้องกันคือ sgi.sh. สิ่งที่คุณต้องทำคือสร้าง
a คำแนะนำ/sgi.sh ไฟล์ที่คุณเขียน:
d_vfork="$define"
ซึ่งจะทำการรีแมปเสมอ ส้อม on ส้อม (ดู d_vfork.U). เมื่อทำงานบนระบบ SGI สำหรับ
ครั้งแรก, กำหนดค่า จะตรวจพบว่ามี คำแนะนำ/sgi.sh ไฟล์และเราอยู่บน
เครื่อง IRIX (ชื่อเคอร์เนลมักจะเป็น /irix) ดังนั้นจึงจะเสนอ sgi เป็น
คำใบ้ที่เป็นไปได้ หากผู้ใช้ยอมรับและเนื่องจาก $d_vส้อม ค่าจะถูกแก้ไขผ่านทาง
$setvar โทร โว้ว! จะถูกปล่อยออกมาเพื่อเตือนว่าเรากำลังจะลบล้างค่า
คำนวณโดย กำหนดค่า.
โปรดทราบว่าคุณไม่จำเป็นต้องให้ ทั้งหมด คำแนะนำที่รู้จักโดย Oldconfig.U. หากไฟล์คำใบ้คือ
ที่ขาดหายไปจะไม่ถูกเสนอให้เป็นทางเลือกที่เป็นไปได้ การทดสอบฮิวริสติกวิ่งเพื่อคำนวณ
ผู้สมัครคำใบ้ที่เป็นไปได้นั้นไม่สม่ำเสมอ หากคุณมีค่าใหม่หรือการทดสอบที่แตกต่างกันโปรด
ส่งมาให้ฉัน...
ที่เอาชนะ ทางเลือก
หากคุณสร้าง config.over ไฟล์ในไดเร็กทอรีระดับบนสุด กำหนดค่า จะถามคุณว่าคุณ
ต้องการโหลดเพื่อแทนที่ค่าเริ่มต้น สิ่งนี้ทำก่อนการสร้าง
config.sh ไฟล์จึงเปิดโอกาสให้คุณแก้ไขค่าที่เก็บไว้ในนั้น
ซึ่งแตกต่างจากแนวทางคำใบ้ตรงที่มันเป็นไฟล์ในเครื่อง ซึ่งผู้ใช้คือ
อิสระที่จะสร้างเพื่อการใช้งานของเขาเอง คุณไม่ควรให้ไฟล์ดังกล่าวด้วยตัวเอง แต่ให้
ผู้ใช้ทราบเกี่ยวกับความเป็นไปได้นี้
กำหนดค่า Options
พื้นที่ กำหนดค่า สคริปต์อาจถูกเรียกด้วยตัวเลือกบางอย่างที่ระบุในบรรทัดคำสั่ง to
ปรับเปลี่ยนพฤติกรรมเล็กน้อย นี่คือตัวเลือกที่อนุญาต:
-d ใช้ค่าเริ่มต้นสำหรับคำตอบทั้งหมด
-e ดำเนินไปโดยไม่ถามถึงการผลิตของ config.sh.
-f ไฟล์ ใช้ไฟล์ที่ระบุเป็นการกำหนดค่าเริ่มต้น หากไม่ได้ใช้สวิตช์นี้
การกำหนดค่านำมาจาก config.sh, เมื่อปัจจุบัน.
-h พิมพ์ข้อความช่วยเหลือและออก
-r ใช้ค่าสัญลักษณ์ C ซ้ำถ้าเป็นไปได้ นี้จะข้ามค่าใช้จ่าย nm เครื่องหมาย
การสกัด หากใช้ครั้งแรก (โดยไม่มีไฟล์กำหนดค่าก่อนหน้า)
กำหนดค่า จะพยายามคอมไพล์และลิงค์โปรแกรมเล็กๆ มาให้ทราบครับ
การมีสัญลักษณ์หรือไม่มีอยู่
-s โหมดเงียบ เฉพาะสตริงที่พิมพ์บน file descriptor #4 เท่านั้นที่จะเห็นบน
หน้าจอ (นั่นคือข้อความสำคัญ) ไม่สามารถปิดได้อย่างสมบูรณ์
เอาต์พุตใด ๆ แต่คุณสามารถใช้ 'กำหนดค่า -เดอร์ > / dev / null 2> & 1' ให้เต็มที่
รันแบทช์โดยไม่มีเอาต์พุตและไม่จำเป็นต้องมีการโต้ตอบกับผู้ใช้
-D สัญลักษณ์=ค่า
กำหนดไว้ล่วงหน้า เครื่องหมาย ที่จะแบกรับไว้ ความคุ้มค่า. ก็ยังใช้ได้'-D
เครื่องหมาย' ซึ่งจะใช้ค่าเริ่มต้นเป็น 'define'
-E หยุดที่ส่วนท้ายของคำถามการกำหนดค่า หลังจากสร้าง a
config.sh. นี้จะไม่ดำเนินการใด ๆ 'ทำ ขึ้นอยู่กับ' หรือการแยกไฟล์ .SH
-K ผู้ใช้ที่มีความรู้ เมื่อคุณใช้ตัวเลือกนี้ คุณจะรู้ว่าคุณกำลังทำอะไรและ
ดังนั้น config.sh ไฟล์จะได้รับการจัดการเสมอราวกับว่ามันตั้งใจให้เป็น
นำมาใช้ใหม่ ถึงแม้ว่ามันอาจจะถูกสร้างขึ้นบนระบบต่างด้าวก็ตาม นอกจากนี้ยัง
ป้องกันการยกเลิกเมื่อ กำหนดค่า ตรวจพบคอมไพเลอร์ C ที่ใช้ไม่ได้หรือ set . ผิด
ของธง C ทางลัดเพิ่มเติมอาจถูกเปิดโดยตัวเลือกนี้เช่นกันใน
อนาคต. ตัวเลือกนี้มีบันทึกไว้ใน กำหนดค่า ข้อความการใช้งานเพื่อเตือนเรา
เกี่ยวกับการดำรงอยู่ของมัน แต่คำอธิบายที่ให้มาหวังว่าจะเป็นความลับเพียงพอ
:-)
-O อนุญาตค่าที่ระบุผ่าน a -D or -U เพื่อแทนที่การตั้งค่าจากการโหลดใด ๆ
ไฟล์การกำหนดค่า นี่ไม่ใช่พฤติกรรมเริ่มต้นเนื่องจากการแทนที่ will
ไม่ถูกเผยแพร่ไปยังตัวแปรที่ได้มาจากตัวแปรที่คุณกำลังแก้ไขในปัจจุบัน
โดยธรรมชาติแล้วไม่มี -O, การตั้งค่าจะทำได้ก็ต่อเมื่อไม่มีไฟล์กำหนดค่าเป็น
Loading ซึ่งปลอดภัยเพราะยังไม่ได้คำนวณตัวแปรอนุพันธ์...
-S ทำการแทนที่ตัวแปรในไฟล์ .SH ทั้งหมด คุณสามารถรวมเข้ากับ
-f เปลี่ยนไปเผยแพร่การกำหนดค่าที่คุณต้องการ
-U สัญลักษณ์=
ที่ตั้งไว้ล่วงหน้า เครื่องหมาย เพื่อรับค่าว่าง ก็ยังใช้ได้'-U เครื่องหมาย'
ซึ่งจะกำหนด เครื่องหมาย ที่จะ 'ไม่รู้จัก'
-V พิมพ์หมายเลขเวอร์ชันของ เมตาคอนฟิก ที่สร้างสิ่งนี้ขึ้นมา กำหนดค่า ต้นฉบับ
และออก
เล่น สิ่งแวดล้อม
เมื่อเริ่มต้น กำหนดค่า สร้างท้องถิ่น UU ไดเรกทอรีและเรียกใช้จากที่นั่น ไดเร็กทอรี
ถูกลบเมื่อ Configure สิ้นสุดลง แต่หมายความว่าคุณต้องเรียกใช้สคริปต์จากที่ที่
คุณสามารถเขียนได้ กล่าวคือ ไม่ได้มาจากระบบไฟล์แบบอ่านอย่างเดียว
คุณสามารถเรียกใช้ กำหนดค่า จากระยะไกลเช่นใน:
../แพ็คเกจ/กำหนดค่า
เพื่อกำหนดค่าแหล่งที่มาที่ไม่มีอยู่ในเครื่อง ไฟล์ที่สร้างขึ้นทั้งหมดจะถูกใส่ใน
ไดเร็กทอรีที่คุณเรียกใช้สคริปต์ เวทมนตร์นี้ทำได้ด้วย src.U
หน่วยซึ่งกำลังตั้งค่า $src และ $rsrc ตัวแปรเพื่อชี้ไปที่แหล่งที่มาของแพ็คเกจ ที่
เส้นทางจะเต็มหรือสัมพัทธ์ ขึ้นอยู่กับว่า กำหนดค่า ถูกเรียกโดยเต็มหรือ
เส้นทางสัมพัทธ์
จากภายใน UU ไดเรกทอรีย่อย คุณสามารถใช้ $rsrc เพื่อเข้าถึงไฟล์ต้นฉบับ (หน่วย
การอ้างอิงถึงคำใบ้ลิงค์ของไฟล์ต้นฉบับจะใช้กลไกนี้เสมอและไม่ถือว่า
ไฟล์มีอยู่ในไดเร็กทอรีหลัก) Makefiles ทั้งหมดควรใช้ตัวแปร $src
เป็นตัวชี้ไปยังแหล่งที่มาจากด้านบนของไดเร็กทอรี build (โดยที่ กำหนดค่า กำลังทำงาน)
โดยตรงหรือผ่านการตั้งค่า VPATH
เมื่อวิ่ง กำหนดค่า จากระยะไกล ไฟล์ .SH จะถูกแตกในไดเร็กทอรี build ไม่ใช่
ในต้นไม้ต้นทาง อย่างไรก็ตาม มันต้องใช้ a . บางชนิด ทำ รองรับการคอมไพล์
สิ่งต่าง ๆ ในไดเร็กทอรี build ในขณะที่แหล่งที่มาอยู่ที่อื่น
การใช้ มายากล นิยามใหม่
โดยใช้ประโยชน์จากไฟล์ -M เปลี่ยน การแมปเวทย์มนตร์บางอย่างอาจเกิดขึ้นภายใน a confmagic.h
ไฟล์. ต้องรวมไฟล์นั้นไว้หลัง config.hแน่นอน แต่หลังจากทั้งหมด
อื่น ๆ ที่จำเป็นรวมถึงไฟล์ กล่าวคือ:
#include "config.h"
...
... อื่น ๆ รวม ...
...
#รวม "confmagic.h"
โดยปกติแล้ว confmagic.h จะพยายามทำการแมปใหม่ บีคัดลอก() on เมมปี้() ถ้าไม่ บีคัดลอก() is
มีจำหน่ายในพื้นที่หรือแปลง ส้อม เข้าไป ส้อม เมื่อจำเป็นจึงทำให้เปล่าประโยชน์
กังวลเกี่ยวกับ HAS_VFORK สัญลักษณ์.
เวทย์มนตร์การกำหนดค่านี้มีบันทึกไว้ในไฟล์อภิธานศัพท์
Unit แม่แบบ
มีชุดแม่แบบหน่วยใน เมตาคอนฟิก ไดเรกทอรีต้นทางซึ่งมีวัตถุประสงค์เพื่อ
ใช้โดยโปรแกรม (ยังไม่ได้เขียน) เพื่อผลิตหน่วยใหม่สำหรับประเภทต่าง ๆ อย่างรวดเร็ว
สถานการณ์ ไม่มีเอกสารสำหรับโปรเจ็กต์ที่ยังไม่เสร็จนี้ แต่ฉันคิดว่าฉันจะพูดถึงมัน
ในหน้าคู่มือ ในกรณีที่ท่านต้องการทำเองแล้วร่วมสมทบ...
ผู้เขียน
แลร์รี่ วอลล์[ป้องกันอีเมล]> สำหรับรุ่น 2.0.
Harlan Stenn[ป้องกันอีเมล]> สำหรับการขยายหน่วยที่สำคัญ
ราฟาเอล มันเฟรดิ[ป้องกันอีเมล]>.
ผู้มีส่วนร่วมอื่น ๆ อีกมากมายสำหรับ เมตาคอนฟิก หน่วย ดูไฟล์เครดิตสำหรับรายการ
ใช้ metaconfig ออนไลน์โดยใช้บริการ onworks.net
