Crate libperl_sys

Expand description

§libperl-sys

Built against Perl 5.40.1 (threaded, x86_64-linux-gnu-thread-multi).

The function signatures, PL_* globals, and Sv* / Av* / Hv* helpers documented below reflect this specific Perl. Different Perl versions may have minor signature differences (added / removed functions, changed integer widths, threading-mode variations). Use the PERL_VERSION / PERL_THREADED / PERL_ARCHNAME constants for runtime identification.

Low-level, raw FFI declarations for the Perl 5 C API (libperl). Generated at build time by bindgen (regular C declarations) plus libperl-macrogen (the C macros and static inline functions that bindgen skips).

This crate is the unsafe foundation under libperl-rs; most users want that safer wrapper. Reach for libperl-sys directly when you need an API element that hasn’t been wrapped yet, or when you’re writing a sibling crate at the same layer.

§What you get

Re-exported at the crate root:

Perl_* extern functions and PL_* mutable statics (from bindgen),
Sv* / Av* / Hv* / PL_xxx!() macro helpers and inline wrappers (from libperl-macrogen) — these unify the threaded vs non-threaded calling conventions so the same source builds against both MULTIPLICITY modes,
PL_xxx_ptr!() pointer accessors (read and write the interpreter variables through one primitive) and the thx calling-convention shim module — together they let downstream crates touch raw interpreter state without cfg-forking on the threading mode (GH-20),
opcode → name lookup table (conv_opcode) and per-function signature dictionary (sigdb) for downstream codegen.

§Safety

Every public item here is unsafe to use. Even reading a PL_* global requires the right interpreter context, and Perl’s API uses raw *mut pointers ubiquitously.

§Build requirements

A working Perl 5 install with development headers (Perl.h, EXTERN.h, …). Typical packages: perl-dev, perl-devel.
LLVM / libclang (for bindgen).
Internet access at first build (libperl-macrogen downloads a pre-extracted apidoc snapshot from GitHub Releases).

Threaded vs non-threaded Perl is auto-detected — no feature flag to set.

Re-exports§

pub use perl_core::*;

Modules§

conv_opcode
perl_core: Auto-generated FFI declarations (bindgen + libperl-macrogen output).
sigdb
thx: Threaded-style calling-convention shims (GH-20).

Macros§

PL_AboveLatin1: PL_AboveLatin1 — PERLVAR(I, AboveLatin1, SV*)
PL_AboveLatin1_ptr: *mut accessor for PL_AboveLatin1 (read form: PL_AboveLatin1!).
PL_Assigned_invlist: PL_Assigned_invlist — PERLVAR(I, Assigned_invlist, SV*)
PL_Assigned_invlist_ptr: *mut accessor for PL_Assigned_invlist (read form: PL_Assigned_invlist!).
PL_CCC_non0_non230: PL_CCC_non0_non230 — PERLVAR(I, CCC_non0_non230, SV*)
PL_CCC_non0_non230_ptr: *mut accessor for PL_CCC_non0_non230 (read form: PL_CCC_non0_non230!).
PL_C_locale_obj: PL_C_locale_obj — PERLVARI(G, C_locale_obj, locale_t)
PL_C_locale_obj_ptr: *mut accessor for PL_C_locale_obj (read form: PL_C_locale_obj!).
PL_DBcontrol: PL_DBcontrol — PERLVARA(I, DBcontrol, DBVARMG_COUNT, IV)
PL_DBcontrol_ptr: *mut accessor for PL_DBcontrol (read form: PL_DBcontrol!).
PL_DBcv: PL_DBcv — PERLVAR(I, DBcv, CV*)
PL_DBcv_ptr: *mut accessor for PL_DBcv (read form: PL_DBcv!).
PL_DBgv: PL_DBgv — PERLVAR(I, DBgv, GV*)
PL_DBgv_ptr: *mut accessor for PL_DBgv (read form: PL_DBgv!).
PL_DBline: PL_DBline — PERLVAR(I, DBline, GV*)
PL_DBline_ptr: *mut accessor for PL_DBline (read form: PL_DBline!).
PL_DBsignal: PL_DBsignal — PERLVAR(I, DBsignal, SV*)
PL_DBsignal_ptr: *mut accessor for PL_DBsignal (read form: PL_DBsignal!).
PL_DBsingle: PL_DBsingle — PERLVAR(I, DBsingle, SV*)
PL_DBsingle_ptr: *mut accessor for PL_DBsingle (read form: PL_DBsingle!).
PL_DBsub: PL_DBsub — PERLVAR(I, DBsub, GV*)
PL_DBsub_ptr: *mut accessor for PL_DBsub (read form: PL_DBsub!).
PL_DBtrace: PL_DBtrace — PERLVAR(I, DBtrace, SV*)
PL_DBtrace_ptr: *mut accessor for PL_DBtrace (read form: PL_DBtrace!).
PL_GCB_invlist: PL_GCB_invlist — PERLVAR(I, GCB_invlist, SV*)
PL_GCB_invlist_ptr: *mut accessor for PL_GCB_invlist (read form: PL_GCB_invlist!).
PL_HasMultiCharFold: PL_HasMultiCharFold — PERLVAR(I, HasMultiCharFold, SV*)
PL_HasMultiCharFold_ptr: *mut accessor for PL_HasMultiCharFold (read form: PL_HasMultiCharFold!).
PL_InBitmap: PL_InBitmap — PERLVARI(I, InBitmap, SV*)
PL_InBitmap_ptr: *mut accessor for PL_InBitmap (read form: PL_InBitmap!).
PL_InMultiCharFold: PL_InMultiCharFold — PERLVAR(I, InMultiCharFold, SV*)
PL_InMultiCharFold_ptr: *mut accessor for PL_InMultiCharFold (read form: PL_InMultiCharFold!).
PL_LB_invlist: PL_LB_invlist — PERLVAR(I, LB_invlist, SV*)
PL_LB_invlist_ptr: *mut accessor for PL_LB_invlist (read form: PL_LB_invlist!).
PL_Latin1: PL_Latin1 — PERLVAR(I, Latin1, SV*)
PL_Latin1_ptr: *mut accessor for PL_Latin1 (read form: PL_Latin1!).
PL_Posix_ptrs: PL_Posix_ptrs — PERLVARA(I, Posix_ptrs, POSIX_CC_COUNT, SV*)
PL_Posix_ptrs_ptr: *mut accessor for PL_Posix_ptrs (read form: PL_Posix_ptrs!).
PL_Private_Use: PL_Private_Use — PERLVAR(I, Private_Use, SV*)
PL_Private_Use_ptr: *mut accessor for PL_Private_Use (read form: PL_Private_Use!).
PL_SB_invlist: PL_SB_invlist — PERLVAR(I, SB_invlist, SV*)
PL_SB_invlist_ptr: *mut accessor for PL_SB_invlist (read form: PL_SB_invlist!).
PL_SCX_invlist: PL_SCX_invlist — PERLVAR(I, SCX_invlist, SV*)
PL_SCX_invlist_ptr: *mut accessor for PL_SCX_invlist (read form: PL_SCX_invlist!).
PL_Sv: PL_Sv — PERLVAR(I, Sv, SV*)
PL_Sv_ptr: *mut accessor for PL_Sv (read form: PL_Sv!).
PL_TR_SPECIAL_HANDLING_UTF8: PL_TR_SPECIAL_HANDLING_UTF8 — PERLVARA(I, TR_SPECIAL_HANDLING_UTF8, UTF8_MAXBYTES, char)
PL_TR_SPECIAL_HANDLING_UTF8_ptr: *mut accessor for PL_TR_SPECIAL_HANDLING_UTF8 (read form: PL_TR_SPECIAL_HANDLING_UTF8!).
PL_UpperLatin1: PL_UpperLatin1 — PERLVAR(I, UpperLatin1, SV*)
PL_UpperLatin1_ptr: *mut accessor for PL_UpperLatin1 (read form: PL_UpperLatin1!).
PL_WB_invlist: PL_WB_invlist — PERLVAR(I, WB_invlist, SV*)
PL_WB_invlist_ptr: *mut accessor for PL_WB_invlist (read form: PL_WB_invlist!).
PL_XPosix_ptrs: PL_XPosix_ptrs — PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV*)
PL_XPosix_ptrs_ptr: *mut accessor for PL_XPosix_ptrs (read form: PL_XPosix_ptrs!).
PL_Xpv: PL_Xpv — PERLVAR(I, Xpv, XPV*)
PL_Xpv_ptr: *mut accessor for PL_Xpv (read form: PL_Xpv!).
PL_an: PL_an — PERLVARI(I, an, U32)
PL_an_ptr: *mut accessor for PL_an (read form: PL_an!).
PL_argvgv: PL_argvgv — PERLVAR(I, argvgv, GV*)
PL_argvgv_ptr: *mut accessor for PL_argvgv (read form: PL_argvgv!).
PL_argvout_stack: PL_argvout_stack — PERLVAR(I, argvout_stack, AV*)
PL_argvout_stack_ptr: *mut accessor for PL_argvout_stack (read form: PL_argvout_stack!).
PL_argvoutgv: PL_argvoutgv — PERLVAR(I, argvoutgv, GV*)
PL_argvoutgv_ptr: *mut accessor for PL_argvoutgv (read form: PL_argvoutgv!).
PL_basetime: PL_basetime — PERLVAR(I, basetime, Time_t)
PL_basetime_ptr: *mut accessor for PL_basetime (read form: PL_basetime!).
PL_beginav: PL_beginav — PERLVAR(I, beginav, AV*)
PL_beginav_ptr: *mut accessor for PL_beginav (read form: PL_beginav!).
PL_beginav_save: PL_beginav_save — PERLVARI(I, beginav_save, AV*)
PL_beginav_save_ptr: *mut accessor for PL_beginav_save (read form: PL_beginav_save!).
PL_blockhooks: PL_blockhooks — PERLVAR(I, blockhooks, AV*)
PL_blockhooks_ptr: *mut accessor for PL_blockhooks (read form: PL_blockhooks!).
PL_body_arenas: PL_body_arenas — PERLVAR(I, body_arenas, void*)
PL_body_arenas_ptr: *mut accessor for PL_body_arenas (read form: PL_body_arenas!).
PL_body_roots: PL_body_roots — PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*)
PL_body_roots_ptr: *mut accessor for PL_body_roots (read form: PL_body_roots!).
PL_bodytarget: PL_bodytarget — PERLVAR(I, bodytarget, SV*)
PL_bodytarget_ptr: *mut accessor for PL_bodytarget (read form: PL_bodytarget!).
PL_breakable_sub_gen: PL_breakable_sub_gen — PERLVARI(I, breakable_sub_gen, U32)
PL_breakable_sub_gen_ptr: *mut accessor for PL_breakable_sub_gen (read form: PL_breakable_sub_gen!).
PL_check_mutex: PL_check_mutex — PERLVAR(G, check_mutex, perl_mutex)
PL_check_mutex_ptr: *mut accessor for PL_check_mutex (read form: PL_check_mutex!).
PL_checkav: PL_checkav — PERLVAR(I, checkav, AV*)
PL_checkav_ptr: *mut accessor for PL_checkav (read form: PL_checkav!).
PL_checkav_save: PL_checkav_save — PERLVARI(I, checkav_save, AV*)
PL_checkav_save_ptr: *mut accessor for PL_checkav_save (read form: PL_checkav_save!).
PL_chopset: PL_chopset — PERLVARI(I, chopset, const char*)
PL_chopset_ptr: *mut accessor for PL_chopset (read form: PL_chopset!).
PL_clocktick: PL_clocktick — PERLVARI(I, clocktick, long)
PL_clocktick_ptr: *mut accessor for PL_clocktick (read form: PL_clocktick!).
PL_collation_ix: PL_collation_ix — PERLVARI(I, collation_ix, PERL_UINTMAX_T)
PL_collation_ix_ptr: *mut accessor for PL_collation_ix (read form: PL_collation_ix!).
PL_collation_name: PL_collation_name — PERLVAR(I, collation_name, char*)
PL_collation_name_ptr: *mut accessor for PL_collation_name (read form: PL_collation_name!).
PL_collation_standard: PL_collation_standard — PERLVARI(I, collation_standard, bool)
PL_collation_standard_ptr: *mut accessor for PL_collation_standard (read form: PL_collation_standard!).
PL_collxfrm_base: PL_collxfrm_base — PERLVAR(I, collxfrm_base, Size_t)
PL_collxfrm_base_ptr: *mut accessor for PL_collxfrm_base (read form: PL_collxfrm_base!).
PL_collxfrm_mult: PL_collxfrm_mult — PERLVARI(I, collxfrm_mult, Size_t)
PL_collxfrm_mult_ptr: *mut accessor for PL_collxfrm_mult (read form: PL_collxfrm_mult!).
PL_colors: PL_colors — PERLVARA(I, colors, 6, char*)
PL_colors_ptr: *mut accessor for PL_colors (read form: PL_colors!).
PL_colorset: PL_colorset — PERLVAR(I, colorset, bool)
PL_colorset_ptr: *mut accessor for PL_colorset (read form: PL_colorset!).
PL_compcv: PL_compcv — PERLVAR(I, compcv, CV*)
PL_compcv_ptr: *mut accessor for PL_compcv (read form: PL_compcv!).
PL_compiling: PL_compiling — PERLVAR(I, compiling, COP)
PL_compiling_ptr: *mut accessor for PL_compiling (read form: PL_compiling!).
PL_comppad: PL_comppad — PERLVAR(I, comppad, PAD*)
PL_comppad_name: PL_comppad_name — PERLVAR(I, comppad_name, PADNAMELIST*)
PL_comppad_name_fill: PL_comppad_name_fill — PERLVAR(I, comppad_name_fill, PADOFFSET)
PL_comppad_name_fill_ptr: *mut accessor for PL_comppad_name_fill (read form: PL_comppad_name_fill!).
PL_comppad_name_floor: PL_comppad_name_floor — PERLVAR(I, comppad_name_floor, PADOFFSET)
PL_comppad_name_floor_ptr: *mut accessor for PL_comppad_name_floor (read form: PL_comppad_name_floor!).
PL_comppad_name_ptr: *mut accessor for PL_comppad_name (read form: PL_comppad_name!).
PL_comppad_ptr: *mut accessor for PL_comppad (read form: PL_comppad!).
PL_constpadix: PL_constpadix — PERLVAR(I, constpadix, PADOFFSET)
PL_constpadix_ptr: *mut accessor for PL_constpadix (read form: PL_constpadix!).
PL_cop_seqmax: PL_cop_seqmax — PERLVARI(I, cop_seqmax, U32)
PL_cop_seqmax_ptr: *mut accessor for PL_cop_seqmax (read form: PL_cop_seqmax!).
PL_csighandler1p: PL_csighandler1p — PERLVARI(G, csighandler1p, Sighandler1_t)
PL_csighandler1p_ptr: *mut accessor for PL_csighandler1p (read form: PL_csighandler1p!).
PL_csighandler3p: PL_csighandler3p — PERLVARI(G, csighandler3p, Sighandler3_t)
PL_csighandler3p_ptr: *mut accessor for PL_csighandler3p (read form: PL_csighandler3p!).
PL_csighandlerp: PL_csighandlerp — PERLVARI(G, csighandlerp, Sighandler_t)
PL_csighandlerp_ptr: *mut accessor for PL_csighandlerp (read form: PL_csighandlerp!).
PL_ctype_name: PL_ctype_name — PERLVARI(I, ctype_name, const char*)
PL_ctype_name_ptr: *mut accessor for PL_ctype_name (read form: PL_ctype_name!).
PL_cur_locale_obj: PL_cur_locale_obj — PERLVARI(I, cur_locale_obj, locale_t)
PL_cur_locale_obj_ptr: *mut accessor for PL_cur_locale_obj (read form: PL_cur_locale_obj!).
PL_curcop: PL_curcop — PERLVAR(I, curcop, COP*)
PL_curcop_ptr: *mut accessor for PL_curcop (read form: PL_curcop!).
PL_curcopdb: PL_curcopdb — PERLVARI(I, curcopdb, COP*)
PL_curcopdb_ptr: *mut accessor for PL_curcopdb (read form: PL_curcopdb!).
PL_curinterp: PL_curinterp — PERLVARI(G, curinterp, PerlInterpreter*)
PL_curinterp_ptr: *mut accessor for PL_curinterp (read form: PL_curinterp!).
PL_curpad: PL_curpad — PERLVAR(I, curpad, SV**)
PL_curpad_ptr: *mut accessor for PL_curpad (read form: PL_curpad!).
PL_curpm: PL_curpm — PERLVAR(I, curpm, PMOP*)
PL_curpm_ptr: *mut accessor for PL_curpm (read form: PL_curpm!).
PL_curpm_under: PL_curpm_under — PERLVAR(I, curpm_under, PMOP*)
PL_curpm_under_ptr: *mut accessor for PL_curpm_under (read form: PL_curpm_under!).
PL_curstack: PL_curstack — PERLVAR(I, curstack, AV*)
PL_curstack_ptr: *mut accessor for PL_curstack (read form: PL_curstack!).
PL_curstackinfo: PL_curstackinfo — PERLVAR(I, curstackinfo, PERL_SI*)
PL_curstackinfo_ptr: *mut accessor for PL_curstackinfo (read form: PL_curstackinfo!).
PL_curstash: PL_curstash — PERLVAR(I, curstash, HV*)
PL_curstash_ptr: *mut accessor for PL_curstash (read form: PL_curstash!).
PL_curstname: PL_curstname — PERLVAR(I, curstname, SV*)
PL_curstname_ptr: *mut accessor for PL_curstname (read form: PL_curstname!).
PL_custom_op_descs: PL_custom_op_descs — PERLVAR(I, custom_op_descs, HV*)
PL_custom_op_descs_ptr: *mut accessor for PL_custom_op_descs (read form: PL_custom_op_descs!).
PL_custom_op_names: PL_custom_op_names — PERLVAR(I, custom_op_names, HV*)
PL_custom_op_names_ptr: *mut accessor for PL_custom_op_names (read form: PL_custom_op_names!).
PL_custom_ops: PL_custom_ops — PERLVAR(I, custom_ops, HV*)
PL_custom_ops_ptr: *mut accessor for PL_custom_ops (read form: PL_custom_ops!).
PL_cv_has_eval: PL_cv_has_eval — PERLVARI(I, cv_has_eval, bool)
PL_cv_has_eval_ptr: *mut accessor for PL_cv_has_eval (read form: PL_cv_has_eval!).
PL_dbargs: PL_dbargs — PERLVAR(I, dbargs, AV*)
PL_dbargs_ptr: *mut accessor for PL_dbargs (read form: PL_dbargs!).
PL_debstash: PL_debstash — PERLVAR(I, debstash, HV*)
PL_debstash_ptr: *mut accessor for PL_debstash (read form: PL_debstash!).
PL_debug: PL_debug — PERLVAR(I, debug, volatile U32)
PL_debug_pad: PL_debug_pad — PERLVAR(I, debug_pad, struct perl_debug_pad)
PL_debug_pad_ptr: *mut accessor for PL_debug_pad (read form: PL_debug_pad!).
PL_debug_ptr: *mut accessor for PL_debug (read form: PL_debug!).
PL_def_layerlist: PL_def_layerlist — PERLVARI(I, def_layerlist, PerlIO_list_t*)
PL_def_layerlist_ptr: *mut accessor for PL_def_layerlist (read form: PL_def_layerlist!).
PL_defgv: PL_defgv — PERLVAR(I, defgv, GV*)
PL_defgv_ptr: *mut accessor for PL_defgv (read form: PL_defgv!).
PL_defoutgv: PL_defoutgv — PERLVAR(I, defoutgv, GV*)
PL_defoutgv_ptr: *mut accessor for PL_defoutgv (read form: PL_defoutgv!).
PL_defstash: PL_defstash — PERLVAR(I, defstash, HV*)
PL_defstash_ptr: *mut accessor for PL_defstash (read form: PL_defstash!).
PL_delaymagic: PL_delaymagic — PERLVAR(I, delaymagic, U16)
PL_delaymagic_egid: PL_delaymagic_egid — PERLVAR(I, delaymagic_egid, Gid_t)
PL_delaymagic_egid_ptr: *mut accessor for PL_delaymagic_egid (read form: PL_delaymagic_egid!).
PL_delaymagic_euid: PL_delaymagic_euid — PERLVAR(I, delaymagic_euid, Uid_t)
PL_delaymagic_euid_ptr: *mut accessor for PL_delaymagic_euid (read form: PL_delaymagic_euid!).
PL_delaymagic_gid: PL_delaymagic_gid — PERLVAR(I, delaymagic_gid, Gid_t)
PL_delaymagic_gid_ptr: *mut accessor for PL_delaymagic_gid (read form: PL_delaymagic_gid!).
PL_delaymagic_ptr: *mut accessor for PL_delaymagic (read form: PL_delaymagic!).
PL_delaymagic_uid: PL_delaymagic_uid — PERLVAR(I, delaymagic_uid, Uid_t)
PL_delaymagic_uid_ptr: *mut accessor for PL_delaymagic_uid (read form: PL_delaymagic_uid!).
PL_destroyhook: PL_destroyhook — PERLVARI(I, destroyhook, destroyable_proc_t)
PL_destroyhook_ptr: *mut accessor for PL_destroyhook (read form: PL_destroyhook!).
PL_diehook: PL_diehook — PERLVAR(I, diehook, SV*)
PL_diehook_ptr: *mut accessor for PL_diehook (read form: PL_diehook!).
PL_do_undump: PL_do_undump — PERLVARI(G, do_undump, bool)
PL_do_undump_ptr: *mut accessor for PL_do_undump (read form: PL_do_undump!).
PL_dollarzero_mutex: PL_dollarzero_mutex — PERLVAR(G, dollarzero_mutex, perl_mutex)
PL_dollarzero_mutex_ptr: *mut accessor for PL_dollarzero_mutex (read form: PL_dollarzero_mutex!).
PL_doswitches: PL_doswitches — PERLVAR(I, doswitches, bool)
PL_doswitches_ptr: *mut accessor for PL_doswitches (read form: PL_doswitches!).
PL_dowarn: PL_dowarn — PERLVAR(I, dowarn, U8)
PL_dowarn_ptr: *mut accessor for PL_dowarn (read form: PL_dowarn!).
PL_dump_re_max_len: PL_dump_re_max_len — PERLVARI(I, dump_re_max_len, STRLEN)
PL_dump_re_max_len_ptr: *mut accessor for PL_dump_re_max_len (read form: PL_dump_re_max_len!).
PL_dumpindent: PL_dumpindent — PERLVARI(I, dumpindent, U16)
PL_dumpindent_ptr: *mut accessor for PL_dumpindent (read form: PL_dumpindent!).
PL_e_script: PL_e_script — PERLVAR(I, e_script, SV*)
PL_e_script_ptr: *mut accessor for PL_e_script (read form: PL_e_script!).
PL_efloatbuf: PL_efloatbuf — PERLVAR(I, efloatbuf, char*)
PL_efloatbuf_ptr: *mut accessor for PL_efloatbuf (read form: PL_efloatbuf!).
PL_efloatsize: PL_efloatsize — PERLVAR(I, efloatsize, STRLEN)
PL_efloatsize_ptr: *mut accessor for PL_efloatsize (read form: PL_efloatsize!).
PL_endav: PL_endav — PERLVAR(I, endav, AV*)
PL_endav_ptr: *mut accessor for PL_endav (read form: PL_endav!).
PL_env_mutex: PL_env_mutex — PERLVAR(G, env_mutex, perl_RnW1_mutex_t)
PL_env_mutex_ptr: *mut accessor for PL_env_mutex (read form: PL_env_mutex!).
PL_envgv: PL_envgv — PERLVAR(I, envgv, GV*)
PL_envgv_ptr: *mut accessor for PL_envgv (read form: PL_envgv!).
PL_errgv: PL_errgv — PERLVAR(I, errgv, GV*)
PL_errgv_ptr: *mut accessor for PL_errgv (read form: PL_errgv!).
PL_errors: PL_errors — PERLVARI(I, errors, SV*)
PL_errors_ptr: *mut accessor for PL_errors (read form: PL_errors!).
PL_eval_begin_nest_depth: PL_eval_begin_nest_depth — PERLVARI(I, eval_begin_nest_depth, U32)
PL_eval_begin_nest_depth_ptr: *mut accessor for PL_eval_begin_nest_depth (read form: PL_eval_begin_nest_depth!).
PL_eval_root: PL_eval_root — PERLVAR(I, eval_root, OP*)
PL_eval_root_ptr: *mut accessor for PL_eval_root (read form: PL_eval_root!).
PL_eval_start: PL_eval_start — PERLVAR(I, eval_start, OP*)
PL_eval_start_ptr: *mut accessor for PL_eval_start (read form: PL_eval_start!).
PL_evalseq: PL_evalseq — PERLVARI(I, evalseq, U32)
PL_evalseq_ptr: *mut accessor for PL_evalseq (read form: PL_evalseq!).
PL_exit_flags: PL_exit_flags — PERLVAR(I, exit_flags, U8)
PL_exit_flags_ptr: *mut accessor for PL_exit_flags (read form: PL_exit_flags!).
PL_exitlist: PL_exitlist — PERLVARI(I, exitlist, PerlExitListEntry*)
PL_exitlist_ptr: *mut accessor for PL_exitlist (read form: PL_exitlist!).
PL_exitlistlen: PL_exitlistlen — PERLVARI(I, exitlistlen, I32)
PL_exitlistlen_ptr: *mut accessor for PL_exitlistlen (read form: PL_exitlistlen!).
PL_fdpid: PL_fdpid — PERLVAR(I, fdpid, AV*)
PL_fdpid_ptr: *mut accessor for PL_fdpid (read form: PL_fdpid!).
PL_filemode: PL_filemode — PERLVAR(I, filemode, int)
PL_filemode_ptr: *mut accessor for PL_filemode (read form: PL_filemode!).
PL_firstgv: PL_firstgv — PERLVAR(I, firstgv, GV*)
PL_firstgv_ptr: *mut accessor for PL_firstgv (read form: PL_firstgv!).
PL_fold_locale: PL_fold_locale — PERLVARA(I, fold_locale, 256, U8)
PL_fold_locale_ptr: *mut accessor for PL_fold_locale (read form: PL_fold_locale!).
PL_forkprocess: PL_forkprocess — PERLVAR(I, forkprocess, int)
PL_forkprocess_ptr: *mut accessor for PL_forkprocess (read form: PL_forkprocess!).
PL_formtarget: PL_formtarget — PERLVAR(I, formtarget, SV*)
PL_formtarget_ptr: *mut accessor for PL_formtarget (read form: PL_formtarget!).
PL_generation: PL_generation — PERLVARI(I, generation, int)
PL_generation_ptr: *mut accessor for PL_generation (read form: PL_generation!).
PL_gensym: PL_gensym — PERLVARI(I, gensym, I32)
PL_gensym_ptr: *mut accessor for PL_gensym (read form: PL_gensym!).
PL_globalstash: PL_globalstash — PERLVAR(I, globalstash, HV*)
PL_globalstash_ptr: *mut accessor for PL_globalstash (read form: PL_globalstash!).
PL_globhook: PL_globhook — PERLVARI(I, globhook, globhook_t)
PL_globhook_ptr: *mut accessor for PL_globhook (read form: PL_globhook!).
PL_hash_rand_bits: PL_hash_rand_bits — PERLVARI(I, hash_rand_bits, UV)
PL_hash_rand_bits_enabled: PL_hash_rand_bits_enabled — PERLVARI(I, hash_rand_bits_enabled, U8)
PL_hash_rand_bits_enabled_ptr: *mut accessor for PL_hash_rand_bits_enabled (read form: PL_hash_rand_bits_enabled!).
PL_hash_rand_bits_ptr: *mut accessor for PL_hash_rand_bits (read form: PL_hash_rand_bits!).
PL_hash_seed_set: PL_hash_seed_set — PERLVARI(G, hash_seed_set, bool)
PL_hash_seed_set_ptr: *mut accessor for PL_hash_seed_set (read form: PL_hash_seed_set!).
PL_hash_seed_w: PL_hash_seed_w — PERLVARA(G, hash_seed_w, PERL_HASH_SEED_WORDS, PVT__PERL_HASH_WORD_TYPE)
PL_hash_seed_w_ptr: *mut accessor for PL_hash_seed_w (read form: PL_hash_seed_w!).
PL_hash_state_w: PL_hash_state_w — PERLVARA(G, hash_state_w, PERL_HASH_STATE_WORDS, PVT__PERL_HASH_WORD_TYPE)
PL_hash_state_w_ptr: *mut accessor for PL_hash_state_w (read form: PL_hash_state_w!).
PL_hintgv: PL_hintgv — PERLVAR(I, hintgv, GV*)
PL_hintgv_ptr: *mut accessor for PL_hintgv (read form: PL_hintgv!).
PL_hints_mutex: PL_hints_mutex — PERLVAR(G, hints_mutex, perl_mutex)
PL_hints_mutex_ptr: *mut accessor for PL_hints_mutex (read form: PL_hints_mutex!).
PL_hook__require__after: PL_hook__require__after — PERLVARI(I, hook__require__after, SV*)
PL_hook__require__after_ptr: *mut accessor for PL_hook__require__after (read form: PL_hook__require__after!).
PL_hook__require__before: PL_hook__require__before — PERLVARI(I, hook__require__before, SV*)
PL_hook__require__before_ptr: *mut accessor for PL_hook__require__before (read form: PL_hook__require__before!).
PL_hv_fetch_ent_mh: PL_hv_fetch_ent_mh — PERLVAR(I, hv_fetch_ent_mh, HE*)
PL_hv_fetch_ent_mh_ptr: *mut accessor for PL_hv_fetch_ent_mh (read form: PL_hv_fetch_ent_mh!).
PL_in_clean_all: PL_in_clean_all — PERLVARI(I, in_clean_all, bool)
PL_in_clean_all_ptr: *mut accessor for PL_in_clean_all (read form: PL_in_clean_all!).
PL_in_clean_objs: PL_in_clean_objs — PERLVARI(I, in_clean_objs, bool)
PL_in_clean_objs_ptr: *mut accessor for PL_in_clean_objs (read form: PL_in_clean_objs!).
PL_in_eval: PL_in_eval — PERLVAR(I, in_eval, U8)
PL_in_eval_ptr: *mut accessor for PL_in_eval (read form: PL_in_eval!).
PL_in_load_module: PL_in_load_module — PERLVARI(I, in_load_module, bool)
PL_in_load_module_ptr: *mut accessor for PL_in_load_module (read form: PL_in_load_module!).
PL_in_some_fold: PL_in_some_fold — PERLVAR(I, in_some_fold, SV*)
PL_in_some_fold_ptr: *mut accessor for PL_in_some_fold (read form: PL_in_some_fold!).
PL_in_utf8_COLLATE_locale: PL_in_utf8_COLLATE_locale — PERLVAR(I, in_utf8_COLLATE_locale, bool)
PL_in_utf8_COLLATE_locale_ptr: *mut accessor for PL_in_utf8_COLLATE_locale (read form: PL_in_utf8_COLLATE_locale!).
PL_in_utf8_CTYPE_locale: PL_in_utf8_CTYPE_locale — PERLVARI(I, in_utf8_CTYPE_locale, bool)
PL_in_utf8_CTYPE_locale_ptr: *mut accessor for PL_in_utf8_CTYPE_locale (read form: PL_in_utf8_CTYPE_locale!).
PL_in_utf8_turkic_locale: PL_in_utf8_turkic_locale — PERLVARI(I, in_utf8_turkic_locale, bool)
PL_in_utf8_turkic_locale_ptr: *mut accessor for PL_in_utf8_turkic_locale (read form: PL_in_utf8_turkic_locale!).
PL_incgv: PL_incgv — PERLVAR(I, incgv, GV*)
PL_incgv_ptr: *mut accessor for PL_incgv (read form: PL_incgv!).
PL_infix_plugin: PL_infix_plugin — PERLVARI(G, infix_plugin, Perl_infix_plugin_t)
PL_infix_plugin_ptr: *mut accessor for PL_infix_plugin (read form: PL_infix_plugin!).
PL_initav: PL_initav — PERLVAR(I, initav, AV*)
PL_initav_ptr: *mut accessor for PL_initav (read form: PL_initav!).
PL_inplace: PL_inplace — PERLVAR(I, inplace, char*)
PL_inplace_ptr: *mut accessor for PL_inplace (read form: PL_inplace!).
PL_internal_random_state: PL_internal_random_state — PERLVAR(I, internal_random_state, PL_RANDOM_STATE_TYPE)
PL_internal_random_state_ptr: *mut accessor for PL_internal_random_state (read form: PL_internal_random_state!).
PL_isarev: PL_isarev — PERLVARI(I, isarev, HV*)
PL_isarev_ptr: *mut accessor for PL_isarev (read form: PL_isarev!).
PL_keyword_plugin: PL_keyword_plugin — PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t)
PL_keyword_plugin_mutex: PL_keyword_plugin_mutex — PERLVAR(G, keyword_plugin_mutex, perl_mutex)
PL_keyword_plugin_mutex_ptr: *mut accessor for PL_keyword_plugin_mutex (read form: PL_keyword_plugin_mutex!).
PL_keyword_plugin_ptr: *mut accessor for PL_keyword_plugin (read form: PL_keyword_plugin!).
PL_known_layers: PL_known_layers — PERLVARI(I, known_layers, PerlIO_list_t*)
PL_known_layers_ptr: *mut accessor for PL_known_layers (read form: PL_known_layers!).
PL_langinfo_sv: PL_langinfo_sv — PERLVARI(I, langinfo_sv, SV*)
PL_langinfo_sv_ptr: *mut accessor for PL_langinfo_sv (read form: PL_langinfo_sv!).
PL_last_in_gv: PL_last_in_gv — PERLVAR(I, last_in_gv, GV*)
PL_last_in_gv_ptr: *mut accessor for PL_last_in_gv (read form: PL_last_in_gv!).
PL_lastfd: PL_lastfd — PERLVAR(I, lastfd, int)
PL_lastfd_ptr: *mut accessor for PL_lastfd (read form: PL_lastfd!).
PL_lastgotoprobe: PL_lastgotoprobe — PERLVAR(I, lastgotoprobe, OP*)
PL_lastgotoprobe_ptr: *mut accessor for PL_lastgotoprobe (read form: PL_lastgotoprobe!).
PL_laststatval: PL_laststatval — PERLVARI(I, laststatval, int)
PL_laststatval_ptr: *mut accessor for PL_laststatval (read form: PL_laststatval!).
PL_laststype: PL_laststype — PERLVARI(I, laststype, U16)
PL_laststype_ptr: *mut accessor for PL_laststype (read form: PL_laststype!).
PL_locale_mutex: PL_locale_mutex — PERLVAR(G, locale_mutex, perl_mutex)
PL_locale_mutex_depth: PL_locale_mutex_depth — PERLVARI(I, locale_mutex_depth, int)
PL_locale_mutex_depth_ptr: *mut accessor for PL_locale_mutex_depth (read form: PL_locale_mutex_depth!).
PL_locale_mutex_ptr: *mut accessor for PL_locale_mutex (read form: PL_locale_mutex!).
PL_localizing: PL_localizing — PERLVAR(I, localizing, U8)
PL_localizing_ptr: *mut accessor for PL_localizing (read form: PL_localizing!).
PL_localpatches: PL_localpatches — PERLVAR(I, localpatches, const char*const*)
PL_localpatches_ptr: *mut accessor for PL_localpatches (read form: PL_localpatches!).
PL_lockhook: PL_lockhook — PERLVARI(I, lockhook, share_proc_t)
PL_lockhook_ptr: *mut accessor for PL_lockhook (read form: PL_lockhook!).
PL_main_cv: PL_main_cv — PERLVAR(I, main_cv, CV*)
PL_main_cv_ptr: *mut accessor for PL_main_cv (read form: PL_main_cv!).
PL_main_root: PL_main_root — PERLVAR(I, main_root, OP*)
PL_main_root_ptr: *mut accessor for PL_main_root (read form: PL_main_root!).
PL_main_start: PL_main_start — PERLVAR(I, main_start, OP*)
PL_main_start_ptr: *mut accessor for PL_main_start (read form: PL_main_start!).
PL_mainstack: PL_mainstack — PERLVAR(I, mainstack, AV*)
PL_mainstack_ptr: *mut accessor for PL_mainstack (read form: PL_mainstack!).
PL_markstack: PL_markstack — PERLVAR(I, markstack, Stack_off_t*)
PL_markstack_max: PL_markstack_max — PERLVAR(I, markstack_max, Stack_off_t*)
PL_markstack_max_ptr: *mut accessor for PL_markstack_max (read form: PL_markstack_max!).
PL_markstack_ptr: PL_markstack_ptr — PERLVAR(I, markstack_ptr, Stack_off_t*)
PL_markstack_ptr_ptr: *mut accessor for PL_markstack_ptr (read form: PL_markstack_ptr!).
PL_max_intro_pending: PL_max_intro_pending — PERLVAR(I, max_intro_pending, PADOFFSET)
PL_max_intro_pending_ptr: *mut accessor for PL_max_intro_pending (read form: PL_max_intro_pending!).
PL_maxsysfd: PL_maxsysfd — PERLVARI(I, maxsysfd, I32)
PL_maxsysfd_ptr: *mut accessor for PL_maxsysfd (read form: PL_maxsysfd!).
PL_mbrlen_ps: PL_mbrlen_ps — PERLVAR(I, mbrlen_ps, mbstate_t)
PL_mbrlen_ps_ptr: *mut accessor for PL_mbrlen_ps (read form: PL_mbrlen_ps!).
PL_mbrtowc_ps: PL_mbrtowc_ps — PERLVAR(I, mbrtowc_ps, mbstate_t)
PL_mbrtowc_ps_ptr: *mut accessor for PL_mbrtowc_ps (read form: PL_mbrtowc_ps!).
PL_memory_debug_header: PL_memory_debug_header — PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
PL_memory_debug_header_ptr: *mut accessor for PL_memory_debug_header (read form: PL_memory_debug_header!).
PL_mess_sv: PL_mess_sv — PERLVAR(I, mess_sv, SV*)
PL_mess_sv_ptr: *mut accessor for PL_mess_sv (read form: PL_mess_sv!).
PL_min_intro_pending: PL_min_intro_pending — PERLVAR(I, min_intro_pending, PADOFFSET)
PL_min_intro_pending_ptr: *mut accessor for PL_min_intro_pending (read form: PL_min_intro_pending!).
PL_minus_E: PL_minus_E — PERLVAR(I, minus_E, bool)
PL_minus_E_ptr: *mut accessor for PL_minus_E (read form: PL_minus_E!).
PL_minus_F: PL_minus_F — PERLVAR(I, minus_F, bool)
PL_minus_F_ptr: *mut accessor for PL_minus_F (read form: PL_minus_F!).
PL_minus_a: PL_minus_a — PERLVAR(I, minus_a, bool)
PL_minus_a_ptr: *mut accessor for PL_minus_a (read form: PL_minus_a!).
PL_minus_c: PL_minus_c — PERLVAR(I, minus_c, bool)
PL_minus_c_ptr: *mut accessor for PL_minus_c (read form: PL_minus_c!).
PL_minus_l: PL_minus_l — PERLVAR(I, minus_l, bool)
PL_minus_l_ptr: *mut accessor for PL_minus_l (read form: PL_minus_l!).
PL_minus_n: PL_minus_n — PERLVAR(I, minus_n, bool)
PL_minus_n_ptr: *mut accessor for PL_minus_n (read form: PL_minus_n!).
PL_minus_p: PL_minus_p — PERLVAR(I, minus_p, bool)
PL_minus_p_ptr: *mut accessor for PL_minus_p (read form: PL_minus_p!).
PL_mmap_page_size: PL_mmap_page_size — PERLVARI(G, mmap_page_size, IV)
PL_mmap_page_size_ptr: *mut accessor for PL_mmap_page_size (read form: PL_mmap_page_size!).
PL_modcount: PL_modcount — PERLVAR(I, modcount, I32)
PL_modcount_ptr: *mut accessor for PL_modcount (read form: PL_modcount!).
PL_modglobal: PL_modglobal — PERLVAR(I, modglobal, HV*)
PL_modglobal_ptr: *mut accessor for PL_modglobal (read form: PL_modglobal!).
PL_multideref_pc: PL_multideref_pc — PERLVAR(I, multideref_pc, UNOP_AUX_item*)
PL_multideref_pc_ptr: *mut accessor for PL_multideref_pc (read form: PL_multideref_pc!).
PL_my_ctx_mutex: PL_my_ctx_mutex — PERLVAR(G, my_ctx_mutex, perl_mutex)
PL_my_ctx_mutex_ptr: *mut accessor for PL_my_ctx_mutex (read form: PL_my_ctx_mutex!).
PL_my_cxt_index: PL_my_cxt_index — PERLVARI(G, my_cxt_index, int)
PL_my_cxt_index_ptr: *mut accessor for PL_my_cxt_index (read form: PL_my_cxt_index!).
PL_my_cxt_list: PL_my_cxt_list — PERLVARI(I, my_cxt_list, void**)
PL_my_cxt_list_ptr: *mut accessor for PL_my_cxt_list (read form: PL_my_cxt_list!).
PL_my_cxt_size: PL_my_cxt_size — PERLVARI(I, my_cxt_size, int)
PL_my_cxt_size_ptr: *mut accessor for PL_my_cxt_size (read form: PL_my_cxt_size!).
PL_my_environ: PL_my_environ — PERLVARI(G, my_environ, char**)
PL_my_environ_ptr: *mut accessor for PL_my_environ (read form: PL_my_environ!).
PL_na: PL_na — PERLVAR(I, na, STRLEN)
PL_na_ptr: *mut accessor for PL_na (read form: PL_na!).
PL_nomemok: PL_nomemok — PERLVAR(I, nomemok, bool)
PL_nomemok_ptr: *mut accessor for PL_nomemok (read form: PL_nomemok!).
PL_numeric_name: PL_numeric_name — PERLVAR(I, numeric_name, char*)
PL_numeric_name_ptr: *mut accessor for PL_numeric_name (read form: PL_numeric_name!).
PL_numeric_radix_sv: PL_numeric_radix_sv — PERLVAR(I, numeric_radix_sv, SV*)
PL_numeric_radix_sv_ptr: *mut accessor for PL_numeric_radix_sv (read form: PL_numeric_radix_sv!).
PL_numeric_standard: PL_numeric_standard — PERLVARI(I, numeric_standard, int)
PL_numeric_standard_ptr: *mut accessor for PL_numeric_standard (read form: PL_numeric_standard!).
PL_numeric_underlying: PL_numeric_underlying — PERLVARI(I, numeric_underlying, bool)
PL_numeric_underlying_is_standard: PL_numeric_underlying_is_standard — PERLVARI(I, numeric_underlying_is_standard, bool)
PL_numeric_underlying_is_standard_ptr: *mut accessor for PL_numeric_underlying_is_standard (read form: PL_numeric_underlying_is_standard!).
PL_numeric_underlying_ptr: *mut accessor for PL_numeric_underlying (read form: PL_numeric_underlying!).
PL_ofsgv: PL_ofsgv — PERLVAR(I, ofsgv, GV*)
PL_ofsgv_ptr: *mut accessor for PL_ofsgv (read form: PL_ofsgv!).
PL_oldname: PL_oldname — PERLVAR(I, oldname, char*)
PL_oldname_ptr: *mut accessor for PL_oldname (read form: PL_oldname!).
PL_op: PL_op — PERLVAR(I, op, OP*)
PL_op_mask: PL_op_mask — PERLVARI(I, op_mask, char*)
PL_op_mask_ptr: *mut accessor for PL_op_mask (read form: PL_op_mask!).
PL_op_mutex: PL_op_mutex — PERLVAR(G, op_mutex, perl_mutex)
PL_op_mutex_ptr: *mut accessor for PL_op_mutex (read form: PL_op_mutex!).
PL_op_ptr: *mut accessor for PL_op (read form: PL_op!).
PL_op_seq: PL_op_seq — PERLVARI(G, op_seq, UV)
PL_op_seq_ptr: *mut accessor for PL_op_seq (read form: PL_op_seq!).
PL_op_sequence: PL_op_sequence — PERLVARI(G, op_sequence, HV*)
PL_op_sequence_ptr: *mut accessor for PL_op_sequence (read form: PL_op_sequence!).
PL_opfreehook: PL_opfreehook — PERLVARI(I, opfreehook, Perl_ophook_t)
PL_opfreehook_ptr: *mut accessor for PL_opfreehook (read form: PL_opfreehook!).
PL_origalen: PL_origalen — PERLVAR(I, origalen, U32)
PL_origalen_ptr: *mut accessor for PL_origalen (read form: PL_origalen!).
PL_origargc: PL_origargc — PERLVAR(I, origargc, int)
PL_origargc_ptr: *mut accessor for PL_origargc (read form: PL_origargc!).
PL_origargv: PL_origargv — PERLVAR(I, origargv, char**)
PL_origargv_ptr: *mut accessor for PL_origargv (read form: PL_origargv!).
PL_origenviron: PL_origenviron — PERLVARI(G, origenviron, char**)
PL_origenviron_ptr: *mut accessor for PL_origenviron (read form: PL_origenviron!).
PL_origfilename: PL_origfilename — PERLVAR(I, origfilename, char*)
PL_origfilename_ptr: *mut accessor for PL_origfilename (read form: PL_origfilename!).
PL_ors_sv: PL_ors_sv — PERLVAR(I, ors_sv, SV*)
PL_ors_sv_ptr: *mut accessor for PL_ors_sv (read form: PL_ors_sv!).
PL_osname: PL_osname — PERLVAR(I, osname, char*)
PL_osname_ptr: *mut accessor for PL_osname (read form: PL_osname!).
PL_pad_reset_pending: PL_pad_reset_pending — PERLVAR(I, pad_reset_pending, bool)
PL_pad_reset_pending_ptr: *mut accessor for PL_pad_reset_pending (read form: PL_pad_reset_pending!).
PL_padix: PL_padix — PERLVAR(I, padix, PADOFFSET)
PL_padix_floor: PL_padix_floor — PERLVAR(I, padix_floor, PADOFFSET)
PL_padix_floor_ptr: *mut accessor for PL_padix_floor (read form: PL_padix_floor!).
PL_padix_ptr: *mut accessor for PL_padix (read form: PL_padix!).
PL_padlist_generation: PL_padlist_generation — PERLVARI(I, padlist_generation, U32)
PL_padlist_generation_ptr: *mut accessor for PL_padlist_generation (read form: PL_padlist_generation!).
PL_padname_const: PL_padname_const — PERLVAR(I, padname_const, PADNAME)
PL_padname_const_ptr: *mut accessor for PL_padname_const (read form: PL_padname_const!).
PL_padname_undef: PL_padname_undef — PERLVAR(I, padname_undef, PADNAME)
PL_padname_undef_ptr: *mut accessor for PL_padname_undef (read form: PL_padname_undef!).
PL_parser: PL_parser — PERLVAR(I, parser, yy_parser*)
PL_parser_ptr: *mut accessor for PL_parser (read form: PL_parser!).
PL_patchlevel: PL_patchlevel — PERLVAR(I, patchlevel, SV*)
PL_patchlevel_ptr: *mut accessor for PL_patchlevel (read form: PL_patchlevel!).
PL_peepp: PL_peepp — PERLVARI(I, peepp, peep_t)
PL_peepp_ptr: *mut accessor for PL_peepp (read form: PL_peepp!).
PL_perl_destruct_level: PL_perl_destruct_level — PERLVARI(I, perl_destruct_level, signed char)
PL_perl_destruct_level_ptr: *mut accessor for PL_perl_destruct_level (read form: PL_perl_destruct_level!).
PL_perldb: PL_perldb — PERLVAR(I, perldb, U32)
PL_perldb_ptr: *mut accessor for PL_perldb (read form: PL_perldb!).
PL_perlio: PL_perlio — PERLVARI(I, perlio, PerlIOl*)
PL_perlio_debug_fd: PL_perlio_debug_fd — PERLVARI(G, perlio_debug_fd, int)
PL_perlio_debug_fd_ptr: *mut accessor for PL_perlio_debug_fd (read form: PL_perlio_debug_fd!).
PL_perlio_fd_refcnt: PL_perlio_fd_refcnt — PERLVARI(G, perlio_fd_refcnt, int*)
PL_perlio_fd_refcnt_ptr: *mut accessor for PL_perlio_fd_refcnt (read form: PL_perlio_fd_refcnt!).
PL_perlio_fd_refcnt_size: PL_perlio_fd_refcnt_size — PERLVARI(G, perlio_fd_refcnt_size, int)
PL_perlio_fd_refcnt_size_ptr: *mut accessor for PL_perlio_fd_refcnt_size (read form: PL_perlio_fd_refcnt_size!).
PL_perlio_mutex: PL_perlio_mutex — PERLVAR(G, perlio_mutex, perl_mutex)
PL_perlio_mutex_ptr: *mut accessor for PL_perlio_mutex (read form: PL_perlio_mutex!).
PL_perlio_ptr: *mut accessor for PL_perlio (read form: PL_perlio!).
PL_phase: PL_phase — PERLVARI(I, phase, enum perl_phase)
PL_phase_ptr: *mut accessor for PL_phase (read form: PL_phase!).
PL_preambleav: PL_preambleav — PERLVAR(I, preambleav, AV*)
PL_preambleav_ptr: *mut accessor for PL_preambleav (read form: PL_preambleav!).
PL_prevailing_version: PL_prevailing_version — PERLVAR(I, prevailing_version, U16)
PL_prevailing_version_ptr: *mut accessor for PL_prevailing_version (read form: PL_prevailing_version!).
PL_profiledata: PL_profiledata — PERLVARI(I, profiledata, U32*)
PL_profiledata_ptr: *mut accessor for PL_profiledata (read form: PL_profiledata!).
PL_psig_name: PL_psig_name — PERLVAR(I, psig_name, SV**)
PL_psig_name_ptr: *mut accessor for PL_psig_name (read form: PL_psig_name!).
PL_psig_pend: PL_psig_pend — PERLVAR(I, psig_pend, int*)
PL_psig_pend_ptr: *mut accessor for PL_psig_pend (read form: PL_psig_pend!).
PL_psig_ptr: PL_psig_ptr — PERLVAR(I, psig_ptr, SV**)
PL_psig_ptr_ptr: *mut accessor for PL_psig_ptr (read form: PL_psig_ptr!).
PL_ptr_table: PL_ptr_table — PERLVAR(I, ptr_table, PTR_TBL_t*)
PL_ptr_table_ptr: *mut accessor for PL_ptr_table (read form: PL_ptr_table!).
PL_random_state: PL_random_state — PERLVAR(I, random_state, PL_RANDOM_STATE_TYPE)
PL_random_state_ptr: *mut accessor for PL_random_state (read form: PL_random_state!).
PL_reentrant_buffer: PL_reentrant_buffer — PERLVAR(I, reentrant_buffer, REENTR*)
PL_reentrant_buffer_ptr: *mut accessor for PL_reentrant_buffer (read form: PL_reentrant_buffer!).
PL_reentrant_retint: PL_reentrant_retint — PERLVAR(I, reentrant_retint, int)
PL_reentrant_retint_ptr: *mut accessor for PL_reentrant_retint (read form: PL_reentrant_retint!).
PL_reg_curpm: PL_reg_curpm — PERLVARI(I, reg_curpm, PMOP*)
PL_reg_curpm_ptr: *mut accessor for PL_reg_curpm (read form: PL_reg_curpm!).
PL_regex_pad: PL_regex_pad — PERLVAR(I, regex_pad, SV**)
PL_regex_pad_ptr: *mut accessor for PL_regex_pad (read form: PL_regex_pad!).
PL_regex_padav: PL_regex_padav — PERLVAR(I, regex_padav, AV*)
PL_regex_padav_ptr: *mut accessor for PL_regex_padav (read form: PL_regex_padav!).
PL_registered_mros: PL_registered_mros — PERLVAR(I, registered_mros, HV*)
PL_registered_mros_ptr: *mut accessor for PL_registered_mros (read form: PL_registered_mros!).
PL_regmatch_slab: PL_regmatch_slab — PERLVARI(I, regmatch_slab, regmatch_slab*)
PL_regmatch_slab_ptr: *mut accessor for PL_regmatch_slab (read form: PL_regmatch_slab!).
PL_regmatch_state: PL_regmatch_state — PERLVAR(I, regmatch_state, regmatch_state*)
PL_regmatch_state_ptr: *mut accessor for PL_regmatch_state (read form: PL_regmatch_state!).
PL_replgv: PL_replgv — PERLVAR(I, replgv, GV*)
PL_replgv_ptr: *mut accessor for PL_replgv (read form: PL_replgv!).
PL_restartjmpenv: PL_restartjmpenv — PERLVAR(I, restartjmpenv, JMPENV*)
PL_restartjmpenv_ptr: *mut accessor for PL_restartjmpenv (read form: PL_restartjmpenv!).
PL_restartop: PL_restartop — PERLVAR(I, restartop, OP*)
PL_restartop_ptr: *mut accessor for PL_restartop (read form: PL_restartop!).
PL_rpeepp: PL_rpeepp — PERLVARI(I, rpeepp, peep_t)
PL_rpeepp_ptr: *mut accessor for PL_rpeepp (read form: PL_rpeepp!).
PL_rs: PL_rs — PERLVAR(I, rs, SV*)
PL_rs_ptr: *mut accessor for PL_rs (read form: PL_rs!).
PL_runops: PL_runops — PERLVARI(I, runops, runops_proc_t)
PL_runops_ptr: *mut accessor for PL_runops (read form: PL_runops!).
PL_savebegin: PL_savebegin — PERLVARI(I, savebegin, bool)
PL_savebegin_ptr: *mut accessor for PL_savebegin (read form: PL_savebegin!).
PL_savestack: PL_savestack — PERLVAR(I, savestack, ANY*)
PL_savestack_ix: PL_savestack_ix — PERLVAR(I, savestack_ix, I32)
PL_savestack_ix_ptr: *mut accessor for PL_savestack_ix (read form: PL_savestack_ix!).
PL_savestack_max: PL_savestack_max — PERLVAR(I, savestack_max, I32)
PL_savestack_max_ptr: *mut accessor for PL_savestack_max (read form: PL_savestack_max!).
PL_savestack_ptr: *mut accessor for PL_savestack (read form: PL_savestack!).
PL_scopestack: PL_scopestack — PERLVAR(I, scopestack, I32*)
PL_scopestack_ix: PL_scopestack_ix — PERLVAR(I, scopestack_ix, I32)
PL_scopestack_ix_ptr: *mut accessor for PL_scopestack_ix (read form: PL_scopestack_ix!).
PL_scopestack_max: PL_scopestack_max — PERLVAR(I, scopestack_max, I32)
PL_scopestack_max_ptr: *mut accessor for PL_scopestack_max (read form: PL_scopestack_max!).
PL_scopestack_name: PL_scopestack_name — PERLVARI(I, scopestack_name, const char**)
PL_scopestack_name_ptr: *mut accessor for PL_scopestack_name (read form: PL_scopestack_name!).
PL_scopestack_ptr: *mut accessor for PL_scopestack (read form: PL_scopestack!).
PL_scratch_langinfo: PL_scratch_langinfo — PERLVARI(I, scratch_langinfo, SV*)
PL_scratch_langinfo_ptr: *mut accessor for PL_scratch_langinfo (read form: PL_scratch_langinfo!).
PL_scratch_locale_obj: PL_scratch_locale_obj — PERLVARI(I, scratch_locale_obj, locale_t)
PL_scratch_locale_obj_ptr: *mut accessor for PL_scratch_locale_obj (read form: PL_scratch_locale_obj!).
PL_secondgv: PL_secondgv — PERLVAR(I, secondgv, GV*)
PL_secondgv_ptr: *mut accessor for PL_secondgv (read form: PL_secondgv!).
PL_setlocale_buf: PL_setlocale_buf — PERLVARI(I, setlocale_buf, char*)
PL_setlocale_buf_ptr: *mut accessor for PL_setlocale_buf (read form: PL_setlocale_buf!).
PL_setlocale_bufsize: PL_setlocale_bufsize — PERLVARI(I, setlocale_bufsize, Size_t)
PL_setlocale_bufsize_ptr: *mut accessor for PL_setlocale_bufsize (read form: PL_setlocale_bufsize!).
PL_sharehook: PL_sharehook — PERLVARI(I, sharehook, share_proc_t)
PL_sharehook_ptr: *mut accessor for PL_sharehook (read form: PL_sharehook!).
PL_sig_pending: PL_sig_pending — PERLVARI(I, sig_pending, int)
PL_sig_pending_ptr: *mut accessor for PL_sig_pending (read form: PL_sig_pending!).
PL_sigfpe_saved: PL_sigfpe_saved — PERLVAR(G, sigfpe_saved, Sighandler_t)
PL_sigfpe_saved_ptr: *mut accessor for PL_sigfpe_saved (read form: PL_sigfpe_saved!).
PL_sighandler1p: PL_sighandler1p — PERLVAR(I, sighandler1p, Sighandler1_t)
PL_sighandler1p_ptr: *mut accessor for PL_sighandler1p (read form: PL_sighandler1p!).
PL_sighandler3p: PL_sighandler3p — PERLVAR(I, sighandler3p, Sighandler3_t)
PL_sighandler3p_ptr: *mut accessor for PL_sighandler3p (read form: PL_sighandler3p!).
PL_sighandlerp: PL_sighandlerp — PERLVAR(I, sighandlerp, Sighandler_t)
PL_sighandlerp_ptr: *mut accessor for PL_sighandlerp (read form: PL_sighandlerp!).
PL_signalhook: PL_signalhook — PERLVARI(I, signalhook, despatch_signals_proc_t)
PL_signalhook_ptr: *mut accessor for PL_signalhook (read form: PL_signalhook!).
PL_signals: PL_signals — PERLVAR(I, signals, U32)
PL_signals_ptr: *mut accessor for PL_signals (read form: PL_signals!).
PL_sortcop: PL_sortcop — PERLVAR(I, sortcop, OP*)
PL_sortcop_ptr: *mut accessor for PL_sortcop (read form: PL_sortcop!).
PL_sortstash: PL_sortstash — PERLVAR(I, sortstash, HV*)
PL_sortstash_ptr: *mut accessor for PL_sortstash (read form: PL_sortstash!).
PL_splitstr: PL_splitstr — PERLVARI(I, splitstr, char*)
PL_splitstr_ptr: *mut accessor for PL_splitstr (read form: PL_splitstr!).
PL_srand_called: PL_srand_called — PERLVARI(I, srand_called, bool)
PL_srand_called_ptr: *mut accessor for PL_srand_called (read form: PL_srand_called!).
PL_srand_override: PL_srand_override — PERLVARI(I, srand_override, U32)
PL_srand_override_next: PL_srand_override_next — PERLVARI(I, srand_override_next, U32)
PL_srand_override_next_ptr: *mut accessor for PL_srand_override_next (read form: PL_srand_override_next!).
PL_srand_override_ptr: *mut accessor for PL_srand_override (read form: PL_srand_override!).
PL_stack_base: PL_stack_base — PERLVAR(I, stack_base, SV**)
PL_stack_base_ptr: *mut accessor for PL_stack_base (read form: PL_stack_base!).
PL_stack_max: PL_stack_max — PERLVAR(I, stack_max, SV**)
PL_stack_max_ptr: *mut accessor for PL_stack_max (read form: PL_stack_max!).
PL_stack_sp: PL_stack_sp — PERLVAR(I, stack_sp, SV**)
PL_stack_sp_ptr: *mut accessor for PL_stack_sp (read form: PL_stack_sp!).
PL_start_env: PL_start_env — PERLVAR(I, start_env, JMPENV)
PL_start_env_ptr: *mut accessor for PL_start_env (read form: PL_start_env!).
PL_stashcache: PL_stashcache — PERLVAR(I, stashcache, HV*)
PL_stashcache_ptr: *mut accessor for PL_stashcache (read form: PL_stashcache!).
PL_stashpad: PL_stashpad — PERLVAR(I, stashpad, HV**)
PL_stashpad_ptr: *mut accessor for PL_stashpad (read form: PL_stashpad!).
PL_stashpadix: PL_stashpadix — PERLVARI(I, stashpadix, PADOFFSET)
PL_stashpadix_ptr: *mut accessor for PL_stashpadix (read form: PL_stashpadix!).
PL_stashpadmax: PL_stashpadmax — PERLVARI(I, stashpadmax, PADOFFSET)
PL_stashpadmax_ptr: *mut accessor for PL_stashpadmax (read form: PL_stashpadmax!).
PL_statcache: PL_statcache — PERLVAR(I, statcache, Stat_t)
PL_statcache_ptr: *mut accessor for PL_statcache (read form: PL_statcache!).
PL_statgv: PL_statgv — PERLVAR(I, statgv, GV*)
PL_statgv_ptr: *mut accessor for PL_statgv (read form: PL_statgv!).
PL_statname: PL_statname — PERLVARI(I, statname, SV*)
PL_statname_ptr: *mut accessor for PL_statname (read form: PL_statname!).
PL_statusvalue: PL_statusvalue — PERLVAR(I, statusvalue, I32)
PL_statusvalue_posix: PL_statusvalue_posix — PERLVAR(I, statusvalue_posix, I32)
PL_statusvalue_posix_ptr: *mut accessor for PL_statusvalue_posix (read form: PL_statusvalue_posix!).
PL_statusvalue_ptr: *mut accessor for PL_statusvalue (read form: PL_statusvalue!).
PL_stderrgv: PL_stderrgv — PERLVAR(I, stderrgv, GV*)
PL_stderrgv_ptr: *mut accessor for PL_stderrgv (read form: PL_stderrgv!).
PL_stdingv: PL_stdingv — PERLVAR(I, stdingv, GV*)
PL_stdingv_ptr: *mut accessor for PL_stdingv (read form: PL_stdingv!).
PL_strategy_accept: PL_strategy_accept — PERLVARI(G, strategy_accept, int)
PL_strategy_accept_ptr: *mut accessor for PL_strategy_accept (read form: PL_strategy_accept!).
PL_strategy_dup: PL_strategy_dup — PERLVARI(G, strategy_dup, int)
PL_strategy_dup2: PL_strategy_dup2 — PERLVARI(G, strategy_dup2, int)
PL_strategy_dup2_ptr: *mut accessor for PL_strategy_dup2 (read form: PL_strategy_dup2!).
PL_strategy_dup_ptr: *mut accessor for PL_strategy_dup (read form: PL_strategy_dup!).
PL_strategy_mkstemp: PL_strategy_mkstemp — PERLVARI(G, strategy_mkstemp, int)
PL_strategy_mkstemp_ptr: *mut accessor for PL_strategy_mkstemp (read form: PL_strategy_mkstemp!).
PL_strategy_open: PL_strategy_open — PERLVARI(G, strategy_open, int)
PL_strategy_open3: PL_strategy_open3 — PERLVARI(G, strategy_open3, int)
PL_strategy_open3_ptr: *mut accessor for PL_strategy_open3 (read form: PL_strategy_open3!).
PL_strategy_open_ptr: *mut accessor for PL_strategy_open (read form: PL_strategy_open!).
PL_strategy_pipe: PL_strategy_pipe — PERLVARI(G, strategy_pipe, int)
PL_strategy_pipe_ptr: *mut accessor for PL_strategy_pipe (read form: PL_strategy_pipe!).
PL_strategy_socket: PL_strategy_socket — PERLVARI(G, strategy_socket, int)
PL_strategy_socket_ptr: *mut accessor for PL_strategy_socket (read form: PL_strategy_socket!).
PL_strategy_socketpair: PL_strategy_socketpair — PERLVARI(G, strategy_socketpair, int)
PL_strategy_socketpair_ptr: *mut accessor for PL_strategy_socketpair (read form: PL_strategy_socketpair!).
PL_strtab: PL_strtab — PERLVAR(I, strtab, HV*)
PL_strtab_ptr: *mut accessor for PL_strtab (read form: PL_strtab!).
PL_strxfrm_NUL_replacement: PL_strxfrm_NUL_replacement — PERLVARI(I, strxfrm_NUL_replacement, U8)
PL_strxfrm_NUL_replacement_ptr: *mut accessor for PL_strxfrm_NUL_replacement (read form: PL_strxfrm_NUL_replacement!).
PL_strxfrm_is_behaved: PL_strxfrm_is_behaved — PERLVARI(I, strxfrm_is_behaved, bool)
PL_strxfrm_is_behaved_ptr: *mut accessor for PL_strxfrm_is_behaved (read form: PL_strxfrm_is_behaved!).
PL_strxfrm_max_cp: PL_strxfrm_max_cp — PERLVARI(I, strxfrm_max_cp, U8)
PL_strxfrm_max_cp_ptr: *mut accessor for PL_strxfrm_max_cp (read form: PL_strxfrm_max_cp!).
PL_sub_generation: PL_sub_generation — PERLVARI(I, sub_generation, U32)
PL_sub_generation_ptr: *mut accessor for PL_sub_generation (read form: PL_sub_generation!).
PL_subline: PL_subline — PERLVAR(I, subline, I32)
PL_subline_ptr: *mut accessor for PL_subline (read form: PL_subline!).
PL_subname: PL_subname — PERLVAR(I, subname, SV*)
PL_subname_ptr: *mut accessor for PL_subname (read form: PL_subname!).
PL_sv_arenaroot: PL_sv_arenaroot — PERLVAR(I, sv_arenaroot, SV*)
PL_sv_arenaroot_ptr: *mut accessor for PL_sv_arenaroot (read form: PL_sv_arenaroot!).
PL_sv_consts: PL_sv_consts — PERLVARA(I, sv_consts, SV_CONSTS_COUNT, SV*)
PL_sv_consts_ptr: *mut accessor for PL_sv_consts (read form: PL_sv_consts!).
PL_sv_count: PL_sv_count — PERLVAR(I, sv_count, IV)
PL_sv_count_ptr: *mut accessor for PL_sv_count (read form: PL_sv_count!).
PL_sv_no: PL_sv_no — PERLVAR(I, sv_no, SV)
PL_sv_no_ptr: *mut accessor for PL_sv_no (read form: PL_sv_no!).
PL_sv_placeholder: PL_sv_placeholder — PERLVAR(G, sv_placeholder, SV)
PL_sv_placeholder_ptr: *mut accessor for PL_sv_placeholder (read form: PL_sv_placeholder!).
PL_sv_root: PL_sv_root — PERLVAR(I, sv_root, SV*)
PL_sv_root_ptr: *mut accessor for PL_sv_root (read form: PL_sv_root!).
PL_sv_undef: PL_sv_undef — PERLVAR(I, sv_undef, SV)
PL_sv_undef_ptr: *mut accessor for PL_sv_undef (read form: PL_sv_undef!).
PL_sv_yes: PL_sv_yes — PERLVAR(I, sv_yes, SV)
PL_sv_yes_ptr: *mut accessor for PL_sv_yes (read form: PL_sv_yes!).
PL_sv_zero: PL_sv_zero — PERLVAR(I, sv_zero, SV)
PL_sv_zero_ptr: *mut accessor for PL_sv_zero (read form: PL_sv_zero!).
PL_taint_warn: PL_taint_warn — PERLVAR(I, taint_warn, bool)
PL_taint_warn_ptr: *mut accessor for PL_taint_warn (read form: PL_taint_warn!).
PL_tainted: PL_tainted — PERLVARI(I, tainted, bool)
PL_tainted_ptr: *mut accessor for PL_tainted (read form: PL_tainted!).
PL_tainting: PL_tainting — PERLVAR(I, tainting, bool)
PL_tainting_ptr: *mut accessor for PL_tainting (read form: PL_tainting!).
PL_thr_key: PL_thr_key — PERLVAR(G, thr_key, perl_key)
PL_thr_key_ptr: *mut accessor for PL_thr_key (read form: PL_thr_key!).
PL_threadhook: PL_threadhook — PERLVARI(I, threadhook, thrhook_proc_t)
PL_threadhook_ptr: *mut accessor for PL_threadhook (read form: PL_threadhook!).
PL_tmps_floor: PL_tmps_floor — PERLVARI(I, tmps_floor, SSize_t)
PL_tmps_floor_ptr: *mut accessor for PL_tmps_floor (read form: PL_tmps_floor!).
PL_tmps_ix: PL_tmps_ix — PERLVARI(I, tmps_ix, SSize_t)
PL_tmps_ix_ptr: *mut accessor for PL_tmps_ix (read form: PL_tmps_ix!).
PL_tmps_max: PL_tmps_max — PERLVAR(I, tmps_max, SSize_t)
PL_tmps_max_ptr: *mut accessor for PL_tmps_max (read form: PL_tmps_max!).
PL_tmps_stack: PL_tmps_stack — PERLVAR(I, tmps_stack, SV**)
PL_tmps_stack_ptr: *mut accessor for PL_tmps_stack (read form: PL_tmps_stack!).
PL_top_env: PL_top_env — PERLVAR(I, top_env, JMPENV*)
PL_top_env_ptr: *mut accessor for PL_top_env (read form: PL_top_env!).
PL_toptarget: PL_toptarget — PERLVAR(I, toptarget, SV*)
PL_toptarget_ptr: *mut accessor for PL_toptarget (read form: PL_toptarget!).
PL_underlying_radix_sv: PL_underlying_radix_sv — PERLVAR(I, underlying_radix_sv, SV*)
PL_underlying_radix_sv_ptr: *mut accessor for PL_underlying_radix_sv (read form: PL_underlying_radix_sv!).
PL_unicode: PL_unicode — PERLVAR(I, unicode, U32)
PL_unicode_ptr: *mut accessor for PL_unicode (read form: PL_unicode!).
PL_unitcheckav: PL_unitcheckav — PERLVAR(I, unitcheckav, AV*)
PL_unitcheckav_ptr: *mut accessor for PL_unitcheckav (read form: PL_unitcheckav!).
PL_unitcheckav_save: PL_unitcheckav_save — PERLVARI(I, unitcheckav_save, AV*)
PL_unitcheckav_save_ptr: *mut accessor for PL_unitcheckav_save (read form: PL_unitcheckav_save!).
PL_unlockhook: PL_unlockhook — PERLVARI(I, unlockhook, share_proc_t)
PL_unlockhook_ptr: *mut accessor for PL_unlockhook (read form: PL_unlockhook!).
PL_unsafe: PL_unsafe — PERLVAR(I, unsafe, bool)
PL_unsafe_ptr: *mut accessor for PL_unsafe (read form: PL_unsafe!).
PL_user_def_props: PL_user_def_props — PERLVARI(G, user_def_props, HV*)
PL_user_def_props_aTHX: PL_user_def_props_aTHX — PERLVAR(G, user_def_props_aTHX, PerlInterpreter*)
PL_user_def_props_aTHX_ptr: *mut accessor for PL_user_def_props_aTHX (read form: PL_user_def_props_aTHX!).
PL_user_def_props_ptr: *mut accessor for PL_user_def_props (read form: PL_user_def_props!).
PL_user_prop_mutex: PL_user_prop_mutex — PERLVAR(G, user_prop_mutex, perl_mutex)
PL_user_prop_mutex_ptr: *mut accessor for PL_user_prop_mutex (read form: PL_user_prop_mutex!).
PL_utf8_charname_begin: PL_utf8_charname_begin — PERLVAR(I, utf8_charname_begin, SV*)
PL_utf8_charname_begin_ptr: *mut accessor for PL_utf8_charname_begin (read form: PL_utf8_charname_begin!).
PL_utf8_charname_continue: PL_utf8_charname_continue — PERLVAR(I, utf8_charname_continue, SV*)
PL_utf8_charname_continue_ptr: *mut accessor for PL_utf8_charname_continue (read form: PL_utf8_charname_continue!).
PL_utf8_foldclosures: PL_utf8_foldclosures — PERLVAR(I, utf8_foldclosures, SV*)
PL_utf8_foldclosures_ptr: *mut accessor for PL_utf8_foldclosures (read form: PL_utf8_foldclosures!).
PL_utf8_idcont: PL_utf8_idcont — PERLVAR(I, utf8_idcont, SV*)
PL_utf8_idcont_ptr: *mut accessor for PL_utf8_idcont (read form: PL_utf8_idcont!).
PL_utf8_idstart: PL_utf8_idstart — PERLVAR(I, utf8_idstart, SV*)
PL_utf8_idstart_ptr: *mut accessor for PL_utf8_idstart (read form: PL_utf8_idstart!).
PL_utf8_mark: PL_utf8_mark — PERLVAR(I, utf8_mark, SV*)
PL_utf8_mark_ptr: *mut accessor for PL_utf8_mark (read form: PL_utf8_mark!).
PL_utf8_perl_idcont: PL_utf8_perl_idcont — PERLVAR(I, utf8_perl_idcont, SV*)
PL_utf8_perl_idcont_ptr: *mut accessor for PL_utf8_perl_idcont (read form: PL_utf8_perl_idcont!).
PL_utf8_perl_idstart: PL_utf8_perl_idstart — PERLVAR(I, utf8_perl_idstart, SV*)
PL_utf8_perl_idstart_ptr: *mut accessor for PL_utf8_perl_idstart (read form: PL_utf8_perl_idstart!).
PL_utf8_tofold: PL_utf8_tofold — PERLVAR(I, utf8_tofold, SV*)
PL_utf8_tofold_ptr: *mut accessor for PL_utf8_tofold (read form: PL_utf8_tofold!).
PL_utf8_tolower: PL_utf8_tolower — PERLVAR(I, utf8_tolower, SV*)
PL_utf8_tolower_ptr: *mut accessor for PL_utf8_tolower (read form: PL_utf8_tolower!).
PL_utf8_tosimplefold: PL_utf8_tosimplefold — PERLVAR(I, utf8_tosimplefold, SV*)
PL_utf8_tosimplefold_ptr: *mut accessor for PL_utf8_tosimplefold (read form: PL_utf8_tosimplefold!).
PL_utf8_totitle: PL_utf8_totitle — PERLVAR(I, utf8_totitle, SV*)
PL_utf8_totitle_ptr: *mut accessor for PL_utf8_totitle (read form: PL_utf8_totitle!).
PL_utf8_toupper: PL_utf8_toupper — PERLVAR(I, utf8_toupper, SV*)
PL_utf8_toupper_ptr: *mut accessor for PL_utf8_toupper (read form: PL_utf8_toupper!).
PL_utf8_xidcont: PL_utf8_xidcont — PERLVAR(I, utf8_xidcont, SV*)
PL_utf8_xidcont_ptr: *mut accessor for PL_utf8_xidcont (read form: PL_utf8_xidcont!).
PL_utf8_xidstart: PL_utf8_xidstart — PERLVAR(I, utf8_xidstart, SV*)
PL_utf8_xidstart_ptr: *mut accessor for PL_utf8_xidstart (read form: PL_utf8_xidstart!).
PL_utf8cache: PL_utf8cache — PERLVARI(I, utf8cache, I8)
PL_utf8cache_ptr: *mut accessor for PL_utf8cache (read form: PL_utf8cache!).
PL_utf8locale: PL_utf8locale — PERLVAR(I, utf8locale, bool)
PL_utf8locale_ptr: *mut accessor for PL_utf8locale (read form: PL_utf8locale!).
PL_veto_cleanup: PL_veto_cleanup — PERLVARI(G, veto_cleanup, int)
PL_veto_cleanup_ptr: *mut accessor for PL_veto_cleanup (read form: PL_veto_cleanup!).
PL_veto_switch_non_tTHX_context: PL_veto_switch_non_tTHX_context — PERLVARI(G, veto_switch_non_tTHX_context, int)
PL_veto_switch_non_tTHX_context_ptr: *mut accessor for PL_veto_switch_non_tTHX_context (read form: PL_veto_switch_non_tTHX_context!).
PL_warn_locale: PL_warn_locale — PERLVAR(I, warn_locale, SV*)
PL_warn_locale_ptr: *mut accessor for PL_warn_locale (read form: PL_warn_locale!).
PL_warnhook: PL_warnhook — PERLVAR(I, warnhook, SV*)
PL_warnhook_ptr: *mut accessor for PL_warnhook (read form: PL_warnhook!).
PL_watch_pvx: PL_watch_pvx — PERLVARI(G, watch_pvx, char*)
PL_watch_pvx_ptr: *mut accessor for PL_watch_pvx (read form: PL_watch_pvx!).
PL_watchaddr: PL_watchaddr — PERLVARI(I, watchaddr, char**)
PL_watchaddr_ptr: *mut accessor for PL_watchaddr (read form: PL_watchaddr!).
PL_watchok: PL_watchok — PERLVAR(I, watchok, char*)
PL_watchok_ptr: *mut accessor for PL_watchok (read form: PL_watchok!).
PL_wcrtomb_ps: PL_wcrtomb_ps — PERLVAR(I, wcrtomb_ps, mbstate_t)
PL_wcrtomb_ps_ptr: *mut accessor for PL_wcrtomb_ps (read form: PL_wcrtomb_ps!).
PL_xsubfilename: PL_xsubfilename — PERLVARI(I, xsubfilename, const char*)
PL_xsubfilename_ptr: *mut accessor for PL_xsubfilename (read form: PL_xsubfilename!).

Constants§

PERL_ARCHNAME: Perl archname (e.g. "x86_64-linux-thread-multi" or "x86_64-linux-gnu"). Mostly informational; the more useful invariants are in PERL_VERSION and PERL_THREADED.
PERL_THREADED: "threaded" if the target Perl was built with useithreads, "non-threaded" otherwise. Threading mode determines whether most Perl C API functions take a leading my_perl: *mut PerlInterpreter parameter.
PERL_VERSION: Perl version this binding was generated against (e.g. "5.38.4").