/* * This file was generated automatically by ExtUtils::ParseXS version 3.34 from the * contents of XSParagraph.xs. Do not edit this file, edit XSParagraph.xs instead. * * ANY CHANGES MADE HERE WILL BE LOST! * */ #line 1 "XSParagraph.xs" #ifdef HAVE_CONFIG_H #include #endif #define PERL_NO_GET_CONTEXT #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #include "ppport.h" #include "xspara.h" #line 24 "XSParagraph.c" #ifndef PERL_UNUSED_VAR # define PERL_UNUSED_VAR(var) if (0) var = var #endif #ifndef dVAR # define dVAR dNOOP #endif /* This stuff is not part of the API! You have been warned. */ #ifndef PERL_VERSION_DECIMAL # define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s) #endif #ifndef PERL_DECIMAL_VERSION # define PERL_DECIMAL_VERSION \ PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION) #endif #ifndef PERL_VERSION_GE # define PERL_VERSION_GE(r,v,s) \ (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s)) #endif #ifndef PERL_VERSION_LE # define PERL_VERSION_LE(r,v,s) \ (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s)) #endif /* XS_INTERNAL is the explicit static-linkage variant of the default * XS macro. * * XS_EXTERNAL is the same as XS_INTERNAL except it does not include * "STATIC", ie. it exports XSUB symbols. You probably don't want that * for anything but the BOOT XSUB. * * See XSUB.h in core! */ /* TODO: This might be compatible further back than 5.10.0. */ #if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1) # undef XS_EXTERNAL # undef XS_INTERNAL # if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING) # define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name) # define XS_INTERNAL(name) STATIC XSPROTO(name) # endif # if defined(__SYMBIAN32__) # define XS_EXTERNAL(name) EXPORT_C XSPROTO(name) # define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name) # endif # ifndef XS_EXTERNAL # if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus) # define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__) # define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__) # else # ifdef __cplusplus # define XS_EXTERNAL(name) extern "C" XSPROTO(name) # define XS_INTERNAL(name) static XSPROTO(name) # else # define XS_EXTERNAL(name) XSPROTO(name) # define XS_INTERNAL(name) STATIC XSPROTO(name) # endif # endif # endif #endif /* perl >= 5.10.0 && perl <= 5.15.1 */ /* The XS_EXTERNAL macro is used for functions that must not be static * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL * macro defined, the best we can do is assume XS is the same. * Dito for XS_INTERNAL. */ #ifndef XS_EXTERNAL # define XS_EXTERNAL(name) XS(name) #endif #ifndef XS_INTERNAL # define XS_INTERNAL(name) XS(name) #endif /* Now, finally, after all this mess, we want an ExtUtils::ParseXS * internal macro that we're free to redefine for varying linkage due * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to! */ #undef XS_EUPXS #if defined(PERL_EUPXS_ALWAYS_EXPORT) # define XS_EUPXS(name) XS_EXTERNAL(name) #else /* default to internal */ # define XS_EUPXS(name) XS_INTERNAL(name) #endif #ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE #define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params) /* prototype to pass -Wmissing-prototypes */ STATIC void S_croak_xs_usage(const CV *const cv, const char *const params); STATIC void S_croak_xs_usage(const CV *const cv, const char *const params) { const GV *const gv = CvGV(cv); PERL_ARGS_ASSERT_CROAK_XS_USAGE; if (gv) { const char *const gvname = GvNAME(gv); const HV *const stash = GvSTASH(gv); const char *const hvname = stash ? HvNAME(stash) : NULL; if (hvname) Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params); else Perl_croak_nocontext("Usage: %s(%s)", gvname, params); } else { /* Pants. I don't think that it should be possible to get here. */ Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params); } } #undef PERL_ARGS_ASSERT_CROAK_XS_USAGE #define croak_xs_usage S_croak_xs_usage #endif /* NOTE: the prototype of newXSproto() is different in versions of perls, * so we define a portable version of newXSproto() */ #ifdef newXS_flags #define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0) #else #define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv) #endif /* !defined(newXS_flags) */ #if PERL_VERSION_LE(5, 21, 5) # define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file) #else # define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b) #endif #line 168 "XSParagraph.c" XS_EUPXS(XS_Texinfo__XS__XSParagraph_init); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_init) { dVAR; dXSARGS; if (items != 2) croak_xs_usage(cv, "unused, unused2"); { int unused = (int)SvIV(ST(0)) ; char * unused2 = (char *)SvPV_nolen(ST(1)) ; int RETVAL; dXSTARG; RETVAL = xspara_init(unused, unused2); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_set_state); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_set_state) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "state"); { SV * state = ST(0) ; xspara_set_state(state); } XSRETURN_EMPTY; } XS_EUPXS(XS_Texinfo__XS__XSParagraph_new); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_new) { dVAR; dXSARGS; if (items < 1) croak_xs_usage(cv, "class, ..."); { SV * class = ST(0) ; #line 49 "XSParagraph.xs" HV *pkg; HV *conf = 0; int id; #line 220 "XSParagraph.c" SV * RETVAL; #line 53 "XSParagraph.xs" items--; if (items > 0) { if (SvROK(ST(1)) && SvTYPE(SvRV(ST(1))) == SVt_PVHV) conf = (HV *) SvRV(ST(1)); } id = xspara_new (conf); /* Create a blessed integer, which the other functions need as their first argument. */ pkg = gv_stashpv ("Texinfo::Convert::XSParagraph::XSParagraph", 0); RETVAL = newSViv (id); #line 235 "XSParagraph.c" RETVAL = sv_2mortal(RETVAL); ST(0) = RETVAL; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_end_line_count); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_end_line_count) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; int RETVAL; dXSTARG; #line 73 "XSParagraph.xs" xspara_set_state (paragraph); RETVAL = xspara_end_line_count (); #line 257 "XSParagraph.c" XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph__end_line); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph__end_line) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; #line 82 "XSParagraph.xs" xspara_set_state (paragraph); xspara__end_line (); #line 276 "XSParagraph.c" } XSRETURN_EMPTY; } XS_EUPXS(XS_Texinfo__XS__XSParagraph_end_line); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_end_line) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; char * RETVAL; dXSTARG; #line 89 "XSParagraph.xs" xspara_set_state (paragraph); RETVAL = xspara_end_line (); #line 296 "XSParagraph.c" sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_get_pending); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_get_pending) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; char * RETVAL; dXSTARG; #line 98 "XSParagraph.xs" xspara_set_state (paragraph); RETVAL = xspara_get_pending (); #line 317 "XSParagraph.c" sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_pending_word); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_pending_word) { dVAR; dXSARGS; if (items < 1) croak_xs_usage(cv, "paragraph, ..."); { SV * paragraph = ST(0) ; #line 108 "XSParagraph.xs" int add_spaces = 0; char *retval; #line 336 "XSParagraph.c" SV * RETVAL; #line 111 "XSParagraph.xs" items -= 1; if (items > 0) { if (SvOK(ST(1))) { add_spaces = (int)SvIV(ST(1));; } } xspara_set_state (paragraph); retval = xspara_add_pending_word (add_spaces); RETVAL = newSVpv (retval, 0); SvUTF8_on (RETVAL); #line 352 "XSParagraph.c" RETVAL = sv_2mortal(RETVAL); ST(0) = RETVAL; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_end); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_end) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; #line 131 "XSParagraph.xs" char *retval; #line 371 "XSParagraph.c" SV * RETVAL; #line 133 "XSParagraph.xs" xspara_set_state (paragraph); retval = xspara_end (); RETVAL = newSVpv (retval, 0); SvUTF8_on (RETVAL); #line 379 "XSParagraph.c" RETVAL = sv_2mortal(RETVAL); ST(0) = RETVAL; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_text); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_text) { dVAR; dXSARGS; if (items != 2) croak_xs_usage(cv, "paragraph, text_in"); { SV * paragraph = ST(0) ; SV * text_in = ST(1) ; #line 147 "XSParagraph.xs" char *text; char *retval; #line 401 "XSParagraph.c" SV * RETVAL; #line 150 "XSParagraph.xs" /* Always convert the input to UTF8 with sv_utf8_upgrade, so we can process it properly in xspara_add_next. */ if (!SvUTF8 (text_in)) sv_utf8_upgrade (text_in); text = SvPV_nolen (text_in); xspara_set_state (paragraph); retval = xspara_add_text (text); RETVAL = newSVpv (retval, 0); SvUTF8_on (RETVAL); #line 417 "XSParagraph.c" RETVAL = sv_2mortal(RETVAL); ST(0) = RETVAL; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_next); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_next) { dVAR; dXSARGS; if (items < 2) croak_xs_usage(cv, "paragraph, text_in, ..."); { SV * paragraph = ST(0) ; SV * text_in = ST(1) ; #line 171 "XSParagraph.xs" char *text; STRLEN text_len; char *retval; SV *arg_in; int transparent = 0; #line 442 "XSParagraph.c" SV * RETVAL; #line 177 "XSParagraph.xs" items -= 2; if (items > 0) { items--; arg_in = ST(2); if (SvOK(arg_in)) transparent = (int)SvIV(arg_in); } /* Always convert the input to UTF8 with sv_utf8_upgrade, so we can process it properly in xspara_add_next. */ if (!SvUTF8 (text_in)) sv_utf8_upgrade (text_in); text = SvPV (text_in, text_len); xspara_set_state (paragraph); retval = xspara_add_next (text, text_len, transparent); RETVAL = newSVpv (retval, 0); SvUTF8_on (RETVAL); #line 466 "XSParagraph.c" RETVAL = sv_2mortal(RETVAL); ST(0) = RETVAL; } XSRETURN(1); } XS_EUPXS(XS_Texinfo__XS__XSParagraph_remove_end_sentence); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_remove_end_sentence) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; #line 206 "XSParagraph.xs" xspara_set_state (paragraph); xspara_remove_end_sentence (); #line 486 "XSParagraph.c" } XSRETURN_EMPTY; } XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_end_sentence); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_add_end_sentence) { dVAR; dXSARGS; if (items != 2) croak_xs_usage(cv, "paragraph, value"); { SV * paragraph = ST(0) ; SV * value = ST(1) ; #line 214 "XSParagraph.xs" int intvalue = 0; #line 505 "XSParagraph.c" #line 216 "XSParagraph.xs" if (SvOK(value)) intvalue = (int)SvIV(value); xspara_set_state (paragraph); xspara_add_end_sentence (intvalue); #line 511 "XSParagraph.c" } XSRETURN_EMPTY; } XS_EUPXS(XS_Texinfo__XS__XSParagraph_allow_end_sentence); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_allow_end_sentence) { dVAR; dXSARGS; if (items != 1) croak_xs_usage(cv, "paragraph"); { SV * paragraph = ST(0) ; #line 225 "XSParagraph.xs" xspara_set_state (paragraph); xspara_allow_end_sentence (); #line 529 "XSParagraph.c" } XSRETURN_EMPTY; } XS_EUPXS(XS_Texinfo__XS__XSParagraph_set_space_protection); /* prototype to pass -Wmissing-prototypes */ XS_EUPXS(XS_Texinfo__XS__XSParagraph_set_space_protection) { dVAR; dXSARGS; if (items < 2) croak_xs_usage(cv, "paragraph, space_protection_in, ..."); { SV * paragraph = ST(0) ; SV * space_protection_in = ST(1) ; #line 236 "XSParagraph.xs" int space_protection = -1; int ignore_columns = -1; int keep_end_lines = -1; int french_spacing = -1; int double_width_no_break = -1; SV *arg_in; #line 553 "XSParagraph.c" char * RETVAL; dXSTARG; #line 243 "XSParagraph.xs" if (SvOK(space_protection_in)) space_protection = (int)SvIV(space_protection_in); /* Get optional arguments from stack. */ items -= 2; if (items > 0) { items--; arg_in = ST(2); if (SvOK(arg_in)) ignore_columns = (int)SvIV(arg_in); } if (items > 0) { items--; arg_in = ST(3); if (SvOK(arg_in)) keep_end_lines = (int)SvIV(arg_in); } if (items > 0) { items--; arg_in = ST(4); if (SvOK(arg_in)) french_spacing = (int)SvIV(arg_in); } if (items > 0) { items--; arg_in = ST(5); if (SvOK(arg_in)) double_width_no_break = (int)SvIV(arg_in); } xspara_set_state (paragraph); RETVAL = xspara_set_space_protection (space_protection, ignore_columns, keep_end_lines, french_spacing, double_width_no_break); #line 594 "XSParagraph.c" sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; } XSRETURN(1); } #ifdef __cplusplus extern "C" #endif XS_EXTERNAL(boot_Texinfo__XS__XSParagraph); /* prototype to pass -Wmissing-prototypes */ XS_EXTERNAL(boot_Texinfo__XS__XSParagraph) { #if PERL_VERSION_LE(5, 21, 5) dVAR; dXSARGS; #else dVAR; dXSBOOTARGSXSAPIVERCHK; #endif #if (PERL_REVISION == 5 && PERL_VERSION < 9) char* file = __FILE__; #else const char* file = __FILE__; #endif PERL_UNUSED_VAR(file); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(items); /* -W */ #if PERL_VERSION_LE(5, 21, 5) XS_VERSION_BOOTCHECK; # ifdef XS_APIVERSION_BOOTCHECK XS_APIVERSION_BOOTCHECK; # endif #endif (void)newXSproto_portable("Texinfo::XS::XSParagraph::init", XS_Texinfo__XS__XSParagraph_init, file, "$$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::set_state", XS_Texinfo__XS__XSParagraph_set_state, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::new", XS_Texinfo__XS__XSParagraph_new, file, "$;@"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::end_line_count", XS_Texinfo__XS__XSParagraph_end_line_count, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::_end_line", XS_Texinfo__XS__XSParagraph__end_line, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::end_line", XS_Texinfo__XS__XSParagraph_end_line, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::get_pending", XS_Texinfo__XS__XSParagraph_get_pending, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::add_pending_word", XS_Texinfo__XS__XSParagraph_add_pending_word, file, "$;@"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::end", XS_Texinfo__XS__XSParagraph_end, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::add_text", XS_Texinfo__XS__XSParagraph_add_text, file, "$$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::add_next", XS_Texinfo__XS__XSParagraph_add_next, file, "$$;@"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::remove_end_sentence", XS_Texinfo__XS__XSParagraph_remove_end_sentence, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::add_end_sentence", XS_Texinfo__XS__XSParagraph_add_end_sentence, file, "$$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::allow_end_sentence", XS_Texinfo__XS__XSParagraph_allow_end_sentence, file, "$"); (void)newXSproto_portable("Texinfo::XS::XSParagraph::set_space_protection", XS_Texinfo__XS__XSParagraph_set_space_protection, file, "$$;@"); #if PERL_VERSION_LE(5, 21, 5) # if PERL_VERSION_GE(5, 9, 0) if (PL_unitcheckav) call_list(PL_scopestack_ix, PL_unitcheckav); # endif XSRETURN_YES; #else Perl_xs_boot_epilog(aTHX_ ax); #endif }