tastytea
/
compilescript
Archived
1
0
Fork 0
Code Issues Pull Requests Releases 2 Wiki Activity

Merge branch 'develop' into main

This commit is contained in:
tastytea 2019-10-01 11:15:06 +02:00
parent 83abaf81b6 6efea73391
commit 95e9b19c83
Signed by: tastytea
GPG Key ID: CFC39497F1B26E07
10 changed files with 205 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

83
CMakeLists.txt
View File

@ -1,50 +1,47 @@
cmake_minimum_required (VERSION 3.2)
project(compilescript
VERSION 0.4.0
LANGUAGES CXX
)
# Support version 3.6 and above, but use policy settings up to 3.14.
# 3.6 is needed because of IMPORTED_TARGET in pkg_check_modules().
cmake_minimum_required(VERSION 3.6...3.14)
# Ranges are supported from 3.12, set policy to current for < 3.12.
if(${CMAKE_VERSION} VERSION_LESS 3.12)
cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
endif()
include(GNUInstallDirs)
find_package(PkgConfig REQUIRED)
pkg_check_modules(LIBXDG_BASEDIR REQUIRED libxdg-basedir)
pkg_check_modules(LIBCONFIG REQUIRED libconfig++)
project(compilescript
VERSION 0.4.0
LANGUAGES CXX)
# DESCRIPTION was introduced in version 3.9.
if(NOT (${CMAKE_VERSION} VERSION_LESS 3.9))
set(PROJECT_DESCRIPTION
"Execute source files from compiled languages as scripts.")
endif()
option(WITH_MAN "Compile and install manpage." YES)
set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_FLAGS_DEBUG
"${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wpedantic -ftrapv -fsanitize=undefined -g -Og -fno-omit-frame-pointer")
include_directories(${PROJECT_BINARY_DIR})
include_directories(${LIBXDG_BASEDIR_INCLUDE_DIRS})
include_directories(${LIBCONFIG_INCLUDE_DIRS})
link_directories(${LIBXDG_BASEDIR_LIBRARY_DIRS})
link_directories(${LIBCONFIG_LIBRARY_DIRS})
# Write version in header
configure_file(
"${PROJECT_SOURCE_DIR}/src/version.hpp.in"
"${PROJECT_BINARY_DIR}/version.hpp"
)
file(GLOB sources src/*.cpp)
add_executable(${CMAKE_PROJECT_NAME} "${sources}")
target_link_libraries(${CMAKE_PROJECT_NAME}
"${LIBXDG_BASEDIR_LDFLAGS} ${LIBCONFIG_LDFLAGS}"
"-lstdc++fs")
install(TARGETS ${CMAKE_PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_BINDIR})
set(WITH_MAN "YES" CACHE STRING "WITH_MAN defaults to \"YES\"")
if (WITH_MAN)
add_custom_command(OUTPUT "${PROJECT_BINARY_DIR}/${CMAKE_PROJECT_NAME}.1"
WORKING_DIRECTORY "${PROJECT_BINARY_DIR}"
DEPENDS "${CMAKE_SOURCE_DIR}/${CMAKE_PROJECT_NAME}.1.adoc"
COMMAND ${CMAKE_SOURCE_DIR}/build_manpage.sh
ARGS ${PROJECT_VERSION})
add_custom_target(run ALL
DEPENDS "${PROJECT_BINARY_DIR}/${CMAKE_PROJECT_NAME}.1")
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_PROJECT_NAME}.1
DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)
set(DEBUG_CXXFLAGS
"-Wall"
"-Wextra"
"-Wpedantic"
"-ftrapv"
"-fsanitize=undefined"
"-g"
"-Og"
"-fno-omit-frame-pointer")
set(DEBUG_LDFLAGS
"-fsanitize=undefined")
add_compile_options("$<$<CONFIG:Debug>:${DEBUG_CXXFLAGS}>")
# add_link_options was introduced in version 3.13.
if(${CMAKE_VERSION} VERSION_LESS 3.13)
set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${DEBUG_LDFLAGS}")
else()
add_link_options("$<$<CONFIG:Debug>:${DEBUG_LDFLAGS}>")
endif()
add_subdirectory(src)
if (WITH_MAN)
add_subdirectory(man)
endif()

14
man/CMakeLists.txt Normal file
View File

@ -0,0 +1,14 @@
include(GNUInstallDirs)
add_custom_command(
OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.1"
WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}"
DEPENDS "${PROJECT_NAME}.1.adoc"
COMMAND "${PROJECT_SOURCE_DIR}/man/build_manpage.sh"
ARGS "${PROJECT_VERSION}")
add_custom_target(man ALL
DEPENDS "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.1")
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.1
DESTINATION ${CMAKE_INSTALL_MANDIR}/man1)

5
build_manpage.sh → man/build_manpage.sh
View File

@ -3,9 +3,10 @@
name="compilescript"
if [ -n "${1}" ]; then
dir="$(dirname ${0})"
dir=$(dirname "${0}")
version=${1}
cp -vf "${dir}/${name}.1.adoc" .
sed -Ei "s/(Revision: +)[0-9]+\.[0-9]\.[0-9]/\1${1}/" "${name}.1.adoc"
sed -Ei "s/(Revision: +)[0-9]+\.[0-9]\.[0-9]/\1${version}/" "${name}.1.adoc"
a2x --doctype manpage --format manpage --no-xmllint "${name}.1.adoc"
else
echo "usage: ${0} VERSION" >&2

0
compilescript.1.adoc → man/compilescript.1.adoc
View File

22
src/CMakeLists.txt Normal file
View File

@ -0,0 +1,22 @@
include(GNUInstallDirs)
find_package(PkgConfig REQUIRED)
pkg_check_modules(libxdg-basedir REQUIRED IMPORTED_TARGET libxdg-basedir)
pkg_check_modules(libconfig++ REQUIRED IMPORTED_TARGET libconfig++)
# Write version in header
configure_file("version.hpp.in" "${CMAKE_CURRENT_BINARY_DIR}/version.hpp")
set(sources "main.cpp" "../xdgcfg/src/xdgcfg.cpp")
add_executable(${CMAKE_PROJECT_NAME} "${sources}")
target_include_directories(${PROJECT_NAME}
PRIVATE
"${PROJECT_SOURCE_DIR}/xdgcfg/include"
"${CMAKE_CURRENT_BINARY_DIR}")
target_link_libraries(${CMAKE_PROJECT_NAME}
PRIVATE PkgConfig::libxdg-basedir PkgConfig::libconfig++ stdc++fs)
install(TARGETS ${CMAKE_PROJECT_NAME} DESTINATION "${CMAKE_INSTALL_BINDIR}")

210
src/main.cpp
View File

@ -14,40 +14,54 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#if __cplusplus >= 201703L
#include <filesystem>
#else
#include <experimental/filesystem>
#endif
#include <iostream>
#include <string>
#include <fstream>
#include <chrono>
#include <system_error>
#include <cstdlib>
#include <unistd.h>
#include "version.hpp"
#include "xdgcfg.hpp"
#include <libconfig.h++>
#include <basedir.h>
#include "xdgcfg.hpp"
#include "version.hpp"
#include <unistd.h>
#include <chrono>
#include <cstdlib>
#include <exception>
#include <experimental/filesystem>
#include <fstream>
#include <iostream>
#include <string>
#include <system_error>
#include <vector>
#if __cplusplus >= 201703L
namespace fs = std::filesystem;
#else
namespace fs = std::experimental::filesystem;
#endif
namespace fs = std::experimental::filesystem;
using std::cout;
using std::cerr;
using std::endl;
using std::chrono::system_clock;
using std::chrono::hours;
using std::chrono::duration_cast;
using std::string;
using std::vector;
string compiler = "g++ -x c++";
fs::path cache_dir;
int clean_after_hours = 30 * 24;
class Compilescript
{
private:
string _compiler;
fs::path _cache_dir;
int _clean_after_hours;
bool read_settings()
public:
Compilescript();
void read_settings();
void cleanup();
bool compile(const string &filename, char *argv[]);
void print_version();
};
Compilescript::Compilescript()
: _compiler("g++ -x c++")
, _clean_after_hours(30 * 24)
{}
void Compilescript::read_settings()
{
bool need_save = false;
xdgcfg config("compilescript.cfg");
@ -56,106 +70,79 @@ bool read_settings()
if (cfg.exists("compiler"))
{
compiler = cfg["compiler"].c_str();
_compiler = cfg["compiler"].c_str();
}
else
{
cfg.add("compiler", libconfig::Setting::TypeString) = compiler;
cfg.add("compiler", libconfig::Setting::TypeString) = _compiler;
need_save = true;
}
if (cfg.exists("clean_after_hours"))
{
cfg.lookupValue("clean_after_hours", clean_after_hours);
cfg.lookupValue("clean_after_hours", _clean_after_hours);
}
else
{
cfg.add("clean_after_hours",
libconfig::Setting::TypeInt) = clean_after_hours;
libconfig::Setting::TypeInt) = _clean_after_hours;
need_save = true;
}
if (cfg.exists("cache_dir"))
{
cache_dir = cfg["cache_dir"].c_str();
_cache_dir = cfg["cache_dir"].c_str();
}
else
{
xdgHandle xdg;
xdgInitHandle(&xdg);
cache_dir = xdgCacheHome(&xdg);
cache_dir /= "compilescript";
_cache_dir = xdgCacheHome(&xdg);
_cache_dir /= "compilescript";
xdgWipeHandle(&xdg);
}
if (!fs::is_directory(cache_dir))
if (!fs::is_directory(_cache_dir))
{
fs::create_directories(cache_dir);
fs::create_directories(_cache_dir);
}
if (need_save)
{
config.write();
}
return true;
}
void cleanup()
void Compilescript::cleanup()
{
for (const fs::directory_entry &entry
: fs::recursive_directory_iterator(cache_dir))
for (const auto &entry : fs::recursive_directory_iterator(_cache_dir))
{
if (fs::is_regular_file(entry))
if (!fs::is_regular_file(entry))
{
auto diff = system_clock::now() - fs::last_write_time(entry);
if (duration_cast<hours>(diff).count() > clean_after_hours)
{
fs::path current_path = entry.path();
std::error_code e;
continue;
}
while (fs::remove(current_path, e))
const auto diff = system_clock::now() - fs::last_write_time(entry);
if (duration_cast<hours>(diff).count() > _clean_after_hours)
{
fs::path current_path = entry.path();
std::error_code e;
while (fs::remove(current_path, e))
{
current_path = current_path.parent_path();
if (current_path == _cache_dir)
{
current_path = current_path.parent_path();
if (current_path == cache_dir)
{
break;
}
break;
}
}
}
}
}
int main(int argc, char *argv[])
bool Compilescript::compile(const string &filename, char *argv[])
{
if (!read_settings())
{
return 1;
}
if (argc <= 1)
{
cerr << "usage: " << argv[0] <<
" [file|--cleanup|--version] [arguments]\n";
return 1;
}
if (string(argv[1]) == "--cleanup")
{
cleanup();
return 0;
}
if (string(argv[1]) == "--version")
{
cout << "compilescript " << global::version << endl <<
"Copyright (C) 2018, 2019 tastytea <tastytea@tastytea.de>\n"
"License GPLv3: GNU GPL version 3 <https://www.gnu.org/licenses/gpl-3.0.html>.\n"
"This program comes with ABSOLUTELY NO WARRANTY. This is free software,\n"
"and you are welcome to redistribute it under certain conditions.\n";
return 0;
}
const fs::path original = fs::canonical(argv[1]);
const fs::path source = cache_dir / original;
const fs::path original = fs::canonical(filename);
const fs::path source = _cache_dir / original;
const fs::path binary = (source.string() + ".bin");
string compiler_arguments;
fs::create_directories(binary.parent_path());
@ -178,7 +165,11 @@ int main(int argc, char *argv[])
}
std::getline(in, buf);
if (buf.substr(0, 16) == "//compilescript:")
if (buf.substr(0, 17) == "// compilescript:")
{
compiler_arguments = buf.substr(17);
}
else if (buf.substr(0, 16) == "//compilescript:")
{
compiler_arguments = buf.substr(16);
}
@ -204,26 +195,73 @@ int main(int argc, char *argv[])
else
{
cerr << "ERROR: Could not open file: " << source << endl;
return 1;
return false;
}
}
else
{
cerr << "ERROR: Could not open file: " << original << endl;
return 1;
return false;
}
int ret = std::system((compiler + " " + source.string() + " " +
compiler_arguments +
" -o " + binary.string()).c_str());
const string command = _compiler + " " + source.string() + " "
+ compiler_arguments + " -o " + binary.string();
int ret = std::system(command.c_str()); // NOLINT Doesn't apply here.
if (ret != 0)
{
cerr << "ERROR: Compilation failed.\n";
return 1;
return false;
}
}
execv(binary.c_str(), &argv[1]);
execvp(binary.c_str(), &argv[1]); // NOLINT We know that argv[1] exists.
return true;
}
void Compilescript::print_version()
{
cout << "compilescript " << global::version << '\n' <<
"Copyright (C) 2018, 2019 tastytea <tastytea@tastytea.de>\n"
"License GPLv3: GNU GPL version 3 "
"<https://www.gnu.org/licenses/gpl-3.0.html>.\n"
"This program comes with ABSOLUTELY NO WARRANTY. This is free software,"
"\nand you are welcome to redistribute it under certain conditions.\n";
}
int main(int argc, char *argv[])
{
const vector<string> args(argv, argv + argc);
Compilescript App;
App.read_settings();
if (args.size() <= 1)
{
cerr << "usage: " << args[0]
<< " [file|--cleanup|--version] [arguments]\n";
return 1;
}
if (args[1] == "--cleanup")
{
App.cleanup();
return 0;
}
if (args[1] == "--version")
{
App.print_version();
return 0;
}
try
{
App.compile(args[1], argv);
}
catch (const std::exception &e)
{
cerr << "Error: " << e.what() << endl;
return 1;
}
return 0;
}

2
src/version.hpp.in
View File

@ -3,7 +3,7 @@
namespace global
{
static constexpr char version[] = "@PROJECT_VERSION@";
static constexpr char version[] = "@PROJECT_VERSION@";
}
#endif // VERSION_HPP

1
src/xdgcfg.cpp
View File

@ -1 +0,0 @@
../xdgcfg/src/xdgcfg.cpp

1
src/xdgcfg.hpp
View File

@ -1 +0,0 @@
../xdgcfg/src/xdgcfg.hpp

2
xdgcfg

@ -1 +1 @@
Subproject commit e22f82fc6f1c40cda3d3ce5e671299f26f622528
Subproject commit 9337964266ae55415beaa7f517cc4240a259289a