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

โครงการ:

ชื่อ

makepp_builtins -- คำสั่งในตัวใน makepp

DESCRIPTION

A: awk, C: &แมว,
ซีจีอาร์พี,
&chmod,
chown,
&cp,
ซีพี,
&ตัด, D: ข้อมูล, E: &สะท้อน
&ประสบการณ์ F: เท็จ,
เอฟเอ็มที, G: &เกรป H: หัว, I: &ติดตั้ง, L: &ln, M: m4,
&mkdir,
&mv, P: &เพิร์ล
&พรีโพรเซส,
&printf, R: &อาร์ม,
คือ rm, S: &เส็ด
&เรียงลำดับ, T: หาง,
&แม่แบบ
&สัมผัส,
tr, U: &ถอนการติดตั้ง
&ยูนีค Y: &ใช่

มีความเป็นไปได้เหมือนเชลล์พิเศษที่จะเรียกใช้คำสั่งในตัวในกฎ เพียง
อักขระเมตาที่รู้จักคือเครื่องหมายแสดงความคิดเห็น แบ็กสแลช เครื่องหมายอัญประกาศเดี่ยวและคู่ เท่านั้น
อาจมีคำสั่งหนึ่งคำสั่งต่อบรรทัด และไม่มีการเปลี่ยนเส้นทาง I/O (ดู "-i" และ "-o"
ด้านล่างแทน)

คำสั่งเหล่านี้ขึ้นต้นด้วย "&" ซึ่งเป็นอักขระฟังก์ชันใน Perl และไม่ใช่ valid
ตัวละครตัวแรกในเชลล์ หากไม่พบคำสั่งในตัวของชื่อนั้นก็จะ
ไวยากรณ์สำหรับการเรียกสคริปต์ภายนอกภายในอินสแตนซ์ Perl ที่ดำเนินการตามกฎ
ดู "วิ่ง"

คำสั่งเหล่านี้ เช่นเดียวกับคำสั่งที่คุณกำหนดเองและสคริปต์ Perl ยังสามารถเรียกได้ว่าเป็น a
ทำให้ฟังก์ชันส่งคืนเอาต์พุตมาตรฐาน สิ่งนี้ต้องการ Perl ที่จะสร้างสำหรับ PerlIO
การขึ้นบรรทัดใหม่จะถูกแปลงเป็นช่องว่าง ยกเว้นเมื่อประเมินภายในคำสั่ง "define"

คำแรก ;= $(&cut -d' ' -f0 $(FILES))

เมื่อคำสั่งเหล่านี้ไม่ได้เยื้องเป็นการดำเนินการของกฎ คำสั่งเหล่านี้จะถูกดำเนินการขณะอ่านค่า
เมคไฟล์ คุณยังสามารถเข้าถึงคำสั่งเหล่านี้แบบสแตนด์อโลนได้ เช่น หากคุณต้องการคุณสมบัติบางอย่าง
ไม่พร้อมใช้งานในรุ่นยูนิกซ์ ผ่านคำสั่ง makeppbuiltin

คำสั่งเหล่านี้ส่วนใหญ่อิงตามตัวแปร GNU แต่มีตัวเลือกมากมาย (เช่น --backup,
--interactive หรือ --recursive) ไม่สมเหตุสมผลใน makefile ดังนั้นแม้ว่า
พวกเขาจะง่ายต่อการนำไปใช้ใน Perl พวกเขาถูกละทิ้ง คำสั่ง Unix มากมาย
เสนอทางเลือกที่หลากหลายซึ่งครอบคลุมกรณีที่ค่อนข้างซับซ้อน (เช่น sort field
ข้อมูลจำเพาะ) ในขณะที่ยังคงถูกจำกัดโดยเนื้อแท้ อนุญาตให้เข้าถึง Perl ซึ่งก็คือ
นำเสนอต่อไปให้พลังมากขึ้นที่นี่

รายชื่อไฟล์อาจว่างเปล่า ทำให้ปลอดภัยที่จะเรียกใช้คำสั่งเหล่านี้โดยไม่เลือก
รายการ. ตัวเลือกในรูปแบบสั้นอาจติดกาวเข้าด้วยกันเหมือนใน "-ab" แทนที่จะเป็น "-a -b"
ในรูปแบบยาว อาร์กิวเมนต์อาจติดด้วยเครื่องหมาย "=" หรือแยกกัน
ในรูปแบบย่ออาจติดกาวโดยตรงหรือแยกกัน

Standard ตัวเลือก
ตัวเลือกสองสามอย่างเป็นเรื่องธรรมดาสำหรับบิวอินหลายตัว แม้ว่าบางครั้งรูปแบบสั้น ๆ จะถูกซ่อนโดย
ตัวเลือกของคำสั่งเอง (เช่นใน "&cut -f"):

-A ชื่อไฟล์
--args-ไฟล์=ชื่อไฟล์
--อาร์กิวเมนต์-ไฟล์=ชื่อไฟล์
อ่านไฟล์และแยกวิเคราะห์ว่าเป็นช่องว่างที่ยกมา - และ/หรือขึ้นบรรทัดใหม่แยก
ตัวเลือก

-f
--บังคับ
บังคับให้สร้างไฟล์ที่ต้องการโดยพารามิเตอร์ แม้ว่าจะแตกต่างกันก็ตาม
ของไฟล์หรือไดเร็กทอรีว่างของชื่อนั้นมีอยู่แล้ว สิ่งนี้จะต้องนำหน้า "-o,
--output=filename" option ถ้ามันมีผลกับสิ่งนั้น

-i คำสั่งเชลล์
--inpipe=คำสั่งเชลล์
เริ่มคำสั่ง Shell และไพพ์เอาต์พุตไปยังบิวด์อิน สามารถเลือกได้
จะต่อท้าย "|" ตัวอักษรเพื่อระบุว่านี่คือท่อ ด้วยตัวเลือกนี้ no
ต้องระบุชื่อไฟล์ แต่ถ้าคุณต้องการที่จะดำเนินการในตัวทั้งสองไฟล์และ
เอาต์พุตไพพ์ คุณต้องใช้ "-" เป็นชื่อไฟล์สำหรับเอาต์พุตไพพ์ ท่อคือ
ว่าง แต่เว้นแต่คุณจะให้ "--infail" คำสั่งจะไม่รอดังนั้น
สามารถยุติพร้อมกันได้ ตัวเลือกนี้จำเป็นเพราะไม่มีการเปลี่ยนเส้นทาง
วากยสัมพันธ์

-I
--ล้มเหลว
หากคำสั่งเชลล์ "--inpipe" ล้มเหลว นั่นจะทำให้บิวด์อินปัจจุบันล้มเหลวด้วย
ปัจจุบันนี้ใช้ไม่ได้กับ Strawberry และ Win ActiveState เนื่องจาก
วิธีครึ่งใจที่พวกเขาเลียนแบบ Unix fork / exec Cygwin ทำให้ถูกต้องแม้ว่า

-o ชื่อไฟล์
--เอาท์พุท=ชื่อไฟล์
เขียนผลลัพธ์ไปยังไฟล์นี้ แทนที่จะเป็น stdout ชื่อไฟล์อาจมีสิ่งเหล่านี้
แบบฟอร์ม:

ชื่อไฟล์
>ชื่อไฟล์
เพียงแค่เขียนไปยังไฟล์.

>>ชื่อไฟล์
ต่อท้าย (ไม่จำเป็น) ไฟล์ที่มีอยู่

+<ชื่อไฟล์
เปิดไฟล์เพื่อป้อนข้อมูล อนุญาตให้แก้ไขแบบแทนที่ได้ ด้วยตัวเลือกนี้ ตัวแปร
ไม่จำเป็นต้องระบุชื่อไฟล์อินพุต แต่ถ้าคุณต้องการที่จะดำเนินการในตัวบน
ไฟล์มากกว่านี้ คุณต้องใช้ "-" เป็นชื่อไฟล์อินพุตสำหรับไฟล์นี้ ในความเป็นจริง
เอาต์พุตถูกเขียนลงในไฟล์ชั่วคราวซึ่งจะถูกย้ายไปที่ชื่อไฟล์ในตอนท้าย

|คำสั่งเชลล์
ไพพ์เอาต์พุตของบิวด์อินไปยังคำสั่งเชลล์

ตัวเลือกนี้จำเป็นเนื่องจากไม่มีรูปแบบการเปลี่ยนเส้นทาง

-O
--ล้มเหลว
หากคำสั่งเชลล์ "--output" ล้มเหลว นั่นจะทำให้บิวด์อินปัจจุบันล้มเหลวด้วย

-r จำนวน
--record-ขนาด=จำนวน
ตั้งค่าในเครื่อง $/ สำหรับบิวด์อินปัจจุบัน สิ่งนี้แยกอินพุตออกเป็นบันทึกความยาว
จำนวน มากกว่าทีละบรรทัด ถ้า จำนวน เป็นศูนย์ แต่ละไฟล์อินพุตโดยรวมเป็นหนึ่ง
บันทึก.

-s เชือก
--คั่น=เชือก
ตั้งค่าในเครื่อง $/ สำหรับบิวด์อินปัจจุบัน สิ่งนี้แยกอินพุตบน เชือก มากกว่าสาย
ตามบรรทัด

-S
--ซิงก์ไลน์
สร้าง "#line""ไม่"" """ไฟล์"""" และ "#ไลน์""ไม่" บรรทัดที่เข้าใจโดย C-like มากมาย
ภาษา

-v
--รายละเอียด
จัดทำเอกสารการเปลี่ยนแปลงระบบไฟล์ สิ่งนี้จะต้องนำหน้าตัวเลือกอื่น ๆ หากเป็น
จัดทำเอกสารผลกระทบ หากคุณส่งตัวเลือกนี้ไปให้ makepp เอง เหมือนกับว่าคุณมี
มอบให้กับทุกคำสั่งในตัว

ในตัว คำสั่ง
มีแรงจูงใจสองประการในการมีคำสั่งในตัวใน makepp ประการแรกคือการเสนอ a
ชุดของยูทิลิตี้ซึ่งไม่เหมือนกับคำสั่งของเชลล์ที่รับประกันว่าจะทำงานเหมือนกัน
ทุกที่ เช่น "&echo -n" หรือ "&mkdir -p" และช่วยให้คุณไม่ต้องยุ่งยากในการค้นหาเส้นทาง
เพื่อ &ติดตั้ง และค้นหาตัวเลือกที่แตกต่างกันอย่างมาก ในสภาพแวดล้อมการรวบรวม
มีประโยชน์ที่จะมีตัวเลือก "--synclines" ซึ่งปกติจะมีเฉพาะ "m4" เท่านั้น
ฟิลเตอร์

อีกประการหนึ่งคือคำถามของประสิทธิภาพ โดยทั่วไปแล้วควรหลีกเลี่ยง fork/execs ที่มีราคาแพง
ที่เป็นไปได้อย่างสมเหตุสมผล ในการจำลอง Unix เช่น Cygwin หรือ BS2000/Posix สิ่งนี้จะกลายเป็น
ชนะอย่างเห็นได้ชัด แต่แม้กระทั่งบน Linux เมื่อชุดทดสอบ makepp ถูกแปลงจาก
คำสั่งภายนอกสำหรับ buildins มีการประหยัดโดยรวมของการใช้งาน CPU ของผู้ใช้ 3% และ 15%
การใช้งาน CPU ของระบบ (แน่นอนว่าการทดสอบนั้นหนักมากในการดำเนินการดั้งเดิมและแทบจะไม่เรียก
คอมไพเลอร์)

ความสม่ำเสมอก็เป็นปัญหาเช่นกัน แม้ว่าเราจะไม่ปฏิรูป Unix ปกติสั่ง
มีความแตกต่างกันของนิพจน์ทั่วไป และประดิษฐ์ภาษาต่างๆ มากมาย แต่ละภาษา
แตกต่างแน่นอนสำหรับการทำบางสิ่งบางอย่าง (เช่น "expr", "sed" ...) หรือตัวเลือกที่ซับซ้อนสำหรับ
การระบุฟิลด์ ตัวคั่น คอลัมน์ (เช่น "ตัด", "เรียงลำดับ" ...)

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

ย่อย my_filter {
# คืนค่าจริง iff $_ เป็นที่พึงปรารถนา
}
%.out: %.in Makeppfile
&grep &my_filter $(อินพุต) -o $(เอาต์พุต)

หากคุณใช้ฟังก์ชันหรือตัวแปร Perl ในคำสั่งของคุณ makepp จะไม่รู้จักสิ่งนี้เป็น
การพึ่งพาอาศัยกัน โดยทั่วไปจะปลอดภัยกว่าที่จะบอกทุกอย่างของ makepp ดังนั้นกฎที่ใช้Perl
องค์ประกอบควรขึ้นอยู่กับ makefile หรือโมดูลที่จัดเตรียมองค์ประกอบเหล่านั้นตามที่แสดงใน
ตัวอย่างข้างต้น

ในทางกลับกัน อาจเป็นสิ่งที่พึงปรารถนาหากคุณมีโปรแกรมที่ผสมผสานแบบเป็นโปรแกรม
และลักษณะการกำหนดค่าในไฟล์เดียว ตัวอย่างจะเป็นไฟล์ WSDL ที่มีทั้งa
คำจำกัดความของอินเทอร์เฟซบริการเว็บและที่อยู่ IP คุณสามารถประมวลผลไฟล์นี้ล่วงหน้าด้วย
คำสั่ง &template เพื่อแก้ไขในการกำหนดค่า แต่อย่าให้ makepp แจ้งให้ทราบ

&แมว [ตัวเลือก ... ] ชื่อไฟล์ ...
เชื่อมไฟล์ทั้งหมดเป็นไฟล์เดียว

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=ชื่อไฟล์, -O, --outfail, -S,
--synclines, -v, --verbose"

&chmod [ตัวเลือก ... ] โหมด ชื่อไฟล์ ...
ชุดอุปกรณ์ โหมด สำหรับไฟล์ที่กำหนดทั้งหมด โหมดต้องเป็นสตริงฐานแปด

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -v, --verbose"

&cp [ตัวเลือก ... ] ไฟล์ต้นฉบับ ไฟล์ปลายทาง
&cp [ตัวเลือก ... ] ไฟล์ต้นฉบับ
&cp [ตัวเลือก ... ] ไฟล์ต้นฉบับ ... ปลายทาง
คัดลอก ไฟล์ต้นฉบับ ไปยัง ไฟล์ปลายทางอย่างใดอย่างหนึ่ง ไฟล์ต้นฉบับ ไปยังไดเร็กทอรีปัจจุบันหรือหลายรายการ
ไฟล์ต้นฉบับที่จะ ปลายทาง ที่มีชื่อเดียวกัน

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -v,
--verbose"

-l
--ลิงค์
ลองเชื่อมโยงไฟล์. หากไม่สำเร็จ ให้ลองใช้ลิงก์สัญลักษณ์ หากเป็นเช่นนั้น
ขอ มิฉะนั้น คัดลอก

-s
--สัญลักษณ์
--สัญลักษณ์-ลิงค์
--symlink
พยายามเชื่อมโยงไฟล์ด้วยสัญลักษณ์ หากล้มเหลวให้คัดลอก

ดูหมายเหตุภายใต้ &ln.

&ตัด [ตัวเลือก ... ] ชื่อไฟล์ ...
พิมพ์ส่วนของบรรทัดที่เลือกจากแต่ละไฟล์หรือบรรทัดที่เลือก นับทั้งหมด
ไฟล์. เอาต์พุตถูกคั่นด้วยตัวคั่นซึ่งมีค่าเริ่มต้นเป็น TAB สำหรับฟิลด์และ
สตริงว่างสำหรับอักขระ

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=ชื่อไฟล์, -O, --outfail, -r,
--record-size=number --separator=string, -S, --synclines, -v, --verbose"

-c รายการ
--ตัวอักษร=รายการ
พิมพ์ตัวอักษรทั้งหมดที่ระบุโดย รายการ. รายการ อาจเป็นนิพจน์ Perl ใด ๆ
ส่งคืนรายการจำนวนเต็ม จำนวนเต็มอาจเป็นค่าบวกก็ได้ เริ่มต้นที่
ศูนย์เพื่อนับตั้งแต่ต้น หรือลบเพื่อนับจากจุดสิ้นสุด ต่างจาก Unix
"ตัด" คำสั่งที่คุณขอได้รับการเคารพ

ไม่เหมือนกับตัวดำเนินการสไลซ์ของ Perl ที่ช่วง ".." ต้องเป็นค่าบวกหรือ
ค่าลบ & ตัดช่วยให้เริ่มต้นด้วยค่าบวกและลงท้ายด้วยค่าลบ แต่
ใช้ได้ก็ต่อเมื่อนิพจน์ของคุณประกอบด้วยตัวเลข จุลภาค และ . เท่านั้น
"..". เช่น "1..-2" หมายถึงทุกอย่าง ยกเว้นอันแรก (0) และอันสุดท้าย (-1)

นิพจน์รายการสามารถดูทั้งบรรทัดใน $_ การเปลี่ยนแปลงนั้นจะเป็น
ละเลย แต่เพราะเมื่อนิพจน์นี้ได้รับการประเมินบรรทัดได้แล้ว
แยกเป็นตัวแปร autosplit ของ Perl @::F ตัวเลขที่คุณส่งคืนเป็นจริง
ดัชนีไปยังรายการนั้น

-d เชือก
--ตัวคั่น=เชือก
ตั้งค่าตัวคั่นใหม่สำหรับฟิลด์อินพุตและเอาต์พุต ไม่เหมือนกับ Unix "cut" สิ่งนี้อาจมี
ความยาวใดๆ

-E
--โนสเคป
ถือว่า "\" เป็นตัวอักษรปกติสำหรับ "-p, --printf=format"

-f รายการ
--ฟิลด์=รายการ
พิมพ์ทุกกลุ่มที่ระบุโดย รายการ. รายการ ตามที่อธิบายไว้ใน "-c,
--characters=list" โปรดทราบว่าสิ่งนี้จะซ่อนตัวเลือกมาตรฐาน "-f" ซึ่งต้องเป็น
กำหนดให้เป็น "--แรง"

-l รายการ
--line=รายการ
พิมพ์บรรทัดทั้งหมดที่ระบุโดย รายการ. รายการ ตามที่อธิบายไว้ใน "-c,
--characters=list" โดยมีข้อแตกต่างที่สำคัญอย่างหนึ่ง: บรรทัดแรกมีหมายเลข 1 ตรงนั้น
ไม่ใช่บรรทัดที่ 0 สิ่งนี้ไม่มีประสิทธิภาพสำหรับไฟล์ขนาดใหญ่หากคุณมีไฟล์ผสม
ช่วงบวกถึงลบในรายการของคุณ เนื่องจากจะอ่านทุกอย่างในหน่วยความจำ
มิฉะนั้น Perl สามารถเพิ่มประสิทธิภาพนี้ได้ แต่ฉันไม่รู้ว่ามันทำได้หรือเปล่า

-m
--การจับคู่
พิมพ์เฉพาะบรรทัดที่ตรงกัน เช่น บรรทัดที่มีอักขระหรือฟิลด์เพียงพอ นี้
หมายถึง "-- คั่นเท่านั้น" ซึ่งเป็นสาเหตุที่คุณจะพลาดบรรทัดฟิลด์เดียวด้วย
"--ฟิลด์=0"

-p รูป
--printf=รูป
ใช้รูปแบบ (ด้วย \escapes) กับฟิลด์หรืออักขระทั้งหมด

-s
--ตัวคั่นเท่านั้น
พิมพ์เฉพาะบรรทัดที่มีตัวคั่น

&ตัด -c 10-20,-5,25- $(อินพุต)
&cut -c 'grep $$_ % 3, 0' $(input) # 99st 1 คอลัมน์ไม่คูณ 100
&cut -d: --fields 0,4 --printf='%10s is %s\n' / etc / passwd

&ก้อง [ตัวเลือก ... ] เชือก ...
&printf [ตัวเลือก ... ] รูป อาร์กิวเมนต์ ...
&ใช่ [ตัวเลือก ... ] เชือก ...
เขียนสตริงทั้งหมดไปยัง stdout หรือไฟล์ภายนอกที่กำหนด ทั้ง &echo และ &yes เพิ่มบรรทัดใหม่
ในตอนท้าย สตริงหรือสำหรับรูปแบบ &printf อาจมี "\" หนี เนื่องจาก
เป็นที่รู้จักจาก C หรือ Unix หรือ Shell "echo" ที่ทันสมัย อย่างไรก็ตามพวกเขาอยู่ใน Perl double-
เครื่องหมายคำพูด ซึ่งหมายถึงความแตกต่างบางอย่าง เช่น ไม่อนุญาตให้ใช้ "\" ต่อท้ายเดี่ยว
Perl มีการหลบหนีที่น่าสนใจอีกสองสามทาง แต่คุณอาจคาดหวังที่จะทำอะไรบางอย่าง
แตกต่างกันคือ:

\cA เป็นอักขระควบคุม ^A

\u พิมพ์ใหญ่ตัวอักษรต่อไปนี้

\U ขยายส่วนที่เหลือ หรือเพิ่มเป็น "\E" หรือ "\L" ถัดไป หากพบ

\xHH, \NS{ฮ}
เป็นค่าอักขระของรหัสฐานสิบหกที่กำหนด โปรดทราบว่ารหัสตัวเลขไม่ใช่
แบบพกพาไปยังแพลตฟอร์ม ECDIC!

ต่างจาก Unix "ใช่" &yes เหมือนกับ &echo ทุกประการ เว้นแต่จะทำซ้ำผลลัพธ์สำหรับ
ตราบเท่าที่ทำได้ โดยทั่วไปจนถึง "--output '| สั่งการ'" สิ้นสุด และถ้า &ใช่
ไม่มีข้อโต้แย้ง ค่าเริ่มต้นคือ "y"

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -o,
--output=ชื่อไฟล์, -O, --outfail, -v, --verbose"

-E
--โนสเคป
ถือว่า "\" เป็นตัวอักษรปกติ

-n
--ไม่มีบรรทัดใหม่
อย่าเพิ่มบรรทัดใหม่หลังสตริงสุดท้าย (ไม่เข้าใจโดย &printf.)

&ด่วน [ตัวเลือก ... ] เพิร์ลโค้ด ...
พิมพ์ค่าสเกลาร์ของ perlcode ซึ่งอาจเขียนเป็นอาร์กิวเมนต์หนึ่งหรือหลายอาร์กิวเมนต์
โปรดทราบว่าเชลล์ไม่ได้แยกวิเคราะห์คำสั่งในตัว ดังนั้น "*", "(" หรือ ">" ไม่ใช่
พิเศษ. แต่เครื่องหมายคำพูดสตริงจะถูกแยกวิเคราะห์โดย makepp ดังนั้นต้องยกคำพูดของสตริง Perl
สองครั้ง เว้นแต่คุณต้องการใช้คำเปล่า หากค่าเป็นเท็จ การดำเนินการนี้จะล้มเหลว บันทึก
นั่น -- ไม่เหมือนใน Unix "expr" -- ฟังก์ชันดัชนีของ Perl เริ่มต้นที่ 0 (เท็จ) และคืนค่า
-1 (จริง) สำหรับความล้มเหลว

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -o,
--output=ชื่อไฟล์, -O, --outfail, -v, --verbose"

-n
--ไม่มีบรรทัดใหม่
อย่าเพิ่มบรรทัดใหม่หลังผลลัพธ์

&expr ($(VAR) - 3) * 2 < 1 && -1 || 1
&expr "$(VAR) - 3 * 2 < 1 ? 'joy' : 'sorrow'" -o $(output)
-&expr $(VAR) - 3 * 2 -o >>$(เอาต์พุต)

&grep [ตัวเลือก ... ] เพิร์ลโค้ด ชื่อไฟล์ ...
&เพิร์ล [ตัวเลือก ... ] เพิร์ลโค้ด ชื่อไฟล์ ...
&sed [ตัวเลือก ... ] เพิร์ลโค้ด ชื่อไฟล์ ...
ไฟล์ทั้งหมดจะถูกอ่านทีละบรรทัด (เว้นแต่คุณจะให้ตัวเลือก "--separator") และ
เพิร์ลโค้ด ได้รับการประเมินสำหรับแต่ละบรรทัดก่อนที่จะพิมพ์ &sed คล้ายกับ
"perl -pe" ในขณะที่ &grep ส่งออกเฉพาะบรรทัดเหล่านั้นที่ เพิร์ลโค้ด คืนความจริง
ค่า. &perl นั้นคล้ายกับ "perl -ne" โดยจะแสดงเฉพาะสิ่งที่คุณพิมพ์อย่างชัดเจนเท่านั้น
ใน เพิร์ลโค้ด. เนื้อหาบรรทัดมีอยู่ใน $_ ซึ่งอาจแก้ไขได้

จากสามสิ่งนี้ มีเพียง &grep เท่านั้นที่จะล้มเหลวหากไม่มีผลลัพธ์ใด ๆ โปรดทราบว่าไม่มี
ตัวเลือกละเว้นเนื่องจากคุณจะทำอย่างนั้นด้วย "/regexp/i".

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=ชื่อไฟล์, -O, --outfail, -r,
--record-size=number, -s, --separator=string, -S, --synclines, --verbose"

ตัวเลือก "--synclines" เหมาะสมกับ &perl หากคุณใช้ &Mpp::Cmds::print to
เอาต์พุต $_ &grep เท่านั้นที่มีตัวเลือกเพิ่มเติม:

-c
--นับ
ระงับเอาต์พุตปกติ แทนที่จะพิมพ์จำนวนบรรทัดที่ตรงกัน ด้วยเครื่องหมาย "-v,
--invert-match" ตัวเลือก (ดูด้านล่าง) นับบรรทัดที่ไม่ตรงกัน

-l
--รายการ
--files-กับ-ตรงกัน
ส่งออกเฉพาะชื่อไฟล์ที่มีการจับคู่ เมื่อรวมกับ "-v แล้ว
--invert-match" ส่งออกชื่อไฟล์ด้วยบรรทัดที่ไม่ตรงกัน (บิต
ไร้สาระ แต่เข้ากันได้กับ Unix -vl) เมื่อนำมารวมกันเป็นสองเท่า
"-vv" ส่งออกชื่อไฟล์ที่ไม่ตรงกัน

-v
--ทางกลับกัน
- ย้อนกลับการจับคู่
--invert-ตรง
กลับความรู้สึกของการจับคู่ เพื่อเลือกบรรทัดที่ไม่ตรงกัน โปรดทราบว่าสิ่งนี้ซ่อน
ตัวเลือกมาตรฐาน "-v" ซึ่งจะต้องกำหนดเป็น "--verbose"

-w ชื่อไฟล์
--waste-ไฟล์=ชื่อไฟล์
ตะกร้าขยะเสริมสำหรับรวบรวมบรรทัดที่ถูกปฏิเสธ นี่ไม่ใช่แค่สำหรับ
การดีบักโค้ดการเลือกของคุณ แต่สำหรับการแยกอินพุตของคุณออกเป็นสองส่วน เช่นเดียวกับ
ผลลัพธ์ปกติ คุณอาจแก้ไข $_ ก่อนคืนค่าเท็จ

&sed s/foo/bar/ f1 f2 f3 -o outfile # ชอบ sed s/foo/bar/ f1 f2 f3 >outfile
&sed '$$_ = uc' f1 f2 f3 -o outfile # like tr '[:lower:]' '[:upper:]' f1 f2 f3
&grep '$$. % 3' f1 f2 f3 -o outfile # กำจัดทุกบรรทัดที่ 3
&grep -c /match/i f1 f2 f3 # นับบรรทัดที่ตรงกับ 'match' กับ STDOUT

โดยไม่ต้องผลักดันให้คุณสร้าง accessors จำนวนมาก นี่คือวิธีที่คุณสามารถทำได้โดยเพียงแค่
ใส่ความคิดเห็นของ RO หรือ RW ระหว่างแต่ละประเภทและชื่อตัวแปรที่ต้องการ ทั้งหมดในที่เดียว
ไลน์. getter ที่สร้างขึ้นและเมธอดตัวตั้งค่าแบบเลือกได้จะไปที่ founder ถัดไป
ส่วนสาธารณะหรือส่วนที่ได้รับการคุ้มครอง:

# สร้าง get และ may set method จาก "type /* R[OW] */ member;"
cxx_accessors ย่อย {
$acc ||= ''; # ผู้สมัครรับ 5.10.0 state
ถ้า( m!^\s*(.+?)\s*/\*\s*R([OW])\s*\*/\s*(.+?)\s*;! ) {
$acc .= "#บรรทัด $.\n"; # บอก C++ ว่าสิ่งนี้มาจากไหน
$acc .= "void set\u$3( const $1 &__tmp ) { $3 = __tmp; }"
ถ้า $2 eq 'W';
$acc .= "const $1 &get\u$3() const { return $3; }\n";
} elsif( /^\s*(?:สาธารณะ|ป้องกัน)\s*:/ ) {
$_ .= $ตาม;
$acc = '';
}
}

%.cc: %.cc.in # ใช้ &sed สำหรับการจัดการ I/O
&sed --sync-lines &cxx_accessors $(อินพุต) -o $(เอาต์พุต)

&ติดตั้ง [ตัวเลือก ... ] ไฟล์ต้นฉบับ ไฟล์ปลายทาง
&ติดตั้ง [ตัวเลือก ... ] ไฟล์ต้นฉบับ ... ปลายทาง
&ติดตั้ง --ไดเรกทอรี [ตัวเลือก ... ] ไดเรกทอรี ...
ย้ายหรือเปลี่ยนชื่อ ไฟล์ต้นฉบับ ไปยัง ไฟล์ปลายทาง, หรือหลายรายการ ไฟล์ต้นฉบับที่จะ ปลายทาง กับ
ชื่อเดียวกัน นี่เป็นวิธีที่ต้องการในการถ่ายโอนผลลัพธ์การสร้างไปยังขั้นสุดท้าย
สถานที่ติดตั้ง

ทุกการแก้ไขระบบไฟล์ที่ดำเนินการโดย &ติดตั้ง จะถูกบันทึกที่ส่วนท้ายของ
ไฟล์ชี้ไปที่ตัวแปรสภาพแวดล้อม $INSTALL_LOG หรือถ้าไม่ได้ตั้งค่าไว้แต่
เราอยู่ภายใต้ไดเร็กทอรีที่มี a ไฟล์ RootMakepp (.mk), ไปยังไฟล์ของ .install_log ในที่
ไดเร็กทอรีหรือไฟล์นั้นในไดเร็กทอรีปัจจุบัน คุณอาจต้องการลบ
logfile ก่อนชุด & ติดตั้งการเรียกใช้

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -v, --verbose"

-c
--สำเนา
คัดลอกไฟล์แทนที่จะย้าย แบบนี้ดีกว่าเพราะไม่บังคับ
makepp เพื่อสร้างไฟล์ใหม่ในครั้งต่อไป แต่มันไม่ใช่ค่าเริ่มต้นสำหรับ
เข้ากันได้กับโปรแกรมติดตั้งอื่น ๆ

-d
--ไดเรกทอรี
ในรูปแบบที่สามของคำสั่งนี้ ให้สร้างไดเร็กทอรีและ any . ที่กำหนดทั้งหมด
ไดเรกทอรีหลักที่จำเป็น

-g กลุ่ม
--กลุ่ม=กลุ่ม
เปลี่ยนความเป็นเจ้าของกลุ่มของไฟล์ปลายทาง กลุ่มอาจได้รับโดย
ชื่อหรือตัวเลข

-l
--ลิงค์
ลองเชื่อมโยงไฟล์. หากล้มเหลวให้คัดลอก

--บันทึก=ชื่อไฟล์
--logfile=ชื่อไฟล์
ใช้ ชื่อไฟล์ แทนไฟล์บันทึกปกติ

-m โหมด
--โหมด=โหมด
ชุดอุปกรณ์ โหมด สำหรับไฟล์หรือไดเร็กทอรีปลายทางทั้งหมด โหมดต้องเป็นสตริงฐานแปด

-o เจ้าของ
--เจ้าของ=เจ้าของ
เปลี่ยนความเป็นเจ้าของไฟล์ปลายทาง เจ้าของอาจได้รับชื่อหรือ
เป็นตัวเลข

-r
-- แก้ไข
--resolve-สัญลักษณ์
--resolve-สัญลักษณ์-ลิงค์
--resolve-symlink
-S
--สัญลักษณ์
--สัญลักษณ์-ลิงค์
--symlink
สร้างลิงก์สัญลักษณ์แทนการย้าย ตัวเลือกเหล่านี้จะถูกส่งต่อไปยัง &ln และ are
อธิบายไว้ที่นั่น

-s
--สตริป
เรียกยูทิลิตี้ "แถบ" ซึ่งต้องอยู่ใน $PATH ในไฟล์ปลายทาง

&ln [ตัวเลือก ... ] ไฟล์ต้นฉบับ ไฟล์ปลายทาง
&ln [ตัวเลือก ... ] ไฟล์ต้นฉบับ
&ln [ตัวเลือก ... ] ไฟล์ต้นฉบับ ... ปลายทาง
ลิงค์ ไฟล์ต้นฉบับ ไปยัง ไฟล์ปลายทางอย่างใดอย่างหนึ่ง ไฟล์ต้นฉบับ ไปยังไดเร็กทอรีปัจจุบันหรือหลายรายการ
ไฟล์ต้นฉบับที่จะ ปลายทาง ที่มีชื่อเดียวกัน

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -v,
--verbose"

-r
-- แก้ไข
--resolve-สัญลักษณ์
--resolve-สัญลักษณ์-ลิงค์
--resolve-symlink
นี่คือสิ่งที่คุณต้องการให้ "ln -s" ทำเสมอ สร้างสัญลักษณ์มากกว่ายาก
ลิงก์ ไม่ใช่ไปยังสตริงที่ระบุ แต่ไปยังไฟล์ที่กำหนดจริงๆ

-s
--สัญลักษณ์
--สัญลักษณ์-ลิงค์
--symlink
สร้างสัญลักษณ์แทนฮาร์ดลิงก์

หมายเหตุ ในไฟล์หรือระบบปฏิบัติการต่างๆ ไม่รองรับการดำเนินการนี้ หรือมัน
คือเช่นโดย Cygwin แต่ไม่เข้าใจโดยคอมไพเลอร์ Windows ดั้งเดิมหากคุณใช้
สำหรับ makefile คุณไม่สามารถเปลี่ยนแปลงได้ เพื่อให้ได้ผลลัพธ์อย่างน้อย &ln และ "&cp -l
-s" สามารถคัดลอกไฟล์ให้คุณแทน (ไม่ใช่ไดเร็กทอรี) เพื่อให้บรรลุสิ่งนี้ คุณ
ต้องส่งออกตัวแปรต่อไปนี้ก่อนที่จะเรียก makepp:

ส่งออก MAKEPP_LN_CP=1
&ln --resolve หรือ --symbolic จะคัดลอกไฟล์แทนที่จะสร้างสัญลักษณ์
ลิงค์

ส่งออก MAKEPP_LN_CP=2
&ln จะคัดลอกไฟล์แทนที่จะสร้างฮาร์ดลิงก์

ส่งออก MAKEPP_LN_CP=3
การเรียกใช้ &ln ทั้งหมดจะคัดลอกไฟล์แทนที่จะสร้างประเภทใดประเภทหนึ่ง
ลิงค์

&mkdir [ตัวเลือก ... ] ไดเรกทอรี ...
สร้างไดเร็กทอรี

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -v,
--verbose"

-m โหมด
--โหมด=โหมด
ชุดอุปกรณ์ โหมด สำหรับไดเร็กทอรีที่สร้างขึ้นทั้งหมด โดยไม่คำนึงถึง umask โหมดต้องเป็น an
สตริงฐานแปด

-p
--พ่อแม่
สร้างไดเร็กทอรีหลักที่จำเป็นด้วย ละเว้นการสร้างไดเร็กทอรีล้มเหลว
เนื่องจากไดเร็กทอรีที่มีอยู่แล้ว (แม้ว่าจะถูกสร้างขึ้นพร้อมกันโดย
กระบวนการอื่น)

&mv [ตัวเลือก ... ] ไฟล์ต้นฉบับ ไฟล์ปลายทาง
&mv [ตัวเลือก ... ] ไฟล์ต้นฉบับ
&mv [ตัวเลือก ... ] ไฟล์ต้นฉบับ ... ปลายทาง
ย้ายหรือเปลี่ยนชื่อ ไฟล์ต้นฉบับ ไปยัง ไฟล์ปลายทางอย่างใดอย่างหนึ่ง ไฟล์ต้นฉบับ ไปยังไดเร็กทอรีปัจจุบันหรือหลายรายการ
ไฟล์ต้นฉบับที่จะ ปลายทาง ที่มีชื่อเดียวกัน

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -v,
--verbose"

&ประมวลผลล่วงหน้า [ตัวเลือก ... ] ตัวแปร=นิยาม ... ชื่อไฟล์ ...
สิ่งนี้จะประมวลผลไฟล์ล่วงหน้าในลักษณะเดียวกับที่ makepp ทำกับ makefiles นี่คือ
มีประสิทธิภาพมากกว่า &เทมเพลต แต่ไม่เหมาะกับไฟล์ที่มีจำนวนมาก
"$"-เครื่องหมาย เช่น Makefiles หรือสคริปต์

คำสั่งแบบมีเงื่อนไข เช่นเดียวกับคำสั่ง "include"/"_include" (ซึ่งในที่นี้
ไม่สร้างไฟล์หรือค้นหาด้านบน), "perl"/"makeperl"/"perl_begin" หรือ
"sub"/"makesub" หรือคำสั่งใดๆ ที่คุณกำหนดภายในไฟล์จะได้รับการประมวลผล ว่างเปล่า
และบรรทัดความคิดเห็นจะถูกตัดออก

แต่แทนที่จะเรียนรู้กฎการสร้าง มันจะส่งออกบรรทัดที่เหลือทั้งหมดหลังจาก
"$(...)" การขยายนิพจน์ เพื่อป้องกันไม่ให้ข้อความถูกรับรู้เช่นนี้
คุณสามารถนำหน้าด้วยนิพจน์ว่าง "$()" เช่นเดียวกับสายคุณ
ต้องการที่จะอยู่ว่างหรือที่จะเก็บเครื่องหมายความคิดเห็นชั้นนำ ในทำนองเดียวกัน ถ้า a
แบ็กสแลชต่อท้ายไม่ใช่การเข้าร่วมบรรทัดถัดไป ให้ใส่ "$()" ต่อท้าย

บรรทัดปกติได้รับเอาต์พุตตามที่เป็นอยู่
บรรทัดที่มี $(MAKEEXPRESSIONS) ได้รับการขยายและส่งออก
ifdef ต้องการ # ไม่ได้รับผลลัพธ์ไม่ว่าจะกำหนดหรือไม่
อาจไม่ได้ผลลัพธ์
endif
รวมไฟล์บางไฟล์
_include บางไฟล์ที่อาจไม่มี # หรือ -include
$()include นิพจน์ว่าง ป้องกันไม่ให้คีย์เวิร์ดถูกจดจำ
# บรรทัดความคิดเห็นและบรรทัดว่างถูกกลืนหายไป

$()# เว้นแต่จะถูกปิดบังด้วยนิพจน์ที่ว่างเปล่า
-
นิพจน์ที่ว่างเปล่าป้องกัน \$()
แบ็กสแลชต่อเนื่องจากการถูกจดจำ

อาจให้:

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

การแสดงออกที่ว่างเปล่าป้องกัน \
แบ็กสแลชต่อเนื่องจากการถูกจดจำ

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -o,
--output=ชื่อไฟล์, -O, --outfail, -S, --synclines, -v, --verbose"

-a
--งานที่มอบหมาย
ยังปฏิบัติต่องานที่ได้รับมอบหมายภายในไฟล์เหมือนที่ makepp ทำ อนิจจาบรรทัดดังกล่าวไม่สามารถ
ปิดบังด้วย "$()" ว่าง เพราะการสร้างชื่อตัวแปรด้วย . นั้นถูกกฎหมาย
นิพจน์ นอกจากนี้ยังตระหนักถึงคำสั่ง "กำหนด"
"export"/"unexport" และ "override" (สามารถปกปิดได้ด้วย "$()")

-ชม \\%กัญชา
--hashref=\\%กัญชา
ซึ่งช่วยให้จัดสรรค่าตัวแปรล่วงหน้าได้ รวมถึงค่าที่ยาวไม่ง่าย
ผ่านในคำสั่ง นิพจน์ที่ส่งผ่านอาจเป็นรหัส Perl ใด ๆ ที่ส่งคืน a
การอ้างอิงแฮช รวมเข้ากับตัวแปรอื่น ๆ ที่ส่งผ่านไปยังคำสั่ง
รวมถึงจากตัวเลือก "--hashref" อื่น

&rm [ตัวเลือก ... ] ชื่อไฟล์ ...
ลบไฟล์หากคุณมีสิทธิ์เขียนไดเร็กทอรี นี่คือสิ่งที่ Unix "rm -f" จะ
ลบเนื่องจากมีการป้องกันพิเศษสำหรับการใช้งานแบบโต้ตอบที่ไม่จำเป็นใน
เมคไฟล์

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -v, --verbose"

-f
--บังคับ
ซึ่งจะช่วยป้องกันการบ่นเกี่ยวกับไฟล์ที่ไม่มีอยู่จริง ที่เป็นผลข้างเคียงนี้
ตัวเลือกมีใน Unix และตัวเลือกเดียวที่เหมาะสมที่นี่

-m
--metainfo
นอกจากไฟล์ที่กำหนดแล้ว ยังลบข้อมูลเมตา makepp . ด้วย
เก็บเกี่ยวกับพวกเขาในไดเร็กทอรี .makepp ดังนั้น makepp ลืมทุกอย่างที่เคยรู้
เกี่ยวกับไฟล์ที่กำหนด หากไดเร็กทอรี .makepp ว่างเปล่าหลังจากนี้ ก็เช่นกัน
ถูกลบ

การดำเนินการนี้จะลบไดเร็กทอรีที่ระบุด้วย แต่ถ้าไดเร็กทอรีว่างเท่านั้น เพื่ออำนวยความสะดวก
สิ่งนี้จะลบไดเร็กทอรีล่าสุดตามลำดับความลึกจากมากไปน้อย คุณสามารถ
ใช้นิพจน์ "**" เพื่อลบลำดับชั้นทั้งหมด นี่คือตัวอย่างที่จะพบใน
สร้างไฟล์ระดับบนสุดมากมาย โปรดทราบว่ามียูทิลิตี้ "makeppclean" ที่สามารถทำได้
นี้ได้อย่างมีประสิทธิภาพมากขึ้น

$(ปลอมสะอาด):
&rm -fm $(เฉพาะเก่า **/*)

$(หลอกลวง): cleanold
&rm -f $(อักขระตัวแทน **/*.[ao])

$(phony distclean): สะอาด
&rm -fm $(เฉพาะเป้าหมาย **/*)

&เรียงลำดับ [ตัวเลือก ... ] ชื่อไฟล์ ...
จัดเรียงไฟล์ทั้งหมดเข้าด้วยกันในลำดับพจนานุกรม สิ่งนี้ไม่มีประสิทธิภาพสำหรับค่อนข้างใหญ่
ไฟล์เพราะมันเกิดขึ้นในหน่วยความจำอย่างสมบูรณ์ มันจะล้มเหลวถ้าขนาดรวมของ
ไฟล์ทั้งหมดเกินหน่วยความจำที่คุณมีสิทธิ์

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=ชื่อไฟล์, -O, --outfail,
--record-size=number, -s, --separator=string, -v, --verbose"

-c เพิร์ลโค้ด
--เปรียบเทียบ=เพิร์ลโค้ด
เพิร์ลโค้ด แสดงถึงบล็อกการจัดเรียง Perl โดยมีสองตัวเลือกการเรียงลำดับใน $a และ
$ข.

-n
--ตัวเลข
--การเรียงลำดับตัวเลข
การเรียงลำดับนี้เป็นตัวเลขที่จุดเริ่มต้นของเรกคอร์ด ช่องว่างชั้นนำคือ
ข้ามไป คุณสามารถใช้ "--transform" และ "--detransform" หากตัวเลขไม่อยู่ที่
การเริ่มต้น.

-r
--ย้อนกลับ
แสดงผลในลำดับที่กลับกัน โปรดทราบว่าสิ่งนี้ซ่อนตัวเลือกมาตรฐาน
"-r" ซึ่งต้องระบุเป็น "--record-size"

-t เพิร์ลโค้ด
--แปลง=เพิร์ลโค้ด
-d เพิร์ลโค้ด
--ดีทรานส์ฟอร์ม=เพิร์ลโค้ด
หากคุณมีรหัสที่ซับซ้อน การเรียงลำดับจะแพงขึ้นเรื่อยๆ ตามสัดส่วนของ
จำนวนบันทึก nเนื่องจากโค้ดถูกเรียก O(n บันทึก(n)) ครั้ง หลีกเลี่ยง
ที่คุณสามารถอนุญาตให้ Perl จดจ่อกับการเรียงลำดับโดยแก้ไข .ก่อน
สตริง เช่น การดึงเกณฑ์การค้นหาที่ซับซ้อนจะเกิดขึ้นหนึ่งครั้งต่อบันทึก
และแก้ไขกลับเมื่อจัดเรียงแล้ว

หากมีตัวเลือกเหล่านี้ "--แปลง" เพิร์ลโค้ด ได้รับการแมปไปยังบันทึก
ใน $_ ทีละรายการและสามารถแก้ไขได้ หลังจากการเรียงลำดับ "--detransform"
เพิร์ลโค้ด ถูกแมปกับเร็กคอร์ดที่แก้ไขใน $_ ทีละรายการและ can
แก้ไขกลับ โดยปกติ คุณจะใช้ทั้งสองตัวเลือกนี้หรือทั้งสองอย่าง เว้นแต่
คุณต้องการส่งออกบรรทัดที่แก้ไข

เปลี่ยนสตริงให้เป็นโครงสร้างของเกณฑ์การจัดเรียงที่แยกออกมา ซึ่งคุณ
"--เปรียบเทียบ" เพิร์ลโค้ด สามารถรับได้ที่เรียกว่า Schwartzian Transform (ST)
บรรจุทุกอย่างลงในสตริงเพื่อไม่ให้มี "--เปรียบเทียบ" เพิร์ลโค้ด is
จำเป็น ทำให้การเรียงลำดับทั้งหมดเกิดขึ้นได้โดยไม่ต้องใช้ Perl . ที่มีราคาแพง
รหัสเรียกว่า การแปลง Guttmann-Rosler (GRT) คุณสามารถหาเคล็ดลับโดย
ค้นหาชื่อเหล่านั้นในเว็บ

# จัดเรียงนิพจน์ตัวเลขอย่างแพงตามค่า ($$ ปกป้อง $ จากการขยาย makepp)
&sort --compare 'eval( $$a ) <=> eval( $$b )' $(input) -o >>$(output)

# ST สำหรับการคัดแยกตัวพิมพ์เล็กและตัวพิมพ์ใหญ่
&sort -t '[lc, $$_]' -c '$$a->[0] cmp $$b->[0]' -d '$$_->[1]' $(input) - o >>$(เอาท์พุต)

# GRT โดยใช้ฟังก์ชันการปรับเปลี่ยนที่กำหนดไว้ที่อื่นใน Makeppfile
&sort -t &transform -d &detransform $(อินพุต) -o >>$(เอาต์พุต)

-u
--ยูนิค
--มีเอกลักษณ์
หลังจากจัดเรียงแล้ว ให้กำจัดรายการที่ซ้ำกัน เหล่านี้เป็นเส้นที่เหมือนกันหรือถ้า
ให้ตัวเลือก "--เปรียบเทียบ" ซึ่งเป็นตัวเลือกที่ เพิร์ลโค้ด รายงานเท่าเทียม

&แม่แบบ [ตัวเลือก ... ] มาโคร=นิยาม ... ชื่อไฟล์ ...
นี่คือตัวประมวลผลล่วงหน้าของมาโคร ซึ่งไม่ค่อยมีประสิทธิภาพเท่ากับตัวประมวลผลล่วงหน้า C หรือ "m4"
ดู&ประมวลผลล่วงหน้าสำหรับทางเลือกที่มีประสิทธิภาพยิ่งขึ้น ได้แรงบันดาลใจจากมาโครของ automake
แทนที่ใน Makefile.am และ Makefile.in. แต่มันไปไกลกว่านั้น ข้อความปกติใดๆ
ผ่านไปไม่เปลี่ยนแปลง โครงสร้างพิเศษโดยค่าเริ่มต้นจะคั่นด้วย "@" พวกเขา
ต้องพอดีกับหนึ่งบรรทัด เว้นแต่คุณจะผ่าน "-r, --record-size" หรือ "--separator"

@# ความเห็น @
โปรดทราบว่าแม้จะยืมจากสคริปต์ "#" ไวยากรณ์ความคิดเห็นสิ้นสุดบรรทัด แต่อันนี้คือ
ความคิดเห็นแบบอินไลน์

@มาโคร@
โครงสร้างนี้ถูกแทนที่ด้วยค่าของ มาโคร. ชื่อมาโครต้องขึ้นต้นด้วย
ตัวอักษรหรือขีดล่าง ตามด้วยตัวอักษร ขีดล่าง ลบ หรือ
จุด ไม่เหมือนกับชื่อ makepp ขีดล่างและเครื่องหมายลบไม่เท่ากัน

@มาโคร(arg1, arg2-
เหมือนอันแรกแต่มีมิติ args แทนที่ $1 ถึง $9 หรือ
"${ตัวเลข}" ในมูลค่า หรือถ้าค่าเป็นฟังก์ชัน Perl จะถูกส่งผ่านเป็น
พารามิเตอร์ปกติ ผลลัพธ์จะแทนที่โครงสร้างทั้งหมด หนึ่งระดับของ
การทำรังมาโครเป็นไปได้โดยที่ args ในวงเล็บอาจมี plain
คำขอ "@MACRO@" เช่นเดียวกับใน "@f(@x@)@" โดยที่ "@x@" จะถูกขยายก่อนที่จะถูกขยาย
ถูกแทนที่ด้วยตัว "f"

@รวม(ชื่อไฟล์)@
นี่เป็นมาโครที่กำหนดไว้ล่วงหน้าเท่านั้น มันถูกแทนที่ด้วย &template-processed
เนื้อหาของไฟล์ที่มีชื่อ เช่นเดียวกับมาโครทั้งหมด สิ่งนี้สามารถเกิดขึ้นได้ตรงกลาง a
ไลน์. อนิจจาเพราะสิ่งนั้น "-S, --synclines" ละเว้นการรวมไฟล์ทำให้
ทุกอย่างดูเหมือนจะมาจากไฟล์รวม

@มาโคร=คำนิยาม@
@มาโคร?=คำนิยาม@
สิ่งนี้กำหนดมาโครภายในไฟล์ สิ่งนี้ถูกแทนที่โดยไม่มีอะไร ที่สอง
รูปแบบจะมีผลก็ต่อเมื่อไม่ได้กำหนดมาโคร สันนิษฐานว่าอยู่ในคำสั่ง
เส้น

@มาโคร { เพิร์ลโค้ด }@
นอกจากนี้ยังกำหนดมาโครซึ่งเป็นเนื้อหาย่อยของ Perl อาร์กิวเมนต์ if
มีครับ ให้ผ่านเป็น @_

@{ เพิร์ลโค้ด }@
สิ่งนี้ทำงาน เพิร์ลโค้ด ทันทีและถูกแทนที่ด้วยค่าที่ส่งคืน

จนถึงตอนนี้ เราได้เห็นเพียงไวยากรณ์เดียวสำหรับการฝังสิ่งพิเศษ มีอีก
ไวยากรณ์หลายบรรทัด และทั้งคู่อนุญาตให้รูปแบบระงับการขึ้นบรรทัดใหม่ เหล่านี้เป็น
ไวยากรณ์ในตัว (ซึ่งสามารถกำหนดค่าได้ตามตัวเลือกด้านล่าง) ที่นี่ พิเศษ ย่อมาจาก
โครงสร้างใด ๆ ที่แสดงด้านบน:

@พิเศษ@
@พิเศษ@\
นี้สามารถปรากฏคูณที่ใดก็ได้ในบรรทัด ตัวแปรตามด้วย .ทันที
"\" ใช้งานได้ต่อท้ายบรรทัดเท่านั้น นอกจากนี้ยังแทนที่ตัวแบ่งบรรทัดต่อไปนี้

@@พิเศษ@@ ปกติ ข้อความ @@
@@พิเศษ@@ ปกติ ข้อความ -
นี้เป็นเหมือนก่อนหน้านี้ อย่างไรก็ตาม ข้อความปกติซึ่งถูกแทนที่ด้วย
สามารถขยายได้หลายบรรทัด คุณสามารถใส่ส่วนพิเศษในบรรทัดความคิดเห็นรอบ ๆ
ซอร์สโค้ดที่จำเป็นในสคริปต์ที่ถอนการติดตั้งเท่านั้น จะถูกกำจัดหรือ
แทนที่ระหว่างกระบวนการติดตั้ง:

# @@# 2 บรรทัดถัดไปจะหายไป @@
echo คุณกำลังเรียกใช้เวอร์ชันที่ถอนการติดตั้งของสคริปต์นี้
#@@
# @@ทดแทน@@
echo อย่างอื่นจะอยู่ที่นี่
#@@

ตัวอย่างที่ไม่มีความหมายซึ่งแสดงถึงความเป็นไปได้ต่างๆ:

@m1=คำจำกัดความบางอย่าง@\
@m2=foo $1 บาร์@\
@middle_of_arg=iddl@\
@m1@ @m2(m@middle_of_arg@e)@
@@m2(หลายสาย)@@
...
@@ ข้อความธรรมดา 1 + 2 = @{ 1 + 2 }@

จะกลายเป็น

คำจำกัดความบางอย่างของ foo แถบกลาง
foo หลายบรรทัด แถบข้อความธรรมดา 1 + 2 = 3

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=ชื่อไฟล์, -O, --outfail, -r,
--record-size=number --separator=string, -S, --synclines, -v, --verbose"

-d
--กำหนด
แทนที่เฉพาะอินสแตนซ์ของมาโครที่กำหนดไว้จริงเท่านั้น ไม่มีตัวเลือกนี้
สิ่งที่ไม่ได้กำหนดทั้งหมดจะถูกแทนที่ด้วยอะไร

-ชม \\%กัญชา
--hashref=\\%กัญชา
ซึ่งช่วยให้จัดสรรค่ามาโครล่วงหน้าได้ รวมถึงค่าที่ยาวไม่ง่าย
ผ่านในคำสั่ง นิพจน์ที่ส่งผ่านอาจเป็นรหัส Perl ใด ๆ ที่ส่งคืน a
การอ้างอิงแฮช สิ่งนี้ถูกรวมเข้ากับมาโครอื่น ๆ ที่ส่งผ่านไปยังคำสั่ง
รวมถึงจากตัวเลือก "--hashref" อื่น ค่าแฮชอาจเป็นรหัส
อ้างอิง ในกรณีนั้นฟังก์ชันจะถูกเรียก เช่นเดียวกับ "@macro { เพิร์ลโค้ด }@"
คำจำกัดความ

-s /คำนำหน้า/ส่วนต่อท้าย/
--ง่าย=/คำนำหน้า/ส่วนต่อท้าย/
ใช้ อุปสรรค และ วิภัตติ ก่อนและหลัง พิเศษ ตามลำดับแทน "@" NS
อักขระตัวแรกเป็นตัวคั่นและไม่จำเป็นต้องเป็นเครื่องหมายทับ ค่าเหล่านี้เป็น Perl
regexp คุณต้องไม่แนะนำการจัดกลุ่มเช่น "(...)" แต่ "(?:...)" ก็ใช้ได้

-m /prefix/suffix/afterprefix/[ส่วนต่อท้าย/]
--มัลติไลน์=/prefix/suffix/afterprefix/[ส่วนต่อท้าย/]
ใช้ อุปสรรค, วิภัตติ และ Afterprefix ก่อนและหลัง พิเศษ และในตอนท้ายของ
บล็อกตามลำดับแทน "@@" ถ้า คำต่อท้าย ยังได้รับชื่อมาโคร
จะต้องได้รับการทำซ้ำก่อน อักขระตัวแรกเป็นตัวคั่นและไม่จำเป็นต้องเป็น
เครื่องหมายทับ เช่น XML-ish ซึ่งคุณต้องเพิ่ม "--defined" หากคุณต้องการ
รักษาแท็กอื่นๆ ที่คุณไม่ได้กำหนดไว้:

--กำหนด --simple=|<|/>| --multiline=|<|>| |

หรือดีกว่า ใช้คำแนะนำในการประมวลผล " " มีวัตถุประสงค์เพื่อวัตถุประสงค์ดังกล่าว:

--กำหนด --simple='|<\?|\?>|'

หรือถ้าคุณต้องการรวมสิ่งนี้กับ "&entity;" ไวยากรณ์สำหรับมาโครอย่างง่าย
การแทนที่ (คงไว้ซึ่งเอนทิตีตัวเลข "☺" ซึ่งไม่ใช่ความคิดเห็น):

--กำหนด --simple='_(?:&(?!#)|<\?)_(?:;|\?>)_'

&สัมผัส [ตัวเลือก ... ] ชื่อไฟล์ ...
อัปเดตการแก้ไขและเข้าถึงการประทับเวลาของแต่ละไฟล์เป็นตอนนี้ ถ้าไฟล์
ไม่มีอยู่จริง มันถูกสร้างขึ้น

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -v, --verbose"

&ถอนการติดตั้ง [ตัวเลือก ... ] [ชื่อไฟล์ ... ]
ถอนการติดตั้งไฟล์ที่ติดตั้งไว้ก่อนหน้านี้โดย &install NS ชื่อไฟล์s เป็นไฟล์บันทึกที่เขียน
โดย&ติดตั้ง หากไม่มีให้หรือไม่มีตัวเลือก "--inpipe" ให้อ่านไฟล์บันทึกเริ่มต้น
ของ&ติดตั้ง

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -i,
--inpipe=shellcommand, -I, --infail, -v, --verbose"

&uniq [ตัวเลือก ... ] ชื่อไฟล์ ...
ทิ้งทั้งหมดยกเว้นบรรทัดเดียวที่ต่อเนื่องกัน

"ตัวเลือกมาตรฐาน": "-A, --args-file, --arguments-file=filename, -f, --force, -i,
--inpipe=shellcommand, -I, --infail, -o, --output=ชื่อไฟล์, -O, --outfail, -r,
--record-size=number, -s, --separator=string, -S, --synclines, -v, --verbose"

-c เพิร์ลโค้ด
--เปรียบเทียบ=เพิร์ลโค้ด
เพิร์ลโค้ด รับบรรทัดก่อนหน้าและปัจจุบันใน $a และ $b และจะส่งกลับ
จริงถ้ามันถือว่าสองบรรทัดเท่ากัน

&uniq --compare='lc( $$a ) eq lc $$b' $(อินพุต) -o $(เอาต์พุต)

จำลองได้ คำสั่ง
สิ่งต่าง ๆ ไม่ได้สร้างขึ้น แต่สามารถทำได้ด้วยคำสั่งอื่น ๆ :

awk ใช้ &sed.

ซีจีอาร์พี
chown
คำสั่งเหล่านี้ส่วนใหญ่ไม่สามารถพกพาได้! พวกเขาจะไม่ทำอะไรอย่างเงียบๆ หรือล้มเหลว
ขึ้นอยู่กับระบบ โดยทั่วไปมีเพียง root เท่านั้นที่สามารถดำเนินการเหล่านี้ได้ ซึ่งก็คือ
เหตุใดจึงมีให้ใช้งานผ่านคำสั่ง &install เท่านั้น

cpp ใช้ &preprocess หรือ &template

ข้อมูล
สิ่งเหล่านี้บางส่วนทำสิ่งเดียวกัน:

&expr เวลาท้องถิ่น
&expr gmtime

เท็จ
ใช้ &expr โดยไม่มีอาร์กิวเมนต์หรือ 0

หัว
หาง
คุณสามารถบรรลุผลลัพธ์เดียวกันด้วย &grep หรือ "&cut --lines":

&grep 1..10 ไฟล์ # สิบบรรทัดแรก
&grep 10..eof file # ทุกบรรทัดตั้งแต่สิบเป็นต้นไป
&cut --lines -10..-1 file #สิบบรรทัดสุดท้าย

โปรดทราบว่า 1..10 ใน &grep เป็นตัวดำเนินการ flip-flop หมายเลขบรรทัดของ Perl ซึ่งน่ารำคาญ
เริ่มต้นที่ 1 อย่าเริ่มต้นที่ 0 มิฉะนั้น flip-flop จะไม่มีวันเป็นจริง

fmt สิ่งนี้ถูกกล่าวถึงที่นี่เนื่องจาก Perl มีฟังก์ชันที่เกี่ยวข้อง อย่างไรก็ตามฉันมี
ปัญหาในการใช้การประกาศ "รูปแบบ" ใน makefile สิ่งที่ทำงานคือ
ฟังก์ชัน "formline" พื้นฐาน เช่นการแปลงไฟล์ csv ประกอบด้วยชื่อและ
ราคาเป็นรูปแบบตาราง:

ย่อย csv2txt {
formline "\@<<<<<<<<<<<<<<<< ^###########.##\n", แยก ',';
$_ = $^ก;
$^A = '';
}

%.txt: %.csv
&sed &csv2txt $(อินพุต) -o $(เอาต์พุต)

m4 ใช้ &ประมวลผลล่วงหน้า หรือ &แม่แบบ

คือ rm
ใช้ &rm.

tr ใช้ &sed.

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