Crate libperl_sys

Expand description

§libperl-sys

Built against Perl 5.38.2 (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,
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

Macros§

PL_AboveLatin1: PL_AboveLatin1 — PERLVAR(I, AboveLatin1, SV*)
PL_Assigned_invlist: PL_Assigned_invlist — PERLVAR(I, Assigned_invlist, SV*)
PL_CCC_non0_non230: PL_CCC_non0_non230 — PERLVAR(I, CCC_non0_non230, SV*)
PL_C_locale_obj: PL_C_locale_obj — PERLVARI(G, C_locale_obj, locale_t)
PL_DBcontrol: PL_DBcontrol — PERLVARA(I, DBcontrol, DBVARMG_COUNT, IV)
PL_DBcv: PL_DBcv — PERLVAR(I, DBcv, CV*)
PL_DBgv: PL_DBgv — PERLVAR(I, DBgv, GV*)
PL_DBline: PL_DBline — PERLVAR(I, DBline, GV*)
PL_DBsignal: PL_DBsignal — PERLVAR(I, DBsignal, SV*)
PL_DBsingle: PL_DBsingle — PERLVAR(I, DBsingle, SV*)
PL_DBsub: PL_DBsub — PERLVAR(I, DBsub, GV*)
PL_DBtrace: PL_DBtrace — PERLVAR(I, DBtrace, SV*)
PL_GCB_invlist: PL_GCB_invlist — PERLVAR(I, GCB_invlist, SV*)
PL_HasMultiCharFold: PL_HasMultiCharFold — PERLVAR(I, HasMultiCharFold, SV*)
PL_InBitmap: PL_InBitmap — PERLVARI(I, InBitmap, SV*)
PL_InMultiCharFold: PL_InMultiCharFold — PERLVAR(I, InMultiCharFold, SV*)
PL_LB_invlist: PL_LB_invlist — PERLVAR(I, LB_invlist, SV*)
PL_Latin1: PL_Latin1 — PERLVAR(I, Latin1, SV*)
PL_Posix_ptrs: PL_Posix_ptrs — PERLVARA(I, Posix_ptrs, POSIX_CC_COUNT, SV*)
PL_Private_Use: PL_Private_Use — PERLVAR(I, Private_Use, SV*)
PL_SB_invlist: PL_SB_invlist — PERLVAR(I, SB_invlist, SV*)
PL_SCX_invlist: PL_SCX_invlist — PERLVAR(I, SCX_invlist, SV*)
PL_Sv: PL_Sv — PERLVAR(I, Sv, SV*)
PL_TR_SPECIAL_HANDLING_UTF8: PL_TR_SPECIAL_HANDLING_UTF8 — PERLVARA(I, TR_SPECIAL_HANDLING_UTF8, UTF8_MAXBYTES, char)
PL_UpperLatin1: PL_UpperLatin1 — PERLVAR(I, UpperLatin1, SV*)
PL_WB_invlist: PL_WB_invlist — PERLVAR(I, WB_invlist, SV*)
PL_XPosix_ptrs: PL_XPosix_ptrs — PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV*)
PL_Xpv: PL_Xpv — PERLVAR(I, Xpv, XPV*)
PL_an: PL_an — PERLVARI(I, an, U32)
PL_argvgv: PL_argvgv — PERLVAR(I, argvgv, GV*)
PL_argvout_stack: PL_argvout_stack — PERLVAR(I, argvout_stack, AV*)
PL_argvoutgv: PL_argvoutgv — PERLVAR(I, argvoutgv, GV*)
PL_basetime: PL_basetime — PERLVAR(I, basetime, Time_t)
PL_beginav: PL_beginav — PERLVAR(I, beginav, AV*)
PL_beginav_save: PL_beginav_save — PERLVARI(I, beginav_save, AV*)
PL_blockhooks: PL_blockhooks — PERLVAR(I, blockhooks, AV*)
PL_body_arenas: PL_body_arenas — PERLVAR(I, body_arenas, void*)
PL_body_roots: PL_body_roots — PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*)
PL_bodytarget: PL_bodytarget — PERLVAR(I, bodytarget, SV*)
PL_breakable_sub_gen: PL_breakable_sub_gen — PERLVARI(I, breakable_sub_gen, U32)
PL_check_mutex: PL_check_mutex — PERLVAR(G, check_mutex, perl_mutex)
PL_checkav: PL_checkav — PERLVAR(I, checkav, AV*)
PL_checkav_save: PL_checkav_save — PERLVARI(I, checkav_save, AV*)
PL_chopset: PL_chopset — PERLVARI(I, chopset, const char*)
PL_clocktick: PL_clocktick — PERLVARI(I, clocktick, long)
PL_collation_ix: PL_collation_ix — PERLVARI(I, collation_ix, U32)
PL_collation_name: PL_collation_name — PERLVAR(I, collation_name, char*)
PL_collation_standard: PL_collation_standard — PERLVARI(I, collation_standard, bool)
PL_collxfrm_base: PL_collxfrm_base — PERLVAR(I, collxfrm_base, Size_t)
PL_collxfrm_mult: PL_collxfrm_mult — PERLVARI(I, collxfrm_mult, Size_t)
PL_colors: PL_colors — PERLVARA(I, colors, 6, char*)
PL_colorset: PL_colorset — PERLVAR(I, colorset, bool)
PL_compcv: PL_compcv — PERLVAR(I, compcv, CV*)
PL_compiling: PL_compiling — PERLVAR(I, compiling, COP)
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_floor: PL_comppad_name_floor — PERLVAR(I, comppad_name_floor, PADOFFSET)
PL_constpadix: PL_constpadix — PERLVAR(I, constpadix, PADOFFSET)
PL_cop_seqmax: PL_cop_seqmax — PERLVARI(I, cop_seqmax, U32)
PL_csighandler1p: PL_csighandler1p — PERLVARI(G, csighandler1p, Sighandler1_t)
PL_csighandler3p: PL_csighandler3p — PERLVARI(G, csighandler3p, Sighandler3_t)
PL_csighandlerp: PL_csighandlerp — PERLVARI(G, csighandlerp, Sighandler_t)
PL_ctype_name: PL_ctype_name — PERLVARI(I, ctype_name, const char*)
PL_cur_LC_ALL: PL_cur_LC_ALL — PERLVARI(I, cur_LC_ALL, const char*)
PL_cur_locale_obj: PL_cur_locale_obj — PERLVARI(I, cur_locale_obj, locale_t)
PL_curcop: PL_curcop — PERLVAR(I, curcop, COP*)
PL_curcopdb: PL_curcopdb — PERLVARI(I, curcopdb, COP*)
PL_curinterp: PL_curinterp — PERLVARI(G, curinterp, PerlInterpreter*)
PL_curlocales: PL_curlocales — PERLVARA(I, curlocales, 12, const char*)
PL_curpad: PL_curpad — PERLVAR(I, curpad, SV**)
PL_curpm: PL_curpm — PERLVAR(I, curpm, PMOP*)
PL_curpm_under: PL_curpm_under — PERLVAR(I, curpm_under, PMOP*)
PL_curstack: PL_curstack — PERLVAR(I, curstack, AV*)
PL_curstackinfo: PL_curstackinfo — PERLVAR(I, curstackinfo, PERL_SI*)
PL_curstash: PL_curstash — PERLVAR(I, curstash, HV*)
PL_curstname: PL_curstname — PERLVAR(I, curstname, SV*)
PL_custom_op_descs: PL_custom_op_descs — PERLVAR(I, custom_op_descs, HV*)
PL_custom_op_names: PL_custom_op_names — PERLVAR(I, custom_op_names, HV*)
PL_custom_ops: PL_custom_ops — PERLVAR(I, custom_ops, HV*)
PL_cv_has_eval: PL_cv_has_eval — PERLVARI(I, cv_has_eval, bool)
PL_dbargs: PL_dbargs — PERLVAR(I, dbargs, AV*)
PL_debstash: PL_debstash — PERLVAR(I, debstash, HV*)
PL_debug: PL_debug — PERLVAR(I, debug, volatile U32)
PL_debug_pad: PL_debug_pad — PERLVAR(I, debug_pad, struct perl_debug_pad)
PL_def_layerlist: PL_def_layerlist — PERLVARI(I, def_layerlist, PerlIO_list_t*)
PL_defgv: PL_defgv — PERLVAR(I, defgv, GV*)
PL_defoutgv: PL_defoutgv — PERLVAR(I, defoutgv, GV*)
PL_defstash: PL_defstash — PERLVAR(I, defstash, HV*)
PL_delaymagic: PL_delaymagic — PERLVAR(I, delaymagic, U16)
PL_delaymagic_egid: PL_delaymagic_egid — PERLVAR(I, delaymagic_egid, Gid_t)
PL_delaymagic_euid: PL_delaymagic_euid — PERLVAR(I, delaymagic_euid, Uid_t)
PL_delaymagic_gid: PL_delaymagic_gid — PERLVAR(I, delaymagic_gid, Gid_t)
PL_delaymagic_uid: PL_delaymagic_uid — PERLVAR(I, delaymagic_uid, Uid_t)
PL_destroyhook: PL_destroyhook — PERLVARI(I, destroyhook, destroyable_proc_t)
PL_diehook: PL_diehook — PERLVAR(I, diehook, SV*)
PL_do_undump: PL_do_undump — PERLVARI(G, do_undump, bool)
PL_dollarzero_mutex: PL_dollarzero_mutex — PERLVAR(G, dollarzero_mutex, perl_mutex)
PL_doswitches: PL_doswitches — PERLVAR(I, doswitches, bool)
PL_dowarn: PL_dowarn — PERLVAR(I, dowarn, U8)
PL_dump_re_max_len: PL_dump_re_max_len — PERLVARI(I, dump_re_max_len, STRLEN)
PL_dumpindent: PL_dumpindent — PERLVARI(I, dumpindent, U16)
PL_e_script: PL_e_script — PERLVAR(I, e_script, SV*)
PL_efloatbuf: PL_efloatbuf — PERLVAR(I, efloatbuf, char*)
PL_efloatsize: PL_efloatsize — PERLVAR(I, efloatsize, STRLEN)
PL_endav: PL_endav — PERLVAR(I, endav, AV*)
PL_env_mutex: PL_env_mutex — PERLVAR(G, env_mutex, perl_RnW1_mutex_t)
PL_envgv: PL_envgv — PERLVAR(I, envgv, GV*)
PL_errgv: PL_errgv — PERLVAR(I, errgv, GV*)
PL_errors: PL_errors — PERLVARI(I, errors, SV*)
PL_eval_begin_nest_depth: PL_eval_begin_nest_depth — PERLVARI(I, eval_begin_nest_depth, U32)
PL_eval_root: PL_eval_root — PERLVAR(I, eval_root, OP*)
PL_eval_start: PL_eval_start — PERLVAR(I, eval_start, OP*)
PL_evalseq: PL_evalseq — PERLVARI(I, evalseq, U32)
PL_exit_flags: PL_exit_flags — PERLVAR(I, exit_flags, U8)
PL_exitlist: PL_exitlist — PERLVARI(I, exitlist, PerlExitListEntry*)
PL_exitlistlen: PL_exitlistlen — PERLVARI(I, exitlistlen, I32)
PL_fdpid: PL_fdpid — PERLVAR(I, fdpid, AV*)
PL_filemode: PL_filemode — PERLVAR(I, filemode, int)
PL_firstgv: PL_firstgv — PERLVAR(I, firstgv, GV*)
PL_fold_locale: PL_fold_locale — PERLVARA(I, fold_locale, 256, U8)
PL_forkprocess: PL_forkprocess — PERLVAR(I, forkprocess, int)
PL_formtarget: PL_formtarget — PERLVAR(I, formtarget, SV*)
PL_generation: PL_generation — PERLVARI(I, generation, int)
PL_gensym: PL_gensym — PERLVARI(I, gensym, I32)
PL_globalstash: PL_globalstash — PERLVAR(I, globalstash, HV*)
PL_globhook: PL_globhook — PERLVARI(I, globhook, globhook_t)
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_seed_set: PL_hash_seed_set — PERLVARI(G, hash_seed_set, bool)
PL_hash_seed_w: PL_hash_seed_w — PERLVARA(G, hash_seed_w, PERL_HASH_SEED_WORDS, PVT__PERL_HASH_WORD_TYPE)
PL_hash_state_w: PL_hash_state_w — PERLVARA(G, hash_state_w, PERL_HASH_STATE_WORDS, PVT__PERL_HASH_WORD_TYPE)
PL_hintgv: PL_hintgv — PERLVAR(I, hintgv, GV*)
PL_hints_mutex: PL_hints_mutex — PERLVAR(G, hints_mutex, perl_mutex)
PL_hook__require__after: PL_hook__require__after — PERLVARI(I, hook__require__after, SV*)
PL_hook__require__before: PL_hook__require__before — PERLVARI(I, hook__require__before, SV*)
PL_hv_fetch_ent_mh: PL_hv_fetch_ent_mh — PERLVAR(I, hv_fetch_ent_mh, HE*)
PL_in_clean_all: PL_in_clean_all — PERLVARI(I, in_clean_all, bool)
PL_in_clean_objs: PL_in_clean_objs — PERLVARI(I, in_clean_objs, bool)
PL_in_eval: PL_in_eval — PERLVAR(I, in_eval, U8)
PL_in_load_module: PL_in_load_module — PERLVARI(I, in_load_module, bool)
PL_in_some_fold: PL_in_some_fold — PERLVAR(I, in_some_fold, SV*)
PL_in_utf8_COLLATE_locale: PL_in_utf8_COLLATE_locale — PERLVAR(I, in_utf8_COLLATE_locale, bool)
PL_in_utf8_CTYPE_locale: PL_in_utf8_CTYPE_locale — PERLVAR(I, in_utf8_CTYPE_locale, bool)
PL_in_utf8_turkic_locale: PL_in_utf8_turkic_locale — PERLVAR(I, in_utf8_turkic_locale, bool)
PL_incgv: PL_incgv — PERLVAR(I, incgv, GV*)
PL_infix_plugin: PL_infix_plugin — PERLVARI(G, infix_plugin, Perl_infix_plugin_t)
PL_initav: PL_initav — PERLVAR(I, initav, AV*)
PL_inplace: PL_inplace — PERLVAR(I, inplace, char*)
PL_internal_random_state: PL_internal_random_state — PERLVAR(I, internal_random_state, PL_RANDOM_STATE_TYPE)
PL_isarev: PL_isarev — PERLVARI(I, isarev, HV*)
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_known_layers: PL_known_layers — PERLVARI(I, known_layers, PerlIO_list_t*)
PL_langinfo_buf: PL_langinfo_buf — PERLVARI(I, langinfo_buf, const char*)
PL_langinfo_bufsize: PL_langinfo_bufsize — PERLVARI(I, langinfo_bufsize, Size_t)
PL_last_in_gv: PL_last_in_gv — PERLVAR(I, last_in_gv, GV*)
PL_lastfd: PL_lastfd — PERLVAR(I, lastfd, int)
PL_lastgotoprobe: PL_lastgotoprobe — PERLVAR(I, lastgotoprobe, OP*)
PL_laststatval: PL_laststatval — PERLVARI(I, laststatval, int)
PL_laststype: PL_laststype — PERLVARI(I, laststype, U16)
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_localizing: PL_localizing — PERLVAR(I, localizing, U8)
PL_localpatches: PL_localpatches — PERLVAR(I, localpatches, const char*const*)
PL_lockhook: PL_lockhook — PERLVARI(I, lockhook, share_proc_t)
PL_main_cv: PL_main_cv — PERLVAR(I, main_cv, CV*)
PL_main_root: PL_main_root — PERLVAR(I, main_root, OP*)
PL_main_start: PL_main_start — PERLVAR(I, main_start, OP*)
PL_mainstack: PL_mainstack — PERLVAR(I, mainstack, AV*)
PL_markstack: PL_markstack — PERLVAR(I, markstack, I32*)
PL_markstack_max: PL_markstack_max — PERLVAR(I, markstack_max, I32*)
PL_markstack_ptr: PL_markstack_ptr — PERLVAR(I, markstack_ptr, I32*)
PL_max_intro_pending: PL_max_intro_pending — PERLVAR(I, max_intro_pending, PADOFFSET)
PL_maxsysfd: PL_maxsysfd — PERLVARI(I, maxsysfd, I32)
PL_mbrlen_ps: PL_mbrlen_ps — PERLVAR(I, mbrlen_ps, mbstate_t)
PL_mbrtowc_ps: PL_mbrtowc_ps — PERLVAR(I, mbrtowc_ps, mbstate_t)
PL_memory_debug_header: PL_memory_debug_header — PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
PL_mess_sv: PL_mess_sv — PERLVAR(I, mess_sv, SV*)
PL_min_intro_pending: PL_min_intro_pending — PERLVAR(I, min_intro_pending, PADOFFSET)
PL_minus_E: PL_minus_E — PERLVAR(I, minus_E, bool)
PL_minus_F: PL_minus_F — PERLVAR(I, minus_F, bool)
PL_minus_a: PL_minus_a — PERLVAR(I, minus_a, bool)
PL_minus_c: PL_minus_c — PERLVAR(I, minus_c, bool)
PL_minus_l: PL_minus_l — PERLVAR(I, minus_l, bool)
PL_minus_n: PL_minus_n — PERLVAR(I, minus_n, bool)
PL_minus_p: PL_minus_p — PERLVAR(I, minus_p, bool)
PL_mmap_page_size: PL_mmap_page_size — PERLVARI(G, mmap_page_size, IV)
PL_modcount: PL_modcount — PERLVAR(I, modcount, I32)
PL_modglobal: PL_modglobal — PERLVAR(I, modglobal, HV*)
PL_multideref_pc: PL_multideref_pc — PERLVAR(I, multideref_pc, UNOP_AUX_item*)
PL_my_ctx_mutex: PL_my_ctx_mutex — PERLVAR(G, my_ctx_mutex, perl_mutex)
PL_my_cxt_index: PL_my_cxt_index — PERLVARI(G, my_cxt_index, int)
PL_my_cxt_list: PL_my_cxt_list — PERLVARI(I, my_cxt_list, void**)
PL_my_cxt_size: PL_my_cxt_size — PERLVARI(I, my_cxt_size, int)
PL_my_environ: PL_my_environ — PERLVARI(G, my_environ, char**)
PL_na: PL_na — PERLVAR(I, na, STRLEN)
PL_nomemok: PL_nomemok — PERLVAR(I, nomemok, bool)
PL_numeric_name: PL_numeric_name — PERLVAR(I, numeric_name, char*)
PL_numeric_radix_sv: PL_numeric_radix_sv — PERLVAR(I, numeric_radix_sv, SV*)
PL_numeric_standard: PL_numeric_standard — PERLVARI(I, numeric_standard, int)
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_ofsgv: PL_ofsgv — PERLVAR(I, ofsgv, GV*)
PL_oldname: PL_oldname — PERLVAR(I, oldname, char*)
PL_op: PL_op — PERLVAR(I, op, OP*)
PL_op_mask: PL_op_mask — PERLVARI(I, op_mask, char*)
PL_op_mutex: PL_op_mutex — PERLVAR(G, op_mutex, perl_mutex)
PL_op_seq: PL_op_seq — PERLVARI(G, op_seq, UV)
PL_op_sequence: PL_op_sequence — PERLVARI(G, op_sequence, HV*)
PL_opfreehook: PL_opfreehook — PERLVARI(I, opfreehook, Perl_ophook_t)
PL_origalen: PL_origalen — PERLVAR(I, origalen, U32)
PL_origargc: PL_origargc — PERLVAR(I, origargc, int)
PL_origargv: PL_origargv — PERLVAR(I, origargv, char**)
PL_origenviron: PL_origenviron — PERLVARI(G, origenviron, char**)
PL_origfilename: PL_origfilename — PERLVAR(I, origfilename, char*)
PL_ors_sv: PL_ors_sv — PERLVAR(I, ors_sv, SV*)
PL_osname: PL_osname — PERLVAR(I, osname, char*)
PL_pad_reset_pending: PL_pad_reset_pending — PERLVAR(I, pad_reset_pending, bool)
PL_padix: PL_padix — PERLVAR(I, padix, PADOFFSET)
PL_padix_floor: PL_padix_floor — PERLVAR(I, padix_floor, PADOFFSET)
PL_padlist_generation: PL_padlist_generation — PERLVARI(I, padlist_generation, U32)
PL_padname_const: PL_padname_const — PERLVAR(I, padname_const, PADNAME)
PL_padname_undef: PL_padname_undef — PERLVAR(I, padname_undef, PADNAME)
PL_parser: PL_parser — PERLVAR(I, parser, yy_parser*)
PL_patchlevel: PL_patchlevel — PERLVAR(I, patchlevel, SV*)
PL_peepp: PL_peepp — PERLVARI(I, peepp, peep_t)
PL_perl_destruct_level: PL_perl_destruct_level — PERLVARI(I, perl_destruct_level, signed char)
PL_perldb: PL_perldb — PERLVAR(I, perldb, U32)
PL_perlio: PL_perlio — PERLVARI(I, perlio, PerlIOl*)
PL_perlio_debug_fd: PL_perlio_debug_fd — PERLVARI(G, perlio_debug_fd, int)
PL_perlio_fd_refcnt: PL_perlio_fd_refcnt — PERLVARI(G, perlio_fd_refcnt, int*)
PL_perlio_fd_refcnt_size: PL_perlio_fd_refcnt_size — PERLVARI(G, perlio_fd_refcnt_size, int)
PL_perlio_mutex: PL_perlio_mutex — PERLVAR(G, perlio_mutex, perl_mutex)
PL_phase: PL_phase — PERLVARI(I, phase, enum perl_phase)
PL_preambleav: PL_preambleav — PERLVAR(I, preambleav, AV*)
PL_prevailing_version: PL_prevailing_version — PERLVAR(I, prevailing_version, U16)
PL_profiledata: PL_profiledata — PERLVARI(I, profiledata, U32*)
PL_psig_name: PL_psig_name — PERLVAR(I, psig_name, SV**)
PL_psig_pend: PL_psig_pend — PERLVAR(I, psig_pend, int*)
PL_psig_ptr: PL_psig_ptr — PERLVAR(I, psig_ptr, SV**)
PL_ptr_table: PL_ptr_table — PERLVAR(I, ptr_table, PTR_TBL_t*)
PL_random_state: PL_random_state — PERLVAR(I, random_state, PL_RANDOM_STATE_TYPE)
PL_reentrant_buffer: PL_reentrant_buffer — PERLVAR(I, reentrant_buffer, REENTR*)
PL_reentrant_retint: PL_reentrant_retint — PERLVAR(I, reentrant_retint, int)
PL_reg_curpm: PL_reg_curpm — PERLVARI(I, reg_curpm, PMOP*)
PL_regex_pad: PL_regex_pad — PERLVAR(I, regex_pad, SV**)
PL_regex_padav: PL_regex_padav — PERLVAR(I, regex_padav, AV*)
PL_registered_mros: PL_registered_mros — PERLVAR(I, registered_mros, HV*)
PL_regmatch_slab: PL_regmatch_slab — PERLVARI(I, regmatch_slab, regmatch_slab*)
PL_regmatch_state: PL_regmatch_state — PERLVAR(I, regmatch_state, regmatch_state*)
PL_replgv: PL_replgv — PERLVAR(I, replgv, GV*)
PL_restartjmpenv: PL_restartjmpenv — PERLVAR(I, restartjmpenv, JMPENV*)
PL_restartop: PL_restartop — PERLVAR(I, restartop, OP*)
PL_rpeepp: PL_rpeepp — PERLVARI(I, rpeepp, peep_t)
PL_rs: PL_rs — PERLVAR(I, rs, SV*)
PL_runops: PL_runops — PERLVARI(I, runops, runops_proc_t)
PL_savebegin: PL_savebegin — PERLVARI(I, savebegin, bool)
PL_savestack: PL_savestack — PERLVAR(I, savestack, ANY*)
PL_savestack_ix: PL_savestack_ix — PERLVAR(I, savestack_ix, I32)
PL_savestack_max: PL_savestack_max — PERLVAR(I, savestack_max, I32)
PL_scopestack: PL_scopestack — PERLVAR(I, scopestack, I32*)
PL_scopestack_ix: PL_scopestack_ix — PERLVAR(I, scopestack_ix, I32)
PL_scopestack_max: PL_scopestack_max — PERLVAR(I, scopestack_max, I32)
PL_scopestack_name: PL_scopestack_name — PERLVARI(I, scopestack_name, const char**)
PL_scratch_locale_obj: PL_scratch_locale_obj — PERLVARI(I, scratch_locale_obj, locale_t)
PL_secondgv: PL_secondgv — PERLVAR(I, secondgv, GV*)
PL_setlocale_buf: PL_setlocale_buf — PERLVARI(I, setlocale_buf, const char*)
PL_setlocale_bufsize: PL_setlocale_bufsize — PERLVARI(I, setlocale_bufsize, Size_t)
PL_sharehook: PL_sharehook — PERLVARI(I, sharehook, share_proc_t)
PL_sig_pending: PL_sig_pending — PERLVARI(I, sig_pending, int)
PL_sigfpe_saved: PL_sigfpe_saved — PERLVAR(G, sigfpe_saved, Sighandler_t)
PL_sighandler1p: PL_sighandler1p — PERLVAR(I, sighandler1p, Sighandler1_t)
PL_sighandler3p: PL_sighandler3p — PERLVAR(I, sighandler3p, Sighandler3_t)
PL_sighandlerp: PL_sighandlerp — PERLVAR(I, sighandlerp, Sighandler_t)
PL_signalhook: PL_signalhook — PERLVARI(I, signalhook, despatch_signals_proc_t)
PL_signals: PL_signals — PERLVAR(I, signals, U32)
PL_sortcop: PL_sortcop — PERLVAR(I, sortcop, OP*)
PL_sortstash: PL_sortstash — PERLVAR(I, sortstash, HV*)
PL_splitstr: PL_splitstr — PERLVARI(I, splitstr, char*)
PL_srand_called: PL_srand_called — PERLVARI(I, srand_called, bool)
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_stack_base: PL_stack_base — PERLVAR(I, stack_base, SV**)
PL_stack_max: PL_stack_max — PERLVAR(I, stack_max, SV**)
PL_stack_sp: PL_stack_sp — PERLVAR(I, stack_sp, SV**)
PL_start_env: PL_start_env — PERLVAR(I, start_env, JMPENV)
PL_stashcache: PL_stashcache — PERLVAR(I, stashcache, HV*)
PL_stashpad: PL_stashpad — PERLVAR(I, stashpad, HV**)
PL_stashpadix: PL_stashpadix — PERLVARI(I, stashpadix, PADOFFSET)
PL_stashpadmax: PL_stashpadmax — PERLVARI(I, stashpadmax, PADOFFSET)
PL_statcache: PL_statcache — PERLVAR(I, statcache, Stat_t)
PL_statgv: PL_statgv — PERLVAR(I, statgv, GV*)
PL_statname: PL_statname — PERLVARI(I, statname, SV*)
PL_statusvalue: PL_statusvalue — PERLVAR(I, statusvalue, I32)
PL_statusvalue_posix: PL_statusvalue_posix — PERLVAR(I, statusvalue_posix, I32)
PL_stderrgv: PL_stderrgv — PERLVAR(I, stderrgv, GV*)
PL_stdingv: PL_stdingv — PERLVAR(I, stdingv, GV*)
PL_stdize_locale_buf: PL_stdize_locale_buf — PERLVARI(I, stdize_locale_buf, const char*)
PL_stdize_locale_bufsize: PL_stdize_locale_bufsize — PERLVARI(I, stdize_locale_bufsize, Size_t)
PL_strategy_accept: PL_strategy_accept — PERLVARI(G, strategy_accept, int)
PL_strategy_dup: PL_strategy_dup — PERLVARI(G, strategy_dup, int)
PL_strategy_dup2: PL_strategy_dup2 — PERLVARI(G, strategy_dup2, int)
PL_strategy_mkstemp: PL_strategy_mkstemp — PERLVARI(G, strategy_mkstemp, int)
PL_strategy_open: PL_strategy_open — PERLVARI(G, strategy_open, int)
PL_strategy_open3: PL_strategy_open3 — PERLVARI(G, strategy_open3, int)
PL_strategy_pipe: PL_strategy_pipe — PERLVARI(G, strategy_pipe, int)
PL_strategy_socket: PL_strategy_socket — PERLVARI(G, strategy_socket, int)
PL_strategy_socketpair: PL_strategy_socketpair — PERLVARI(G, strategy_socketpair, int)
PL_strtab: PL_strtab — PERLVAR(I, strtab, HV*)
PL_strxfrm_NUL_replacement: PL_strxfrm_NUL_replacement — PERLVARI(I, strxfrm_NUL_replacement, U8)
PL_strxfrm_is_behaved: PL_strxfrm_is_behaved — PERLVARI(I, strxfrm_is_behaved, bool)
PL_strxfrm_max_cp: PL_strxfrm_max_cp — PERLVARI(I, strxfrm_max_cp, U8)
PL_sub_generation: PL_sub_generation — PERLVARI(I, sub_generation, U32)
PL_subline: PL_subline — PERLVAR(I, subline, I32)
PL_subname: PL_subname — PERLVAR(I, subname, SV*)
PL_sv_arenaroot: PL_sv_arenaroot — PERLVAR(I, sv_arenaroot, SV*)
PL_sv_consts: PL_sv_consts — PERLVARA(I, sv_consts, SV_CONSTS_COUNT, SV*)
PL_sv_count: PL_sv_count — PERLVAR(I, sv_count, IV)
PL_sv_no: PL_sv_no — PERLVAR(I, sv_no, SV)
PL_sv_placeholder: PL_sv_placeholder — PERLVAR(G, sv_placeholder, SV)
PL_sv_root: PL_sv_root — PERLVAR(I, sv_root, SV*)
PL_sv_undef: PL_sv_undef — PERLVAR(I, sv_undef, SV)
PL_sv_yes: PL_sv_yes — PERLVAR(I, sv_yes, SV)
PL_sv_zero: PL_sv_zero — PERLVAR(I, sv_zero, SV)
PL_taint_warn: PL_taint_warn — PERLVAR(I, taint_warn, bool)
PL_tainted: PL_tainted — PERLVARI(I, tainted, bool)
PL_tainting: PL_tainting — PERLVAR(I, tainting, bool)
PL_thr_key: PL_thr_key — PERLVAR(G, thr_key, perl_key)
PL_threadhook: PL_threadhook — PERLVARI(I, threadhook, thrhook_proc_t)
PL_tmps_floor: PL_tmps_floor — PERLVARI(I, tmps_floor, SSize_t)
PL_tmps_ix: PL_tmps_ix — PERLVARI(I, tmps_ix, SSize_t)
PL_tmps_max: PL_tmps_max — PERLVAR(I, tmps_max, SSize_t)
PL_tmps_stack: PL_tmps_stack — PERLVAR(I, tmps_stack, SV**)
PL_top_env: PL_top_env — PERLVAR(I, top_env, JMPENV*)
PL_toptarget: PL_toptarget — PERLVAR(I, toptarget, SV*)
PL_underlying_numeric_obj: PL_underlying_numeric_obj — PERLVARI(I, underlying_numeric_obj, locale_t)
PL_underlying_radix_sv: PL_underlying_radix_sv — PERLVAR(I, underlying_radix_sv, SV*)
PL_unicode: PL_unicode — PERLVAR(I, unicode, U32)
PL_unitcheckav: PL_unitcheckav — PERLVAR(I, unitcheckav, AV*)
PL_unitcheckav_save: PL_unitcheckav_save — PERLVARI(I, unitcheckav_save, AV*)
PL_unlockhook: PL_unlockhook — PERLVARI(I, unlockhook, share_proc_t)
PL_unsafe: PL_unsafe — PERLVAR(I, unsafe, bool)
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_prop_mutex: PL_user_prop_mutex — PERLVAR(G, user_prop_mutex, perl_mutex)
PL_utf8_charname_begin: PL_utf8_charname_begin — PERLVAR(I, utf8_charname_begin, SV*)
PL_utf8_charname_continue: PL_utf8_charname_continue — PERLVAR(I, utf8_charname_continue, SV*)
PL_utf8_foldclosures: PL_utf8_foldclosures — PERLVAR(I, utf8_foldclosures, SV*)
PL_utf8_idcont: PL_utf8_idcont — PERLVAR(I, utf8_idcont, SV*)
PL_utf8_idstart: PL_utf8_idstart — PERLVAR(I, utf8_idstart, SV*)
PL_utf8_mark: PL_utf8_mark — PERLVAR(I, utf8_mark, SV*)
PL_utf8_perl_idcont: PL_utf8_perl_idcont — PERLVAR(I, utf8_perl_idcont, SV*)
PL_utf8_perl_idstart: PL_utf8_perl_idstart — PERLVAR(I, utf8_perl_idstart, SV*)
PL_utf8_tofold: PL_utf8_tofold — PERLVAR(I, utf8_tofold, SV*)
PL_utf8_tolower: PL_utf8_tolower — PERLVAR(I, utf8_tolower, SV*)
PL_utf8_tosimplefold: PL_utf8_tosimplefold — PERLVAR(I, utf8_tosimplefold, SV*)
PL_utf8_totitle: PL_utf8_totitle — PERLVAR(I, utf8_totitle, SV*)
PL_utf8_toupper: PL_utf8_toupper — PERLVAR(I, utf8_toupper, SV*)
PL_utf8_xidcont: PL_utf8_xidcont — PERLVAR(I, utf8_xidcont, SV*)
PL_utf8_xidstart: PL_utf8_xidstart — PERLVAR(I, utf8_xidstart, SV*)
PL_utf8cache: PL_utf8cache — PERLVARI(I, utf8cache, I8)
PL_utf8locale: PL_utf8locale — PERLVAR(I, utf8locale, bool)
PL_veto_cleanup: PL_veto_cleanup — PERLVARI(G, veto_cleanup, int)
PL_veto_switch_non_tTHX_context: PL_veto_switch_non_tTHX_context — PERLVARI(G, veto_switch_non_tTHX_context, int)
PL_warn_locale: PL_warn_locale — PERLVAR(I, warn_locale, SV*)
PL_warnhook: PL_warnhook — PERLVAR(I, warnhook, SV*)
PL_watch_pvx: PL_watch_pvx — PERLVARI(G, watch_pvx, char*)
PL_watchaddr: PL_watchaddr — PERLVARI(I, watchaddr, char**)
PL_watchok: PL_watchok — PERLVAR(I, watchok, char*)
PL_wcrtomb_ps: PL_wcrtomb_ps — PERLVAR(I, wcrtomb_ps, mbstate_t)
PL_xsubfilename: PL_xsubfilename — PERLVARI(I, xsubfilename, const char*)

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").