mirror of
https://github.com/revng/revng
synced 2026-06-21 14:07:57 +00:00
Giacomo Vercesi
de997ca2e4
Add the infrastructure code needed to allow to add mixins to Tuple-Tree Generated classes in python.
549 lines
17 KiB
CMake
549 lines
17 KiB
CMake
#
|
|
# This file is distributed under the MIT License. See LICENSE.md for details.
|
|
#
|
|
|
|
function(tuple_tree_generator_impl)
|
|
set(oneValueArgs
|
|
TARGET_NAME
|
|
EMIT_TRACKING
|
|
GENERATED_HEADERS_VARIABLE
|
|
GENERATED_IMPLS_VARIABLE
|
|
NAMESPACE
|
|
SCHEMA_PATH
|
|
HEADERS_DIR
|
|
INCLUDE_PATH_PREFIX
|
|
JSONSCHEMA_PATH
|
|
ROOT_TYPE
|
|
GLOBAL_NAME
|
|
PYTHON_PATH
|
|
TYPESCRIPT_PATH
|
|
DOCS_PATH
|
|
PYTHON_MIXINS)
|
|
set(multiValueArgs TYPESCRIPT_INCLUDE STRING_TYPES SEPARATE_STRING_TYPES
|
|
SCALAR_TYPES)
|
|
cmake_parse_arguments(GENERATOR "" "${oneValueArgs}" "${multiValueArgs}"
|
|
"${ARGN}")
|
|
if(NOT DEFINED GENERATOR_JSONSCHEMA_PATH)
|
|
set(GENERATOR_JSONSCHEMA_PATH "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_ROOT_TYPE)
|
|
set(GENERATOR_ROOT_TYPE "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_GLOBAL_NAME)
|
|
set(GENERATOR_GLOBAL_NAME "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_STRING_TYPES)
|
|
set(GENERATOR_STRING_TYPES "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_SEPARATE_STRING_TYPES)
|
|
set(GENERATOR_SEPARATE_STRING_TYPES "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_SCALAR_TYPES)
|
|
set(GENERATOR_SCALAR_TYPES "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_PYTHON_PATH)
|
|
set(GENERATOR_PYTHON_PATH "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_TYPESCRIPT_PATH)
|
|
set(GENERATOR_TYPESCRIPT_PATH "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_DOCS_PATH)
|
|
set(GENERATOR_DOCS_PATH "")
|
|
endif()
|
|
if(NOT DEFINED GENERATOR_PYTHON_MIXINS)
|
|
set(GENERATOR_PYTHON_MIXINS "")
|
|
endif()
|
|
|
|
#
|
|
# C++ headers and implementation generation
|
|
#
|
|
tuple_tree_generator_compute_generated_cpp_files(
|
|
"${GENERATOR_SCHEMA_PATH}" "${GENERATOR_HEADERS_DIR}"
|
|
LOCAL_GENERATED_HEADERS LOCAL_GENERATED_IMPLS)
|
|
|
|
tuple_tree_generator_generate_cpp(
|
|
"${GENERATOR_SCHEMA_PATH}"
|
|
"${GENERATOR_NAMESPACE}"
|
|
"${GENERATOR_HEADERS_DIR}"
|
|
"${GENERATOR_INCLUDE_PATH_PREFIX}"
|
|
"${LOCAL_GENERATED_HEADERS}"
|
|
"${LOCAL_GENERATED_IMPLS}"
|
|
"${GENERATOR_ROOT_TYPE}"
|
|
"${GENERATOR_SCALAR_TYPES}"
|
|
"${GENERATOR_EMIT_TRACKING}")
|
|
|
|
set("${GENERATOR_GENERATED_HEADERS_VARIABLE}"
|
|
${LOCAL_GENERATED_HEADERS}
|
|
PARENT_SCOPE)
|
|
set("${GENERATOR_GENERATED_IMPLS_VARIABLE}"
|
|
${LOCAL_GENERATED_IMPLS}
|
|
PARENT_SCOPE)
|
|
set(EXTRA_TARGETS)
|
|
|
|
#
|
|
# Produce JSON schema, if requested
|
|
#
|
|
if(NOT "${GENERATOR_JSONSCHEMA_PATH}" STREQUAL "")
|
|
tuple_tree_generator_generate_jsonschema(
|
|
"${GENERATOR_SCHEMA_PATH}"
|
|
"${GENERATOR_NAMESPACE}"
|
|
"${GENERATOR_ROOT_TYPE}"
|
|
"${GENERATOR_STRING_TYPES}"
|
|
"${GENERATOR_SEPARATE_STRING_TYPES}"
|
|
"${GENERATOR_SCALAR_TYPES}"
|
|
"${GENERATOR_JSONSCHEMA_PATH}")
|
|
list(APPEND EXTRA_TARGETS ${GENERATOR_JSONSCHEMA_PATH})
|
|
endif()
|
|
|
|
#
|
|
# Produce JSON schema, if requested
|
|
#
|
|
if(NOT "${GENERATOR_DOCS_PATH}" STREQUAL "")
|
|
tuple_tree_generator_generate_docs(
|
|
"${GENERATOR_SCHEMA_PATH}" "${GENERATOR_NAMESPACE}"
|
|
"${GENERATOR_DOCS_PATH}" "${GENERATOR_ROOT_TYPE}"
|
|
"${GENERATOR_SCALAR_TYPES}")
|
|
list(APPEND EXTRA_TARGETS ${GENERATOR_DOCS_PATH})
|
|
endif()
|
|
|
|
#
|
|
# Produce Python code, if requested
|
|
#
|
|
if(NOT "${GENERATOR_PYTHON_PATH}" STREQUAL "")
|
|
tuple_tree_generator_generate_python(
|
|
"${GENERATOR_SCHEMA_PATH}"
|
|
"${GENERATOR_NAMESPACE}"
|
|
"${GENERATOR_ROOT_TYPE}"
|
|
"${GENERATOR_STRING_TYPES}"
|
|
"${GENERATOR_SEPARATE_STRING_TYPES}"
|
|
"${GENERATOR_SCALAR_TYPES}"
|
|
"${GENERATOR_PYTHON_MIXINS}"
|
|
"${GENERATOR_PYTHON_PATH}")
|
|
list(APPEND EXTRA_TARGETS ${GENERATOR_PYTHON_PATH})
|
|
endif()
|
|
|
|
#
|
|
# Produce TypeScript code, if requested
|
|
#
|
|
if(NOT "${GENERATOR_TYPESCRIPT_PATH}" STREQUAL "")
|
|
tuple_tree_generator_generate_typescript(
|
|
"${GENERATOR_SCHEMA_PATH}"
|
|
"${GENERATOR_NAMESPACE}"
|
|
"${GENERATOR_ROOT_TYPE}"
|
|
"${GENERATOR_GLOBAL_NAME}"
|
|
"${GENERATOR_TYPESCRIPT_INCLUDE}"
|
|
"${GENERATOR_STRING_TYPES}"
|
|
"${GENERATOR_SEPARATE_STRING_TYPES}"
|
|
"${GENERATOR_SCALAR_TYPES}"
|
|
"${GENERATOR_TYPESCRIPT_PATH}")
|
|
list(APPEND EXTRA_TARGETS ${GENERATOR_TYPESCRIPT_PATH})
|
|
endif()
|
|
|
|
add_custom_target(
|
|
"${GENERATOR_TARGET_NAME}"
|
|
DEPENDS "${GENERATOR_SCHEMA_PATH}" ${LOCAL_GENERATED_HEADERS}
|
|
${LOCAL_GENERATED_IMPLS} ${GENERATOR_JSONSCHEMA_PATH}
|
|
${EXTRA_TARGETS} generate-node_modules)
|
|
endfunction()
|
|
|
|
# Computes the list of headers and C++ source files that will be generated by
|
|
# tuple_tree_generator. Note: the output variables will be overwritten
|
|
function(tuple_tree_generator_compute_generated_cpp_files SCHEMA_PATH
|
|
HEADERS_DIR GENERATED_HEADERS_VARIABLE GENERATED_IMPLS_VARIABLE)
|
|
# This triggers CMake upon editing the schema file. Source:
|
|
# https://cmake.org/cmake/help/latest/prop_dir/CMAKE_CONFIGURE_DEPENDS.html
|
|
# https://www.reddit.com/r/cmake/comments/iokem9/comment/g4gewpo/
|
|
set_property(
|
|
DIRECTORY
|
|
APPEND
|
|
PROPERTY CMAKE_CONFIGURE_DEPENDS "${SCHEMA_PATH}")
|
|
execute_process(
|
|
COMMAND
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-cpp-paths.py" "--forward-decls"
|
|
"--early" "--late" "${SCHEMA_PATH}" "${HEADERS_DIR}"
|
|
COMMAND "tr" "\n" ";"
|
|
OUTPUT_VARIABLE LOCAL_GENERATED_HEADERS_VARIABLE COMMAND_ERROR_IS_FATAL ANY)
|
|
|
|
execute_process(
|
|
COMMAND "${SCRIPTS_ROOT_DIR}/tuple-tree-generate-cpp-paths.py" "--impl"
|
|
"${SCHEMA_PATH}" "${HEADERS_DIR}"
|
|
COMMAND "tr" "\n" ";"
|
|
OUTPUT_VARIABLE LOCAL_GENERATED_IMPLS_VARIABLE COMMAND_ERROR_IS_FATAL ANY)
|
|
|
|
set("${GENERATED_HEADERS_VARIABLE}"
|
|
${LOCAL_GENERATED_HEADERS_VARIABLE}
|
|
PARENT_SCOPE)
|
|
set("${GENERATED_IMPLS_VARIABLE}"
|
|
${LOCAL_GENERATED_IMPLS_VARIABLE}
|
|
PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
set(TEMPLATES_DIR
|
|
"${CMAKE_SOURCE_DIR}/scripts/tuple_tree_generator/tuple_tree_generator/templates"
|
|
)
|
|
|
|
set(CPP_TEMPLATES
|
|
"${TEMPLATES_DIR}/class_forward_decls.h.tpl"
|
|
"${TEMPLATES_DIR}/enum.h.tpl"
|
|
"${TEMPLATES_DIR}/struct.h.tpl"
|
|
"${TEMPLATES_DIR}/struct_forward_decls.h.tpl"
|
|
"${TEMPLATES_DIR}/struct_late.h.tpl"
|
|
"${TEMPLATES_DIR}/struct_impl.cpp.tpl")
|
|
|
|
set(PYTHON_TEMPLATES "${TEMPLATES_DIR}/tuple_tree_gen.py.tpl")
|
|
|
|
set(TYPESCRIPT_TEMPLATES "${TEMPLATES_DIR}/tuple_tree_gen.ts.tpl")
|
|
|
|
set(SCRIPTS_ROOT_DIR "${CMAKE_SOURCE_DIR}/scripts/tuple_tree_generator")
|
|
# The list of Python scripts is build as follows:
|
|
#
|
|
# find scripts/tuple_tree_generator -name "*.py" | sort | sed
|
|
# 's|scripts/tuple_tree_generator|"\${SCRIPTS_ROOT_DIR}|; s/$/"/'
|
|
#
|
|
# TODO: detect and warn about extra files in those directories
|
|
set(TUPLE_TREE_GENERATOR_SOURCES
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-cpp.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-cpp-paths.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-jsonschema.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-python.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-typescript.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/generators/cppheaders.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/generators/__init__.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/generators/jinja_utils.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/generators/jsonschema.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/generators/python.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/generators/typescript.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/__init__.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/schema/definition.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/schema/enum.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/schema/__init__.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/schema/schema.py"
|
|
"${SCRIPTS_ROOT_DIR}/tuple_tree_generator/schema/struct.py")
|
|
|
|
# Generates docs
|
|
function(
|
|
tuple_tree_generator_generate_docs
|
|
# Path to the yaml definitions
|
|
YAML_DEFINITIONS
|
|
# Base namespace of the generated classes (e.g. model)
|
|
NAMESPACE
|
|
# List of headers that are expected to be generated
|
|
EXPECTED_GENERATED_MARKDOWN
|
|
# Root type of the schema, if there is any
|
|
ROOT_TYPE
|
|
SCALAR_TYPES)
|
|
|
|
set(SCALAR_TYPE_ARGS)
|
|
foreach(ST ${SCALAR_TYPES})
|
|
list(APPEND SCALAR_TYPE_ARGS --scalar-type "'${ST}'")
|
|
endforeach()
|
|
|
|
add_custom_command(
|
|
COMMAND
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-docs.py" --namespace
|
|
"${NAMESPACE}" --root-type \""${ROOT_TYPE}"\" ${SCALAR_TYPE_ARGS}
|
|
"${YAML_DEFINITIONS}" > "${EXPECTED_GENERATED_MARKDOWN}"
|
|
OUTPUT "${EXPECTED_GENERATED_MARKDOWN}"
|
|
DEPENDS "${YAML_DEFINITIONS}" "${TEMPLATES_DIR}/docs.md.tpl"
|
|
${TUPLE_TREE_GENERATOR_SOURCES})
|
|
endfunction()
|
|
|
|
# Generates headers and implementation C++ files
|
|
function(
|
|
tuple_tree_generator_generate_cpp
|
|
# Path to the yaml definitions
|
|
YAML_DEFINITIONS
|
|
# Base namespace of the generated classes (e.g. model)
|
|
NAMESPACE
|
|
# Output directory
|
|
OUTPUT_DIR
|
|
# Include path prefix
|
|
INCLUDE_PATH_PREFIX
|
|
# List of headers that are expected to be generated
|
|
EXPECTED_GENERATED_HEADERS
|
|
# List of implementation files expected to be generated
|
|
EXPECTED_GENERATED_IMPLS
|
|
# Root type of the schema, if there is any
|
|
ROOT_TYPE
|
|
SCALAR_TYPES
|
|
EMIT_TRACKING)
|
|
|
|
set(SCALAR_TYPE_ARGS)
|
|
foreach(ST ${SCALAR_TYPES})
|
|
list(APPEND SCALAR_TYPE_ARGS --scalar-type "'${ST}'")
|
|
endforeach()
|
|
|
|
if(${EMIT_TRACKING})
|
|
set(TRACKING "--tracking")
|
|
else()
|
|
set(TRACKING "")
|
|
endif()
|
|
|
|
add_custom_command(
|
|
COMMAND
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-cpp.py" --namespace
|
|
"${NAMESPACE}" --include-path-prefix "${INCLUDE_PATH_PREFIX}" --root-type
|
|
\""${ROOT_TYPE}"\" ${SCALAR_TYPE_ARGS} "${YAML_DEFINITIONS}"
|
|
"${OUTPUT_DIR}" ${TRACKING} ${TRACKING_DEBUG}
|
|
OUTPUT ${EXPECTED_GENERATED_HEADERS} ${EXPECTED_GENERATED_IMPLS}
|
|
DEPENDS "${YAML_DEFINITIONS}" ${CPP_TEMPLATES}
|
|
${TUPLE_TREE_GENERATOR_SOURCES})
|
|
endfunction()
|
|
|
|
# Generates JSON schema files
|
|
function(
|
|
tuple_tree_generator_generate_jsonschema
|
|
YAML_DEFINITIONS # Path to the yaml definitions
|
|
NAMESPACE # Base namespace of the generated classes (e.g. model)
|
|
ROOT_TYPE # Type to use as the root of the JSON schema
|
|
STRING_TYPES # Types equivalent to plain strings
|
|
SEPARATE_STRING_TYPES # Types equivalent to plain strings that get a separate
|
|
# type definition
|
|
SCALAR_TYPES
|
|
OUTPUT_PATH # Output path
|
|
)
|
|
set(STRING_TYPE_ARGS)
|
|
foreach(ST ${STRING_TYPES})
|
|
list(APPEND STRING_TYPE_ARGS --string-type "${ST}")
|
|
endforeach()
|
|
|
|
set(SEPARATE_STRING_TYPE_ARGS)
|
|
foreach(ST ${SEPARATE_STRING_TYPES})
|
|
list(APPEND SEPARATE_STRING_TYPE_ARGS --separate-string-type "${ST}")
|
|
endforeach()
|
|
|
|
set(SCALAR_TYPE_ARGS)
|
|
foreach(ST ${SCALAR_TYPES})
|
|
list(APPEND SCALAR_TYPE_ARGS --scalar-type "'${ST}'")
|
|
endforeach()
|
|
|
|
add_custom_command(
|
|
COMMAND
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-jsonschema.py" --namespace
|
|
"${NAMESPACE}" --root-type "${ROOT_TYPE}" --output "${OUTPUT_PATH}"
|
|
${STRING_TYPE_ARGS} ${SEPARATE_STRING_TYPE_ARGS} ${SCALAR_TYPE_ARGS}
|
|
"${YAML_DEFINITIONS}"
|
|
OUTPUT "${OUTPUT_PATH}"
|
|
DEPENDS "${YAML_DEFINITIONS}" ${TUPLE_TREE_GENERATOR_SOURCES})
|
|
endfunction()
|
|
|
|
# Generates typescript files
|
|
function(
|
|
tuple_tree_generator_generate_typescript
|
|
# Path to the yaml definitions
|
|
YAML_DEFINITIONS
|
|
# Base namespace of the generated classes (e.g. model)
|
|
NAMESPACE
|
|
# Type to use as the root of the schema
|
|
ROOT_TYPE
|
|
# Name of the global type, e.g. Model
|
|
GLOBAL_NAME
|
|
# Files to be included in the prouduced output
|
|
INCLUDE_FILES
|
|
# Types equivalent to plain strings
|
|
STRING_TYPES
|
|
# Types equivalent to plain strings that get a separate type definition
|
|
EXTERNAL_TYPES
|
|
SCALAR_TYPES
|
|
# Output path
|
|
OUTPUT_PATH)
|
|
|
|
set(INCLUDE_FILES_ARGS)
|
|
foreach(IF ${INCLUDE_FILES})
|
|
list(APPEND INCLUDE_FILE_ARGS --external-file "${IF}")
|
|
endforeach()
|
|
|
|
set(STRING_TYPE_ARGS)
|
|
foreach(ST ${STRING_TYPES})
|
|
list(APPEND STRING_TYPE_ARGS --string-type "${ST}")
|
|
endforeach()
|
|
|
|
set(EXTERNAL_TYPE_ARGS)
|
|
foreach(ET ${EXTERNAL_TYPES})
|
|
list(APPEND EXTERNAL_TYPE_ARGS --external-type "${ET}")
|
|
endforeach()
|
|
|
|
set(SCALAR_TYPE_ARGS)
|
|
foreach(ET ${SCALAR_TYPES})
|
|
list(APPEND SCALAR_TYPE_ARGS --scalar-type "'${ET}'")
|
|
endforeach()
|
|
|
|
add_custom_command(
|
|
COMMAND
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-typescript.py" --namespace
|
|
"${NAMESPACE}" --root-type "${ROOT_TYPE}" --output "${OUTPUT_PATH}"
|
|
--global-name "${GLOBAL_NAME}" ${INCLUDE_FILE_ARGS} ${STRING_TYPE_ARGS}
|
|
${EXTERNAL_TYPE_ARGS} ${SCALAR_TYPE_ARGS} "${YAML_DEFINITIONS}"
|
|
OUTPUT "${OUTPUT_PATH}"
|
|
DEPENDS "${YAML_DEFINITIONS}" ${TYPESCRIPT_TEMPLATES}
|
|
"${CMAKE_SOURCE_DIR}/typescript/model.ts"
|
|
${TUPLE_TREE_GENERATOR_SOURCES})
|
|
endfunction()
|
|
|
|
# Generates python files
|
|
function(
|
|
tuple_tree_generator_generate_python
|
|
# Path to the yaml definitions
|
|
YAML_DEFINITIONS
|
|
# Base namespace of the generated classes (e.g. model)
|
|
NAMESPACE
|
|
# Type to use as the root of the schema
|
|
ROOT_TYPE
|
|
# Types equivalent to plain strings
|
|
STRING_TYPES
|
|
# Types equivalent to plain strings that get a separate type definition
|
|
EXTERNAL_TYPES
|
|
SCALAR_TYPES
|
|
# Path to files containing the mixins python classes
|
|
PYTHON_MIXINS
|
|
# Output path
|
|
OUTPUT_PATH)
|
|
set(STRING_TYPE_ARGS)
|
|
foreach(ST ${STRING_TYPES})
|
|
list(APPEND STRING_TYPE_ARGS --string-type "${ST}")
|
|
endforeach()
|
|
|
|
set(EXTERNAL_TYPE_ARGS)
|
|
foreach(ET ${EXTERNAL_TYPES})
|
|
list(APPEND EXTERNAL_TYPE_ARGS --external-type "${ET}")
|
|
endforeach()
|
|
|
|
set(SCALAR_TYPE_ARGS)
|
|
foreach(ET ${SCALAR_TYPES})
|
|
list(APPEND SCALAR_TYPE_ARGS --scalar-type "'${ET}'")
|
|
endforeach()
|
|
|
|
set(PYTHON_MIXINS_ARGS)
|
|
foreach(PM ${PYTHON_MIXINS})
|
|
list(APPEND PYTHON_MIXINS_ARGS --mixins "'${PM}'")
|
|
endforeach()
|
|
|
|
add_custom_command(
|
|
COMMAND
|
|
"${SCRIPTS_ROOT_DIR}/tuple-tree-generate-python.py" --namespace
|
|
"${NAMESPACE}" --root-type "${ROOT_TYPE}" --output "${OUTPUT_PATH}"
|
|
${PYTHON_MIXINS_ARGS} ${STRING_TYPE_ARGS} ${EXTERNAL_TYPE_ARGS}
|
|
${SCALAR_TYPE_ARGS} "${YAML_DEFINITIONS}"
|
|
OUTPUT "${OUTPUT_PATH}"
|
|
DEPENDS "${YAML_DEFINITIONS}" ${PYTHON_TEMPLATES}
|
|
${TUPLE_TREE_GENERATOR_SOURCES})
|
|
endfunction()
|
|
|
|
# Extracts definitions and generates C++ headers and implementations from the
|
|
# given header files. The definitions must be embedded as described in the docs
|
|
# for tuple_tree_generator_extract_definitions_from_headers. Name of the target
|
|
# on which generated code will be attached too
|
|
|
|
# TARGET_ID HEADERS List of C++ headers
|
|
|
|
# NAMESPACE Delimiter used to mark comments embedding type schemas
|
|
|
|
# SCHEMA_PATH Path to YAML schema
|
|
|
|
# HEADER_DIRECTORY Directory where the headers will be generated
|
|
|
|
# HEADER_DIRECTORY Full path where the headers will be generated, incompatible
|
|
# with INCLUDE_PATH_PREFIX
|
|
|
|
# HEADERS_PATH Include path prefix
|
|
|
|
# JSONSCHEMA_PATH Where the JSON schema will be produced (empty for no schema)
|
|
|
|
# ROOT_TYPE Type to use as the root of the JSON schema
|
|
|
|
# PYTHON_PATH Path where the python generated code will be produced (empty for
|
|
# skipping python code generation)
|
|
|
|
# STRING_TYPES Types equivalent to strings
|
|
|
|
# SEPARATE_STRING_TYPES Types equivalent to strings which get a separate type
|
|
# definition
|
|
|
|
# EMIT_TRACKING emits in every generated struct all the required wrappers and
|
|
# members needed to track accesses to every field.
|
|
function(target_tuple_tree_generator TARGET_ID)
|
|
set(options INSTALL EMIT_TRACKING)
|
|
set(oneValueArgs
|
|
HEADER_DIRECTORY
|
|
NAMESPACE
|
|
SCHEMA_PATH
|
|
JSONSCHEMA_PATH
|
|
ROOT_TYPE
|
|
GLOBAL_NAME
|
|
INCLUDE_PATH_PREFIX
|
|
PYTHON_PATH
|
|
TYPESCRIPT_PATH
|
|
HEADERS_PATH
|
|
PYTHON_MIXINS)
|
|
set(multiValueArgs TYPESCRIPT_INCLUDE STRING_TYPES SEPARATE_STRING_TYPES
|
|
SCALAR_TYPES)
|
|
cmake_parse_arguments(GEN "${options}" "${oneValueArgs}" "${multiValueArgs}"
|
|
"${ARGN}")
|
|
|
|
if(NOT DEFINED GEN_INCLUDE_PATH_PREFIX)
|
|
set(GEN_INCLUDE_PATH_PREFIX "revng/${GEN_HEADER_DIRECTORY}")
|
|
endif()
|
|
|
|
# Generate C++ headers from the collected YAML
|
|
#
|
|
# TODO: the generated folder path should be configurable
|
|
if(NOT DEFINED GEN_HEADERS_PATH)
|
|
set(GEN_HEADERS_PATH
|
|
"${CMAKE_BINARY_DIR}/include/revng/${GEN_HEADER_DIRECTORY}/Generated")
|
|
endif()
|
|
|
|
# Choose a target name that's available
|
|
set(INDEX 1)
|
|
set(GENERATOR_TARGET_NAME generate-${TARGET_ID}-tuple-tree-code)
|
|
if(TARGET "${GENERATOR_TARGET_NAME}")
|
|
math(EXPR INDEX "${INDEX}+1")
|
|
set(GENERATOR_TARGET_NAME generate-${TARGET_ID}-tuple-tree-code-${INDEX})
|
|
endif()
|
|
|
|
tuple_tree_generator_impl(
|
|
TARGET_NAME
|
|
"${GENERATOR_TARGET_NAME}"
|
|
NAMESPACE
|
|
${GEN_NAMESPACE}
|
|
SCHEMA_PATH
|
|
"${GEN_SCHEMA_PATH}"
|
|
HEADERS_DIR
|
|
"${GEN_HEADERS_PATH}"
|
|
INCLUDE_PATH_PREFIX
|
|
"${GEN_INCLUDE_PATH_PREFIX}"
|
|
GENERATED_HEADERS_VARIABLE
|
|
GENERATED_HEADERS
|
|
GENERATED_IMPLS_VARIABLE
|
|
GENERATED_IMPLS
|
|
JSONSCHEMA_PATH
|
|
"${GEN_JSONSCHEMA_PATH}"
|
|
ROOT_TYPE
|
|
${GEN_ROOT_TYPE}
|
|
GLOBAL_NAME
|
|
${GEN_GLOBAL_NAME}
|
|
STRING_TYPES
|
|
"${GEN_STRING_TYPES}"
|
|
SEPARATE_STRING_TYPES
|
|
"${GEN_SEPARATE_STRING_TYPES}"
|
|
PYTHON_PATH
|
|
${GEN_PYTHON_PATH}
|
|
TYPESCRIPT_PATH
|
|
${GEN_TYPESCRIPT_PATH}
|
|
TYPESCRIPT_INCLUDE
|
|
${GEN_TYPESCRIPT_INCLUDE}
|
|
SCALAR_TYPES
|
|
${GEN_SCALAR_TYPES}
|
|
EMIT_TRACKING
|
|
${GEN_EMIT_TRACKING}
|
|
PYTHON_MIXINS
|
|
"${GEN_PYTHON_MIXINS}")
|
|
if(GEN_INSTALL)
|
|
install(DIRECTORY ${GEN_HEADERS_PATH}
|
|
DESTINATION include/revng/${GEN_HEADER_DIRECTORY})
|
|
endif()
|
|
|
|
target_sources(${TARGET_ID} PRIVATE ${GENERATED_IMPLS})
|
|
|
|
add_dependencies(${TARGET_ID} "${GENERATOR_TARGET_NAME}")
|
|
endfunction()
|