Affix
view release on metacpan or search on metacpan
dyncall/CMakeLists.txt view on Meta::CPAN
enable_language(CXX)
endif()
include(CheckCCompilerFlag)
check_c_compiler_flag("-fPIC -Werror" COMPILER_HAS_FPIC)
add_custom_target(show-compiler-predefs COMMAND ${CMAKE_C_COMPILER_PREDEFINES_COMMAND})
# compile_asm(TARGET target ASM_FILES file1 [file2 ...] OUTPUT_OBJECTS [variableName])
# CMake does not support the ARM or ARM64 assemblers on Windows when using the
# MSBuild generator.
# credit to dotnet/runtime:
# https://github.com/dotnet/runtime/blob/e98fb61d8b4bb6687ccddead861d8b140751647b/eng/native/functions.cmake#L173-L207
function(compile_asm)
set(options "")
set(oneValueArgs TARGET OUTPUT_OBJECTS)
set(multiValueArgs ASM_FILES)
cmake_parse_arguments(COMPILE_ASM "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGV})
set (ASSEMBLED_OBJECTS "")
foreach(ASM_FILE ${COMPILE_ASM_ASM_FILES})
get_filename_component(name ${ASM_FILE} NAME_WE)
# Produce object file where CMake would store .obj files for an OBJECT library.
# ex: artifacts\obj\coreclr\windows.arm64.Debug\src\vm\wks\cee_wks.dir\Debug\AsmHelpers.obj
set (OBJ_FILE "${CMAKE_CURRENT_BINARY_DIR}/${COMPILE_ASM_TARGET}.dir/${CMAKE_CFG_INTDIR}/${name}.obj")
# Need to compile asm file using custom command as include directories are not provided to asm compiler
add_custom_command(OUTPUT ${OBJ_FILE}
COMMAND "${CMAKE_ASM_COMPILER}" ${ASM_INCLUDE_DIRECTORIES} -o ${OBJ_FILE} ${ASM_FILE}
DEPENDS ${ASM_FILE}
COMMENT "Assembling ${ASM_FILE} ---> \"${CMAKE_ASM_COMPILER}\" ${ASM_INCLUDE_DIRECTORIES} -o ${OBJ_FILE} ${ASM_FILE}"+ COMMENT "Assembling ${ASM_FILE} ---> \"${CMAKE_ASM_COMPILER}\" ${ASM_INCLUDE_DIRECTO...
# mark obj as source that does not require compile
set_source_files_properties(${OBJ_FILE} PROPERTIES EXTERNAL_OBJECT TRUE)
# Add the generated OBJ in the dependency list so that it gets consumed during linkage
list(APPEND ASSEMBLED_OBJECTS ${OBJ_FILE})
endforeach()
set(${COMPILE_ASM_OUTPUT_OBJECTS} ${ASSEMBLED_OBJECTS} PARENT_SCOPE)
endfunction()
if(MSVC)
if("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
# Explicitly specify the assembler to be used for Arm64 compile
file(TO_CMAKE_PATH "$ENV{VCToolsInstallDir}\\bin\\HostX64\\arm64\\armasm64.exe" CMAKE_ASM_COMPILER)
# file(TO_CMAKE_PATH "C:\\Program Files (x86)\\Microsoft Visual Studio\\2019\\Enterprise\\VC\\Tools\\MSVC\\14.28.29333\\bin\\HostX64\\arm64\\armasm64.exe" CMAKE_ASM_COMPILER)
set(CMAKE_ASM_MASM_COMPILER ${CMAKE_ASM_COMPILER})
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
# Under the terms of Contract DE-AC04-94AL85000, there is a non-exclusive
# license for use of this work by or on behalf of the
# U.S. Government. Redistribution and use in source and binary forms, with
# or without modification, are permitted provided that this Notice and any
# statement of authorship are reproduced on all copies.
#
# The following MACROS are defined:
#
# ADD_LATEX_DOCUMENT(<tex_file>
# [BIBFILES <bib_files>]
# [INPUTS <input_tex_files>]
# [IMAGE_DIRS] <image_directories>
# [IMAGES] <image_files>
# [CONFIGURE] <tex_files>
# [DEPENDS] <tex_files>
# [USE_INDEX] [USE_GLOSSARY]
# [DEFAULT_PDF] [MANGLE_TARGET_NAMES])
# Adds targets that compile <tex_file>. The latex output is placed
# in LATEX_OUTPUT_PATH or CMAKE_CURRENT_BINARY_DIR if the former is
# not set. The latex program is picky about where files are located,
# so all input files are copied from the source directory to the
# output directory. This includes the target tex file, any tex file
# listed with the INPUTS option, the bibliography files listed with
# the BIBFILES option, and any .cls, .bst, and .clo files found in
# the current source directory. Images found in the IMAGE_DIRS
# directories or listed by IMAGES are also copied to the output
# directory and coverted to an appropriate format if necessary. Any
# tex files also listed with the CONFIGURE option are also processed
# with the CMake CONFIGURE_FILE command (with the @ONLY flag. Any
# file listed in CONFIGURE but not the target tex file or listed with
# INPUTS has no effect. DEPENDS can be used to specify generated files
# that are needed to compile the latex target.
#
# The following targets are made:
# dvi: Makes <name>.dvi
# pdf: Makes <name>.pdf using pdflatex.
# safepdf: Makes <name>.pdf using ps2pdf. If using the default
# program arguments, this will ensure all fonts are
# embedded and no lossy compression has been performed
# on images.
# ps: Makes <name>.ps
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
# 1.7.1 Fixed some dependency issues.
#
# 1.7.0 Added DEPENDS options (thanks to Theodore Papadopoulo).
#
# 1.6.1 Ported the makeglossaries command to CMake and embedded the port
# into UseLATEX.cmake.
#
# 1.6.0 Allow the use of the makeglossaries command. Thanks to Oystein
# S. Haaland for the patch.
#
# 1.5.0 Allow any type of file in the INPUTS lists, not just tex file
# (suggested by Eric Noulard). As a consequence, the ability to
# specify tex files without the .tex extension is removed. The removed
# function is of dubious value anyway.
#
# When copying input files, skip over any file that exists in the
# binary directory but does not exist in the source directory with the
# assumption that these files were added by some other mechanism. I
# find this useful when creating large documents with multiple
# chapters that I want to build separately (for speed) as I work on
# them. I use the same boilerplate as the starting point for all
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
# Since its external use is pretty much deprecated, I removed that
# documentation.
#
# 1.4.1 Copy .sty files along with the other class and package files.
#
# 1.4.0 Added a MANGLE_TARGET_NAMES option that will mangle the target names.
#
# Fixed problem with copying bib files that became apparent with
# CMake 2.4.
#
# 1.3.0 Added a LATEX_OUTPUT_PATH variable that allows you or the user to
# specify where the built latex documents to go. This is especially
# handy if you want to do in-source builds.
#
# Removed the ADD_LATEX_IMAGES macro and absorbed the functionality
# into ADD_LATEX_DOCUMENT. The old interface was always kind of
# clunky anyway since you had to specify the image directory in both
# places. It also made supporting LATEX_OUTPUT_PATH problematic.
#
# Added support for jpeg files.
#
# 1.2.0 Changed the configuration options yet again. Removed the NO_CONFIGURE
# Replaced it with a CONFIGURE option that lists input files for which
# configure should be run.
#
# The pdf target no longer depends on the dvi target. This allows you
# to build latex documents that require pdflatex. Also added an option
# to make the pdf target the default one.
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
ENDIF(NOT ${VAR})
ENDMACRO(LATEX_NEEDIT)
MACRO(LATEX_WANTIT VAR NAME)
IF (NOT ${VAR})
MESSAGE(STATUS "I could not find the ${NAME} command.")
ENDIF(NOT ${VAR})
ENDMACRO(LATEX_WANTIT)
MACRO(LATEX_SETUP_VARIABLES)
SET(LATEX_OUTPUT_PATH "${LATEX_OUTPUT_PATH}"
CACHE PATH "If non empty, specifies the location to place LaTeX output."
)
FIND_PACKAGE(LATEX)
MARK_AS_ADVANCED(CLEAR
LATEX_COMPILER
PDFLATEX_COMPILER
BIBTEX_COMPILER
MAKEINDEX_COMPILER
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
SET(LATEX_DVI_IMAGE_EXTENSIONS
${LATEX_DVI_VECTOR_IMAGE_EXTENSIONS} ${LATEX_DVI_RASTER_IMAGE_EXTENSIONS})
SET(LATEX_PDF_VECTOR_IMAGE_EXTENSIONS .pdf)
SET(LATEX_PDF_RASTER_IMAGE_EXTENSIONS .png .jpeg .jpg)
SET(LATEX_PDF_IMAGE_EXTENSIONS
${LATEX_PDF_VECTOR_IMAGE_EXTENSIONS} ${LATEX_PDF_RASTER_IMAGE_EXTENSIONS})
SET(LATEX_IMAGE_EXTENSIONS
${LATEX_DVI_IMAGE_EXTENSIONS} ${LATEX_PDF_IMAGE_EXTENSIONS})
ENDMACRO(LATEX_SETUP_VARIABLES)
MACRO(LATEX_GET_OUTPUT_PATH var)
SET(${var})
IF (LATEX_OUTPUT_PATH)
IF ("${LATEX_OUTPUT_PATH}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
MESSAGE(SEND_ERROR "You cannot set LATEX_OUTPUT_PATH to the same directory that contains LaTeX input files.")
ELSE ("${LATEX_OUTPUT_PATH}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
SET(${var} "${LATEX_OUTPUT_PATH}")
ENDIF ("${LATEX_OUTPUT_PATH}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
ELSE (LATEX_OUTPUT_PATH)
IF ("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
MESSAGE(SEND_ERROR "LaTeX files must be built out of source or you must set LATEX_OUTPUT_PATH.")
ELSE ("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
SET(${var} "${CMAKE_CURRENT_BINARY_DIR}")
ENDIF ("${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
ENDIF (LATEX_OUTPUT_PATH)
ENDMACRO(LATEX_GET_OUTPUT_PATH)
MACRO(LATEX_ADD_CONVERT_COMMAND output_path input_path output_extension
input_extension flags)
SET (converter ${IMAGEMAGICK_CONVERT})
SET (convert_flags "")
# ImageMagick has broken eps to pdf conversion
# use ps2pdf instead
IF (${input_extension} STREQUAL ".eps" AND ${output_extension} STREQUAL ".pdf")
IF (PS2PDF_CONVERTER)
SET (converter ${PS2PDF_CONVERTER})
SET (convert_flags "-dEPSCrop ${flags}")
ELSE (PS2PDF_CONVERTER)
MESSAGE(SEND_ERROR "Using postscript files with pdflatex requires ps2pdf for conversion.")
ENDIF (PS2PDF_CONVERTER)
ELSE (${input_extension} STREQUAL ".eps" AND ${output_extension} STREQUAL ".pdf")
SET (convert_flags ${flags})
ENDIF (${input_extension} STREQUAL ".eps" AND ${output_extension} STREQUAL ".pdf")
ADD_CUSTOM_COMMAND(OUTPUT ${output_path}
COMMAND ${converter}
ARGS ${convert_flags} ${input_path} ${output_path}
DEPENDS ${input_path}
)
ENDMACRO(LATEX_ADD_CONVERT_COMMAND)
# Makes custom commands to convert a file to a particular type.
MACRO(LATEX_CONVERT_IMAGE output_files input_file output_extension convert_flags
output_extensions other_files)
SET(input_dir ${CMAKE_CURRENT_SOURCE_DIR})
LATEX_GET_OUTPUT_PATH(output_dir)
GET_FILENAME_COMPONENT(extension "${input_file}" EXT)
STRING(REGEX REPLACE "\\.[^.]*\$" ${output_extension} output_file
"${input_file}")
LATEX_LIST_CONTAINS(is_type ${extension} ${output_extensions})
IF (is_type)
IF (convert_flags)
LATEX_ADD_CONVERT_COMMAND(${output_dir}/${output_file}
${input_dir}/${input_file} ${output_extension} ${extension}
"${convert_flags}")
SET(${output_files} ${${output_files}} ${output_dir}/${output_file})
ELSE (convert_flags)
# As a shortcut, we can just copy the file.
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${input_file}
COMMAND ${CMAKE_COMMAND}
ARGS -E copy ${input_dir}/${input_file} ${output_dir}/${input_file}
DEPENDS ${input_dir}/${input_file}
)
SET(${output_files} ${${output_files}} ${output_dir}/${input_file})
ENDIF (convert_flags)
ELSE (is_type)
SET(do_convert TRUE)
# Check to see if there is another input file of the appropriate type.
FOREACH(valid_extension ${output_extensions})
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
${input_dir}/${input_file} ${output_extension} ${extension}
"${convert_flags}")
SET(${output_files} ${${output_files}} ${output_dir}/${output_file})
ENDIF (do_convert)
ENDIF (is_type)
ENDMACRO(LATEX_CONVERT_IMAGE)
# Adds custom commands to process the given files for dvi and pdf builds.
# Adds the output files to the given variables (does not replace).
MACRO(LATEX_PROCESS_IMAGES dvi_outputs pdf_outputs)
LATEX_GET_OUTPUT_PATH(output_dir)
FOREACH(file ${ARGN})
IF (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${file}")
GET_FILENAME_COMPONENT(extension "${file}" EXT)
SET(convert_flags)
# Check to see if we need to downsample the image.
LATEX_LIST_CONTAINS(is_raster extension
${LATEX_DVI_RASTER_IMAGE_EXTENSIONS}
${LATEX_PDF_RASTER_IMAGE_EXTENSIONS})
IF (LATEX_SMALL_IMAGES)
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
ENDMACRO(ADD_LATEX_IMAGES)
MACRO(LATEX_COPY_GLOBBED_FILES pattern dest)
FILE(GLOB file_list ${pattern})
FOREACH(in_file ${file_list})
GET_FILENAME_COMPONENT(out_file ${in_file} NAME)
CONFIGURE_FILE(${in_file} ${dest}/${out_file} COPYONLY)
ENDFOREACH(in_file)
ENDMACRO(LATEX_COPY_GLOBBED_FILES)
MACRO(LATEX_COPY_INPUT_FILE file)
LATEX_GET_OUTPUT_PATH(output_dir)
IF (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file})
GET_FILENAME_COMPONENT(path ${file} PATH)
FILE(MAKE_DIRECTORY ${output_dir}/${path})
LATEX_LIST_CONTAINS(use_config ${file} ${LATEX_CONFIGURE})
IF (use_config)
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/${file}
${output_dir}/${file}
@ONLY
)
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${file}
COMMAND ${CMAKE_COMMAND}
ARGS ${CMAKE_BINARY_DIR}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${file}
)
ELSE (use_config)
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${file}
COMMAND ${CMAKE_COMMAND}
ARGS -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${file} ${output_dir}/${file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${file}
)
ENDIF (use_config)
ELSE (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file})
IF (EXISTS ${output_dir}/${file})
# Special case: output exists but input does not. Assume that it was
# created elsewhere and skip the input file copy.
ELSE (EXISTS ${output_dir}/${file})
MESSAGE("Could not find input file ${CMAKE_CURRENT_SOURCE_DIR}/${file}")
ENDIF (EXISTS ${output_dir}/${file})
ENDIF (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${file})
ENDMACRO(LATEX_COPY_INPUT_FILE)
#############################################################################
# Commands provided by the UseLATEX.cmake "package"
#############################################################################
MACRO(LATEX_USAGE command message)
MESSAGE(SEND_ERROR
"${message}\nUsage: ${command}(<tex_file>\n [BIBFILES <bib_file> <bib_file> ...]\n [INPUTS <tex_file> <tex_file> ...]\n [IMAGE_DIRS <directory1> <directory2> ...]\n [IMAGES <image_file1> <image_file2>\n ...
)
ENDMACRO(LATEX_USAGE command message)
# Parses arguments to ADD_LATEX_DOCUMENT and ADD_LATEX_TARGETS and sets the
# variables LATEX_TARGET, LATEX_IMAGE_DIR, LATEX_BIBFILES, LATEX_DEPENDS, and
# LATEX_INPUTS.
MACRO(PARSE_ADD_LATEX_ARGUMENTS command)
LATEX_PARSE_ARGUMENTS(
LATEX
"BIBFILES;INPUTS;IMAGE_DIRS;IMAGES;CONFIGURE;DEPENDS"
"USE_INDEX;USE_GLOSSARY;USE_GLOSSARIES;DEFAULT_PDF;MANGLE_TARGET_NAMES"
${ARGN}
)
# The first argument is the target latex file.
IF (LATEX_DEFAULT_ARGS)
LATEX_CAR(LATEX_MAIN_INPUT ${LATEX_DEFAULT_ARGS})
LATEX_CDR(LATEX_DEFAULT_ARGS ${LATEX_DEFAULT_ARGS})
GET_FILENAME_COMPONENT(LATEX_TARGET ${LATEX_MAIN_INPUT} NAME_WE)
ELSE (LATEX_DEFAULT_ARGS)
LATEX_USAGE(${command} "No tex file target given to ${command}.")
ENDIF (LATEX_DEFAULT_ARGS)
IF (LATEX_DEFAULT_ARGS)
LATEX_USAGE(${command} "Invalid or depricated arguments: ${LATEX_DEFAULT_ARGS}")
ENDIF (LATEX_DEFAULT_ARGS)
# Backward compatibility between 1.6.0 and 1.6.1.
IF (LATEX_USE_GLOSSARIES)
SET(LATEX_USE_GLOSSARY TRUE)
ENDIF (LATEX_USE_GLOSSARIES)
ENDMACRO(PARSE_ADD_LATEX_ARGUMENTS)
MACRO(ADD_LATEX_TARGETS)
LATEX_GET_OUTPUT_PATH(output_dir)
PARSE_ADD_LATEX_ARGUMENTS(ADD_LATEX_TARGETS ${ARGV})
# Set up target names.
IF (LATEX_MANGLE_TARGET_NAMES)
SET(dvi_target ${LATEX_TARGET}_dvi)
SET(pdf_target ${LATEX_TARGET}_pdf)
SET(ps_target ${LATEX_TARGET}_ps)
SET(safepdf_target ${LATEX_TARGET}_safepdf)
SET(html_target ${LATEX_TARGET}_html)
SET(auxclean_target ${LATEX_TARGET}_auxclean)
dyncall/buildsys/cmake/Modules/UseLATEX.cmake view on Meta::CPAN
ENDFOREACH(file)
ENDFOREACH(extension)
ENDFOREACH(dir)
SET(dvi_images)
SET(pdf_images)
LATEX_PROCESS_IMAGES(dvi_images pdf_images ${LATEX_IMAGES})
SET(make_dvi_command
${CMAKE_COMMAND} -E chdir ${output_dir}
${LATEX_COMPILER} ${LATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT})
SET(make_pdf_command
${CMAKE_COMMAND} -E chdir ${output_dir}
${PDFLATEX_COMPILER} ${PDFLATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT})
SET(make_dvi_depends ${LATEX_DEPENDS} ${dvi_images})
SET(make_pdf_depends ${LATEX_DEPENDS} ${pdf_images})
FOREACH(input ${LATEX_MAIN_INPUT} ${LATEX_INPUTS})
SET(make_dvi_depends ${make_dvi_depends} ${output_dir}/${input})
SET(make_pdf_depends ${make_pdf_depends} ${output_dir}/${input})
ENDFOREACH(input)
IF (LATEX_BIBFILES)
SET(make_dvi_command ${make_dvi_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${BIBTEX_COMPILER} ${BIBTEX_COMPILER_FLAGS} ${LATEX_TARGET})
SET(make_pdf_command ${make_pdf_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${BIBTEX_COMPILER} ${BIBTEX_COMPILER_FLAGS} ${LATEX_TARGET})
FOREACH (bibfile ${LATEX_BIBFILES})
SET(make_dvi_depends ${make_dvi_depends} ${output_dir}/${bibfile})
SET(make_pdf_depends ${make_pdf_depends} ${output_dir}/${bibfile})
ENDFOREACH (bibfile ${LATEX_BIBFILES})
ENDIF (LATEX_BIBFILES)
IF (LATEX_USE_INDEX)
SET(make_dvi_command ${make_dvi_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${LATEX_COMPILER} ${LATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${MAKEINDEX_COMPILER} ${MAKEINDEX_COMPILER_FLAGS} ${LATEX_TARGET}.idx)
SET(make_pdf_command ${make_pdf_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${PDFLATEX_COMPILER} ${PDFLATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${MAKEINDEX_COMPILER} ${MAKEINDEX_COMPILER_FLAGS} ${LATEX_TARGET}.idx)
ENDIF (LATEX_USE_INDEX)
IF (LATEX_USE_GLOSSARY)
SET(make_dvi_command ${make_dvi_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${LATEX_COMPILER} ${LATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${CMAKE_COMMAND}
-D LATEX_BUILD_COMMAND=makeglossaries
-D LATEX_TARGET=${LATEX_TARGET}
-D MAKEINDEX_COMPILER=${MAKEINDEX_COMPILER}
-D MAKEGLOSSARIES_COMPILER_FLAGS=${MAKEGLOSSARIES_COMPILER_FLAGS}
-P ${LATEX_USE_LATEX_LOCATION}
)
SET(make_pdf_command ${make_pdf_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${PDFLATEX_COMPILER} ${PDFLATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${CMAKE_COMMAND}
-D LATEX_BUILD_COMMAND=makeglossaries
-D LATEX_TARGET=${LATEX_TARGET}
-D MAKEINDEX_COMPILER=${MAKEINDEX_COMPILER}
-D MAKEGLOSSARIES_COMPILER_FLAGS=${MAKEGLOSSARIES_COMPILER_FLAGS}
-P ${LATEX_USE_LATEX_LOCATION}
)
ENDIF (LATEX_USE_GLOSSARY)
SET(make_dvi_command ${make_dvi_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${LATEX_COMPILER} ${LATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${LATEX_COMPILER} ${LATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT})
SET(make_pdf_command ${make_pdf_command}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${PDFLATEX_COMPILER} ${PDFLATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT}
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${PDFLATEX_COMPILER} ${PDFLATEX_COMPILER_FLAGS} ${LATEX_MAIN_INPUT})
# Add commands and targets for building dvi outputs.
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${LATEX_TARGET}.dvi
COMMAND ${make_dvi_command}
DEPENDS ${make_dvi_depends}
)
IF (LATEX_DEFAULT_PDF)
ADD_CUSTOM_TARGET(${dvi_target}
DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
ELSE (LATEX_DEFAULT_PDF)
ADD_CUSTOM_TARGET(${dvi_target} ALL
DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
ENDIF (LATEX_DEFAULT_PDF)
# Add commands and targets for building pdf outputs (with pdflatex).
IF (PDFLATEX_COMPILER)
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${LATEX_TARGET}.pdf
COMMAND ${make_pdf_command}
DEPENDS ${make_pdf_depends}
)
IF (LATEX_DEFAULT_PDF)
ADD_CUSTOM_TARGET(${pdf_target} ALL
DEPENDS ${output_dir}/${LATEX_TARGET}.pdf)
ELSE (LATEX_DEFAULT_PDF)
ADD_CUSTOM_TARGET(${pdf_target}
DEPENDS ${output_dir}/${LATEX_TARGET}.pdf)
ENDIF (LATEX_DEFAULT_PDF)
ENDIF (PDFLATEX_COMPILER)
IF (DVIPS_CONVERTER)
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${LATEX_TARGET}.ps
COMMAND ${CMAKE_COMMAND} -E chdir ${output_dir}
${DVIPS_CONVERTER} ${DVIPS_CONVERTER_FLAGS} -o ${LATEX_TARGET}.ps ${LATEX_TARGET}.dvi
DEPENDS ${output_dir}/${LATEX_TARGET}.dvi)
ADD_CUSTOM_TARGET(${ps_target}
DEPENDS ${output_dir}/${LATEX_TARGET}.ps)
IF (PS2PDF_CONVERTER)
# Since both the pdf and safepdf targets have the same output, we
# cannot properly do the dependencies for both. When selecting safepdf,
# simply force a recompile every time.
ADD_CUSTOM_TARGET(${safepdf_target}
${CMAKE_COMMAND} -E chdir ${output_dir}
${PS2PDF_CONVERTER} ${PS2PDF_CONVERTER_FLAGS} ${LATEX_TARGET}.ps ${LATEX_TARGET}.pdf
)
ADD_DEPENDENCIES(${safepdf_target} ${ps_target})
ENDIF (PS2PDF_CONVERTER)
ENDIF (DVIPS_CONVERTER)
IF (LATEX2HTML_CONVERTER)
ADD_CUSTOM_TARGET(${html_target}
${CMAKE_COMMAND} -E chdir ${output_dir}
${LATEX2HTML_CONVERTER} ${LATEX2HTML_CONVERTER_FLAGS} ${LATEX_MAIN_INPUT}
)
ADD_DEPENDENCIES(${html_target} ${LATEX_MAIN_INPUT} ${LATEX_INPUTS})
ENDIF (LATEX2HTML_CONVERTER)
ADD_CUSTOM_TARGET(${auxclean_target}
${CMAKE_COMMAND} -E remove ${output_dir}/${LATEX_TARGET}.aux ${output_dir}/${LATEX_TARGET}.idx ${output_dir}/${LATEX_TARGET}.ind
)
ENDMACRO(ADD_LATEX_TARGETS)
MACRO(ADD_LATEX_DOCUMENT)
LATEX_GET_OUTPUT_PATH(output_dir)
IF (output_dir)
PARSE_ADD_LATEX_ARGUMENTS(ADD_LATEX_DOCUMENT ${ARGV})
LATEX_COPY_INPUT_FILE(${LATEX_MAIN_INPUT})
FOREACH (bib_file ${LATEX_BIBFILES})
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/${bib_file}
${output_dir}/${bib_file}
COPYONLY)
ADD_CUSTOM_COMMAND(OUTPUT ${output_dir}/${bib_file}
COMMAND ${CMAKE_COMMAND}
ARGS -E copy ${CMAKE_CURRENT_SOURCE_DIR}/${bib_file} ${output_dir}/${bib_file}
DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${bib_file}
)
ENDFOREACH (bib_file)
FOREACH (input ${LATEX_INPUTS})
LATEX_COPY_INPUT_FILE(${input})
ENDFOREACH(input)
LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.cls ${output_dir})
LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.bst ${output_dir})
LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.clo ${output_dir})
LATEX_COPY_GLOBBED_FILES(${CMAKE_CURRENT_SOURCE_DIR}/*.sty ${output_dir})
ADD_LATEX_TARGETS(${ARGV})
ENDIF (output_dir)
ENDMACRO(ADD_LATEX_DOCUMENT)
dyncall/doc/manual/CMakeLists.txt view on Meta::CPAN
find_package(LATEX)
if(PDFLATEX_COMPILER)
add_custom_command(
OUTPUT manual.pdf
COMMAND ${PDFLATEX_COMPILER}
ARGS manual.tex
DEPENDS manual.tex
)
file(GLOB CLEAN_FILES *.aux *.log *.lof *.lol *.lot *.out *.toc)
set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${CLEAN_FILES}")
endif()
add_custom_target(manual ALL echo DEPENDS manual.pdf)
dyncall/dyncall/CMakeLists.txt view on Meta::CPAN
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
if(MSVC)
if(CMAKE_SIZEOF_VOID_P MATCHES 4)
set(ASM_SRC dyncall_call_x86_generic_masm.asm)
elseif("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
set(ASM_SRC ${CMAKE_SOURCE_DIR}/dyncall/dyncall_call_arm64_masm.asm)
compile_asm(TARGET dyncall_s ASM_FILES ${ASM_SRC} OUTPUT_OBJECTS ASM_SRC)
else()
set(ASM_SRC dyncall_call_x64_generic_masm.asm)
endif()
else()
set(ASM_SRC dyncall_call.S)
set_source_files_properties(${ASM_SRC} PROPERTIES LANGUAGE "C")
endif()
add_library(dyncall_s STATIC ${ASM_SRC}
dyncall_vector.c
dyncall/dyncall/dyncall_call_x86_nasm.asm view on Meta::CPAN
pop edi ; restore edi, esi
pop esi
mov esp, ebp ; epilog
pop ebp
ret
;; Stack markings for ELF/GNU to specify no executable stack */
;
;%ifidn __OUTPUT_FORMAT__,elf
;section .note.GNU-stack noalloc noexec nowrite progbits
;%endif
dyncall/dyncallback/CMakeLists.txt view on Meta::CPAN
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
#
include_directories(${PROJECT_SOURCE_DIR}/dyncall)
if(MSVC)
if(CMAKE_SIZEOF_VOID_P MATCHES 4)
set(ASM_SRC dyncall_callback_x86_masm.asm)
elseif("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
set(ASM_SRC ${CMAKE_SOURCE_DIR}/dyncallback/dyncall_callback_arm64_masm.asm)
compile_asm(TARGET dyncallback_s ASM_FILES ${ASM_SRC} OUTPUT_OBJECTS ASM_SRC)
else()
set(ASM_SRC dyncall_callback_x64_masm.asm)
endif()
else()
set(ASM_SRC dyncall_callback_arch.S)
set_source_files_properties(${ASM_SRC} PROPERTIES LANGUAGE "C")
endif()
add_library(dyncallback_s STATIC ${ASM_SRC}
dyncall_thunk.c
dyncall/test/dynload_plain/CMakeLists.txt view on Meta::CPAN
add_executable(dynload_plain dynload_plain.c)
target_link_libraries(dynload_plain dynload_s ${CMAKE_DL_LIBS})
file(WRITE x.c "int dynload_plain_testfunc() { return 5; }")
add_library(x SHARED x.c)
set_target_properties(x PROPERTIES OUTPUT_NAME "dynload_plain_ß_test")
set_target_properties(x PROPERTIES PREFIX "")
set_target_properties(x PROPERTIES SUFFIX "")
if(${UNIX})
exec_program("((ldd `which ls` | grep -o '/.*/libc.so[^ ]*' || ls /lib*/libc.so* || ls /usr/lib/libc.so*) | grep -v '\\.a\$' | (sort -V -r || sort -t . -n -k 2)) 2>/dev/null | head -1" OUTPUT_VARIABLE DEF_C_DYLIB)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DDEF_C_DYLIB=\\\"${DEF_C_DYLIB}\\\"")
endif()
dyncall/test/hacking-arm-thumb-interwork/Makefile.darwin view on Meta::CPAN
all: ${LOADLIBES} test
thumb.o: thumb.c
${CC} -c ${CPPFLAGS} ${CFLAGS} ${TARGET_ARCH} -mthumb $< -o $@
arm.o: arm.c
test.o: test.c
test: test.o thumb.o arm.o
${LINK.o} $^ ${OUTPUT_OPTION}
%.s: %.c
${CC} -S ${CPPFLAGS} ${CFLAGS} ${TARGET_ARCH} $< -o $@
clean:
${RM} ${TARGETS} *.o
dyncall/test/hacking-arm-thumb-interwork/Makefile.linux view on Meta::CPAN
TARGETS = test
TARGET_ARCH += -mthumb-interwork
all: test
thumb.o: thumb.c
${COMPILE.c} $< -mthumb ${OUTPUT_OPTION}
test: test.o thumb.o arm.o
${LINK.o} $^ ${OUTPUT_OPTION}
clean:
${RM} ${TARGETS} *.o
lib/Affix.xs view on Meta::CPAN
{
dSP;
int count;
SV *err_tmp;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(lib);
mXPUSHp(symbol, strlen(symbol));
XPUSHs(args);
PUTBACK;
count = call_pv(form("Affix::%s_mangle", abi), G_SCALAR | G_EVAL | G_KEEPERR);
SPAGAIN;
err_tmp = ERRSV;
if (SvTRUE(err_tmp)) {
croak("Malformed call to %s_mangle( ... )\n", abi, SvPV_nolen(err_tmp));
POPs;
}
else if (count != 1) { croak("Failed to mangle %s symbol named %s", abi, abi); }
else {
retval = POPp;
lib/Affix.xs view on Meta::CPAN
SV *_instanceof(pTHX_ SV *type) {
SV *retval;
char *name = SvPV_nolen(*hv_fetchs(MUTABLE_HV(SvRV(type)), "package", 0));
{
dSP;
int count;
SV *err_tmp;
ENTER;
SAVETMPS;
PUSHMARK(SP);
PUTBACK;
count = call_pv(name, G_SCALAR | G_EVAL);
SPAGAIN;
err_tmp = ERRSV;
if (SvTRUE(err_tmp)) {
croak("Malformed InstanceOf[ '%s' ]; %s\n", name, SvPV_nolen(err_tmp));
POPs;
}
else {
if (count != 1) croak("Malformed InstanceOf[ '%s' ]; missing typedef", name);
retval = POPs;
lib/Affix.xs view on Meta::CPAN
static SV *call_encoding(pTHX_ const char *method, SV *obj, SV *src, SV *check) {
dSP;
I32 count;
SV *dst = &PL_sv_undef;
PUSHMARK(sp);
if (check) check = sv_2mortal(newSVsv(check));
if (!check || SvROK(check) || !SvTRUE_nomg(check)) src = sv_2mortal(newSVsv(src));
XPUSHs(obj);
XPUSHs(src);
XPUSHs(check ? check : &PL_sv_no);
PUTBACK;
count = call_method(method, G_SCALAR);
SPAGAIN;
if (count > 0) {
dst = POPs;
SvREFCNT_inc(dst);
}
PUTBACK;
return dst;
}
// https://www.gnu.org/software/libunistring/manual/html_node/The-wchar_005ft-mess.html
// TODO: store this SV* for the sake of speed
static SV *find_encoding(pTHX) {
char encoding[9];
my_snprintf(encoding, 9, "UTF-%d%cE", (WCHAR_T_SIZE == 2 ? 16 : 32),
((BYTEORDER == 0x1234 || BYTEORDER == 0x12345678) ? 'L' : 'B'));
// warn("encoding: %s", encoding);
dSP;
int count;
require_pv("Encode.pm");
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(encoding, 0)));
PUTBACK;
count = call_pv("Encode::find_encoding", G_SCALAR);
SPAGAIN;
if (SvTRUE(ERRSV)) {
warn("Error: %s\n", SvPV_nolen(ERRSV));
(void)POPs;
}
if (count != 1) croak("find_encoding fault: bad number of returned values: %d", count);
SV *encode = POPs;
SvREFCNT_inc(encode);
PUTBACK;
FREETMPS;
LEAVE;
return encode;
}
char cbHandler(DCCallback *, DCArgs *, DCValue *, DCpointer);
SV *ptr2sv(pTHX_ DCpointer ptr, SV *type) {
SV *RETVAL = newSV(0);
char *_type = SvPV_nolen(type);
lib/Affix.xs view on Meta::CPAN
case DC_SIGCHAR_POINTER: {
HV *hv_ptr = MUTABLE_HV(SvRV(type));
SV **type_ptr = hv_fetchs(hv_ptr, "type", 0);
DCpointer value = safemalloc(_sizeof(aTHX_ * type_ptr));
if (SvOK(data)) sv2ptr(aTHX_ * type_ptr, data, value, packed);
Copy(&value, ptr, 1, intptr_t);
} break;
case DC_SIGCHAR_WIDE_CHAR: {
char *eh = SvPV_nolen(data);
dXSARGS;
PUTBACK;
const char *pat = "W";
SSize_t s = unpackstring(pat, pat + 1, eh, eh + WCHAR_T_SIZE + 1, SVt_PVAV);
SPAGAIN;
if (s != 1) croak("Failed to unpack wchar_t");
SV *data = POPs;
switch (WCHAR_T_SIZE) {
case I8SIZE:
if (SvPOK(data)) {
char *value = SvPV_nolen(data);
Copy(&value, ptr, 1, char);
lib/Affix.xs view on Meta::CPAN
SV *sv = newSV(0);
if (ptr != NULL && SvOK(MUTABLE_SV(ptr))) { sv = MUTABLE_SV(ptr); }
PUSHs(sv);
} break;
default:
croak("Unhandled callback arg. Type: %c [%s]", cbx->sig[i], cbx->sig);
break;
}
}
}
PUTBACK;
if (cbx->ret == DC_SIGCHAR_VOID) {
count = call_sv(cbx->cv, G_VOID);
SPAGAIN;
}
else {
count = call_sv(cbx->cv, G_SCALAR);
SPAGAIN;
if (count != 1) croak("Big trouble: %d returned items", count);
SV *ret = POPs;
switch (ret_c) {
lib/Affix.xs view on Meta::CPAN
} break;
case DC_SIGCHAR_STRING:
result->Z = SvPOK(ret) ? SvPVx_nolen_const(ret) : NULL;
break;
case DC_SIGCHAR_WIDE_STRING:
result->p = SvPOK(ret) ? (DCpointer)SvPVx_nolen_const(ret) : NULL;
ret_c = DC_SIGCHAR_POINTER;
break;
case DC_SIGCHAR_WIDE_CHAR: {
char *eh = SvPV_nolen(ret);
PUTBACK;
const char *pat = "W";
SSize_t s = unpackstring(pat, pat + 1, eh, eh + WCHAR_T_SIZE + 1, SVt_PVAV);
SPAGAIN;
if (s != 1) croak("Failed to unpack wchar_t");
switch (WCHAR_T_SIZE) {
case I8SIZE:
result->c = (char)POPi;
ret_c = DC_SIGCHAR_CHAR;
break;
case SHORTSIZE:
lib/Affix.xs view on Meta::CPAN
case DC_SIGCHAR_STRUCT:
case DC_SIGCHAR_UNION:
case DC_SIGCHAR_INSTANCEOF:
case DC_SIGCHAR_ANY:
//~ result->p = SvPOK(ret) ? sv2ptr(aTHX_ ret, _instanceof(aTHX_ cbx->retval), false):
// NULL; ~ ret_c = DC_SIGCHAR_POINTER; ~ break;
default:
croak("Unhandled return from callback: %c", ret_c);
}
}
PUTBACK;
FREETMPS;
LEAVE;
return ret_c;
}
typedef struct {
SV *type;
void *ptr;
lib/Affix.xs view on Meta::CPAN
SV *RETVAL;
{
dSP;
int count;
ENTER;
SAVETMPS;
PUSHMARK(SP);
mXPUSHs(newSVpv(package, 0));
for (int i = 0; i < items; i++)
mXPUSHs(newSVsv(ST(i)));
PUTBACK;
count = call_method("new", G_SCALAR);
SPAGAIN;
if (count != 1) croak("Big trouble\n");
RETVAL = newSVsv(POPs);
PUTBACK;
FREETMPS;
LEAVE;
}
RETVAL = sv_2mortal(RETVAL);
ST(0) = RETVAL;
XSRETURN(1);
}
XS_INTERNAL(Types) {
dVAR;
lib/Affix.xs view on Meta::CPAN
dcArgChar(MY_CXT.cvm, (char)(SvIOK(ST(pos_arg)) ? SvIV(ST(pos_arg))
: *SvPV_nolen(ST(pos_arg))));
break;
case DC_SIGCHAR_UCHAR:
dcArgChar(MY_CXT.cvm,
(unsigned char)(SvIOK(ST(pos_arg)) ? SvUV(ST(pos_arg))
: *SvPV_nolen(ST(pos_arg))));
break;
case DC_SIGCHAR_WIDE_CHAR: {
char *eh = SvPV_nolen(ST(pos_arg));
PUTBACK;
const char *pat = "W";
SSize_t s = unpackstring(pat, pat + 1, eh, eh + WCHAR_T_SIZE + 1, SVt_PVAV);
SPAGAIN;
if (s != 1) croak("Failed to unpack wchar_t");
switch (WCHAR_T_SIZE) {
case I8SIZE:
dcArgChar(MY_CXT.cvm, (char)POPi);
break;
case SHORTSIZE:
dcArgShort(MY_CXT.cvm, (short)POPi);
lib/Affix.xs view on Meta::CPAN
// clang-format off
MODULE = Affix PACKAGE = Affix
# Override default typemap
TYPEMAP: <<HERE
DCpointer T_DCPOINTER
INPUT
T_DCPOINTER
if (sv_derived_from($arg, \"Affix::Pointer\")){
IV tmp = SvIV((SV*)SvRV($arg));
$var = INT2PTR($type, tmp);
}
else
croak(\"$var is not of type Affix::Pointer\");
OUTPUT
T_DCPOINTER
sv_setref_pv($arg,\"Affix::Pointer\", $var);
HERE
BOOT:
// clang-format on
#ifdef USE_ITHREADS
my_perl = (PerlInterpreter *)PERL_GET_CONTEXT;
#endif
lib/Affix.xs view on Meta::CPAN
if (len == 0) croak("Failed to get library name");
DLSyms *syms = dlSymsInit(name);
int count = dlSymsCount(syms);
for (int i = 0; i < count; ++i) {
av_push(RETVAL, newSVpv(dlSymsName(syms, i), 0));
}
dlSymsCleanup(syms);
safefree(name);
}
// clang-format off
OUTPUT:
RETVAL
DLLib *
load_lib(const char * lib_name)
CODE:
{
// clang-format on
// Use perl to get the actual path to the library
{
dSP;
int count;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(ST(0));
PUTBACK;
count = call_pv("Affix::locate_lib", G_SCALAR);
SPAGAIN;
if (count == 1) lib_name = SvPVx_nolen(POPs);
PUTBACK;
FREETMPS;
LEAVE;
}
RETVAL =
#if defined(_WIN32) || defined(_WIN64)
dlLoadLibrary(lib_name);
#else
(DLLib *)dlopen(lib_name, RTLD_LAZY /* RTLD_NOW|RTLD_GLOBAL */);
#endif
if (RETVAL == NULL) {
lib/Affix.xs view on Meta::CPAN
unsigned int err = GetLastError();
croak("Failed to load %s: %d", lib_name, err);
#else
char *reason = dlerror();
croak("Failed to load %s: %s", lib_name, reason);
#endif
XSRETURN_EMPTY;
}
}
// clang-format off
OUTPUT:
RETVAL
void
pin(SV *sv, lib, symbol, SV *type);
const char * symbol
PREINIT:
struct ufuncs uf;
PPCODE:
// clang-format on
{
lib/Affix.xs view on Meta::CPAN
char *lib_name = (char *)SvPV_nolen(ST(1));
// Use perl to get the actual path to the library
{
dSP;
int count;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(ST(1));
PUTBACK;
count = call_pv("Affix::locate_lib", G_SCALAR);
SPAGAIN;
if (count == 1) lib_name = SvPVx_nolen(POPs);
PUTBACK;
FREETMPS;
LEAVE;
}
lib =
#if defined(_WIN32) || defined(_WIN64)
dlLoadLibrary(lib_name);
#else
(DLLib *)dlopen(lib_name, RTLD_LAZY /* RTLD_NOW|RTLD_GLOBAL */);
#endif
if (lib == NULL) {
lib/Affix.xs view on Meta::CPAN
char *lib_name = (char *)SvPV_nolen(_lib);
// Use perl to get the actual path to the library
{
dSP;
int count;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(_lib);
PUTBACK;
count = call_pv("Affix::locate_lib", G_SCALAR);
SPAGAIN;
if (count == 1) lib_name = SvPVx_nolen(POPs);
PUTBACK;
FREETMPS;
LEAVE;
}
lib =
#if defined(_WIN32) || defined(_WIN64)
dlLoadLibrary(lib_name);
#else
(DLLib *)dlopen(lib_name, RTLD_LAZY /* RTLD_NOW|RTLD_GLOBAL */);
#endif
if (lib == NULL) {
lib/Affix.xs view on Meta::CPAN
case DC_SIGCHAR_CC_PREFIX: { // Don't add to perl sig or inc arg count
char cc[1];
{
dSP;
int count;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(*type_ref);
PUTBACK;
count = call_method("csig", G_SCALAR);
SPAGAIN;
if (count == 1) Copy(POPp, cc, 1, char);
PUTBACK;
FREETMPS;
LEAVE;
}
call->sig[c_sig_pos++] = cc[0];
if (i == 0 &&
!(cc[0] != DC_SIGCHAR_CC_ELLIPSIS || cc[0] != DC_SIGCHAR_CC_ELLIPSIS_VARARGS)) {
call->reset = false;
}
}
continue;
lib/Affix.xs view on Meta::CPAN
STMT_START {
cv = newXSproto_portable((ix == 0 ? func_name : NULL), Affix_call, file, call->perl_sig);
if (cv == NULL) croak("ARG! Something went really wrong while installing a new XSUB!");
XSANY.any_ptr = (DCpointer)call;
}
STMT_END;
RETVAL = sv_bless((ix == 1 ? newRV_noinc(MUTABLE_SV(cv)) : newRV_inc(MUTABLE_SV(cv))),
gv_stashpv("Affix", GV_ADD));
}
// clang-format off
OUTPUT:
RETVAL
void
typedef(char * name, IN_OUTLIST SV * type)
CODE:
// clang-format on
{
{
CV *cv = newXSproto_portable(name, Types_return_typedef, __FILE__, "");
XSANY.any_sv = SvREFCNT_inc(newSVsv(type));
lib/Affix.xs view on Meta::CPAN
}
else if (sv_derived_from(type, "Affix::Type::Struct")) {
HV *href = MUTABLE_HV(SvRV(type));
hv_stores(href, "typedef", newSVpv(name, 0));
}
}
else
croak("Expected a subclass of Affix::Type::Base");
}
// clang-format off
OUTPUT:
type
void
CLONE(...)
CODE :
MY_CXT_CLONE;
void
sv_dump(SV * sv)
CODE :
sv_dump(sv);
DCpointer
sv2ptr( SV * data, SV * type)
CODE:
RETVAL = safemalloc(_sizeof(aTHX_ type));
sv2ptr(aTHX_ type, data, RETVAL, false);
OUTPUT:
RETVAL
SV *
ptr2sv(DCpointer ptr, SV * type)
CODE:
RETVAL = ptr2sv(aTHX_ ptr, type);
OUTPUT:
RETVAL
void
DumpHex(DCpointer ptr, size_t size)
CODE:
DumpHex(ptr, size);
BOOT :
// clang-format on
{
lib/Affix.xs view on Meta::CPAN
CLEANUP(CC_ARM_ARM);
CLEANUP(CC_ARM_THUMB);
CLEANUP(CC_SYSCALL);
}
// clang-format off
size_t
sizeof(SV * type)
CODE:
RETVAL = _sizeof(aTHX_ type);
OUTPUT:
RETVAL
size_t
offsetof(SV * type, char * field)
CODE:
// clang-format on
{
if (sv_isobject(type) && (sv_derived_from(type, "Affix::Type::Struct"))) {
HV *href = MUTABLE_HV(SvRV(type));
SV **fields_ref = hv_fetch(href, "fields", 6, 0);
lib/Affix.xs view on Meta::CPAN
RETVAL = _offsetof(aTHX_ * av_fetch(av_field, 1, 0));
break;
}
if (i == field_count) croak("Given structure does not contain field named '%s'", field);
}
}
else
croak("Given type is not a structure");
}
// clang-format off
OUTPUT:
RETVAL
DCpointer
malloc(size_t size)
CODE:
// clang-format on
{
RETVAL = safemalloc(size);
if (RETVAL == NULL) XSRETURN_EMPTY;
}
// clang-format off
OUTPUT:
RETVAL
DCpointer
calloc(size_t num, size_t size)
CODE:
// clang-format off
{RETVAL = safecalloc(num, size);
if (RETVAL == NULL) XSRETURN_EMPTY;}
// clang-format off
OUTPUT:
RETVAL
DCpointer
realloc(IN_OUT DCpointer ptr, size_t size)
CODE:
ptr = saferealloc(ptr, size);
OUTPUT:
RETVAL
void
free(DCpointer ptr)
PPCODE:
// clang-format on
{
if (ptr) {
safefree(ptr);
ptr = NULL;
lib/Affix.xs view on Meta::CPAN
else if (SvIOK(ST(1))) {
IV tmp = SvIV((SV *)(ST(1)));
rhs = INT2PTR(DCpointer, tmp);
}
else if (SvPOK(ST(1))) { rhs = (DCpointer)(unsigned char *)SvPV_nolen(ST(1)); }
else
croak("dest is not of type Affix::Pointer");
RETVAL = memcmp(lhs, rhs, count);
}
// clang-format off
OUTPUT:
RETVAL
DCpointer
memset(DCpointer dest, char ch, size_t count)
void
memcpy(dest, src, size_t nitems)
INIT:
DCpointer dest, src;
PPCODE:
lib/Affix.xs view on Meta::CPAN
FALLBACK: TRUE
IV
plus(DCpointer ptr, IV other, IV swap)
OVERLOAD: +
CODE:
// clang-format on
RETVAL = PTR2IV(ptr) + other;
// clang-format off
OUTPUT:
RETVAL
IV
minus(DCpointer ptr, IV other, IV swap)
OVERLOAD: -
CODE:
// clang-format on
RETVAL = PTR2IV(ptr) - other;
// clang-format off
OUTPUT:
RETVAL
char *
as_string(DCpointer ptr, ...)
OVERLOAD: \"\"
CODE:
// clang-format on
RETVAL = (char *)ptr;
// clang-format off
OUTPUT:
RETVAL
SV *
raw(ptr, size_t size, bool utf8 = false)
CODE:
// clang-format on
{
DCpointer ptr;
if (sv_derived_from(ST(0), "Affix::Pointer")) {
IV tmp = SvIV((SV *)SvRV(ST(0)));
lib/Affix.xs view on Meta::CPAN
}
else if (SvIOK(ST(0))) {
IV tmp = SvIV((SV *)(ST(0)));
ptr = INT2PTR(DCpointer, tmp);
}
else
croak("dest is not of type Affix::Pointer");
RETVAL = newSVpvn_utf8((const char *)ptr, size, utf8 ? 1 : 0);
}
// clang-format off
OUTPUT:
RETVAL
void
dump(ptr, size_t size)
CODE:
// clang-format on
{
DCpointer ptr;
if (sv_derived_from(ST(0), "Affix::Pointer")) {
IV tmp = SvIV((SV *)SvRV(ST(0)));
lib/typemap view on Meta::CPAN
TYPEMAP
// https://perldoc.perl.org/perlxs#Returning-SVs,-AVs-and-HVs-through-RETVAL
AV * T_AVREF_REFCOUNT_FIXED
DLLib * T_DLL
INPUT
T_DLL
// $Package | $type | $ntype
if (sv_derived_from($arg, \"Affix::DLLib\")){
IV tmp = SvIV((SV*)SvRV($arg));
$var = INT2PTR($type, tmp);
}
else
croak(\"$var is not of type Affix::DLLib\");
OUTPUT
T_DLL
// $Package | $type | $ntype
sv_setref_pv($arg, \"Affix::DLLib\", (void*)$var);
( run in 0.408 second using v1.01-cache-2.11-cpan-4e96b696675 )