Initial commit

Author: AndrewShpagin

.gitignore

@@ -0,0 +1,3 @@
+.vs
+client-MicrosoftVS
+x64-Debug

CMakeLists.txt

@@ -0,0 +1,12 @@
+# CMakeList.txt : CMake project for CppAsScript, include source and define
+# project specific logic here.
+#
+cmake_minimum_required (VERSION 3.8)
+set(CMAKE_CXX_STANDARD 17)
+
+project ("CppAsScript")
+
+# Add source to this project's executable.
+add_executable (CppAsScript "CppAsScript.cpp" "CppAsScript.h" "maker/_win.cpp" "maker/CLangScripter.cpp" "api_test/export.cpp")
+
+# TODO: Add tests and install targets if needed.

CppAsScript.cpp

@@ -0,0 +1,27 @@
+// CppAsScript.cpp : Defines the entry point for the application.
+//
+
+#include "maker/CLangScripter.h"
+#include <filesystem>
+
+int main()
+{
+	CLangProject PR;
+	std::filesystem::path cur = std::filesystem::current_path().parent_path().parent_path().parent_path();
+	
+	std::filesystem::path test = cur;
+	test.append("test/test.cpp");
+	
+	std::filesystem::path inc = cur;
+	inc.append("api_test/");
+	
+	PR.addFile(test.string()).addIncludeFolder(inc.string()).debug();
+
+	auto f = PR.bind<void()>("main");
+	if (f)f();
+
+	auto f1 = PR.bind<void(int)>("test123");
+	if (f1)f1(23);
+
+	return 0;
+}

CppAsScript.h

@@ -0,0 +1,8 @@
+// CppAsScript.h : Include file for standard system include files,
+// or project specific include files.
+
+#pragma once
+
+#include <iostream>
+
+// TODO: Reference additional headers your program requires here.

api_test/export.cpp

@@ -0,0 +1,13 @@
+#include <cstdio>
+
+#define APICALL __declspec(dllexport)
+
+#include "export.h"
+
+APICALL void test(const char* res) {
+	printf("%s", res);
+}
+
+void testClass::testfn(const char* x) {
+	printf("%s", x);
+}

api_test/export.h

@@ -0,0 +1,5 @@
+APICALL void test(const char* res);
+class APICALL testClass {
+public:
+	void testfn(const char* x);
+};

maker/CLangScripter.cpp

@@ -0,0 +1,115 @@
+// CLangScripter.cpp : Defines the entry point for the application.
+//
+
+#include "CLangScripter.h"
+
+#include "md5.h"
+
+static std::string _replace(const std::string& str, const std::string& sub, const std::string& mod) {
+	std::string tmp(str);
+	auto fnd = tmp.find(sub);
+	if (fnd != -1)tmp.replace(fnd, sub.length(), mod);
+	return tmp;
+}
+
+void CLangProject::_add(const std::string& opt) {
+	_remove(opt);
+	_options += " " + opt;
+	_replace(_options, "  ", " ");
+}
+
+void CLangProject::_remove(const std::string& opt) {
+	_replace(_options, opt, "");
+	_replace(_options, "  ", " ");
+}
+
+CLangProject::CLangProject() {
+	builder = CLangBuilder::create();
+	ref = nullptr;
+	_options = "/std:c++latest /LD";
+}
+
+CLangProject::~CLangProject() {
+	if (builder)delete(builder);
+	builder = nullptr;
+	if (ref)delete(ref);
+	ref = nullptr;
+}
+
+bool CLangProject::valid() {
+	return ref != nullptr;
+}
+
+std::string& CLangProject::compileLog() {
+	return log;
+}
+
+std::string& CLangProject::module() {
+	return modulePath;
+}
+
+std::vector<std::string>& CLangProject::filesList() {
+	return files;
+}
+
+std::string& CLangProject::options() {
+	return _options;
+}
+
+std::string& CLangProject::includes() {
+	return _includes;
+}
+
+CLangProject& CLangProject::addFile(const std::string& path) {
+	filesList().push_back(path);
+	return *this;
+}
+
+CLangProject& CLangProject::addIncludeFolder(const std::string& path) {
+	includes() += " /I " + path;
+	return *this;
+}
+
+CLangProject& CLangProject::addSource(const char* cpp_text) {
+	std::string fn = "temp_" + md5::hash(cpp_text) + ".cpp";
+	std::string res = builder->pathInHeap(fn);
+	std::ofstream f(res);
+	if (f.is_open()) {
+		f << cpp_text;
+		f.close();
+	}
+	filesList().push_back(res);
+	return *this;
+}
+
+CLangProject& CLangProject::speedOptimization() {
+	_add("/Ot");
+	return *this;
+}
+
+CLangProject& CLangProject::sizeOptimization() {
+	_add("/Os");
+	return *this;
+}
+
+CLangProject& CLangProject::debug() {
+	_remove("/LD");
+	_add("/LDd");
+	return *this;
+}
+
+CLangProject& CLangProject::release() {
+	_remove("/LDd");
+	_add("/LD");
+	return *this;
+}
+
+void CLangProject::recompileIfNeed() {
+	if(builder) {
+		builder->compile(*this);
+		if (ref)delete(ref);
+		ref = LibReference::create();
+		ref->loadModule(module().c_str());
+	}
+}
+

maker/CLangScripter.h

@@ -0,0 +1,81 @@
+// CLangScripter.h : Include file for standard system include files,
+// or project specific include files.
+#pragma once
+
+#include <vector>
+#include <iostream>
+#include <stdexcept>
+#include <cstdio>
+#include <functional>
+
+class LibReference {
+public:
+	virtual ~LibReference() {};
+	virtual bool valid() const = 0;
+	virtual bool loadModule(const char* path) = 0;
+	virtual void unLoadModule() = 0;
+	virtual void* raw_ptr(const char* functionName) = 0;
+	static LibReference* create();
+};
+
+class CLangProject;
+
+class CLangBuilder {
+	friend class CLangProject;
+public:
+	
+	virtual ~CLangBuilder() {};
+	virtual const char* getModuleExtension() const = 0;
+	virtual void compile(CLangProject& project) = 0;
+	virtual std::string pathInHeap(const std::string& relative) = 0;
+	
+	static CLangBuilder* create();
+};
+
+class CLangProject {
+protected:
+	std::vector<std::string> files;
+	std::string modulePath;
+	std::string log;
+	std::string _options;
+	std::string _includes;
+	LibReference* ref;
+	CLangBuilder* builder;
+	void _add(const std::string& opt);
+	void _remove(const std::string& opt);
+public:		
+	CLangProject();
+	virtual ~CLangProject();
+	bool valid();
+	CLangProject& addFile(const std::string& path);
+	CLangProject& addIncludeFolder(const std::string& path);
+	
+	CLangProject& addSource(const char* cpp_text);
+	CLangProject& speedOptimization();
+	CLangProject& sizeOptimization();
+	CLangProject& debug();
+	CLangProject& release();
+	
+	void recompileIfNeed();
+
+	template <class F>
+	std::function<F> bind(const char* functionName);
+	
+	std::string& compileLog();
+	std::string& module();
+	std::vector<std::string>& filesList();
+	std::string& options();
+	std::string& includes();
+};
+
+template <class F>
+std::function<F> CLangProject::bind(const char* functionName) {
+	std::function<F> f1 = nullptr;
+	if (!ref) {
+		recompileIfNeed();
+	}
+	if (ref) {
+		f1 = static_cast<F*>(ref->raw_ptr(functionName));
+	}
+	return f1;
+}