################################################################################
##
##  Provide Pandoc compilation support for the CMake build system
##
##  Version: 0.0.1
##  Author: Jeet Sukumatan (jeetsukumaran@gmail.com)
##
##  Copyright 2015 Jeet Sukumaran.
##
##  This software is released under the BSD 3-Clause License.
##
##  Redistribution and use in source and binary forms, with or without
##  modification, are permitted provided that the following conditions are
##  met:
##
##  1. Redistributions of source code must retain the above copyright notice,
##  this list of conditions and the following disclaimer.
##
##  2. Redistributions in binary form must reproduce the above copyright
##  notice, this list of conditions and the following disclaimer in the
##  documentation and/or other materials provided with the distribution.
##
##  3. Neither the name of the copyright holder nor the names of its
##  contributors may be used to endorse or promote products derived from this
##  software without specific prior written permission.
##
##  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
##  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
##  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
##  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
##  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
##  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
##  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
##  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
##  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
##  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
##  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
##
################################################################################

include(CMakeParseArguments)

if(NOT EXISTS ${PANDOC_EXECUTABLE})
    # find_program(PANDOC_EXECUTABLE NAMES pandoc)
    find_program(PANDOC_EXECUTABLE pandoc)
    mark_as_advanced(PANDOC_EXECUTABLE)
    if(NOT EXISTS ${PANDOC_EXECUTABLE})
        message(FATAL_ERROR "Pandoc not found. Install Pandoc (http://johnmacfarlane.net/pandoc/) or set cache variable PANDOC_EXECUTABLE.")
        return()
    endif()
endif()
if(NOT EXISTS ${PP_EXECUTABLE})
    find_program(PP_EXECUTABLE pp)
    mark_as_advanced(PP_EXECUTABLE)
    if(NOT EXISTS ${PP_EXECUTABLE})
        message("PP not found. If this is wrong, please set cache variable PP_EXECUTABLE.")
    endif()
endif()
if(NOT DEFINED ${PREPROCESS_TEMP_DIRECTORY})
    set(PREPROCESS_TEMP_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/_preprocessed")
endif()

###############################################################################
# Based on code from UseLATEX
# Author: Kenneth Moreland <kmorel@sandia.gov>
# Copyright 2004 Sandia Corporation.
# 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.

# Adds command to copy file from the source directory to the destination
# directory: used to move source files from source directory into build
# directory before main build
function(pandocology_add_input_file source_path dest_dir dest_filelist_var native_dest_filelist_var)
    set(dest_filelist)
    set(native_dest_filelist)
    file(GLOB globbed_source_paths "${source_path}")
    foreach(globbed_source_path ${globbed_source_paths})
        get_filename_component(filename ${globbed_source_path} NAME)
        get_filename_component(absolute_dest_path ${dest_dir}/${filename} ABSOLUTE)
        file(RELATIVE_PATH relative_dest_path ${CMAKE_CURRENT_BINARY_DIR} ${absolute_dest_path})
        list(APPEND dest_filelist ${absolute_dest_path})
        file(TO_NATIVE_PATH ${absolute_dest_path} native_dest_path)
        list(APPEND native_dest_filelist ${native_dest_path})
        file(TO_NATIVE_PATH ${globbed_source_path} native_globbed_source_path)
        ADD_CUSTOM_COMMAND(
            OUTPUT ${relative_dest_path}
            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${native_globbed_source_path} ${native_dest_path}
            DEPENDS ${globbed_source_path}
            )
        set(${dest_filelist_var} ${${dest_filelist_var}} ${dest_filelist} PARENT_SCOPE)
        set(${native_dest_filelist_var} ${${native_dest_filelist_var}} ${native_dest_filelist} PARENT_SCOPE)
    endforeach()
endfunction()

# A version of GET_FILENAME_COMPONENT that treats extensions after the last
# period rather than the first.
function(pandocology_get_file_stemname varname filename)
    SET(result)
    GET_FILENAME_COMPONENT(name ${filename} NAME)
    STRING(REGEX REPLACE "\\.[^.]*\$" "" result "${name}")
    SET(${varname} "${result}" PARENT_SCOPE)
endfunction()

function(pandocology_get_file_extension varname filename)
    SET(result)
    GET_FILENAME_COMPONENT(name ${filename} NAME)
    STRING(REGEX MATCH "\\.[^.]*\$" result "${name}")
    SET(${varname} "${result}" PARENT_SCOPE)
endfunction()
###############################################################################

function(pandocology_add_input_dir source_dir dest_parent_dir dir_dest_filelist_var native_dir_dest_filelist_var)
    set(dir_dest_filelist)
    set(native_dir_dest_filelist)
    file(TO_CMAKE_PATH ${source_dir} source_dir)
    get_filename_component(dir_name ${source_dir} NAME)
    get_filename_component(absolute_dest_dir ${dest_parent_dir}/${dir_name} ABSOLUTE)
    file(RELATIVE_PATH relative_dest_dir ${CMAKE_CURRENT_BINARY_DIR} ${absolute_dest_dir})
    file(TO_NATIVE_PATH ${absolute_dest_dir} native_absolute_dest_dir)
    add_custom_command(
        OUTPUT ${relative_dest_dir}
        COMMAND ${CMAKE_COMMAND} -E make_directory ${native_absolute_dest_dir}
        DEPENDS ${source_dir}
        )
    file(GLOB_RECURSE source_files "${source_dir}/*")
    foreach(source_file ${source_files})
        file(RELATIVE_PATH relative_source_file ${source_dir} ${source_file})
        # get_filename_component(absolute_source_path ${CMAKE_CURRENT_SOURCE_DIR}/${source_file} ABSOLUTE)
        get_filename_component(relative_source_dir ${relative_source_file} DIRECTORY)
        pandocology_add_input_file(${source_file} ${absolute_dest_dir}/${relative_source_dir} dir_dest_filelist native_dir_dest_filelist)
    endforeach()
    set(${dir_dest_filelist_var} ${${dir_dest_filelist_var}} ${dir_dest_filelist} PARENT_SCOPE)
    set(${native_dir_dest_filelist_var} ${${native_dir_dest_filelist_var}} ${native_dir_dest_filelist} PARENT_SCOPE)
endfunction()

function(add_to_make_clean filepath)
    file(TO_NATIVE_PATH ${CMAKE_CURRENT_BINARY_DIR}/${filepath} native_filepath)
    get_directory_property(make_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
    set_directory_properties(PROPERTIES ADDITIONAL_MAKE_CLEAN_FILES "${make_clean_files};${native_filepath}")
endfunction()

function(disable_insource_build)
    IF ( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE )
        MESSAGE(FATAL_ERROR "The build directory must be different from the main project source "
"directory. Please create a directory such as '${CMAKE_SOURCE_DIR}/build', "
"and run CMake from there, passing the path to this source directory as "
"the path argument. E.g.:
    $ cd ${CMAKE_SOURCE_DIR}
    $ mkdir build
    $ cd build
    $ cmake .. && make && sudo make install
This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
Please delete them:
    $ rm -r CMakeFiles/ CmakeCache.txt
")
    ENDIF()
endfunction()

# This builds a document
#
# Usage:
#
#
#     INCLUDE(pandocology)
#
#     add_document(
#         TARGET              figures
#         OUTPUT_FILE         figures.tex
#         SOURCES              figures.md
#         RESOURCE_DIRS        figs
#         PANDOC_DIRECTIVES    -t latex
#         NO_EXPORT_PRODUCT
#         )
#
#     add_document(
#         TARGET               opus
#         OUTPUT_FILE          opus.pdf
#         SOURCES              opus.md
#         RESOURCE_FILES       opus.bib systbiol.template.latex systematic-biology.csl
#         RESOURCE_DIRS        figs
#         PANDOC_DIRECTIVES    -t             latex
#                             --smart
#                             --template     systbiol.template.latex
#                             --filter       pandoc-citeproc
#                             --csl          systematic-biology.csl
#                             --bibliography opus.bib
#                             --include-after-body=figures.tex
#         DEPENDS             figures
#         EXPORT_ARCHIVE
#         )
#
#
# Deprecated command signature for backwards compatibility:
#
#     add_document(
#         figures.tex
#         SOURCES              figures.md
#         RESOURCE_DIRS        figs
#         PANDOC_DIRECTIVES    -t latex
#         NO_EXPORT_PRODUCT
#         )
#
# This command signature will cause an error due to a circular dependency during
# build when the sources are at the top level directory of the project. A
# warning is issued. The solution is to use the alternative commande signature.
#
function(add_document)
    set(options          EXPORT_ARCHIVE NO_EXPORT_PRODUCT EXPORT_PDF DIRECT_TEX_TO_PDF VERBOSE PREPROCESS)
    set(oneValueArgs     TARGET OUTPUT_FILE PRODUCT_DIRECTORY)
    set(multiValueArgs   SOURCES RESOURCE_FILES RESOURCE_DIRS PANDOC_DIRECTIVES PP_DIRECTIVES DEPENDS)
    cmake_parse_arguments(ADD_DOCUMENT "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} )

    # this is because `make clean` will dangerously clean up source files
    disable_insource_build()

    if ("${ADD_DOCUMENT_TARGET}" STREQUAL "" AND "${ADD_DOCUMENT_OUTPUT_FILE}" STREQUAL "")
        set(bw_comp_mode_args TRUE)
    endif()

    if(bw_comp_mode_args)
        list(LENGTH ADD_DOCUMENT_UNPARSED_ARGUMENTS unparsed_args_num)
        if (${unparsed_args_num} GREATER 1)
            message(FATAL_ERROR "add_document() requires at most one target name")
        endif()

        if (${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
          message(WARNING "This add_document() signature does not support sources on the top level directory. \
          It will cause a circular dependency error during build.")
        endif()

        list(GET ADD_DOCUMENT_UNPARSED_ARGUMENTS 0 ADD_DOCUMENT_TARGET)
        set(ADD_DOCUMENT_OUTPUT_FILE ${ADD_DOCUMENT_TARGET})
    endif()

    if ("${ADD_DOCUMENT_TARGET}" STREQUAL "")
        MESSAGE(FATAL_ERROR "add_document() requires a target name by using the TARGET option")
    endif()

    if ("${ADD_DOCUMENT_OUTPUT_FILE}" STREQUAL "")
        MESSAGE(FATAL_ERROR "add_document() requires an output file name by using the OUTPUT_FILE option")
    endif()

    if (NOT bw_comp_mode_args)
        if ("${ADD_DOCUMENT_TARGET}" STREQUAL "${ADD_DOCUMENT_OUTPUT_FILE}")
            message(FATAL_ERROR "Target '${ADD_DOCUMENT_TARGET}': Must different from OUTPUT_FILE")
        endif()
    endif()

    set(output_file ${ADD_DOCUMENT_OUTPUT_FILE})
    file(TO_NATIVE_PATH ${output_file} native_output_file)

    # get the stem of the target name
    pandocology_get_file_stemname(output_file_stemname ${output_file})
    pandocology_get_file_extension(output_file_extension ${output_file})

    if (${ADD_DOCUMENT_EXPORT_PDF})
        if (NOT "${output_file_extension}" STREQUAL ".tex" AND NOT "${output_file_extension}" STREQUAL ".latex")
            MESSAGE(FATAL_ERROR "Target '${ADD_DOCUMENT_TARGET}': Cannot use 'EXPORT_PDF' for target of type '${output_file_extension}': target type must be '.tex' or '.latex'")
        endif()
    endif()

    if (${ADD_DOCUMENT_DIRECT_TEX_TO_PDF})
        list(LENGTH ${ADD_DOCUMENT_SOURCES} SOURCE_LEN)
        if (SOURCE_LEN GREATER 1)
            MESSAGE(FATAL_ERROR "Target '${ADD_DOCUMENT_TARGET}': Only one source can be specified when using the 'DIRECT_TEX_TO_PDF' option")
        endif()

        pandocology_get_file_stemname(source_stemname ${ADD_DOCUMENT_SOURCES})
        pandocology_get_file_extension(source_extension ${ADD_DOCUMENT_SOURCES})

        if (NOT "${source_extension}" STREQUAL ".tex" AND NOT "${source_extension}" STREQUAL ".latex")
            MESSAGE(FATAL_ERROR "Target '${ADD_DOCUMENT_TARGET}': Cannot use 'DIRECT_TEX_TO_PDF' for source of type '${source_extension}': source type must be '.tex' or '.latex'")
        endif()

        set(check_target ${source_stemname}.pdf)
        if (NOT ${check_target} STREQUAL ${output_file})
            MESSAGE(FATAL_ERROR "Target '${ADD_DOCUMENT_TARGET}': Must use target name of '${check_target}' if using 'DIRECT_TEX_TO_PDF'")
        endif()
    endif()

    ## set up output directory
    if ("${ADD_DOCUMENT_PRODUCT_DIRECTORY}" STREQUAL "")
        set(ADD_DOCUMENT_PRODUCT_DIRECTORY "product")
    endif()

    get_filename_component(product_directory ${CMAKE_BINARY_DIR}/${ADD_DOCUMENT_PRODUCT_DIRECTORY} ABSOLUTE)
    file(TO_NATIVE_PATH ${product_directory} native_product_directory)

    set(dest_output_file ${product_directory}/${output_file})
    file(TO_NATIVE_PATH ${dest_output_file} native_dest_output_file)

    ## get primary source
    set(build_sources)
    set(native_build_sources)
    foreach(input_file ${ADD_DOCUMENT_SOURCES} )
        pandocology_add_input_file(${CMAKE_CURRENT_SOURCE_DIR}/${input_file} ${CMAKE_CURRENT_BINARY_DIR} build_sources native_build_sources)
    endforeach()

    ## get resource files
    set(build_resources)
    set(native_build_resources)
    foreach(resource_file ${ADD_DOCUMENT_RESOURCE_FILES})
        if(IS_ABSOLUTE ${resource_file})
          pandocology_add_input_file(${resource_file} ${CMAKE_CURRENT_BINARY_DIR} build_resources native_build_resources)
        else()
          pandocology_add_input_file(${CMAKE_CURRENT_SOURCE_DIR}/${resource_file} ${CMAKE_CURRENT_BINARY_DIR} build_resources native_build_resources)
    endforeach()

    ## get resource dirs
    set(exported_resources)
    set(native_exported_resources)
    foreach(resource_dir ${ADD_DOCUMENT_RESOURCE_DIRS})
        if(IS_ABSOLUTE ${resource_dir})
          pandocology_add_input_dir(${resource_dir} ${CMAKE_CURRENT_BINARY_DIR} build_resources native_build_resources)
        else()
          pandocology_add_input_dir(${CMAKE_CURRENT_SOURCE_DIR}/${resource_dir} ${CMAKE_CURRENT_BINARY_DIR} build_resources native_build_resources)
        endif()
        if (${ADD_DOCUMENT_EXPORT_ARCHIVE})
            pandocology_add_input_dir(${CMAKE_CURRENT_SOURCE_DIR}/${resource_dir} ${product_directory} exported_resources native_exported_resources)
        endif()
    endforeach()

    ## primary command
    if (${ADD_DOCUMENT_DIRECT_TEX_TO_PDF})
        if (${ADD_DOCUMENT_VERBOSE})
            add_custom_command(
                OUTPUT  ${output_file} # note that this is in the build directory
                DEPENDS ${build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS}
                COMMAND ${CMAKE_COMMAND} -E make_directory ${native_product_directory}
                COMMAND latexmk -gg -halt-on-error -interaction=nonstopmode -file-line-error -pdf ${native_build_sources}
                )
        else()
            add_custom_command(
              OUTPUT  ${output_file} # note that this is in the build directory
                DEPENDS ${build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS}
                COMMAND ${CMAKE_COMMAND} -E make_directory ${native_product_directory}
                COMMAND latexmk -gg -halt-on-error -interaction=nonstopmode -file-line-error -pdf ${native_build_sources} 2>/dev/null >/dev/null || (grep --no-messages -A8 ".*:[0-9]*:.*" ${output_file_stemname}.log && false)
                )
        endif()
        add_to_make_clean(${output_file})
    else()
        if(${ADD_DOCUMENT_PREPROCESS})
            if(EXISTS ${PP_EXECUTABLE})
                message("Preprocessing documents with PP.")
                set(PREPROCESSING_WITH_PP)
                file(MAKE_DIRECTORY ${PREPROCESS_TEMP_DIRECTORY})
                set(preprocessed_build_sources)
                foreach(native_build_source ${native_build_sources})
                    get_filename_component(native_source_name ${native_build_source} NAME)
                    set(preprocessed_build_source "${PREPROCESS_TEMP_DIRECTORY}/${native_source_name}")
                    set(pp_working_directory ${CMAKE_CURRENT_SOURCE_DIR})
                    file(RELATIVE_PATH preprocessed_output_filepath ${pp_working_directory} ${preprocessed_build_source})
                    add_custom_command(
                        OUTPUT  ${preprocessed_build_source}
                        DEPENDS ${build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS}
                        COMMAND ${PP_EXECUTABLE} ${ADD_DOCUMENT_PP_DIRECTIVES} ${native_build_source} > ${preprocessed_output_filepath}
                        VERBATIM
                        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
                    )
                    add_to_make_clean(${preprocessed_build_source})
                    list(APPEND preprocessed_build_sources ${preprocessed_build_source})
                endforeach()
                add_custom_command(
                OUTPUT  ${output_file} # note that this is in the build directory
                DEPENDS ${preprocessed_build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS}
                COMMAND ${CMAKE_COMMAND} -E make_directory ${native_product_directory}
                COMMAND ${PANDOC_EXECUTABLE} ${preprocessed_build_sources} ${ADD_DOCUMENT_PANDOC_DIRECTIVES} -o ${native_output_file}
                )
            add_to_make_clean(${output_file})
            else()
                message(FATAL_ERROR "PREPROCESS set but no preprocessor found!")
                return()
            endif()
        else()
            add_custom_command(
                OUTPUT  ${output_file} # note that this is in the build directory
                DEPENDS ${build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS}
                COMMAND ${CMAKE_COMMAND} -E make_directory ${native_product_directory}
                COMMAND ${PANDOC_EXECUTABLE} ${native_build_sources} ${ADD_DOCUMENT_PANDOC_DIRECTIVES} -o ${native_output_file}
                )
            add_to_make_clean(${output_file})
        endif()
    endif()

    add_custom_target (
        ${output_file}_product
        DEPENDS ${output_file}
        )

    ## figure out what all is going to be produced by this build set, and set
    ## those as dependencies of the primary target
    set(primary_target_dependencies)
    set(primary_target_dependencies ${primary_target_dependencies} ${CMAKE_CURRENT_BINARY_DIR}/${output_file})
    if (NOT ${ADD_DOCUMENT_NO_EXPORT_PRODUCT})
        set(primary_target_dependencies ${primary_target_dependencies} ${product_directory}/${output_file})
    endif()
    if (${ADD_DOCUMENT_EXPORT_PDF})
        set(primary_target_dependencies ${primary_target_dependencies} ${CMAKE_CURRENT_BINARY_DIR}/${output_file_stemname}.pdf)
        set(primary_target_dependencies ${primary_target_dependencies} ${product_directory}/${output_file_stemname}.pdf)
    endif()
    if (${ADD_DOCUMENT_EXPORT_ARCHIVE})
        set(primary_target_dependencies ${primary_target_dependencies} ${product_directory}/${output_file_stemname}.tbz)
    endif()

    ## primary target
    # # target cannot have same (absolute name) as dependencies:
    # # http://www.cmake.org/pipermail/cmake/2011-March/043378.html
    add_custom_target(
        ${ADD_DOCUMENT_TARGET}
        ALL
        DEPENDS ${primary_target_dependencies} ${ADD_DOCUMENT_DEPENDS}
        )

    # run post-pdf
    if (${ADD_DOCUMENT_EXPORT_PDF})
        add_custom_command(
            OUTPUT ${native_product_directory}/${output_file_stemname}.pdf ${CMAKE_CURRENT_BINARY_DIR}/${output_file_stemname}.pdf
            DEPENDS ${output_file} ${build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS}

            # Does not work: custom template used to generate tex is ignored
            # COMMAND ${PANDOC_EXECUTABLE} ${output_file} -f latex -o ${output_file_stemname}.pdf

            # (1)   Apparently, both nonstopmode and batchmode produce an output file
            #       even if there was an error. This tricks latexmk into believing
            #       the file is actually up-to-date.
            #       So we use `-halt-on-error` or `-interaction=errorstopmode`
            #       instead.
            # (2)   `grep` returns a non-zero error code if the pattern is not
            #       found. So, in our scheme below to filter the output of
            #       `pdflatex`, it is precisely when there is NO error that
            #       grep returns a non-zero code, which fools CMake into thinking
            #       tex'ing failed.
            #       Hence the need for `| grep ...| cat` or `| grep  || true`.
            #       But we can go better:
            #           latexmk .. || (grep .. && false)
            #       So we can have our cake and eat it too: here we want to
            #       re-raise the error after a successful grep if there was an
            #       error in `latexmk`.
            # COMMAND latexmk -gg -halt-on-error -interaction=nonstopmode # -file-line-error -pdf ${output_file} 2>&1 | grep -A8 ".*:[0-9]*:.*" || true
            COMMAND latexmk -gg -halt-on-error -interaction=nonstopmode -file-line-error -pdf ${native_output_file} 2>/dev/null >/dev/null || (grep --no-messages -A8 ".*:[0-9]*:.*" ${output_file_stemname}.log && false)

            COMMAND ${CMAKE_COMMAND} -E copy ${output_file_stemname}.pdf ${native_product_directory}
            )
        add_to_make_clean(${output_file_stemname}.pdf)
        add_to_make_clean(${product_directory}/${output_file_stemname}.pdf)
    endif()

    ## copy products
    if (NOT ${ADD_DOCUMENT_NO_EXPORT_PRODUCT})
        add_custom_command(
            OUTPUT ${native_dest_output_file}
            DEPENDS ${build_sources} ${build_resources} ${ADD_DOCUMENT_DEPENDS} ${output_file}_product
            COMMAND ${CMAKE_COMMAND} -E copy_if_different ${native_output_file} ${native_dest_output_file}
            )
        add_to_make_clean(${product_directory}/${output_file})
    endif()

    ## copy resources
    set(export_archive_file ${product_directory}/${output_file_stemname}.tbz)
    file(TO_NATIVE_PATH ${export_archive_file} native_export_archive_file)

    if (${ADD_DOCUMENT_EXPORT_ARCHIVE})
        add_custom_command(
            OUTPUT ${export_archive_file}
            DEPENDS ${output_file}
            COMMAND ${CMAKE_COMMAND} -E tar cjf ${native_export_archive_file} ${native_output_file} ${native_build_resources} ${ADD_DOCUMENT_DEPENDS}
            )
        add_to_make_clean(${export_archive_file})
    endif()
endfunction(add_document)

function(add_tex_document)
    add_document(${ARGV} DIRECT_TEX_TO_PDF)
endfunction()

# LEGACY SUPPORT
function(add_pandoc_document)
    add_document(${ARGV})
endfunction()