นี่คือข้อเสียของคำสั่งที่สามารถเรียกใช้ในผู้ให้บริการโฮสต์ฟรีของ OnWorks โดยใช้เวิร์กสเตชันออนไลน์ฟรีของเรา เช่น Ubuntu Online, Fedora Online, โปรแกรมจำลองออนไลน์ของ Windows หรือโปรแกรมจำลองออนไลน์ของ MAC OS
โครงการ:
ชื่อ
จุดด้อย - ระบบการสร้างซอฟต์แวร์
DESCRIPTION
คำแนะนำและข้อมูลอ้างอิงสำหรับเวอร์ชัน 2.2.0
ลิขสิทธิ์ (c) 1996-2000 Free Software Foundation, Inc.
โปรแกรมนี้เป็นซอฟต์แวร์ฟรี คุณสามารถแจกจ่ายซ้ำและ/หรือแก้ไขภายใต้เงื่อนไขของ
GNU General Public License ที่เผยแพร่โดย Free Software Foundation; ทั้ง
เวอร์ชัน 2 ของใบอนุญาต หรือ (ตามที่คุณเลือก) เวอร์ชันที่ใหม่กว่า
โปรแกรมนี้เผยแพร่ด้วยความหวังว่าจะมีประโยชน์ แต่ไม่มีการรับประกันใดๆ
โดยไม่มีการรับประกันโดยนัยของความสามารถในการขายสินค้าหรือความเหมาะสมสำหรับวัตถุประสงค์เฉพาะ
ดูสัญญาอนุญาตสาธารณะทั่วไปของ GNU สำหรับรายละเอียดเพิ่มเติม
คุณควรได้รับสำเนาสัญญาอนุญาตสาธารณะทั่วไปของกนูพร้อมกับโปรแกรมนี้
ดูไฟล์ COPYING. ถ้าไม่ เขียนถึง Free Software Foundation, Inc., 59 Temple
เพลส - สวีท 330 บอสตัน แมสซาชูเซตส์ 02111-1307 สหรัฐอเมริกา
บทนำ
จุดด้อย เป็นระบบสำหรับสร้างซอฟต์แวร์เป็นหลัก แต่ค่อนข้างแตกต่างจาก
ระบบการสร้างซอฟต์แวร์ก่อนหน้า ข้อเสียได้รับการออกแบบจากพื้นดินเพื่อจัดการ
อย่างง่ายดายด้วยการสร้างซอฟต์แวร์ที่กระจายอยู่บนไดเร็กทอรีต้นทางหลายแห่ง ข้อเสีย
ทำให้ง่ายต่อการสร้างสคริปต์บิลด์ที่เรียบง่าย เข้าใจได้ และสามารถบำรุงรักษาได้
ข้อเสียทำให้มั่นใจได้ว่าซอฟต์แวร์ที่ซับซ้อนสามารถทำซ้ำได้ง่ายและแม่นยำ
ข้อเสียใช้เทคนิคหลายอย่างเพื่อทำสิ่งนี้ให้สำเร็จ สคริปต์การก่อสร้างเป็นเพียง
สคริปต์ Perl ทำให้เข้าใจง่ายและมีความยืดหยุ่นสูง ขอบเขตทั่วโลกของ
ตัวแปรจะถูกแทนที่ด้วยกลไกการนำเข้า/ส่งออกสำหรับการแบ่งปันข้อมูลระหว่าง
สคริปต์ ปรับปรุงความสามารถในการอ่านและการบำรุงรักษาของแต่ละสคริปต์อย่างมีนัยสำคัญ
การก่อสร้าง สภาพแวดล้อม มีการแนะนำ: เหล่านี้เป็นวัตถุ Perl ที่จับ
ข้อมูลที่จำเป็นสำหรับการควบคุมกระบวนการสร้าง ใช้สภาพแวดล้อมที่หลากหลาย
เมื่อต้องใช้ความหมายที่แตกต่างกันสำหรับการสร้างผลิตภัณฑ์ในแผนผังการสร้าง ข้อเสีย
ใช้การวิเคราะห์การพึ่งพาอัตโนมัติและใช้สิ่งนี้เพื่อจัดลำดับทั้ง
สร้าง. บิลด์แบบแปรผันสามารถสร้างขึ้นได้อย่างง่ายดายจากทรีต้นทางเดียว สร้างอัจฉริยะ
การตั้งค่าย่อยเป็นไปได้เมื่อทำงานกับการเปลี่ยนแปลงที่แปลแล้ว สามารถตั้งค่าการแทนที่เป็น
แทนที่คำแนะนำในการสร้างอย่างง่ายดายโดยไม่ต้องแก้ไขสคริปต์ใดๆ การเข้ารหัส MD5
ลายเซ็น เชื่อมโยงกับไฟล์ที่ได้รับ และใช้เพื่อกำหนดว่า
ไฟล์ที่กำหนดจะต้องสร้างใหม่
ในขณะที่นำเสนอทั้งหมดข้างต้นและอื่น ๆ ข้อเสียยังคงเรียบง่ายและใช้งานง่าย นี่จะ,
หวังว่าจะชัดเจนเมื่อคุณอ่านส่วนที่เหลือของเอกสารนี้
Why ข้อเสีย? Why ไม่ ให้?
ข้อเสียคือ ทำ ทดแทน ในย่อหน้าต่อไปนี้ เราจะดูที่
ลักษณะที่ไม่พึงปรารถนาของการสร้าง - และสภาพแวดล้อมการสร้างโดยทั่วไปตามการสร้าง - นั่น
กระตุ้นการพัฒนาจุดด้อย
สร้าง ความซับซ้อน
ระบบ make-based แบบดั้งเดิมทุกขนาดมักจะค่อนข้างซับซ้อน ยี่ห้อเดิม
ประโยชน์ใช้สอยและอนุพันธ์มีส่วนทำให้เกิดแนวโน้มนี้ในหลายประการ ทำให้เป็น
ไม่เก่งในการจัดการกับระบบที่กระจายไปทั่วหลายไดเร็กทอรี งานต่างๆ-
รอบ ๆ ใช้เพื่อเอาชนะความยากลำบากนี้ ทางเลือกปกติคือเพื่อให้เรียกใช้
ตัวเองซ้ำ ๆ สำหรับแต่ละไดเร็กทอรีย่อยของบิลด์ สิ่งนี้นำไปสู่รหัสที่ซับซ้อนใน
ซึ่งมักจะไม่ชัดเจนว่าตัวแปรถูกตั้งค่าอย่างไร หรือมีผลอย่างไรกับการตั้งค่าของตัวแปร
จะมีในการสร้างโดยรวม ภาษาสคริปต์ make ค่อยๆ ขยายออกไป
เพื่อให้มีความเป็นไปได้มากขึ้น แต่สิ่งเหล่านี้กลับทำให้รกไปแล้ว
ภาษาที่มากเกินไป บ่อยครั้งที่งานสร้างเสร็จสิ้นในหลายรอบเพื่อให้
ผลิตภัณฑ์ที่เหมาะสมจากไดเร็กทอรีหนึ่งไปยังไดเร็กทอรีอื่น นี้แสดงถึงต่อไป
เพิ่มความซับซ้อนในการสร้าง
สร้าง การทำสำเนาได้
ความหายนะของผู้ผลิตทั้งหมดคือการจัดการการพึ่งพาที่ถูกต้องเสมอ ส่วนใหญ่มักจะ an
มีความพยายามในการทำงานที่เหมาะสมของการพึ่งพาภายในไดเร็กทอรีเดียว แต่ไม่มี
มีความพยายามอย่างจริงจังในการทำงานระหว่างไดเร็กทอรี แม้ว่าการพึ่งพาอาศัยกันจะเป็น
ทำงานอย่างถูกต้อง ให้อาศัยการเปรียบเทียบการประทับเวลาง่าย ๆ เพื่อตรวจสอบว่า
ไฟล์ล้าสมัยเกี่ยวกับผู้ที่อยู่ในความอุปการะโดยทั่วไปไม่เพียงพอสำหรับ
กำหนดว่าเมื่อใดควรสร้างไฟล์ใหม่ หากไลบรารีภายนอก เช่น is
สร้างใหม่แล้ว ``snapped'' เข้าที่ การประทับเวลาในไฟล์ที่สร้างขึ้นใหม่อาจ
ควรจะเร็วกว่าการสร้างในท้องถิ่นครั้งสุดท้าย เพราะมันถูกสร้างขึ้นก่อนที่มันจะปรากฏให้เห็น
ตัวแปร สร้าง
Make จัดเตรียมสิ่งอำนวยความสะดวกที่จำกัดสำหรับการจัดการบิลด์ตัวแปร ด้วยการขยายพันธุ์
ของแพลตฟอร์มฮาร์ดแวร์และความจำเป็นในการแก้จุดบกพร่องกับโค้ดที่ปรับให้เหมาะสม ความสามารถในการ
สร้างตัวแปรเหล่านี้ได้อย่างง่ายดายเป็นสิ่งจำเป็น ที่สำคัญกว่านั้น ถ้าตัวแปรถูกสร้างขึ้น มัน
เป็นสิ่งสำคัญที่จะสามารถแยกความแตกต่างหรือเพื่อให้สามารถทำซ้ำได้
ต้นฉบับหรือตัวแปรตามต้องการ ทำให้แยกบิลด์ออกเป็น .ยากมาก
ไดเร็กทอรีบิลด์หลายไดเร็กทอรีแยกจากแหล่งที่มา และถ้าไม่ใช้เทคนิคนี้
แทบจะเป็นไปไม่ได้เลยที่จะรับประกันว่าตัวแปรที่มีอยู่ใน
ต้นไม้โดยไม่ต้องอาศัยการสร้างใหม่ทั้งหมด
คลัง
Make ให้การสนับสนุนอย่างจำกัดสำหรับการสร้างซอฟต์แวร์จากโค้ดที่มีอยู่ในa
โครงสร้างไดเร็กทอรีที่เก็บส่วนกลาง คุณสมบัติ VPATH ของ GNU make (และอื่น ๆ
ทำให้การใช้งาน) มีวัตถุประสงค์เพื่อให้สิ่งนี้ แต่ใช้งานไม่ได้ตามที่คาดไว้: it
เปลี่ยนเส้นทางของไฟล์เป้าหมายเป็นชื่อ VPATH เร็วเกินไปในการวิเคราะห์ ดังนั้น
ค้นหาการพึ่งพาทั้งหมดในไดเร็กทอรี VPATH เพื่อให้แน่ใจว่าการพัฒนาที่ถูกต้อง
บิลด์ มันเป็นสิ่งสำคัญที่จะสามารถสร้างไฟล์ในไดเร็กทอรี build โลคัลและ have
ไฟล์ใดๆ ในที่เก็บโค้ด (ไดเร็กทอรี VPATH ในเงื่อนไข make) ที่ขึ้นอยู่กับ local
ไฟล์ได้รับการสร้างใหม่อย่างถูกต้อง สิ่งนี้เป็นไปไม่ได้ด้วย VPATH หากไม่มีการเข้ารหัสจำนวนมาก
ความรู้พื้นที่เก็บข้อมูลที่ซับซ้อนโดยตรงใน makefiles
การเก็บรักษา it ง่าย
มีการกล่าวถึงปัญหาบางประการเกี่ยวกับ make ข้างต้น ในนี้และต่อไป
เราจะแนะนำจุดด้อยและแสดงให้เห็นว่าปัญหาเหล่านี้ได้รับการแก้ไขอย่างไร
Perl สคริปต์
ข้อเสียคือใช้ Perl นั่นคือ สคริปต์ข้อเสีย--ที่ถูกเกณฑ์ทหาร และ สร้าง ไฟล์เทียบเท่า
ไปยัง Makefile or ทำไฟล์- ทั้งหมดเขียนด้วยภาษา Perl สิ่งนี้ให้ประโยชน์ทันที: the
ภาษาสำหรับเขียนสคริปต์เป็นภาษาที่คุ้นเคย แม้ว่าคุณจะไม่ได้เป็น Perl
โปรแกรมเมอร์ มันช่วยให้รู้ว่า Perl เป็นเพียงภาษาประกาศธรรมดาๆ
ด้วยการควบคุมที่ชัดเจนและความหมายที่คุ้นเคย มันมีตัวแปรที่ทำงาน
โดยพื้นฐานแล้วคือวิธีที่คุณคาดหวัง รูทีนย่อย โฟลว์ของการควบคุม และอื่นๆ ที่นั่น
ไม่มีไวยากรณ์พิเศษสำหรับข้อเสีย การใช้ Perl เป็นภาษาสคริปต์
ลดความซับซ้อนของงานในการแสดงวิธีแก้ปัญหาที่เหมาะสมกับความซับซ้อนมักจะ
ความต้องการของบิลด์
สวัสดี โลก!
เพื่อเริ่มต้นการสนทนาต่อไปนี้ นี่คือวิธีที่คุณสามารถสร้าง สวัสดี โลก! C
แอปพลิเคชันที่มีข้อเสีย:
$env = ข้อเสียใหม่ ();
โปรแกรม $env 'hello', 'hello.c';
หากคุณติดตั้งสคริปต์นี้ในไดเร็กทอรี ให้ตั้งชื่อสคริปต์ สร้างและสร้างไฟล์
สวัสดีซี ไฟล์ต้นฉบับในไดเร็กทอรีเดียวกัน จากนั้นคุณสามารถพิมพ์ `cons hello' เพื่อสร้าง
แอพลิเคชัน
% ข้อเสีย สวัสดี
cc -c สวัสดี.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
การก่อสร้าง สภาพแวดล้อม
การทำให้เข้าใจง่ายที่สำคัญของข้อเสียคือแนวคิดของ a การก่อสร้าง สิ่งแวดล้อม. การก่อสร้าง
สภาพแวดล้อมคือ วัตถุ โดดเด่นด้วยชุดของคู่คีย์/ค่าและชุดของ วิธีการ
เพื่อที่จะบอก Cons ว่าจะสร้างอะไรขึ้นมา คุณต้องเรียกใช้วิธีที่เหมาะสมผ่าน an
สภาพแวดล้อมการก่อสร้างที่เหมาะสม พิจารณาตัวอย่างต่อไปนี้:
$env = ข้อเสียใหม่ (
CC => 'gcc',
LIBS => 'libworld.a'
);
โปรแกรม $env 'hello', 'hello.c';
ในกรณีนี้ แทนที่จะใช้สภาพแวดล้อมการก่อสร้างเริ่มต้น ตามที่เป็นอยู่ เรามี
แทนที่ค่าของ `CC' เพื่อให้ใช้ GNU C Compiler ที่เทียบเท่ากันแทน ตั้งแต่
เวอร์ชั่นนี้ของ สวัสดี โลก! ต้องมีห้องสมุด libworld.a, เราได้ระบุไว้ว่า ใดๆ
โปรแกรมที่เชื่อมโยงในสภาพแวดล้อมนี้ควรเชื่อมโยงกับไลบรารีนั้น ถ้าห้องสมุด
มีอยู่แล้ว ดี และดี แต่ถ้าไม่มี เราก็จะต้องรวมข้อความว่า:
ห้องสมุด $env 'libworld', 'world.c';
ตอนนี้ ถ้าคุณพิมพ์ 'cons สวัสดี' ไลบรารีจะถูกสร้างขึ้นก่อนที่โปรแกรมจะลิงก์ และ
แน่นอน `gcc' จะถูกใช้เพื่อคอมไพล์ทั้งสองโมดูล:
% ข้อเสีย สวัสดี
gcc -c สวัสดี.c -o สวัสดี.o
gcc -c world.c -o world.o
ar libworld.a world.o
ar: การสร้าง libworld.a
ranlib libworld.a
gcc -o สวัสดี สวัสดี.o libworld.a
อัตโนมัติ และ สมบูรณ์ เมืองขึ้น การวิเคราะห์
ด้วยข้อเสีย การพึ่งพาจะได้รับการจัดการโดยอัตโนมัติ ต่อจากตัวอย่างก่อนหน้า หมายเหตุ
ว่าเมื่อเราปรับเปลี่ยน โลก.ค, โลก.o ถูกคอมไพล์ใหม่ libworld.a สร้างขึ้นใหม่และ สวัสดี
เชื่อมโยงใหม่:
% vi world.ค
[แก้ไข]
% ข้อเสีย สวัสดี
gcc -c world.c -o world.o
ar libworld.a world.o
ar: การสร้าง libworld.a
ranlib libworld.a
gcc -o สวัสดี สวัสดี.o libworld.a
นี่เป็นตัวอย่างที่ค่อนข้างง่าย: ข้อเสีย ``รู้'' โลก.o ขึ้นอยู่กับ โลก.ค, เพราะ
การพึ่งพาได้รับการตั้งค่าอย่างชัดเจนโดยวิธี "ไลบรารี" มันยังรู้อีกด้วยว่า libworld.a
ขึ้นอยู่กับ โลก.o และที่ สวัสดี ขึ้นอยู่กับ libworld.aทั้งหมดด้วยเหตุผลที่คล้ายคลึงกัน
ตอนนี้ปรากฎว่า สวัสดีซี รวมถึงไฟล์คำจำกัดความของอินเตอร์เฟส world.h:
% emacs world.h
[แก้ไข]
% ข้อเสีย สวัสดี
gcc -c สวัสดี.c -o สวัสดี.o
gcc -o สวัสดี สวัสดี.o libworld.a
คอนรู้ได้ยังไงว่า สวัสดีซี รวมถึง world.hและที่ สวัสดีโอ จึงต้อง
เรียบเรียงใหม่? สำหรับตอนนี้พอจะพูดได้ว่าเมื่อพิจารณาแล้วจะได้หรือไม่ สวัสดีโอ ขึ้น-
จนถึงปัจจุบัน Cons เรียกใช้เครื่องสแกนสำหรับการพึ่งพา สวัสดีซี. เครื่องสแกนนี้ระบุ
รวมไฟล์โดย สวัสดีซี เพื่อสร้างรายการการพึ่งพาเพิ่มเติมนอกเหนือจากนั้น
ทำให้ชัดเจนโดยสคริปต์ Cons กระบวนการนี้เป็นแบบเรียกซ้ำ: ไฟล์ใดๆ ที่รวมโดย
ไฟล์ที่รวมไว้จะถูกสแกนด้วย
ไม่แพงนี่? คำตอบคือ -- ขึ้นอยู่กับ หากคุณสร้างระบบขนาดใหญ่เต็มรูปแบบ
เวลาในการสแกนไม่มีนัยสำคัญ หากคุณสร้างระบบขนาดใหญ่ขึ้นใหม่ ข้อเสียจะ
ใช้เวลาพอสมควรคิดเกี่ยวกับมันก่อนที่จะตัดสินใจว่าไม่มีอะไรต้อง
เสร็จสิ้น (แม้ว่าจะไม่จำเป็นต้องใช้เวลานานกว่าที่ทำ!) ข่าวดีก็คือข้อด้อยทำให้
ง่ายมากที่จะย่อยการสร้างของคุณอย่างชาญฉลาด เมื่อคุณกำลังทำงานกับการเปลี่ยนแปลงที่แปลเป็นภาษาท้องถิ่น
อัตโนมัติ ทั่วโลก สร้าง ลำดับ
เนื่องจากข้อเสียทำการวิเคราะห์การพึ่งพาอาศัยกันอย่างสมบูรณ์และแม่นยำ และทำสิ่งนี้ทั่วโลกเพื่อ
บิลด์ทั้งหมด Cons สามารถใช้ข้อมูลนี้เพื่อควบคุม .ได้อย่างเต็มที่ ลำดับ
ของงานสร้าง ลำดับนี้เห็นได้ชัดในตัวอย่างข้างต้น และเทียบเท่ากับอะไร
คุณคาดหวังสำหรับการสร้างโดยให้การอ้างอิงเต็มรูปแบบ ด้วยข้อเสีย สิ่งนี้จะขยายออกไป
บิลด์แบบหลายไดเร็กทอรีที่ใหญ่กว่าเล็กน้อย เป็นผลให้ความซับซ้อนทั้งหมดที่เกี่ยวข้อง
เพื่อให้แน่ใจว่าบิลด์ถูกจัดระเบียบอย่างถูกต้อง - รวมถึง multi-pass hierarchical
สร้าง--ถูกกำจัด เราจะหารือเรื่องนี้เพิ่มเติมในหัวข้อถัดไป
การก่อสร้าง ใหญ่ ต้นไม้ -- นิ่ง เพียงแค่ as ง่าย
A ลำดับชั้น of สร้าง สคริปต์
บิลด์ที่ใหญ่กว่า ใน Cons ถูกจัดระเบียบโดยการสร้างลำดับชั้นของ สร้าง สคริปต์. ที่ด้านบน
ของต้นไม้มีอักษรชื่อว่า สร้าง. สคริปต์ที่เหลือตามแบบแผนคือ
ที่เรียกว่า ที่ถูกเกณฑ์ทหาร. สคริปต์เหล่านี้เชื่อมต่อเข้าด้วยกันอย่างง่าย ๆ โดย "บิลด์"
คำสั่ง "ส่งออก" และ "นำเข้า"
พื้นที่ สร้าง คำสั่ง
คำสั่ง `Build' รับรายการของ ที่ถูกเกณฑ์ทหาร ชื่อไฟล์และจัดให้เป็น
รวมอยู่ในการสร้าง ตัวอย่างเช่น:
สร้าง qw(
ไดรเวอร์/จอแสดงผล/เกณฑ์
ไดรเวอร์/เมาส์/ทหารเกณฑ์
parser/เกณฑ์
ค่าสาธารณูปโภค/ทหารเกณฑ์
);
นี่คือลำดับชั้นสองระดับอย่างง่ายของสคริปต์การสร้าง: บริษัท ย่อยทั้งหมด ที่ถูกเกณฑ์ทหาร ไฟล์
ถูกกล่าวถึงในระดับบนสุด สร้าง ไฟล์. สังเกตว่าไม่ใช่ไดเร็กทอรีทั้งหมดในทรี
จำเป็นต้องมีการสร้างสคริปต์ที่เกี่ยวข้องกับพวกเขา
นอกจากนี้ยังสามารถเขียนเป็นสคริปต์หลายระดับได้ ตัวอย่างเช่น สร้าง ไฟล์อาจ
มีคำสั่งนี้:
สร้าง qw(
parser/เกณฑ์
คนขับรถ/ทหารเกณฑ์
ค่าสาธารณูปโภค/ทหารเกณฑ์
);
และ ที่ถูกเกณฑ์ทหาร แฟ้มใน ไดรเวอร์ ไดเรกทอรีอาจมีสิ่งนี้:
สร้าง qw(
แสดง/เกณฑ์
เมาส์/ทหารเกณฑ์
);
ประสบการณ์แสดงให้เห็นว่ารูปแบบเดิมเข้าใจง่ายขึ้นเล็กน้อยเนื่องจาก
ต้นไม้ก่อสร้างทั้งหมดวางอยู่ตรงหน้าคุณที่ระดับบนสุด รูปแบบไฮบริดคือ
เป็นไปได้เช่นกัน ส่วนประกอบที่บำรุงรักษาแยกต่างหากซึ่งจำเป็นต้องรวมเข้ากับ a
ตัวอย่างเช่น build tree อาจเกี่ยวโยงกับ build tree ในที่เดียว แต่ให้นิยามของตัวมันเอง
ลำดับชั้นการก่อสร้าง
โดยค่าเริ่มต้น ข้อเสีย จะไม่เปลี่ยนไดเร็กทอรีการทำงานเป็นไดเร็กทอรีที่มี a
บริษัท สาขา ที่ถูกเกณฑ์ทหาร รวมไฟล์. ลักษณะการทำงานนี้สามารถเปิดใช้งานสำหรับบิลด์โดย
ระบุในระดับบนสุด สร้าง ไฟล์:
Conscript_chdir 1;
เมื่อเปิดใช้งาน Cons จะเปลี่ยนเป็น บริษัท ย่อย ที่ถูกเกณฑ์ทหาร ไฟล์ที่มีไดเร็กทอรี
ขณะอ่านไฟล์นั้นแล้วเปลี่ยนกลับไปที่ไดเร็กทอรีระดับบนสุดเมื่อไฟล์
ได้รับการประมวลผล
คาดว่าลักษณะการทำงานนี้จะกลายเป็นค่าเริ่มต้นในข้อเสียบางรุ่นในอนาคต
เพื่อเตรียมพร้อมสำหรับการเปลี่ยนแปลงนี้ บิลด์ที่คาดว่า Cons จะยังคงอยู่ที่ด้านบนสุดของบิลด์
ในขณะที่อ่านใน บริษัท ย่อย ที่ถูกเกณฑ์ทหาร ไฟล์ควรปิดการใช้งานคุณสมบัตินี้อย่างชัดเจนเป็น
ดังต่อไปนี้:
Conscript_chdir 0;
ญาติ, ญาติยอด, และ แน่นอน ไฟล์ ชื่อ
คุณอาจสังเกตเห็นว่าชื่อไฟล์ที่ระบุในคำสั่ง Build สัมพันธ์กับ
ตำแหน่งของสคริปต์ที่เรียกใช้ โดยทั่วไปสิ่งนี้เป็นจริงสำหรับชื่อไฟล์อื่น
ข้อโต้แย้งของคำสั่งอื่น ๆ เช่นกัน แม้ว่าเราอาจจะพูดถึงที่นี่เช่นกันว่าถ้าคุณเริ่ม
ชื่อไฟล์ที่มีเครื่องหมายแฮช ``#'' จากนั้นไฟล์นั้นจะถูกตีความโดยสัมพันธ์กับด้านบน-
ไดเร็กทอรีระดับ (โดยที่ สร้าง ไฟล์อยู่) และไม่น่าแปลกใจเลยที่ถ้าคุณเริ่มทำ
ด้วย ``/'' จะถือว่าเป็นชื่อพาธสัมบูรณ์ สิ่งนี้เป็นจริงแม้ในระบบ
ซึ่งใช้แบ็กสแลชแทนที่จะเป็นสแลชไปข้างหน้าเพื่อตั้งชื่อพาธสัมบูรณ์
การใช้ โมดูล in สร้าง สคริปต์
คุณสามารถดึงโมดูลเข้าในแต่ละ ที่ถูกเกณฑ์ทหาร ไฟล์โดยใช้ Perl ปกติ `use' หรือ `require'
งบ:
ใช้ภาษาอังกฤษ
ต้องการ My::Module;
`use' หรือ `require' แต่ละครั้งจะมีผลกับสิ่งเดียวเท่านั้น ที่ถูกเกณฑ์ทหาร ไฟล์ที่ปรากฎ ในการใช้ a
โมดูลหลายตัว ที่ถูกเกณฑ์ทหาร คุณต้องใส่คำสั่ง `use' หรือ `require' ในแต่ละไฟล์
หนึ่งที่ต้องการโมดูล
ขอบเขต of ตัวแปร
ระดับบนสุด สร้าง ไฟล์และทั้งหมด ที่ถูกเกณฑ์ทหาร ไฟล์เริ่มต้นชีวิตใน Perl . ที่แยกจากกัน
บรรจุภัณฑ์ จุดด้อย ควบคุมตารางสัญลักษณ์สำหรับแพ็คเกจเพื่อให้ตารางสัญลักษณ์สำหรับ
แต่ละสคริปต์ว่างเปล่า ยกเว้น สร้าง ไฟล์ซึ่งได้รับบางบรรทัดคำสั่ง
อาร์กิวเมนต์ ตัวแปรทั้งหมดที่ตั้งค่าหรือใช้จึงถูกกำหนดโดยสคริปต์
ตัวเอง -- ไม่ใช่โดยสคริปต์ภายนอกบางตัว
ตัวแปรสามารถระบุได้อย่างชัดเจน นำเข้า โดยสคริปต์จากสคริปต์หลัก นำเข้า a
ตัวแปรก็ต้องเป็น ส่งออก โดยผู้ปกครองและเริ่มต้น (มิฉะนั้นข้อผิดพลาด
จะเกิดขึ้น)
พื้นที่ ส่งออก คำสั่ง
คำสั่ง `Export' ถูกใช้ในตัวอย่างต่อไปนี้:
$env = ข้อเสียใหม่ ();
$INCLUDE = "#ส่งออก/รวม";
$LIB = "#ส่งออก/lib";
ส่งออก qw ( env รวม LIB );
สร้าง qw( util/Conscript );
ค่าของตัวแปรอย่างง่ายที่กล่าวถึงในรายการ "ส่งออก" จะถูกแยกออกไป
โดยคำสั่ง `สร้าง' ที่ตามมาใดๆ คำสั่ง `Export' จะส่งออกเฉพาะ Perl เกลา
ตัวแปร กล่าวคือ ตัวแปรที่ชื่อขึ้นต้นด้วย `$' ตัวแปร วัตถุ เป็นต้น
สามารถส่งออกได้โดยการอ้างอิง - แต่สคริปต์ทั้งหมดจะอ้างถึงวัตถุเดียวกันและสิ่งนี้
วัตถุควรได้รับการพิจารณาให้อ่านอย่างเดียวโดยสคริปต์ย่อยและโดยต้นฉบับ
สคริปต์การส่งออก อย่างไรก็ตาม การกำหนดค่าใหม่ให้กับสเกลาร์ที่ส่งออกนั้นเป็นที่ยอมรับได้
ตัวแปร -- ที่จะไม่เปลี่ยนตัวแปรอ้างอิงที่อ้างอิง ลำดับนี้สำหรับ
ตัวอย่าง ไม่เป็นไร:
$env = ข้อเสียใหม่ ();
ส่งออก qw ( env รวม LIB );
สร้าง qw( util/Conscript );
$env = ข้อเสียใหม่ (CFLAGS => '-O');
สร้าง qw( อื่นๆ/เกณฑ์ );
ไม่สำคัญว่าตัวแปรจะถูกตั้งค่าก่อนหรือหลังคำสั่ง `Export' ดิ
สิ่งสำคัญคือค่าของตัวแปรในขณะที่ดำเนินการคำสั่ง `Build'
นี่คือสิ่งที่ได้รับกระรอกออกไป คำสั่ง 'ส่งออก' ที่ตามมาใดๆ ก็ตาม
ทำให้เป็นโมฆะก่อน: คุณต้องพูดถึงตัวแปรทั้งหมดที่คุณต้องการส่งออกในแต่ละ
คำสั่ง 'ส่งออก'
พื้นที่ นำเข้า คำสั่ง
ตัวแปรที่ส่งออกโดยคำสั่ง "ส่งออก" สามารถนำเข้าสู่สคริปต์ย่อยได้โดยใช้คำสั่ง
คำสั่ง 'นำเข้า' สคริปต์ย่อยนำเข้าตัวแปรโดยตรงจาก .เสมอ
สคริปต์ที่เหนือกว่า พิจารณาตัวอย่างนี้:
นำเข้า qw ( env INCLUDE );
สิ่งนี้ถูกกฎหมายก็ต่อเมื่อสคริปต์หลักส่งออกทั้ง `$env' และ `$INCLUDE' ยังต้อง
ได้ให้แต่ละค่าตัวแปรเหล่านี้ ได้สำหรับสคริปต์ย่อยเท่านั้น
นำเข้าชุดย่อยของตัวแปรที่ส่งออก (ในตัวอย่างนี้ `$LIB' ซึ่งส่งออกโดย
ตัวอย่างก่อนหน้าจะไม่ถูกนำเข้า)
ตัวแปรที่นำเข้าทั้งหมดจะถูกส่งออกซ้ำโดยอัตโนมัติ ดังนั้นลำดับ:
นำเข้า qw ( env INCLUDE );
สร้าง qw ( under-me/Conscript );
จะจัดหาทั้ง `$env' และ `$INCLUDE' ให้กับไฟล์ย่อย ถ้าต้องเป็น `$env' เท่านั้น
ส่งออกแล้วสิ่งต่อไปนี้จะเพียงพอ:
นำเข้า qw ( env INCLUDE );
ส่งออก qw ( env );
สร้าง qw ( under-me/Conscript );
จำเป็นต้องพูด ตัวแปรอาจถูกแก้ไขในเครื่องก่อนที่จะเรียกใช้ `สร้าง' บน
สคริปต์ย่อย
สร้าง ต้นฉบับ การประเมินผล ใบสั่ง
ข้อจำกัดเพียงอย่างเดียวในการจัดลำดับของสคริปต์บิลด์คือสคริปต์ที่เหนือกว่าคือ
ประเมินก่อนสคริปต์ที่ด้อยกว่าของพวกเขา ระดับบนสุด สร้าง ไฟล์ เช่น is
ประเมินก่อน ตามด้วยสคริปต์ที่ด้อยกว่า นี่คือทั้งหมดที่คุณต้องรู้
เกี่ยวกับลำดับการประเมิน เนื่องจากโดยทั่วไปแล้วคำสั่งซื้อจะไม่เกี่ยวข้อง พิจารณาสิ่งต่อไปนี้
คำสั่ง `สร้าง':
สร้าง qw(
ไดรเวอร์/จอแสดงผล/เกณฑ์
ไดรเวอร์/เมาส์/ทหารเกณฑ์
parser/เกณฑ์
ค่าสาธารณูปโภค/ทหารเกณฑ์
);
เราได้เลือกให้ชื่อสคริปต์เรียงตามตัวอักษร เพราะนั่นคือที่สุด
สะดวกในการบำรุงรักษา การเปลี่ยนคำสั่งซื้อจะไม่ทำให้เกิดความแตกต่างกับ
สร้าง.
A รุ่น for ใช้งานร่วมกัน ไฟล์
เรื่อง ง่าย การประชุม
ในระบบซอฟต์แวร์ที่ซับซ้อนใดๆ วิธีการแบ่งปันผลิตภัณฑ์บิวด์จะต้อง
ที่จัดตั้งขึ้น. เราขอเสนอชุดอนุสัญญาแบบง่าย ๆ ที่นำไปใช้ได้เล็กน้อย
ข้อเสีย แต่ได้ผลมาก
กฎพื้นฐานคือกำหนดให้สร้างผลิตภัณฑ์ทั้งหมดที่ต้องแชร์ระหว่าง
ไดเร็กทอรีถูกแชร์ผ่านไดเร็กทอรีระดับกลาง เรามักจะเรียกสิ่งนี้ว่า
ส่งออกและในสภาพแวดล้อม C ให้ไดเร็กทอรีย่อยแบบธรรมดาของไดเร็กทอรีนี้
เช่น ประกอบด้วย, lib, ถังฯลฯ
ไดเร็กทอรีเหล่านี้ถูกกำหนดโดยระดับบนสุด สร้าง ไฟล์. ง่ายๆ สร้าง ไฟล์
a สวัสดี โลก! แอปพลิเคชันที่จัดระเบียบโดยใช้หลายไดเร็กทอรีอาจมีลักษณะดังนี้:
# สร้างไฟล์สำหรับ Hello, World!
# ที่จะวางผลิตภัณฑ์ที่ใช้ร่วมกันของเราทั้งหมด
$EXPORT = '#export';
ส่งออก qw ( CONS INCLUDE LIB BIN );
# ไดเร็กทอรีมาตรฐานสำหรับการแบ่งปันผลิตภัณฑ์
$INCLUDE = "$ส่งออก/รวม";
$LIB = "$ส่งออก/lib";
$BIN = "$ส่งออก/ถัง";
#สภาพแวดล้อมการก่อสร้างที่ได้มาตรฐาน
$CONS = ข้อเสียใหม่ (
CPPPATH => $INCLUDE, # รวมพาธสำหรับการรวบรวม C
LIBPATH => $LIB, # Library path สำหรับเชื่อมโยงโปรแกรม
LIBS => '-lworld', # รายการไลบรารีมาตรฐาน
);
สร้าง qw(
สวัสดี/ทหารเกณฑ์
โลก/ทหารเกณฑ์
);
พื้นที่ โลก ไดเรกทอรีของ ที่ถูกเกณฑ์ทหาร ไฟล์มีลักษณะดังนี้:
# ไฟล์ Conscript สำหรับไดเร็กทอรี world
นำเข้า qw ( CONS INCLUDE LIB );
# ติดตั้งผลิตภัณฑ์ของไดเรกทอรีนี้
ติดตั้ง $CONS $LIB, 'libworld.a';
ติดตั้ง $CONS $INCLUDE, 'world.h';
#สินค้าภายใน
ไลบรารี $CONS 'libworld.a', 'world.c';
และ สวัสดี ไดเรกทอรีของ ที่ถูกเกณฑ์ทหาร ไฟล์มีลักษณะดังนี้:
# ไฟล์ Conscript สำหรับไดเร็กทอรี hello
นำเข้า qw ( CONS BIN );
#สินค้าส่งออก
ติดตั้ง $CONS $BIN 'สวัสดี';
#สินค้าภายใน
โปรแกรม $CONS 'hello', 'hello.c';
เพื่อสร้าง สวัสดี โลก! โปรแกรมที่มีโครงสร้างไดเร็กทอรีนี้ ไปที่ระดับบนสุด
ไดเร็กทอรี และเรียกใช้ `cons' ด้วยอาร์กิวเมนต์ที่เหมาะสม ในตัวอย่างต่อไปนี้ เรา
บอก Cons ให้สร้างไดเร็กทอรี ส่งออก. ในการสร้างไดเร็กทอรี Cons จะสร้างซ้ำทั้งหมด
ผลิตภัณฑ์ที่รู้จักภายในไดเร็กทอรีนั้น (เฉพาะในกรณีที่จำเป็นต้องสร้างใหม่) ถ้ามีของ
ผลิตภัณฑ์เหล่านั้นขึ้นอยู่กับผลิตภัณฑ์อื่น ๆ ในไดเร็กทอรีอื่น ๆ จากนั้นจะถูกสร้างขึ้น
เกินไป
% ข้อเสียการส่งออก
ติดตั้ง world/world.h เป็น export/include/world.h
cc -Iexport/include -c สวัสดี/hello.c -o สวัสดี/hello.o
ซีซี -Iexport/รวม -c world/world.c -o world/world.o
ar r world/libworld.a world/world.o
ar: การสร้างโลก/libworld.a
ranlib world/libworld.a
ติดตั้ง world/libworld.a เป็น export/lib/libworld.a
cc -o สวัสดี/สวัสดี สวัสดี/hello.o -Lexport/lib -lworld
ติดตั้งสวัสดี/สวัสดีเป็นการส่งออก/ถัง/สวัสดี
ทำความสะอาด เข้าใจได้ ตำแหน่งอิสระ สคริปต์
คุณจะสังเกตได้ว่าทั้งสอง ที่ถูกเกณฑ์ทหาร ไฟล์สะอาดมากและตรงประเด็น พวกเขาเพียงแค่
ระบุผลิตภัณฑ์ของไดเร็กทอรีและวิธีสร้างผลิตภัณฑ์เหล่านั้น คำแนะนำในการสร้าง
น้อยที่สุด: ระบุสภาพแวดล้อมการก่อสร้างที่จะใช้ ชื่อผลิตภัณฑ์
และชื่อของอินพุต โปรดทราบด้วยว่าสคริปต์นั้นไม่ขึ้นกับตำแหน่ง: ถ้าคุณ
ต้องการจัดระเบียบต้นไม้ต้นทางของคุณใหม่ คุณมีอิสระที่จะทำเช่นนั้น: คุณเพียงแค่ต้องเปลี่ยน
สร้าง ไฟล์ (ในตัวอย่างนี้) เพื่อระบุตำแหน่งใหม่ของ ที่ถูกเกณฑ์ทหาร ไฟล์
การใช้แผนผังการส่งออกทำให้เป้าหมายนี้ง่ายขึ้น
โปรดทราบด้วยว่า Cons ดูแลรายละเอียดเล็กน้อยให้คุณอย่างไร ทั้งหมด ส่งออก ไดเรกทอรีสำหรับ
ตัวอย่างถูกสร้างขึ้นโดยอัตโนมัติ และไฟล์ที่ติดตั้งนั้นเชื่อมโยงอย่างหนักกับ
ไดเรกทอรีส่งออกตามลำดับเพื่อประหยัดพื้นที่และเวลา ความใส่ใจในรายละเอียดนี้ช่วยประหยัด
ทำงานมาก และทำให้ง่ายต่อการสร้างสคริปต์ที่เรียบง่ายและบำรุงรักษาได้
แยก แหล่ง และ สร้าง ต้นไม้
มักจะแนะนำให้เก็บไฟล์ที่ได้รับจากบิลด์แยกจากไฟล์
ไฟล์ต้นฉบับ สิ่งนี้ทำให้ง่ายต่อการติดตามว่าไฟล์ต้นฉบับคืออะไรและ
ยังทำให้ง่ายต่อการจัดการ ตัวแปร บิลด์ โดยเฉพาะอย่างยิ่งหากคุณต้องการบิลด์ตัวแปร
ที่จะอยู่ร่วมกัน
แยก สร้าง และ แหล่ง ไดเรกทอรี การใช้ ลิงค์ คำสั่ง
ข้อเสียมีกลไกง่ายๆ ที่จัดการข้อกำหนดเหล่านี้ทั้งหมด 'ลิงค์'
คำสั่งถูกเรียกในตัวอย่างนี้:
ลิงค์ 'build' => 'src';
ไดเร็กทอรีที่ระบุจะถูก ``ลิงก์'' ไปยังไดเร็กทอรีต้นทางที่ระบุ เอาเป็นว่า
ที่คุณตั้งค่าไดเร็กทอรีต้นทาง สิ่งอำนวยความสะดวกกับไดเร็กทอรีย่อย โลก และ สวัสดี ด้านล่างมัน
เช่นเดียวกับในตัวอย่างก่อนหน้า จากนั้นคุณสามารถแทนที่บรรทัดการสร้างดั้งเดิม
ต่อไปนี้:
สร้าง qw(
สร้าง/โลก/เกณฑ์
สร้าง/สวัสดี/เกณฑ์
);
สังเกตว่าคุณปฏิบัติต่อ ที่ถูกเกณฑ์ทหาร ไฟล์ราวกับว่ามีอยู่ในไดเร็กทอรีบิลด์ ตอนนี้ถ้า
คุณพิมพ์คำสั่งเหมือนเดิม คุณจะได้ผลลัพธ์ดังต่อไปนี้:
% ข้อเสียการส่งออก
ติดตั้ง build/world/world.h เป็น export/include/world.h
ซีซี -Iexport/include -c build/hello/hello.c -o build/hello/hello.o
cc -Iexport/include -c build/world/world.c -o build/world/world.o
ar build/world/libworld.a build/world/world.o
ar: การสร้าง build/world/libworld.a
ranlib build/world/libworld.a
ติดตั้ง build/world/libworld.a เป็น export/lib/libworld.a
cc -o build/hello/hello build/hello/hello.o -Lexport/lib -lworld
ติดตั้ง build/hello/hello เป็น export/bin/hello
อีกครั้งที่ Cons ได้ดูแลรายละเอียดให้คุณแล้ว โดยเฉพาะอย่างยิ่งคุณจะสังเกตเห็นว่าทั้งหมด
บิลด์เสร็จสิ้นโดยใช้ไฟล์ต้นฉบับและไฟล์อ็อบเจ็กต์จากไดเร็กทอรีบิลด์ สำหรับ
ตัวอย่าง, สร้าง/โลก/world.o เรียบเรียงจาก สร้าง/โลก/world.cและ
ส่งออก/รวม/world.h ติดตั้งจาก สร้าง/โลก/world.h. สิ่งนี้สำเร็จได้มากที่สุด
ระบบโดยง่ายของ ``ยาก'' เชื่อมโยงไฟล์ที่ต้องการจากแต่ละแหล่ง
ไดเร็กทอรีลงในไดเร็กทอรี build ที่เหมาะสม
ลิงก์ได้รับการดูแลรักษาอย่างถูกต้องโดย Cons ไม่ว่าคุณจะทำอะไรกับไดเร็กทอรีต้นทาง
หากคุณแก้ไขไฟล์ต้นฉบับ โปรแกรมแก้ไขของคุณอาจทำสิ่งนี้ ``แทนที่'' หรืออาจเปลี่ยนชื่อไฟล์
ก่อนแล้วสร้างไฟล์ใหม่ ในกรณีหลัง ฮาร์ดลิงก์จะหายไป ข้อเสียจะ
ตรวจพบเงื่อนไขนี้ในครั้งต่อไปที่จำเป็นต้องใช้ไฟล์ต้นฉบับ และจะเชื่อมโยงอีกครั้ง
อย่างเหมาะสม.
นอกจากนี้ คุณจะสังเกตเห็นว่า ไม่ ต้องมีการเปลี่ยนแปลงพื้นฐาน ที่ถูกเกณฑ์ทหาร
ไฟล์. และเราสามารถไปต่อได้ ดังที่เราจะเห็นในหัวข้อถัดไป
ตัวแปร สร้าง
สวัสดี โลก! for กล้วย และ ลูกพีช ระบบปฏิบัติการ
บิลด์ของ Variant ต้องการเพียงส่วนขยายอื่นที่เรียบง่าย มาดูตัวอย่างกัน
ข้อกำหนดเพื่ออนุญาตการสร้างสำหรับทั้งระบบปฏิบัติการ baNaNa และ peAcH ในกรณีนี้,
เรากำลังใช้ระบบไฟล์แบบกระจาย เช่น NFS เพื่อเข้าถึงระบบเฉพาะ และ
ต้องรวบรวมเพียงหนึ่งหรือระบบอื่น ๆ สำหรับการเรียกใช้
`ข้อเสีย' นี่เป็นวิธีหนึ่งที่เราสามารถตั้งค่า สร้าง ไฟล์ของเรา สวัสดี โลก!
แอพลิเคชัน
# สร้างไฟล์สำหรับ Hello, World!
die qq(ต้องระบุ OS) เว้นแต่ $OS = $ARG{OS};
die qq(OS ต้องเป็น "พีช" หรือ "กล้วย")
ถ้า $OS ne "peach" && $OS ne "banana";
# ที่จะวางผลิตภัณฑ์ที่ใช้ร่วมกันของเราทั้งหมด
$EXPORT = "#ส่งออก/$OS";
ส่งออก qw ( CONS INCLUDE LIB BIN );
# ไดเร็กทอรีมาตรฐานสำหรับการแบ่งปันผลิตภัณฑ์
$INCLUDE = "$ส่งออก/รวม";
$LIB = "$ส่งออก/lib";
$BIN = "$ส่งออก/ถัง";
#สภาพแวดล้อมการก่อสร้างที่ได้มาตรฐาน
$CONS = ข้อเสียใหม่ (
CPPPATH => $INCLUDE, # รวมพาธสำหรับการรวบรวม C
LIBPATH => $LIB, # Library path สำหรับเชื่อมโยงโปรแกรม
LIBS => '-lworld', # รายการไลบรารีมาตรฐาน
);
# $BUILD เป็นที่ที่เราจะได้มาซึ่งทุกสิ่ง
$BUILD = "#สร้าง/$OS";
# บอกข้อเสียว่าไฟล์ต้นฉบับของ $BUILD อยู่ที่ไหน
ลิงก์ $BUILD => 'src';
สร้าง (
"$สร้าง/สวัสดี/เกณฑ์",
"$BUILD/โลก/เกณฑ์",
);
ตอนนี้ถ้าเราเข้าสู่ระบบ peAcH เราก็สามารถสร้าง สวัสดี โลก! แอปพลิเคชันสำหรับสิ่งนั้น
แพลตฟอร์ม:
ข้อเสีย % การส่งออก OS=พีช
ติดตั้ง build/peach/world/world.h เป็น export/peach/include/world.h
cc -Iexport/peach/include -c build/peach/hello/hello.c -o build/peach/hello/hello.o
ซีซี -Iexport/peach/include -c build/peach/world/world.c -o build/peach/world/world.o
เป็น build/peach/world/libworld.a build/peach/world/world.o
ar: การสร้าง build/peach/world/libworld.a
ranlib build/peach/world/libworld.a
ติดตั้ง build/peach/world/libworld.a เป็น export/peach/lib/libworld.a
cc -o build/peach/hello/hello build/peach/hello/hello.o -Lexport/peach/lib -lworld
ติดตั้ง build/peach/hello/hello เป็น export/peach/bin/hello
รูปแบบต่างๆ on a ชุดรูปแบบ
รูปแบบอื่น ๆ ของรุ่นนี้เป็นไปได้ ตัวอย่างเช่น คุณอาจตัดสินใจว่าคุณต้องการ
เพื่อแยกไฟล์รวมของคุณออกเป็นไฟล์ที่ขึ้นอยู่กับแพลตฟอร์มและไฟล์ที่ไม่ขึ้นกับแพลตฟอร์ม
ในกรณีนี้ คุณต้องกำหนดทางเลือกอื่นสำหรับ `$INCLUDE' สำหรับขึ้นอยู่กับแพลตฟอร์ม
ไฟล์. ที่สุด ที่ถูกเกณฑ์ทหาร ไฟล์ที่สร้างโดยอิสระรวมถึงไฟล์จะ
ไม่ต้องเปลี่ยน
คุณอาจต้องการคอมไพล์ทั้งระบบของคุณด้วยการดีบักหรือการทำโปรไฟล์
ตัวอย่างเช่น เปิดใช้งาน คุณสามารถทำได้ด้วยตัวเลือกบรรทัดคำสั่งที่เหมาะสม เช่น
`ดีบัก=เปิด' จากนั้นจะถูกแปลเป็นแพลตฟอร์มเฉพาะที่เหมาะสม
ข้อกำหนดในการเปิดใช้งานการดีบัก (ซึ่งอาจรวมถึงการปิดการปรับให้เหมาะสมสำหรับ
ตัวอย่าง). คุณสามารถเลือกเปลี่ยนเนมสเปซสำหรับระบบประเภทต่างๆ เหล่านี้ได้
แต่อย่างที่เราเห็นในตอนต่อไปไม่ใช่ จำเป็น การทำเช่นนี้เนื่องจากข้อเสียคือสวย
ฉลาดในการสร้างสิ่งต่างๆ ขึ้นใหม่เมื่อคุณเปลี่ยนทางเลือก
ลายเซ็น
MD5 การเข้ารหัสลับ ลายเซ็น
เมื่อใดก็ตามที่ Cons สร้างไฟล์ที่ได้รับ มันจะเก็บ ลายเซ็น สำหรับไฟล์นั้น ลายเซ็น
ถูกเก็บไว้ในไฟล์แยกต่างหาก หนึ่งไฟล์ต่อไดเร็กทอรี หลังจากรวบรวมตัวอย่างก่อนหน้านี้แล้ว
.ฝากขาย แฟ้มใน สร้าง/พีช/โลก ไดเร็กทอรีมีลักษณะดังนี้:
world.o:834179303 23844c0b102ecdc0b4548d1cd1cbd8c6
libworld.a:834179304 9bf6587fa06ec49d864811a105222c00
ตัวเลขแรกคือการประทับเวลา สำหรับระบบ UNIX โดยทั่วไปคือจำนวน
วินาทีตั้งแต่วันที่ 1 มกราคม 1970 ค่าที่สองคือเช็คซัม MD5 ดิ ระบุความประสงค์หรือขอข้อมูลเพิ่มเติม ย่อยอาหาร
ขั้นตอนวิธี เป็นอัลกอริธึมที่กำหนดสตริงอินพุต คำนวณการเข้ารหัสที่แข็งแกร่ง
ลายเซ็นสำหรับสตริงนั้น เช็คซัม MD5 ที่เก็บไว้ใน .ฝากขาย ไฟล์เป็นผล a
ไดเจสต์ของข้อมูลการพึ่งพาทั้งหมดสำหรับไฟล์ที่ระบุ ตัวอย่างเช่น สำหรับ
โลก.o ไฟล์ซึ่งรวมถึงอย่างน้อย โลก.ค ไฟล์และไฟล์ส่วนหัวใด ๆ ที่ Cons
รู้เกี่ยวกับสิ่งนั้นรวมอยู่โดยตรงหรือโดยอ้อมโดย โลก.ค. ไม่เพียงเท่านั้น แต่ยัง
บรรทัดคำสั่งจริงที่ใช้ในการสร้าง โลก.o ยังถูกป้อนเข้าสู่การคำนวณของ
ลายเซ็น ในทำนองเดียวกัน libworld.a ได้รับลายเซ็นซึ่ง ``รวม'' ทั้งหมด
ลายเซ็นขององค์ประกอบ (และด้วยเหตุนี้ ลายเซ็นของ ของพวกเขา
องค์ประกอบ) เช่นเดียวกับบรรทัดคำสั่งที่สร้างไฟล์
ลายเซ็นของไฟล์ที่ไม่ได้รับจะถูกคำนวณโดยค่าเริ่มต้นโดยใช้ค่าปัจจุบัน
เวลาในการแก้ไขไฟล์และชื่อรายการของไฟล์ (เว้นแต่จะมี a
ปัจจุบัน .ฝากขาย รายการสำหรับไฟล์นั้น ซึ่งในกรณีนี้ จะใช้ลายเซ็นนั้น)
สังเกตว่าไม่จำเป็นต้องมีไฟล์ที่ได้รับมาขึ้นอยู่กับใด ๆ สร้าง or
ที่ถูกเกณฑ์ทหาร ไฟล์ -- หากการเปลี่ยนแปลงในไฟล์เหล่านี้ส่งผลต่อไฟล์ที่เป็นปัญหา ก็จะเป็น
สะท้อนโดยอัตโนมัติในลายเซ็น เนื่องจากส่วนที่เกี่ยวข้องของบรรทัดคำสั่งคือ
รวมอยู่ในลายเซ็น การเปลี่ยนแปลงที่ไม่เกี่ยวข้องจะไม่มีผลใดๆ
เมื่อ Cons พิจารณาว่าจะได้รับไฟล์ใดไฟล์หนึ่งหรือไม่ อันดับแรกจะคำนวณ
ลายเซ็นที่คาดไว้ของไฟล์ จากนั้นจะเปรียบเทียบเวลาแก้ไขล่าสุดของไฟล์กับ
เวลาที่บันทึกไว้ใน .ฝากขาย รายการหากมีอยู่ หากเวลาเหล่านี้ตรงกัน ดังนั้น
ลายเซ็นที่เก็บไว้ใน .ฝากขาย ไฟล์ถือว่าถูกต้อง หากไฟล์ก่อนหน้า
ลายเซ็นไม่ตรงกับลายเซ็นใหม่ที่คาดไว้ จากนั้นไฟล์จะต้องได้รับการสร้างใหม่
โปรดสังเกตว่าไฟล์จะถูกสร้างใหม่ทุกครั้งที่มีการเปลี่ยนแปลงไฟล์ที่ขึ้นต่อกัน ใน
โดยเฉพาะอย่างยิ่ง สังเกตว่า ใด เปลี่ยนเป็นเวลาแก้ไขของผู้อยู่ในอุปการะ (ไปข้างหน้าหรือ
ย้อนเวลากลับไป) จะบังคับให้คอมไพล์ไฟล์ที่ได้รับใหม่
การใช้ลายเซ็นเหล่านี้เป็นวิธีการที่ง่ายมาก มีประสิทธิภาพ และประสิทธิผลของ
การปรับปรุง -- อย่างมาก -- ความสามารถในการทำซ้ำของระบบ
เราจะสาธิตสิ่งนี้ด้วยตัวอย่างง่ายๆ:
# ง่าย ๆ "สวัสดีชาวโลก!" สร้างไฟล์
$CFLAGS = '-g' ถ้า $ARG{DEBUG} เท่ากับ 'เปิด';
$CONS = ข้อเสียใหม่ (CFLAGS => $CFLAGS);
โปรแกรม $CONS 'hello', 'hello.c';
สังเกตว่า Cons คอมไพล์ใหม่ในเวลาที่เหมาะสม:
% ข้อเสีย สวัสดี
cc -c สวัสดี.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
% ข้อเสีย สวัสดี
ข้อเสีย: "สวัสดี" เป็นข้อมูลล่าสุด
% ข้อเสีย DEBUG = สวัสดี
cc -g -c hello.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
% ข้อเสีย DEBUG = สวัสดี
ข้อเสีย: "สวัสดี" เป็นข้อมูลล่าสุด
% ข้อเสีย สวัสดี
cc -c สวัสดี.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
รหัส คลัง
องค์กรพัฒนาซอฟต์แวร์หลายแห่งจะมีไดเร็กทอรีที่เก็บส่วนกลางอย่างน้อยหนึ่งไดเร็กทอรี
ต้นไม้ที่มีซอร์สโค้ดปัจจุบันสำหรับหนึ่งหรือหลายโปรเจ็กต์ เช่นเดียวกับที่ได้รับ
ไฟล์อ็อบเจ็กต์ ไลบรารี และไฟล์เรียกทำงาน เพื่อลดการคอมไพล์ซ้ำโดยไม่จำเป็น
เป็นประโยชน์ในการใช้ไฟล์จากที่เก็บเพื่อสร้างซอฟต์แวร์การพัฒนา - สมมติว่า
แน่นอนว่าไม่มีไฟล์การพึ่งพาที่ใหม่กว่าอยู่ในแผนผังการสร้างในเครื่อง
กรุ
ข้อเสียมีกลไกในการระบุรายการที่เก็บรหัสที่จะค้นหา
ตามลำดับ สำหรับไฟล์ต้นฉบับและไฟล์ที่ได้รับที่ไม่พบในแผนผังไดเร็กทอรีบิวด์ในเครื่อง
บรรทัดต่อไปนี้ในa สร้าง file จะสั่งให้ Cons ดูก่อนภายใต้
/usr/การทดลอง/พื้นที่เก็บข้อมูล ไดเร็กทอรีแล้วภายใต้ /usr/ผลิตภัณฑ์/พื้นที่เก็บข้อมูล ไดเรกทอรี:
ที่เก็บ qw (
/usr/การทดลอง/พื้นที่เก็บข้อมูล
/usr/ผลิตภัณฑ์/พื้นที่เก็บข้อมูล
);
ไดเร็กทอรีที่เก็บที่ระบุอาจมีไฟล์ต้นฉบับ ไฟล์ที่ได้รับ (อ็อบเจ็กต์
ไลบรารีและไฟล์เรียกทำงาน) หรือทั้งสองอย่าง หากไม่มีไฟล์ในเครื่อง (ต้นทางหรือที่ได้รับ) ภายใต้
ไดเร็กทอรีที่ Cons ถูกดำเนินการ จากนั้นจะพบสำเนาแรกของไฟล์ชื่อเดียวกัน
ภายใต้ไดเร็กทอรีที่เก็บจะใช้เพื่อสร้างไฟล์ที่ได้รับในเครื่อง
ข้อเสีย รักษารายการไดเรกทอรีที่เก็บทั่วโลกไว้หนึ่งรายการ ข้อเสียจะกำจัด
ไดเร็กทอรีปัจจุบัน และไดเร็กทอรีที่ไม่มีอยู่ จากรายการ
หา สร้าง ไฟล์ in a กรุ
ข้อเสียก็จะค้นหา สร้าง และ ที่ถูกเกณฑ์ทหาร ไฟล์ในทรีที่เก็บหรือทรี
สิ่งนี้นำไปสู่สถานการณ์ไก่กับไข่: คุณมองต้นไม้ที่เก็บอย่างไร
สำหรับ สร้าง ไฟล์ถ้า สร้าง file จะบอกคุณว่าที่เก็บอยู่ที่ไหน? ที่จะได้รับ
รอบนี้ ที่เก็บอาจถูกระบุผ่านตัวเลือก `-R' บนบรรทัดคำสั่ง:
% ข้อเสีย -R /usr/experiment/repository -R /usr/product/repository
ไดเร็กทอรีที่เก็บใด ๆ ที่ระบุใน the สร้าง or ที่ถูกเกณฑ์ทหาร ไฟล์จะถูกต่อท้าย
ไปยังไดเร็กทอรีที่เก็บที่ระบุโดยตัวเลือกบรรทัดคำสั่ง `-R'
กรุ แหล่ง ไฟล์
หากซอร์สโค้ด (รวมถึง ที่ถูกเกณฑ์ทหาร ไฟล์) สำหรับเวอร์ชันไลบรารีของ สวัสดี
โลก! แอปพลิเคชัน C อยู่ในที่เก็บ (ไม่มีไฟล์ที่ได้รับ) ข้อเสียจะใช้
ไฟล์ต้นฉบับที่เก็บเพื่อสร้างโลคัลไฟล์อ็อบเจ็กต์และไฟล์เรียกทำงาน:
% ข้อเสีย -R /usr/src_only/repository สวัสดี
gcc -c /usr/src_only/repository/hello.c -o สวัสดี.o
gcc -c /usr/src_only/repository/world.c -o world.o
ar libworld.a world.o
ar: การสร้าง libworld.a
ranlib libworld.a
gcc -o สวัสดี สวัสดี.o libworld.a
การสร้างไฟล์ต้นฉบับในเครื่องจะทำให้ Cons สร้างไฟล์ที่ได้รับที่เหมาะสมใหม่หรือ
ไฟล์:
%ปิโกเวิลด์.ค
[แก้ไข]
% ข้อเสีย -R /usr/src_only/repository สวัสดี
gcc -c world.c -o world.o
ar libworld.a world.o
ar: การสร้าง libworld.a
ranlib libworld.a
gcc -o สวัสดี สวัสดี.o libworld.a
และการลบไฟล์ต้นฉบับในเครื่องจะทำให้ Cons เปลี่ยนกลับเป็นการสร้างที่ได้รับ
ไฟล์จากแหล่งเก็บข้อมูล:
%rm world.ค
% ข้อเสีย -R /usr/src_only/repository สวัสดี
gcc -c /usr/src_only/repository/world.c -o world.o
ar libworld.a world.o
ar: การสร้าง libworld.a
ranlib libworld.a
gcc -o สวัสดี สวัสดี.o libworld.a
กรุ ที่ได้มา ไฟล์
หากแผนผังที่เก็บมีไฟล์ที่ได้รับ (โดยปกติคือไฟล์อ็อบเจ็กต์ ไลบรารี หรือ
ไฟล์ปฏิบัติการ) จุดด้อยจะทำการคำนวณลายเซ็นตามปกติเพื่อตัดสินใจว่า
ไฟล์ที่เก็บเป็นข้อมูลล่าสุดหรือไฟล์ที่ได้รับต้องสร้างขึ้นในเครื่อง นี่หมายความว่า
เพื่อให้แน่ใจว่าการคำนวณลายเซ็นถูกต้อง ต้นไม้ที่เก็บต้องมี
.ฝากขาย ไฟล์ที่สร้างโดย Cons เมื่อสร้างไฟล์ที่ได้รับ
ซึ่งมักจะทำได้โดยการสร้างซอฟต์แวร์ในที่เก็บ (หรือ
หรือในไดเร็กทอรี build จากนั้นคัดลอกผลลัพธ์ไปยังที่เก็บ):
% cd /usr/all/ที่เก็บ
% ข้อเสีย สวัสดี
gcc -c สวัสดี.c -o สวัสดี.o
gcc -c world.c -o world.o
ar libworld.a world.o
ar: การสร้าง libworld.a
ranlib libworld.a
gcc -o สวัสดี สวัสดี.o libworld.a
(สิ่งนี้ปลอดภัยแม้ว่า สร้าง ไฟล์แสดงรายการ /usr/all/พื้นที่เก็บข้อมูล ไดเรกทอรีใน
คำสั่ง `Repository' เพราะ Cons จะลบไดเร็กทอรีปัจจุบันออกจาก repository
รายการ.)
ตอนนี้ถ้าเราต้องการสร้างสำเนาของแอปพลิเคชันด้วยตัวเราเอง สวัสดีซี ไฟล์ที่เราต้องการเท่านั้น
เพื่อสร้างไฟล์ต้นฉบับที่จำเป็นและใช้ตัวเลือก `-R' เพื่อให้ Cons ใช้ other
ไฟล์จากที่เก็บ:
% mkdir $HOME/build1
% ซีดี $HOME/build1
% เอ็ด สวัสดีค
[แก้ไข]
% ข้อเสีย -R /usr/all/repository สวัสดี
gcc -c สวัสดี.c -o สวัสดี.o
gcc -o สวัสดี hello.o /usr/all/repository/libworld.a
สังเกตว่าข้อเสียไม่ได้ใส่ใจที่จะสร้างท้องถิ่นขึ้นมาใหม่ libworld.a ห้องสมุด (หรือคอมไพล์ใหม่
โลก.o โมดูล) แต่ใช้เวอร์ชันที่คอมไพล์แล้วจากที่เก็บแทน
เนื่องจากลายเซ็น MD5 ที่ Cons ใส่ไว้ใน .ฝากขาย ไฟล์มีการประทับเวลาสำหรับ
ไฟล์ที่ได้รับ การประทับเวลาของลายเซ็นต้องตรงกับการประทับเวลาของไฟล์สำหรับลายเซ็นถึง
ถือว่าใช้ได้
ระบบซอฟต์แวร์บางระบบอาจเปลี่ยนแปลงการประทับเวลาบนไฟล์ที่เก็บ (โดยการคัดลอก
เช่น) ซึ่งในกรณีนี้ Cons จะถือว่าลายเซ็นที่เก็บไม่ถูกต้องตามค่าเริ่มต้น
และสร้างไฟล์ใหม่โดยไม่จำเป็น ลักษณะการทำงานนี้อาจเปลี่ยนแปลงได้โดยการระบุ:
พื้นที่เก็บข้อมูล_Sig_Times_OK 0;
สิ่งนี้บอกให้ Cons ละเว้นการประทับเวลาเมื่อตัดสินใจว่าลายเซ็นถูกต้องหรือไม่ (บันทึก
ว่าการหลีกเลี่ยงการตรวจสุขภาพจิตนี้หมายความว่าต้องมีการควบคุมพื้นที่เก็บข้อมูลอย่างเหมาะสม
ต้นไม้เพื่อให้แน่ใจว่าไฟล์ที่ได้รับไม่สามารถแก้ไขได้โดยไม่ต้องอัปเดต .ฝากขาย
ลายเซ็น.)
ในประเทศ สำเนา of ไฟล์
หากแผนผังที่เก็บมีผลลัพธ์ที่สมบูรณ์ของบิลด์ และเราพยายามสร้างจาก
พื้นที่เก็บข้อมูลที่ไม่มีไฟล์ใด ๆ ในทรีโลคัลของเรา บางสิ่งที่น่าประหลาดใจพอสมควร
เกิดขึ้น:
% mkdir $HOME/build2
% ซีดี $HOME/build2
% ข้อเสีย -R /usr/all/repository สวัสดี
ข้อเสีย: "สวัสดี" เป็นข้อมูลล่าสุด
ทำไม Cons บอกว่า สวัสดี โปรแกรมอัพเดทเมื่อไม่มี สวัสดี โปรแกรมเข้า
ไดเร็กทอรีบิลด์ท้องถิ่น? เนื่องจากที่เก็บ (ไม่ใช่โลคัลไดเร็กทอรี) มี
ทันเหตุการณ์ สวัสดี โปรแกรมและข้อเสียกำหนดอย่างถูกต้องว่าไม่ต้องทำอะไรเลย
สร้างสำเนาล่าสุดของไฟล์นี้ขึ้นใหม่
อย่างไรก็ตาม มีหลายครั้งที่ควรตรวจสอบให้แน่ใจว่าสำเนาของ . ในพื้นที่
ไฟล์อยู่เสมอ สคริปต์การบรรจุหรือการทดสอบ เช่น อาจสันนิษฐานว่า
ไฟล์ที่สร้างขึ้นมีอยู่ในเครื่อง แทนที่จะทำให้สคริปต์ย่อยเหล่านี้ตระหนักถึง
ไดเร็กทอรีที่เก็บ คำสั่ง `Local' อาจถูกเพิ่มในa สร้าง or ที่ถูกเกณฑ์ทหาร ไฟล์ไปที่
ระบุว่าไฟล์หรือไฟล์บางไฟล์ต้องปรากฏในไดเร็กทอรีบิลด์ภายในเครื่อง:
ท้องถิ่น qw(
สวัสดี
);
จากนั้น หากเราเรียกใช้คำสั่งเดิมซ้ำ Cons จะทำสำเนาโปรแกรมจาก
สำเนาที่เก็บ (บอกคุณว่ากำลังทำเช่นนั้น):
% ข้อเสีย -R /usr/all/repository สวัสดี
สำเนาของสวัสดีจาก /usr/all/repository/hello
ข้อเสีย: "สวัสดี" เป็นข้อมูลล่าสุด
สังเกตว่า เนื่องจากการทำสำเนาในเครื่องไม่ถือเป็น "งานสร้าง" ของ
สวัสดี ไฟล์ Cons ยังคงรายงานว่าเป็นข้อมูลล่าสุด
การสร้างสำเนาในเครื่องมีประโยชน์มากที่สุดสำหรับไฟล์ที่ติดตั้งลงใน an
ไดเร็กทอรีระดับกลาง (สำหรับการแชร์กับไดเร็กทอรีอื่น) ผ่านคำสั่ง `Install'
ประกอบกับคำสั่ง `Install' สำหรับไฟล์ที่มีคำสั่ง `Local' ที่แสดงร่วมนั้นเป็นเช่นนั้น
ทั่วไปที่ Cons ให้คำสั่ง `Install_Local' เป็นวิธีที่สะดวกในการทำทั้งสองอย่าง:
Install_Local $env, '#export', 'hello';
เทียบเท่ากับ:
ติดตั้ง $env '#export', 'hello';
ท้องถิ่น '#export/hello';
ทั้งคำสั่ง `Local' และ `Install_Local' จะอัพเดต local .ฝากขาย ไฟล์ด้วย
ลายเซ็นไฟล์ที่เหมาะสม เพื่อให้สร้างในอนาคตได้อย่างถูกต้อง
กรุ เมืองขึ้น การวิเคราะห์
เนื่องจากการสแกนในตัว ข้อเสียจะค้นหาทรีที่เก็บที่ระบุเพื่อรวม
.h ไฟล์. เว้นแต่คอมไพเลอร์จะรู้เกี่ยวกับทรีที่เก็บด้วย มันจะเป็น
ไม่สามารถหาได้ .h ไฟล์ที่มีอยู่ในที่เก็บเท่านั้น ถ้า ตัวอย่างเช่น สวัสดีซี
ไฟล์รวมถึง สวัสดีฮะ ไฟล์ในไดเร็กทอรีปัจจุบัน:
% ข้อเสีย -R /usr/all/repository สวัสดี
gcc -c /usr/all/repository/hello.c -o สวัสดี.o
/usr/all/repository/hello.c:1: hello.h: ไม่มีไฟล์หรือไดเรกทอรีดังกล่าว
การแก้ปัญหานี้บังคับให้มีข้อกำหนดบางประการเกี่ยวกับสภาพแวดล้อมการก่อสร้าง
กำหนดและเข้าสู่วิธีการใช้คำสั่งพรีโปรเซสเซอร์ C `#include เพื่อรวมไฟล์
เพื่อแจ้งให้คอมไพเลอร์ทราบเกี่ยวกับแผนผังที่เก็บ Cons จะเพิ่ม `-I' ที่เหมาะสม
แฟล็กไปยังคำสั่งการคอมไพล์ ซึ่งหมายความว่าตัวแปร `CPPPPATH' ใน
สร้างสภาพแวดล้อมต้องระบุไดเรกทอรีย่อยทั้งหมดอย่างชัดเจนที่จะค้นหา
สำหรับไฟล์ที่รวมไว้ รวมถึงไดเร็กทอรีปัจจุบัน ดังนั้นเราจึงสามารถแก้ไขข้างต้นได้
ตัวอย่างโดยการเปลี่ยนการสร้างสภาพแวดล้อมใน สร้าง ไฟล์ดังต่อไปนี้:
$env = ข้อเสียใหม่ (
CC => 'gcc',
CPPPATH => '.',
LIBS => 'libworld.a',
);
เนื่องจากคำจำกัดความของตัวแปร `CPPPPATH' ผลลัพธ์นี้ เมื่อเราดำเนินการ . อีกครั้ง
คำสั่ง:
% ข้อเสีย -R /usr/all/repository สวัสดี
gcc -c -I. -I/usr/all/repository /usr/all/repository/hello.c -o สวัสดี.o
gcc -o สวัสดี hello.o /usr/all/repository/libworld.a
ลำดับของแฟล็ก `-I' ทำซ้ำ สำหรับตัวประมวลผลล่วงหน้า C ที่เก็บข้อมูลเดียวกัน-
เส้นทางการค้นหาไดเรกทอรีที่ Cons ใช้สำหรับการวิเคราะห์การพึ่งพาของตนเอง ถ้ามี
ที่เก็บหลายแห่งและไดเร็กทอรี 'CPPPATH' หลายรายการ ข้อเสียจะผนวกที่เก็บ
ไดเร็กทอรีไปยังจุดเริ่มต้นของไดเร็กทอรี `CPPPATH' แต่ละตัว คูณจำนวนอย่างรวดเร็ว
ของแฟล็ก `-I' ตัวอย่างเช่น a สร้าง ไฟล์ที่มี:
ที่เก็บ qw(
/u1
/u2
);
$env = ข้อเสียใหม่ (
CPPPATH => 'a:b:c',
);
จะให้ผลลัพธ์คำสั่งคอมไพล์ของ:
ซีซี -Ia -I/u1/a -I/u2/a -Ib -I/u1/b -I/u2/b -Ic -I/u1/c -I/u2/c -c สวัสดี.c -o สวัสดี.o
เนื่องจากข้อเสียอาศัยแฟล็ก `-I' ของคอมไพเลอร์เพื่อสื่อสารลำดับที่
ต้องค้นหาไดเร็กทอรีที่เก็บ, การจัดการไดเร็กทอรีที่เก็บข้อเสียคือ
โดยพื้นฐานแล้วเข้ากันไม่ได้กับการใช้เครื่องหมายคำพูดคู่บนคำสั่ง `#include' ใน C . ของคุณ
รหัสแหล่งที่มา:
#include "file.h" /* อย่าใช้คำพูดสองครั้งแบบนี้ */
เนื่องจากตัวประมวลผลล่วงหน้า C ส่วนใหญ่เมื่อต้องเผชิญกับคำสั่งดังกล่าว มักจะมาก่อนเสมอ
ค้นหาไดเร็กทอรีที่มีไฟล์ต้นฉบับ สิ่งนี้บ่อนทำลายความซับซ้อน `-ฉัน'
ตัวเลือกที่ Cons สร้างขึ้นเพื่อให้ตัวประมวลผลล่วงหน้าสอดคล้องกับการค้นหาที่ต้องการ
เส้นทาง.
ดังนั้น เมื่อใช้ repository tree ใน Cons เสมอ ใช้วงเล็บมุมสำหรับรวม
ไฟล์:
#รวม /* ใช้วงเล็บเหลี่ยมแทน */
พื้นที่เก็บข้อมูล_รายการ
ข้อเสียจัดเตรียมคำสั่ง `Repository_List' เพื่อส่งคืนรายการของไดเร็กทอรีที่เก็บทั้งหมด
ในลำดับการค้นหาปัจจุบัน สามารถใช้สำหรับการดีบักหรือทำ Perl . ที่ซับซ้อนมากขึ้น
สิ่งของ:
@list = พื้นที่เก็บข้อมูล_รายการ;
พิมพ์ join(' ', @list), "\n";
กรุ ปฏิสัมพันธ์ กับ อื่น ๆ จุดด้อย คุณสมบัติ
การจัดการต้นไม้ที่เก็บของ Cons โต้ตอบอย่างถูกต้องกับคุณสมบัติ Cons อื่น ๆ - ซึ่งก็คือ
โดยทั่วไปแล้วจะไม่เป็นไปตามที่คุณคาดหวัง
สิ่งที่น่าสังเกตมากที่สุดคือ ต้นไม้ของพื้นที่เก็บข้อมูลโต้ตอบอย่างถูกต้องและค่อนข้างมีประสิทธิภาพด้วย 'ลิงก์'
สั่งการ. แผนผังที่เก็บอาจมีไดเร็กทอรีย่อยอย่างน้อยหนึ่งไดเร็กทอรีสำหรับเวอร์ชัน builds
สร้างผ่าน 'ลิงก์' ไปยังไดเร็กทอรีย่อยต้นทาง ข้อเสียจะค้นหาไฟล์ที่ได้รับใน
ไดเร็กทอรีย่อย build ที่เหมาะสมภายใต้แผนผังที่เก็บ
ค่าเริ่มต้น เป้าหมาย
จนถึงตอนนี้ เราได้สาธิตการเรียกใช้ Cons โดยมีเป้าหมายที่ชัดเจนในการสร้าง:
% ข้อเสีย สวัสดี
โดยปกติ Cons จะไม่สร้างสิ่งใดเว้นแต่จะระบุเป้าหมาย แต่ระบุ '.'
(ไดเร็กทอรีปัจจุบัน) จะสร้างทุกอย่าง:
% ข้อเสีย # ไม่สร้างอะไรเลย
ข้อเสีย % # สร้างทุกอย่างภายใต้ไดเรกทอรีระดับบนสุด
การเพิ่มวิธีการ `Default' ให้กับ any สร้าง or ที่ถูกเกณฑ์ทหาร ไฟล์จะเพิ่มที่ระบุ
เป้าหมายไปยังรายการเป้าหมายเริ่มต้น ข้อเสียจะสร้างค่าเริ่มต้นเหล่านี้หากไม่มี
เป้าหมายที่ระบุไว้ในบรรทัดคำสั่ง ดังนั้นการเพิ่มบรรทัดต่อไปนี้ที่ระดับบนสุด
สร้าง file จะเลียนแบบพฤติกรรมทั่วไปของ Make ในการสร้างทุกอย่างโดยค่าเริ่มต้น:
ค่าเริ่มต้น '.';
ต่อไปนี้จะเพิ่ม สวัสดี และ ลาก่อน คำสั่ง (ในไดเร็กทอรีเดียวกับ the
สร้าง or ที่ถูกเกณฑ์ทหาร ไฟล์) ไปยังรายการเริ่มต้น:
ค่าเริ่มต้น qw(
สวัสดี
ลาก่อน
);
อาจใช้วิธี "ค่าเริ่มต้น" มากกว่าหนึ่งครั้งเพื่อเพิ่มเป้าหมายลงในรายการเริ่มต้น
เลือก สร้าง
ข้อเสียมีสองวิธีในการลดขนาดของบิลด์ที่กำหนด อันดับแรกคือการระบุ
เป้าหมายบนบรรทัดคำสั่ง และวิธีที่สองคือวิธีการตัดแต่งต้นไม้สำหรับสร้าง ดี
พิจารณาข้อกำหนดเป้าหมายก่อน
เลือก กำหนดเป้าหมาย
เช่นเดียวกับยี่ห้อ Cons อนุญาตให้กำหนด ``เป้าหมาย'' ในบรรทัดคำสั่ง เป้าหมายข้อเสีย
อาจเป็นไฟล์หรือไดเร็กทอรีก็ได้ เมื่อมีการระบุไดเร็กทอรี นี่เป็นเพียงคำสั่งสั้น-
สัญกรณ์มือสำหรับทุกผลิตภัณฑ์ที่สืบเนื่อง - ที่ Cons รู้ - ในช่องที่ระบุ
ไดเรกทอรีและด้านล่าง ตัวอย่างเช่น:
% ข้อเสีย build/hello/hello.o
หมายถึงการสร้าง สวัสดีโอ และทุกอย่างที่ สวัสดีโอ อาจต้อง นี่คือจากเมื่อก่อน
รุ่นของ สวัสดี โลก! โปรแกรมที่ สวัสดีโอ ขึ้นอยู่กับ
ส่งออก/รวม/world.h. หากไฟล์นั้นไม่อัพเดท (เพราะมีคนแก้ไข
src/world/world.h)จากนั้นจะถูกสร้างขึ้นใหม่แม้ว่าจะอยู่ในไดเร็กทอรีระยะไกลจาก
สร้าง/สวัสดี.
ในตัวอย่างนี้:
% สร้างข้อเสีย
ทุกอย่างใน สร้าง ไดเร็กทอรีถูกสร้างขึ้น ถ้าจำเป็น อีกครั้ง นี่อาจทำให้ไฟล์มากขึ้น
ที่จะสร้าง โดยเฉพาะทั้งสองอย่าง ส่งออก/รวม/world.h และ ส่งออก/lib/libworld.a เป็น
ที่ต้องการโดย สร้าง/สวัสดี ไดเร็กทอรีและจะถูกสร้างขึ้นหากล้าสมัย
ถ้าเราทำแทน:
% ข้อเสียการส่งออก
เฉพาะไฟล์ที่ควรติดตั้งในไดเร็กทอรีเอ็กซ์พอร์ตเท่านั้นที่จะถูกสร้างใหม่ if
ที่จำเป็นแล้วติดตั้งที่นั่น โปรดทราบว่า `cons build' อาจสร้างไฟล์ที่`cons
การส่งออก' ไม่ได้สร้างและในทางกลับกัน
ไม่ ''พิเศษ'' เป้าหมาย
ด้วยจุดด้อย เป้าหมาย ``พิเศษ'' แบบ make-style นั้นไม่จำเป็น อะนาล็อกที่ง่ายที่สุดด้วย Cons
คือการใช้พิเศษ ส่งออก ไดเร็กทอรีแทน สมมติว่าคุณมี
ชุดการทดสอบหน่วยทั้งหมดที่เกี่ยวข้องกับรหัสของคุณ การทดสอบอยู่ใน
ไดเรกทอรีต้นทางใกล้กับรหัส อย่างไรก็ตาม โดยปกติ คุณไม่ต้องการสร้างการทดสอบเหล่านี้
ทางออกหนึ่งคือการจัดเตรียมคำแนะนำในการสร้างทั้งหมดสำหรับการสร้างการทดสอบ จากนั้นจึงไปที่
ติดตั้งการทดสอบในส่วนที่แยกต่างหากของแผนผัง หากเราติดตั้งการทดสอบในระดับบนสุด
ไดเรกทอรีที่เรียกว่า การทดสอบ, แล้ว:
% การทดสอบข้อเสีย
จะสร้างการทดสอบทั้งหมด
% ข้อเสียการส่งออก
จะสร้างเวอร์ชันที่ใช้งานจริงของระบบ (แต่ไม่ใช่การทดสอบ) และ:
% สร้างข้อเสีย
ควรจะหลีกเลี่ยง (เนื่องจากจะรวบรวมการทดสอบโดยไม่จำเป็น)
หากคุณต้องการสร้างการทดสอบเพียงครั้งเดียว คุณสามารถตั้งชื่อการทดสอบได้อย่างชัดเจน (in
อย่างใดอย่างหนึ่ง การทดสอบ ไดเร็กทอรีหรือ สร้าง ไดเร็กทอรี) คุณยังสามารถรวมการทดสอบ
เป็นลำดับชั้นที่สะดวกภายในไดเร็กทอรีการทดสอบ ลำดับชั้นนี้ไม่จำเป็นต้อง
จำเป็นต้องตรงกับลำดับชั้นต้นทางในลักษณะเดียวกับลำดับชั้นที่รวมอยู่ด้วย
อาจไม่ตรงกับลำดับชั้นต้นทาง (ลำดับชั้นรวมไม่น่าจะมากกว่า
ลึกกว่าสองระดับ สำหรับโปรแกรม C)
หากคุณต้องการสร้างทุกอย่างในต้นไม้ (ขึ้นอยู่กับตัวเลือกของคุณ
เลือก) คุณสามารถใช้:
ข้อเสีย %
วิธีนี้ไม่ได้ผลเป็นพิเศษเพราะจะทำให้ต้นไม้ทั้งหมดเดินซ้ำซาก
รวมทั้งต้นต้นทาง ต้นไม้ต้นทางอาจมีวัตถุที่สร้างได้ใน
มันไม่มีอะไรหยุดคุณไม่ให้ทำเช่นนี้ แม้ว่าปกติแล้วคุณจะสร้างในบิลด์ที่แยกจากกัน
ต้นไม้.
สร้าง การตัด
ควบคู่ไปกับการเลือกเป้าหมาย สร้าง การตัด สามารถใช้เพื่อลดขอบเขตของ
สร้าง. ในตัวอย่าง peAcH และ baNaNa ก่อนหน้านี้ เราได้เห็นแล้วว่าการขับเคลื่อนด้วยสคริปต์เป็นอย่างไร
การตัดแต่งกิ่งสามารถใช้เพื่อสร้างเพียงครึ่งเดียวของงานสร้างที่เป็นไปได้สำหรับตัวใดตัวหนึ่ง
เรียก 'ข้อเสีย' ข้อเสียยังจัดให้มีการประชุมบรรทัดคำสั่งเพื่อความสะดวก
ให้คุณระบุได้ว่า ที่ถูกเกณฑ์ทหาร ไฟล์ได้รับ ``สร้าง'' จริง ๆ - นั่นคือรวมเข้าด้วยกัน
เข้าไปในต้นไม้สร้าง ตัวอย่างเช่น:
% ข้อเสีย สร้าง +โลก
อาร์กิวเมนต์ `+' แนะนำนิพจน์ทั่วไปของ Perl แน่นอนว่าสิ่งนี้ต้องยกมาที่
ระดับเชลล์หากมีอักขระเมตาของเชลล์ภายในนิพจน์ ดิ
นิพจน์ตรงกับแต่ละ ที่ถูกเกณฑ์ทหาร ไฟล์ที่ถูกกล่าวถึงใน 'Build'
คำสั่งและเฉพาะสคริปต์ที่มีชื่อตรงกันเท่านั้นที่รวมเข้ากับ
สร้างต้นไม้ อนุญาตให้ใช้อาร์กิวเมนต์ดังกล่าวได้หลายข้อ ซึ่งในกรณีนี้จะจับคู่กับอาร์กิวเมนต์ใดก็ได้
เพียงพอที่จะรวมสคริปต์
ในตัวอย่างข้างต้น the สวัสดี โปรแกรมจะไม่ถูกสร้างขึ้นเนื่องจากข้อเสียจะไม่มี
ความรู้เกี่ยวกับสคริปต์ สวัสดี/ทหารเกณฑ์. libworld.a ไฟล์เก็บถาวรจะถูกสร้างขึ้น อย่างไรก็ตาม ถ้า
จำเป็นต้องเป็น
มีการใช้งานสองสามอย่างสำหรับการตัดแต่งกิ่งผ่านบรรทัดคำสั่ง อาจจะมีประโยชน์มากที่สุด
คือความสามารถในการเปลี่ยนแปลงท้องถิ่น จากนั้น มีความรู้เพียงพอเกี่ยวกับ
ผลที่ตามมาของการเปลี่ยนแปลงเหล่านั้น จำกัดขนาดของโครงสร้างต้นไม้เพื่อเร่งความเร็ว
เวลาสร้างใหม่ การใช้งานครั้งที่สองสำหรับการตัดแต่งกิ่งคือการป้องกันการคอมไพล์ใหม่อย่างแข็งขัน
ของไฟล์บางไฟล์ที่คุณรู้ว่าจะคอมไพล์ใหม่เนื่องจากไฟล์ส่วนหัวที่แก้ไข ตัวอย่างเช่น
คุณอาจรู้ว่าการเปลี่ยนแปลงในไฟล์ส่วนหัวนั้นไม่มีสาระสำคัญหรือว่า
การเปลี่ยนแปลงอาจถูกละเว้นได้อย่างปลอดภัยสำหรับต้นไม้ส่วนใหญ่เพื่อการทดสอบ ข้อเสียคือ
ทัศนะ คือ ยอมรับพฤติกรรมนี้ในทางปฏิบัติโดยเข้าใจว่า
ในบิลด์ตัวถัดไป ทุกสิ่งที่จำเป็นต้องสร้างใหม่จะเป็น ไม่มีเทียบเท่า
คำสั่ง ``make touch'' เพื่อทำเครื่องหมายไฟล์ว่าเป็นข้อมูลล่าสุดอย่างถาวร ดังนั้นความเสี่ยงใด ๆ ที่เป็น
ที่เกิดขึ้นจากการตัดแต่งกิ่งจะลดลง สำหรับงานปล่อยคุณภาพแน่นอนเราแนะนำ
ที่คุณไม่ได้ใช้การตัดแต่งกิ่ง (อย่างไรก็ตาม ใช้ระหว่างการผสานรวมได้อย่างสมบูรณ์แบบ
สำหรับตรวจสอบการคอมไพล์ ฯลฯ อย่าลืมสร้าง unconstrained ก่อนคอมมิชชัน
บูรณาการ)
ชั่วคราว แทนที่
ข้อเสียมีกลไกที่ง่ายมากสำหรับการแทนที่แง่มุมต่างๆ ของบิลด์ สาระสำคัญคือ
ที่คุณเขียนไฟล์แทนที่ที่มีคำสั่ง `Override' อย่างน้อยหนึ่งคำสั่ง และคุณ
ระบุสิ่งนี้ในบรรทัดคำสั่ง เมื่อคุณเรียกใช้ `cons':
% ข้อเสีย -o มากกว่าการส่งออก
จะสร้าง ส่งออก ไดเร็กทอรี โดยมีไฟล์ที่ได้รับทั้งหมดอยู่ภายใต้การแทนที่ปัจจุบัน
ใน เกิน ไฟล์. หากคุณไม่ใช้ตัวเลือก `-o' แสดงว่าทุกอย่างที่จำเป็นในการลบ
การแทนที่ทั้งหมดจะถูกสร้างขึ้นใหม่
ที่เอาชนะ สิ่งแวดล้อม ตัวแปร
ไฟล์การแทนที่สามารถมีการลบล้างได้สองประเภท สิ่งแรกคือสภาพแวดล้อมที่เข้ามา
ตัวแปร สิ่งเหล่านี้สามารถเข้าถึงได้โดยปกติโดย สร้าง ไฟล์จากแฮช `%ENV'
ตัวแปร. สิ่งเหล่านี้สามารถถูกแทนที่เล็กน้อยในไฟล์แทนที่โดยการตั้งค่า
องค์ประกอบที่เหมาะสมของ `%ENV' (สิ่งเหล่านี้อาจถูกแทนที่ในสภาพแวดล้อมของผู้ใช้
แน่นอน).
พื้นที่ เอาชนะ คำสั่ง
การแทนที่ประเภทที่สองทำได้สำเร็จด้วยคำสั่ง `Override' ซึ่งดูเหมือน
นี้:
แทนที่ , => , => , ...;
นิพจน์ทั่วไป regexp จะจับคู่กับทุกไฟล์ที่ได้รับที่เป็นผู้สมัคร
สำหรับงานสร้าง หากไฟล์ที่ได้รับตรงกัน คู่ตัวแปร/ค่าจะถูกใช้เพื่อ
แทนที่ค่าในสภาพแวดล้อมการก่อสร้างที่เกี่ยวข้องกับไฟล์ที่ได้รับ
สมมติว่าเรามีสภาพแวดล้อมการก่อสร้างดังนี้:
$CONS = ข้อเสียใหม่ (
ตำรวจ => '',
CDBG => '-g',
CFLAGS => '%COPT %CDBG',
);
แล้วถ้าเรามีไฟล์แทนที่ เกิน ที่มีคำสั่งนี้:
แทนที่ '\.o$', COPT => '-O', CDBG => '';
จากนั้นการเรียกใช้ `cons' ใด ๆ ที่มี `-o over' ที่สร้าง .o ไฟล์ผ่านสภาพแวดล้อมนี้จะ
ทำให้พวกเขาถูกคอมไพล์ด้วย `-O 'และไม่มี `-g' แน่นอนว่าการแทนที่สามารถเป็น
จำกัดไว้ที่ไดเร็กทอรีเดียวโดยการเลือกนิพจน์ทั่วไปที่เหมาะสม
นี่คือเวอร์ชันดั้งเดิมของ Hello, World! โปรแกรมที่สร้างขึ้นด้วยสภาพแวดล้อมนี้
โปรดทราบว่า Cons จะสร้างชิ้นส่วนที่เหมาะสมขึ้นใหม่เมื่อมีการใช้หรือลบการแทนที่:
% ข้อเสีย สวัสดี
cc -g -c hello.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
% ข้อเสีย -o มากกว่า สวัสดี
cc -O -c สวัสดี.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
% ข้อเสีย -o มากกว่า สวัสดี
ข้อเสีย: "สวัสดี" เป็นข้อมูลล่าสุด
% ข้อเสีย สวัสดี
cc -g -c hello.c -o สวัสดี.o
cc -o สวัสดี สวัสดี.o
สิ่งสำคัญคือต้องใช้คำสั่ง "แทนที่" ชั่วคราวแบบทันทีทันใด
การแทนที่ที่จำเป็นสำหรับการพัฒนาเนื่องจากการแทนที่นั้นไม่ขึ้นอยู่กับแพลตฟอร์มและ
เพราะพวกเขาพึ่งพาความรู้อย่างใกล้ชิดเกี่ยวกับการทำงานของสคริปต์มากเกินไป สำหรับ
การใช้งานชั่วคราวเป็นสิ่งที่คุณต้องการ
โปรดทราบว่ายังคงมีประโยชน์ในการให้ พูด ความสามารถในการสร้างการเพิ่มประสิทธิภาพอย่างเต็มที่
เวอร์ชันของระบบสำหรับการใช้งานจริง - จาก สร้าง และ ที่ถูกเกณฑ์ทหาร ไฟล์. ทางนี้
คุณสามารถปรับแต่งระบบที่ปรับให้เหมาะสมกับแพลตฟอร์มได้ ในกรณีที่จำเป็นต้องมีการแลกเปลี่ยนเครื่องมือเพิ่มประสิทธิภาพ
สร้าง (ไฟล์บางไฟล์อาจไม่ได้รับการคอมไพล์ด้วยการปรับให้เหมาะสมอย่างสมบูรณ์ เป็นต้น) จากนั้น
สิ่งเหล่านี้สามารถบันทึกสำหรับลูกหลาน (และการทำซ้ำ) ได้โดยตรงในสคริปต์
More on การก่อสร้าง สภาพแวดล้อม
ค่าเริ่มต้น การก่อสร้าง ตัวแปร
เราได้กล่าวถึงและใช้แนวคิดของ a การก่อสร้าง สิ่งแวดล้อมหลายครั้งใน
หน้าที่แล้ว ตอนนี้ก็ถึงเวลาที่จะทำให้เรื่องนี้เป็นรูปธรรมขึ้นอีกเล็กน้อย ดังต่อไปนี้
คำให้การ:
$env = ข้อเสียใหม่ ();
การอ้างอิงถึงสภาพแวดล้อมการก่อสร้างเริ่มต้นใหม่จะถูกสร้างขึ้น ประกอบด้วยตัวเลข
ของตัวแปรการก่อสร้างและวิธีการบางอย่าง ในการเขียนปัจจุบัน รายการเริ่มต้นของ
ตัวแปรการก่อสร้างถูกกำหนดดังนี้:
ซีซี => 'ซีซี',
CFLAGS => '',
CCCOM => '%CC %CFLAGS %_IFLAGS -c %< -o %>',
INCDIRPREFIX => '-ฉัน'
CXX => '%CC',
CXXFLAGS => '%CFLAGS',
CXXCOM => '%CXX %CXXFLAGS %_IFLAGS -c %< -o %>',
ลิงค์ => '%CXX',
LINKCOM => '%LINK %LDFLAGS -o %> %< %_LDIRS %LIBS',
LINKMODULECOM => '%LD -r -o %> %<',
LIBDIRPREFIX => '-L',
AR => 'อาร์',
อาร์ฟลากส์ => 'r',
ARCOM => "%AR %ARFLAGS %> %<\n%RANLIB %>",
RANLIB => 'รันลิบ',
AS => 'เป็น',
แอสฟแล็กส์ => '',
ASCOM => '%AS %ASFLAGS %< -o %>',
LD => 'ld',
แอลดีแฟลกส์ => '',
PREFLIB => 'lib',
SUFLIB => '.a',
SUFLIBS => '.so:.a',
SUFOBJ => '.o',
ENV => { 'เส้นทาง' => '/ bin:/ usr / bin' },
บนระบบ Win32 (Windows NT) ตัวแปรการก่อสร้างต่อไปนี้จะถูกแทนที่ใน
ค่าเริ่มต้น:
CC => 'cl',
CFLAGS => '/nologo',
CCCOM => '%CC %CFLAGS %_IFLAGS /c %< /Fo%>',
CXXCOM => '%CXX %CXXFLAGS %_IFLAGS /c %< /Fo%>',
INCDIRPREFIX => '/ฉัน',
ลิงค์ => 'ลิงค์'
LINKCOM => '%LINK %LDFLAGS / ออก:%> %< %_LDIRS %LIBS',
LINKMODULECOM => '%LD /r /o %> %<',
LIBDIRPREFIX => '/LIBPATH:',
AR => 'lib',
ARFLAGS => '/nologo ',
ARCOM => "%AR %ARFLAGS / ออก:%> %<",
รันลิบ => '',
LD => 'ลิงก์'
LDFLAGS => '/nologo ',
PREFLIB => '',
SUEXE => '.exe',
SUFLIB => '.lib',
SUFLIBS => '.dll:.lib',
SUFOBJ => '.obj',
ตัวแปรเหล่านี้ถูกใช้โดยวิธีการต่าง ๆ ที่เกี่ยวข้องกับสภาพแวดล้อมใน
โดยเฉพาะอย่างยิ่งวิธีการใด ๆ ที่เรียกใช้คำสั่งภายนอกในที่สุดจะแทนที่สิ่งเหล่านี้
ลงในคำสั่งสุดท้ายตามความเหมาะสม ตัวอย่างเช่น เมธอด `Objects' ใช้
ไฟล์ต้นฉบับจำนวนหนึ่งและจัดเรียงเพื่อให้ได้มาซึ่งอ็อบเจกต์ที่เกี่ยวข้องหากจำเป็น
ไฟล์. ตัวอย่างเช่น:
ออบเจ็กต์ $env 'foo.c', 'bar.c';
ซึ่งจะจัดให้มีการผลิตหากจำเป็น ฟูโอ และ บาร์.โอ. คำสั่งที่เรียกใช้นั้นง่าย
`%CCCOM' ซึ่งขยายผ่านการแทนที่เป็นคำสั่งภายนอกที่เหมาะสมที่จำเป็น
เพื่อสร้างแต่ละวัตถุ เราจะสำรวจกฎการทดแทนเพิ่มเติมภายใต้ "คำสั่ง"
วิธีการด้านล่าง
ตัวแปรการก่อสร้างยังใช้เพื่อวัตถุประสงค์อื่นอีกด้วย ตัวอย่างเช่น `CPPPPATH' คือ
ใช้เพื่อระบุพาธที่คั่นด้วยโคลอนของไดเรกทอรี include สิ่งเหล่านี้มีวัตถุประสงค์เพื่อเป็น
ส่งผ่านไปยังตัวประมวลผลล่วงหน้า C และยังใช้โดยเครื่องจักรสแกนไฟล์ C ถึง
กำหนดการอ้างอิงที่เกี่ยวข้องกับการรวบรวม C ตัวแปรที่ขึ้นต้นด้วย
ขีดเส้นใต้ สร้างด้วยวิธีการต่างๆ และปกติควรถือว่าเป็น ``ภายใน''
ตัวแปร เช่น เมื่อเรียก method ที่เรียกการสร้าง object
จากแหล่ง C ตัวแปร `_IFLAGS' ถูกสร้างขึ้น: ซึ่งสอดคล้องกับสวิตช์ `-I'
ต้องการโดยคอมไพเลอร์ C เพื่อเป็นตัวแทนของไดเร็กทอรีที่ระบุโดย `CPPPATH'
โปรดทราบว่าสำหรับสภาพแวดล้อมเฉพาะใดๆ ค่าของตัวแปรจะถูกตั้งค่าเพียงครั้งเดียว จากนั้น
ไม่เคยรีเซ็ต (หากต้องการเปลี่ยนตัวแปร คุณต้องสร้างสภาพแวดล้อมใหม่ มีวิธีการให้
สำหรับการคัดลอกสภาพแวดล้อมที่มีอยู่เพื่อจุดประสงค์นี้) ตัวแปรภายในบางตัว เช่น
`_IFLAGS' ถูกสร้างขึ้นตามความต้องการ แต่เมื่อตั้งค่าแล้ว พวกมันจะคงที่ตลอดอายุของ
สิ่งแวดล้อม
ตัวแปร 'CFLAGS', 'LDFLAGS' และ 'ARFLAGS' ล้วนเป็นแหล่งสำหรับส่งผ่านตัวเลือกไปยัง
คอมไพเลอร์ ตัวโหลด และผู้จัดเก็บ ตามลำดับ ไม่ชัดเจน `INCDIRPREFIX'
ตัวแปรระบุสตริงตัวเลือกที่จะผนวกกับจุดเริ่มต้นของแต่ละรายการรวมถึง
ไดเร็กทอรีเพื่อให้คอมไพเลอร์รู้ว่าจะหาได้ที่ไหน .h ไฟล์. ในทำนองเดียวกัน
ตัวแปร `LIBDIRPREFIX' ระบุสตริงตัวเลือกที่จะต่อท้ายจุดเริ่มต้นของ
แต่ละไดเร็กทอรีที่ตัวเชื่อมโยงควรค้นหาไลบรารี
ตัวแปรอื่น `ENV' ใช้เพื่อกำหนดสภาพแวดล้อมของระบบในระหว่างการดำเนินการ
ของคำสั่งภายนอก โดยค่าเริ่มต้น ตัวแปรสภาพแวดล้อมเดียวที่ตั้งค่าไว้คือ "เส้นทาง"
ซึ่งเป็นเส้นทางการดำเนินการสำหรับคำสั่ง UNIX เพื่อการทำซ้ำอย่างสูงสุด คุณควร
จริงๆจัดเพื่อกำหนดเส้นทางการดำเนินการของคุณเองในระดับบนสุดของคุณ สร้าง ไฟล์ (หรือ
บางทีโดยการนำเข้าแพ็คเกจการก่อสร้างที่เหมาะสมด้วยคำสั่ง Perl `use') ดิ
ตัวแปรเริ่มต้นมีไว้เพื่อให้คุณออกจากพื้นดิน
การสอดแทรก การก่อสร้าง ตัวแปร
ตัวแปรสภาพแวดล้อมการก่อสร้างอาจถูกสอดแทรกในชื่อไฟล์ต้นทางและเป้าหมาย
โดยนำหน้าชื่อตัวแปรการก่อสร้างด้วย `%'
$env = ข้อเสียใหม่ (
DESTDIR => 'โปรแกรม',
SRCDIR => 'src',
);
โปรแกรม $env '%DESTDIR/hello', '%SRCDIR/hello.c';
การขยายตัวของตัวแปรการก่อสร้างเป็นแบบเรียกซ้ำ นั่นคือ file ชื่อ(s) จะถูก re-
ขยายจนไม่สามารถทดแทนได้อีก หากตัวแปรการก่อสร้างไม่ใช่
ที่กำหนดไว้ในสภาพแวดล้อม จากนั้นสตริงว่างจะถูกแทนที่
ค่าเริ่มต้น การก่อสร้าง วิธีการ
รายการวิธีการก่อสร้างเริ่มต้นมีดังต่อไปนี้:
พื้นที่ 'ใหม่' นวกรรมิก
วิธีการ 'ใหม่' คือตัวสร้างอ็อบเจ็กต์ Perl นั่นคือไม่ได้เรียกใช้ผ่านการอ้างอิง
กับสภาพแวดล้อมการก่อสร้างที่มีอยู่ การอ้างอิงแต่ค่อนข้างคงที่โดยใช้ชื่อ
ของชาวเพิร์ล แพ็คเกจ โดยที่คอนสตรัคเตอร์ถูกกำหนดไว้ วิธีการถูกเรียกใช้เช่นนี้:
$env = ข้อเสียใหม่ ( );
สภาพแวดล้อมที่คุณได้รับกลับได้รับพรในแพ็คเกจ `ข้อเสีย' ซึ่งหมายความว่ามันจะ
ได้เชื่อมโยงกับวิธีการเริ่มต้นที่อธิบายไว้ด้านล่าง การก่อสร้างส่วนบุคคล
ตัวแปรสามารถถูกแทนที่ได้โดยการระบุคู่ของชื่อ/ค่าในรายการแทนที่ สังเกตว่า
เพื่อแทนที่ตัวแปรสภาพแวดล้อมคำสั่งใด ๆ (เช่นอะไรก็ได้ภายใต้ `ENV') คุณจะต้อง
แทนที่พวกเขาทั้งหมด คุณสามารถแก้ไขปัญหานี้ได้โดยใช้วิธี `คัดลอก' บน an
สภาพแวดล้อมการก่อสร้างที่มีอยู่
พื้นที่ 'โคลน' วิธี
วิธีการ 'โคลน' สร้างโคลนของสภาพแวดล้อมการก่อสร้างที่มีอยู่ และสามารถ
เรียกดังตัวอย่างต่อไปนี้
$env2 = $env1->โคลน( );
คุณสามารถให้การแทนที่ในลักษณะปกติเพื่อสร้างสภาพแวดล้อมที่แตกต่างจาก
ต้นฉบับ. หากคุณต้องการชื่อใหม่ในสภาพแวดล้อมเดียวกัน (ซึ่งอาจมีประโยชน์เมื่อ
การส่งออกสภาพแวดล้อมไปยังส่วนประกอบที่มีอยู่) คุณสามารถใช้การกำหนดอย่างง่าย
พื้นที่ `คัดลอก' วิธี
วิธีการ `คัดลอก' จะแยกตัวแปรการก่อสร้างที่กำหนดไว้ภายนอกออกจาก an
และส่งกลับเป็นรายการคู่ของชื่อ/ค่า การลบล้างยังสามารถเป็น
ซึ่งในกรณีนี้ ค่าที่ถูกแทนที่จะถูกส่งกลับตามความเหมาะสม ดิ
รายการที่ส่งคืนสามารถกำหนดให้กับแฮชตามที่แสดงในต้นแบบด้านล่าง แต่ก็สามารถ
ถูกจัดการด้วยวิธีอื่น:
%env = $env1->คัดลอก( );
ค่าของ `ENV' ซึ่งเป็นแฮชเองก็ถูกคัดลอกไปยังแฮชใหม่ด้วย ดังนั้นนี่อาจเป็น
เปลี่ยนโดยไม่ต้องกลัวว่าจะกระทบกับสิ่งแวดล้อมเดิม ตัวอย่างเช่น ถ้าคุณจริงๆ
ต้องการแทนที่เฉพาะตัวแปร `PATH' ในสภาพแวดล้อมเริ่มต้น คุณสามารถทำได้
ต่อไปนี้:
%cons = ข้อเสียใหม่ ()->copy();
$cons{ENV}{PATH} = " ";
$cons = ข้อเสียใหม่ (%cons);
การดำเนินการนี้จะเหลือสิ่งอื่นที่อาจอยู่ในสภาพแวดล้อมการดำเนินการเริ่มต้น
ไม่ถูกรบกวน
พื้นที่ 'ติดตั้ง' วิธี
เมธอด `Install' จะจัดไฟล์ที่ระบุให้ติดตั้งในไฟล์ที่ระบุ
ไดเร็กทอรี การติดตั้งได้รับการปรับให้เหมาะสม: ไฟล์จะไม่ถูกคัดลอกหากสามารถเชื่อมโยงได้ ถ้า
นี่ไม่ใช่พฤติกรรมที่ต้องการ คุณจะต้องใช้วิธีอื่นในการติดตั้ง
ไฟล์. เรียกว่าดังนี้
ติดตั้ง $env , ;
โปรดทราบว่าในขณะที่ไฟล์ที่จะติดตั้งอาจตั้งชื่อตามอำเภอใจ เฉพาะไฟล์สุดท้ายเท่านั้น
ส่วนประกอบของแต่ละชื่อใช้สำหรับชื่อเป้าหมายที่ติดตั้ง ตัวอย่างเช่น ถ้าคุณ
นัดติดตั้ง ฟู/บาร์ in ฐาน, สิ่งนี้จะสร้าง บาร์ แฟ้มใน ฐาน ไดเร็กทอรี (ไม่
ฟู/บาร์).
พื้นที่ 'ติดตั้งเป็น' วิธี
เมธอด `InstallAs' จัดเรียงสำหรับแหล่งที่มาที่ระบุ ไฟล์(s) ที่จะติดตั้งเป็น
เป้าหมายที่กำหนด ไฟล์(ส). ควรระบุไฟล์หลายไฟล์เป็นรายการไฟล์ ดิ
การติดตั้งได้รับการปรับให้เหมาะสม: ไฟล์จะไม่ถูกคัดลอกหากสามารถเชื่อมโยงได้ ถ้านี่ไม่ใช่
พฤติกรรมที่ต้องการ คุณจะต้องใช้วิธีอื่นในการติดตั้งไฟล์ มันคือ
เรียกดังนี้
`InstallAs' ทำงานได้สองวิธี:
ติดตั้งไฟล์เดียว:
ติดตั้งเป็น $env TgtFile, SrcFile;
การติดตั้งหลายไฟล์:
InstallAs $env ['tgt1', 'tgt2'], ['src1', 'src2'];
หรือแม้กระทั่งเป็น:
@srcs = qw(src1 src2 src3);
@tgts = qw(tgt1 tgt2 tgt3);
ติดตั้งเป็น $env [@tgts], [@srcs];
ทั้งรายการเป้าหมายและแหล่งที่มาควรมีความยาวเท่ากัน
พื้นที่ 'ล้ำค่า' วิธี
วิธี 'ล้ำค่า' ขอข้อเสียที่จะไม่ลบไฟล์ที่ระบุหรือรายการไฟล์ก่อน
สร้างใหม่อีกครั้ง มันถูกเรียกใช้เป็น:
ล้ำค่า ;
สิ่งนี้มีประโยชน์อย่างยิ่งในการอนุญาตให้มีการอัปเดตไลบรารีหรือ debug . ที่เพิ่มขึ้น
ไฟล์ข้อมูลที่ได้รับการปรับปรุงแทนที่จะสร้างใหม่ทุกครั้ง ข้อเสียจะยังคง
ลบไฟล์เมื่อระบุแฟล็ก `-r'
พื้นที่ 'คำสั่ง' วิธี
เมธอด `Command' เป็นวิธี catchall ที่สามารถใช้เพื่อจัดเรียงข้อมูลภายนอกใดๆ ได้
คำสั่งที่จะเรียกอัพเดทเป้าหมาย สำหรับคำสั่งนี้ ไฟล์เป้าหมายและรายการของ
มีอินพุตให้ นอกจากนี้ บรรทัดคำสั่งการก่อสร้าง หรือบรรทัด ให้ไว้เป็น
สตริง (สตริงนี้อาจมีหลายคำสั่งฝังอยู่ภายใน คั่นด้วย new
เส้น) `คำสั่ง' ถูกเรียกดังนี้:
คำสั่ง $env , , ;
เป้าหมายขึ้นอยู่กับรายการไฟล์อินพุตที่ระบุ และอินพุตต้อง
สร้างได้สำเร็จหรือ Cons จะไม่พยายามสร้างเป้าหมาย
ภายในคำสั่งก่อสร้าง ตัวแปรใดๆ จากสภาพแวดล้อมการก่อสร้างอาจเป็น
แนะนำโดยนำหน้าชื่อของตัวแปรการก่อสร้างด้วย `%' นี่เป็นแบบเรียกซ้ำ:
คำสั่งถูกขยายออกไปจนไม่สามารถแทนที่ได้อีก ถ้าก่อสร้าง
ตัวแปรไม่ได้ถูกกำหนดในสภาพแวดล้อม จากนั้นสตริง null จะถูกแทนที่ อา
`%%' สองเท่าจะถูกแทนที่ด้วย `%' เดียวในคำสั่งการก่อสร้าง
มีตัวแปรหลอกหลายตัวซึ่งจะถูกขยายด้วย:
%> ชื่อไฟล์เป้าหมาย (ในคำสั่ง multi-target นี่เป็นเป้าหมายแรกเสมอ
กล่าวถึง).
%0 เหมือนกับ `%>'
%1, %2, ..., %9
สิ่งเหล่านี้อ้างถึงไฟล์อินพุตแรกถึงเก้าตามลำดับ
%< ชุดอินพุตทั้งหมด หากมีการใช้สิ่งเหล่านี้ที่อื่นใน
บรรทัดคำสั่งปัจจุบัน (ผ่าน `%1', `%2' เป็นต้น) จากนั้นคำสั่งเหล่านั้นจะถูกลบออกจาก
รายการที่จัดทำโดย `%<' พิจารณาคำสั่งต่อไปนี้ที่พบในa ที่ถูกเกณฑ์ทหาร ไฟล์
ใน ทดสอบ ไดเรกทอรี:
คำสั่ง $env 'tgt', qw(foo bar baz), qq(
เสียงสะท้อน %< -i %1 > %>
เสียงสะท้อน %< -i %2 >> %>
เสียงสะท้อน %< -i %3 >> %>
);
If TGT จำเป็นต้องได้รับการปรับปรุง ซึ่งจะทำให้การดำเนินการของ
ตามคำสั่ง สมมติว่าไม่มีการรีแมปสำหรับ ทดสอบ
ไดเรกทอรี:
ทดสอบเสียงสะท้อน/ทดสอบบาร์/baz -i ทดสอบ/foo > ทดสอบ/tgt
echo test/foo test/baz -i test/bar >> ทดสอบ/tgt
echo test/foo test/bar -i test/baz >> ทดสอบ/tgt
ตัวแปรเทียมใดๆ ข้างต้นอาจถูกติดตามโดยทันทีโดยข้อใดข้อหนึ่งต่อไปนี้
คำต่อท้ายเพื่อเลือกส่วนของชื่อพาธที่ขยาย:
:a พาธสัมบูรณ์ไปยังชื่อไฟล์
:b ไดเร็กทอรีพร้อมชื่อไฟล์ที่ถูกถอดส่วนต่อท้าย
:d ไดเร็กทอรี
:f ชื่อไฟล์
:s คำต่อท้ายชื่อไฟล์
:F ชื่อไฟล์ถูกถอดจากส่วนต่อท้ายใด ๆ
ต่อจากตัวอย่างข้างต้น `%<:f' จะขยายเป็น `foo bar baz' และ `%':d> จะขยาย
ขยายเป็น 'ทดสอบ'
เป็นไปได้ที่จะเขียนส่วนหนึ่งของคำสั่งโดยทางโปรแกรมโดยการปิดส่วนหนึ่งของมัน
ระหว่าง `%[' และ `%]' สิ่งนี้จะเรียกตัวแปรการก่อสร้างที่มีชื่อเป็นคำแรก
อยู่ในวงเล็บเพื่ออ้างอิงรหัส Perl; ผลลัพธ์ของการโทรนี้จะถูกนำไปใช้
เพื่อแทนที่เนื้อหาของวงเล็บในบรรทัดคำสั่ง ตัวอย่างเช่น ให้ an
ไฟล์อินพุตที่มีอยู่ชื่อ tgt.ใน:
@keywords = qw(ฟู บาร์ บาซ);
$env = ข้อเสียใหม่ (X_COMMA => sub { join(",", @_) });
คำสั่ง $env 'tgt', 'tgt.in', qq(
echo '# คำสำคัญ: %[X_COMMA @keywords %]' > %>
แมว %< >> %>
);
สิ่งนี้จะดำเนินการ:
echo '# คำสำคัญ: foo,bar,baz' > tgt
แมว tgt.in >> tgt
หลังจากการแทนที่เกิดขึ้น สตริงของช่องว่างสีขาวจะถูกแปลงเป็นช่องว่างเดียว และ
พื้นที่สีขาวนำหน้าและต่อท้ายถูกตัดออก จึงไม่สามารถแนะนำได้
พื้นที่สีขาวความยาวผันแปรในสตริงที่ส่งผ่านไปยังคำสั่งโดยไม่ต้องอาศัยบางส่วน
ประเภทของการอ้างอิงเชลล์
หากมีการระบุสตริงคำสั่งแบบหลายบรรทัด คำสั่งจะถูกดำเนินการตามลำดับ ถ้ามี
ของคำสั่งล้มเหลว ส่วนที่เหลือจะไม่ถูกดำเนินการ และเป้าหมายจะไม่ถูกทำเครื่องหมายเป็น
อัปเดต กล่าวคือไม่มีการจัดเก็บลายเซ็นใหม่สำหรับเป้าหมาย
โดยปกติหากคำสั่งทั้งหมดสำเร็จและส่งคืนสถานะเป็นศูนย์ (หรือแพลตฟอร์มใดก็ตาม-
จำเป็นต้องมีการบ่งชี้ความสำเร็จโดยเฉพาะ) จากนั้นลายเซ็นใหม่จะถูกเก็บไว้สำหรับ
เป้า. หากคำสั่งรายงานความสำเร็จผิดพลาดแม้หลังจากความล้มเหลว ข้อเสียก็จะ
ถือว่าไฟล์เป้าหมายที่สร้างโดยคำสั่งนั้นถูกต้องและเป็นปัจจุบัน
คำแรกของแต่ละสตริงคำสั่ง หลังจากการขยาย จะถือว่าเป็นไฟล์ปฏิบัติการ
คำสั่งค้นหาตัวแปรสภาพแวดล้อม `PATH' (ซึ่งในทางกลับกัน ระบุโดย
ตัวแปรการก่อสร้าง `ENV') หากพบคำสั่งนี้บนเส้นทาง เป้าหมายจะ
ขึ้นอยู่กับมัน: คำสั่งจะถูกสร้างขึ้นโดยอัตโนมัติตามความจำเป็น มันคือ
เป็นไปได้ที่จะเขียนคำสั่งแบบหลายส่วนไปยังเชลล์บางตัว คั่นด้วยเซมิโคลอน เพียง
คำคำสั่งแรกจะขึ้นอยู่กับ อย่างไรก็ตาม ถ้าคุณเขียนสตริงคำสั่งของคุณ
ด้วยวิธีนี้ คุณต้องตั้งค่าการพึ่งพาอย่างชัดเจน (ด้วยวิธี "ขึ้นอยู่กับ" หรือ
ตรวจสอบให้แน่ใจว่าคำสั่งที่คุณใช้เป็นคำสั่งระบบที่คาดว่าจะเป็น
มีอยู่. หากไม่พร้อมใช้งาน คุณจะได้รับข้อผิดพลาดแน่นอน
หากคำสั่งใดๆ (แม้แต่คำสั่งเดียวในคำสั่งหลายบรรทัด) เริ่มต้นด้วย `[perl]' ส่วนที่เหลือ
ของบรรทัดคำสั่งนั้นจะถูกประเมินโดย Perl ที่ทำงานอยู่แทนที่จะถูกแยกโดย
เปลือก. หากเกิดข้อผิดพลาดในการแยกวิเคราะห์ Perl หรือถ้านิพจน์ Perl คืนค่า 0 หรือ
undef คำสั่งจะถือว่าล้มเหลว ตัวอย่างเช่น นี่คือคำง่ายๆ
คำสั่งที่สร้างไฟล์ `foo' โดยตรงจาก Perl:
$env = ข้อเสียใหม่ ();
คำสั่ง $env 'foo'
qq([perl] open(FOO,'>foo');print FOO "hi\\n"; close(FOO); 1);
โปรดทราบว่าเมื่อดำเนินการคำสั่ง คุณจะอยู่ในแพ็คเกจเดียวกันกับเมื่อ สร้าง
or ที่ถูกเกณฑ์ทหาร ไฟล์ถูกอ่าน ดังนั้นคุณสามารถเรียกใช้ฟังก์ชัน Perl ที่คุณกำหนดไว้ในไฟล์เดียวกันได้
สร้าง or ที่ถูกเกณฑ์ทหาร ไฟล์ที่ `Command' ปรากฏ:
$env = ข้อเสียใหม่ ();
ย่อย create_file {
ไฟล์ $ ของฉัน = shift;
open(FILE, ">$ไฟล์");
พิมพ์ไฟล์ "สวัสดี\n";
ปิด (ไฟล์);
1 กลับ;
}
คำสั่ง $env 'foo', "[perl] &create_file('%>')";
สตริง Perl จะใช้เพื่อสร้างลายเซ็นสำหรับไฟล์ที่ได้รับ ดังนั้นหากคุณ
เปลี่ยนสตริง ไฟล์จะถูกสร้างขึ้นใหม่ เนื้อหาของรูทีนย่อยที่คุณเรียก
อย่างไรก็ตาม ไม่ได้เป็นส่วนหนึ่งของลายเซ็น ดังนั้นหากคุณแก้ไขรูทีนย่อยที่เรียกว่า
`create_file' ด้านบน เป้าหมายจะ ไม่ จะถูกสร้างขึ้นใหม่ ผู้ใช้คำเตือน
ข้อเสีย ปกติจะพิมพ์คำสั่งก่อนดำเนินการ พฤติกรรมนี้จะถูกระงับหาก
อักขระตัวแรกของคำสั่งคือ `@' โปรดทราบว่าคุณอาจต้องแยก `@' ออกจาก
ชื่อคำสั่งหรือ Escape เพื่อป้องกันไม่ให้ `@cmd' ดูเหมือนอาร์เรย์ไปยัง Perl quote
ตัวดำเนินการที่ทำการแก้ไข:
# บรรทัดคำสั่งแรกไม่ถูกต้อง
#เพราะว่า "@cp" ดูเหมือนอาร์เรย์
# ไปยังฟังก์ชัน Perl qq//
#ใช้แบบที่สองแทน
คำสั่ง $env 'foo', 'foo.in', qq(
@cp %< tempfile
@ cp tempfile %>
);
หากมีอักขระเมตาเชลล์อยู่ที่ใดก็ได้ในบรรทัดคำสั่งที่ขยาย เช่น `<'
`>', เครื่องหมายคำพูดหรือเซมิโคลอน จากนั้นคำสั่งจะถูกดำเนินการจริงโดยเรียกใช้ a
เปลือก. ซึ่งหมายความว่าคำสั่งเช่น:
ซีดี ฟู
เพียงอย่างเดียวมักจะล้มเหลวเนื่องจากไม่มีคำสั่ง `cd' บนเส้นทาง แต่คำสั่ง
สตริง:
cd $<:d; tar cf $>:f $<:f
เมื่อขยายจะยังคงประกอบด้วยเซมิโคลอนของอักขระเมตาของเชลล์ และเชลล์จะเป็น
เรียกให้ตีความคำสั่ง เนื่องจากเชลล์ย่อยนี้ตีความ `cd' คำสั่ง
จะดำเนินการตามที่คาดไว้
ในการระบุคำสั่งที่มีหลายเป้าหมาย คุณสามารถระบุการอ้างอิงไปยังรายการของ
เป้าหมาย ใน Perl สามารถสร้างการอ้างอิงรายการได้โดยการใส่รายการไว้ในวงเล็บเหลี่ยม
ดังนั้นคำสั่งต่อไปนี้:
คำสั่ง $env ['foo.h', 'foo.c'], 'foo.template', q(
รุ่น %1
);
สามารถใช้ในกรณีที่คำสั่ง `gen' สร้างสองไฟล์ทั้ง ฟู และ ฟู.ซี.
พื้นที่ `วัตถุ' วิธี
วิธีการ `วัตถุ' จัดเรียงเพื่อสร้างไฟล์วัตถุที่สอดคล้องกับที่ระบุ
ไฟล์ต้นฉบับ มันถูกเรียกใช้ตามที่แสดงด้านล่าง:
@files = วัตถุ $env ;
ภายใต้ Unix ไฟล์ต้นฉบับที่ลงท้ายด้วย .s และ .c ได้รับการสนับสนุนในขณะนี้และจะถูกรวบรวม
เป็นชื่อไฟล์เดียวกันที่ลงท้ายด้วย .o. ตามค่าเริ่มต้น ไฟล์ทั้งหมดจะถูกสร้างขึ้นโดยการเรียกใช้
คำสั่งภายนอกซึ่งเป็นผลมาจากการขยายตัวแปรการสร้าง `CCCOM' ด้วย
`%<' และ `%>' ถูกตั้งค่าเป็นไฟล์ต้นทางและอ็อบเจกต์ตามลำดับ (ดูวิธี `Command'
สำหรับรายละเอียดการขยาย) ตัวแปร `CPPPATH' ยังใช้เมื่อสแกนไฟล์ต้นฉบับ
สำหรับการพึ่งพา นี่คือรายการชื่อพาธที่คั่นด้วยโคลอน และยังใช้เพื่อสร้าง
ตัวแปรการก่อสร้าง `_IFLAGS' ซึ่งจะมีรายการที่เหมาะสมของ -`I'
ตัวเลือกสำหรับการรวบรวม ชื่อพาธที่สัมพันธ์กันใน `CPPPATH' จะถูกตีความว่าสัมพันธ์กัน
ไปยังไดเร็กทอรีที่สร้างสภาพแวดล้อมการก่อสร้างที่เกี่ยวข้อง (absolute
และอาจใช้ชื่อที่สัมพันธ์กันระดับบนสุดก็ได้) ตัวแปรนี้ถูกใช้โดย `CCCOM' พฤติกรรม
ของคำสั่งนี้สามารถแก้ไขได้โดยเปลี่ยนตัวแปรใด ๆ ที่มีการสอดแทรก
เป็น 'CCCOM' เช่น 'CC', 'CFLAGS' และทางอ้อม 'CPPPATH' นอกจากนี้ยังสามารถ
แทนที่ค่าของ `CCCOM' เอง เพื่อความสะดวก ไฟล์นี้จะส่งคืนรายการของ
ชื่อไฟล์อ็อบเจ็กต์
พื้นที่ 'โปรแกรม' วิธี
เมธอด `Program' จัดเรียงเพื่อเชื่อมโยงโปรแกรมที่ระบุกับอ็อบเจกต์ที่ระบุ
ไฟล์. เรียกใช้ในลักษณะต่อไปนี้:
โปรแกรม $env , ;
ชื่อโปรแกรมจะมีค่าของตัวแปรการก่อสร้าง `SUFEXE' ต่อท้าย (by
ค่าเริ่มต้น `.exe' บนระบบ Win32 ไม่มีอะไรบนระบบ Unix) หากคำต่อท้ายยังไม่มีอยู่
นำเสนอ.
ไฟล์ต้นฉบับอาจถูกระบุแทนที่ไฟล์อ็อบเจ็กต์ -- วิธีการ `Objects' จะเป็น
เรียกให้จัดการแปลงไฟล์ทั้งหมดเป็นไฟล์อ็อบเจ็กต์และด้วยเหตุนี้ทั้งหมด
การสังเกตเกี่ยวกับวิธีการ `วัตถุ' ข้างต้น นำไปใช้กับวิธีนี้ด้วย
การเชื่อมโยงจริงของโปรแกรมจะถูกจัดการโดยคำสั่งภายนอกซึ่งส่งผลให้
จากการขยายตัวแปรการสร้าง `LINKCOM' โดยตั้งค่า `%<' เป็นไฟล์อ็อบเจ็กต์เป็น
เชื่อมโยง (ตามลำดับที่แสดง) และตั้งค่า `%>' เป็นเป้าหมาย (ดูวิธี `Command'
สำหรับรายละเอียดการขยาย) ผู้ใช้อาจตั้งค่าตัวแปรเพิ่มเติมในการก่อสร้าง
สภาพแวดล้อม รวมถึง `LINK' เพื่อกำหนดโปรแกรมที่จะใช้สำหรับการเชื่อมโยง `LIBPATH', a
รายการเส้นทางการค้นหาไลบรารีที่คั่นด้วยเครื่องหมายทวิภาค สำหรับใช้กับข้อกำหนดไลบรารีของ
ฟอร์ม -llibและ `LIBS' ที่ระบุรายการไลบรารีที่จะเชื่อมโยง (ใน -llib
แบบฟอร์มหรือเพียงแค่เป็นชื่อพาธ ชื่อพาธสัมพัทธ์ทั้งใน 'LIBPATH' และ 'LIBS' ถูกตีความ
สัมพันธ์กับไดเร็กทอรีที่สร้างสภาพแวดล้อมการก่อสร้างที่เกี่ยวข้อง
(อาจใช้ชื่อสัมบูรณ์และชื่อญาติระดับบนสุดก็ได้) ข้อเสียตั้งค่าโดยอัตโนมัติ
การพึ่งพาไลบรารีใด ๆ ที่กล่าวถึงใน 'LIBS': ไลบรารีเหล่านั้นจะถูกสร้างขึ้นมาก่อน
คำสั่งถูกเชื่อมโยง
พื้นที่ 'ห้องสมุด' วิธี
เมธอด 'Library' จัดสร้างไลบรารีที่ระบุจากอ็อบเจกต์ที่ระบุ
ไฟล์. เรียกใช้ได้ดังนี้
ห้องสมุด $env , ;
ชื่อไลบรารีจะมีค่าของตัวแปรการก่อสร้าง `SUFLIB' ต่อท้าย (by
ค่าเริ่มต้น, `.lib' บนระบบ Win32, `.a' บนระบบ Unix) หากคำต่อท้ายนั้นยังไม่มีอยู่
นำเสนอ.
ไฟล์ต้นฉบับอาจถูกระบุแทนที่ไฟล์อ็อบเจ็กต์ -- วิธีการ `Objects' จะเป็น
เรียกให้จัดการแปลงไฟล์ทั้งหมดเป็นไฟล์อ็อบเจ็กต์และด้วยเหตุนี้ทั้งหมด
การสังเกตเกี่ยวกับวิธีการ `วัตถุ' ข้างต้น นำไปใช้กับวิธีนี้ด้วย
การสร้างห้องสมุดจริงจะได้รับการจัดการโดยคำสั่งภายนอกซึ่งส่งผลให้
จากการขยายตัวแปรการสร้าง `ARCOM' โดยที่ `%<' ตั้งค่าเป็นสมาชิกไลบรารี (in
ลำดับที่นำเสนอ) และ `%>' ไปยังไลบรารีที่จะสร้าง (ดูวิธี `Command' สำหรับ
รายละเอียดการขยาย) ผู้ใช้อาจตั้งค่าตัวแปรในสภาพแวดล้อมการก่อสร้างซึ่งจะ
ส่งผลต่อการทำงานของคำสั่ง ซึ่งรวมถึง `AR' โปรแกรมเก็บถาวรที่จะใช้
`ARFLAGS' ซึ่งสามารถใช้เพื่อแก้ไขแฟล็กที่กำหนดให้กับโปรแกรมที่ระบุโดย `AR'
และ `RANLIB' ชื่อของโปรแกรมสร้างดัชนีไฟล์เก็บถาวร หากจำเป็น (หากเฉพาะ
need ไม่ต้องการฟังก์ชันหลัง ดังนั้น `ARCOM' จะต้องถูกกำหนดใหม่เป็น not
อ้างอิง `RANLIB')
เมธอด `Library' อนุญาตให้ระบุไลบรารีเดียวกันได้หลายวิธี
การร้องขอ วัตถุที่ร่วมทั้งหมดจากการวิงวอนทั้งหมด (ซึ่งอาจมาจาก
ไดเร็กทอรีที่แตกต่างกัน) ถูกรวมและสร้างโดยคำสั่ง archive เดียว บันทึก,
อย่างไรก็ตาม ถ้าคุณตัดบิลด์เพื่อระบุเฉพาะบางส่วนของไลบรารี ดังนั้นเท่านั้น
ส่วนหนึ่งของห้องสมุดจะถูกสร้างขึ้น (ส่วนที่เหลือจะหายไป!)
พื้นที่ 'โมดูล' วิธี
วิธีการ "โมดูล" เป็นการผสมผสานระหว่างวิธี "โปรแกรม" และ "คำสั่ง" ค่อนข้างมากกว่า
สร้างโปรแกรมปฏิบัติการได้โดยตรง คำสั่งนี้อนุญาตให้คุณระบุของคุณเอง
คำสั่งเพื่อสร้างโมดูลจริง วิธีการถูกเรียกใช้ดังนี้:
โมดูล $env , , ;
คำสั่งนี้มีประโยชน์ในกรณีที่คุณต้องการสร้าง เช่น ไดนามิก
โมดูลที่โหลดหรือไลบรารีโค้ดที่เชื่อมโยงแบบสแตติก
พื้นที่ 'ขึ้นอยู่กับ' วิธี
วิธีการ 'ขึ้นอยู่กับ' ช่วยให้คุณสามารถระบุการพึ่งพาเพิ่มเติมสำหรับเป้าหมาย มันคือ
เรียกใช้ดังนี้:
ขึ้นอยู่กับ $env , ;
สิ่งนี้อาจมีประโยชน์ในบางครั้ง โดยเฉพาะอย่างยิ่งในกรณีที่ไม่มีเครื่องสแกนอยู่ (หรือ is
เขียนได้) สำหรับไฟล์บางประเภท โดยปกติ การอ้างอิงจะถูกคำนวณ
โดยอัตโนมัติจากการรวมกันของการพึ่งพาที่ชัดเจนซึ่งตั้งค่าโดยเมธอด
เรียกหรือโดยการสแกนไฟล์ต้นฉบับ
อาจระบุชุดของการพึ่งพาที่เหมือนกันสำหรับหลายเป้าหมายโดยใช้การอ้างอิงถึง
รายการเป้าหมาย ใน Perl สามารถสร้างการอ้างอิงรายการได้โดยการใส่รายการใน square
วงเล็บ ดังนั้นคำสั่งต่อไปนี้:
ขึ้นอยู่กับ $env ['foo', 'bar'], 'input_file_1', 'input_file_2';
ระบุว่าทั้ง foo และ บาร์ ไฟล์ขึ้นอยู่กับไฟล์อินพุตที่แสดง
พื้นที่ 'ละเว้น' วิธี
วิธีการ 'ละเว้น' ช่วยให้คุณละเว้นการพึ่งพาอย่างชัดเจนที่ Cons อนุมานบน
เป็นเจ้าของ. เรียกใช้ได้ดังนี้
ไม่สนใจ ;
สามารถใช้เพื่อหลีกเลี่ยงการคอมไพล์ใหม่เนื่องจากการเปลี่ยนแปลงในไฟล์ส่วนหัวของระบบหรือ
ยูทิลิตี้ที่ทราบว่าไม่ส่งผลกระทบต่อเป้าหมายที่สร้างขึ้น
ตัวอย่างเช่น หากโปรแกรมถูกสร้างขึ้นในไดเร็กทอรีที่เมาท์ NFS ในหลายระบบที่
มีสำเนาที่แตกต่างกันของ stdio.hความแตกต่างจะส่งผลต่อลายเซ็นของทั้งหมด
เป้าหมายที่ได้รับซึ่งสร้างจากไฟล์ต้นฉบับที่ `#include '. นี้จะทำให้ทั้งหมด
เป้าหมายเหล่านั้นจะถูกสร้างขึ้นใหม่เมื่อเปลี่ยนระบบ หากไม่เป็นกิริยาที่พึงประสงค์
จากนั้นบรรทัดต่อไปนี้จะลบการพึ่งพาบน stdio.h ไฟล์:
ละเว้น '^/usr/include/stdio\.h$';
โปรดทราบว่าอาร์กิวเมนต์ของวิธีการ 'ละเว้น' เป็นนิพจน์ทั่วไป พิเศษมาก
ต้องหนีอักขระและคุณอาจต้องการยึดจุดเริ่มต้นหรือจุดสิ้นสุดของ
นิพจน์ด้วยอักขระ `^' หรือ `$'
พื้นที่ 'เกลือ' วิธี
วิธี `เกลือ' เพิ่มค่าคงที่ให้กับการคำนวณลายเซ็นสำหรับทุกๆ ค่าที่ได้รับ
ไฟล์. เรียกใช้ได้ดังนี้
เกลือ $สตริง;
การเปลี่ยนค่า Salt จะบังคับให้สร้างไฟล์ที่ได้รับทุกไฟล์ขึ้นมาใหม่ทั้งหมด นี้สามารถ
ใช้เพื่อบังคับให้สร้างใหม่ในสถานการณ์ที่ต้องการ ตัวอย่างเช่น,
เกลือ `uname -s`;
จะบังคับให้สร้างไฟล์ที่ได้รับใหม่ทั้งหมดทุกครั้งที่ระบบปฏิบัติการเปิด
ที่ดำเนินการสร้าง (ตามที่รายงานโดย `uname -s') เปลี่ยนแปลง
พื้นที่ 'ใช้แคช' วิธี
วิธี `UseCache' สั่งให้ Cons รักษาแคชของไฟล์ที่ได้รับ เพื่อแชร์
ท่ามกลางต้นไม้ที่สร้างแยกจากโครงการเดียวกัน
UseCache("แคช/ ") ⎪⎪ warn("ไม่พบไดเรกทอรีแคช");
พื้นที่ `เส้นทางแหล่งที่มา' วิธี
mathod `SourcePath' ส่งคืนชื่อพาธต้นทางที่แท้จริงของไฟล์ ตรงข้ามกับ
ชื่อพาธภายในไดเร็กทอรีบิลด์ เรียกใช้ได้ดังนี้
$path = SourcePath ;
พื้นที่ 'คอนส์พาธ' วิธี
เมธอด `ConsPath' จะคืนค่าเป็น จริง หากพาธที่ให้มานั้นเป็นไฟล์ที่สืบทอดได้ และคืนค่า
undef (เท็จ) อย่างอื่น เรียกใช้ได้ดังนี้
$result = คอนพาธ ;
พื้นที่ `เส้นทางแยก' วิธี
เมธอด `SplitPath' จะค้นหาชื่อพาธหลายชื่อในสตริงที่คั่นด้วยค่าดีฟอลต์
ตัวคั่นพาธสำหรับระบบปฏิบัติการ (':' บนระบบ UNIX, ';' บน Windows NT) และ
ส่งคืนชื่อที่มีคุณสมบัติครบถ้วน เรียกใช้ได้ดังนี้
@paths = SplitPath ;
เมธอด `SplitPath' จะแปลงชื่อที่นำหน้า '#' เป็นบิลด์ระดับบนสุดที่เหมาะสม
ชื่อ (ไม่มี '#') และจะเปลี่ยนชื่อสัมพันธ์เป็นชื่อระดับบนสุด
พื้นที่ 'ไดร์พาธ' วิธี
เมธอด `DirPath' ส่งคืนพาธบิลด์ ชื่อ(s) ของไดเร็กทอรีหรือรายการไดเร็กทอรี
เรียกใช้ได้ดังนี้
$cwd = DirPath ;
การใช้งานทั่วไปสำหรับวิธี `DirPath' คือ:
$cwd = DirPath '.';
เพื่อดึงเส้นทางไปยังไดเร็กทอรีปัจจุบันของ บริษัท ย่อย ที่ถูกเกณฑ์ทหาร ไฟล์
พื้นที่ `เส้นทางไฟล์' วิธี
เมธอด `FilePath' ส่งคืนพาธบิลด์ ชื่อ(s) ของไฟล์หรือรายการของไฟล์ มันคือ
เรียกใช้ดังนี้:
$file = FilePath ;
พื้นที่ 'ช่วย' วิธี
เมธอด `Help' ระบุข้อความช่วยเหลือที่จะแสดงเมื่อผู้ใช้เรียก `cons
-ชม'. สามารถใช้เพื่อจัดเตรียมเอกสารของเป้าหมาย ค่านิยม build . ที่เฉพาะเจาะจง
ตัวเลือก ฯลฯ สำหรับแผนผังการสร้าง เรียกใช้ได้ดังนี้
ช่วย ;
วิธีการ `Help' สามารถเรียกได้เพียงครั้งเดียว และโดยทั่วไปควรระบุไว้ที่ด้านบน-
ระดับ สร้าง ไฟล์
ขยาย จุดด้อย
ที่เอาชนะ การก่อสร้าง ตัวแปร
มีหลายวิธีในการขยายข้อเสีย ซึ่งแตกต่างกันไปตามระดับความยาก ง่ายที่สุด
วิธีคือการกำหนดสภาพแวดล้อมการก่อสร้างของคุณเองตามสภาพแวดล้อมเริ่มต้น
แต่ปรับเปลี่ยนเพื่อสะท้อนความต้องการเฉพาะของคุณ นี้มักจะเพียงพอสำหรับ C-based
แอปพลิเคชัน คุณสามารถใช้คอนสตรัคเตอร์ 'ใหม่' และวิธีการ 'โคลน' และ 'คัดลอก' ไปที่
สร้างสภาพแวดล้อมแบบไฮบริด การเปลี่ยนแปลงเหล่านี้สามารถโปร่งใสได้ทั้งหมดต่อผู้ที่อยู่ภายใต้
ที่ถูกเกณฑ์ทหาร ไฟล์
เพิ่ม ใหม่ วิธีการ
สำหรับการเปลี่ยนแปลงที่มีความต้องการมากขึ้นเล็กน้อย คุณอาจต้องการเพิ่มวิธีการใหม่ให้กับ `ข้อเสีย'
บรรจุุภัณฑ์. นี่คือตัวอย่างส่วนขยายง่ายๆ อย่าง `InstallScript' ซึ่งติดตั้ง a
สคริปต์ tcl ในตำแหน่งที่ร้องขอ แต่แก้ไขสคริปต์ก่อนเพื่อสะท้อนถึงแพลตฟอร์ม-
เส้นทางที่ขึ้นต่อกันที่ต้องติดตั้งในสคริปต์:
# cons::InstallScript - สร้างเวอร์ชันที่ขึ้นกับแพลตฟอร์มของเชลล์
# สคริปต์โดยแทนที่สตริง ``#!your-path-here'' ด้วยเฉพาะแพลตฟอร์ม
# เส้นทาง $BIN_DIR
ข้อเสียย่อย::InstallScript {
ของฉัน ($env, $dst, $src) = @_;
คำสั่ง $env $dst, $src, qq(
sed s+your-path-here+$BIN_DIR+ %< > %>
chmod oug+x %>
);
}
ขอให้สังเกตว่าวิธีการนี้ถูกกำหนดโดยตรงในแพ็คเกจ `cons' (โดยนำหน้าชื่อ
ด้วย `ข้อเสีย::') การเปลี่ยนแปลงในลักษณะนี้จะมองเห็นได้ทั่วโลกต่อทุกสภาพแวดล้อม
และสามารถเรียกได้ดังตัวอย่างต่อไปนี้
InstallScript $env "$BIN/foo", "foo.tcl";
สำหรับการปรับปรุงโดยทั่วไปเล็กน้อย ตัวแปร `BINDIR' สามารถส่งผ่านในรูปแบบ an
อาร์กิวเมนต์หรือนำมาจากสภาพแวดล้อมการก่อสร้าง -- เป็น `%BINDIR'
ที่เอาชนะ วิธีการ
แทนที่จะเพิ่มเมธอดลงในเนมสเปซ "ข้อเสีย" คุณสามารถกำหนดแพ็กเกจใหม่ได้
ซึ่งสืบทอดวิธีการที่มีอยู่จากแพ็คเกจ `cons' และแทนที่หรือเพิ่มอย่างอื่น นี้
สามารถทำได้โดยใช้กลไกการสืบทอดของ Perl
ตัวอย่างต่อไปนี้กำหนดแพ็คเกจใหม่ `cons::switch' ซึ่งแทนที่มาตรฐาน
วิธีการ 'ห้องสมุด' วิธีการแทนที่สร้างโมดูลไลบรารีที่เชื่อมโยง แทนที่จะเป็นไลบรารี
เอกสารสำคัญ มีการสร้างคอนสตรัคเตอร์ใหม่ สภาพแวดล้อมที่สร้างขึ้นด้วยตัวสร้างนี้ will
มีวิธีห้องสมุดใหม่ คนอื่นจะไม่
แพ็คเกจข้อเสีย::สวิตช์;
เริ่มต้น {@ISA = 'ข้อเสีย'}
ย่อยใหม่ {
กะ;
อวยพรข้อเสียใหม่(@_);
}
ห้องสมุดย่อย {
my($env) = กะ;
my($lib) = กะ;
my(@objs) = วัตถุ $env @_;
คำสั่ง $env $lib, @objs, q(
%LD -r %LDFLAGS %< -o %>
);
}
ฟังก์ชันนี้สามารถเรียกใช้ได้ดังตัวอย่างต่อไปนี้:
$env = ข้อเสียใหม่ :: switch(@overrides);
...
ห้องสมุด $env 'lib.o', 'foo.c', 'bar.c';
กล่าวอ้าง จุดด้อย
คำสั่ง `cons' มักจะถูกเรียกใช้จากรูทของแผนผังการสร้าง อา สร้าง ไฟล์
ต้องมีอยู่ในไดเร็กทอรีนั้น หากใช้อาร์กิวเมนต์ `-f' แทน สร้าง
อาจใช้ไฟล์ได้ (และอาจเป็นรูทสำรอง เนื่องจาก `cons' จะเป็น cd to สร้าง
ไฟล์ที่มีไดเร็กทอรี)
หากมีการเรียกใช้ `cons' จากลูกของรูทของทรีบิวด์ด้วยอาร์กิวเมนต์ `-t'
จะเดินขึ้นลำดับชั้นของไดเร็กทอรีมองหา a สร้าง ไฟล์. (ชื่ออื่นอาจ
ยังคงระบุด้วย `-f'.) เป้าหมายที่ให้มาในบรรทัดคำสั่งจะถูกแก้ไข
ที่จะสัมพันธ์กับสิ่งที่ค้นพบ สร้าง ไฟล์. ตัวอย่างเช่น จากไดเร็กทอรีที่มี
ระดับบนสุด สร้าง ไฟล์การเรียกใช้ต่อไปนี้:
% ซีดี libfoo/subdir
ข้อเสีย % -t เป้าหมาย
เทียบเท่ากับ:
% ข้อเสีย libfoo/subdir/target
หากมีเป้าหมาย "เริ่มต้น" ที่ระบุไว้ในลำดับชั้นของไดเรกทอรี สร้าง or
ที่ถูกเกณฑ์ทหาร ไฟล์ เฉพาะเป้าหมายเริ่มต้นที่หรือด้านล่างไดเร็กทอรีที่ `cons -t'
ถูกเรียกจะถูกสร้างขึ้น
คำสั่งถูกเรียกใช้ดังนี้:
ข้อเสีย --
ที่ไหน ข้อโต้แย้ง สามารถเป็นอย่างใดอย่างหนึ่งต่อไปนี้ ในลำดับใดก็ได้:
เป้า สร้างเป้าหมายที่กำหนด ถ้า เป้า เป็นไดเร็กทอรี แล้ว recursively build
ทุกอย่างภายในไดเร็กทอรีนั้น
+รูปแบบ จำกัด การ ที่ถูกเกณฑ์ทหาร ไฟล์ที่พิจารณาเฉพาะไฟล์ที่ตรงกัน Belt hold ซึ่งเป็น
นิพจน์ทั่วไปของ Perl ยอมรับอาร์กิวเมนต์ `+' หลายรายการ
ชื่อ=
ชุดอุปกรณ์ ชื่อ มูลค่า คลื่น ในแฮช `ARG' ที่ส่งผ่านไปยังระดับบนสุด สร้าง ไฟล์
`-cc' แสดงคำสั่งที่จะถูกดำเนินการ เมื่อดึงข้อมูลจากแคช ไม่
บ่งชี้ว่าได้รับไฟล์ที่ได้รับ; สิ่งนี้มีประโยชน์สำหรับ
การสร้างบันทึกการสร้างที่สามารถเปรียบเทียบกับบันทึกการสร้างจริง
`-cd' ปิดใช้งานการแคชทั้งหมด อย่าดึงจากแคชหรือล้างไปยังแคช
`-cr' สร้างการพึ่งพาในลำดับแบบสุ่ม สิ่งนี้มีประโยชน์เมื่อสร้างหลายรายการ
ต้นไม้ที่คล้ายกันที่เปิดใช้งานการแคช
`-cs' ซิงโครไนซ์เป้าหมายการสร้างที่มีอยู่ซึ่งพบว่ามีแคชเป็นปัจจุบัน
สิ่งนี้มีประโยชน์หากปิดใช้งานการแคชด้วย -cc หรือเพิ่งเปิดใช้งานเมื่อเร็ว ๆ นี้
ด้วย UseCache
`-d' เปิดใช้งานการดีบักการพึ่งพา
`-f'
ใช้ไฟล์ที่ระบุแทน สร้าง (แต่ก่อนอื่นให้เปลี่ยนเป็นมี
ไดเรกทอรีของ ไฟล์).
`-h' แสดงข้อความช่วยเหลือในเครื่องไปยังบิลด์ปัจจุบันหากมีการกำหนดไว้และออก
`-k' ทำต่อไปให้ไกลที่สุดหลังจากเกิดข้อผิดพลาด
`-o'
อ่านไฟล์แทนที่ ไฟล์.
`-p' แสดงสินค้าก่อสร้างตามต้นไม้ที่กำหนด ไม่มีการพยายามสร้าง
`-pa' แสดงผลิตภัณฑ์ก่อสร้างและการดำเนินการที่เกี่ยวข้อง ไม่มีการพยายามสร้าง
`-pw' แสดงผลิตภัณฑ์และตำแหน่งที่กำหนดไว้ ไม่มีการพยายามสร้าง
`-q' อย่าใช้อย่างละเอียดเกี่ยวกับการติดตั้งและการลบเป้าหมาย
`-r' ลบผลิตภัณฑ์ก่อสร้างที่เกี่ยวข้องกับ . ไม่มีการพยายามสร้าง
`-อาร์'
ค้นหาไฟล์ใน ส่วนที่เหลือ. หลายรายการ -R ส่วนที่เหลือ ไดเร็กทอรีถูกค้นหาใน
คำสั่งที่ระบุ
`-t' สำรวจลำดับชั้นของไดเร็กทอรีเพื่อค้นหา a สร้าง ไฟล์หากไม่มีอยู่
ในไดเร็กทอรีปัจจุบัน เป้าหมายจะถูกแก้ไขให้สัมพันธ์กับ
สร้าง ไฟล์
`-v' แสดงเวอร์ชัน `cons' และดำเนินการประมวลผลต่อ
`-V' แสดงเวอร์ชัน `ข้อเสีย' และออก
`-wf'
เขียนชื่อไฟล์ทั้งหมดที่พิจารณาเป็น ไฟล์.
`-x' แสดงข้อความช่วยเหลือที่คล้ายกับข้อความนี้ และออก
และ สร้าง-args สามารถเป็นข้อโต้แย้งใด ๆ ที่คุณต้องการดำเนินการใน สร้าง ไฟล์
โปรดทราบว่าควรมี a -- แยกข้อโต้แย้งออกเป็นข้อโต้แย้งและข้อโต้แย้งที่คุณ
ต้องการประมวลผลใน สร้าง ไฟล์
การประมวลผลของ สร้าง-args สามารถทำได้โดยแพ็คเกจมาตรฐานเช่น รับ หรือ
ตัวแปรหรือแพ็คเกจที่ผู้ใช้กำหนด ข้อเสีย จะผ่านใน สร้าง-args as @ARGV และ
จะไม่พยายามตีความสิ่งใดหลังจาก --.
% ข้อเสีย -R /usr/local/repository -d os=solaris +driver -- -c test -f DEBUG
จะส่งต่อไป cons
-R /usr/local/repository -d os=solaris +ไดรเวอร์
และต่อไปนี้ถึงระดับบนสุด สร้าง ไฟล์เป็น @ARGV
-c ทดสอบ -f DEBUG
โปรดทราบว่า `cons -r .' เทียบเท่ากับ `make clean' แบบเรียกซ้ำแบบเต็ม แต่ไม่ต้องการ
สนับสนุนใน สร้าง ไฟล์หรืออะไรก็ได้ ที่ถูกเกณฑ์ทหาร ไฟล์. สิ่งนี้มีประโยชน์มากที่สุดหากคุณเป็น
รวบรวมไฟล์ลงในไดเร็กทอรีต้นทาง (ถ้าคุณแยก สร้าง และ ส่งออก ไดเรกทอรี
จากนั้นคุณสามารถลบไดเร็กทอรีได้)
ตัวเลือก `-p', `-pa' และ `-pw' มีประโยชน์อย่างมากสำหรับใช้เป็นตัวช่วยในการอ่าน
สคริปต์หรือการดีบัก หากคุณต้องการทราบว่าสคริปต์ใดติดตั้งอยู่ ส่งออก/รวม/foo.h,
ตัวอย่างเช่น เพียงพิมพ์:
% ข้อเสีย -pw ส่งออก/รวม/foo.h
การใช้ และ การเขียน เมืองขึ้น สแกนเนอร์
QuickScan อนุญาตให้ตั้งค่าสแกนเนอร์ที่ไม่ขึ้นกับเป้าหมายอย่างง่ายสำหรับไฟล์ต้นทาง เท่านั้น
เครื่องสแกน QuickScan หนึ่งเครื่องอาจเชื่อมโยงกับไฟล์ต้นทางและสภาพแวดล้อมที่กำหนด
QuickScan ถูกเรียกใช้ดังนี้:
QuickScan CONSENV CODEREF, ชื่อไฟล์ [, เส้นทาง]
รูทีนย่อยที่อ้างอิงโดย CODEREF คาดว่าจะส่งคืนรายชื่อไฟล์ที่รวมอยู่ด้วย
โดยตรงโดย FILE ในทางกลับกัน ชื่อไฟล์เหล่านี้จะถูกสแกน อาร์กิวเมนต์ PATH ทางเลือก
ให้เส้นทางการค้นหาเพื่อค้นหา FILENAME และ/หรือไฟล์ที่ส่งคืนโดยผู้ใช้
รูทีนย่อย PATH อาจเป็นการอ้างอิงถึงอาร์เรย์ของชื่อไดเร็กทอรีการค้นหาหรือa
สตริงของชื่อที่คั่นด้วยอักขระตัวคั่นของระบบ (':' บนระบบ UNIX, ';' บน
วินโดวส์เอ็นที)
รูทีนย่อยถูกเรียกหนึ่งครั้งสำหรับแต่ละบรรทัดในไฟล์ โดยที่ $_ ถูกตั้งค่าเป็นบรรทัดปัจจุบัน
หากรูทีนย่อยต้องการดูบรรทัดเพิ่มเติม หรือทั้งไฟล์
จากนั้นมันสามารถอ่านได้เองจาก filehandle SCAN นอกจากนี้ยังอาจยุติการวนซ้ำหาก
มันรู้ดีว่าไม่มีข้อมูลเพิ่มเติมโดยปิดการจัดการไฟล์
ไม่ว่าจะมีเส้นทางการค้นหาหรือไม่ QuickScan จะพยายามค้นหาไฟล์ก่อน
สัมพันธ์กับไดเร็กทอรีปัจจุบัน (สำหรับไฟล์ระดับบนสุดที่ส่งไปยัง QuickScan โดยตรง)
หรือจากไดเร็กทอรีที่มีไฟล์ที่อ้างอิงถึงไฟล์ นี่ไม่ค่อย
ทั่วๆ ไป แต่ดูดีพอ -- โดยเฉพาะอย่างยิ่งถ้าคุณมีความหรูหราในการเขียนของคุณเอง
สาธารณูปโภคและสามารถควบคุมการใช้เส้นทางการค้นหาด้วยวิธีมาตรฐาน ในที่สุด
เส้นทางการค้นหาปัจจุบันคั่นด้วยเครื่องหมายทวิภาค นี่อาจไม่ได้ทำให้ค่าย NT มีความสุข
นี่คือตัวอย่างจริง นำมาจาก a สร้าง ไฟล์ที่นี่:
ข้อเสียย่อย::SMFgen {
ของฉัน($env, @tables) = @_;
foreach $t (@tables) {
$env->QuickScan(ย่อย { /\b\S*?\.smf\b/g }, "$t.smf",
$env->{SMF_INCLUDE_PATH});
$env->คำสั่ง(
["$t.smdb.cc","$t.smdb.h","$t.snmp.cc","$t.ami.cc", "$t.http.cc"],
"$t.smf",
q(
smfgen %( %SMF_INCLUDE_OPT %) %
)
);
}
}
[โปรดทราบว่าไม่ควรใส่รูปแบบ `$env->QuickScan ...' และ `$env->Command ...'
จำเป็น แต่ด้วยเหตุผลบางอย่าง จำเป็นสำหรับการวิงวอนนี้โดยเฉพาะ สิ่งนี้ปรากฏขึ้น
เป็นข้อบกพร่องใน Perl หรือความเข้าใจผิดในส่วนของฉัน รูปแบบการร้องขอนี้ไม่ได้
ดูเหมือนจะจำเป็นเสมอ]
ค้นหาชื่อทั้งหมดของแบบฟอร์ม .smf ในไฟล์ มันจะกลับชื่อแม้ว่า
พบได้ในความคิดเห็น แต่ไม่เป็นไร (กลไกนี้ให้อภัยไฟล์พิเศษ
พวกเขาถูกละเลยโดยสันนิษฐานว่าไฟล์ที่หายไปจะถูกสังเกตเมื่อ
โปรแกรม ในตัวอย่างนี้ smfgen ถูกเรียกใช้จริง)
สแกนเนอร์ถูกเรียกใช้สำหรับไฟล์ต้นฉบับที่กำหนดเท่านั้น หากบางเป้าหมายในไฟล์ . ต้องการ
ต้นไม้. มันถูกเรียกใช้เพียงครั้งเดียวสำหรับไฟล์ต้นฉบับที่กำหนด
นี่เป็นอีกวิธีหนึ่งในการสร้างเครื่องสแกนเดียวกัน อันนี้ใช้การอ้างอิงรหัสที่ชัดเจน
และ (โดยไม่จำเป็น ในกรณีนี้) จะอ่านไฟล์ทั้งหมดเอง:
myscan ย่อย {
ของฉัน(@includes);
ทำ {
พุช(@includes, /\b\S*?\.smf\b/g);
} ในขณะที่ ;
@รวมถึง
}
โปรดทราบว่าลำดับของการวนซ้ำจะกลับกัน โดยมีการทดสอบลูปในตอนท้าย นี่คือ
เพราะบรรทัดแรกอ่านให้คุณแล้ว สแกนเนอร์นี้สามารถแนบมากับแหล่งที่มาได้
ไฟล์โดย:
QuickScan $env \myscan, "$_.smf";
การสนับสนุน AND คำแนะนำ
ข้อเสียถูกดูแลโดยชุมชนผู้ใช้ สมัครสมาชิก ส่งเมล์มาที่ ข้อเสีย-อภิปราย-
[ป้องกันอีเมล] กับร่างกาย สมัครเป็นสมาชิก.
กรุณารายงานข้อเสนอแนะใด ๆ ผ่านทาง [ป้องกันอีเมล] รายชื่อผู้รับจดหมาย
ใช้ข้อเสียออนไลน์โดยใช้บริการ onworks.net
