זהו פרלינטרן הפקודה שניתן להפעיל בספק האירוח החינמי של OnWorks באמצעות אחת מתחנות העבודה המקוונות המרובות שלנו, כגון Ubuntu Online, Fedora Online, אמולטור מקוון של Windows או אמולטור מקוון של MAC OS
תָכְנִית:
שֵׁם
perlintern - תיעוד שנוצר אוטומטית של פונקציות Perl פנימיות בלבד
תיאור
קובץ זה הוא התיעוד המופק באופן אוטומטי של פונקציות במתורגמן של Perl
מתועדים באמצעות פורמט התיעוד הפנימי של Perl אך אינם מסומנים כחלק מה-
Perl API. במילים אחרות, הֵם יש לו לֹא ל להשתמש in סיומות!
זמן קומפילציה היקף ווים
BhkENTRY
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
החזר ערך ממבנה BHK. אשר הוא אסימון קדם-מעבד המציין
איזה כניסה להחזיר. אם הדגל המתאים לא מוגדר, זה יחזיר NULL.
סוג ערך ההחזר תלוי באיזו ערך אתה מבקש.
void * BhkENTRY(BHK *hk, which)
BhkFLAGS
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
החזר את דגלי ה-BHK.
U32 BhkFLAGS(BHK *hk)
CALL_BLOCK_HOOKS
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
התקשר לכל ה-blokkים הרשומים לסוג אשר. אשר הוא עיבוד מקדים
אֲסִימוֹן; הסוג של גדול מ תלוי אשר.
void CALL_BLOCK_HOOKS(אשר, arg)
מותאם אישית מפעילים
core_prototype
פונקציה זו מקצה את אב הטיפוס של פונקציית הליבה בעלת השם ל-"sv", או ל-a
תמותה חדשה SV אם "sv" הוא NULL. זה מחזיר את ה-"sv" שהשתנה, או NULL אם הליבה
לפונקציה אין אב טיפוס. "קוד" הוא קוד המוחזר על ידי "מילת מפתח()". זה חייב
לא יהיה שווה ל-0.
SV * core_prototype(SV *sv, const char *name,
const int קוד,
int * const opnum)
CV מניפולציה פונקציות
docatch בדוק את המקרים 0 או 3 של cur_env.je_ret, בשימוש רק בהקשר eval.
0 משמש כהמשך בתוך eval,
3 משמש עבור קובייה שנתפסה על ידי eval פנימי - המשך לולאה פנימית
ראה cop.h: je_mustcatch, כאשר הוא מוגדר בכל רמת ריצה ל-TRUE, פירושו ש-eval ops חייב
להקים jmpenv מקומי כדי לטפל במלכודות חריגות.
OP* docatch(OP *o)
CV הפניה סופרת ו CvOUTSIDE
CvWEAKOUTSIDE
לכל קורות חיים יש מצביע, "CvOUTSIDE()", אל קורות החיים המקיפים את המילים שלו (אם יש).
מכיוון שמצביעים על אבות טיפוס משנה אנונימיים מאוחסנים בחריצי משטח "&", זה א
אפשר לקבל התייחסות מעגלית, כשההורה מצביע על הילד ו
להיפך. כדי למנוע את דליפת הזיכרון שלאחר מכן, איננו מגדילים את ההפניה
ספירת קורות החיים שעליהם הצביע "CvOUTSIDE" ב- אחד ספציפי למשל כי
להורה יש חריץ משטח "&" המפנה אלינו. במקרה זה, אנו מגדירים את
דגל "CvWEAKOUTSIDE" בילד. זה מאפשר לנו לקבוע לפי מה
בנסיבות שעלינו להפחית את הספירה מחדש של ההורה בעת שחרור ה-
יֶלֶד.
ישנה סיבוך נוסף עם שמות משנה אנונימיים שאינם סגורים (כלומר אלה ש
אין להתייחס למילונים כלשהם מחוץ לאותה משנה). במקרה זה, האנונימי
אב-טיפוס משותף במקום שיבוט. יש לכך תוצאה שה-
ההורה עשוי להשתחרר כל עוד יש ילדים פעילים, למשל
התחל { $a = sub { eval '$x' } }
במקרה זה, ה-BEGIN משוחרר מיד לאחר הביצוע מכיוון שאין
הפניות אקטיביות אליו: לאב-טיפוס המשנה של אנון מוגדר "CvWEAKOUTSIDE" מכיוון שהוא
לא סגירה, ו-$a מצביע על אותו קורות חיים, כך שזה לא תורם ל-BEGIN's
גם לספור מחדש. כאשר $a מבוצע, ה-"eval '$x'" גורם לשרשרת של
יש לעקוב אחר "CvOUTSIDE", ולגשת ל-BEGIN הפנוי.
כדי להימנע מכך, בכל פעם שמתפנה קורות חיים והפנקס המשויך לו, כל "&" נכנס
הפנקס יוסרו במפורש מהפנקס, ואם הספירה החוזרת של ה-pointed-to
anon sub עדיין חיובי, אז ה-"CvOUTSIDE" של הילד הזה מוגדר להצביע על שלו
סָבָּא אוֹ סָבתָא. זה יתרחש רק במקרה הספציפי היחיד של אי סגירה
אב טיפוס של anon בעל הפניה פעילה אחת או יותר (כגון $a לעיל).
דבר נוסף שיש לקחת בחשבון הוא שקורות חיים עשויים להיות פשוט לא מוגדרים ולא
משוחרר, למשל "undef &foo". במקרה זה, הספירה החוזרת שלו אולי לא הגיעה לאפס, אבל
אנחנו עדיין מוחקים את הפנקס שלו ואת ה-"CvROOT" שלו וכו'. מכיוון שילדים שונים עשויים עדיין
אם "CvOUTSIDE" שלהם מצביע על קורות חיים לא מוגדרים זה, אנחנו שומרים על "CvOUTSIDE" משלו
לעת עתה, כך ששרשרת ההיקפים המילוניים אינה מנותקת. לדוגמה,
יש להדפיס את הכתובות הבאות 123:
שלי $x = 123;
sub tmp { sub { eval '$x' } }
שלי $a = tmp();
undef &tmp;
הדפס $a->();
bool CvWEAKOUTSIDE(CV *cv)
הטבעה פונקציות
cv_dump dump את התוכן של קורות חיים
void cv_dump(CV *cv, const char *title)
cv_forget_slab
כאשר קורות חיים יש ספירת התייחסות על הלוח שלו (CvSLABBED), הוא אחראי על
לוודא שהוא משוחרר. (לכן, לא צריך לסמוך על שני קורות חיים
אותו לוח.) קורות החיים צריכים רק להתייחס ללוח במהלך ההידור. פַּעַם
הוא מורכב ומצורף CvROOT, הוא סיים את עבודתו, כך שהוא יכול לשכוח את
לוּחַ.
void cv_forget_slab(CV *cv)
do_dump_pad
זרוק את התוכן של רשימת padlist
void do_dump_pad(רמת I32, PerlIO *קובץ,
PADLIST *padlist, int full)
padlist_dup
משכפל כרית.
PADLIST * padlist_dup(PADLIST *srcpad,
CLONE_PARAMS *param)
padnamelist_dup
משכפל רשימת שמות רפידה.
PADNAMELIST * padnamelist_dup(PADNAMELIST *srcpad,
CLONE_PARAMS *param)
padname_dup
משכפל שם משטח.
PADNAME * padname_dup(PADNAME *src, CLONE_PARAMS *param)
pad_alloc_name
מקצה מקום בפנקס הקומפילציה כרגע (דרך "pad_alloc" ב-perlapi) ו
לאחר מכן מאחסן שם עבור אותו ערך. שם מאומץ והופך לערך השם; זה
חייב כבר להכיל את מחרוזת השם. מאמצים ו ourstash ו
יתווסף לדגל "padadd_STATE". שם. אף אחד מהעיבודים האחרים של
"pad_add_name_pvn" ב-perlapi נעשה. מחזירה את ההיסט של הפנקס שהוקצה
חָרִיץ.
PADOFFSET pad_alloc_name(PADNAME *שם, דגלים של U32,
HV *typestash, HV *ourstash)
pad_block_start
עדכן את משתני מצב הקומפילציה בכניסה לבלוק חדש.
void pad_block_start(int full)
pad_check_dup
בדוק אם יש הצהרות כפולות: דווח על כל אחד מ:
* שלי בהיקף הנוכחי עם אותו שם;
* שלנו (בכל מקום בפנקס) עם אותו שם ו-
אותו מחסן כמו C
"is_our" מציין שהשם שיש לבדוק הוא הצהרת 'שלנו'.
void pad_check_dup(PADNAME *שם, דגלים של U32,
const HV *ourstash)
pad_findlex
מצא מילון עם שם בכל מקום בשרשרת של כריות מקוננות. הוסף ערכים מזויפים ב-
רפידות פנימיות אם זה נמצא בכרית חיצונית.
מחזירה את ההיסט בפד התחתון של lex או lex מזויף. cv הוא קורות החיים ב
אשר להתחיל את החיפוש, ו-seq הוא ה-cop_seq הנוכחי שיש להתאים נגדו. אם
אזהרה נכונה, הדפס אזהרות מתאימות. ערכי ההחזרה של out_* vars, וכן הלאה
הם מצביעים למקום שבו יש לאחסן את הערכים המוחזרים. out_capture, אם לא-
null, מבקשת ללכוד את המופע הפנימי ביותר של המילונית; out_name הוא
הגדר את שם הפנקס התואם הפנימי ביותר או שם הפנקס המזויף; out_flags מחזיר את ה-
דגלים המשויכים בדרך כלל לשדה PARENT_FAKELEX_FLAGS של שם משטח מזויף.
שים לב כי pad_findlex() הוא רקורסיבי; זה חוזר במעלה שרשרת קורות החיים, ואז מגיע
חזרה למטה, תוך הוספת ערכים מזויפים תוך כדי. זה חייב להיות ככה כי מזויף
שמות באבות טיפוס של אנון צריכים לאחסן ב-xlow את האינדקס בפנקס האב.
PADOFFSET pad_findlex(const char *namepv,
STRLEN namelen, U32 דגלים,
const CV* cv, U32 seq, int warn,
SV** out_capture,
PADNAME** out_name,
int *out_flags)
pad_fixup_inner_anons
עבור כל קורות חיים אנונים בפנקס, שנה את ה-CvOUTSIDE של קורות החיים הזה מ-old_cv ל-new_cv אם
נחוץ. נחוץ כאשר יש להעביר קורות חיים חדשים שהורכבו לקורות חיים קיים
מבנה.
void pad_fixup_inner_anons(PADLIST *padlist,
קורות חיים *קורות חיים ישן, קורות חיים *חדש_קורות חיים)
pad_free
שחרר את ה-SV ב-offset po בפד הנוכחי.
void pad_free(PADOFFSET po)
pad_leavemy
ניקוי בסוף ההיקף במהלך הקומפילציה: הגדר את המספר המרבי המרבי עבור מילונים ב
זה היקף ולהזהיר מכל מילונים שמעולם לא הוצגו.
void pad_leavemy()
pad_push
דחוף מסגרת משטח חדשה לרשימת המשטחים, אלא אם כבר יש משטח בעומק הזה,
במקרה זה אל תטרחו ליצור אחד חדש. לאחר מכן תן לפנקס החדש _ in
משבצת אפס.
void pad_push(PADLIST *padlist, int depth)
pad_reset
סמן את כל הזמניים הנוכחיים לשימוש חוזר
void pad_reset()
pad_swipe
נטוש את ה-tmp בפד הנוכחי ב-offset po והחלף בחדש.
void pad_swipe(PADOFFSET po, bool readjust)
GV פונקציות
gv_try_downgrade
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
אם ניתן לבטא את ה-Typglob "gv" בצורה תמציתית יותר, בכך שיש משהו אחר
מאשר GV אמיתי במקומו במחסן, החליפו אותו בצורה האופטימלית.
הדרישות הבסיסיות לכך הן ש"gv" הוא טיפוגלוב אמיתי, הוא מספיק
רגיל, והוא מוזכר רק מהחבילה שלו. פונקציה זו נועדה להיות
משמש כאשר GV נבדק בחלקו כדי לראות מה היה שם, גורם
משדרג, אבל על סמך מה שנמצא מתברר שה-GV האמיתי לא
נדרש אחרי הכל.
אם "gv" הוא טיפוס ריק לחלוטין, הוא נמחק מהמאגר.
אם "gv" הוא סוג גלוב המכיל רק תת קבוע מספיק-רגיל, ה-
typeglob מוחלף במציין מיקום עם התייחסות סקלרית בצורה קומפקטית יותר
מייצג את אותו הדבר.
void gv_try_downgrade(GV* gv)
בליל מניפולציה פונקציות
hv_ename_add
מוסיף שם לרשימה הפנימית של שמות אפקטיביים של מחסן. ראה "hv_ename_delete".
זה נקרא כאשר מחסן מוקצה למיקום חדש בטבלת הסמלים.
void hv_ename_add(HV *hv, const char *name, U32 len,
דגלים של U32)
hv_ename_delete
מסיר שם מהרשימה הפנימית של מחסן של שמות יעילים. אם זה ה
שם שהוחזר על ידי "HvENAME", ואז שם אחר ברשימה יתפוס את מקומו
("HvENAME" ישתמש בו).
זה נקרא כאשר מחסנית נמחקת מטבלת הסמלים.
void hv_ename_delete(HV *hv, const char *name,
U32 len, U32 דגלים)
refcounted_he_chain_2hv
יוצר ומחזיר "HV *" המייצג את התוכן של "refcounted_he"
שַׁרשֶׁרֶת. דגלים אינו בשימוש כרגע וחייב להיות אפס.
HV * refcounted_he_chain_2hv(
const struct refcounted_he *c, דגלים של U32
)
recounted_he_fetch_pv
כמו "refcounted_he_fetch_pvn", אבל לוקח מחרוזת עם סיומת אפס במקום
זוג מיתר/אורך.
SV * refcounted_he_fetch_pv(
const struct refcounted_he *שרשרת,
const char *key, U32 hash, U32 flags
)
recounted_he_fetch_pvn
חפש לאורך שרשרת "refcounted_he" עבור ערך עם המפתח שצוין על ידי keypv
ו keylen. אם דגלים יש את הסיביות "REFCOUNTED_HE_KEY_UTF8" מוגדר, אוקטטים המפתח הם
מתפרשים כ-UTF-8, אחרת הם מתפרשים כלטינית-1. שירים הוא
Hash מחושב מראש של מחרוזת המפתח, או אפס אם הוא לא חושב מראש.
מחזירה סקלאר תמותה המייצג את הערך המשויך למפתח, או
&PL_sv_placeholder אם אין ערך המשויך למפתח.
SV * refcounted_he_fetch_pvn(
const struct refcounted_he *שרשרת,
const char *keypv, STRLEN keylen, U32 hash,
דגלים של U32
)
recounted_he_fetch_pvs
כמו "refcounted_he_fetch_pvn", אבל לוקח מחרוזת מילולית במקום א
זוג מחרוזת/אורך, וללא Hash מחושב מראש.
SV * refcounted_he_fetch_pvs(
const struct refcounted_he *שרשרת,
const char *מפתח, דגלים של U32
)
refcounted_he_fetch_sv
כמו "refcounted_he_fetch_pvn", אבל לוקח סקלאר של Perl במקום מחרוזת/אורך
זוג.
SV * refcounted_he_fetch_sv(
const struct refcounted_he *שרשרת, SV *מפתח,
Hash U32, דגלים של U32
)
סופר מחדש_הוא_חופשי
מקטין את ספירת ההפניות של "refcounted_he" באחד. אם ההתייחסות
הספירה מגיעה לאפס זיכרון המבנה משתחרר, מה שגורם (באופן רקורסיבי) ל- a
הפחתת ספירת ההתייחסות של ההורה "refcounted_he" שלו. בטוח לעבור א
מצביע null לפונקציה זו: לא מתרחשת פעולה במקרה זה.
void refcounted_he_free(struct refcounted_he *he)
recounted_he_inc
הגדל את ספירת ההפניות של "refcounted_he". המצביע ל-
גם "refcounted_he" מוחזר. זה בטוח להעביר מצביע ריק לכך
פונקציה: לא מתרחשת פעולה ומוחזר מצביע null.
struct refcounted_he * refcounted_he_inc(
struct refcounted_he *הוא
)
recounted_he_new_pv
כמו "refcounted_he_new_pvn", אבל לוקח מחרוזת עם סיומת nul במקום a
זוג מיתר/אורך.
struct refcounted_he * refcounted_he_new_pv(
struct refcounted_he *הורה,
const char *key, U32 hash,
SV *ערך, דגלי U32
)
recounted_he_new_pvn
יוצר "refcounted_he" חדש. זה מורכב מצמד מפתח/ערך יחיד ו-a
התייחסות לשרשרת "refcounted_he" קיימת (שעשויה להיות ריקה), וכך
יוצר שרשרת ארוכה יותר. בעת שימוש בשרשרת הארוכה יותר, צמד המפתח/ערך החדש לוקח
עדיפות על פני כל כניסה עבור אותו מפתח בהמשך השרשרת.
המפתח החדש מצוין על ידי keypv ו keylen. אם דגלים יש
"REFCOUNTED_HE_KEY_UTF8" מוגדר, אוקטטים המפתח מתפרשים כ-UTF-8,
אחרת הם מתפרשים כלטינית-1. שירים הוא hash מחושב מראש של המפתח
מחרוזת, או אפס אם זה לא חושב מראש.
ערך הוא הערך הסקלרי שיש לאחסן עבור מפתח זה. ערך מועתק על ידי זה
פונקציה, אשר לפיכך אינה לוקחת בעלות על כל התייחסות אליה, ומאוחר יותר
שינויים בסקלרים לא יבואו לידי ביטוי בערך הנראה ב-
"סופר_הוא מחדש". סוגים מורכבים של סקלרים לא יאוחסנו עם רפרנציאל
יושרה, אך ייכפה על חוטים. ערך יכול להיות ריק או
&PL_sv_placeholder כדי לציין שאין לשייך ערך למפתח;
זה, כמו כל ערך שאינו ריק, מקבל עדיפות על קיומו של ערך
עבור המפתח בהמשך השרשרת.
הורה מצביע על שאר שרשרת "refcounted_he" שתצורף לחדש
"סופר_הוא מחדש". פונקציה זו לוקחת בעלות על הפניה אחת הורה, ו
מחזירה הפניה אחת ל-"refcounted_he" החדש.
struct refcounted_he * refcounted_he_new_pvn(
struct refcounted_he *הורה,
const char *keypv,
STRLEN keylen, U32 hash,
SV *ערך, דגלי U32
)
recounted_he_new_pvs
כמו "refcounted_he_new_pvn", אבל לוקח מחרוזת מילולית במקום a
זוג מחרוזת/אורך, וללא Hash מחושב מראש.
struct refcounted_he * refcounted_he_new_pvs(
struct refcounted_he *הורה,
const char *מפתח, SV *ערך,
דגלים של U32
)
refcounted_he_new_sv
כמו "refcounted_he_new_pvn", אבל לוקח סקלאר של Perl במקום מחרוזת/אורך
זוג.
struct refcounted_he * refcounted_he_new_sv(
struct refcounted_he *הורה,
SV *מפתח, U32 hash, SV *ערך,
דגלים של U32
)
IO פונקציות
start_glob
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
פונקציה שנקראת על ידי "do_readline" כדי להוליד גלוב (או לעשות את הגלוב בתוך perl on
VMS). קוד זה היה בעבר מוטבע, אך כעת perl משתמש ב-"File::Glob" גלוב זה
starter משמש רק על ידי miniperl במהלך תהליך הבנייה. הרחקתו מתכווץ
pp_hot.c; כיווץ pp_hot.c עוזר להאיץ.
PerlIO* start_glob(SV *tmpglob, IO *io)
לקסר ממשק
validate_proto
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
פונקציה זו מבצעת בדיקת תחביר על אב טיפוס, "פרוטו". אם "להזהיר" הוא
נכון, כל תווים לא חוקיים או סוגריים לא תואמים יפעילו פרוטו לא חוקי
אזהרות, המצהיר שהם זוהו באב הטיפוס עבור "שם".
ערך ההחזרה הוא "true" אם זהו אב טיפוס חוקי, ו-"false" אם לא,
ללא קשר אם "להזהיר" היה "נכון" או "שקר".
שימו לב ש"NULL" הוא "פרוטו" חוקי ותמיד יחזיר "true".
הערה: הצורה perl_ של פונקציה זו הוצאה משימוש.
bool validate_proto(SV *name, SV *proto, bool warn)
קסם פונקציות
קסם_ברור
מופעל על ידי מחיקה מ-%^H, מקליט את המפתח ל-"PL_compiling.cop_hints_hash".
int magic_clearhint(SV* sv, MAGIC* mg)
רמזי_קסם
מופעל על ידי ניקוי %^H, מאפס את "PL_compiling.cop_hints_hash".
int magic_clearhints(SV* sv, MAGIC* mg)
magic_methcall
הפעל שיטת קסם (כמו FETCH).
"sv" ו-"mg" הם הדבר הקשור וקסם העניבה.
"meth" הוא שם השיטה להתקשרות.
"argc" הוא מספר ה-args (בנוסף ל-$self) שיש להעביר לשיטה.
ה"דגלים" יכולים להיות:
שיטת הפעלת G_DISCARD עם דגל G_DISCARD ואל תעשה זאת
להחזיר ערך
G_UNDEF_FILL מלא את הערימה עם מצביעי argc אל
PL_sv_undef
הארגומנטים עצמם הם כל ערכים הבאים אחרי הארגומנט "דגלים".
מחזיר את ה-SV (אם קיים) שהוחזר על ידי השיטה, או NULL במקרה של כשל.
SV* magic_methcall(SV *sv, const MAGIC *mg,
SV *meth, U32 דגלים, U32 argc,
...)
ערכת_קסם
מופעל על ידי חנות ל-%^H, מתעד את צמד המפתח/ערך ל
"PL_compiling.cop_hints_hash". ההנחה היא שרמזים אינם מאחסנים דבר
זה יצטרך עותק עמוק. אולי כדאי להזהיר אם נמצא אסמכתא.
int magic_sethint(SV* sv, MAGIC* mg)
mg_localize
העתק חלק מהקסם מ-SV קיים לגרסה מקומית חדשה של אותו SV.
קסם מיכל (למשל %ENV, $1, תיקו) מועתק, קסם ערך לא (לדוגמה, טאינט,
pos).
אם setmagic הוא שקר אז לא ייקרא קסם סט ב-SV החדש (ריק). זֶה
בדרך כלל פירושו שההקצאה תגיע בקרוב (למשל 'local $x = $y'), וזה
יטפל בקסם.
void mg_localize(SV* sv, SV* nsv, bool setmagic)
שונות פונקציות
free_c_backtrace
מבטל מעקב אחורי שהתקבל מ-get_c_bracktrace.
void free_c_backtrace(Perl_c_backtrace* bt)
get_c_backtrace
אוסף את ה-backtrace (הידוע גם בשם "stacktrace") למאגר ליניארי מרובע אחד,
אשר המתקשר צריך Perl_free_c_backtrace().
סורק את הפריימים אחורה לפי עומק + דילוג, ואז שומט את הדילוג הפנימי ביותר, חוזר ב-
רוב מסגרות העומק.
Perl_c_backtrace* get_c_backtrace(int max_depth,
דילוג int)
MRO פונקציות
mro_get_linear_isa_dfs
מחזירה את ליניאריזציה של חיפוש עומק-ראשון של @ISA המאחסן הנתון. השיבה
הערך הוא AV לקריאה בלבד*. "רמה" צריך להיות 0 (הוא משמש באופן פנימי בזה
הרקורסיה של הפונקציה).
אתה אחראי על "SvREFCNT_inc()" בערך ההחזר אם אתה מתכנן לאחסן
זה בכל מקום למחצה לצמיתות (אחרת זה עלול להימחק מתחתיך
בפעם הבאה שהמטמון יבוטל).
AV* mro_get_linear_isa_dfs(HV* stash, רמת U32)
mro_isa_changed_in
נוקטת את הצעדים הדרושים (פסילות מטמון, בעיקר) כאשר ה-@ISA של הנתון
החבילה השתנתה. מופעל על ידי קסם "setisa", לא צריך להפעיל
באופן ישיר.
void mro_isa_changed_in(HV* stash)
mro_package_moved
קרא לפונקציה זו כדי לאותת למחסן שהוא הוקצה לנקודה אחרת
בהיררכיית המחסן. "מחסן" הוא המחסן שהוקצה. "oldstash"
הוא המחסן שהוא מחליף, אם בכלל. "gv" הוא הגלוב שנמצא למעשה
שהוקצה ל.
אפשר לקרוא לזה גם עם ארגומנט ראשון null כדי לציין שיש ל-"oldstash".
נמחק.
פונקציה זו מבטלת מטמון isa במאגר הישן, בכל חבילות המשנה המקוננות
בתוכו, ועל תת המחלקות של כל אלה, כולל חבילות שאינן קיימות
שיש להם ערכים תואמים ב-"stash".
זה גם מגדיר את השמות היעילים ("HvENAME") על כל המאחסנים לפי הצורך.
אם ה-"gv" קיים ואינו נמצא בטבלת הסמלים, אז הפונקציה הזו פשוט
החזרות. זה מסומן ידלג אם "דגלים ו-1".
void mro_package_moved(HV * const stash,
HV * const oldstash,
const GV * const gv,
דגלים של U32)
אופטרי מניפולציה פונקציות
finalize_optree
פונקציה זו מסיימת את האופטרי. יש להתקשר ישירות לאחר ההשלמה
אופטרי בנוי. זה מבצע בדיקה נוספת שלא ניתן לבצע ב-
ck_xxx פונקציות רגילות והופכות את העץ לבטוח בחוט.
void finalize_optree(OP* o)
כָּרִית נתונים מבנים
CX_CURPAD_SAVE
שמור את הפנקס הנוכחי במבנה בלוק ההקשר הנתון.
void CX_CURPAD_SAVE(הקשר struct)
CX_CURPAD_SV
גש ל-SV ב-offset po בפנקס הנוכחי השמור בבלוק ההקשר הנתון
מבנה (יכול לשמש כ-lvalue).
SV * CX_CURPAD_SV(struct context, PADOFFSET po)
PadnameIsOUR
האם זה משתנה "שלנו".
bool PadnameIsOUR(PADNAME pn)
PadnameIsSTATE
האם זהו משתנה "מצב".
bool PadnameIsSTATE(PADNAME pn)
PadnameOURSTASH
המחסן שבו הוכרז המשתנה "שלנו" הזה.
HV * PadnameOURSTASH()
PadnameOUTER
האם ערך זה שייך לרפידה חיצונית. ערכים שעבורם זה נכון הם
מכונה לעתים קרובות 'מזויף'.
bool PadnameOUTER(PADNAME pn)
PadnameTYPE
המחסן המשויך למילוני מודפס. זה מחזיר את ה-%Foo:: hash עבור "my
פו $בר".
HV * PadnameTYPE(PADNAME pn)
PAD_BASE_SV
קבל את הערך מהחריץ "po" בפנקס הבסיס (DEPTH=1) של רשימת padlist
SV * PAD_BASE_SV(PADLIST padlist, PADOFFSET po)
PAD_CLONE_VARS
שכפל את משתני המצב הקשורים להרצה והידור של פדים.
void PAD_CLONE_VARS(PerlInterpreter *proto_perl,
פרמטר CLONE_PARAMS*)
PAD_COMPNAME_FLAGS
החזר את הדגלים עבור שם משטח ההידור הנוכחי בהיסט "po". מניח א
כניסת משבצת חוקית.
U32 PAD_COMPNAME_FLAGS(PADOFFSET po)
PAD_COMPNAME_GEN
מספר הדור של השם בהיסט "po" בפנקס ההידור הנוכחי
(לערך). שימו לב ש"SvUVX" נחטף למטרה זו.
STRLEN PAD_COMPNAME_GEN(PADOFFSET po)
PAD_COMPNAME_GEN_set
מגדיר את מספר הדור של השם בהיסט "po" ב-ling pad הנוכחי
(lvalue) ל-"gen". שימו לב ש"SvUV_set" נחטף למטרה זו.
STRLEN PAD_COMPNAME_GEN_set(PADOFFSET po, int gen)
PAD_COMPNAME_OURSTASH
החזר את המאגר המשויך למשתנה "שלנו". מניח שהכניסה לחריץ היא א
מילון "שלנו" תקף.
HV * PAD_COMPNAME_OURSTASH(PADOFFSET po)
PAD_COMPNAME_PV
החזר את השם של שם משטח ההידור הנוכחי בהיסט "po". מניח תקף
כניסה למשבצת.
char * PAD_COMPNAME_PV(PADOFFSET po)
PAD_COMPNAME_TYPE
החזר את הסוג (סטש) של שם משטח ההידור הנוכחי בהיסט "po". חייב להיות
שם חוקי. מחזירה null אם לא הוקלדה.
HV * PAD_COMPNAME_TYPE(PADOFFSET po)
PAD_RESTORE_LOCAL
שחזר את הפנקס הישן שנשמר במשתנה המקומי opad by PAD_SAVE_LOCAL()
void PAD_RESTORE_LOCAL(PAD *opad)
PAD_SAVE_LOCAL
שמור את הפד הנוכחי במשתנה המקומי opad, ואז הפוך את הפד הנוכחי לשווה
ל-npad
void PAD_SAVE_LOCAL(PAD *opad, PAD *npad)
PAD_SAVE_SETNULLPAD
שמור את הפנקס הנוכחי ואז הגדר אותו ל- null.
בטל PAD_SAVE_SETNULLPAD()
PAD_SETSV
הגדר את החריץ בהיסט "po" בפנקס הנוכחי ל-"sv"
SV * PAD_SETSV(PADOFFSET po, SV* sv)
PAD_SET_CUR
הגדר את הפנקס הנוכחי ל-pad "n" ברשימת ה-pads, שמור את הפד הנוכחי הקודם.
NB כרגע המאקרו הזה מתרחב למחרוזת ארוכה מדי עבור כמה מהדרים, אז זהו
הכי טוב להחליף אותו
SAVECOMPPAD();
PAD_SET_CUR_NOSAVE(padlist,n);
void PAD_SET_CUR(PADLIST padlist, I32 n)
PAD_SET_CUR_NOSAVE
כמו PAD_SET_CUR, אבל בלי השמירה
void PAD_SET_CUR_NOSAVE(PADLIST padlist, I32 n)
PAD_SV קבל את הערך בהיסט "po" בפנקס הנוכחי
SV * PAD_SV(PADOFFSET po)
PAD_SVl גרסה קלת משקל ו-lvalue של "PAD_SV". קבל או הגדר את הערך ב-offset "po"
בפנקס הנוכחי. שלא כמו "PAD_SV", אינו מדפיס אבחון עם -DX. ל
לשימוש פנימי בלבד.
SV * PAD_SVl(PADOFFSET po)
SAVECLEARSV
נקה את הערך המחודד לרפידה ביציאה מהטווח. (כלומר פעולת זמן הריצה של 'שלי')
void SAVECLEARSV(SV **svp)
SAVECOMPPAD
שמור את PL_comppad ו-PL_curpad
void SAVECOMPPAD()
SAVEPADSV
שמור חריץ משטח (משמש לשחזור לאחר איטרציה)
XXX DAPM יהיה הגיוני יותר להפוך את ה-arg ל-PADOFFSET
void SAVEPADSV(PADOFFSET po)
פר מתורגמן משתנים
PL_DBסינגל
כאשר Perl מופעלת במצב ניפוי באגים, עם ה -d מתג, ה-SV הזה הוא בוליאני אשר
מציין אם תת-צעדים הם חד-צעדיים. צעד אחד הוא אוטומטי
מופעל לאחר כל צעד. זהו משתנה C שמתאים למשתנה של Perl
$DB::משתנה יחיד. ראה "PL_DBsub".
SV * PL_DBסינגל
PL_DBsub
כאשר Perl מופעלת במצב ניפוי באגים, עם ה -d מתג, GV זה מכיל את ה-SV
שמחזיק את השם של המשנה שמתבצע ניפוי באגים. זהו משתנה C אשר
מתאים למשתנה $DB::sub של Perl. ראה "PL_DBסינגל".
GV * PL_DBsub
PL_DBtrace
משתנה מעקב בשימוש כאשר Perl מופעלת במצב ניפוי באגים, עם ה- -d החלף. זֶה
הוא משתנה C המתאים למשתנה $DB::trace של Perl. לִרְאוֹת
"PL_DBסינגל".
SV * PL_DBtrace
PL_דוארן
משתנה C המתאים למשתנה האזהרה $^W של Perl.
bool PL_dowarn
PL_last_in_gv
ה-GV ששימש לאחרונה עבור פעולת קלט של filehandle. (" ")
GV* PL_last_in_gv
PL_ofsgv
הגלוב המכיל את מפריד שדות הפלט - "*," במרחב Perl.
GV* PL_ofsgv
PL_rs מפריד רשומות הקלט - $/ ברווח Perl.
SV* PL_rs
לערום מניפולציה מאקרו
djSP הכריז רק "SP". זה למעשה זהה ל-"dSP", ומצהיר על עותק מקומי
של מצביע המחסנית של perl, זמין דרך המאקרו "SP". ראה "SP". (פנוי ל
תאימות קוד מקור לאחור עם דגם השרשור הישן (Perl 5.005).
djSP;
LVRET True אם האופציה הזו תהיה ערך ההחזרה של תת שגרת lvalue
SV מניפולציה פונקציות
SV (או AV, HV וכו') מוקצה לשני חלקים: הראש (struct sv, av, hv...)
מכיל מידע על סוג וספירת הפניות, ולסוגים רבים, מצביע לגוף
(struct xrv, xpv, xpviv...), המכיל שדות ספציפיים לכל סוג. כמה סוגים
אחסן את כל מה שהם צריכים בראש, אז אל תהיה לך גוף.
בכל התצורות הפרנואידיות ביותר לזיכרון (לדוגמה: PURIFY), ראשים וגופים הם
מוקצים מתוך זירות, אשר כברירת מחדל הן חלקי זיכרון של כ-4K
למעלה לתוך N ראשים או גופים. גופי Sv מוקצים לפי סוג ה-sv שלהם, מה שמבטיח גודל
עקביות הדרושה להקצאה בטוחה ממערכים.
עבור ראשי SV, המשבצת הראשונה בכל זירה שמורה, ומחזיקה קישור אל הבא
זירה, כמה דגלים ופתק של מספר המשבצות. נחשוש דרך כל שרשרת זירה היא
רשימה מקושרת של פריטים בחינם; כאשר זה הופך ריק, זירה נוספת מוקצה ו
מחולקים ל-N פריטים אשר מושחלים לרשימה החינמית.
גופי SV דומים, אבל הם משתמשים בערכות זירה כברירת מחדל, שמפרידות בין הקישור לבין
מידע מהזירה עצמה, וקבל בחזרה את המשבצת הראשונה בזירה. גופי SV רחוקים יותר
שתואר מאוחר יותר.
המשתנים הגלובליים הבאים משויכים לזירות:
PL_sv_arenaroot מצביע לרשימת זירות SV
מצביע PL_sv_root לרשימת מבני SV בחינם
PL_body_arenas ראש הרשימה המקושרת של זירות הגוף
מערך מצביעים PL_body_roots[] לרשימה של גופים חופשיים של svtype
מערכים מתווספים לפי ה-svtype הדרוש
כמה ראשי SV מיוחדים אינם מוקצים מזירה, אלא נוצרים ישירות
במבנה המתורגמן, למשל PL_sv_undef. ניתן לשנות את גודל הזירות מה-
ברירת מחדל על ידי הגדרה מתאימה של PERL_ARENA_SIZE בזמן ההידור.
זירת SV משרתת את המטרה המשנית של לאפשר איתור ו-SVs עדיין חיים
נהרס במהלך הניקוי הסופי.
ברמה הנמוכה ביותר, פקודות המאקרו new_SV() ו del_SV() לתפוס ולשחרר ראש SV. (אם
ניפוי באגים עם -DD, del_SV() קורא לפונקציה S_del_sv() כדי להחזיר את ה-SV לחופשי
רשימה עם בדיקת שגיאות.) new_SV() שיחות more_sv() / sv_add_arena() כדי להוסיף זירה נוספת
אם הרשימה החינמית ריקה. שדה SVTYPE ברשימה החינמית מוגדרת לכל אלה.
בזמן הניקוי הסופי מאוד, sv_free_arenas() נקרא מ perl_destruct() ל
חופשי פיזית את כל הזירות שהוקצו מאז תחילת המתורגמן.
הפונקציה לְבַקֵר() סורק את רשימת זירות SV, וקורא לפונקציה שצוינה עבור כל SV
הוא מוצא את מה שעדיין פעיל - כלומר שיש לו SvTYPE שונה מכל ה-1, ואינו אפס
SvREFCNT. לְבַקֵר() משמש את הפונקציות הבאות (מצוין בתור [פונקציה שקוראת
לְבַקֵר()] / [פונקציה שנקראה על ידי לְבַקֵר() עבור כל SV]):
sv_report_used() / do_report_used()
זרוק את כל ה-SVs הנותרים (סיוע באגים)
sv_clean_objs() / do_clean_objs(),do_clean_named_objs(),
do_clean_named_io_objs(),do_curse()
נסה לשחרר את כל החפצים שעליהם מצביעים קרוואנים,
נסה לעשות את אותו הדבר עבור כל האובייקטים ב-
התייחסות ectly על ידי typeglobs מדי, ו
ואז לעשות סוויפ אחרון, לקלל כל אחד
חפצים שנותרו. התקשר פעם אחת מ
perl_destruct(), לפני קריאת sv_clean_all()
לְהַלָן.
sv_clean_all() / do_clean_all()
SvREFCNT_dec(sv) כל SV שנותר, אולי
מפעיל sv_free(). זה גם קובע את
דגל SVf_BREAK על ה-SV כדי לציין שה
refcnt הורד באופן מלאכותי, וכך
מונעת מה-sv_free() לתת אזהרות מזויפות
על SVs אשר באופן בלתי צפוי יש refcnt
של אפס. נקרא שוב ושוב מ-perl_destruct()
עד שלא יישארו SVs.
SvTHINKFIRST
בדיקת דגל מהירה כדי לראות אם יש להעביר sv ל-sv_force_normal to be
"שודרג לאחור" לפני שניתן לשנות את SvIVX או SvPVX ישירות.
לדוגמה, אם הסקלר שלך הוא הפניה ואתה רוצה לשנות את חריץ SvIVX,
אתה לא יכול פשוט לעשות SvROK_off, כי זה ידליף את הרפרנט.
זה משמש באופן פנימי על ידי פונקציות שונות לשינוי sv, כגון sv_setsv,
sv_setiv ו-sv_pvn_force.
מקרה אחד שזה לא מטפל בו הוא gv ללא סט SvFAKE. לאחר
if (SvTHINKFIRST(gv)) sv_force_normal(gv);
זה עדיין יהיה gv.
SvTHINKFIRST מייצר לפעמים תוצאות חיוביות שגויות. במקרים אלו sv_force_normal
לא עושה דבר.
U32 SvTHINKFIRST(SV *sv)
sv_add_arena
בהינתן נתח של זיכרון, קשר אותו לראש רשימת הזירות, ופצל אותו
לתוך רשימה של SVs בחינם.
void sv_add_arena(char *const ptr, const U32 size,
דגלי const U32)
sv_clean_all
הפחת את ה-recnt של כל SV שנותר, ואולי תפעיל ניקוי. זֶה
ייתכן שיהיה צורך לקרוא לפונקציה מספר פעמים כדי לשחרר SVs שהם מורכבים
היררכיות הפניה עצמית.
I32 sv_clean_all()
sv_clean_objs
נסה להשמיד את כל החפצים שעדיין לא שוחררו.
void sv_clean_objs()
sv_free_arenas
הקצה את הזיכרון המשמש את כל הזירות. שימו לב שכל ראשי ה-SV הבודדים
וגופים בתוך הזירות בוודאי כבר שוחררו.
void sv_free_arenas()
SV-Body הַקצָאָה
sv_2num הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
החזר SV עם הערך המספרי של המקור SV, תוך ביצוע כל צורך
התייחסות או המרת עומס יתר. המתקשר צפוי לטפל בקבלת-
כבר קסם.
SV* sv_2num(SV *const sv)
sv_copypv
מעתיק ייצוג מחרוזת של המקור SV אל SV היעד.
מבצע אוטומטית כל mg_get הכרחי וכפייה של ערכים מספריים לתוך
מחרוזות. מובטח לשמר את דגל UTF8 גם מחפצים עמוסים מדי. דוֹמֶה
בטבע ל-sv_2pv[_flags] אבל פועל ישירות על SV במקום רק על
חוּט. משתמש בעיקר ב-sv_2pv_flags כדי לבצע את עבודתו, למעט כאשר זה יאבד את
UTF-8'ness של ה-PV.
void sv_copypv(SV *const dsv, SV *const ssv)
sv_ref מחזירה SV המתאר את מה שה-SV עבר בו הוא הפניה אליו.
SV* sv_ref(SV *dst, const SV *const sv,
const int ob)
Unicode תמיכה
find_uninit_var
הערה: פונקציה זו היא ניסיונית ועשויה להשתנות או להיות מוסרת ללא הודעה מוקדמת.
מצא את השם של המשתנה הלא מוגדר (אם קיים) שגרם לאופרטור להופיע
אזהרת "שימוש בערך לא מאותחל". אם ההתאמה נכונה, החזר רק שם אם
הערך שלו תואם ל-uninit_sv. אז באופן גס, אם אופרטור unary (כגון
OP_COS) יוצר אזהרה, ואז מעקב אחר הילד הישיר של המבצע עשוי להניב
OP_PADSV או OP_GV שנותנים את השם של המשתנה הלא מוגדר. מנגד
יד, עם OP_ADD יש שני ענפים לעקוב, אז אנחנו מדפיסים רק את המשתנה
שם אם נקבל התאמה מדויקת. desc_p מצביע על מצביע מחרוזת המחזיק את
תיאור האופציה. זה עשוי להתעדכן במידת הצורך.
השם מוחזר כ-SV בן תמותה.
מניח ש-PL_op הוא ה-op שהפעיל במקור את השגיאה, וזה
PL_comppad/PL_curpad מצביע על הפנקס המופעל כעת.
SV* find_uninit_var(const OP *const obase,
const SV *const uninit_sv,
bool match, const char **desc_p)
report_uninit
הדפס אזהרת "שימוש במשתנה לא מאותחל" מתאימה.
void report_uninit(const SV *uninit_sv)
לא מתועד פונקציות
הפונקציות הבאות אינן מתועדות כרגע. אם אתה משתמש באחד מהם, אולי תרצה
לשקול יצירה והגשה של תיעוד עבורו.
PerlIO_restore_errno
PerlIO_save_errno
Slab_Alloc
לוח_ללא תשלום
לוח_to_ro
Slab_to_rw
_add_range_to_invlist
_core_swash_init
_קבל_קידוד
_get_swash_invlist
_invlist_array_init
_invlist_contains_cp
_invlist_contents
_invlist_dump
_invlist_intersection
_invlist_intersection_maybe_complement_2nd
_invlist_invert
_invlist_len
_invlist_populate_swatch
_invlist_search
_invlist_subtract
_invlist_union
_invlist_union_maybe_complement_2
_load_PL_utf8_foldclosures
_new_invlist
_setup_canned_invlist
_swash_inversion_hash
_swash_to_invlist
_לקיפול_לטיני1
_to_upper_title_latin1
_להזהיר_בעייתי_מקומי
aassign_common_vars
add_cp_to_invlist
alloc_maybe_populate_EXACT
הקצבה
amagic_מופעל
להגיש מועמדות
av_extend_guts
av_reify
bind_match
boot_core_PerlIO
boot_core_UNIVERSAL
boot_core_mro
קנו
check_utf8_print
ck_anoncode
ck_backtick
ck_bitop
ck_cmp
ck_concat
ck_defined
ck_delete
ck_כל אחד
ck_entersub_args_core
ck_eof
ck_eval
ck_exec
ck_קיים
ck_ftst
ck_כיף
ck_glob
ck_grep
ck_index
ck_join
ck_length
ck_lfun
ck_listiob
ck_match
ck_method
ck_null
ck_open
ck_prototype
ck_readline
ck_refassign
ck_repeat
ck_require
ck_return
ck_rfun
ck_rvconst
ck_sassign
ck_select
ck_shift
ck_smartmatch
ck_sort
ck_spair
ck_split
ck_stringify
ck_subr
ck_substr
ck_svconst
ck_tell
ck_trunc
השוטר הקרוב ביותר
compute_EXACTish
coresub_op
create_eval_scope
croak_no_mem
croak_popstack
מנוע_מחדש
custom_op_get_field
cv_ckproto_len_flags
cv_clone_into
cv_const_sv_or_av
cv_undef_flags
cvgv_from_hek
cvgv_set
cvstash_set
deb_stack_all
defelem_target
delete_eval_scope
למות_להירגע
do_aexec
do_aexec5
do_eof
do_exec
do_exec3
do_execfree
do_ipcctl
do_ipcget
do_msgrcv
do_msgsnd
do_ncmp
do_open6
do_open_raw
do_print
do_readline
לעשות_חפש
do_semop
do_shmio
do_sysseek
ספר
do_trans
do_vecget
do_vecset
do_vop
קובץ מסמך
drand48_init_r
drand48_r
dump_all_perl
dump_packsubs_perl
dump_sub_perl
dump_sv_child
emulate_cop_io
feature_is_enabled
find_lexical_cv
find_runcv_where
find_rundefsv2
find_script
free_tied_hv_pool
get_and_check_backslash_N_name
get_db_sub
get_debug_opts
קבל_זרע_חשיש
get_invlist_iter_addr
get_invlist_offset_addr
get_invlist_previous_index_addr
get_no_modify
get_opargs
get_re_arg
getenv_len
grok_atoUV
grok_bslash_x
gv_fetchmeth_internal
gv_override
gv_setref
gv_stashpvn_internal
gv_stashsvpvn_cached
hfree_next_entry
hv_backreferences_p
hv_kill_backrefs
hv_placeholders_p
hv_undef_flags
init_argv_symbols
init_constants
init_dbargs
init_debugger
הפוך
invlist_array
invlist_clone
invlist_highest
invlist_is_iterating
invlist_iterfinish
invlist_iterinit
invlist_max
invlist_previous_index
invlist_set_len
invlist_set_previous_index
invlist_trim
io_close
is_utf8_common
isinfnansv
אולי
מילות מפתח
keyword_plugin_standard
רשימה
לְמַקֵם
magic_clear_all_env
magic_cleararylen_p
magic_clearenv
magic_clearisa
magic_clearpack
magic_clearsig
magic_copycallchecker
magic_existspack
magic_freearylen_p
magic_freeovrld
קסם_קבל
magic_getarylen
magic_getdebugvar
magic_getdefelem
magic_getnkeys
magic_getpack
magic_getpos
magic_getsig
magic_getsubstr
magic_gettaint
magic_getuvar
magic_getvec
magic_killbackrefs
magic_nextpack
magic_regdata_cnt
magic_regdatum_get
magic_regdatum_set
magic_scalarpack
סט_קסם
magic_set_all_env
magic_setarylen
magic_setcollxfrm
magic_setdbline
magic_setdebugvar
magic_setdefelem
magic_setenv
magic_setisa
magic_setlvref
magic_setmglob
magic_setnkeys
magic_setpack
magic_setpos
magic_setregexp
magic_setsig
magic_setsubstr
מאפיין_קסם
magic_setutf8
magic_setuvar
magic_setvec
magic_sizepack
magic_wipepack
malloc_בגודל_טוב
malloced_size
mem_collxfrm
mg_find_mglob
מצב_ממשמעת
יותר_גופות
mro_meta_dup
mro_meta_init
multideref_stringify
my_attrs
my_clearenv
my_lstat_flags
שלי_סטטיסטיקה
my_unexec
newATTRSUB_x
newGP
newMETHOP_internal
newSTUB
newSVavdefelem
newXS_deffile
newXS_len_flags
new_warnings_bitfield
nextargv
noperl_die
אופסAV
אופסHV
op_clear
op_integerize
op_lvalue_flags
op_refcnt_dec
op_refcnt_inc
op_relocate_sv
op_std_init
op_unscope
opmethod_stash
opslab_force_free
opslab_free
opslab_free_nopad
חבילה
package_version
pad_add_weakref
padlist_store
padname_free
padnamelist_free
parse_subsignature
parse_unicode_opts
parser_free
parser_free_nexttoke_ops
נתיב_ניתן לחיפוש
לְהָצִיץ
pmruntime
populate_isa
ptr_hash
שגיאה
re_op_compile
reg_named_buff
reg_named_buff_iter
reg_numbered_buff_fetch
reg_numbered_buff_length
reg_numbered_buff_store
reg_qr_package
reg_skipcomment
reg_temp_copy
באופן קבוע
regpposixcc
regprop
report_evil_fh
report_redefined_cv
report_wrongway_fh
rpeep
rsignal_restore
rsignal_save
rxres_save
same_dirent
save_aliased_sv
save_strlen
sawparens
סקלר
scalarvoid
set_caret_X
set_padlist
should_warn_nl
סיגנדלר
softref2xv
ssc_add_range
ssc_clear_locale
ssc_cp_and
ssc_intersection
ssc_union
sub_crush_depth
sv_add_backref
sv_buf_to_ro
sv_del_backref
sv_free2
sv_kill_backrefs
sv_len_utf8_nomg
sv_magicext_mglob
sv_mortalcopy_flags
sv_only_taint_gmagic
sv_or_pv_pos_u2b
sv_resetpvn
sv_sethek
sv_setsv_cow
sv_unglob
שיטת_קשר
tmps_grow_p
translate_substr_offsets
try_amagic_bin
try_amagic_un
unshare_hek
לנצל
varname
vivify_defelem
vivify_ref
wait4pid
was_lvalue_sub
שעון
win32_croak_not_implemented
write_to_stderr
xs_boot_epilog
xs_לחיצת יד
yyerror
yyerror_pv
yyerror_pvn
yylex
yyparse
yyunlex
מחברים
מערכת התיעוד האוטומטי נוספה במקור לליבת פרל על ידי בנג'מין סטוהל.
התיעוד הוא על ידי מי שהיה אדיב מספיק לתעד את תפקידיו.
השתמש ב-perlintern באינטרנט באמצעות שירותי onworks.net
