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

โครงการ:

ชื่อ

gvpr - การสแกนรูปแบบกราฟและภาษาการประมวลผล

เรื่องย่อ

จีวีพีอาร์ [-icnqV?] [ -o ออกจากไฟล์ ] [ -a args ] [ 'โปรก' | -f โปรไฟล์ ] [ ไฟล์ ]

DESCRIPTION

จีวีพีอาร์ (ก่อนหน้านี้รู้จักกันในนาม จีพีอาร์) เป็นโปรแกรมแก้ไขกราฟสตรีมที่ได้รับแรงบันดาลใจจาก awk. มันคัดลอกอินพุต
กราฟเป็นผลลัพธ์ อาจเปลี่ยนโครงสร้างและคุณลักษณะ สร้างใหม่
กราฟหรือการพิมพ์ข้อมูลตามอำเภอใจ แบบจำลองกราฟนั้นจัดทำโดย
libcgraph(3). โดยเฉพาะอย่างยิ่ง, จีวีพีอาร์ อ่านและเขียนกราฟโดยใช้ภาษาจุด

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

สำหรับกราฟอินพุตแต่ละรายการ จะมีกราฟย่อยเป้าหมาย แทนด้วย $T, เดิมว่างเปล่าและใช้
เพื่อสะสมเอนทิตีที่เลือกและกราฟผลลัพธ์ $Oใช้สำหรับการประมวลผลขั้นสุดท้ายแล้ว
เขียนเพื่อส่งออก โดยค่าเริ่มต้น กราฟผลลัพธ์คือกราฟเป้าหมาย กราฟผลลัพธ์
สามารถตั้งค่าในโปรแกรมหรือในความหมายที่จำกัด บนบรรทัดคำสั่ง

OPTIONS

รองรับตัวเลือกต่อไปนี้:

-a args
สตริง args ถูกแบ่งออกเป็นโทเค็นที่คั่นด้วยช่องว่างโดยแต่ละบุคคล
โทเค็นที่มีอยู่เป็นสตริงใน จีวีพีอาร์ โปรแกรม as อาร์จีวี[0],...,ARGV[ARGC-1].
อักขระช่องว่างภายในสตริงย่อยที่มีเครื่องหมายคำพูดเดี่ยวหรือคู่ หรือนำหน้าด้วย a
แบ็กสแลชจะถูกละเว้นเป็นตัวคั่น โดยทั่วไป อักขระแบ็กสแลชจะปิด
ความหมายพิเศษใดๆ ของอักขระต่อไปนี้ โปรดทราบว่าโทเค็นที่ได้มาจาก
หลาย -a ธงถูกต่อกัน

-c ใช้กราฟต้นทางเป็นกราฟผลลัพธ์

-i หาส่วนขยายกราฟย่อยที่เกิดจากโหนดของกราฟเอาต์พุตในบริบทของ
กราฟรากของมัน

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

-f โปรไฟล์
ใช้เนื้อหาของไฟล์ที่ระบุเป็นโปรแกรมเพื่อดำเนินการกับอินพุต ถ้า
โปรไฟล์ มีเครื่องหมายทับ ชื่อถูกใช้เป็นชื่อพาธของไฟล์
มิฉะนั้น, จีวีพีอาร์ จะใช้ไดเร็กทอรีที่ระบุในตัวแปรสภาพแวดล้อม
กฟปราพัท เพื่อค้นหาไฟล์. ถ้า -f ไม่ได้รับ จีวีพีอาร์ จะใช้อันแรกที่ไม่ใช่-
อาร์กิวเมนต์ option เป็นโปรแกรม

-q ปิดข้อความเตือน

-n ปิดการอ่านกราฟล่วงหน้า โดยค่าเริ่มต้น ตัวแปร $NG ถูกตั้งค่าเป็นกราฟถัดไป
ที่จะประมวลผล สิ่งนี้ต้องอ่านกราฟถัดไปก่อนประมวลผล
กราฟปัจจุบัน ซึ่งอาจบล็อกได้หากกราฟถัดไปสร้างขึ้นเพื่อตอบสนองต่อ
การดำเนินการบางอย่างที่เกี่ยวข้องกับการประมวลผลของกราฟปัจจุบัน

-V ทำให้โปรแกรมพิมพ์ข้อมูลเวอร์ชันและออก

-? ทำให้โปรแกรมพิมพ์ข้อมูลการใช้งานและออก

ตัวดำเนินการ

รองรับตัวถูกดำเนินการต่อไปนี้:

ไฟล์ ชื่อไฟล์ที่มี 1 กราฟขึ้นไปในภาษาดอท ถ้าไม่ -f ตัวเลือก
จะได้รับชื่อจะถูกลบออกจากรายการและใช้เป็นโปรแกรมป้อนข้อมูล
หากรายการไฟล์ว่างเปล่า สเตดิน จะถูกนำไปใช้.

โปรแกรม

A จีวีพีอาร์ โปรแกรมประกอบด้วยรายการของภาคแสดงการกระทำ ซึ่งมีรูปแบบใดรูปแบบหนึ่ง:

เริ่ม { การกระทำ }

บีอีจี_จี { การกระทำ }

N [ คำกริยา ] { การกระทำ }

E [ คำกริยา ] { การกระทำ }

END_G { การกระทำ }

END { การกระทำ }

โปรแกรมสามารถมีได้มากที่สุดอย่างละหนึ่งรายการ เริ่ม, END_G และ END ข้อ สามารถ
เป็นจำนวนใด ๆ ของ บีอีจี_จี, N และ E คำสั่งแรกใช้กับกราฟที่สองถึง
โหนดที่สามถึงขอบ สิ่งเหล่านี้ถูกแยกออกเป็นบล็อก บล็อกประกอบด้วย an
ไม่จำเป็น บีอีจี_จี คำชี้แจงและทั้งหมด N และ E งบต่อไป บีอีจี_จี คำสั่ง if
ใด ๆ. ความหมายระดับบนสุดของ จีวีพีอาร์ โปรแกรมคือ:

ประเมินผล เริ่ม ข้อ ถ้ามี
สำหรับแต่ละกราฟอินพุต G {
สำหรับแต่ละบล็อก {
ชุด G เป็นกราฟปัจจุบันและวัตถุปัจจุบัน
ประเมินผล บีอีจี_จี ข้อ ถ้ามี
สำหรับแต่ละโหนดและขอบใน G {
ตั้งค่าโหนดหรือขอบเป็นวัตถุปัจจุบัน
ประเมินผล N or E ข้อต่างๆ ตามความเหมาะสม
}
}
ชุด G เป็นวัตถุปัจจุบัน
ประเมินผล END_G ข้อ ถ้ามี
}
ประเมินผล END ข้อ ถ้ามี

การกระทำของ เริ่ม, บีอีจี_จี, END_G และ END อนุประโยคจะดำเนินการเมื่ออนุประโยคเป็น
ประเมิน สำหรับ N or E อนุประโยค ทั้งเพรดิเคตหรือการกระทำอาจถูกละเว้น ถ้ามี
ไม่มีภาคแสดงที่มีการกระทำ การกระทำจะดำเนินการกับทุกโหนดหรือขอบเช่น
เหมาะสม. หากไม่มีการดำเนินการใดๆ และเพรดิเคตประเมินเป็นจริง ค่าที่เกี่ยวข้อง
โหนดหรือขอบถูกเพิ่มลงในกราฟเป้าหมาย

บล็อคจะถูกประเมินตามลำดับที่เกิดขึ้น ภายในบล็อก the N ข้อ
(E ตามลำดับ) จะได้รับการประเมินตามลำดับที่เกิดขึ้น หมายเหตุ แม้ว่า
ว่าภายในบล็อก N or E อนุประโยคอาจสอดประสานกัน ขึ้นอยู่กับลำดับการข้ามผ่าน

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

นอกเหนือจากประเภทฐาน C ปกติ (ถือเป็นโมฆะ, int, ถัง, ลอย, ยาว, ไม่ได้ลงนาม และ สอง),
จีวีพีอาร์ ให้ เชือก เป็นคำพ้องสำหรับ ถ่าน*และประเภทตามกราฟ node_t, ขอบ_t,
กราฟ_t และ obj_t. obj_t สามารถมองได้ว่าเป็น supertype ของคอนกรีตอีก 3 ชนิด
ประเภท; ประเภทฐานที่ถูกต้องจะคงอยู่แบบไดนามิก นอกจากประเภทฐานเหล่านี้แล้ว
เฉพาะนิพจน์ประเภทอื่นที่รองรับเท่านั้นคืออาร์เรย์ (เชื่อมโยง)

ค่าคงที่เป็นไปตามไวยากรณ์ C แต่สตริงอาจอ้างอิงด้วย "... " or '...'. จีวีพีอาร์
ยอมรับความคิดเห็น C ++ เช่นเดียวกับความคิดเห็นประเภท cpp อย่างหลังถ้าบรรทัดขึ้นต้นด้วย
อักขระ '#' ส่วนที่เหลือของบรรทัดจะถูกละเว้น

คำสั่งอาจเป็นการประกาศฟังก์ชัน ตัวแปรหรืออาร์เรย์ หรือคำสั่งปฏิบัติการ
คำแถลง. สำหรับการประกาศมีขอบเขตเดียว การประกาศอาร์เรย์มีรูปแบบ:

ชนิด แถว [ type0 ]

ที่ไหน type0 เป็นทางเลือก หากมีการจัดหา parser จะบังคับให้อาร์เรย์ทั้งหมด
ตัวห้อยมีประเภทที่ระบุ ถ้าไม่ได้ให้มา วัตถุทุกประเภทสามารถ
ใช้เป็นตัวห้อย เช่นเดียวกับในภาษา C จะต้องประกาศตัวแปรและอาร์เรย์ โดยเฉพาะอย่างยิ่ง an
ตัวแปรที่ไม่ได้ประกาศจะถูกตีความว่าเป็นชื่อของแอตทริบิวต์ของโหนด ขอบ หรือ
กราฟขึ้นอยู่กับบริบท

คำสั่งปฏิบัติการสามารถเป็นอย่างใดอย่างหนึ่งต่อไปนี้:

{ [ คำสั่ง ... ] }
การแสดงออก // อย่างธรรมดา คือ = การแสดงออก
ถ้า( การแสดงออก ) คำสั่ง [ อื่น คำสั่ง ]
สำหรับ( การแสดงออก ; การแสดงออก ; การแสดงออก ) คำสั่ง
สำหรับ( แถว [ คือ ]) คำสั่ง
ฟอร์ ( แถว [ คือ ]) คำสั่ง
ในขณะที่ ( การแสดงออก ) คำสั่ง
สวิตช์ ( การแสดงออก ) กรณี งบ
ทำลาย [ การแสดงออก ]
ต่อ [ การแสดงออก ]
กลับ [ การแสดงออก ]
รายการในวงเล็บเป็นตัวเลือก

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

คำจำกัดความของฟังก์ชันสามารถปรากฏในเครื่องหมายเท่านั้น เริ่ม ประโยค

นิพจน์รวมถึงนิพจน์ C ปกติ การเปรียบเทียบสตริงโดยใช้ == และ != รักษา
ตัวถูกดำเนินการทางขวามือเป็นรูปแบบสำหรับวัตถุประสงค์ในการจับคู่นิพจน์ทั่วไป รูปแบบ
ใช้ ครับ(1) ไวยากรณ์รูปแบบการจับคู่ไฟล์ (เพื่อความเท่าเทียมกันของสตริงอย่างง่าย ให้ใช้ strcmp
ฟังก์ชัน

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

นิพจน์ประเภทกราฟิก (เช่น กราฟ_t, โหนด_t, ขอบ_t, obj_t) อาจตามด้วย a
การอ้างอิงภาคสนามในรูปแบบของ .ชื่อ. ค่าผลลัพธ์คือค่าของแอตทริบิวต์
ชื่อ ชื่อ ของวัตถุที่กำหนด นอกจากนี้ ในบางบริบทที่ไม่ได้ประกาศ
ตัวระบุที่ไม่ได้แก้ไขจะถือเป็นชื่อแอตทริบิวต์ โดยเฉพาะอย่างยิ่ง ตัวระบุดังกล่าว
แสดงถึงคุณสมบัติของโหนดหรือขอบปัจจุบันตามลำดับใน N และ E อนุประโยคและ
กราฟปัจจุบันใน บีอีจี_จี และ END_G ข้อ

ตามปกติใน libcgraph(3) โมเดล คุณลักษณะเป็นค่าสตริง นอกจากนี้, จีวีพีอาร์
รองรับแอตทริบิวต์หลอกบางอย่างของออบเจ็กต์กราฟ ไม่จำเป็นต้องมีค่าสตริง เหล่านี้
สะท้อนคุณสมบัติที่แท้จริงของวัตถุกราฟและผู้ใช้ไม่สามารถตั้งค่าได้

หัว : node_t
หัวของขอบ

หาง : node_t
หางของขอบ

ชื่อ : เชือก
ชื่อของขอบ โหนด หรือกราฟ ชื่อของขอบมีรูปแบบ "<หาง‐
ชื่อ>[]"ที่ไหน เป็น "->"หรือ"--"ขึ้นอยู่กับ
ไม่ว่ากราฟจะถูกกำกับหรือไม่ ส่วนวงเล็บ [] จะปรากฏขึ้นก็ต่อเมื่อ
edge มีคีย์ที่ไม่สำคัญ

องศา : int
indegree ของโหนด

นอกระดับ : int
outdegree ของโหนด

ระดับ : int
ระดับของโหนด

ราก : กราฟ_t
กราฟรากของวัตถุ รูทของกราฟรูทคือตัวมันเอง

ผู้ปกครอง : กราฟ_t
กราฟหลักของกราฟย่อย พาเรนต์ของกราฟรูทคือ NULL

n_edges : int
จำนวนขอบในกราฟ

n_nodes : int
จำนวนโหนดในกราฟ

กำกับการแสดง : int
จริง (ไม่ใช่ศูนย์) ถ้ากราฟกำกับอยู่

เข้มงวด : int
จริง (ไม่ใช่ศูนย์) ถ้ากราฟเข้มงวด

สร้างขึ้นใน ฟังก์ชั่น

ฟังก์ชันต่อไปนี้สร้างขึ้นใน จีวีพีอาร์. ฟังก์ชันเหล่านั้นส่งคืนการอ้างอิงไปยังกราฟ
วัตถุกลับมา NULL ในกรณีที่ล้มเหลว

กราฟ และ กราฟย่อย
กราฟ(s : เชือก, t : เชือก): กราฟ_t
สร้างกราฟชื่อ s และประเภทที่ระบุโดยสตริง t.
ละเว้นตัวอักษร U, D, S, N มีการตีความแบบไม่มีทิศทาง
กำกับ เข้มงวด และไม่เข้มงวด ตามลำดับ ถ้า t ว่างเปล่า, กำกับ, ไม่ใช่-
สร้างกราฟที่เข้มงวด

รองลงมา(g : กราฟ_t, s : เชือก): กราฟ_t
สร้าง subgraph ใน graph g ด้วยชื่อ s. ถ้ามีซับกราฟอยู่แล้ว ก็คือ
กลับ

isSubg(g : กราฟ_t, s : เชือก): กราฟ_t
ส่งกลับกราฟย่อยในกราฟ g ด้วยชื่อ s, ถ้ามันมีอยู่, หรือ NULL มิฉะนั้น.

Fstsubg(g : กราฟ_t): กราฟ_t
ส่งกลับกราฟย่อยแรกในกราฟ g,หรือ NULL ถ้าไม่มีอยู่

nxtsubg(sg : กราฟ_t): กราฟ_t
ส่งคืน subgraph ถัดไปหลังจาก sg,หรือ NULL.

คือไดเร็กต์(g : กราฟ_t): int
คืนค่า true if และ only if g เป็นผู้กำกับ

เข้มงวด(g : กราฟ_t): int
คืนค่า true if และ only if g เข้มงวด

โหนด(g : กราฟ_t): int
ส่งกลับจำนวนโหนดใน g.

ขอบ(g : กราฟ_t): int
ส่งกลับจำนวนขอบใน g.

โหนด
ปม(sg : กราฟ_t, s : เชือก): node_t
สร้างโหนดในกราฟ g ของชื่อ s. หากมีโหนดดังกล่าวอยู่แล้ว โหนดดังกล่าวจะถูกส่งคืน

โหนดย่อย(sg : กราฟ_t, n : node_t): node_t
แทรกโหนด n ลงในหมวดย่อย g. ส่งคืนโหนด

โหนด(g : กราฟ_t): node_t
ส่งคืนโหนดแรกในกราฟ g,หรือ NULL ถ้าไม่มีอยู่

nxtnode(n : node_t): node_t
ส่งคืนโหนดถัดไปหลังจาก n ในกราฟรากหรือ NULL.

nxtnode_sg(sg : กราฟ_t, n : node_t): node_t
ส่งคืนโหนดถัดไปหลังจาก n in sg,หรือ NULL.

เป็นโหนด(sg : กราฟ_t, s : เชือก): node_t
ค้นหาโหนดใน (ย่อย) graph sg ของชื่อ s. หากมีโหนดดังกล่าวอยู่ โหนดนั้นจะถูกส่งคืน
มิฉะนั้น, NULL จะถูกส่งกลับ

คือโหนดย่อย(sg : กราฟ_t, n : node_t): int
คืนค่าที่ไม่ใช่ศูนย์ถ้า node n อยู่ใน (ย่อย) กราฟ sgหรือศูนย์อย่างอื่น

ระดับของ(sg : กราฟ_t, n : node_t): int
ส่งกลับค่า indegree ของโหนด n ใน (ย่อย) กราฟ sg.

นอกระดับของ(sg : กราฟ_t, n : node_t): int
ส่งกลับค่า outdegree ของโหนด n ใน (ย่อย) กราฟ sg.

องศาของ(sg : กราฟ_t, n : node_t): int
ส่งกลับระดับของโหนด n ใน (ย่อย) กราฟ sg.

ขอบ
ขอบ(t : node_t, h : node_t, s : เชือก): ขอบ_t
สร้างขอบด้วยโหนดหาง t, หัวโหนด h และชื่อ s ในกราฟรูท ถ้า
กราฟไม่มีทิศทาง ความแตกต่างระหว่างโหนดส่วนหัวและส่วนท้ายไม่สำคัญ
หากขอบดังกล่าวมีอยู่แล้วจะถูกส่งคืน

edge_sg(sg : กราฟ_t, t : node_t, h : node_t, s : เชือก): ขอบ_t
สร้างขอบด้วยโหนดหาง t, หัวโหนด h และชื่อ s ใน (ย่อย) กราฟ sg (และทั้งหมด
กราฟหลัก) หากกราฟไม่มีทิศทาง ความแตกต่างระหว่างหัวกับหาง
โหนดไม่สำคัญ หากขอบดังกล่าวมีอยู่แล้วจะถูกส่งคืน

ย่อย(g : กราฟ_t, e : ขอบ_t): ขอบ_t
ใส่ขอบ e ลงในหมวดย่อย g. ส่งกลับขอบ

คือEdge(t : node_t, h : node_t, s : เชือก): ขอบ_t
มองหาขอบที่มีโหนดหาง t, หัวโหนด h และชื่อ s. ถ้ากราฟเป็น
ไม่มีทิศทาง ความแตกต่างระหว่างโหนดส่วนหัวและส่วนท้ายนั้นไม่สำคัญ ถ้าเช่น
ขอบมีอยู่ก็จะถูกส่งกลับ มิฉะนั้น, NULL จะถูกส่งกลับ

isEdge_sg(sg : กราฟ_t, t : node_t, h : node_t, s : เชือก): ขอบ_t
มองหาขอบที่มีโหนดหาง t, หัวโหนด h และชื่อ s ใน (ย่อย) กราฟ sg. หาก
กราฟไม่มีทิศทาง ความแตกต่างระหว่างโหนดส่วนหัวและส่วนท้ายไม่สำคัญ
หากมีขอบดังกล่าวอยู่ก็จะถูกส่งคืน มิฉะนั้น, NULL จะถูกส่งกลับ

คือ Subedge(g : กราฟ_t, e : ขอบ_t): int
คืนค่าที่ไม่ใช่ศูนย์ถ้า edge e อยู่ใน (ย่อย) กราฟ sgหรือศูนย์อย่างอื่น

อ้วน(n : node_t): ขอบ_t
คืนค่า outedge แรกของโหนด n ในกราฟรูท

fstout_sg(sg : กราฟ_t, n : node_t): ขอบ_t
คืนค่า outedge แรกของโหนด n ใน (ย่อย) กราฟ sg.

ไม่เป็นไร(e : ขอบ_t): ขอบ_t
ส่งกลับ outedge ถัดไปหลังจาก e ในกราฟรูท

nxtout_sg(sg : กราฟ_t, e : ขอบ_t): ขอบ_t
ส่งกลับ outedge ถัดไปหลังจาก e ในกราฟ sg.

ฟสติน(n : node_t): ขอบ_t
คืนค่า inedge แรกของโหนด n ในกราฟรูท

fstin_sg(sg : กราฟ_t, n : node_t): ขอบ_t
คืนค่า inedge แรกของโหนด n ในกราฟ sg.

เอ็นซิน(e : ขอบ_t): ขอบ_t
คืนค่า inedge ถัดไปหลังจาก e ในกราฟรูท

nxtin_sg(sg : กราฟ_t, e : ขอบ_t): ขอบ_t
คืนค่า inedge ถัดไปหลังจาก e ในกราฟ sg.

ปิด(n : node_t): ขอบ_t
คืนค่าขอบแรกของโหนด n ในกราฟรูท

fstedge_sg(sg : กราฟ_t, n : node_t): ขอบ_t
คืนค่าขอบแรกของโหนด n ในกราฟ sg.

nxtedge(e : ขอบ_t, node_t): ขอบ_t
คืนค่าขอบถัดไปหลังจาก e ในกราฟรูท

nxtedge_sg(sg : กราฟ_t, e : ขอบ_t, node_t): ขอบ_t
คืนค่าขอบถัดไปหลังจาก e ในกราฟ sg.

OPP(e : ขอบ_t, node_t): node_t
ส่งคืนโหนดบนขอบ e ไม่เท่ากับ n. ส่งกลับค่า NULL if n ไม่ใช่โหนดของ
e. สิ่งนี้มีประโยชน์เมื่อใช้ ปิด และ nxtedge เพื่อแจกแจงเพื่อนบ้านของ
n.

กราฟ I / O
เขียน(g : กราฟ_t): ถือเป็นโมฆะ
พิมพ์ g ในรูปแบบจุดบนกระแสข้อมูลขาออก

เขียนG(g : กราฟ_t, ชื่อ : เชือก): ถือเป็นโมฆะ
พิมพ์ g ในรูปแบบดอทลงในไฟล์ ชื่อ.

fwriteG(g : กราฟ_t, fd : int): ถือเป็นโมฆะ
พิมพ์ g ในรูปแบบจุดบนสตรีมเปิดแสดงด้วยจำนวนเต็ม fd.

อ่านG(ชื่อ : เชือก): กราฟ_t
ส่งคืนกราฟที่อ่านจากไฟล์ ชื่อ. กราฟควรอยู่ในรูปแบบจุด ถ้าไม่
กราฟสามารถอ่านได้ NULL จะถูกส่งกลับ

FreadG(fd : int): กราฟ_t
ส่งคืนกราฟถัดไปที่อ่านจากสตรีมเปิด fd. คืนสินค้า NULL ที่ส่วนท้ายของไฟล์

กราฟ เบ็ดเตล็ด
ลบ(g : กราฟ_t, x : obj_t): ถือเป็นโมฆะ
ลบวัตถุ x จากกราฟ g. ถ้า g is NULL, ฟังก์ชันใช้กราฟรากของ
x. ถ้า x เป็นกราฟหรือกราฟย่อย ปิด เว้นแต่ x ถูกล็อค.

อยู่ใน(g : กราฟ_t, x : obj_t): int
คืนค่าจริง if x อยู่ในหมวดย่อย g.

โคลนG(g : กราฟ_t, s : เชือก): กราฟ_t
สร้างโคลนของกราฟ g ที่ชื่อว่า s. ถ้า s คือ "" กราฟที่สร้างขึ้นมี
ชื่อเดียวกับ g.

โคลน(g : กราฟ_t, x : obj_t): obj_t
สร้างโคลนของวัตถุ x ในกราฟ g. โดยเฉพาะอย่างยิ่ง วัตถุใหม่มีเหมือนกัน
แอตทริบิวต์ชื่อ/ค่าและโครงสร้างเป็นวัตถุดั้งเดิม ถ้าวัตถุที่มี
คีย์เดียวกับ x มีอยู่แล้ว คุณลักษณะของมันถูกซ้อนทับโดยพวกของ x และ
วัตถุถูกส่งกลับ หากขอบถูกลอกแบบ จุดปลายทั้งสองจะถูกลอกแบบโดยปริยาย
ถ้ากราฟถูกโคลน โหนด ขอบ และกราฟย่อยทั้งหมดจะถูกโคลนโดยปริยาย ถ้า x
เป็นกราฟ g อาจจะ NULLซึ่งในกรณีนี้วัตถุที่ลอกแบบจะเป็นรูทใหม่
กราฟ. ในกรณีนี้การโทรจะเท่ากับ โคลนG(x,"").

สำเนา(g : กราฟ_t, x : obj_t): obj_t
สร้างสำเนาของวัตถุ x ในกราฟ gโดยที่วัตถุใหม่มีชื่อ/ค่าเหมือนกัน
คุณลักษณะที่เป็นวัตถุดั้งเดิม ถ้าวัตถุที่มีคีย์เดียวกับ x แล้ว
มีอยู่ คุณลักษณะของมันถูกซ้อนทับโดยพวกของ x และวัตถุจะถูกส่งกลับ บันทึก
ว่านี่คือสำเนาตื้น ถ้า x เป็นกราฟ ไม่มีโหนด ขอบ หรือกราฟย่อยใดๆ
จะถูกคัดลอกลงในกราฟใหม่ ถ้า x เป็นขอบ จุดปลายจะถูกสร้างขึ้นถ้า
จำเป็น แต่จะไม่ถูกโคลน ถ้า x เป็นกราฟ g อาจจะ NULLซึ่งในกรณีนี้
วัตถุที่ลอกแบบจะเป็นกราฟรูทใหม่

สำเนาA(สิ่งอำนวยความสะดวก : obj_t, TGT : obj_t): int
คัดลอกแอตทริบิวต์ของวัตถุ สิ่งอำนวยความสะดวก คัดค้าน TGT, เขียนทับค่าแอตทริบิวต์ใด ๆ
TGT เบื้องต้นอาจมี

ชักจูง(g : กราฟ_t): ถือเป็นโมฆะ
ขยาย g ไปยังส่วนขยายของกราฟย่อยที่เกิดจากโหนดในกราฟราก

มี Attr(สิ่งอำนวยความสะดวก : obj_t, ชื่อ : เชือก): int
คืนค่าที่ไม่ใช่ศูนย์ถ้า object สิ่งอำนวยความสะดวก มีคุณลักษณะที่มีชื่อเป็น ชื่อ. คืนค่า 0
มิฉะนั้น.

isAtr(g : กราฟ_t, ชนิด : เชือก, ชื่อ : เชือก): int
คืนค่าที่ไม่ใช่ศูนย์หากแอตทริบิวต์ ชื่อ ถูกกำหนดไว้ใน g สำหรับวัตถุของ
กำหนด ชนิด. สำหรับโหนด ขอบ และกราฟ ชนิด ควรเป็น "N", "E" และ "G"
ตามลำดับ มันจะคืนค่า 0 มิฉะนั้น

อายุ(สิ่งอำนวยความสะดวก : obj_t, ชื่อ : เชือก): เชือก
ส่งคืนค่าแอตทริบิวต์ ชื่อ ในวัตถุ สิ่งอำนวยความสะดวก. สิ่งนี้มีประโยชน์สำหรับกรณีเหล่านั้น
เมื่อ ชื่อ ขัดแย้งกับหนึ่งในคำหลักเช่น "หัว" หรือ "ราก" ถ้า
ยังไม่ได้ประกาศแอตทริบิวต์ในกราฟ ฟังก์ชันจะเริ่มต้นด้วย
ค่าเริ่มต้นของ "" เพื่อหลีกเลี่ยงปัญหานี้ เราควรใช้ มี Attr or isAtr ฟังก์ชัน
เพื่อตรวจสอบว่าแอตทริบิวต์มีอยู่

ชุด(สิ่งอำนวยความสะดวก : obj_t, ชื่อ : เชือก, ความคุ้มค่า : เชือก): int
ตั้งค่าแอตทริบิวต์ ชื่อ ในวัตถุ สิ่งอำนวยความสะดวก ไปยัง ความคุ้มค่า. คืนค่า 0 เมื่อสำเร็จ
ความล้มเหลวไม่เป็นศูนย์ ดู อายุ ข้างบน.

รับDflt(g : กราฟ_t, ชนิด : เชือก, ชื่อ : เชือก): เชือก
ส่งกลับค่าเริ่มต้นของแอตทริบิวต์ ชื่อ ในวัตถุใน g ของที่ให้มา ชนิด. สำหรับ
โหนด ขอบ และกราฟ ชนิด ควรเป็น "N", "E" และ "G" ตามลำดับ ถ้า
ยังไม่ได้ประกาศแอตทริบิวต์ในกราฟ ฟังก์ชันจะเริ่มต้นด้วย
ค่าเริ่มต้นของ "" เพื่อหลีกเลี่ยงปัญหานี้ เราควรใช้ isAtr ฟังก์ชั่นการตรวจสอบ
ว่าแอตทริบิวต์มีอยู่

setDflt(g : กราฟ_t, ชนิด : เชือก, ชื่อ : เชือก, ความคุ้มค่า : เชือก): int
ตั้งค่าเริ่มต้นของแอตทริบิวต์ ชื่อ ไปยัง ความคุ้มค่า ในวัตถุใน g ของที่ให้มา
ชนิด. สำหรับโหนด ขอบ และกราฟ ชนิด ควรเป็น "N", "E" และ "G" ตามลำดับ
คืนค่า 0 เมื่อสำเร็จ ไม่ใช่ศูนย์เมื่อล้มเหลว ดู รับDflt ข้างบน.

fstAttr(g : กราฟ_t, ชนิด : เชือก): เชือก
ส่งกลับชื่อของแอตทริบิวต์แรกของวัตถุใน g ของที่ให้มา ชนิด. สำหรับ
โหนด ขอบ และกราฟ ชนิด ควรเป็น "N", "E" และ "G" ตามลำดับ ถ้ามี
ไม่มีแอตทริบิวต์ สตริง "" ถูกส่งกลับ

nxtAttr(g : กราฟ_t, ชนิด : เชือก, ชื่อ : เชือก): เชือก
ส่งคืนชื่อแอตทริบิวต์ถัดไปของวัตถุใน g ของที่ให้มา ชนิด หลังจากที่
คุณลักษณะ ชื่อ. อาร์กิวเมนต์ ชื่อ ต้องเป็นชื่อของแอตทริบิวต์ที่มีอยู่ มัน
โดยทั่วไปจะเป็นค่าส่งคืนของการเรียกครั้งก่อนหน้าไปยัง fstAttr or nxtAttr. สำหรับ
โหนด ขอบ และกราฟ ชนิด ควรเป็น "N", "E" และ "G" ตามลำดับ ถ้ามี
ไม่มีแอตทริบิวต์เหลืออยู่ สตริง "" จะถูกส่งคืน

เปรียบเทียบ(g : กราฟ_t, n : node_t): กราฟ_t
ส่งคืนองค์ประกอบที่เชื่อมต่อของกราฟ g ที่มีโหนด n, เป็นอักษรย่อของ
g. กราฟย่อยประกอบด้วยโหนดเท่านั้น ใช้ได้เลย ชักจูง เพื่อเพิ่มขอบ NS
ฟังก์ชั่นล้มเหลวและส่งคืน NULL if n ไม่ได้อยู่ใน g. การเชื่อมต่อขึ้นอยู่กับ
กราฟแสดงทิศทางแบบไม่มีทิศทางของ g.

ชนิดของ(obj : obj_t): เชือก
ส่งคืนตัวบ่งชี้ประเภทของ obj. สำหรับโหนด ขอบ และกราฟ จะส่งกลับ
"N", "E" และ "G" ตามลำดับ

ล็อค(g : กราฟ_t, v : int): int
ใช้การล็อกกราฟบนกราฟรูท ถ้าจำนวนเต็ม v เป็นบวก กราฟคือ
ตั้งไว้เพื่อเรียกอนาคตไปยัง ลบ ไม่มีผลในทันที ถ้า v เป็นศูนย์ the
ปลดล็อคกราฟแล้ว หากมีการเรียกให้ลบกราฟในขณะนั้น
ล็อค กราฟถูกปิด ถ้า v เป็นลบ ไม่มีอะไรทำ ในทุกกรณี
ค่าล็อคก่อนหน้านี้จะถูกส่งกลับ

Strings
วิ่ง(เอฟเอ็มที : เชือก, ...): เชือก
ส่งกลับสตริงที่เกิดจากการจัดรูปแบบค่าของนิพจน์
เกิดขึ้นภายหลัง เอฟเอ็มที ตามที่ printf(3) รูปแบบ เอฟเอ็มที

กซบ(Str : เชือก, ลูบ : เชือก): เชือก

กซบ(Str : เชือก, ลูบ : เชือก, ตัวแทน : เชือก): เชือก
รับคืน Str ด้วยการจับคู่สตริงย่อยทั้งหมด ลูบ ลบหรือแทนที่โดย ตัวแทน,
ตามลำดับ

ด้านล่าง(Str : เชือก, ลูบ : เชือก): เชือก

ด้านล่าง(Str : เชือก, ลูบ : เชือก, ตัวแทน : เชือก): เชือก
รับคืน Str ด้วยการจับคู่สตริงย่อยซ้ายสุด ลูบ ลบหรือแทนที่โดย ตัวแทน,
ตามลำดับ อักขระ '^' และ '$' สามารถใช้ที่จุดเริ่มต้นและจุดสิ้นสุด
ของ ลูบ เพื่อยึดรูปแบบไว้ที่จุดเริ่มต้นหรือจุดสิ้นสุดของ Str.

ย่อย(Str : เชือก, รหัสประจำตัว : int): เชือก

ย่อย(Str : เชือก, รหัสประจำตัว : int, len : int): เชือก
ส่งกลับสตริงย่อยของ Str เริ่มต้นที่ตำแหน่ง รหัสประจำตัว ต่อท้ายสตริงหรือ
ยาว lenตามลำดับ การจัดทำดัชนีเริ่มต้นที่ 0 ถ้า รหัสประจำตัว เป็นลบหรือ รหัสประจำตัว is
มากกว่าความยาวของ Strเกิดข้อผิดพลาดร้ายแรง ในทำนองเดียวกันในวินาที
กรณีถ้า len เป็นลบหรือ รหัสประจำตัว + len มากกว่าความยาวของ Str, ถึงแก่ชีวิต
เกิดข้อผิดพลาด

strcmp(s1 : เชือก, s2 : เชือก): int
ให้ฟังก์ชัน C มาตรฐาน strcmp(3)

ความยาว(s : เชือก): int
ส่งกลับความยาวของสตริง s.

ดัชนี(s : เชือก, t : เชือก): int

รินเดกซ์(s : เชือก, t : เชือก): int
ส่งคืนดัชนีของอักขระในสตริง s โดยที่สำเนาซ้ายสุด (ขวาสุด)
ของสตริง t สามารถพบได้หรือ -1 if t ไม่ใช่สตริงย่อยของ s.

การจับคู่(s : เชือก, p : เชือก): int
ส่งคืนดัชนีของอักขระในสตริง s ตรงซ้ายสุดของแพทเทิร์น
p สามารถพบได้หรือ -1 หากไม่มีสตริงย่อยของ s ที่ตรงกัน p.

ท็อปเปอร์(s : เชือก): เชือก
ส่งคืนเวอร์ชันของ s ด้วยตัวอักษรที่แปลงเป็นตัวพิมพ์ใหญ่

ต่ำกว่า(s : เชือก): เชือก
ส่งคืนเวอร์ชันของ s ด้วยตัวอักษรที่แปลงเป็นตัวพิมพ์เล็ก

ศีล(s : เชือก): เชือก
ส่งคืนเวอร์ชันของ s เหมาะสมที่จะใช้เป็นตัวระบุในไฟล์ดอท

HTML(g : กราฟ_t, s : เชือก): เชือก
ส่งคืนเวอร์ชัน ``magic'' ของ s เป็นสตริง HTML โดยทั่วไปจะใช้เพื่อ
แนบป้ายกำกับที่เหมือน HTML กับวัตถุกราฟ โปรดทราบว่าสตริงที่ส่งคืนอยู่ใน
g. โดยเฉพาะอย่างยิ่ง มันจะเป็นอิสระเมื่อ g ถูกปิดและทำหน้าที่เป็นสตริง HTML
จะต้องใช้กับวัตถุของ g. นอกจากนี้ โปรดทราบว่าวงเล็บมุม
คำพูดไม่ควรเป็นส่วนหนึ่งของ s. สิ่งเหล่านี้จะถูกเพิ่มหาก g เขียนด้วยคอนกรีต DOT
จัดรูปแบบ

ishtml(s : เชือก): int
คืนค่าที่ไม่ใช่ศูนย์ if และ only if s เป็นสตริง HTML

xของ(s : เชือก): เชือก
ส่งคืนสตริง "x" ถ้า s มีรูปแบบ "x,y" โดยที่ทั้งสอง x และ y เป็นตัวเลข

คุณ(s : เชือก): เชือก
ส่งคืนสตริง "y" ถ้า s มีรูปแบบ "x,y" โดยที่ทั้งสอง x และ y เป็นตัวเลข

ของ(s : เชือก): เชือก
ส่งคืนสตริง "llx,lly" ถ้า s มีรูปแบบ "llx,lly,คุณ,อูริ"ซึ่งทั้งหมด llx,
lly, คุณและ อูริ เป็นตัวเลข

คุณของ(s)
คุณของ(s : เชือก): เชือก ส่งคืนสตริง "คุณ,อูริ" ถ้า s มีรูปแบบ
"llx,lly,คุณ,อูริ"ซึ่งทั้งหมด llx, lly, คุณและ อูริ เป็นตัวเลข

สแกน(s : เชือก, เอฟเอ็มที : เชือก, ...): int
สแกนสตริง s, ดึงค่าตามค่า สแกน(3) รูปแบบ เอฟเอ็มที.
ค่าจะถูกเก็บไว้ในที่อยู่ต่อไปนี้ เอฟเอ็มที, ที่อยู่ที่มีรูปแบบ &v,
ที่ไหน v เป็นตัวแปรที่ประกาศเป็นประเภทที่ถูกต้อง ส่งกลับจำนวนรายการ
สแกนสำเร็จแล้ว

แยก(s : เชือก, ขึ้น : แถว, Seps : เชือก): int

แยก(s : เชือก, ขึ้น : แถว): int

สัญญาณ(s : เชือก, ขึ้น : แถว, Seps : เชือก): int

สัญญาณ(s : เชือก, ขึ้น : แถว): int
พื้นที่ แยก ฟังก์ชั่นแบ่งสตริง s ลงในทุ่งนาในขณะที่ สัญญาณ ฟังก์ชัน
แบ่งสตริงเป็นโทเค็น ฟิลด์ประกอบด้วยอักขระที่ไม่ใช่ตัวคั่นทั้งหมด
ระหว่างอักขระตัวคั่นสองตัวหรือจุดเริ่มต้นหรือจุดสิ้นสุดของสตริง ดังนั้น a
ฟิลด์อาจเป็นสตริงว่าง โทเค็นเป็นสตริงย่อยที่ไม่ว่างเปล่าสูงสุด
ที่มีตัวคั่น อักขระตัวคั่นคืออักขระที่ระบุใน
Seps การโต้แย้ง. ถ้า Seps ไม่ได้ระบุ ค่าเริ่มต้นคือ " \t\n" NS
ฟังก์ชันส่งคืนจำนวนฟิลด์หรือโทเค็น

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

I / O
พิมพ์(...): ถือเป็นโมฆะ
พิมพ์( ด่วน, ... ) พิมพ์การแสดงสตริงของอาร์กิวเมนต์แต่ละรายการในทางกลับกันไปยัง
แย่ตามด้วยขึ้นบรรทัดใหม่

printf(เอฟเอ็มที : เชือก, ...): int

printf(fd : int, เอฟเอ็มที : เชือก, ...): int
พิมพ์สตริงที่เกิดจากการจัดรูปแบบค่าของนิพจน์ต่อไปนี้
เอฟเอ็มที ตามที่ printf(3) รูปแบบ เอฟเอ็มที. คืนค่า 0 เมื่อสำเร็จ โดยค่าเริ่มต้น มัน
พิมพ์บน แย่. ถ้าจำนวนเต็มไม่จำเป็น fd จะได้รับ, เอาต์พุตถูกเขียนบน
เปิดสตรีมที่เกี่ยวข้องกับ fd.

scanf(เอฟเอ็มที : เชือก, ...): int

scanf(fd : int, เอฟเอ็มที : เชือก, ...): int
สแกนค่าจากสตรีมอินพุตตาม scanf(3) รูปแบบ เอฟเอ็มที.
ค่าจะถูกเก็บไว้ในที่อยู่ต่อไปนี้ เอฟเอ็มที, ที่อยู่ที่มีรูปแบบ &v,
ที่ไหน v เป็นตัวแปรที่ประกาศเป็นประเภทที่ถูกต้อง โดยค่าเริ่มต้น จะอ่านจาก
สเตดิน. ถ้าจำนวนเต็มไม่จำเป็น fd จะได้รับ อินพุตถูกอ่านจากสตรีมเปิด
ที่เกี่ยวข้องกับ fd. ส่งกลับจำนวนรายการที่สแกนสำเร็จ

โอเพ่นฟ(s : เชือก, t : เชือก): int
เปิดไฟล์ s เป็นสตรีม I/O อาร์กิวเมนต์สตริง t ระบุว่าไฟล์เป็น
เปิด อาร์กิวเมนต์เหมือนกับฟังก์ชัน C เปิด(3). ส่งคืน an
จำนวนเต็มแสดงถึงสตรีมหรือ -1 เมื่อมีข้อผิดพลาด

ตามปกติแล้ว สตรีม 0, 1 และ 2 ได้เปิดเป็น .แล้ว สเตดิน, แย่และ สตเดอร์,
ตามลำดับ ตั้งแต่ จีวีพีอาร์ อาจใช้ สเตดิน ในการอ่านกราฟอินพุต ผู้ใช้ควร
หลีกเลี่ยงการใช้สตรีมนี้

ปิดF(fd : int): int
ปิดสตรีมเปิดที่แสดงด้วยจำนวนเต็ม fd. สตรีม 0, 1 และ 2 ไม่สามารถ
ปิด. คืนค่า 0 เมื่อสำเร็จ

อ่าน L(fd : int): เชือก
ส่งคืนบรรทัดถัดไปที่อ่านจากอินพุตสตรีม fd. ส่งคืนสตริงว่าง ""
ที่ส่วนท้ายของไฟล์ โปรดทราบว่าอักขระขึ้นบรรทัดใหม่จะเหลืออยู่ในสตริงที่ส่งคืน

คณิตศาสตร์
ประสบการณ์(d : สอง): สอง
ส่งกลับ e ไปยัง dพลังที

เข้าสู่ระบบ(d : สอง): สอง
ส่งคืนล็อกธรรมชาติของ d.

ตร.ว(d : สอง): สอง
คืนค่ารากที่สองของ double d.

ธาร(d : สอง, x : สอง): สอง
รับคืน d ยกขึ้นเป็น xพลังที

เกวียน(d : สอง): สอง
ส่งกลับค่าโคไซน์ของ d.

บาป(d : สอง): สอง
ส่งกลับค่าไซน์ของ d.

อาทาน2(y : สอง, x : สอง): สอง
ส่งกลับอาร์คแทนเจนต์ของ y / x ในช่วง -pi ถึง pi

นาที(y : สอง, x : สอง): สอง
ส่งกลับค่าต่ำสุดของ y และ x.

MAX(y : สอง, x : สอง): สอง
ส่งกลับค่าสูงสุดของ y และ x.

ที่สมาคม อาร์เรย์
# ขึ้น : int
ส่งกลับจำนวนองค์ประกอบในอาร์เรย์ ขึ้น.

รหัสประจำตัว in ขึ้น : int
คืนค่า 1 หากตั้งค่าสำหรับ index รหัสประจำตัว ในอาร์เรย์ ขึ้น. คืนค่า 0
มิฉะนั้น.

ยกเลิกการตั้งค่า(v : แถว, รหัสประจำตัว): int
ลบรายการที่จัดทำดัชนีโดย รหัสประจำตัว. คืนค่า 1 หากมีรายการอยู่ มิฉะนั้น 0

ยกเลิกการตั้งค่า(v : แถว): ถือเป็นโมฆะ
กำหนดค่าเริ่มต้นอาร์เรย์อีกครั้ง

เบ็ดเตล็ด
ทางออก(v : int): ถือเป็นโมฆะ
สาเหตุที่ จีวีพีอาร์ เพื่อออกด้วยรหัสทางออก v.

ระบบ(cmd : เชือก): int
ให้ฟังก์ชัน C มาตรฐาน ระบบ(3). มันรัน cmd ในเปลือกของผู้ใช้
สภาพแวดล้อม และส่งคืนสถานะการออกของเชลล์

ทั้งหมด- สอง
ส่งกลับค่าสุ่มหลอกสองเท่าระหว่าง 0 ถึง 1

เส้นใย- int

เส้นใย(v : int): int
ตั้งเมล็ดพันธุ์สำหรับเครื่องกำเนิดตัวเลขสุ่ม อาร์กิวเมนต์ที่เป็นทางเลือกให้เมล็ด
หากไม่ระบุ เวลาปัจจุบันจะถูกใช้ ค่าเมล็ดก่อนหน้าจะถูกส่งกลับ
เส้นใย ควรโทรก่อนโทรไป ทั้งหมด.

สีx(สี : เชือก, เอฟเอ็มที : เชือก): เชือก
แปลสีจากรูปแบบหนึ่งเป็นอีกรูปแบบหนึ่ง NS สี อาร์กิวเมนต์ควรเป็นสี
ในการแสดงสตริงที่รู้จักอย่างใดอย่างหนึ่ง NS เอฟเอ็มที ค่าควรเป็นหนึ่งใน
"RGB", "RGBA", "HSV" หรือ "HSVA" สตริงว่างถูกส่งกลับเมื่อมีข้อผิดพลาด

สร้างขึ้นใน ตัวแปร

จีวีพีอาร์ ให้ตัวแปรพิเศษในตัวบางตัว ซึ่งค่าจะถูกตั้งค่าโดยอัตโนมัติโดย
จีวีพีอาร์ ขึ้นอยู่กับบริบท ยกเว้นตามที่ระบุไว้ ผู้ใช้ไม่สามารถแก้ไขค่าของตนได้

$ : obj_t
หมายถึงวัตถุปัจจุบัน (โหนด ขอบ กราฟ) ขึ้นอยู่กับบริบท มันไม่ใช่
พร้อมใช้งานใน เริ่ม or END ข้อ

$F : เชือก
เป็นชื่อของไฟล์อินพุตปัจจุบัน

$G : กราฟ_t
หมายถึงกราฟปัจจุบันที่กำลังประมวลผล ไม่มีใน เริ่ม or END
ข้อ

$NG : กราฟ_t
หมายถึงกราฟถัดไปที่จะประมวลผล ถ้า $NG คือ NULL กราฟปัจจุบัน $G คือ
กราฟสุดท้าย โปรดทราบว่าหากอินพุตมาจาก stdin กราฟสุดท้ายจะไม่เป็น
กำหนดจนกว่าท่ออินพุตจะปิด ไม่มีใน เริ่ม or END
ข้อหรือถ้า -n ใช้ธง

$O : กราฟ_t
หมายถึงกราฟเอาท์พุท ก่อนการข้ามผ่านของกราฟ จะมีการเริ่มต้นไปยังเป้าหมาย
กราฟ. หลังจากข้ามผ่านและอื่นๆ END_G การกระทำ หากอ้างถึงกราฟที่ไม่ว่างเปล่า
กราฟนั้นถูกพิมพ์ลงบนกระแสข้อมูลขาออก ใช้ได้เฉพาะใน N, E และ END_G
ข้อ ผู้ใช้อาจตั้งค่ากราฟเอาต์พุตได้

$T : กราฟ_t
หมายถึงกราฟเป้าหมายปัจจุบัน เป็น subgraph ของ $G และมีเฉพาะใน
N, E และ END_G ข้อ

$tgtชื่อ : เชือก
หมายถึงชื่อของกราฟเป้าหมาย โดยค่าเริ่มต้น จะถูกตั้งค่าเป็น "gvpr_result". ถ้า
ใช้หลายครั้งในระหว่างการดำเนินการของ จีวีพีอาร์, ชื่อจะต่อท้ายด้วย an
จำนวนเต็ม. ตัวแปรนี้อาจกำหนดโดยผู้ใช้

$tvroot : node_t
ระบุโหนดเริ่มต้นสำหรับความลึก (โดยตรงหรือไม่มีทิศทาง) ก่อนหรือกว้าง-
การข้ามผ่านครั้งแรกของกราฟ (cf. $tvtype ด้านล่าง). ค่าเริ่มต้นคือ NULL for
แต่ละกราฟอินพุต หลังจากการข้ามผ่านที่รูทที่กำหนด ถ้าค่าของ $tvroot
เปลี่ยนไปแล้ว การข้ามผ่านใหม่จะเริ่มด้วยค่าใหม่เป็น $tvroot. นอกจากนี้ set
$ทีวีถัดไป ด้านล่าง

$ทีวีถัดไป : node_t
ระบุโหนดเริ่มต้นถัดไปสำหรับความลึก (โดยตรงหรือไม่มีทิศทาง) ก่อนหรือ
การข้ามผ่านแบบกว้างครั้งแรกของกราฟ (cf. $tvtype ด้านล่าง). หากการข้ามผ่านเสร็จสิ้น
และ $tvroot ไม่ได้รับการรีเซ็ต แต่ $ทีวีถัดไป ได้ตั้งไว้แต่ไม่ได้ใช้ นี่
โหนดจะถูกใช้เป็นตัวเลือกต่อไปสำหรับ $tvroot. ค่าเริ่มต้นคือ NULL for
แต่ละกราฟอินพุต

$tvedge : ขอบ_t
สำหรับ BFS และ DFS traversals ค่านี้จะถูกกำหนดเป็น edge ที่ใช้ในการมาถึงปัจจุบัน
โหนดหรือขอบ ที่จุดเริ่มต้นของการข้ามผ่านหรือสำหรับการข้ามประเภทอื่น
มูลค่าคือ NULL.

$tvtype : ทีวีประเภท_t
บ่งบอกว่า จีวีพีอาร์ ข้ามกราฟ ใช้ค่าคงที่ได้เพียงค่าเดียว
ด้วยคำนำหน้า "TV_" ที่อธิบายไว้ด้านล่าง TV_แบน เป็นค่าเริ่มต้น

ในไลบรารีกราฟพื้นฐาน ซีกราฟ(3) ขอบในกราฟที่ไม่มีทิศทางจะได้รับ
ทิศทางโดยพลการ ใช้สำหรับการข้ามผ่าน เช่น TV_fwd, ต้องใช้
ขอบตรง

อาร์จีซี : int
หมายถึงจำนวนอาร์กิวเมนต์ที่ระบุโดย -a args อาร์กิวเมนต์บรรทัดคำสั่ง

อาร์จีวี : เชือก แถว
หมายถึงอาร์เรย์ของอาร์กิวเมนต์ที่ระบุโดย -a args อาร์กิวเมนต์บรรทัดคำสั่ง NS
iอาร์กิวเมนต์ได้รับโดย อาร์จีวี[i].

สร้างขึ้นใน ค่าคงที่

มีค่าคงที่สัญลักษณ์หลายอย่างที่กำหนดโดย จีวีพีอาร์.

NULL : obj_t
การอ้างอิงวัตถุ null เทียบเท่ากับ 0

TV_แบน : ทีวีประเภท_t
การข้ามผ่านที่เรียบง่ายและแบนราบ โดยมีวัตถุกราฟที่เข้าชมในลำดับที่ดูเหมือนไม่มีกฎเกณฑ์

ทีวี_เน : ทีวีประเภท_t
การข้ามผ่านที่เข้าชมโหนดทั้งหมดก่อน จากนั้นจึงไปที่ขอบทั้งหมด

TV_th : ทีวีประเภท_t
การข้ามผ่านซึ่งเข้าไปที่ขอบทั้งหมดก่อน จากนั้นจึงไปที่โหนดทั้งหมด

TV_dfs : ทีวีประเภท_t
TV_postdfs : ทีวีประเภท_t
TV_prepostdfs : ทีวีประเภท_t
การข้ามผ่านของกราฟโดยใช้การค้นหาเชิงลึกครั้งแรกบนพื้นฐานที่ไม่มีทิศทาง
กราฟ. เพื่อทำการสำรวจ จีวีพีอาร์ จะตรวจสอบค่าของ $tvroot. ถ้าสิ่งนี้มี
ค่าเดียวกับที่เคยมีมา (เมื่อเริ่มต้น ค่าก่อนหน้าจะถูกเตรียมข้อมูลเบื้องต้น
ไปยัง NULL.) จีวีพีอาร์ จะมองหาโหนดที่ไม่ได้เยี่ยมชมและข้ามผ่านการเชื่อมต่อ
ส่วนประกอบ. ในทางกลับกัน ถ้า $tvroot มีการเปลี่ยนแปลงส่วนประกอบที่เชื่อมต่อจะ
ไปเที่ยวโดยถือว่ายังไม่เคยไปหรือถ้า $tvroot is NULLที่
การข้ามผ่านจะหยุด โปรดทราบว่าการใช้ TV_dfs และ $tvrootสามารถสร้างได้
วงอนันต์

โดยค่าเริ่มต้น การข้ามผ่านจะทำในการสั่งซื้อล่วงหน้า นั่นคือมีการเยี่ยมชมโหนดมาก่อน
ขอบที่มองไม่เห็นทั้งหมด สำหรับ TV_postdfsขอบที่ไม่ได้เยี่ยมชมทั้งหมดของโหนดคือ
เยี่ยมชมก่อนโหนด สำหรับ TV_prepostdfs, มีการเยี่ยมชมโหนดสองครั้งก่อนและ
หลังจากขอบที่มองไม่เห็นทั้งหมด

TV_fwd : ทีวีประเภท_t
TV_postfwd : ทีวีประเภท_t
TV_prepostfwd : ทีวีประเภท_t
การข้ามผ่านของกราฟโดยใช้การค้นหาเชิงลึกครั้งแรกบนกราฟที่ตามมาเท่านั้น
ส่วนโค้งไปข้างหน้า ทางเลือกของรากสำหรับการข้ามผ่านจะเหมือนกับที่อธิบายไว้สำหรับ
TV_dfs ข้างต้น. ลำดับการมาเยี่ยมต่าง ๆ ที่ระบุโดย TV_fwd, TV_postfwd
และ TV_prepostfwd เหมือนกับที่ระบุโดยเส้นทางที่คล้ายคลึงกัน
TV_dfs, TV_postdfs และ TV_prepostdfs.

ทีวี_รอบ : ทีวีประเภท_t
ทีวี_โพสต์เรฟ : ทีวีประเภท_t
TV_prepostrev : ทีวีประเภท_t
การข้ามผ่านของกราฟโดยใช้การค้นหาเชิงลึกครั้งแรกบนกราฟที่ตามมาเท่านั้น
ส่วนโค้งย้อนกลับ ทางเลือกของรากสำหรับการข้ามผ่านจะเหมือนกับที่อธิบายไว้สำหรับ
TV_dfs ข้างต้น. ลำดับการมาเยี่ยมต่าง ๆ ที่ระบุโดย ทีวี_รอบ, ทีวี_โพสต์เรฟ
และ TV_prepostrev เหมือนกับที่ระบุโดยเส้นทางที่คล้ายคลึงกัน
TV_dfs, TV_postdfs และ TV_prepostdfs.

TV_bfs : ทีวีประเภท_t
การข้ามผ่านของกราฟโดยใช้การค้นหาแบบกว้างๆ บนกราฟโดยไม่สนใจขอบ
ทิศทาง. ดูรายการบน TV_dfs ข้างต้นสำหรับบทบาทของ $tvroot.

ตัวอย่าง

จีวีพีอาร์ -i 'ไม่มี[สี=="สีน้ำเงิน"]' ไฟล์. gv

สร้างกราฟย่อยที่เกิดจากโหนดของโหนดทั้งหมดที่มีสีน้ำเงิน

จีวีพีอาร์ -c 'N[สี=="สีน้ำเงิน"]{สี = "สีแดง"}' ไฟล์. gv

ทำให้โหนดสีน้ำเงินทั้งหมดเป็นสีแดง

เริ่ม { int n, e; int ทีโอที_n = 0; int สิริ = 0; }
บีอีจี_จี {
n = nโหนด($G);
e = ขอบ($G);
printf ("%NS โหนด %d ขอบ %s\n", n, e, $G.ชื่อ);
ทีโอที_n += n;
สิริ += e;
}
END { printf ("%NS โหนด %d ขอบ รวม\n", โทท_เอ็น, สิริ) }

เวอร์ชั่นของโปรแกรม gc.

จีวีพีอาร์ -c ""

เทียบเท่ากับ Nope.

บีอีจี_จี { กราฟ_t g = กราฟ ("ผสาน", "NS"); }
E {
node_t h = โคลน(g,$.head);
node_t t = โคลน(g,$.tail);
ขอบ_t e = ขอบ(t,h,"");
e.น้ำหนัก = e.น้ำหนัก + 1;
}
END_G { $O = g; }

สร้างกราฟอินพุตเวอร์ชันที่เข้มงวด โดยที่แอตทริบิวต์น้ำหนักของขอบ
ระบุจำนวนขอบจากกราฟอินพุตที่ขอบแสดง

เริ่ม {node_t n; int องศา[]}
อี{องศา[หัว]++; องศา[หาง]++; }
END_G {
for (องศา[n]) {
printf ("องศา[%s] = %d\n", น.ชื่อ องศา[n]);
}
}

คำนวณองศาของโหนดที่มีขอบ

เริ่ม {
int i, เยื้อง;
int เห็น[สตริง];
ถือเป็นโมฆะ ปริญญ์ (นานาชาติ คต) {
for (i = 0; i < ซีเอ็นที; ผม++) printf (" ");
}
}
บีอีจี_จี {

$tvtype = TV_prepostfwd;
$tvroot = โหนด($,ARGV[0]);
}
N {
if (เห็น[$.name]) เยื้อง--;
อื่น {
prInd(เยื้อง);
พิมพ์ ($.ชื่อ);
เห็น[$.name] = 1;
เยื้อง++;
}
}

พิมพ์การข้ามผ่านของกราฟเชิงลึกเป็นอันดับแรก โดยเริ่มจากโหนดที่ชื่อ
อาร์จีวี[0]เป็นรายการที่เยื้อง

และพวกเรา

กฟปราพัท
รายการไดเร็กทอรีที่คั่นด้วยเครื่องหมายโคลอนเพื่อค้นหาไฟล์ที่ระบุโดย
ตัวเลือก -f จีวีพีอาร์ มีรายการเริ่มต้นในตัว ถ้า กฟปราพัท ไม่ได้กำหนดไว้
ใช้รายการเริ่มต้น ถ้า กฟปราพัท เริ่มต้นด้วยเครื่องหมายทวิภาค รายการจะถูกสร้างขึ้นโดย
ท้าย กฟปราพัท ไปที่รายการเริ่มต้น ถ้า กฟปราพัท ลงท้ายด้วยโคลอน รายการคือ
เกิดขึ้นจากการต่อท้ายรายการเริ่มต้นไปที่ กฟปราพัท. มิฉะนั้น, กฟปราพัท ใช้สำหรับ
รายการ.

ในระบบ Windows ให้แทนที่ ``colon'' ด้วย ``semicolon'' ในย่อหน้าก่อนหน้า

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