gvpr - מקוון בענן

תָכְנִית:

שֵׁם

gvpr - שפת סריקה ועיבוד של דפוסי גרף

תַקצִיר

gvpr [-icnqV?] [ -o אוסף ] [ -a טוען ] [ 'פרוג' | -f קובץ פרופיל ] [ קבצים ]

תיאור

gvpr (בעבר בשם gpr) הוא עורך זרם גרפים בהשראת awk. זה מעתיק קלט
גרפים לפלט שלו, אולי לשנות את המבנה והתכונות שלהם, ליצור חדש
גרפים, או הדפסת מידע שרירותי. מודל הגרף הוא זה שמסופק על ידי
libcgraph(3). באופן מיוחד, gvpr קורא וכותב גרפים באמצעות שפת הנקודות.

בעיקרון, gvpr חוצה כל גרף קלט, מסומן ב $G, ביקור בכל צומת וקצה,
התאמתו לכללי הפעולה של הפרדיקטים שסופקו בתוכנית הקלט. הכללים הם
מוערך לפי הסדר. עבור כל פרידיקט שמעריך נכון, הפעולה המתאימה היא
מְבוּצָע. במהלך המעבר, הצומת או הקצה הנוכחיים שמבקרים בו מסומנים ב $.

עבור כל גרף קלט, יש תת-גרף יעד, המסומן ב $T, בתחילה ריק ומשמש
לצבור ישויות נבחרות וגרף פלט, $O, משמש לעיבוד סופי ולאחר מכן
נכתב לפלט. כברירת מחדל, גרף הפלט הוא גרף היעד. גרף הפלט
ניתן להגדיר בתוכנית או, במובן מוגבל, בשורת הפקודה.

אפשרויות

האפשרויות הבאות נתמכות:

-a טוען
המיתר טוען מפוצל לאסימונים מופרדים ברווחים לבנים, עם הפרט
אסימונים זמינים כמחרוזות ב- gvpr תכנית כמו ARGV[0],...,ARGV[ARGC-1].
תווי רווח לבן בתוך מחרוזות משנה עם מרכאות בודדות או כפולות, או שלפניהן א
נטוי אחורי, מתעלמים כמפרידים. באופן כללי, תו נטוי נכבה
כל משמעות מיוחדת של הדמות הבאה. שימו לב שהאסימונים נבעו מ
מספר -a דגלים משורשרים.

-c השתמש בגרף המקור בתור גרף הפלט.

-i הגזר את הרחבת תת-גרף המושרה על ידי הצומת של גרף הפלט בהקשר של
גרף השורש שלו.

-o אוסף
גורם לזרם הפלט להיכתב לקובץ שצוין; כברירת מחדל, הפלט הוא
כתב לי stdout.

-f קובץ פרופיל
השתמש בתוכן של הקובץ שצוין כתוכנית לביצוע על הקלט. אם
קובץ פרופיל מכיל תו לוכסן, השם נלקח כשם הנתיב של הקובץ.
אחרת, gvpr ישתמש בספריות המצוינות במשתנה הסביבה
GVPRPATH כדי לחפש את הקובץ. אם -f לא ניתן, gvpr ישתמש באי הראשון
ארגומנט האופציה בתור התוכנית.

-q מכבה את הודעות האזהרה.

-n מכבה את הקריאה קדימה של הגרף. כברירת מחדל, המשתנה $NG מוגדר לגרף הבא
לעיבוד. זה דורש קריאה של הגרף הבא לפני עיבוד
הגרף הנוכחי, שעלול לחסום אם הגרף הבא נוצר רק בתגובה
פעולה כלשהי הנוגעת לעיבוד הגרף הנוכחי.

-V גורם לתוכנית להדפיס מידע גרסה ולצאת.

-? גורם לתוכנית להדפיס מידע שימוש ולצאת.

אופרנדים

האופרנד הבא נתמך:

קבצים שמות של קבצים המכילים גרף אחד או יותר בשפת הנקודות. אם לא -f אוֹפְּצִיָה
נתון, השם הפרטי מוסר מהרשימה ומשמש כתוכנית הקלט.
אם רשימת הקבצים ריקה, סטדין יהיה בשימוש.

תוכניות

A gvpr התוכנית מורכבת מרשימה של סעיפי פעולה פרדיקטים, באחת מהצורות:

התחל { פעולה }

BEG_G { פעולה }

N [ לְבַסֵס ] { פעולה }

E [ לְבַסֵס ] { פעולה }

END_G { פעולה }

הסוף { פעולה }

תוכנית יכולה להכיל לכל היותר אחד מכל אחד מה- התחל, END_G ו הסוף סעיפים. יש יכול
להיות מספר כלשהו של BEG_G, N ו E הצהרות, הראשון חל על גרפים, השני על
צמתים, השלישי לקצוות. אלה מופרדים לבלוקים, בלוק המורכב מ-
אופציונלי BEG_G הצהרה והכל N ו E הצהרות עד הבאות BEG_G הצהרה, אם
כל. הסמנטיקה ברמה העליונה של א gvpr התוכנית היא:

הערך את התחל סעיף, אם בכלל.
עבור כל גרף קלט G {
עבור כל בלוק {
לקבוע G בתור הגרף הנוכחי והאובייקט הנוכחי.
הערך את BEG_G סעיף, אם בכלל.
עבור כל צומת וקצה פנימה G {
הגדר את הצומת או הקצה כאובייקט הנוכחי.
הערך את N or E סעיפים, לפי העניין.
}
}
לקבוע G בתור האובייקט הנוכחי.
הערך את END_G סעיף, אם בכלל.
}
הערך את הסוף סעיף, אם בכלל.

הפעולות של ה התחל, BEG_G, END_G ו הסוף סעיפים מבוצעים כאשר הסעיפים כן
העריך. ל N or E סעיפים, ניתן להשמיט את הפרדיקט או הפעולה. אם יש
אין פרדיקט עם פעולה, הפעולה מתבצעת בכל צומת או קצה, כמו
מתאים. אם אין פעולה והפרדיקט מוערך כאמת, המשויך
צומת או קצה מתווספים לגרף היעד.

הבלוקים מוערכים לפי סדר הופעתם. בתוך בלוק, ה N סעיפים
(E סעיפים, בהתאמה) מוערכים לפי סדר התרחשותם. שים לב, עם זאת,
שבתוך בלוק, N or E סעיפים עשויים להיות משולבים, בהתאם לסדר המעבר.

פרדיקטים ופעולות הם רצפים של הצהרות בניב C הנתמכים על ידי ה
ביטוי(3) ספריה. ההבדל היחיד בין פרדיקטים לפעולות הוא שהראשון
חייב להיות סוג שעשוי להתפרש כאמת או לא נכון. כאן ה-C הרגיל
פועלת לפי מוסכמה, שבה ערך שאינו אפס נחשב נכון. זה יכלול
מחרוזות לא ריקות והפניות לא ריקות לצמתים, קצוות וכו'. עם זאת, אם מחרוזת יכולה
להמיר למספר שלם, נעשה שימוש בערך זה.

בנוסף לסוגי בסיס C הרגילים (לבטל את, int, char, לצוף, ארוך, לא חתום ו לְהַכפִּיל),
gvpr מספק מחרוזת כמילה נרדפת ל לְהַשְׁחִיר*, והסוגים המבוססים על גרפים node_t, edge_t,
graph_t ו obj_t. ה obj_t ניתן לראות את הסוג כעל טיפוס של 3 הבטון האחרים
סוגים; סוג הבסיס הנכון נשמר באופן דינמי. מלבד סוגי הבסיס הללו, ה
רק ביטויי סוג נתמכים אחרים הם מערכים (אסוציאטיביים).

הקבועים עוקבים אחר תחביר C, אך ניתן לצטט מחרוזות עם אחד מהם "..." or '...'. gvpr
מקבל הערות C++ כמו גם הערות מסוג cpp. עבור האחרון, אם שורה מתחילה עם
תו '#', מתעלמים משאר השורה.

משפט יכול להיות הכרזה של פונקציה, משתנה או מערך, או קובץ הפעלה
הַצהָרָה. להצהרות, יש היקף יחיד. להצהרות מערך יש את הטופס:

סוג מערך [ type0 ]

איפה type0 הוא אופציונלי. אם הוא מסופק, המנתח יאכוף את כל המערך הזה
לנרשמים יש את הסוג שצוין. אם זה לא מסופק, חפצים מכל הסוגים יכולים להיות
משמש כמנוי. כמו ב-C, יש להצהיר על משתנים ומערכים. בפרט, א
משתנה לא מוצהר יתפרש כשם של תכונה של צומת, edge או
גרף, בהתאם להקשר.

הצהרות הניתנות להפעלה יכולות להיות אחת מהאפשרויות הבאות:

{ [ הצהרה ... ] }
ביטוי // בדרך כלל היה = ביטוי
אם ביטוי ) הצהרה [ אחר הצהרה ]
עבור ( ביטוי ; ביטוי ; ביטוי ) הצהרה
עבור ( מערך [ היה ]) הצהרה
forr( מערך [ היה ]) הצהרה
בזמן( ביטוי ) הצהרה
מתג ( ביטוי ) מקרה הצהרות
לשבור [ ביטוי ]
להמשיך [ ביטוי ]
לַחֲזוֹר [ ביטוי ]
פריטים בסוגריים הם אופציונליים.

בצורה השנייה של ה ל הצהרה ו פור משפט, המשתנה היה מוגדר
כל ערך משמש כאינדקס במערך שצוין ולאחר מכן המשויך הצהרה is
העריך. עבור מדדים מספריים ומחרוזים, המדדים מוחזרים בעלייה
סדר מספרי או לקסיקוגרפי (יורד) עבור ל (פור, בהתאמה). זה יכול לשמש
למיון.

הגדרות פונקציות יכולות להופיע רק ב- התחל סעיף.

ביטויים כוללים את ביטויי C הרגילים. השוואות מחרוזות באמצעות == ו != לטפל ב
אופרנד יד ימין כתבנית לצורך התאמת ביטוי רגולרי. דפוסים
להשתמש ksh(1) תחביר דפוס התאמת קובץ. (עבור שוויון מיתרים פשוט, השתמש ב- strcmp
פונקציה.

gvpr ינסה להשתמש בביטוי כמחרוזת או כערך מספרי לפי הצורך. שניהם
יציאות דמויות C ותבניות פונקציות יגרמו לביצוע המרות, במידת האפשר.

ביטויים של סוג גרפי (כלומר, graph_t, node_t, edge_t, obj_t) עשוי להיות אחריו א
הפניה לשדה בצורה של .שם. הערך המתקבל הוא הערך של התכונה
בשם שם של האובייקט הנתון. בנוסף, בהקשרים מסוימים, לא מוצהר,
מזהה לא שונה נחשב לשם תכונה. ספציפית, מזהים כאלה
מציין תכונות של הצומת או הקצה הנוכחיים, בהתאמה, ב N ו E סעיפים, ואת
גרף נוכחי BEG_G ו END_G סעיפים.

כרגיל ב libcgraph(3) מודל, תכונות מוערכות מחרוזת. בנוסף, gvpr
תומך בתכונות פסאודו מסוימות של אובייקטי גרף, לא בהכרח בעלי ערך מחרוזת. אלה
משקף מאפיינים מהותיים של אובייקטי הגרף ולא ניתן להגדיר אותם על ידי המשתמש.

ראש : node_t
ראש קצה.

זנב : node_t
זנב של קצה.

שם : מחרוזת
שם של קצה, צומת או גרף. לשם של קצה יש את הצורה "<tail‐
שם>[]", איפה הוא "->"או"--" תלוי ב
אם הגרף מכוון או לא. חלק התושבת [] מופיע רק אם ה
לקצה יש מפתח לא טריוויאלי.

תואר : int
המדרגה של צומת.

מעלה תואר : int
דרגת החוץ של צומת.

תוֹאַר : int
מידת הצומת.

שורש : graph_t
גרף השורש של אובייקט. השורש של גרף שורש הוא עצמו.

הורה : graph_t
גרף האב של תת-גרף. האב של גרף שורש הוא NULL

n_edges : int
מספר הקצוות בגרף

n_צמתים : int
מספר הצמתים בגרף

מְכוּוָן : int
נכון (לא אפס) אם הגרף מכוון

קַפְּדָנִי : int
נכון (לא אפס) אם הגרף קפדני

BUILT-IN פונקציות

הפונקציות הבאות מובנות gvpr. הפונקציות הללו מחזירות הפניות לגרף
חפצים חוזרים NULL במקרה של כישלון.

גרפים ו תת-גרף
גרף(s : מחרוזת, t : מחרוזת): graph_t
יוצר גרף ששמו s והסוג שלו מצוין על ידי המחרוזת t.
מתעלמים מרישיות, הדמויות U, D, S, N יש את הפרשנות לא מכוונת,
מכוונת, קפדנית ולא קפדנית, בהתאמה. אם t הוא ריק, מכוון, לא
נוצר גרף קפדני.

subg(g : graph_t, s : מחרוזת): graph_t
יוצר תת-גרף בגרף g עם שם s. אם תת-גרף כבר קיים, הוא כן
חזר.

isSubg(g : graph_t, s : מחרוזת): graph_t
מחזירה את תת-גרף בגרף g עם שם s, אם הוא קיים, או NULL אחרת.

fstsubg(g : graph_t): graph_t
מחזירה את תת הגרף הראשון בגרף g, או NULL אם לא קיים.

nxtsubg(sg : graph_t): graph_t
מחזיר את תת-גרף הבא אחרי sg, או NULL.

isDirect(g : graph_t): int
מחזיר אמת אם ורק אם g מכוון.

הוא קפדני(g : graph_t): int
מחזיר אמת אם ורק אם g היא קפדנית.

n צמתים(g : graph_t): int
מחזירה את מספר הצמתים פנימה g.

nedges(g : graph_t): int
מחזירה את מספר הקצוות פנימה g.

צמתים
צומת(sg : graph_t, s : מחרוזת): node_t
יוצר צומת בגרף g של שם s. אם צומת כזה כבר קיים, הוא מוחזר.

תת-צומת(sg : graph_t, n : node_t): node_t
מכניס את הצומת n לתוך המשנה g. מחזיר את הצומת.

fstnode(g : graph_t): node_t
מחזירה את הצומת הראשון בגרף g, או NULL אם לא קיים.

nxtnode(n : node_t): node_t
מחזיר את הצומת הבא אחרי n בגרף השורש, או NULL.

nxtnode_sg(sg : graph_t, n : node_t): node_t
מחזיר את הצומת הבא אחרי n in sg, או NULL.

isNode(sg : graph_t, s : מחרוזת): node_t
מחפש צומת בגרף (תת). sg של שם s. אם קיים צומת כזה, הוא מוחזר.
אחרת, NULL מוחזר.

isSubnode(sg : graph_t, n : node_t): int
מחזיר אם צומת שאינו אפס n נמצא בגרף (תת). sg, או אפס אחרת.

indegreeOf(sg : graph_t, n : node_t): int
מחזירה את דרגת הצומת n בגרף (תת). sg.

outdegreeOf(sg : graph_t, n : node_t): int
מחזיר את דרגת החוץ של הצומת n בגרף (תת). sg.

תואר ב(sg : graph_t, n : node_t): int
מחזיר את מידת הצומת n בגרף (תת). sg.

קצוות
קצה(t : node_t, h : node_t, s : מחרוזת): edge_t
יוצר קצה עם צומת זנב t, צומת ראש h ושם s בגרף השורש. אם ה
הגרף אינו מכוון, ההבחנה בין צמתי הראש והזנב אינה חשובה.
אם קצה כזה כבר קיים, הוא מוחזר.

edge_sg(sg : graph_t, t : node_t, h : node_t, s : מחרוזת): edge_t
יוצר קצה עם צומת זנב t, צומת ראש h ושם s בגרף (תת). sg (וכל
גרפי אב). אם הגרף אינו מכוון, ההבחנה בין ראש וזנב
צמתים לא חשובים. אם קצה כזה כבר קיים, הוא מוחזר.

תת-קצה(g : graph_t, e : edge_t): edge_t
מכניס את הקצה e לתוך המשנה g. מחזיר את הקצה.

isEdge(t : node_t, h : node_t, s : מחרוזת): edge_t
מחפש קצה עם צומת זנב t, צומת ראש h ושם s. אם הגרף הוא
ללא כיוון, ההבחנה בין צמתי ראש וזנב אינה חשובה. אם כזה
הקצה קיים, הוא מוחזר. אחרת, NULL מוחזר.

isEdge_sg(sg : graph_t, t : node_t, h : node_t, s : מחרוזת): edge_t
מחפש קצה עם צומת זנב t, צומת ראש h ושם s בגרף (תת). sg. אם
הגרף אינו מכוון, ההבחנה בין צמתי הראש והזנב אינה חשובה.
אם קיים יתרון כזה, הוא מוחזר. אחרת, NULL מוחזר.

isSubedge(g : graph_t, e : edge_t): int
מחזיר אם קצה שאינו אפס e נמצא בגרף (תת). sg, או אפס אחרת.

fstout(n : node_t): edge_t
מחזירה את הקצה הראשון של הצומת n בגרף השורש.

fstout_sg(sg : graph_t, n : node_t): edge_t
מחזירה את הקצה הראשון של הצומת n בגרף (תת). sg.

nxtout(e : edge_t): edge_t
מחזיר את הקצה הבא אחרי e בגרף השורש.

nxtout_sg(sg : graph_t, e : edge_t): edge_t
מחזיר את הקצה הבא אחרי e בגרף sg.

fstin(n : node_t): edge_t
מחזיר את הקצה הראשון של הצומת n בגרף השורש.

fstin_sg(sg : graph_t, n : node_t): edge_t
מחזיר את הקצה הראשון של הצומת n בגרף sg.

nxtin(e : edge_t): edge_t
מחזיר את הקצה הבא אחרי e בגרף השורש.

nxtin_sg(sg : graph_t, e : edge_t): edge_t
מחזיר את הקצה הבא אחרי e בגרף sg.

fstedge(n : node_t): edge_t
מחזיר את הקצה הראשון של הצומת n בגרף השורש.

fstedge_sg(sg : graph_t, n : node_t): edge_t
מחזיר את הקצה הראשון של הצומת n בגרף sg.

nxtedge(e : edge_t, node_t): edge_t
מחזיר את הקצה הבא אחרי e בגרף השורש.

nxtedge_sg(sg : graph_t, e : edge_t, node_t): edge_t
מחזיר את הקצה הבא אחרי e בגרף sg.

מול(e : edge_t, node_t): node_t
מחזיר את הצומת על הקצה e לא שווה ל n. מחזירה NULL אם n אינו צומת של
e. זה יכול להיות שימושי בעת השימוש fstedge ו nxtedge למנות את השכנים של
n.

גרף I / O
לכתוב(g : graph_t): לבטל את
הדפסים g בפורמט נקודה על זרם הפלט.

לכתובG(g : graph_t, fname : מחרוזת): לבטל את
הדפסים g בפורמט נקודה לתוך הקובץ fname.

fwriteG(g : graph_t, fd : int): לבטל את
הדפסים g בפורמט נקודה על הזרם הפתוח המסומן במספר השלם fd.

readG(fname : מחרוזת): graph_t
מחזיר גרף שנקרא מהקובץ fname. הגרף צריך להיות בפורמט נקודות. אם לא
ניתן לקרוא גרף, NULL מוחזר.

freadG(fd : int): graph_t
מחזירה את הגרף הבא שנקרא מהזרם הפתוח fd. החזרות NULL בסוף הקובץ.

גרף קוֹבֶץ מְעוּרָב
להסיר(g : graph_t, x : obj_t): לבטל את
מוחק אובייקט x מתוך גרף g. אם g is NULL, הפונקציה משתמשת בגרף השורש של
x. אם x הוא גרף או תת-גרף, הוא סגור אלא אם כן x נעול.

isIn(g : graph_t, x : obj_t): int
מחזיר נכון אם x נמצא בתת-גרף g.

cloneG(g : graph_t, s : מחרוזת): graph_t
יוצר שיבוט של גרף g עם שם של s. אם s הוא "", לגרף שנוצר יש את
אותו שם כמו g.

לשבט(g : graph_t, x : obj_t): obj_t
יוצר שיבוט של אובייקט x בגרף g. בפרט, לאובייקט החדש יש את אותו הדבר
תכונות ומבנה שם/ערך כאובייקט המקורי. אם חפץ עם ה
אותו מפתח כמו x כבר קיים, התכונות שלו מכוסות על ידי אלה של x ו
האובייקט מוחזר. אם קצה משוכפל, שתי נקודות הקצה משובטות באופן מרומז.
אם גרף משובט, כל הצמתים, הקצוות ותתי-הגרפים משובטים באופן מרומז. אם x
הוא גרף, g יכול להיות NULL, במקרה זה האובייקט המשובט יהיה שורש חדש
גרָף. במקרה זה, השיחה שווה ערך ל cloneG(x"").

העתק(g : graph_t, x : obj_t): obj_t
יוצר עותק של אובייקט x בגרף g, כאשר לאובייקט החדש יש אותו שם/ערך
תכונות כאובייקט המקורי. אם חפץ עם אותו מפתח כמו x כְּבָר
קיים, התכונות שלו מכוסות על ידי אלה של x והחפץ מוחזר. הערה
שזהו עותק רדוד. אם x הוא גרף, אף אחד מהצמתים, הקצוות או המשנה שלו
מועתקים לגרף החדש. אם x הוא קצה, נקודות הקצה נוצרות אם
נחוצים, אבל הם אינם משובטים. אם x הוא גרף, g יכול להיות NULL, במקרה כזה
האובייקט המשובט יהיה גרף שורש חדש.

copyA(src : obj_t, tgt : obj_t): int
מעתיק את התכונות של האובייקט src להתנגד tgt, החלפת ערכי תכונה
tgt יכול להיות בהתחלה.

לְהַשְׁרוֹת(g : graph_t): לבטל את
משתרע g לסיומת תת-גרף המושרה על ידי הצומת בגרף השורש שלו.

hasAttr(src : obj_t, שם : מחרוזת): int
מחזיר אם אובייקט שאינו אפס src יש תכונה ששמה הוא שם. זה מחזיר 0
אחרת.

isAttr(g : graph_t, סוג : מחרוזת, שם : מחרוזת): int
מחזיר לא אפס אם תכונה שם הוגדר ב g עבור חפצים של
נתן סוג. עבור צמתים, קצוות וגרפים, סוג צריך להיות "N", "E" ו-"G",
בהתאמה. זה מחזיר 0 אחרת.

גיל(src : obj_t, שם : מחרוזת): מחרוזת
מחזירה את הערך של התכונה שם באובייקט src. זה שימושי לאותם מקרים
מתי שם מתנגש עם אחת ממילות המפתח כגון "ראש" או "שורש". אם ה
תכונה לא הוכרזה בגרף, הפונקציה תאתחל אותה עם
ערך ברירת מחדל של "". כדי להימנע מכך, יש להשתמש ב- hasAttr or isAttr פונקציה
כדי לבדוק שהתכונה קיימת.

סט(src : obj_t, שם : מחרוזת, ערך : מחרוזת): int
מגדיר את הערך של התכונה שם באובייקט src ל ערך. מחזיר 0 על הצלחה,
לא אפס על כישלון. לִרְאוֹת גיל מֵעַל.

getDflt(g : graph_t, סוג : מחרוזת, שם : מחרוזת): מחרוזת
מחזירה את ערך ברירת המחדל של התכונה שם בחפצים ב g של הנתון סוג. פורום
צמתים, קצוות וגרפים, סוג צריך להיות "N", "E" ו-"G", בהתאמה. אם ה
תכונה לא הוכרזה בגרף, הפונקציה תאתחל אותה עם
ערך ברירת מחדל של "". כדי להימנע מכך, יש להשתמש ב- isAttr פונקציה לבדוק
שהתכונה קיימת.

setDflt(g : graph_t, סוג : מחרוזת, שם : מחרוזת, ערך : מחרוזת): int
מגדיר את ערך ברירת המחדל של התכונה שם ל ערך בחפצים ב g של הנתון
סוג. עבור צמתים, קצוות וגרפים, סוג צריך להיות "N", "E" ו-"G", בהתאמה.
מחזיר 0 על הצלחה, לא אפס על כישלון. לִרְאוֹת getDflt מֵעַל.

fstAttr(g : graph_t, סוג : מחרוזת): מחרוזת
מחזירה את השם של התכונה הראשונה של אובייקטים ב g של הנתון סוג. פורום
צמתים, קצוות וגרפים, סוג צריך להיות "N", "E" ו-"G", בהתאמה. אם יש
אין תכונות, המחרוזת "" מוחזרת.

nxtAttr(g : graph_t, סוג : מחרוזת, שם : מחרוזת): מחרוזת
מחזירה את שם התכונה הבאה של אובייקטים ב g של הנתון סוג לאחר
תכונה שם. הטיעון שם חייב להיות שם של תכונה קיימת; זה
בדרך כלל יהיה ערך ההחזרה של קריאה קודמת אל fstAttr or nxtAttr. פורום
צמתים, קצוות וגרפים, סוג צריך להיות "N", "E" ו-"G", בהתאמה. אם יש
לא נותרו תכונות, המחרוזת "" מוחזרת.

compOf(g : graph_t, n : node_t): graph_t
מחזירה את הרכיב המחובר של הגרף g המכיל צומת n, כתת גרף של
g. תת-גרף מכיל רק את הצמתים. אפשר להשתמש לְהַשְׁרוֹת כדי להוסיף את הקצוות. ה
הפונקציה נכשלת וחוזרת NULL if n לא נמצא g. הקישוריות מבוססת על
גרף לא מכוון הבסיסי של g.

סוג של(obj : obj_t): מחרוזת
מחזירה אינדיקציה לסוג של obj. עבור צמתים, קצוות וגרפים, הוא חוזר
"N", "E" ו-"G", בהתאמה.

לנעול(g : graph_t, v : int): int
מיישמת נעילת גרפים על גרפי שורש. אם המספר השלם v הוא חיובי, הגרף הוא
מוגדר כך שיתקשרו בעתיד ל להסיר אין השפעה מיידית. אם v הוא אפס, ה
הגרף אינו נעול. אם הייתה קריאה למחוק את הגרף בזמן שהיה
נעול, הגרף סגור. אם v הוא שלילי, שום דבר לא נעשה. בכל המקרים, ה
ערך הנעילה הקודם מוחזר.

מחרוזות
ספרינטף(fmt : מחרוזת, ...): מחרוזת
מחזירה את המחרוזת הנובעת מעיצוב ערכי הביטויים
מתרחש לאחר fmt פי הדפס(3) פורמט fmt

gsub(str : מחרוזת, טפיחה : מחרוזת): מחרוזת

gsub(str : מחרוזת, טפיחה : מחרוזת, מחליף : מחרוזת): מחרוזת
החזרות str עם כל מחרוזות המשנה תואמות טפיחה נמחק או הוחלף על ידי מחליף,
בהתאמה.

להלן(str : מחרוזת, טפיחה : מחרוזת): מחרוזת

להלן(str : מחרוזת, טפיחה : מחרוזת, מחליף : מחרוזת): מחרוזת
החזרות str עם התאמת המחרוזת השמאלית ביותר טפיחה נמחק או הוחלף על ידי מחליף,
בהתאמה. ניתן להשתמש בתווים '^' ו-'$' בהתחלה ובסוף,
בהתאמה, של טפיחה כדי לעגן את התבנית להתחלה או לסוף str.

סובסטראט(str : מחרוזת, idx : int): מחרוזת

סובסטראט(str : מחרוזת, idx : int, לן : int): מחרוזת
מחזירה את המחרוזת המשנה של str מתחיל בעמדה idx לקצה המחרוזת או
של אורך לן, בהתאמה. אינדקס מתחיל ב-0. אם idx הוא שלילי או idx is
גדול מהאורך של str, מתרחשת שגיאה קטלנית. באופן דומה, בשני
מקרה, אם לן הוא שלילי או idx + לן גדול יותר מהאורך של str, קטלני
מתרחשת שגיאה.

strcmp(s1 : מחרוזת, s2 : מחרוזת): int
מספק את פונקציית C הסטנדרטית strcmp(3).

אורך(s : מחרוזת): int
מחזירה את אורך המחרוזת s.

מדד(s : מחרוזת, t : מחרוזת): int

rindex(s : מחרוזת, t : מחרוזת): int
מחזירה את האינדקס של התו במחרוזת s שבו העותק השמאלי ביותר (הימני ביותר).
של מחרוזת t ניתן למצוא, או -1 אם t אינו מחרוזת משנה של s.

להתאים(s : מחרוזת, p : מחרוזת): int
מחזירה את האינדקס של התו במחרוזת s שבו ההתאמה השמאלית ביותר של דפוס
p ניתן למצוא, או -1 אם אין מחרוזת משנה של s גפרורים p.

טופר(s : מחרוזת): מחרוזת
מחזירה גרסה של s עם התווים האלפביתיים המומרים לאותיות גדולות.

להנמיך(s : מחרוזת): מחרוזת
מחזירה גרסה של s עם התווים האלפביתיים המומרים לאותיות קטנות.

קנון(s : מחרוזת): מחרוזת
מחזירה גרסה של s מתאים לשמש כמזהה בקובץ נקודות.

html(g : graph_t, s : מחרוזת): מחרוזת
מחזירה גרסת ``קסם'' של s כמחרוזת HTML. בדרך כלל זה יהיה רגיל
צרף תווית דמוית HTML לאובייקט גרף. שים לב שהמחרוזת המוחזרת נמצאת בתוכו
g. בפרט, זה ישוחרר מתי g סגור, וכדי לפעול כמחרוזת HTML,
יש להשתמש בו עם אובייקט של g. בנוסף, שימו לב כי סוגר הזווית
ציטוטים לא צריכים להיות חלק s. אלה יתווספו אם g כתוב ב-DOT בטון
פורמט.

ishtml(s : מחרוזת): int
מחזיר לא אפס אם ורק אם s הוא מחרוזת HTML.

xOf(s : מחרוזת): מחרוזת
מחזיר את המחרוזת"x" אם s יש את הצורה "x,y", שבו שניהם x ו y הם מספריים.

yOf(s : מחרוזת): מחרוזת
מחזיר את המחרוזת"y" אם s יש את הצורה "x,y", שבו שניהם x ו y הם מספריים.

llOf(s : מחרוזת): מחרוזת
מחזיר את המחרוזת"llx,לילי" אם s יש את הצורה "llx,לילי,urx,Ury", איפה כל llx,
לילי, urx, ו Ury הם מספריים.

urOf(s)
urOf(s : מחרוזת): מחרוזת מחזיר את המחרוזת"urx,Ury" אם s יש את הטופס
"llx,לילי,urx,Ury", איפה כל llx, לילי, urx, ו Ury הם מספריים.

sscanf(s : מחרוזת, fmt : מחרוזת, ...): int
סורק את המחרוזת s, חילוץ ערכים לפי ה sscanf(3) פורמט fmt. ה
הערכים מאוחסנים בכתובות הבאות fmt, כתובות בעלות הטופס &v,
איפה v הוא משתנה מוצהר מהסוג הנכון. מחזירה את מספר הפריטים
נסרק בהצלחה.

לפצל(s : מחרוזת, arr : מערך, seps : מחרוזת): int

לפצל(s : מחרוזת, arr : מערך): int

אסימונים(s : מחרוזת, arr : מערך, seps : מחרוזת): int

אסימונים(s : מחרוזת, arr : מערך): int
אל האני לפצל הפונקציה שוברת את המחרוזת s לתוך שדות, בעוד ה אסימונים פונקציה
שובר את המיתר לאסימונים. שדה מורכב מכל התווים שאינם מפרידים
בין שני תווים מפרידים או ההתחלה או הסוף של המחרוזת. לפיכך, א
השדה עשוי להיות המחרוזת הריקה. אסימון הוא מחרוזת משנה מקסימלית, לא ריקה
המכיל תו מפריד. תווי ההפרדה הם אלה שניתנו ב-
seps טַעֲנָה. אם seps לא מסופק, ערך ברירת המחדל הוא " \t\n". ה
פונקציות מחזירות את מספר השדות או האסימונים.

השדות והאסימונים מאוחסנים במערך הארגומנטים. המערך חייב להיות מחרוזת-
מוערך, ואם צוין סוג אינדקס, הוא חייב להיות int. הערכים מתווספים לאינדקס
לפי מספרים שלמים עוקבים, החל מ-0. כל הערכים שכבר מאוחסנים במערך יהיו
להיות מוחלף, או עדיין להיות נוכח לאחר החזרת הפונקציה.

I / O
הדפסה(...): לבטל את
הדפס( ביטוי, ... ) מדפיס ייצוג מחרוזת של כל ארגומנט בתורו
stdout, ואחריו שורה חדשה.

הדפס(fmt : מחרוזת, ...): int

הדפס(fd : int, fmt : מחרוזת, ...): int
מדפיס את המחרוזת הנובעת מעיצוב הערכים של הביטויים הבאים
fmt פי הדפס(3) פורמט fmt. מחזיר 0 על הצלחה. כברירת מחדל, זה
מדפיס על stdout. אם המספר השלם האופציונלי fd נתון, הפלט כתוב על
זרם פתוח המשויך ל fd.

scanf(fmt : מחרוזת, ...): int

scanf(fd : int, fmt : מחרוזת, ...): int
סורק ערכים מזרם קלט לפי ה scanf(3) פורמט fmt. ה
הערכים מאוחסנים בכתובות הבאות fmt, כתובות בעלות הטופס &v,
איפה v הוא משתנה מוצהר מהסוג הנכון. כברירת מחדל, הוא קורא מ
סטדין. אם המספר השלם האופציונלי fd נתון, הקלט נקרא מהזרם הפתוח
הקשורים fd. מחזירה את מספר הפריטים שנסרקו בהצלחה.

פתוחF(s : מחרוזת, t : מחרוזת): int
פותח את הקובץ s כזרם קלט/פלט. ארגומנט המחרוזת t מציין איך הקובץ
נפתח. הארגומנטים זהים לאלו של הפונקציה C פופ(3). זה מחזיר an
מספר שלם המציין את הזרם, או -1 בשגיאה.

כרגיל, זרמים 0, 1 ו-2 כבר פתוחים כ סטדין, stdout, ו סטדרר,
בהתאמה. מאז gvpr רשאי להשתמש סטדין כדי לקרוא את גרפי הקלט, המשתמש צריך
הימנע משימוש בזרם זה.

closeF(fd : int): int
סוגר את הזרם הפתוח המסומן במספר השלם fd. זרמים 0, 1 ו-2 לא יכולים להיות
סָגוּר. מחזיר 0 על הצלחה.

readL(fd : int): מחרוזת
מחזירה את השורה הבאה שנקראה מזרם הקלט fd. זה מחזיר את המחרוזת הריקה ""
בסוף הקובץ. שים לב שהתו החדש נשאר במחרוזת המוחזרת.

מתמטיקה
exp(d : לְהַכפִּיל): לְהַכפִּיל
מחזיר את e ל dהכוח.

היכנס(d : לְהַכפִּיל): לְהַכפִּיל
מחזיר את היומן הטבעי של d.

מ"ר(d : לְהַכפִּיל): לְהַכפִּיל
מחזירה את השורש הריבועי של הכפול d.

שבויים(d : לְהַכפִּיל, x : לְהַכפִּיל): לְהַכפִּיל
החזרות d הועלה ל xהכוח.

cos(d : לְהַכפִּיל): לְהַכפִּיל
מחזיר את הקוסינוס של d.

חטא(d : לְהַכפִּיל): לְהַכפִּיל
מחזירה את הסינוס של d.

atan2(y : לְהַכפִּיל, x : לְהַכפִּיל): לְהַכפִּיל
מחזיר את הארקטנג'ן של y / x בטווח -pi עד pi.

MIN(y : לְהַכפִּיל, x : לְהַכפִּיל): לְהַכפִּיל
מחזיר את המינימום של y ו x.

מקס(y : לְהַכפִּיל, x : לְהַכפִּיל): לְהַכפִּיל
מחזיר את המקסימום של y ו x.

אסוציאטיבי מערכים
# arr : int
מחזירה את מספר האלמנטים במערך arr.

idx in arr : int
מחזירה 1 אם הוגדר ערך לאינדקס idx במערך arr. זה מחזיר 0
אחרת.

ביטול ההגדרה(v : מערך, idx): int
מסיר את הפריט שנוסף על ידי idx. זה מחזיר 1 אם הפריט היה קיים, 0 אחרת.

ביטול ההגדרה(v : מערך): לבטל את
מאתחל מחדש את המערך.

שונות
יציאה(v : int): לבטל את
גורמים gvpr כדי לצאת עם קוד היציאה v.

מערכת(cmd : מחרוזת): int
מספק את פונקציית C הסטנדרטית מערכת(3). זה מבצע cmd במעטפת של המשתמש
סביבה, ומחזיר את מצב היציאה של המעטפת.

שורה(): לְהַכפִּיל
מחזירה כפול פסאודו אקראי בין 0 ל-1.

זִמָּה(): int

זִמָּה(v : int): int
מגדיר זרע עבור מחולל המספרים האקראיים. הארגומנט האופציונלי נותן את הזרע;
אם הוא מושמט, נעשה שימוש בשעה הנוכחית. ערך הזרע הקודם מוחזר.
זִמָּה יש להתקשר לפני כל שיחות אל שורה.

colorx(צֶבַע : מחרוזת, fmt : מחרוזת): מחרוזת
מתרגם צבע מפורמט אחד לאחר. ה צֶבַע הטיעון צריך להיות צבע
באחד מיצוגי המחרוזת המוכרים. ה fmt הערך צריך להיות אחד מהם
"RGB", "RGBA", "HSV" או "HSVA". מחרוזת ריקה מוחזרת בשגיאה.

BUILT-IN וריאציות

gvpr מספק משתנים מיוחדים ומובנים, שהערכים שלהם נקבעים אוטומטית על ידי
gvpr בהתאם להקשר. למעט כפי שצוין, המשתמש אינו יכול לשנות את הערכים שלו.

$ : obj_t
מציין את האובייקט הנוכחי (צומת, קצה, גרף) בהתאם להקשר. זה לא
אפשר להשיג ב התחל or הסוף סעיפים.

$F : מחרוזת
הוא השם של קובץ הקלט הנוכחי.

$G : graph_t
מציין את הגרף הנוכחי בעיבוד. זה לא זמין ב התחל or הסוף
סעיפים.

$NG : graph_t
מציין את הגרף הבא לעיבוד. אם $NG הוא NULL, הגרף הנוכחי $G האם ה
גרף אחרון. שימו לב שאם הקלט מגיע מ-stdin, הגרף האחרון לא יכול להיות
נקבע עד לסגירת צינור הכניסה. זה לא זמין ב התחל or הסוף
סעיפים, או אם ה -n נעשה שימוש בדגל.

$O : graph_t
מציין את גרף הפלט. לפני חציית הגרף, הוא מאותחל למטרה
גרָף. לאחר מעבר וכל END_G פעולות, אם זה מתייחס לגרף לא ריק,
הגרף הזה מודפס על זרם הפלט. זה תקף רק ב N, E ו END_G
סעיפים. גרף הפלט עשוי להיות מוגדר על ידי המשתמש.

$T : graph_t
מציין את גרף היעד הנוכחי. זה תת-גרף של $G והוא זמין רק ב
N, E ו END_G סעיפים.

$tgtname : מחרוזת
מציין את שם גרף היעד. כברירת מחדל, הוא מוגדר ל "gvpr_result". אם
בשימוש מספר פעמים במהלך הביצוע של gvpr, השם יצורף עם an
מספר שלם. משתנה זה עשוי להיות מוגדר על ידי המשתמש.

$tvroot : node_t
מציין את צומת ההתחלה עבור (מכוון או לא מכוון) עומק-ראשון או רוחב-
מעבר ראשון של הגרף (ראה. $tvtype לְהַלָן). ערך ברירת המחדל הוא NULL ל
כל גרף קלט. לאחר המעבר בשורש הנתון, אם הערך של $tvroot
השתנה, מעבר חדש יתחיל בערך החדש של $tvroot. כמו כן, הגדר
$tvnext לְהַלָן.

$tvnext : node_t
מציין את צומת ההתחלה הבא עבור עומק ראשון (מכוון או בלתי מכוון) או
מעבר ברוחב ראשון של הגרף (ראה. $tvtype לְהַלָן). אם חצייה מסתיימת
ו $tvroot לא אופס אבל ה $tvnext הוגדר אך לא נעשה בו שימוש, זה
הצומת ישמש כבחירה הבאה עבור $tvroot. ערך ברירת המחדל הוא NULL ל
כל גרף קלט.

$tvedge : edge_t
עבור מעברי BFS ו- DFS, זה מוגדר לקצה המשמש כדי להגיע לזרם
צומת או קצה. בתחילת חצייה, או עבור סוגי חצייה אחרים, ה
הערך הוא NULL.

$tvtype : tvtype_t
מציין כיצד gvpr חוצה גרף. זה יכול לקחת רק אחד מהערכים הקבועים
עם הקודמת "TV_" המתוארת להלן. טלוויזיה_שטוח הוא ברירת המחדל.

בספריית הגרפים הבסיסית גרף(3), קצוות בגרפים לא מכוונים מקבלים an
כיוון שרירותי. זה משמש למעברים, כגון TV_fwd, דורש
קצוות מכוונים.

ARGC : int
מציין את מספר הארגומנטים שצוין על ידי -a טוען ארגומנט שורת הפקודה.

ARGV : מחרוזת מערך
מציין את מערך הארגומנטים שצוין על ידי -a טוען ארגומנט שורת הפקודה. ה
iהטיעון ניתן על ידי ARGV[i].

BUILT-IN קבועים

ישנם מספר קבועים סמליים המוגדרים על ידי gvpr.

NULL : obj_t
הפניה לאובייקט אפס, שווה ערך ל-0.

טלוויזיה_שטוח : tvtype_t
מעבר פשוט ושטוח, עם אובייקטים גרפים שבהם מבקרים בסדר שרירותי לכאורה.

TV_ne : tvtype_t
מעבר אשר מבקר תחילה בכל הצמתים, ולאחר מכן בכל הקצוות.

TV_he : tvtype_t
מעבר אשר מבקר תחילה בכל הקצוות, ולאחר מכן בכל הצמתים.

TV_dfs : tvtype_t
TV_postdfs : tvtype_t
TV_prepostdfs : tvtype_t
מעבר של הגרף באמצעות חיפוש עומק ראשון על הבלתי מכוון הבסיסי
גרָף. לעשות את המעבר, gvpr יבדוק את הערך של $tvroot. אם יש לזה את
אותו ערך שהיה לו בעבר (בהתחלה, הערך הקודם מאותחל
ל NULL.) gvpr פשוט יחפש איזה צומת שלא ביקר ויעבור את המחובר שלו
רְכִיב. מצד שני, אם $tvroot השתנה, הרכיב המחובר שלו ישתנה
לסייר, בהנחה שלא ביקר בעבר או, אם $tvroot is NULL, ה
המעבר ייפסק. שימו לב שהשימוש TV_dfs ו $tvroot, אפשר ליצור
לולאה אינסופית.

כברירת מחדל, המעבר מתבצע בהזמנה מראש. כלומר, צומת מבקרים לפני כן
את כל הקצוות הלא מבקרים שלו. ל TV_postdfs, כל הקצוות שלא ביקרו בצומת הם
ביקר לפני הצומת. ל TV_prepostdfs, צומת מבקרים פעמיים, לפני ו
אחרי כל הקצוות הלא מבקרים שלו.

TV_fwd : tvtype_t
TV_postfwd : tvtype_t
TV_prepostfwd : tvtype_t
מעבר של הגרף באמצעות חיפוש עומק ראשון בגרף הבא בלבד
קשתות קדימה. בחירת השורשים למעבר זהה לזו שתוארה עבור
TV_dfs מֵעַל. סדר הביקור השונה שצוין על ידי TV_fwd, TV_postfwd
ו TV_prepostfwd זהים לאלה שצוינו במעברים האנלוגיים
TV_dfs, TV_postdfs ו TV_prepostdfs.

TV_rev : tvtype_t
TV_postrev : tvtype_t
TV_prepostrev : tvtype_t
מעבר של הגרף באמצעות חיפוש עומק ראשון בגרף הבא בלבד
קשתות הפוכות. בחירת השורשים למעבר זהה לזו שתוארה עבור
TV_dfs מֵעַל. סדר הביקור השונה שצוין על ידי TV_rev, TV_postrev
ו TV_prepostrev זהים לאלה שצוינו במעברים האנלוגיים
TV_dfs, TV_postdfs ו TV_prepostdfs.

TV_bfs : tvtype_t
מעבר של הגרף באמצעות חיפוש רוחב ראשון בגרף תוך התעלמות מקצה
כיוונים. ראה את הפריט על TV_dfs לעיל לתפקיד של $tvroot.

דוגמאות

gvpr -i 'N[color=="כחול"]' file.gv

צור את תת-גרף הצמתים של כל הצמתים עם צבע כחול.

gvpr -c 'N[color=="כחול"]{צבע = "אָדוֹם"}' file.gv

הפוך את כל הצמתים הכחולים לאדומים.

התחל { int n, e; int tot_n = 0; int לָשֵׂאת = 0; }
BEG_G {
n = nNodes($G);
e = nEdges($G);
הדפס ("%d צמתים %d קצוות %s\n", n, e, $G.name);
tot_n += n;
לָשֵׂאת += e;
}
הסוף { הדפס ("%d צמתים %d קצוות סך הכל\n", טוט_n, לָשֵׂאת) }

גרסה של התוכנית gc.

gvpr -c ""

שווה ערך ל לא.

BEG_G { graph_t g = גרף ("לְמַזֵג", "S"); }
E {
node_t h = clone(g,$.head);
node_t t = clone(g,$.tail);
edge_t e = edge(t,h,"");
e.weight = e.weight + 1;
}
END_G { $O = g; }

מייצר גרסה קפדנית של גרף הקלט, שבו תכונת המשקל של קצה
מציין כמה קצוות מגרף הקלט מייצג הקצה.

התחל {node_t n; int תואר[]}
E{deg[head]++; deg[זנב]++; }
END_G {
ל (דרגה [n]) {
הדפס ("דרגה[%s] = %d\n", n.name, deg[n]);
}
}

מחשב את המעלות של צמתים עם קצוות.

התחל {
int i, לְשַׁנֵן;
int ראה [מחרוזת];
לבטל את prInd (int cnt) {
ל (i = 0; i < cnt; i++) הדפס (" ");
}
}
BEG_G {

$tvtype = TV_prepostfwd;
$tvroot = node($,ARGV[0]);
}
N {
if (ראה [$.name]) לְשַׁנֵן--;
אחר {
prInd(indent);
הדפסה ($.name);
ראה [$.name] = 1;
כניסה++;
}
}

מדפיס את מעבר העומק-ראשון של הגרף, החל מהצומת ששמו
ARGV[0], כרשימה מפוצלת.

הסביבה

GVPRPATH
רשימה מופרדת בנקודתיים של ספריות שיש לחפש כדי למצוא את הקובץ שצוין על ידי
האפשרות -f. gvpr יש רשימת ברירת מחדל מובנית. אם GVPRPATH אינו מוגדר,
נעשה שימוש ברשימת ברירת המחדל. אם GVPRPATH מתחיל בנקודתיים, הרשימה נוצרת על ידי
מצרף GVPRPATH לרשימת ברירת המחדל. אם GVPRPATH מסתיים בנקודתיים, הרשימה היא
נוצר על ידי הוספת רשימת ברירת המחדל ל GVPRPATH. אחרת, GVPRPATH משמש
הרשימה.

במערכות Windows, החלף את ``נקודתיים'' ב``נקודה-פסיק'' בפסקה הקודמת.

השתמש ב-gvpr באינטרנט באמצעות שירותי onworks.net