Fixed cmake, unnecessary itteration on dictionary, and a crosslang binary bug when shell is not installed

.clangd

@@ -1,2 +0,0 @@
-CompileFlags: # Tweak the parse settings, example directory given to show format
-  Add: ["-Iinclude","-std=gnu++17"]

.gitea/workflows/tag.yaml

@@ -11,7 +11,6 @@ jobs:
   build-arch:
     runs-on: arch-builder
     steps:
-      - run: pacman --noconfirm -Sy nodejs npm
       - uses: actions/checkout@v4
       - run: wget -O /root/repository.key https://git.tesseslanguage.com/api/packages/tesses50/arch/repository.key
       - run: pacman-key --add /root/repository.key
@@ -40,6 +39,7 @@ jobs:
           bash build-tars.sh
         working-directory: ./Packaging/Linux
       - uses: akkuman/gitea-release-action@v1
+        prerelease: true
         env:
           NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18
         with:
@@ -56,6 +56,7 @@ jobs:
           apt install -y pkg-config git gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64 gcc-mingw-w64-i686 g++-mingw-w64-i686 nsis
           bash build-ubuntu-plucky.sh
           bash push-ubuntu-plucky.sh
+          bash build-slims.sh
         working-directory: ./Packaging/Linux
       
       - name: Build for windows
@@ -63,6 +64,7 @@ jobs:
           
         working-directory: ./Packaging/Windows
       - uses: akkuman/gitea-release-action@v1
+        prerelease: true
         env:
           NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18
         with:

.gitignore

@@ -10,4 +10,7 @@ bin
 *.a
 *.exe
 build-x86
-build-x64
+build-x64
+build-x86-slim
+build-x64-slim
+crosslang-*-temp

.vscode/settings.json

@@ -84,7 +84,11 @@
         "stack": "cpp",
         "stdfloat": "cpp"
     },
+    
     "clangd.fallbackFlags": [
-        "-Iinclude"
+        "-I${workspaceFolder}/include",
+        "-I/home/mike/tmp-crosslang/usr/local/include/"
     ]
+
+
 }

CMakeLists.txt

@@ -1,8 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 
-set(CROSSLANG_MAJOR_VERSION 0)
+include(cmake/version.cmake)
-set(CROSSLANG_MINOR_VERSION 0)
+include(cmake/options.cmake)
-set(CROSSLANG_PATCH_VERSION 1)
 
 project(TessesCrossLang VERSION ${CROSSLANG_MAJOR_VERSION}.${CROSSLANG_MINOR_VERSION}.${CROSSLANG_PATCH_VERSION})
 
@@ -12,38 +11,12 @@ set(CMAKE_CXX_STANDARD 17)
 include(CMakePackageConfigHelpers)
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
-#option(CROSSLANG_ENABLE_DOXYGEN "Enable doxygen" ON)
-
-option(CROSSLANG_ENABLE_STATIC "Enable Tesses CrossLang static libraries" ON)
-option(CROSSLANG_ENABLE_SHARED "Enable Tesses CrossLang shared libraries" ON)
-option(CROSSLANG_ENABLE_BINARIES "Enable Tesses CrossLang binaries" ON)
-option(CROSSLANG_INSTALL_DEVELOPMENT "Enable Tesses CrossLang development files" ON)
-option(CROSSLANG_ENABLE_THREADING "Enable Tesses CrossLang threading" ON)
-option(CROSSLANG_ENABLE_TERMIOS "Enable termios (For changing terminal options)" ON)
-option(CROSSLANG_SHARED_EXECUTABLES "Link with libcrosslang_shared" ON)
-option(CROSSLANG_FETCHCONTENT "Use fetchcontent" ON)
-option(CROSSLANG_ENABLE_CONFIG_ENVVAR "Allow setting config directory via the environment variable CROSSLANG_CONFIG" ON)
-option(CROSSLANG_ENABLE_FFI "Enable libffi" OFF)
-option(CROSSLANG_ENABLE_RPATH "Enable RPATH" ON)
-
-option(CROSSLANG_CUSTOM_CONSOLE "Enable custom Console" OFF)
-
-#if(CROSSLANG_ENABLE_DOXYGEN)
-#find_package(Doxygen REQUIRED)
-#doxygen_add_docs(doxygen-crosslang "${CMAKE_CURRENT_SOURCE_DIR}/include/CrossLang.hpp" "${CMAKE_CURRENT_SOURCE_DIR}/docs" "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
-#add_custom_target(crosslang_doxygen ALL
-#    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile.doxygen-crosslang
-#    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
-#)
-
-#endif()
 
 if(CROSSLANG_CUSTOM_CONSOLE)
 set(CROSSLANG_ENABLE_BINARIES OFF)
 set(CROSSLANG_ENABLE_SHARED OFF)
 endif()
 
-set(CROSSLANG_OFFLINE_SHELL_PACKAGE "" CACHE FILEPATH "Path to the shell package generated from https://onedev.site.tesses.net/CrossLang/CrossLangExtras")
 
 if(CROSSLANG_FETCHCONTENT)
 
@@ -77,117 +50,13 @@ endif()
 if(CROSSLANG_ENABLE_FFI)
 find_package(PkgConfig)
 endif()
-
+include(cmake/linkdeps.cmake)
 if(CROSSLANG_ENABLE_FFI AND CROSSLANG_ENABLE_SHARED)
 pkg_check_modules(LIBFFI REQUIRED IMPORTED_TARGET libffi)
 endif()
-function(CROSSLANG_LINK_DEPS CROSSLANG_TARGET_NAME)
+configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/CrossLangVersion.h.in "${CMAKE_CURRENT_BINARY_DIR}/include/CrossLangVersion.h"
-target_include_directories(${CROSSLANG_TARGET_NAME}
+INSTALL_DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/CrossLangVersion.h)
-    PUBLIC
+include(cmake/sources.cmake)
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>"
-    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-)
-if(CROSSLANG_ENABLE_FFI AND CROSSLANG_ENABLE_SHARED)
-
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_FFI)
-target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC PkgConfig::LIBFFI)
-
-endif()
-if(CROSSLANG_ENABLE_TIME)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_TIME)
-endif()
-if(CROSSLANG_ENABLE_CONFIG_ENVVAR)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_CONFIG_ENVVAR)
-endif()
-if(CROSSLANG_ENABLE_PROCESS)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_PROCESS)
-endif()
-if(CROSSLANG_ENABLE_THREADING)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_THREADING)
-endif()
-if(CROSSLANG_ENABLE_TERMIOS)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_TERMIOS)
-endif()
-
-if(CROSSLANG_ENABLE_SQLITE)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_SQLITE)
-endif()
-
-if(CROSSLANG_CUSTOM_CONSOLE)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_CUSTOM_CONSOLE)
-endif()
-if(CROSSLANG_ENABLE_PLATFORM_FOLDERS)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_PLATFORM_FOLDERS)
-endif()
-if(CROSSLANG_ENABLE_SHARED)
-target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_SHARED)
-
-endif()
-if("${CMAKE_SYSTEM_NAME}" STREQUAL "NintendoWii" OR "${CMAKE_SYSTEM_NAME}" STREQUAL "NintendoGameCube")
-target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC fat)
-endif()
-if("${CMAKE_SYSTEM_NAME}" STREQUAL "NintendoWii")
-target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC wiisocket)
-endif()
-if(CROSSLANG_ENABLE_SHARED AND NOT ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows"))
-target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC dl)
-endif()
-target_include_directories(${CROSSLANG_TARGET_NAME}
-    PUBLIC
-    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
-    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
-)
-
-endfunction()
-
-list(APPEND CROSSLANG_SOURCE
-src/assembler/asm.cpp
-src/assembler/disasm.cpp
-src/assembler/merge.cpp
-src/compiler/codegen.cpp
-src/compiler/lexer.cpp
-src/compiler/parser.cpp
-src/compiler/ast.cpp
-src/runtime_methods/class.cpp
-src/runtime_methods/console.cpp
-src/runtime_methods/io.cpp
-src/runtime_methods/std.cpp
-src/runtime_methods/net.cpp
-src/runtime_methods/vm.cpp
-src/runtime_methods/json.cpp
-src/runtime_methods/sqlite.cpp
-src/runtime_methods/dictionary.cpp
-src/runtime_methods/crypto.cpp
-src/runtime_methods/ogc.cpp
-src/runtime_methods/path.cpp
-src/runtime_methods/env.cpp
-src/runtime_methods/process.cpp
-src/runtime_methods/helpers.cpp
-src/types/embed.cpp
-src/types/async.cpp
-src/types/associativearray.cpp
-src/types/any.cpp
-src/types/ittr.cpp
-src/types/closure.cpp
-src/types/dictionary.cpp
-src/types/externalmethod.cpp
-src/types/list.cpp
-src/types/native.cpp
-src/types/rootenvironment.cpp
-src/types/subenvironment.cpp
-src/types/vfsheapobject.cpp
-src/types/streamheapobject.cpp
-src/types/class.cpp
-src/types/classenvironment.cpp
-src/types/random.cpp
-src/vm/filereader.cpp
-src/vm/gc.cpp
-src/vm/gclist.cpp
-src/vm/vm.cpp
-src/vm/exception.cpp
-src/archive.cpp
-src/markedtobject.cpp
-)
 
 if(CROSSLANG_OFFLINE_SHELL_PACKAGE STREQUAL "")
 
@@ -233,173 +102,22 @@ list(APPEND TessesCrossLangLibs crosslang_shared)
 endif()
 
 
-
+if(CROSSLANG_ENABLE_SUPERSLIM)
-
+include(cmake/slim.cmake)
-if(CROSSLANG_INSTALL_DEVELOPMENT)
-install(TARGETS ${TessesCrossLangLibs} 
-    EXPORT TessesCrossLangTargets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
-)
-
-install(FILES include/CrossLang.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/CrossLangVersion.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(EXPORT TessesCrossLangTargets
-    FILE TessesCrossLangTargets.cmake
-    NAMESPACE TessesCrossLang::
-    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesCrossLang
-)
-
-configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/TessesCrossLangConfig.cmake"
-INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesCrossLang)
-configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/CrossLangVersion.h.in "${CMAKE_CURRENT_BINARY_DIR}/include/CrossLangVersion.h"
-INSTALL_DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/CrossLangVersion.h)
-
-install(FILES "${CMAKE_CURRENT_BINARY_DIR}/TessesCrossLangConfig.cmake"
-DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesCrossLang)
 else()
-if(CROSSLANG_ENABLE_SHARED)
+include(cmake/shared.cmake)
-install(TARGETS crosslang_shared
-    EXPORT TessesCrossLangTargets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-
-endif()
-endif()
 
 
 
 if(CROSSLANG_ENABLE_BINARIES)
 if(CROSSLANG_ENABLE_SHARED AND CROSSLANG_SHARED_EXECUTABLES)
-if(CROSSLANG_ENABLE_RPATH)
+include(cmake/shared_exec.cmake)
-set(CMAKE_MACOSX_RPATH 1)
-set(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
-if (APPLE)
-    set(CMAKE_INSTALL_RPATH "@executable_path/../${CMAKE_INSTALL_LIBDIR}")
-else()
-    set(CMAKE_INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
-endif()
-endif()
-add_executable(crossmerge src/crossmergecli.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossasm src/crossasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossdisasm src/crossdisasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
-
-add_executable(crossc src/crosslangcompiler.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossvm src/crosslangvm.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossint src/crosslanginterperter.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossdump src/crosslangdump.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crosslang src/crosslang.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossarchiveextract src/crossarchiveextract.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossarchivecreate src/crossarchivecreate.cpp ${CROSSLANG_WIN32_EXE_SRC})
-if(NOT WIN32)
-add_executable(crossthumbnailer src/crossthumbnailer.cpp ${CROSSLANG_WIN32_EXE_SRC})
-endif()
-target_link_libraries(crossc PUBLIC crosslang_shared)
-target_link_libraries(crossvm PUBLIC crosslang_shared)
-target_link_libraries(crossint PUBLIC crosslang_shared)
-target_link_libraries(crossdump PUBLIC crosslang_shared)
-target_link_libraries(crosslang PUBLIC crosslang_shared)
-target_link_libraries(crossarchiveextract PUBLIC crosslang_shared)
-target_link_libraries(crossarchivecreate PUBLIC crosslang_shared)
-target_link_libraries(crossasm PUBLIC crosslang_shared)
-target_link_libraries(crossdisasm PUBLIC crosslang_shared)
-target_link_libraries(crossmerge PUBLIC crosslang_shared)
-
-if(NOT WIN32)
-target_link_libraries(crossthumbnailer PUBLIC crosslang_shared)
-endif()
 elseif(CROSSLANG_ENABLE_STATIC)
-
+include(cmake/static_exec.cmake)
-add_executable(crossc src/crosslangcompiler.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossvm src/crosslangvm.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossint src/crosslanginterperter.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossdump src/crosslangdump.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crosslang src/crosslang.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossarchiveextract src/crossarchiveextract.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossarchivecreate src/crossarchivecreate.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossasm src/crossasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossdisasm src/crossdisasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossmerge src/crossmergecli.cpp ${CROSSLANG_WIN32_EXE_SRC})
-
-if(NOT WIN32)
-add_executable(crossthumbnailer src/crossthumbnailer.cpp ${CROSSLANG_WIN32_EXE_SRC})
-endif()
-target_link_libraries(crossc PUBLIC crosslang_static)
-target_link_libraries(crossvm PUBLIC crosslang_static)
-target_link_libraries(crossint PUBLIC crosslang_static)
-target_link_libraries(crossdump PUBLIC crosslang_static)
-target_link_libraries(crosslang PUBLIC crosslang_static)
-target_link_libraries(crossarchiveextract PUBLIC crosslang_static)
-target_link_libraries(crossarchivecreate PUBLIC crosslang_static)
-target_link_libraries(crossmerge PUBLIC crosslang_static)
-target_link_libraries(crossasm PUBLIC crosslang_static)
-target_link_libraries(crossdisasm PUBLIC crosslang_static)
-
-if(NOT WIN32)
-target_link_libraries(crossthumbnailer PUBLIC crosslang_static)
-endif()
 else()
-add_executable(crossc src/crosslangcompiler.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+include(cmake/exec.cmake)
-add_executable(crossvm src/crosslangvm.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+endif()
-add_executable(crossint src/crosslanginterperter.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossdump src/crosslangdump.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crosslang src/crosslang.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossarchiveextract src/crossarchiveextract.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossarchivecreate src/crossarchivecreate.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossasm src/crossasmcli.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossdisasm src/crossdisasmcli.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossmerge src/crossmergecli.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
 
-if(NOT WIN32)
-add_executable(crossthumbnailer src/crossthumbnailer.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-endif()
-CROSSLANG_LINK_DEPS(crossc)
-CROSSLANG_LINK_DEPS(crossvm)
-CROSSLANG_LINK_DEPS(crossint)
-CROSSLANG_LINK_DEPS(crosslang)
-CROSSLANG_LINK_DEPS(crossdump)
-CROSSLANG_LINK_DEPS(crossarchiveextract)
-CROSSLANG_LINK_DEPS(crossarchivecreate)
-CROSSLANG_LINK_DEPS(crossmerge)
-CROSSLANG_LINK_DEPS(crossdisasm)
-CROSSLANG_LINK_DEPS(crossasm)
-
-if(NOT WIN32)
-CROSSLANG_LINK_DEPS(crossthumbnailer)
-endif()
-if(CROSSLANG_FETCHCONTENT)
-target_link_libraries(crossc PUBLIC tessesframework)
-target_link_libraries(crossvm PUBLIC tessesframework)
-target_link_libraries(crossint PUBLIC tessesframework)
-target_link_libraries(crosslang PUBLIC tessesframework)
-target_link_libraries(crossdump PUBLIC tessesframework)
-target_link_libraries(crossarchiveextract PUBLIC tessesframework)
-target_link_libraries(crossarchivecreate PUBLIC tessesframework)
-target_link_libraries(crossasm PUBLIC tessesframework)
-target_link_libraries(crossdisasm PUBLIC tessesframework)
-target_link_libraries(crossmerge PUBLIC tessesframework)
-if(NOT WIN32)
-target_link_libraries(crossthumbnailer PUBLIC tessesframework)
-endif()
-else()
-target_link_libraries(crossc PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossvm PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossint PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crosslang PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossdump PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossarchiveextract PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossarchivecreate PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossasm PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossdisasm PUBLIC TessesFramework::tessesframework)
-target_link_libraries(crossmerge PUBLIC TessesFramework::tessesframework)
-if(NOT WIN32)
-target_link_libraries(crossthumbnailer PUBLIC TessesFramework::tessesframework)
-endif()
-endif()
-endif()
 install(TARGETS crossc DESTINATION "${CMAKE_INSTALL_BINDIR}")
 install(TARGETS crossvm DESTINATION "${CMAKE_INSTALL_BINDIR}")
 install(TARGETS crossint DESTINATION "${CMAKE_INSTALL_BINDIR}")
@@ -425,6 +143,7 @@ install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/crosslang.thumbnailer"
 DESTINATION ${CMAKE_INSTALL_PREFIX}/share/thumbnailers)
 endif()
 endif()
+endif()
 include(InstallRequiredSystemLibraries)
 set(CPACK_PACKAGE_CONTACT "Mike Nolan <tesses@tesses.net>")
 set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.md")
@@ -464,5 +183,6 @@ set(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$SMPROGRAMS\\\\$STARTMENU_FOL
 
 
 include(CPack)
-
+if(CROSSLANG_INSTALL_DEVELOPMENT)
-add_subdirectory(pkgconfig)
+add_subdirectory(pkgconfig)
+endif()

Dockerfile.superslim

@@ -0,0 +1,39 @@
+FROM --platform=linux/386 scratch
+COPY --from=i686 . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/amd64 scratch
+COPY --from=x86_64 . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/ppc scratch
+COPY --from=powerpc . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/ppc64 scratch
+COPY --from=powerpc64 . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/arm scratch
+COPY --from=armv7a . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/arm64 scratch
+COPY --from=aarch64 . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/riscv32 scratch
+COPY --from=riscv32 . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]
+
+FROM --platform=linux/riscv64 scratch
+COPY --from=riscv64 . /
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/bin/crossint"]

Packaging/Linux/PKGBUILD

@@ -1,13 +1,13 @@
 # Maintainer: Mike Nolan <tesses@tesses.net>
 pkgname=crosslang # '-bzr', '-git', '-hg' or '-svn'
-pkgver=0.0.1
+pkgver=0.0.3
 pkgrel=1
 pkgdesc=""
 arch=('x86_64' 'powerpc')
 url="https://onedev.site.tesses.net/crosslang"
 license=('GPLv3')
 groups=()
-depends=('mbedtls' 'tesses-framework')
+depends=('mbedtls' 'tesses-framework=0.0.2')
 makedepends=('git' 'cmake' 'make' 'base-devel' 'wget') # 'bzr', 'git', 'mercurial' or 'subversion'
 install=
 source=('crosslang::git+https://onedev.site.tesses.net/crosslang')
@@ -30,16 +30,16 @@ prepare() {
 build() {
 	cd "$srcdir/${pkgname}"
 	mkdir build
-	
+
 	if [[ -z "$CMAKE_TOOLCHAIN" ]]; then
- 	cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=RelWithDebInfo
+ 	cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=Release
   	else
-	cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_TOOLCHAIN_FILE="$CMAKE_TOOLCHAIN"
+	cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE="$CMAKE_TOOLCHAIN"
 	fi
- 
+
 	cd build
 	make -j`nproc`
-	
+
 }
 
 
@@ -49,4 +49,3 @@ package() {
 	cd "$srcdir/${pkgname}/build"
 	make install DESTDIR="$pkgdir/"
 }
-

Packaging/Linux/build-slim.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+mkdir -p ../../artifacts
+mkdir -p crosslang-$TOOLCHAIN\-temp
+cd crosslang-$TOOLCHAIN\-temp
+export DIR="$PWD"
+echo "set(CMAKE_C_COMPILER \"$DIR/$TOOLCHAIN\-cross/bin/$TOOLCHAIN\-gcc\")" > toolchain.cmake
+echo "set(CMAKE_CXX_COMPILER \"$DIR/$TOOLCHAIN\-cross/bin/$TOOLCHAIN\-g++\")" >> toolchain.cmake
+echo "set(CMAKE_C_FLAGS \"-static-libgcc -static-libstdc++ -static\")" >> toolchain.cmake
+echo "set(CMAKE_CXX_FLAGS \"-static-libgcc -static-libstdc++ -static\")" >> toolchain.cmake
+echo "set(CMAKE_EXE_LINKER_FLAGS \"-static-libgcc -static-libstdc++ -static\")" >> toolchain.cmake
+#echo "set(CMAKE_SYSROOT \"$DIR/sysroot\")" >> toolchain.cmake
+echo "set(CMAKE_SYSTEM_NAME Linux)" >> toolchain.cmake
+echo "set(CMAKE_SYSTEM_PROCESSOR $ARCH)" >> toolchain.cmake
+echo "set(CMAKE_POSITION_INDEPENDENT_CODE ON)" >> toolchain.cmake
+wget https://downloads.tesses.net/cache/compilers/$TOOLCHAIN\-cross.tgz
+#wget https://downloads.tesses.net/cache/libraries/source/mbedtls-3.6.3.1.tar.bz2
+#wget -O tf.tar.gz "https://onedev.site.tesses.net/~downloads/projects/1/archives?revision=master&format=tgz"
+tar xvzf $TOOLCHAIN\-cross.tgz
+mkdir build
+cd build
+cmake -S ../../../../ -B . -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DCMAKE_TOOLCHAIN_FILE="$DIR/toolchain.cmake" -DCROSSLANG_ENABLE_SUPERSLIM=ON -DCMAKE_BUILD_TYPE=Release
+make -j`nproc`
+cp crosslang ../../../../artifacts/crosslang-slim-$TOOLCHAIN
+mkdir -p ../../../../builds/containers/$ARCH/usr/bin
+cp crosslang ../../../../builds/containers/$ARCH/usr/bin/crosslang
+ln -s crosslang ../../../../builds/containers/$ARCH/usr/bin/crossint
+ln -s crosslang ../../../../builds/containers/$ARCH/usr/bin/crossc
+ln -s crosslang ../../../../builds/containers/$ARCH/usr/bin/crossvm
+ln -s crosslang ../../../../builds/containers/$ARCH/usr/bin/crossarchivecreate
+ln -s crosslang ../../../../builds/containers/$ARCH/usr/bin/crossarchiveextract
+ln -s crosslang ../../../../builds/containers/$ARCH/usr/bin/crossdump
+rm -rf "$DIR"

Packaging/Linux/build-slims.sh

@@ -0,0 +1,8 @@
+ARCH="i686" TOOLCHAIN="i686-linux-musl" bash build-slim.sh
+ARCH="x86_64" TOOLCHAIN="x86_64-linux-musl" bash build-slim.sh
+ARCH="powerpc" TOOLCHAIN="powerpc-linux-musl" bash build-slim.sh
+ARCH="powerpc64" TOOLCHAIN="powerpc64-linux-musl" bash build-slim.sh
+ARCH="armv7a" TOOLCHAIN="armv7l-linux-musleabihf" bash build-slim.sh
+ARCH="aarch64" TOOLCHAIN="aarch64-linux-musl" bash build-slim.sh
+ARCH="riscv32" TOOLCHAIN="riscv32-linux-musl" bash build-slim.sh
+ARCH="riscv64" TOOLCHAIN="riscv64-linux-musl" bash build-slim.sh

Packaging/Linux/build-tars.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 mkdir build-x86_64-tar
 cd build-x86_64-tar
-cmake -S ../../.. -B . -DTESSESFRAMEWORK_ENABLE_SHARED=ON -DTESSESFRAMEWORK_ENABLE_STATIC=OFF -DTESSESFRAMEWORK_FETCHCONTENT=ON
+cmake -S ../../.. -B . -DTESSESFRAMEWORK_ENABLE_SHARED=ON -DTESSESFRAMEWORK_ENABLE_STATIC=OFF -DTESSESFRAMEWORK_FETCHCONTENT=ON -DCMAKE_BUILD_TYPE=Release
 make -j`nproc`
 make install DESTDIR=./crosslang-x86_64
 mkdir -p crosslang-x86_64/share/Tesses/CrossLang
@@ -12,7 +12,7 @@ cd ..
 foreign() {
 mkdir build-$1\-tar
 cd build-$1\-tar
-cmake -S ../../.. -B . -DTESSESFRAMEWORK_ENABLE_SHARED=ON -DTESSESFRAMEWORK_ENABLE_STATIC=OFF -DTESSESFRAMEWORK_FETCHCONTENT=ON -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/$1\.cmake
+cmake -S ../../.. -B . -DTESSESFRAMEWORK_ENABLE_SHARED=ON -DTESSESFRAMEWORK_ENABLE_STATIC=OFF -DTESSESFRAMEWORK_FETCHCONTENT=ON -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/$1\.cmake -DCMAKE_RELEASE_TYPE=Release
 make -j`nproc`
 make install DESTDIR=./crosslang-$1
 mkdir -p crosslang-$1\/share/Tesses/CrossLang

Packaging/Linux/build-ubuntu-jammy.sh

@@ -6,7 +6,7 @@ cd build/jammy
 wget -O Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm https://downloads.tesses.net/ShellPackage.crvm
 mkdir build-amd64
 apt install -y tessesframework
-cmake -S ../../../../ -B build-amd64 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF
+cmake -S ../../../../ -B build-amd64 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=Release
 cd build-amd64
 make -j`nproc`
 make install DESTDIR=../crosslang_$DEB_VERSION\_amd64
@@ -21,7 +21,7 @@ dpkg-deb --build crosslang_$DEB_VERSION\_amd64
 foreign() {
     apt install -y tessesframework:$1
     mkdir build-$1
-    cmake -S ../../../../ -B build-$1 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/$1\.cmake
+    cmake -S ../../../../ -B build-$1 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/$1\.cmake -DCMAKE_BUILD_TYPE=Release
     cd build-$1
     make -j`nproc`
     make install DESTDIR=../crosslang_$DEB_VERSION\_$1

Packaging/Linux/build-ubuntu-plucky.sh

@@ -5,7 +5,7 @@ cd build/plucky
 wget -O Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm https://downloads.tesses.net/ShellPackage.crvm
 mkdir build-amd64
 apt install -y tessesframework
-cmake -S ../../../../ -B build-amd64 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF
+cmake -S ../../../../ -B build-amd64 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_BUILD_TYPE=Release
 cd build-amd64
 make -j`nproc`
 make install DESTDIR=../crosslang_$DEB_VERSION\_amd64
@@ -20,7 +20,7 @@ dpkg-deb --build crosslang_$DEB_VERSION\_amd64
 foreign() {
     apt install -y tessesframework:$1
     mkdir build-$1
-    cmake -S ../../../../ -B build-$1 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/$1\.cmake
+    cmake -S ../../../../ -B build-$1 -DCMAKE_INSTALL_PREFIX=/usr -DCROSSLANG_FETCHCONTENT=OFF -DCMAKE_TOOLCHAIN_FILE=/opt/toolchains/$1\.cmake -DCMAKE_BUILD_TYPE=Release
     cd build-$1
     make -j`nproc`
     make install DESTDIR=../crosslang_$DEB_VERSION\_$1

Packaging/Linux/version.sh

@@ -1,2 +1,2 @@
 
-export DEB_VERSION=0.0.1
+export DEB_VERSION=0.0.3

Packaging/Windows/build.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-cmake -S ../.. -B build-x86 -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x86.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x86
+cmake -S ../.. -B build-x86 -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x86.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x86 -DCMAKE_BUILD_TYPE=Release
 cd build-x86
 make -j`nproc`
 cpack -G NSIS
@@ -7,10 +7,20 @@ cpack -G ZIP
 mv TessesCrossLang-*-win32.exe ../../../artifacts/crosslang-win32.exe
 mv TessesCrossLang-*-win32.zip ../../../artifacts/crosslang-win32.zip
 cd ..
-cmake -S ../.. -B build-x64 -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x64.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x64
+cmake -S ../.. -B build-x64 -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x64.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x64 -DCMAKE_BUILD_TYPE=Release
 cd build-x64
 make -j`nproc`
 cpack -G NSIS
 cpack -G ZIP
 mv TessesCrossLang-*-win64.exe ../../../artifacts/crosslang-win64.exe
 mv TessesCrossLang-*-win64.zip ../../../artifacts/crosslang-win64.zip
+
+cmake -S ../.. -B build-x86-slim -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x86.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x86 -DCMAKE_BUILD_TYPE=Release -DCROSSLANG_ENABLE_SUPERSLIM=ON
+cd build-x86-slim
+make -j`nproc`
+mv crosslang.exe ../../../artifacts/crosslang-slim-win32.exe
+cd ..
+cmake -S ../.. -B build-x64-slim -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x64.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x64 -DCMAKE_BUILD_TYPE=Release -DCROSSLANG_ENABLE_SUPERSLIM=ON
+cd build-x64-slim
+make -j`nproc`
+mv crosslang.exe ../../../artifacts/crosslang-slim-win64.exe

changelog.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## 0.0.3
+Fixed cmake, unnecessary itteration on dictionary, and a crosslang binary bug when shell is not installed
+
+## 0.0.2
+Add uuids, bytestreams and single file runtime binaries
+
+## 0.0.1
+Start versioning

cmake/exec.cmake

@@ -0,0 +1,57 @@
+add_executable(crossc src/programs/crosslangcompiler.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossvm src/programs/crosslangvm.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossint src/programs/crosslanginterperter.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossdump src/programs/crosslangdump.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crosslang src/programs/crosslang.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossarchiveextract src/programs/crossarchiveextract.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossarchivecreate src/programs/crossarchivecreate.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossasm src/crossasmcli.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossdisasm src/crossdisasmcli.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossmerge src/crossmergecli.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+
+if(NOT WIN32)
+add_executable(crossthumbnailer src/crossthumbnailer.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
+endif()
+CROSSLANG_LINK_DEPS(crossc)
+CROSSLANG_LINK_DEPS(crossvm)
+CROSSLANG_LINK_DEPS(crossint)
+CROSSLANG_LINK_DEPS(crosslang)
+CROSSLANG_LINK_DEPS(crossdump)
+CROSSLANG_LINK_DEPS(crossarchiveextract)
+CROSSLANG_LINK_DEPS(crossarchivecreate)
+CROSSLANG_LINK_DEPS(crossmerge)
+CROSSLANG_LINK_DEPS(crossdisasm)
+CROSSLANG_LINK_DEPS(crossasm)
+
+if(NOT WIN32)
+CROSSLANG_LINK_DEPS(crossthumbnailer)
+endif()
+if(CROSSLANG_FETCHCONTENT)
+target_link_libraries(crossc PUBLIC tessesframework)
+target_link_libraries(crossvm PUBLIC tessesframework)
+target_link_libraries(crossint PUBLIC tessesframework)
+target_link_libraries(crosslang PUBLIC tessesframework)
+target_link_libraries(crossdump PUBLIC tessesframework)
+target_link_libraries(crossarchiveextract PUBLIC tessesframework)
+target_link_libraries(crossarchivecreate PUBLIC tessesframework)
+target_link_libraries(crossasm PUBLIC tessesframework)
+target_link_libraries(crossdisasm PUBLIC tessesframework)
+target_link_libraries(crossmerge PUBLIC tessesframework)
+if(NOT WIN32)
+target_link_libraries(crossthumbnailer PUBLIC tessesframework)
+endif()
+else()
+target_link_libraries(crossc PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossvm PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossint PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crosslang PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossdump PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossarchiveextract PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossarchivecreate PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossasm PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossdisasm PUBLIC TessesFramework::tessesframework)
+target_link_libraries(crossmerge PUBLIC TessesFramework::tessesframework)
+if(NOT WIN32)
+target_link_libraries(crossthumbnailer PUBLIC TessesFramework::tessesframework)
+endif()
+endif()

cmake/linkdeps.cmake

@@ -0,0 +1,62 @@
+function(CROSSLANG_LINK_DEPS CROSSLANG_TARGET_NAME)
+target_include_directories(${CROSSLANG_TARGET_NAME}
+    PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+if(CROSSLANG_ENABLE_FFI AND CROSSLANG_ENABLE_SHARED)
+
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_FFI)
+target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC PkgConfig::LIBFFI)
+
+endif()
+if(CROSSLANG_ENABLE_SUPERSLIM)
+
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_SUPERSLIM)
+endif()
+if(CROSSLANG_ENABLE_TIME)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_TIME)
+endif()
+if(CROSSLANG_ENABLE_CONFIG_ENVVAR)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_CONFIG_ENVVAR)
+endif()
+if(CROSSLANG_ENABLE_PROCESS)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_PROCESS)
+endif()
+if(CROSSLANG_ENABLE_THREADING)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_THREADING)
+endif()
+if(CROSSLANG_ENABLE_TERMIOS)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_TERMIOS)
+endif()
+
+if(CROSSLANG_ENABLE_SQLITE)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_SQLITE)
+endif()
+
+if(CROSSLANG_CUSTOM_CONSOLE)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_CUSTOM_CONSOLE)
+endif()
+if(CROSSLANG_ENABLE_PLATFORM_FOLDERS)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_PLATFORM_FOLDERS)
+endif()
+if(CROSSLANG_ENABLE_SHARED)
+target_compile_definitions(${CROSSLANG_TARGET_NAME} PUBLIC CROSSLANG_ENABLE_SHARED)
+
+endif()
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "NintendoWii" OR "${CMAKE_SYSTEM_NAME}" STREQUAL "NintendoGameCube")
+target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC fat)
+endif()
+if("${CMAKE_SYSTEM_NAME}" STREQUAL "NintendoWii")
+target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC wiisocket)
+endif()
+if(CROSSLANG_ENABLE_SHARED AND NOT ("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows"))
+target_link_libraries(${CROSSLANG_TARGET_NAME} PUBLIC dl)
+endif()
+target_include_directories(${CROSSLANG_TARGET_NAME}
+    PUBLIC
+    "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>"
+    "$<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>"
+)
+
+endfunction()

cmake/options.cmake

@@ -0,0 +1,18 @@
+option(CROSSLANG_ENABLE_STATIC "Enable Tesses CrossLang static libraries" ON)
+option(CROSSLANG_ENABLE_SHARED "Enable Tesses CrossLang shared libraries" ON)
+option(CROSSLANG_ENABLE_BINARIES "Enable Tesses CrossLang binaries" ON)
+option(CROSSLANG_INSTALL_DEVELOPMENT "Enable Tesses CrossLang development files" ON)
+option(CROSSLANG_ENABLE_THREADING "Enable Tesses CrossLang threading" ON)
+option(CROSSLANG_ENABLE_TERMIOS "Enable termios (For changing terminal options)" ON)
+option(CROSSLANG_SHARED_EXECUTABLES "Link with libcrosslang_shared" ON)
+option(CROSSLANG_FETCHCONTENT "Use fetchcontent" ON)
+option(CROSSLANG_ENABLE_CONFIG_ENVVAR "Allow setting config directory via the environment variable CROSSLANG_CONFIG" ON)
+option(CROSSLANG_ENABLE_FFI "Enable libffi" OFF)
+option(CROSSLANG_ENABLE_RPATH "Enable RPATH" ON)
+option(CROSSLANG_ENABLE_SUPERSLIM "Enable crosslang superslim, one binary" OFF)
+
+option(CROSSLANG_CUSTOM_CONSOLE "Enable custom Console" OFF)
+
+
+
+set(CROSSLANG_OFFLINE_SHELL_PACKAGE "" CACHE FILEPATH "Path to the shell package generated from https://onedev.site.tesses.net/CrossLang/CrossLangExtras")

cmake/shared.cmake

@@ -0,0 +1,34 @@
+if(CROSSLANG_INSTALL_DEVELOPMENT)
+install(TARGETS ${TessesCrossLangLibs}
+    EXPORT TessesCrossLangTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+)
+
+install(FILES include/CrossLang.hpp DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/include/CrossLangVersion.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(EXPORT TessesCrossLangTargets
+    FILE TessesCrossLangTargets.cmake
+    NAMESPACE TessesCrossLang::
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesCrossLang
+)
+
+configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/TessesCrossLangConfig.cmake"
+INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesCrossLang)
+
+
+install(FILES "${CMAKE_CURRENT_BINARY_DIR}/TessesCrossLangConfig.cmake"
+DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/TessesCrossLang)
+else()
+
+if(CROSSLANG_ENABLE_SHARED)
+install(TARGETS crosslang_shared
+    EXPORT TessesCrossLangTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+endif()
+endif()

cmake/shared_exec.cmake

@@ -0,0 +1,37 @@
+if(CROSSLANG_ENABLE_RPATH)
+set(CMAKE_MACOSX_RPATH 1)
+set(CMAKE_BUILD_RPATH_USE_ORIGIN TRUE)
+if (APPLE)
+    set(CMAKE_INSTALL_RPATH "@executable_path/../${CMAKE_INSTALL_LIBDIR}")
+else()
+    set(CMAKE_INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
+endif()
+endif()
+add_executable(crossmerge src/crossmergecli.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossasm src/crossasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossdisasm src/crossdisasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
+
+add_executable(crossc src/programs/crosslangcompiler.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossvm src/programs/crosslangvm.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossint src/programs/crosslanginterperter.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossdump src/programs/crosslangdump.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crosslang src/programs/crosslang.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossarchiveextract src/programs/crossarchiveextract.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossarchivecreate src/programs/crossarchivecreate.cpp ${CROSSLANG_WIN32_EXE_SRC})
+if(NOT WIN32)
+add_executable(crossthumbnailer src/crossthumbnailer.cpp ${CROSSLANG_WIN32_EXE_SRC})
+endif()
+target_link_libraries(crossc PUBLIC crosslang_shared)
+target_link_libraries(crossvm PUBLIC crosslang_shared)
+target_link_libraries(crossint PUBLIC crosslang_shared)
+target_link_libraries(crossdump PUBLIC crosslang_shared)
+target_link_libraries(crosslang PUBLIC crosslang_shared)
+target_link_libraries(crossarchiveextract PUBLIC crosslang_shared)
+target_link_libraries(crossarchivecreate PUBLIC crosslang_shared)
+target_link_libraries(crossasm PUBLIC crosslang_shared)
+target_link_libraries(crossdisasm PUBLIC crosslang_shared)
+target_link_libraries(crossmerge PUBLIC crosslang_shared)
+
+if(NOT WIN32)
+target_link_libraries(crossthumbnailer PUBLIC crosslang_shared)
+endif()

cmake/slim.cmake

@@ -0,0 +1,21 @@
+
+add_executable(crosslang WIN32 src/programs/slim.cpp ${CROSSLANG_WIN32_EXE_SRC})
+
+if(CROSSLANG_ENABLE_STATIC)
+
+target_link_libraries(crosslang PUBLIC crosslang_static)
+elseif(CROSSLANG_ENABLE_SHARED)
+target_link_libraries(crosslang PUBLIC crosslang_shared)
+endif()
+
+if(CROSSLANG_ENABLE_SHARED)
+
+install(TARGETS crosslang_shared
+    EXPORT TessesCrossLangTargets
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+)
+
+endif()
+
+install(TARGETS crosslang DESTINATION "${CMAKE_INSTALL_BINDIR}")

cmake/sources.cmake

@@ -0,0 +1,66 @@
+list(APPEND CROSSLANG_SOURCE
+src/vm/bc/add.cpp
+src/vm/bc/sub.cpp
+src/vm/bc/getfield.cpp
+src/vm/bc/setfield.cpp
+src/vm/bc/tostring.cpp
+src/vm/bc/equals.cpp
+src/vm/bc/invokemethod.cpp
+src/vm/bc/executemethod2.cpp
+src/vm/bc/invoketwo.cpp
+src/vm/bc/tobool.cpp
+src/assembler/asm.cpp
+src/assembler/disasm.cpp
+src/assembler/merge.cpp
+src/compiler/codegen.cpp
+src/compiler/lexer.cpp
+src/compiler/parser.cpp
+src/compiler/ast.cpp
+src/runtime_methods/uuid.cpp
+src/runtime_methods/class.cpp
+src/runtime_methods/console.cpp
+src/runtime_methods/io.cpp
+src/runtime_methods/std.cpp
+src/runtime_methods/net.cpp
+src/runtime_methods/vm.cpp
+src/runtime_methods/json.cpp
+src/runtime_methods/sqlite.cpp
+src/runtime_methods/dictionary.cpp
+src/runtime_methods/crypto.cpp
+src/runtime_methods/ogc.cpp
+src/runtime_methods/path.cpp
+src/runtime_methods/env.cpp
+src/runtime_methods/process.cpp
+src/runtime_methods/helpers.cpp
+src/types/embed.cpp
+src/types/async.cpp
+src/types/associativearray.cpp
+src/types/any.cpp
+src/types/ittr.cpp
+src/types/closure.cpp
+src/types/dictionary.cpp
+src/types/externalmethod.cpp
+src/types/list.cpp
+src/types/native.cpp
+src/types/rootenvironment.cpp
+src/types/subenvironment.cpp
+src/types/vfsheapobject.cpp
+src/types/streamheapobject.cpp
+src/types/class.cpp
+src/types/classenvironment.cpp
+src/types/random.cpp
+src/vm/filereader.cpp
+src/vm/gc.cpp
+src/vm/gclist.cpp
+src/vm/vm.cpp
+src/vm/exception.cpp
+src/archive.cpp
+src/markedtobject.cpp
+src/program_lib/crossarchivecreate.cpp
+src/program_lib/crossarchiveextract.cpp
+src/program_lib/crossdump.cpp
+src/program_lib/crosslang.cpp
+src/program_lib/crosslangcompiler.cpp
+src/program_lib/crosslanginterperter.cpp
+src/program_lib/crosslangvm.cpp
+)

cmake/static_exec.cmake

@@ -0,0 +1,28 @@
+add_executable(crossc src/programs/crosslangcompiler.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossvm src/programs/crosslangvm.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossint src/programs/crosslanginterperter.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossdump src/programs/crosslangdump.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crosslang src/programs/crosslang.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossarchiveextract src/programs/crossarchiveextract.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossarchivecreate src/programs/crossarchivecreate.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossasm src/crossasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossdisasm src/crossdisasmcli.cpp ${CROSSLANG_WIN32_EXE_SRC})
+add_executable(crossmerge src/crossmergecli.cpp ${CROSSLANG_WIN32_EXE_SRC})
+
+if(NOT WIN32)
+add_executable(crossthumbnailer src/crossthumbnailer.cpp ${CROSSLANG_WIN32_EXE_SRC})
+endif()
+target_link_libraries(crossc PUBLIC crosslang_static)
+target_link_libraries(crossvm PUBLIC crosslang_static)
+target_link_libraries(crossint PUBLIC crosslang_static)
+target_link_libraries(crossdump PUBLIC crosslang_static)
+target_link_libraries(crosslang PUBLIC crosslang_static)
+target_link_libraries(crossarchiveextract PUBLIC crosslang_static)
+target_link_libraries(crossarchivecreate PUBLIC crosslang_static)
+target_link_libraries(crossmerge PUBLIC crosslang_static)
+target_link_libraries(crossasm PUBLIC crosslang_static)
+target_link_libraries(crossdisasm PUBLIC crosslang_static)
+
+if(NOT WIN32)
+target_link_libraries(crossthumbnailer PUBLIC crosslang_static)
+endif()

cmake/version.cmake

@@ -0,0 +1,3 @@
+set(CROSSLANG_MAJOR_VERSION 0)
+set(CROSSLANG_MINOR_VERSION 0)
+set(CROSSLANG_PATCH_VERSION 3)

include/CrossLang.hpp

@@ -20,6 +20,7 @@
 #include <any>
 
 #include "CrossLangVersion.h"
+#include "TessesFramework/Streams/ByteReader.hpp"
 
 #define CROSSLANG_BYTECODE_MAJOR 1
 #define CROSSLANG_BYTECODE_MINOR 0
@@ -1404,7 +1405,7 @@ class TContinue {
      * 
      */
 
-using TObject = std::variant<int64_t,double,char,bool,std::string,std::regex,Tesses::Framework::Filesystem::VFSPath,std::nullptr_t,Undefined,MethodInvoker,THeapObjectHolder,TVMVersion,std::shared_ptr<Tesses::Framework::Date::DateTime>,std::shared_ptr<Tesses::Framework::Date::TimeSpan>,TBreak,TContinue,std::shared_ptr<Tesses::Framework::Streams::Stream>,std::shared_ptr<Tesses::Framework::Filesystem::VFS>,std::shared_ptr<Tesses::Framework::Http::IHttpServer>,std::shared_ptr<Tesses::Framework::Http::HttpRequestBody>,std::shared_ptr<Tesses::Framework::TextStreams::TextReader>,std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>;
+using TObject = std::variant<int64_t,double,char,bool,std::string,std::regex,Tesses::Framework::Filesystem::VFSPath,std::nullptr_t,Undefined,MethodInvoker,THeapObjectHolder,TVMVersion,std::shared_ptr<Tesses::Framework::Date::DateTime>,std::shared_ptr<Tesses::Framework::Date::TimeSpan>,TBreak,TContinue,std::shared_ptr<Tesses::Framework::Streams::Stream>,std::shared_ptr<Tesses::Framework::Filesystem::VFS>,std::shared_ptr<Tesses::Framework::Http::IHttpServer>,std::shared_ptr<Tesses::Framework::Http::HttpRequestBody>,std::shared_ptr<Tesses::Framework::TextStreams::TextReader>,std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>,std::shared_ptr<Tesses::Framework::Streams::ByteReader>,std::shared_ptr<Tesses::Framework::Streams::ByteWriter>, Tesses::Framework::Uuid>;
 
 class TRootEnvironment;
 class GC;
@@ -1841,6 +1842,7 @@ class GC {
     class TStd {
         private:
             static void RegisterHelpers(GC* gc, TRootEnvironment* env);
+            static void RegisterUuid(GC* gc, TRootEnvironment* env);
         public:
             static void RegisterStd(GC* gc, TRootEnvironment* env);
             static void RegisterConsole(GC* gc,TRootEnvironment* env);
@@ -1857,6 +1859,7 @@ class GC {
             static void RegisterEnv(GC* gc, TRootEnvironment* env);
             static void RegisterProcess(GC* gc, TRootEnvironment* env);
             static void RegisterClass(GC* gc, TRootEnvironment* env);
+            
     };
 
     class TSubEnvironment : public TEnvironment
@@ -2612,5 +2615,15 @@ class GC {
             Tesses::Framework::Filesystem::VFSPath SystemToVFSPath(std::string path);
     };
 
-    
+    namespace Programs {
+        int64_t CrossArchiveCreate(std::vector<std::string>& argv);
+        int64_t CrossArchiveExtract(std::vector<std::string>& argv);
+        TObject CrossLangInterperter(GCList& ls,TRootEnvironment* env,std::vector<std::string>& argv);
+        TObject CrossLangShell(GCList& ls, std::vector<std::string>& argv);
+        
+        TObject CrossLangVM(GCList& ls,TRootEnvironment* env, std::vector<std::string>& argv);
+        
+        void CrossLangDump(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
+        void CrossLangCompiler(std::vector<std::string>& argv);
+    }
 };

src/crosslangvm.cpp

@@ -1,72 +0,0 @@
-#include "CrossLang.hpp"
-using namespace Tesses::Framework;
-using namespace Tesses::CrossLang;
-int main(int argc, char** argv)
-{
-    TF_InitWithConsole();
-    
-    if(argc < 2)
-    {
-        printf("USAGE: %s <filename.crvm> <args...>\n",argv[0]);
-        return 1;
-    }
-    if(argc > 0)
-        TF_AllowPortable(argv[0]);
-    
-    GC gc;
-    gc.Start();
-    GCList ls(gc);
-    TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
-    
-    TStd::RegisterStd(&gc,env);
-    env->LoadFileWithDependencies(&gc, Tesses::Framework::Filesystem::LocalFS, Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(argv[1]));
-    
-    if(env->HasVariable("WebAppMain"))
-    {
-        Args args(argc, argv);
-        int port = 4206;
-        for(auto& item : args.options)
-        {
-            if(item.first == "port")
-            {
-                port = std::stoi(item.second);
-            }
-        }
-
-        env->EnsureDictionary(&gc,"Net")->SetValue("WebServerPort", (int64_t)port);
-        TList* args2 = TList::Create(ls);
-        for(auto& item : args.positional)
-        {
-            args2->Add(item);
-        }
-
-        auto res = env->CallFunctionWithFatalError(ls, "WebAppMain", {args2});
-        auto svr2 = Tesses::CrossLang::ToHttpServer(&gc,res);
-        if(svr2 == nullptr) return 1;
-        Tesses::Framework::Http::HttpServer svr(port,svr2);
-        svr.StartAccepting();
-        TF_RunEventLoop();
-        TDictionary* _dict;
-        TClassObject* _co;
-        if(GetObjectHeap(res,_dict))
-        {
-            _dict->CallMethod(ls,"Close",{});
-        }
-        if(GetObjectHeap(res,_co))
-        {
-            _co->CallMethod(ls,"","Close",{});
-        }
-        TF_Quit();
-    }
-    else {
-    TList* args = TList::Create(ls);
-    for(int arg=1;arg<argc;arg++)
-        args->Add(std::string(argv[arg]));
-   
-    auto res = env->CallFunctionWithFatalError(ls,"main",{args});
-    int64_t iresult;
-    if(GetObject(res,iresult))
-        return (int)iresult;
-    }
-    return 0;
-}

src/program_lib/crossarchivecreate.cpp

@@ -1,11 +1,11 @@
 #include "CrossLang.hpp"
 #include <iostream>
-using namespace Tesses::CrossLang;
+namespace Tesses::CrossLang::Programs {
 using namespace Tesses::Framework::Filesystem;
 using namespace Tesses::Framework::Streams;
-void Help(const char* filename)
+static void Help(std::string& filename)
 {
-    printf("USAGE: %s [OPTIONS] <dirasroot> <archive.crvm>\n", filename);
+    std::cout << "USAGE: " << filename << " [OPTIONS] <dirasroot> <archive.crvm>" << std::endl;
     printf("OPTIONS:\n");
     printf("  -i:  Set info (ex {\"maintainer\": \"Mike Nolan\", \"repo\": \"https://example.com/\", \"homepage\": \"https://example.com/\",\"license\":\"MIT\"})\n");
     printf("  -I:  Set icon name (relative to dirasroot), should be a 128x128 png\n");
@@ -15,7 +15,8 @@ void Help(const char* filename)
     printf("Options except for help have flag with arg like this: -F ARG\n");
     exit(1);
 }
-int main(int argc, char** argv)
+
+int64_t CrossArchiveCreate(std::vector<std::string>& argv)
 {
     Tesses::Framework::TF_Init();
     std::string name="out";
@@ -23,40 +24,40 @@ int main(int argc, char** argv)
    TVMVersion version;
    std::string icon="";
    std::vector<std::string> args;
-    for(int i = 1; i < argc; i++)
+    for(int i = 1; i < argv.size(); i++)
    {
-        if(strcmp(argv[i],"--help") == 0 || strcmp(argv[i],"-h")==0) 
+        if(argv[i] == "--help" || argv[i] == "-h") 
         {
             Help(argv[0]);
         }
-        else if(strcmp(argv[i], "-i") == 0)
+        else if(argv[i] == "-i")
         {
             i++;
-            if(i < argc)
+            if(i < argv.size())
             {
                 info = argv[i];
             }
         }
-        else if(strcmp(argv[i], "-I") == 0)
+        else if(argv[i] == "-I")
         {
             i++;
-            if(i < argc)
+            if(i < argv.size())
             {
                 icon = argv[i];
             }
         }
-        else if(strcmp(argv[i], "-n") == 0)
+        else if(argv[i] == "-n")
         {
             i++;
-            if(i < argc)
+            if(i < argv.size())
             {
                 name = argv[i];
             }
         }
-        else if(strcmp(argv[i], "-v") == 0)
+        else if(argv[i] == "-v")
         {
             i++;
-            if(i < argc)
+            if(i < argv.size())
             {
                 
                 if(!TVMVersion::TryParse(argv[i],version))
@@ -90,4 +91,5 @@ int main(int argc, char** argv)
     CrossArchiveCreate(sdfs,strm,name,version,info,icon);
 
     return 0;
+}
 }

src/program_lib/crossarchiveextract.cpp

@@ -1,34 +1,34 @@
 #include "CrossLang.hpp"
 #include <iostream>
-using namespace Tesses::CrossLang;
+
+namespace Tesses::CrossLang::Programs {
 using namespace Tesses::Framework::Filesystem;
 using namespace Tesses::Framework::Streams;
 
-int main(int argc, char** argv)
+int64_t CrossArchiveExtract(std::vector<std::string>& argv)
 {
     Tesses::Framework::TF_Init();
-    if(argc < 3)
+    if(argv.size() < 3)
     {
-        printf("USAGE: %s <archive.crvm> <dirasroot>\n", argv[0]);
+        std::cout << "USAGE: " << argv[0] << " <archive.crvm> <dirasroot>" << std::endl;
         return 1;
     }
 
     auto sdfs= std::make_shared<SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,std::string(argv[2]));
-
+    auto strm= LocalFS->OpenFile(argv[1], "rb");
-    FILE* f = fopen(argv[1],"rb");
+    if(strm->CanRead()) 
-    if(f == NULL) 
     {
-        printf("ERROR: could not open %s\n", argv[1]);
+        std::cout << "ERROR: could not open " << argv[1] << std::endl;
         return 1;
     }
 
-    auto strm = std::make_shared<FileStream>(f,true,"rb",true);
 
-    auto res = CrossArchiveExtract(strm,sdfs);
+    auto res = Tesses::CrossLang::CrossArchiveExtract(strm,sdfs);
 
     std::cout << "Crvm Name: " << res.first.first << std::endl;
     std::cout << "Crvm Version: " << res.first.second.ToString() << std::endl;
     std::cout << "Crvm Info: " << std::endl << res.second << std::endl;
 
     return 0;
+}
 }

src/program_lib/crossdump.cpp

@@ -1,20 +1,20 @@
 #include "CrossLang.hpp"
 #include <iostream>
-using namespace Tesses::CrossLang;
+namespace Tesses::CrossLang::Programs {
-void Ensure(Tesses::Framework::Streams::Stream& strm,uint8_t* buffer, size_t len)
+static void Ensure(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,uint8_t* buffer, size_t len)
 {
-    if(strm.ReadBlock(buffer,len) != len)
+    if(strm->ReadBlock(buffer,len) != len)
     {
         throw VMException("Could not read " + std::to_string(len) + " byte(s).");
     }
 }
-uint32_t EnsureInt(Tesses::Framework::Streams::Stream& strm)
+static uint32_t EnsureInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
 {
     uint8_t buff[4];
     Ensure(strm,buff,sizeof(buff));
     return BitConverter::ToUint32BE(buff[0]);
 }
-std::string EnsureString(Tesses::Framework::Streams::Stream& strm)
+static std::string EnsureString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
 {
     size_t len = (size_t)EnsureInt(strm);
     std::string myStr={};
@@ -22,30 +22,24 @@ std::string EnsureString(Tesses::Framework::Streams::Stream& strm)
     Ensure(strm,(uint8_t*)myStr.data(), len);
     return myStr;
 }
-void DumpFile(std::filesystem::path p)
+void CrossLangDump(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
 {
-    if(std::filesystem::is_regular_file(p))
+    uint8_t main_header[18];
+    Ensure(strm,main_header,sizeof(main_header));
+    if(strncmp((const char*)main_header,"TCROSSVM",8) != 0) throw VMException("Invalid TCrossVM image.");
+    TVMVersion version(main_header+8);
+    if(version.CompareToRuntime() == 1)
     {
-        try
+        throw VMException("Runtime is too old.");
-        {
+    }
-            std::cout << "File: " << p.string() << std::endl;
+    TVMVersion v2(main_header+13);
-            Tesses::Framework::Streams::FileStream strm(p,"rb");
+    std::cout << "Version: " << v2.ToString() << std::endl;
-            uint8_t main_header[18];
-            Ensure(strm,main_header,sizeof(main_header));
-            if(strncmp((const char*)main_header,"TCROSSVM",8) != 0) throw VMException("Invalid TCrossVM image.");
-            TVMVersion version(main_header+8);
-            if(version.CompareToRuntime() == 1)
-            {
-                throw VMException("Runtime is too old.");
-            }
-            TVMVersion v2(main_header+13);
-            std::cout << "Version: " << v2.ToString() << std::endl;
 
-            size_t _len = (size_t)EnsureInt(strm);
+    size_t _len = (size_t)EnsureInt(strm);
 
-            std::cout << "SectionCount: " << _len << std::endl;
+    std::cout << "SectionCount: " << _len << std::endl;
 
-            std::vector<std::string> strs;
+    std::vector<std::string> strs;
 
             std::unordered_map<uint32_t, std::vector<std::string>> funs;
             std::vector<std::vector<std::string>> closures;
@@ -177,7 +171,7 @@ void DumpFile(std::filesystem::path p)
                         }
                         auto len = EnsureInt(strm);
 
-                        strm.Seek(len,Tesses::Framework::Streams::SeekOrigin::Current);
+                        strm->Seek(len,Tesses::Framework::Streams::SeekOrigin::Current);
 
                         closures.push_back(args);
                     }
@@ -208,7 +202,7 @@ void DumpFile(std::filesystem::path p)
                 }
                 else 
                 {
-                    strm.Seek((int64_t)tableLen,Tesses::Framework::Streams::SeekOrigin::Current);
+                    strm->Seek((int64_t)tableLen,Tesses::Framework::Streams::SeekOrigin::Current);
                 }
             }
             if(hasIcon)
@@ -252,22 +246,10 @@ void DumpFile(std::filesystem::path p)
             for(auto str : strs) {
                 std::cout << EscapeString(str, true) << std::endl;
             }
-        } 
+         
-        catch(std::exception& ex)
+        
-        {
+    
-            std::cout << "Error when reading file \"" << p.string() << "\" " << ex.what() << std::endl;
+    
-        }
-    }
-    else
-    {
-        std::cout << "CrossVM file \"" << p.string() << "\" does not exist." << std::endl;
-    }
-}
-int main(int argc, char** argv)
-{
-    Tesses::Framework::TF_Init();
-    for(int i = 1; i < argc; i++)
-    {
-        DumpFile(argv[i]);
-    }
 }
+
+}

src/program_lib/crosslang.cpp

@@ -1,13 +1,37 @@
 #include "CrossLang.hpp"
+#include "TessesFramework/Platform/Environment.hpp"
 #include <iostream>
 
 #include <string>
 using namespace Tesses::Framework;
-using namespace Tesses::CrossLang;
 using namespace Tesses::Framework::Http;
 
-bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs)
+namespace Tesses::CrossLang::Programs
 {
+
+static bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs)
+{
+    auto inContainer=Platform::Environment::GetVariable("CROSSLANG_CONTAINER");
+    if(inContainer && (*inContainer=="1" || *inContainer=="y" || *inContainer=="Y"))
+    {
+        HttpRequest req;
+        req.url = "https://downloads.tesses.net/ShellPackage.crvm";
+        req.method = "GET";
+        HttpResponse resp(req);
+        if(resp.statusCode == StatusCode::OK)
+        {
+            auto strm = resp.ReadAsStream();
+            CrossLang::CrossArchiveExtract(strm, vfs);
+
+            return true;
+        }
+        else
+        {
+            std::cout << "Error when fetching the script error: " << std::to_string(resp.statusCode) << " " << HttpUtils::StatusCodeString(resp.statusCode) << std::endl;
+            return false;
+        }
+    }
+
     while(true)
     {
         std::cout << "File " << filename.ToString() << " not found, do you want to download the installer from: https://downloads.tesses.net/ShellPackage.crvm (this may install other stuff as well) (Y/n)? ";
@@ -22,8 +46,8 @@ bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared_ptr<Te
             if(resp.statusCode == StatusCode::OK)
             {
                 auto strm = resp.ReadAsStream();
-                CrossArchiveExtract(strm, vfs);
+                CrossLang::CrossArchiveExtract(strm, vfs);
-               
+
                 return true;
             }
             else
@@ -37,35 +61,30 @@ bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared_ptr<Te
             std::cout << "Looks like you will need to install manually" << std::endl;
             return false;
         }
-        else 
+        else
         {
             std::cout << "Please use Y or N (case insensitive)" << std::endl;
-            
+
         }
     }
     return false;
 }
 
-int main(int argc, char** argv)
+TObject CrossLangShell(GCList& ls, std::vector<std::string>& argv)
 {
-    TF_InitWithConsole();
-    if(argc > 0)
-        TF_AllowPortable(argv[0]);
 
-    
-    
     Tesses::Framework::Filesystem::VFSPath dir = GetCrossLangConfigDir();
 
     Tesses::Framework::Filesystem::VFSPath filename = dir / "Shell" / "Shell.crvm";
-    
+
 
     auto p = Tesses::Framework::Platform::Environment::GetRealExecutablePath(Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(argv[0])).GetParent().GetParent() / "share" / "Tesses" / "CrossLang" / "Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm";
-    if(argc == 2 && strcmp(argv[1],"configdir") == 0)
+    if(argv.size() == 2 && argv[1] == "configdir")
     {
         std::cout << dir.ToString() << std::endl;
         return 0;
     }
-    if(argc > 1 && strcmp(argv[1],"update-shell") == 0)
+    if(argv.size() > 1 && argv[1] == "update-shell")
     {
 
         auto subdir = std::make_shared<Tesses::Framework::Filesystem::SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,dir);
@@ -76,8 +95,8 @@ int main(int argc, char** argv)
             if(resp.statusCode == StatusCode::OK)
             {
                 auto strm = resp.ReadAsStream();
-                CrossArchiveExtract(strm, subdir);
+                CrossLang::CrossArchiveExtract(strm, subdir);
-                
+
                 return 0;
             }
             else
@@ -97,8 +116,8 @@ int main(int argc, char** argv)
             auto strm = Tesses::Framework::Filesystem::LocalFS->OpenFile(p,"rb");
             if(strm != nullptr)
             {
-                CrossArchiveExtract(strm, subdir);
+                CrossLang::CrossArchiveExtract(strm, subdir);
-                
+
             }
             else
             {
@@ -111,31 +130,26 @@ int main(int argc, char** argv)
             return 0;
         }
     }
-    
 
-    GC gc;
-    gc.Start();
 
-    GCList ls(gc);
     TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
-    
 
-    TStd::RegisterStd(&gc,env);
+
-    
+    TStd::RegisterStd(ls.GetGC(),env);
-    
+
-    env->LoadFileWithDependencies(&gc, Tesses::Framework::Filesystem::LocalFS, filename);
+
-    
+    env->LoadFileWithDependencies(ls.GetGC(), Tesses::Framework::Filesystem::LocalFS, filename);
+
 
     TList* args = TList::Create(ls);
 
     args->Add(filename.ToString());
-    
+
-    for(int arg=1;arg<argc;arg++)
+    for(size_t arg=1;arg<argv.size();arg++)
         args->Add(std::string(argv[arg]));
-   
+
-    auto res = env->CallFunctionWithFatalError(ls,"main",{args});
+    return env->CallFunctionWithFatalError(ls,"main",{args});
-    int64_t iresult;
+
-    if(GetObject(res,iresult))
+}
-        return (int)iresult;
+
-    return 0;
 }

src/program_lib/crosslangcompiler.cpp

@@ -0,0 +1,290 @@
+#include "CrossLang.hpp"
+#include <iostream>
+#include <fstream>
+using namespace Tesses::Framework;
+using namespace Tesses::Framework::Filesystem;
+namespace Tesses::CrossLang::Programs {
+static void Help(std::string filename)
+{
+    std::cout << "USAGE: " << filename << " [OPTIONS] source_file1 source_file2 source_file_n" << std::endl;
+    printf("OPTIONS:\n");
+    printf("  -o:  Output directory (OUTDIR, defaults to ./bin)\n");
+    printf("  -i:  Set info (ex {\"maintainer\": \"Mike Nolan\", \"repo\": \"https://example.com/\", \"homepage\": \"https://example.com/\",\"license\":\"MIT\"})\n");
+    printf("  -I:  Set icon resource name (in the resource folder), should be a 128x128 png\n");
+    printf("  -v:  Set version (1.0.0.0-prod defaults to 1.0.0.0-dev)\n");
+    printf("  -d:  Add dependency (DependencyName-1.0.0.0-prod)\n");
+    printf("  -D: enable debug)\n");
+    printf("  -t:  Declare a tool (ToolName-1.0.0.0-prod)\n");
+    printf("  -n:  Set name (MyAppOrLibName defaults to out)\n");
+    printf("  -r:  Set resource directory (RESDIR defaults to res)\n");
+    printf("  -h, --help:  Prints help\n");
+    printf("  -e:  Set comptime permissions defaults to none, none for no support, \"secure\" for sane without file access, \"secure_file\" for sane with file access to current directory and sub directories, \"full\" has full runtime.\n");
+    printf("Options except for help have flag with arg like this: -F ARG\n");
+    exit(1);
+}
+void CrossLangCompiler(std::vector<std::string>& argv)
+{
+    /*std::ifstream strm(argv[1],std::ios_base::in|std::ios_base::binary);
+    std::vector<LexToken> tokens;
+    Lex(argv[1],strm,tokens);
+
+    Parser parser(tokens);
+
+    CodeGen gen;
+    gen.GenRoot(parser.ParseRoot());
+    std::vector<uint8_t> data;
+    ByteCodeVectorWriter w(data);
+    gen.Save(std::filesystem::current_path(),w);
+    */
+   TF_InitWithConsole();
+   std::filesystem::path outputDir = std::filesystem::current_path() / "bin";
+   std::vector<std::filesystem::path> source;
+   std::filesystem::path resourceDir = std::filesystem::current_path() / "res";
+   std::vector<std::pair<std::string, TVMVersion>> dependencies;
+   std::vector<std::pair<std::string, TVMVersion>> tools;
+   std::string name="out";
+   std::string info="{}";
+   std::string icon="";
+   std::string comptime="none";
+   TVMVersion version;
+   bool debug=false;
+
+   
+
+   for(size_t i = 1; i < argv.size(); i++)
+   {
+        if(argv[i] == "--help" || argv[i] == "-h") 
+        {
+            Help(argv[0]);
+        }
+        
+        else if(argv[i] == "-o")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                outputDir = argv[i];
+            }
+        }
+        else if(argv[i] == "-r")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                resourceDir = argv[i];
+            }
+        }
+        else if(argv[i] == "-e")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                comptime = argv[i];
+            }
+        }
+   
+        else if(argv[i] == "-i")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                info = argv[i];
+            }
+        }
+        else if(argv[i] == "-I")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                icon = argv[i];
+            }
+        }
+        else if(argv[i] == "-d")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                std::string str = argv[i];
+                auto lastDash = str.find_last_of('-');
+                if(lastDash < str.size())
+                {
+                    std::string str2 = str.substr(lastDash+1);
+                    if(str2 == "dev" || str2 == "alpha" || str2 == "beta" || str2 == "prod")
+                    {
+                        lastDash = str.find_last_of('-',lastDash-1);
+                    }
+                    std::string str1 = str.substr(0,lastDash);
+                    str2 = str.substr(lastDash+1);
+                    
+                    TVMVersion v2;
+                    if(!TVMVersion::TryParse(str2,v2))
+                    {
+                        printf("ERROR: Invalid syntax for version\n");
+                        printf("Expected MAJOR[.MINOR[.PATCH[.BUILD[-dev,-alpha,-beta,-prod]]]]\n");
+                        exit(1);
+                    }
+                    dependencies.push_back(std::pair<std::string,TVMVersion>(str1,v2));
+                    
+                }
+                else
+                {
+                    printf("ERROR: Dependency must have version\n");
+                    exit(1);
+                }
+            }
+        }
+        else if(argv[i] == "-t")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                std::string str = argv[i];
+                auto lastDash = str.find_last_of('-');
+                if(lastDash < str.size())
+                {
+                    std::string str2 = str.substr(lastDash+1);
+                    if(str2 == "dev" || str2 == "alpha" || str2 == "beta" || str2 == "prod")
+                    {
+                        lastDash = str.find_last_of('-',lastDash-1);
+                    }
+                    std::string str1 = str.substr(0,lastDash);
+                    str2 = str.substr(lastDash+1);
+                    
+                    TVMVersion v2;
+                    if(!TVMVersion::TryParse(str2,v2))
+                    {
+                        printf("ERROR: Invalid syntax for version\n");
+                        printf("Expected MAJOR[.MINOR[.PATCH[.BUILD[-dev,-alpha,-beta,-prod]]]]\n");
+                        exit(1);
+                    }
+                    tools.push_back(std::pair<std::string,TVMVersion>(str1,v2));
+                    
+                }
+                else
+                {
+                    printf("ERROR: Tool must have version\n");
+                    exit(1);
+                }
+            }
+        }
+        else if(argv[i] == "-n")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                name = argv[i];
+            }
+        }
+        else if(argv[i] == "-v")
+        {
+            i++;
+            if(i < argv.size())
+            {
+                
+                if(!TVMVersion::TryParse(argv[i],version))
+                {
+                    printf("ERROR: Invalid syntax for version\n");
+                    printf("Expected MAJOR[.MINOR[.PATCH[.BUILD[-dev,-alpha,-beta,-prod]]]]\n");
+                    exit(1);
+                }
+            }
+        }
+        else if(argv[i] == "-D" || argv[i] == "--debug")
+        {
+            debug = true;
+        }
+        else {
+            source.push_back(argv[i]);
+        }
+   }
+    if(source.empty())
+   {
+        Help(argv[0]);
+   }
+  
+
+    std::vector<LexToken> tokens;
+
+    for(auto src : source)
+    {
+        std::ifstream strm(src,std::ios_base::in|std::ios_base::binary);
+        int res = Lex(std::filesystem::absolute(src).string(),strm,tokens);
+        
+    }
+
+    GC* gc=nullptr;
+    GCList* ls=nullptr;
+    TRootEnvironment* env=nullptr;
+    if(comptime != "none")
+    {
+        gc = new GC();
+        gc->Start();
+        ls = new GCList(gc);
+        env = TRootEnvironment::Create(ls,TDictionary::Create(ls));
+
+        if(comptime == "secure")
+        {
+            TStd::RegisterConsole(gc,env);
+            TStd::RegisterClass(gc,env);
+            TStd::RegisterCrypto(gc,env);
+            TStd::RegisterDictionary(gc,env);
+            TStd::RegisterJson(gc,env);
+            TStd::RegisterRoot(gc,env);
+            TStd::RegisterIO(gc,env,false);
+            env->permissions.locked=true;
+        }
+        else if(comptime == "secure_file")
+        {
+            TStd::RegisterConsole(gc,env);
+            TStd::RegisterClass(gc,env);
+            TStd::RegisterCrypto(gc,env);
+            TStd::RegisterDictionary(gc,env);
+            TStd::RegisterJson(gc,env);
+            TStd::RegisterRoot(gc,env);
+            TStd::RegisterIO(gc,env,false);
+            env->permissions.locked=true;
+            auto fs = env->EnsureDictionary(gc,"FS");
+            fs->SetValue("Local", std::make_shared<SubdirFilesystem>(LocalFS,Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory()));
+        }
+        else if(comptime == "full")
+        {
+            TStd::RegisterStd(gc,env);
+            env->permissions.locked=true;
+        }
+    }
+    
+    Parser parser(tokens,gc,env);
+    parser.debug = debug;
+    CodeGen gen;
+
+    auto sfs = std::make_shared<SubdirFilesystem>(LocalFS,LocalFS->SystemToVFSPath(resourceDir.string()));
+    gen.embedFS = sfs;
+
+    gen.GenRoot(parser.ParseRoot());
+    gen.name = name;
+    gen.version = version;
+    gen.info = info;
+    gen.icon = icon;
+    for(auto deps : dependencies)
+    {
+        gen.dependencies.push_back(deps);
+    }
+    for(auto tool : tools)
+    {
+        gen.tools.push_back(tool);
+    }
+    
+    std::filesystem::create_directory(outputDir);
+
+    {
+        auto strm = std::make_shared<Tesses::Framework::Streams::FileStream>(outputDir / (name + "-" + version.ToString() + ".crvm"),"wb");
+    
+        gen.Save(strm);
+    }
+    if(gc != nullptr)
+    {
+        delete ls;
+        delete gc;
+    }
+}
+}

src/program_lib/crosslanginterperter.cpp

@@ -4,20 +4,13 @@
 #include <sstream>
 #include <vector>
 using namespace Tesses::Framework;
-using namespace Tesses::CrossLang;
 using namespace Tesses::Framework::Filesystem;
-int main(int argc, char** argv)
+
+namespace Tesses::CrossLang::Programs {
+TObject CrossLangInterperter(GCList& ls,TRootEnvironment* env,std::vector<std::string>& argv)
 {
-    TF_InitWithConsole();
+    GC* gc = ls.GetGC();    
-    if(argc > 0)
+    if(argv.size() > 1)
-        TF_AllowPortable(argv[0]);
-    GC gc;
-    gc.Start();
-    GCList ls(gc);
-    TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
-    TStd::RegisterStd(&gc,env);
-    
-    if(argc > 1)
     {
         std::ifstream strm(argv[1],std::ios_base::in|std::ios_base::binary);
         std::vector<LexToken> tokens;
@@ -32,30 +25,28 @@ int main(int argc, char** argv)
         gen.GenRoot(parser.ParseRoot());
         std::vector<uint8_t> data;
         {
-        auto strm2 = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
+            auto strm2 = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
-        gen.Save(strm2);
+            gen.Save(strm2);
 
         
-        {
+            {
-            TFile* file = TFile::Create(ls);
+                TFile* file = TFile::Create(ls);
 
-            strm2->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
+                strm2->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
-            file->Load(&gc,strm2);
+                file->Load(gc,strm2);
     
-            env->LoadFile(&gc, file);
+                env->LoadFile(gc, file);
 
             
+            }
         }
-    }
 
-         TList* args = TList::Create(ls);
+        TList* args = TList::Create(ls);
-    for(int arg=1;arg<argc;arg++)
+        for(int arg=1;arg<argv.size();arg++)
-        args->Add(std::string(argv[arg]));
+            args->Add(std::string(argv[arg]));
    
-    auto res = env->CallFunctionWithFatalError(ls,"main",{args});
+        return env->CallFunctionWithFatalError(ls,"main",{args});
-    int64_t iresult;
+    
-    if(GetObject(res,iresult))
-        return (int)iresult;
    
     }
     else
@@ -91,7 +82,7 @@ int main(int argc, char** argv)
             }
             else if(source == "exit")
             {
-                return 0;
+                return (int64_t)0;
             }
             else
             {
@@ -116,9 +107,9 @@ int main(int argc, char** argv)
             TFile* file = TFile::Create(ls);
 
             strm2->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
-            file->Load(&gc,strm2);
+            file->Load(gc,strm2);
     
-            env->LoadFile(&gc, file);
+            env->LoadFile(gc, file);
 
                 
             }   
@@ -126,4 +117,8 @@ int main(int argc, char** argv)
     
         }
     }
+
+    return (int64_t)0;
 }
+
+}

src/program_lib/crosslangvm.cpp

@@ -0,0 +1,61 @@
+#include "CrossLang.hpp"
+using namespace Tesses::Framework;
+namespace Tesses::CrossLang::Programs {
+    TObject CrossLangVM(GCList& ls,TRootEnvironment* env, std::vector<std::string>& argv)
+    {
+        if(argv.size() < 2)
+        {
+            std::cout << "USAGE: " << (argv.empty() ? (std::string)"crossvm" : argv[0]) <<  " <filename.crvm> <args...>" << std::endl;
+            return 1;
+        }
+    
+        env->LoadFileWithDependencies(ls.GetGC(), Tesses::Framework::Filesystem::LocalFS, Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(argv[1]));
+    
+        if(env->HasVariable("WebAppMain"))
+        {
+            Args args(argv);
+            int port = 4206;
+            for(auto& item : args.options)
+            {
+                if(item.first == "port")
+                {
+                    port = std::stoi(item.second);
+                }
+            }
+
+            env->EnsureDictionary(ls.GetGC(),"Net")->SetValue("WebServerPort", (int64_t)port);
+            TList* args2 = TList::Create(ls);
+            for(auto& item : args.positional)
+            {
+                args2->Add(item);
+            }
+
+            auto res = env->CallFunctionWithFatalError(ls, "WebAppMain", {args2});
+            auto svr2 = Tesses::CrossLang::ToHttpServer(ls.GetGC(),res);
+            if(svr2 == nullptr) return 1;
+            Tesses::Framework::Http::HttpServer svr(port,svr2);
+            svr.StartAccepting();
+            TF_RunEventLoop();
+            TDictionary* _dict;
+            TClassObject* _co;
+            if(GetObjectHeap(res,_dict))
+            {
+                _dict->CallMethod(ls,"Close",{});
+            }
+            if(GetObjectHeap(res,_co))
+            {
+                _co->CallMethod(ls,"","Close",{});
+            }
+            TF_Quit();
+            return 0;
+        }
+        else {
+            TList* args = TList::Create(ls);
+            for(size_t arg=1;arg<argv.size();arg++)
+                args->Add(std::string(argv[arg]));
+   
+            return env->CallFunctionWithFatalError(ls,"main",{args});
+    
+        }
+    }
+}

src/programs/crossarchivecreate.cpp

@@ -0,0 +1,9 @@
+#include "CrossLang.hpp"
+
+int main(int argc, char** argv)
+{
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+    return (int)Tesses::CrossLang::Programs::CrossArchiveCreate(args);
+}

src/programs/crossarchiveextract.cpp

@@ -0,0 +1,9 @@
+#include "CrossLang.hpp"
+
+int main(int argc, char** argv)
+{
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+    return (int)Tesses::CrossLang::Programs::CrossArchiveExtract(args);
+}

src/programs/crosslang.cpp

@@ -0,0 +1,25 @@
+#include "CrossLang.hpp"
+
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+using namespace Tesses::Framework::Filesystem;
+int main(int argc, char** argv)
+{
+    TF_InitWithConsole();
+    if(argc > 0)
+        TF_AllowPortable(argv[0]);
+    GC gc;
+    gc.Start();
+    GCList ls(gc);
+    
+
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+    auto res = Programs::CrossLangShell(ls, args);
+
+    int64_t myi64;
+    if(GetObject(res,myi64))
+        return (int)myi64;
+    return 0;
+}

src/programs/crosslangcompiler.cpp

@@ -0,0 +1,23 @@
+#include "CrossLang.hpp"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+using namespace Tesses::Framework::Filesystem;
+int main(int argc, char** argv)
+{
+    TF_InitWithConsole();
+    if(argc > 0)
+        TF_AllowPortable(argv[0]);
+   
+    
+
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+    Programs::CrossLangCompiler(args);
+
+    return 0;
+}

src/programs/crosslangdump.cpp

@@ -0,0 +1,28 @@
+#include "CrossLang.hpp"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+using namespace Tesses::Framework::Filesystem;
+int main(int argc, char** argv)
+{
+    TF_InitWithConsole();
+    if(argc > 0)
+        TF_AllowPortable(argv[0]);
+
+    for(int i = 1; i < argc; i++)
+    {
+        VFSPath path(argv[i]);
+        if(LocalFS->FileExists(path))
+        {
+            std::cout << "File: " << path.ToString() << std::endl;
+            auto strm = LocalFS->OpenFile(path, "rb");
+            Programs::CrossLangDump(strm);
+        }
+        else {
+            std::cout << "File: " << path.ToString() << " does not exist." << std::endl;
+        }
+    }
+}

src/programs/crosslanginterperter.cpp

@@ -0,0 +1,29 @@
+#include "CrossLang.hpp"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+using namespace Tesses::Framework::Filesystem;
+int main(int argc, char** argv)
+{
+    TF_InitWithConsole();
+    if(argc > 0)
+        TF_AllowPortable(argv[0]);
+    GC gc;
+    gc.Start();
+    GCList ls(gc);
+    TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+    TStd::RegisterStd(&gc,env);
+
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+    auto res = Programs::CrossLangInterperter(ls, env, args);
+
+    int64_t myi64;
+    if(GetObject(res,myi64))
+        return (int)myi64;
+    return 0;
+}

src/programs/crosslangvm.cpp

@@ -0,0 +1,29 @@
+#include "CrossLang.hpp"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+using namespace Tesses::Framework::Filesystem;
+int main(int argc, char** argv)
+{
+    TF_InitWithConsole();
+    if(argc > 0)
+        TF_AllowPortable(argv[0]);
+    GC gc;
+    gc.Start();
+    GCList ls(gc);
+    TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+    TStd::RegisterStd(&gc,env);
+
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+    auto res = Programs::CrossLangVM(ls, env, args);
+
+    int64_t myi64;
+    if(GetObject(res,myi64))
+        return (int)myi64;
+    return 0;
+}

src/programs/slim.cpp

@@ -0,0 +1,164 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Filesystem/VFS.hpp"
+using namespace Tesses::Framework;
+using namespace Tesses::CrossLang;
+using namespace Tesses::Framework::Filesystem;
+
+int main(int argc, char** argv)
+{
+    //crosslang crossint
+    //crosslang 
+    //crosslang ...
+
+    std::string programName = "crosslang";
+
+    TF_InitWithConsole();
+    if(argc > 0)
+    {
+        TF_AllowPortable(argv[0]);
+        Tesses::Framework::Filesystem::VFSPath path=(std::string)argv[0];
+        path.RemoveExtension();
+        programName = path.GetFileName();
+    }
+   
+    std::vector<std::string> args(argc);
+    for(int i = 0; i < argc; i++)
+        args[i] = argv[i];
+        if(programName == "crossint")
+        {
+            GC gc;
+            gc.Start();
+            GCList ls(gc);
+            TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+            TStd::RegisterStd(&gc,env);
+            auto res= Programs::CrossLangInterperter(ls, env, args);
+            int64_t myi64;
+            if(GetObject(res,myi64))
+                return (int)myi64;
+            return 0;
+        }
+        else if(programName == "crossc")
+        {
+            Programs::CrossLangCompiler(args);
+            return 0;
+        }
+        else if(programName == "crossarchivecreate")
+        {
+            Programs::CrossArchiveCreate(args);
+            return 0;
+        }
+        else if(programName == "crossarchiveextract")
+        {
+            Programs::CrossArchiveExtract(args);
+            return 0;
+        }
+        else if(programName == "crossdump")
+        {
+            for(size_t i = 1; i < args.size(); i++)
+            {
+                VFSPath path = args[i];
+                if(LocalFS->FileExists(path))
+                {
+                    std::cout << "File: " << path.ToString() << std::endl;
+                    auto strm = LocalFS->OpenFile(path, "rb");
+                    Programs::CrossLangDump(strm);
+                }
+                else {
+                    std::cout << "File: " << path.ToString() << " does not exist." << std::endl;
+                }
+            }
+            return 0;
+        }
+        else if(programName == "crossvm")
+        {
+            GC gc;
+            gc.Start();
+            GCList ls(gc);
+            TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+            TStd::RegisterStd(&gc,env);
+            auto res= Programs::CrossLangVM(ls, env, args);
+            int64_t myi64;
+            if(GetObject(res,myi64))
+                return (int)myi64;
+            return 0;
+    }
+    else if(args.size() > 1)
+    {    
+        
+        if(args[1] == "crossint")
+        {
+            args.erase(args.begin());
+            GC gc;
+            gc.Start();
+            GCList ls(gc);
+            TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+            TStd::RegisterStd(&gc,env);
+            auto res= Programs::CrossLangInterperter(ls, env, args);
+            int64_t myi64;
+            if(GetObject(res,myi64))
+                return (int)myi64;
+            return 0;
+        }
+        else if(args[1] == "crossc")
+        {
+            args.erase(args.begin());
+            Programs::CrossLangCompiler(args);
+            return 0;
+        }
+        else if(args[1] == "crossarchivecreate")
+        {
+            args.erase(args.begin());
+            Programs::CrossArchiveCreate(args);
+            return 0;
+        }
+        else if(args[1] == "crossarchiveextract")
+        {
+            args.erase(args.begin());
+            Programs::CrossArchiveExtract(args);
+            return 0;
+        }
+        else if(args[1] == "crossdump")
+        {
+            for(size_t i = 2; i < args.size(); i++)
+            {
+                VFSPath path = args[i];
+                if(LocalFS->FileExists(path))
+                {
+                    std::cout << "File: " << path.ToString() << std::endl;
+                    auto strm = LocalFS->OpenFile(path, "rb");
+                    Programs::CrossLangDump(strm);
+                }
+                else {
+                    std::cout << "File: " << path.ToString() << " does not exist." << std::endl;
+                }
+            }
+            return 0;
+        }
+        else if(args[1] == "crossvm")
+        {
+            args.erase(args.begin());
+            GC gc;
+            gc.Start();
+            GCList ls(gc);
+            TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+            TStd::RegisterStd(&gc,env);
+            auto res= Programs::CrossLangVM(ls, env, args);
+            int64_t myi64;
+            if(GetObject(res,myi64))
+                return (int)myi64;
+            return 0;
+        }
+    }
+    
+    
+        GC gc;
+        gc.Start();
+        GCList ls(gc);
+        auto res= Programs::CrossLangShell(ls, args);
+        int64_t myi64;
+        if(GetObject(res,myi64))
+            return (int)myi64;
+        return 0;
+        return 0;
+    
+}

src/runtime_methods/env.cpp

@@ -1,4 +1,5 @@
 #include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
 
 #if defined(_WIN32)
 #include <windows.h>
@@ -131,6 +132,10 @@ namespace Tesses::CrossLang
         ls.GetGC()->BarrierEnd();
         return list;
     }
+    static TObject Env_getLittleEndian(GCList& ls, std::vector<TObject> args)
+    {
+        return Tesses::Framework::Serialization::BitConverter::IsLittleEndian();
+    }
     void TStd::RegisterEnv(GC* gc, TRootEnvironment* env)
     {
 
@@ -155,6 +160,7 @@ namespace Tesses::CrossLang
         dict->DeclareFunction(gc,"getUser","Get user folder",{},Env_getUser);
         dict->DeclareFunction(gc,"getPlatform","Get platform name",{},Env_getPlatform);
         dict->DeclareFunction(gc,"GetRealExecutablePath", "Get the absolute path for executable", {"path"},Env_GetRealExecutablePath);
+        dict->DeclareFunction(gc, "getLittleEndian", "Is the platform little endian", {},Env_getLittleEndian);
         gc->BarrierBegin();
         dict->SetValue("EnvPathSeperator",EnvPathSeperator);
         env->SetVariable("Env", dict);

src/runtime_methods/std.cpp

@@ -1,5 +1,11 @@
 
 #include "CrossLang.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Streams/Stream.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <memory>
+#include <variant>
+#include <vector>
 #if defined(CROSSLANG_ENABLE_SHARED)
 #if defined(CROSSLANG_ENABLE_FFI)
 #include <ffi.h>
@@ -568,6 +574,23 @@ namespace Tesses::CrossLang
         std::shared_ptr<Tesses::Framework::TextStreams::TextWriter> strm;
         return GetArgument(args,0,strm);
     }
+    static TObject TypeIsByteReader(GCList& ls, std::vector<TObject> args)
+    {
+        if(args.empty()) return nullptr;
+        std::shared_ptr<Tesses::Framework::Streams::ByteReader> strm;
+        return GetArgument(args,0,strm);
+    }
+    static TObject TypeIsByteWriter(GCList& ls, std::vector<TObject> args)
+    {
+        if(args.empty()) return nullptr;
+        std::shared_ptr<Tesses::Framework::Streams::ByteWriter> strm;
+        return GetArgument(args,0,strm);
+    }
+    static TObject TypeIsUuid(GCList& ls, std::vector<TObject> args)
+    {
+        if(args.empty()) return nullptr;
+        return std::holds_alternative<Tesses::Framework::Uuid>(args[0]);
+    }
     static TObject TypeIsVFS(GCList& ls, std::vector<TObject> args)
     {
         if(args.empty()) return nullptr;
@@ -741,6 +764,11 @@ namespace Tesses::CrossLang
         if(std::holds_alternative<TVMVersion>(_obj)) return "Version";
         if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(_obj)) return "DateTime";
         if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(_obj)) return "TimeSpan";
+        if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::ByteReader>>(_obj)) return "ByteReader";
+
+        if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::ByteWriter>>(_obj)) return "ByteWriter";
+
+        if(std::holds_alternative<Tesses::Framework::Uuid>(_obj)) return "Uuid";
         if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::Stream>>(_obj))
         {
             auto strm = std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(_obj);
@@ -1222,6 +1250,21 @@ namespace Tesses::CrossLang
         }
         return nullptr;
     }
+    static TObject New_ByteReader(GCList& ls, std::vector<TObject> args)
+    {
+        std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
+        if(GetArgument(args, 0, strm))
+            return std::make_shared<Tesses::Framework::Streams::ByteReader>(strm);
+        return nullptr;
+    }
+    static TObject New_ByteWriter(GCList& ls, std::vector<TObject> args)
+    {
+        std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
+        if(GetArgument(args, 0, strm))
+            return std::make_shared<Tesses::Framework::Streams::ByteWriter>(strm);
+        return nullptr;
+    }
+
     void TStd::RegisterRoot(GC* gc, TRootEnvironment* env)
     {
         GCList ls(gc);      
@@ -1230,6 +1273,8 @@ namespace Tesses::CrossLang
         
         env->permissions.canRegisterRoot=true;
         RegisterHelpers(gc,env);
+        RegisterUuid(gc, env);
+        
        
         auto date =env->EnsureDictionary(gc,"DateTime");
         date->DeclareFunction(gc, "Sleep","Sleep for a specified amount of milliseconds (multiply seconds by 1000 to get milliseconds)", {"ms"},DateTime_Sleep);
@@ -1269,6 +1314,10 @@ namespace Tesses::CrossLang
         task->DeclareFunction(gc, "FromResult", "async from result", {"result"}, Task_FromResult);
 
         TDictionary* newTypes = env->EnsureDictionary(gc, "New");
+
+        newTypes->DeclareFunction(gc, "ByteReader","Read binary data from stream",{"stream"},New_ByteReader);
+
+        newTypes->DeclareFunction(gc, "ByteWriter","Write binary data to stream",{"stream"},New_ByteWriter);
         //newTypes->DeclareFunction(gc,)
         newTypes->DeclareFunction(gc, "Promise", "Create an async object",{"resolve","reject"},New_Promise);
         newTypes->DeclareFunction(gc, "DateTime","Create a DateTime object, if only one arg is provided year is epoch, isLocal defaults to true unless epoch",{"year","$month","$day","$hour","$minute","$second","$isLocal"},New_DateTime);
@@ -1339,6 +1388,9 @@ namespace Tesses::CrossLang
         env->DeclareFunction(gc, "TypeIsTimeSpan","Get whether object is a TimeSpan",{"object"},TypeIsTimeSpan);
         env->DeclareFunction(gc, "TypeIsTextReader","Get whether object is a TextReader",{"object"},TypeIsTextReader);
         env->DeclareFunction(gc, "TypeIsTextWriter","Get whether object is a TextWriter",{"object"},TypeIsTextWriter);
+        env->DeclareFunction(gc, "TypeIsByteReader","Get whether object is a ByteReader",{"object"},TypeIsByteReader);
+        env->DeclareFunction(gc, "TypeIsByteWriter","Get whether object is a ByteWriter",{"object"},TypeIsByteWriter);
+        env->DeclareFunction(gc, "TypeIsUuid","Get whether object is a Uuid",{"object"},TypeIsUuid);
         
         
         newTypes->DeclareFunction(gc, "Regex", "Create regex object",{"regex"},[](GCList& ls,std::vector<TObject> args)->TObject {

src/runtime_methods/uuid.cpp

@@ -0,0 +1,40 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Uuid.hpp"
+
+namespace Tesses::CrossLang {
+    static TObject Uuid_NewUuid(GCList& ls, std::vector<TObject> args)
+    {
+        return Tesses::Framework::Uuid::Generate();
+    }
+    static TObject Uuid_TryParse(GCList& ls, std::vector<TObject> args)
+    {
+        std::string str;
+        Tesses::Framework::Uuid uuid;
+        if(GetArgument(args, 0, str) && Tesses::Framework::Uuid::TryParse(str,uuid))
+            return uuid;
+        return nullptr;
+    }
+    static TObject Uuid_FromBytes(GCList& ls, std::vector<TObject> args)
+    {
+        TByteArray* ba;
+        int64_t index;
+        if(GetArgumentHeap(args,0,ba) && GetArgument(args, 1, index) && (size_t)index < ba->data.size() && (size_t)index + 16 <= ba->data.size())
+        {
+            return Tesses::Framework::Serialization::BitConverter::ToUuid(ba->data[(size_t)index]);
+        }
+
+        return nullptr;
+    }
+    
+    void TStd::RegisterUuid(GC* gc, TRootEnvironment* env)
+    {
+        gc->BarrierBegin();
+        TDictionary* guid = env->EnsureDictionary(gc, "Uuid");
+        guid->DeclareFunction(gc,"NewUuid","Create random uuid",{},Uuid_NewUuid);
+        guid->DeclareFunction(gc, "TryParse","Try to parse",{"str"}, Uuid_TryParse);
+        guid->DeclareFunction(gc, "FromBytes", "From bytes (big endian)",{"byteArray","offset"}, Uuid_FromBytes);
+    
+        gc->BarrierEnd();
+    }
+}

src/runtime_methods/vm.cpp

@@ -354,6 +354,11 @@ namespace Tesses::CrossLang
             }
             return nullptr;
         });
+        #if defined(CROSSLANG_ENABLE_SUPERSLIM)
+        dict->SetValue("SuperSlim", true);
+        #else
+        dict->SetValue("SuperSlim", false);
+        #endif
         dict->DeclareFunction(gc, "Eval", "Eval source code",{"source"}, VM_Eval);
         dict->DeclareFunction(gc, "Compile", "Compile Source",{"dict"},VM_Compile);
         

src/types/dictionary.cpp

@@ -110,18 +110,18 @@ namespace Tesses::CrossLang  {
             if(GetObjectHeap(res,callable))
             {
                  auto closure = dynamic_cast<TClosure*>(callable);
-                if(closure != nullptr && !closure->closure->args.empty() && closure->closure->args.front() == "this") 
+                if(closure != nullptr && !closure->closure->args.empty() && closure->closure->args.front() == "this")
                 {
                    std::vector<TObject> args2;
                         args2.push_back(this);
                         args2.insert(args2.end(), args.begin(),args.end());
                     return closure->Call(ls,args2);
-                    
+
                 }
                 else
                 {
                     return callable->Call(ls,args);
-                    
+
                 }
             }
         return Undefined();
@@ -136,23 +136,23 @@ namespace Tesses::CrossLang  {
             if(GetObjectHeap(res,callable))
             {
                  auto closure = dynamic_cast<TClosure*>(callable);
-                if(closure != nullptr && !closure->closure->args.empty() && closure->closure->args.front() == "this") 
+                if(closure != nullptr && !closure->closure->args.empty() && closure->closure->args.front() == "this")
                 {
                    std::vector<TObject> args2;
                         args2.push_back(this);
                         args2.insert(args2.end(), args.begin(),args.end());
                     return closure->CallWithFatalError(ls,args2);
-                    
+
                 }
                 else
                 {
                     return callable->CallWithFatalError(ls,args);
-                    
+
                 }
             }
         return Undefined();
     }
-    
+
     void TDictionary::DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb)
     {
         gc->BarrierBegin();
@@ -184,10 +184,8 @@ namespace Tesses::CrossLang  {
     TObject TDictionary::GetValue(std::string key)
     {
         if(this->items.empty()) return Undefined();
-        for(auto item : this->items)
+        if(this->items.count(key) > 0)
-        {
+                return this->items[key];
-            if(item.first == key) return item.second;
-        }
         return Undefined();
     }
     void TDictionary::SetValue(std::string key, TObject value)
@@ -231,5 +229,5 @@ namespace Tesses::CrossLang  {
         _gc->Watch(dict);
         return dict;
     }
-    
+
-};
+};

src/vm/bc/add.cpp

@@ -0,0 +1,164 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+namespace Tesses::CrossLang {
+    bool InterperterThread::Add(GC* gc)
+    {
+        std::vector<CallStackEntry*>& cse=this->call_stack_entries;
+        GCList ls(gc);
+        auto right = cse.back()->Pop(ls);
+        auto left = cse.back()->Pop(ls);
+
+
+
+        if(std::holds_alternative<std::string>(left) && std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(right))
+        {
+            cse.back()->Push(gc,std::get<std::string>(left) + std::get<Tesses::Framework::Filesystem::VFSPath>(right));
+        
+        }
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
+        {
+            cse.back()->Push(gc,(char)(std::get<char>(left) + std::get<char>(right)));
+        }
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<char>(right))
+        {
+            cse.back()->Push(gc, (char)(std::get<int64_t>(left) + std::get<char>(right)));
+        }
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<int64_t>(right))
+        {
+            cse.back()->Push(gc, (char)(std::get<char>(left) + std::get<int64_t>(right)));
+        }
+        else if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(left) && std::holds_alternative<std::string>(right))
+        {
+            cse.back()->Push(gc,std::get<Tesses::Framework::Filesystem::VFSPath>(left) + std::get<std::string>(right));
+        
+        }
+
+        else if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(left) && std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(right))
+        {
+            cse.back()->Push(gc,std::get<Tesses::Framework::Filesystem::VFSPath>(left) + std::get<Tesses::Framework::Filesystem::VFSPath>(right));
+        
+        }
+
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+        {
+            cse.back()->Push(gc,std::get<int64_t>(left) + std::get<int64_t>(right));
+        }
+        
+        else if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+        {
+            cse.back()->Push(gc,std::get<double>(left) + std::get<double>(right));
+        }
+        else if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+        {
+            cse.back()->Push(gc,std::get<double>(left) + std::get<int64_t>(right));
+        }
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+        {
+            cse.back()->Push(gc,std::get<int64_t>(left) + std::get<double>(right));
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
+        {
+            auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left);
+            auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
+            cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::TimeSpan>((*l) + (*r)));
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
+        {
+            auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
+            auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
+            cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::DateTime>((*l) + (*r)));
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right))
+        {
+            auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left);
+            auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right);
+            cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::DateTime>((*l) + (*r)));
+        }
+        else if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
+        {
+            std::string str={};
+            str.append(std::get<std::string>(left));
+            str.append(std::get<std::string>(right));
+            cse.back()->Push(gc,str);
+        }
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<std::string>(right))
+        {
+            std::string str={};
+            str.push_back(std::get<char>(left));
+            str.append(std::get<std::string>(right));
+            cse.back()->Push(gc,str);
+        }
+        else if(std::holds_alternative<std::string>(left) && std::holds_alternative<char>(right))
+        {
+            std::string str={};
+            str.append(std::get<std::string>(left));
+            str.push_back(std::get<char>(right));
+            cse.back()->Push(gc,str);
+        }
+        else if(std::holds_alternative<THeapObjectHolder>(left))
+        {
+            auto obj = std::get<THeapObjectHolder>(left).obj;
+            auto dict = dynamic_cast<TDictionary*>(obj);
+            auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
+            auto natObj = dynamic_cast<TNativeObject*>(obj);
+            auto cls = dynamic_cast<TClassObject*>(obj);
+            if(cls != nullptr)
+            {
+                gc->BarrierBegin();
+                auto obj=cls->GetValue(cse.back()->callable->className,"operator+");
+                gc->BarrierEnd();
+                TClosure* clos;
+                TCallable* callable;
+                if(GetObjectHeap(obj,clos)) 
+                {
+                    this->AddCallStackEntry(ls,clos,{right});
+                    return true;
+                }
+                else if(GetObjectHeap(obj,callable))
+                {
+                    cse.back()->Push(gc,callable->Call(ls,{right}));
+                    return false;
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+               
+            }
+            else if(natObj != nullptr)
+            {
+                cse.back()->Push(gc, natObj->CallMethod(ls,"operator+",{right}));
+                return false;
+            }
+            else if(dict != nullptr)
+            {
+                gc->BarrierBegin();
+                TObject fn = dict->GetValue("operator+");
+                gc->BarrierEnd();
+                return InvokeTwo(ls,fn,left,right);
+            }
+            else if(dynDict != nullptr)
+            {
+                cse.back()->Push(gc,dynDict->CallMethod(ls,"operator+",{right}));
+                return false;
+            }
+            else
+            {
+                cse.back()->Push(gc, Undefined());
+            }
+           
+        }
+        else
+        {
+            cse.back()->Push(gc, Undefined());
+        }
+        return false;
+    }
+}

src/vm/bc/equals.cpp

@@ -0,0 +1,236 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+
+
+namespace Tesses::CrossLang {
+
+    bool Equals(GC* gc, TObject left, TObject right)
+    {
+        GCList ls(gc);
+        if(std::holds_alternative<std::nullptr_t>(left) && std::holds_alternative<std::nullptr_t>(right))
+        {
+
+            return true;
+        }
+
+        else if(std::holds_alternative<Undefined>(left) && std::holds_alternative<Undefined>(right))
+        {
+            return true;
+        }
+
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+        {
+            return std::get<int64_t>(left) == std::get<int64_t>(right);
+        }
+
+        else if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+        {
+            return std::get<double>(left) == std::get<double>(right);
+        }
+        else if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+        {
+            return std::get<double>(left) == std::get<int64_t>(right);
+        }
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+        {
+            return std::get<int64_t>(left) == std::get<double>(right);
+        }
+
+        else if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
+        {
+            return std::get<std::string>(left) == std::get<std::string>(right);
+        }
+
+        else if(std::holds_alternative<bool>(left) && std::holds_alternative<bool>(right))
+        {
+            return std::get<bool>(left) == std::get<bool>(right);
+        }
+
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
+        {
+            return std::get<char>(left) == std::get<char>(right);
+        }
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<int64_t>(right))
+        {
+            return std::get<char>(left) == std::get<int64_t>(right);
+        }
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<char>(right))
+        {
+            return std::get<int64_t>(left) == std::get<char>(right);
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right))
+        {
+            return std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left)->ToEpoch() == std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right)->ToEpoch();
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
+        {
+            return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left)->TotalSeconds() == std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right)->TotalSeconds();
+        }
+        else if(std::holds_alternative<TVMVersion>(left) && std::holds_alternative<TVMVersion>(right))
+        {
+            auto lver= std::get<TVMVersion>(left);
+            auto rver = std::get<TVMVersion>(right);
+            auto r = lver.CompareTo(rver);
+            return r == 0;
+        }
+        else if(std::holds_alternative<Tesses::Framework::Uuid>(left) && std::holds_alternative<Tesses::Framework::Uuid>(right))
+        {
+            auto l= std::get<Tesses::Framework::Uuid>(left);
+            auto r = std::get<Tesses::Framework::Uuid>(right);
+            
+            return l == r;
+        }
+        else if(std::holds_alternative<THeapObjectHolder>(left))
+        {
+            auto obj = std::get<THeapObjectHolder>(left).obj;
+            auto dict = dynamic_cast<TDictionary*>(obj);
+
+            auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
+            auto native = dynamic_cast<TNative*>(obj);
+            auto natObj = dynamic_cast<TNativeObject*>(obj);
+            auto cls = dynamic_cast<TClassObject*>(obj);
+            if(cls != nullptr)
+            {
+                gc->BarrierBegin();
+                auto obj=cls->GetValue("","operator==");
+                gc->BarrierEnd();
+                TCallable* callable;
+                
+                if(GetObjectHeap(obj,callable))
+                {
+                    return ToBool(callable->Call(ls,{right}));
+                   
+                }
+                else if(std::holds_alternative<std::nullptr_t>(right)) {
+                    return false;
+                }
+                else if(std::holds_alternative<Undefined>(right)) 
+                {
+                    return false;
+                }
+                else if(std::holds_alternative<THeapObjectHolder>(right))
+                {
+                    return cls == std::get<THeapObjectHolder>(right).obj;
+                }
+            }
+             else 
+            if(natObj != nullptr)
+            {
+                return natObj->Equals(gc, right);
+            }
+            if(dict != nullptr)
+            {
+                gc->BarrierBegin();
+                TObject fn = dict->GetValue("operator==");
+                gc->BarrierEnd();
+                if(!std::holds_alternative<Undefined>(fn))
+                {
+                    if(std::holds_alternative<THeapObjectHolder>(fn))
+                    {
+
+                        auto obj = dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj);
+                        if(obj != nullptr)
+                        {
+                            auto closure = dynamic_cast<TClosure*>(obj);
+                            if(closure != nullptr)
+                            {
+
+                                if(!closure->closure->args.empty() && closure->closure->args[0] == "this")
+                                {
+                                    return ToBool(obj->Call(ls,{left,right}));
+                                }
+                                else
+                                {
+                                    return ToBool(obj->Call(ls,{right}));
+                                }
+
+                            }
+                            else
+                            {
+                                return ToBool(obj->Call(ls,{right}));
+
+                            }
+                        }
+                        else {
+
+                            
+                            return dict == std::get<THeapObjectHolder>(right).obj;
+                        }  
+
+                    } else {
+
+                            return dict == std::get<THeapObjectHolder>(right).obj;
+                        }
+
+                }
+                else {
+
+                    return dict == std::get<THeapObjectHolder>(right).obj;
+                }
+                return false;
+
+            }
+
+            else if(dynDict != nullptr)
+            {
+                auto res = dynDict->CallMethod(ls,"operator==",{right});
+                if(!std::holds_alternative<std::nullptr_t>(res) && std::holds_alternative<Undefined>(res))
+                {
+                    return ToBool(res);
+                }
+            }
+            else if(native != nullptr && std::holds_alternative<std::nullptr_t>(right))
+            {
+                return native->GetDestroyed();
+
+            }
+
+            if(std::holds_alternative<THeapObjectHolder>(right))
+            {
+                return obj == std::get<THeapObjectHolder>(right).obj;
+
+            }
+
+            else if(std::holds_alternative<std::nullptr_t>(right))
+            {
+                return false;
+            }
+            else if(std::holds_alternative<Undefined>(right))
+            {
+
+                return false;
+            }
+            else
+            {
+                return false;
+            }
+
+        }
+
+        else if(std::holds_alternative<std::nullptr_t>(right))
+        {
+            return false;
+        }
+        else if(std::holds_alternative<Undefined>(right))
+        {
+            return false;
+        }
+        else
+        {
+            return false;
+
+        }
+
+        return false;
+
+    }
+}

src/vm/bc/getfield.cpp

@@ -0,0 +1,769 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+namespace Tesses::CrossLang {
+    bool InterperterThread::GetField(GC* gc)
+    {
+        std::vector<CallStackEntry*>& cse=this->call_stack_entries;
+
+        if(!cse.empty())
+        {
+            auto stk = cse.back();
+            GCList ls(gc);
+            TObject _key = stk->Pop(ls);
+            
+            
+            TObject instance = stk->Pop(ls);
+            
+            if(!std::holds_alternative<std::string>(_key))
+            {
+                stk->Push(gc,Undefined());
+                return false;
+            }
+
+            std::string key = std::get<std::string>(_key);
+
+
+            if(std::holds_alternative<std::string>(instance))
+            {
+                std::string str = std::get<std::string>(instance);
+                
+                if(key == "Count" || key == "Length")
+                {
+                    int64_t len = (int64_t)str.size();
+                    if(len < 0) len = 0;
+
+                    cse.back()->Push(gc, len);
+                    return false;
+                }
+                cse.back()->Push(gc, Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(instance))
+            {
+                auto vfs = std::get<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(instance);
+                auto tmpFS=std::dynamic_pointer_cast<Tesses::Framework::Filesystem::TempFS>(vfs);
+                if(tmpFS)
+                {
+                    if(key == "TempDirectoryName")
+                    {
+
+                        cse.back()->Push(gc,tmpFS->TempDirectoryName());
+                        return false;
+                    }
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(instance))
+            {
+                auto writer = std::get<std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(instance);
+                auto stringWriter = std::dynamic_pointer_cast<Tesses::Framework::TextStreams::StringWriter>(writer);
+                if(stringWriter != nullptr)
+                {
+                    if(key == "Text")
+                    {
+                        cse.back()->Push(gc, stringWriter->GetString());
+                        return false;
+                    }
+                }
+                if(key == "NewLine")
+                {
+                    cse.back()->Push(gc,writer->newline);
+                    return false;
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::ByteReader>>(instance))
+            {
+                auto br = std::get<std::shared_ptr<Tesses::Framework::Streams::ByteReader>>(instance);
+                if(key == "Stream")
+                {
+                    cse.back()->Push(gc,br->GetStream());
+                    return false;
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::ByteWriter>>(instance))
+            {
+                auto bw = std::get<std::shared_ptr<Tesses::Framework::Streams::ByteWriter>>(instance);
+                if(key == "Stream")
+                {
+                    
+                    cse.back()->Push(gc,bw->GetStream());
+                    return false;
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance))
+            {
+                auto strm = std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance);
+                 if(strm != nullptr)
+                {
+                    auto netStrm = std::dynamic_pointer_cast<Tesses::Framework::Streams::NetworkStream>(strm);
+                   
+                        if(key == "CanRead")
+                        {
+                             
+                            
+                            cse.back()->Push(gc, strm->CanRead());
+                            return false;
+                        }
+                        if(key == "CanWrite")
+                        {
+                            
+                            cse.back()->Push(gc, strm->CanWrite());
+                            return false;
+                        }
+                        if(key == "CanSeek")
+                        {
+                            
+                            
+                            cse.back()->Push(gc, strm->CanSeek());
+                            return false;
+                        }
+                        if(key == "EndOfStream")
+                        {
+                            
+                            cse.back()->Push(gc, strm->EndOfStream());
+                            return false;
+                        }
+                        if(key == "Length")
+                        {
+                            
+                            cse.back()->Push(gc, strm->GetLength());
+                            return false;
+                        }
+                         if(key == "Position")
+                        {
+                            
+                            cse.back()->Push(gc, strm->GetPosition());
+                            return false;
+                        }
+
+                        if(netStrm != nullptr)
+                        {
+                            if(key == "Port")
+                            {
+                                cse.back()->Push(gc, netStrm->GetPort());
+                                return false;
+                            }
+                        }
+
+                        cse.back()->Push(gc, Undefined());
+
+                        return false;
+                    
+                }
+            }
+            if(std::holds_alternative<TVMVersion>(instance))
+            {
+                TVMVersion& version = std::get<TVMVersion>(instance);
+                if(key == "Major")
+                {
+                    stk->Push(gc, (int64_t)version.Major());
+                    return false;
+                }
+                if(key == "Minor")
+                {
+                    stk->Push(gc, (int64_t)version.Minor());
+                    return false;
+                }
+                if(key == "Patch")
+                {
+                    stk->Push(gc, (int64_t)version.Patch());
+                    return false;
+                }
+                if(key == "Build")
+                {
+                    stk->Push(gc, (int64_t)version.Build());
+                    return false;
+                }
+                if(key == "VersionInt")
+                {
+                    stk->Push(gc,(int64_t)version.AsLong());
+                    return false;
+                }
+                if(key == "Stage")
+                {
+                    switch(version.VersionStage())
+                    {
+                        case TVMVersionStage::DevVersion:
+                            stk->Push(gc,"dev");
+                            break;
+                        case TVMVersionStage::AlphaVersion:
+                            stk->Push(gc,"alpha");
+                            break;
+                        case TVMVersionStage::BetaVersion:
+                            stk->Push(gc,"beta");
+                            break;
+                        case TVMVersionStage::ProductionVersion:
+                            stk->Push(gc,"prod");
+                            break;
+                    }
+                    return false;
+                }
+                
+                stk->Push(gc, Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(instance))
+            {
+                auto time = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(instance);
+                if(key == "Days")
+                {
+                    stk->Push(gc, (int64_t)time->Days());
+                    return false;
+                }
+                if(key == "Hours")
+                {
+                    stk->Push(gc, (int64_t)time->Hours());
+                    return false;
+                }
+
+                if(key == "Minutes")
+                {
+                    stk->Push(gc, (int64_t)time->Minutes());
+                    return false;
+                }
+                if(key == "Seconds")
+                {
+                    stk->Push(gc, (int64_t)time->Seconds());
+                    return false;
+                }
+
+                if(key == "TotalHours")
+                {
+                    stk->Push(gc, time->TotalHours());
+                    return false;
+                }
+
+                if(key == "TotalMinutes")
+                {
+                    stk->Push(gc, time->TotalMinutes());
+                    return false;
+                }
+
+                if(key == "TotalSeconds")
+                {
+                    stk->Push(gc, time->TotalSeconds());
+                    return false;
+                }
+                
+                stk->Push(gc, Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(instance))
+            {
+                auto& date = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(instance);
+                if(key == "IsLocal")
+                {
+                    stk->Push(gc, date->IsLocal());
+                    return false;
+                }
+                if(key == "Year")
+                {
+                    stk->Push(gc, (int64_t)date->Year());
+                    return false;
+                }
+                if(key == "Month")
+                {
+                    stk->Push(gc, (int64_t)date->Month());
+                    return false;
+                }
+                if(key == "Day")
+                {
+                    stk->Push(gc, (int64_t)date->Day());
+                    return false;
+                }
+                if(key == "Hour")
+                {
+                    stk->Push(gc, (int64_t)date->Hour());
+                    return false;
+                }
+                if(key == "Minute")
+                {
+                    stk->Push(gc, (int64_t)date->Minute());
+                    return false;
+                }
+                if(key == "Second")
+                {
+                    stk->Push(gc, (int64_t)date->Second());
+                    return false;
+                }
+                if(key == "DayOfWeek")
+                {
+                    stk->Push(gc, (int64_t)date->DayOfWeek());
+                    return false;
+                }
+                
+                stk->Push(gc, Undefined());
+                return false;
+            }
+            if(std::holds_alternative<THeapObjectHolder>(instance))
+            {
+                auto obj = std::get<THeapObjectHolder>(instance).obj;
+                auto bA = dynamic_cast<TByteArray*>(obj);
+                auto list = dynamic_cast<TList*>(obj);
+                auto dict = dynamic_cast<TDictionary*>(obj);
+                auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
+                auto dynList = dynamic_cast<TDynamicList*>(obj);
+                auto tcallable = dynamic_cast<TCallable*>(obj);
+                auto closure = dynamic_cast<TClosure*>(obj);
+                auto externalMethod = dynamic_cast<TExternalMethod*>(obj);
+                auto ittr = dynamic_cast<TEnumerator*>(obj);
+                
+                auto callstackEntry = dynamic_cast<CallStackEntry*>(obj);
+                auto file = dynamic_cast<TFile*>(obj);
+                auto chunk = dynamic_cast<TFileChunk*>(obj);
+                auto natObj = dynamic_cast<TNativeObject*>(obj);
+                auto cls = dynamic_cast<TClassObject*>(obj);
+                auto aarray = dynamic_cast<TAssociativeArray*>(obj);
+                auto task = dynamic_cast<TTask*>(obj);
+                if(task != nullptr)
+                {
+                    if(key == "IsCompleted")
+                    {
+                        cse.back()->Push(gc,task->IsCompleted());
+                        return false;
+                    }
+                    cse.back()->Push(gc,Undefined());
+                    return false;
+                }
+                if(aarray != nullptr)
+                {
+                    if(key == "Count" || key == "Length")
+                    {
+                        cse.back()->Push(gc,aarray->Count());
+                        return false;
+                    }
+                    cse.back()->Push(gc, Undefined());
+                    return false;
+                }
+                else if(cls != nullptr)
+                {
+                    gc->BarrierBegin();
+                    auto obj=cls->GetValue(cse.back()->callable->className,"get"+key);
+                    gc->BarrierEnd();
+                    TClosure* clos;
+                    TCallable* callable;
+                    if(GetObjectHeap(obj,clos)) 
+                    {
+                        this->AddCallStackEntry(ls,clos,{});
+                        return true;
+                    }
+                    else if(GetObjectHeap(obj,callable))
+                    {
+                        cse.back()->Push(gc,callable->Call(ls,{}));
+                        return false;
+                    }
+                    cse.back()->Push(gc,cls->GetValue(cse.back()->callable->className,key));
+                    return false;
+               
+                }
+                else
+                if(natObj != nullptr)
+                {
+                    cse.back()->Push(gc,natObj->CallMethod(ls,"get"+key,{}));
+                    return false;
+                }
+               
+                if(file != nullptr)
+                {
+                    if(key == "Version")
+                    {
+                        cse.back()->Push(gc,file->version);
+                        return false;
+                    }
+                    else if(key == "Name")
+                    {
+                        cse.back()->Push(gc,file->name);
+                        return false;
+                    }
+                    else if(key == "Info")
+                    {
+                        cse.back()->Push(gc, file->info);
+                        return false;
+                    }
+                    else if(key == "Dependencies")
+                    {
+                        auto list = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto item : file->dependencies)
+                        {
+                            auto res = TDictionary::Create(ls);
+                            res->SetValue("Name", item.first);
+                            res->SetValue("Version", item.second);
+                            list->Add(res);
+                        }
+                        gc->BarrierEnd();
+                        cse.back()->Push(gc, list);
+                        return false;
+                    }
+                    else if(key == "Tools")
+                    {
+                        auto list = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto item : file->tools)
+                        {
+                            auto res = TDictionary::Create(ls);
+                            res->SetValue("Name", item.first);
+                            res->SetValue("Version", item.second);
+                            list->Add(res);
+                        }
+                        gc->BarrierEnd();
+                        cse.back()->Push(gc, list);
+                        return false;
+                    }
+                    else if(key == "Strings")
+                    {
+                        auto list = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto item : file->name)
+                        {
+                            list->Add(item);
+                        }
+                        gc->BarrierEnd();
+
+                        cse.back()->Push(gc, list);
+                        return false;
+                    }
+                    else if(key == "MetadataCount")
+                    {
+
+                        cse.back()->Push(gc, (int64_t)file->metadata.size());
+                        return false;
+                    }
+                    else if(key == "Metadata")
+                    {   
+                        TList* meta = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(size_t i = 0; i < file->metadata.size(); i++)
+                        {
+                            meta->Add(
+                                TDictionary::Create(ls,
+                                    {
+                                    TDItem("Name", file->metadata[i].first),
+                                    TDItem("Index",(int64_t)i)
+                                    }
+                                )
+                            );
+                        }
+                        gc->BarrierEnd();
+
+                        cse.back()->Push(gc, meta);
+                        return false;
+                    }
+                    else if(key == "Sections")
+                    {
+                        TList* sections = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto& item : file->sections)
+                        {
+                            TByteArray* ba = TByteArray::Create(ls);
+                            ba->data = item.second;
+                            sections->Add(TDictionary::Create(ls,{
+                                TDItem("Name", item.first),
+                                TDItem("Data", ba)
+                            }));
+                        }
+                        gc->BarrierEnd();
+
+                        cse.back()->Push(gc, sections);
+                        return false;
+                    }
+                    else if(key == "SupportedVMs")
+                    {
+                        TList* supported = TList::Create(ls);
+                        gc->BarrierBegin();
+                        if(file->vms.empty()) 
+                        {
+                            supported->Add(TDictionary::Create(ls,{
+                                TDItem("Name",std::string(VMName)),
+                                TDItem("HowToGet",std::string(VMHowToGet))
+                            }));
+                        }
+                        else {
+                            for(auto item : file->vms)
+                                supported->Add(TDictionary::Create(ls,{
+                                    TDItem("Name",item.first),
+                                    TDItem("HowToGet",item.second)
+                                }));
+                        }
+                        gc->BarrierEnd();
+                        cse.back()->Push(gc, supported);
+                        return false;
+                    }
+                    else if(key == "Chunks")
+                    {
+                        auto list = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto item : file->chunks)
+                        {
+                            list->Add(item);
+                        }
+
+                        gc->BarrierEnd();
+
+                        cse.back()->Push(gc, list);
+                        return false;
+                    }
+                    else if(key == "Classes")
+                    {
+                        auto list = TList::Create(ls);
+                        gc->BarrierBegin();
+
+                        for(uint32_t i = 0; i < (uint32_t)file->classes.size(); i++)
+                        {
+                            list->Add(GetClassInfo(ls,file,i));
+                        }
+
+                        cse.back()->Push(gc, list);
+                        gc->BarrierEnd();
+                        return false;
+                    }
+                    else if(key == "Functions")
+                    {
+                        auto list = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto& item : file->functions)
+                        {
+                            TDictionary* dict = TDictionary::Create(ls);
+                            if(!item.first.empty())
+                                dict->SetValue("Documentation", item.first[0]);
+                            TList* nameParts = TList::Create(ls);
+                            for(size_t i = 1; i < item.first.size(); i++)
+                            {
+                                nameParts->Add(item.first[i]);
+                            }
+                            dict->SetValue("NameParts", nameParts);
+                            dict->SetValue("ChunkId", (int64_t)item.second);
+
+                            list->Add(dict);
+                        }
+                        
+                        cse.back()->Push(gc, list);
+                        gc->BarrierEnd();
+                        return false;
+                    }
+                    else if(key == "Icon")
+                    {
+                        if(file->icon >= 0 && file->icon < file->resources.size())
+                        {
+                            TByteArray* ba = TByteArray::Create(ls);
+                            ba->data = file->resources[file->icon];
+                            cse.back()->Push(gc, ba);
+                            return false;
+                        }
+                        else {
+                            cse.back()->Push(gc, nullptr);
+                            return false;
+                        }
+                    }
+                    cse.back()->Push(gc, Undefined());
+                    return false;
+                }
+                if(chunk != nullptr)
+                {
+                    if(key == "Arguments")
+                    {
+                        auto myargs = TList::Create(ls);
+                        gc->BarrierBegin();
+                        for(auto item : chunk->args)
+                        {
+                            myargs->Add(item);
+                        }
+                        gc->BarrierEnd();
+                        cse.back()->Push(gc, myargs);
+                        return false;
+                    }
+                    if(key == "Code")
+                    {   
+                        auto ba = TByteArray::Create(ls);
+                        ba->data = chunk->code;
+                        cse.back()->Push(gc, ba);
+                        return false;
+                    }
+                    if(key == "File")
+                    {
+                        cse.back()->Push(gc, chunk->file);
+                        return false;
+                    }
+                    cse.back()->Push(gc, Undefined());
+                    return false;
+                }
+                if(callstackEntry != nullptr)
+                {
+                    if(key == "IP") 
+                    {
+                        cse.back()->Push(gc, (int64_t)callstackEntry->ip);
+                        return false;
+                    }
+                    if(key == "IsDone")
+                    {
+                        cse.back()->Push(gc, callstackEntry->ip >= callstackEntry->callable->closure->code.size());
+                        return false;
+                    }
+                    if(key == "Closure")
+                    {
+                        cse.back()->Push(gc, callstackEntry->callable);
+                        return false;
+                    }
+                    if(key == "StackEmpty")
+                    {
+                        cse.back()->Push(gc, callstackEntry->stack.empty());
+                        return false;
+                    }
+                    cse.back()->Push(gc,Undefined());
+                    return false;
+                }
+            
+               
+               
+                
+                if(ittr != nullptr)
+                {
+                    if(key == "Current")
+                    {
+                        cse.back()->Push(gc, ittr->GetCurrent(ls));
+                        return false;
+                    }
+                    cse.back()->Push(gc, Undefined());
+                    return false;
+                }
+                if(closure != nullptr)
+                {
+                    if(key == "Arguments")
+                    {
+                        GCList ls2(gc);
+                        TList* ls = TList::Create(ls2);
+                        for(auto arg : closure->closure->args)
+                        {
+                            ls->Add(arg);
+                        }
+                        cse.back()->Push(gc,ls);
+                        return false;
+                    }
+                    if(key == "File")
+                    {
+                        cse.back()->Push(gc,closure->file);   
+                        return false;                 
+                    }
+                }
+                if(externalMethod != nullptr)
+                {
+                    if(key == "Arguments")
+                    {
+                        GCList ls2(gc);
+                        TList* ls = TList::Create(ls2);
+                        for(auto arg : externalMethod->args)
+                        {
+                            ls->Add(arg);
+                        }
+                        cse.back()->Push(gc,ls);
+                        return false;
+                    }
+                }
+
+                if(tcallable != nullptr)
+                {
+                    if(key == "Documentation")
+                    {
+                        cse.back()->Push(gc, tcallable->documentation);
+                        return false;
+                    }
+                    if(key == "Tag")
+                    {
+                        gc->BarrierBegin();
+                        cse.back()->Push(gc, tcallable->tag);
+                        gc->BarrierEnd();
+                        return false;
+                    }
+                    cse.back()->Push(gc,Undefined());
+                    return false;
+                }
+                
+                if(bA != nullptr)
+                {
+                    if(key == "Count" || key == "Length")
+                    {
+                        int64_t len = (int64_t)bA->data.size();
+                        if(len < 0) len = 0;
+
+                        stk->Push(gc, len);
+                        return false;
+                    }   
+                }
+                if(list != nullptr)
+                {
+                    if(key == "Count" || key == "Length")
+                    {
+                        int64_t len = list->Count();
+                        if(len < 0) len = 0;
+
+                        stk->Push(gc, len);
+                        return false;
+                    }   
+                }
+                if(dynList != nullptr)
+                {
+                    if(key == "Count" || key == "Length")
+                    {
+                        int64_t len = dynList->Count(ls);
+                        if(len < 0) len = 0;
+
+                        stk->Push(gc, len);
+                        return false;
+                    }   
+                }
+                if(dynDict != nullptr)
+                {
+                    if(dynDict->MethodExists(ls,"get" + key))
+                    {
+                        cse.back()->Push(gc,dynDict->CallMethod(ls,"get" + key, {}));
+                    }
+                    else
+                    {
+                        cse.back()->Push(gc, dynDict->GetField(ls,key));
+                    }
+                    return false;
+                }
+
+                if(dict != nullptr)
+                {
+                    gc->BarrierBegin();
+                    TObject fn = dict->GetValue("get" + key);
+                    gc->BarrierEnd();
+                    if(std::holds_alternative<THeapObjectHolder>(fn) && dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj) != nullptr)
+                    {
+                        return InvokeOne(ls,fn, dict);
+                    }
+                    else
+                    {
+                        gc->BarrierBegin();
+                       fn = dict->GetValue(key);
+                        stk->Push(gc, fn);
+                        gc->BarrierEnd();
+                        return false;
+                    }
+                }
+           
+            }
+
+            stk->Push(gc, Undefined());
+        }
+        
+        return false;
+    }
+}

src/vm/bc/invokemethod.cpp

@@ -0,0 +1,54 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+
+namespace Tesses::CrossLang {
+
+    bool InterperterThread::InvokeMethod(GCList& ls, TObject fn, TObject instance, std::vector<TObject> args)
+    {
+    
+        if(std::holds_alternative<THeapObjectHolder>(fn))
+        {
+            
+            auto obj = dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj);
+            if(obj != nullptr)
+            {
+                auto closure = dynamic_cast<TClosure*>(obj);
+                if(closure != nullptr)
+                {
+                    
+                    if(!closure->closure->args.empty() && closure->closure->args[0] == "this")
+                    {
+                        std::vector<TObject> args2;
+                        args2.push_back(instance);
+                        args2.insert(args2.end(), args.begin(),args.end());
+                        this->AddCallStackEntry(ls,closure,args2);
+                    }
+                    else
+                    {
+                        this->AddCallStackEntry(ls,closure,args);
+                    }
+                    
+                }
+                else
+                {
+                    auto val = obj->Call(ls,args);
+                    this->call_stack_entries.back()->Push(ls.GetGC(), val);    
+                    return false;
+                }
+                return true;
+            }
+            
+        }
+        this->call_stack_entries.back()->Push(ls.GetGC(),Undefined());
+        return false;
+    }
+}

src/vm/bc/invoketwo.cpp

@@ -0,0 +1,47 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+namespace Tesses::CrossLang {
+    bool InterperterThread::InvokeTwo(GCList& ls, TObject fn, TObject left, TObject right)
+    {
+        if(std::holds_alternative<THeapObjectHolder>(fn))
+        {
+            
+            auto obj = dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj);
+            if(obj != nullptr)
+            {
+                auto closure = dynamic_cast<TClosure*>(obj);
+                if(closure != nullptr)
+                {
+                    
+                    if(!closure->closure->args.empty() && closure->closure->args[0] == "this")
+                    {
+                        this->AddCallStackEntry(ls,closure,{left,right});
+                    }
+                    else
+                    {
+                        this->AddCallStackEntry(ls,closure,{right});
+                    }
+                    
+                }
+                else
+                {
+                    this->call_stack_entries[this->call_stack_entries.size()-1]->Push(ls.GetGC(), obj->Call(ls,{right}));
+                   
+                    return false;
+                }
+                return true;
+            }
+            
+        }
+        return false;
+    }
+}

src/vm/bc/setfield.cpp

@@ -0,0 +1,278 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+namespace Tesses::CrossLang {
+     
+    bool InterperterThread::SetField(GC* gc)
+    {
+        std::vector<CallStackEntry*>& cse=this->call_stack_entries;
+
+        if(!cse.empty())
+        {
+            auto stk = cse.back();
+            GCList ls(gc);
+            TObject value = stk->Pop(ls);
+            TObject _key = stk->Pop(ls);
+            TObject instance = stk->Pop(ls);
+            
+            if(!std::holds_alternative<std::string>(_key))
+            {
+                stk->Push(gc,Undefined());
+                return false;
+            }
+
+            std::string key = std::get<std::string>(_key);
+             if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(instance))
+            {
+                auto writer = std::get<std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(instance);
+                auto stringWriter = std::dynamic_pointer_cast<Tesses::Framework::TextStreams::StringWriter>(writer);
+                if(stringWriter != nullptr)
+                {
+                    if(key == "Text")
+                    {
+                        if(std::holds_alternative<std::string>(value))
+                        {
+                            stringWriter->GetString() = std::get<std::string>(value);
+                        }
+                        cse.back()->Push(gc, stringWriter->GetString());
+                        return false;
+                    }
+                }
+                if(key == "NewLine")
+                {
+                    if(std::holds_alternative<std::string>(value))
+                    {
+                        writer->newline = std::get<std::string>(value);
+                    }
+                    cse.back()->Push(gc,writer->newline);
+                    return false;
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(instance))
+            {
+                auto svr = std::get<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(instance);
+                auto bas = std::dynamic_pointer_cast<Tesses::Framework::Http::BasicAuthServer>(svr);
+                auto cgi = std::dynamic_pointer_cast<Tesses::Framework::Http::CGIServer>(svr);
+                auto changable = std::dynamic_pointer_cast<Tesses::Framework::Http::ChangeableServer>(svr);
+                if(changable != nullptr)
+                {
+                    if(key == "Server")
+                    {
+                        bas->server = ToHttpServer(gc,value);
+                        stk->Push(gc,value);
+                        return false;
+                    }
+                }
+
+                if(bas != nullptr)
+                {
+                    if(key == "Realm")
+                    {
+                        bool val;
+                        if(GetObject(value,val))
+                        {
+                            bas->realm = val;
+                            stk->Push(gc,val );
+
+                            return false;
+                        }
+                    }
+                    if(key == "Server")
+                    {
+                        bas->server = ToHttpServer(gc,value);
+                        stk->Push(gc,value);
+                        return false;
+                    }
+                    if(key == "Authorization")
+                    {
+                        TCallable* val;
+                        if(GetObjectHeap(value,val))
+                        {
+                            auto marked= CreateMarkedTObject(ls, val);
+                            bas->authorization = [marked](std::string user,std::string password)->bool {
+                                GCList ls(marked->GetGC());
+                                TCallable* callable;
+                                if(GetObjectHeap(marked->GetObject(), callable))
+                                {
+                                    return ToBool(callable->Call(ls,{user,password}));
+                                }   
+                                return false;
+                            };
+                            stk->Push(gc,val);
+
+                            return false;
+                        }
+                    }
+                }
+                
+                if(cgi != nullptr)
+                {
+                    if(key == "WorkingDirectory")
+                    {
+                        Tesses::Framework::Filesystem::VFSPath path;
+                        if(GetObjectAsPath(value,path))
+                        {
+                            cgi->workingDirectory = path;
+                            stk->Push(gc,path);
+                            return false;
+                        }
+                        else {
+                            cgi->workingDirectory = std::nullopt;
+                            stk->Push(gc,nullptr);
+                            return false;
+                        }
+
+                    }
+                    if(key == "DocumentRoot")
+                    {
+                        Tesses::Framework::Filesystem::VFSPath path;
+                        if(GetObjectAsPath(value,path))
+                        {
+                            cgi->document_root= path;
+                            stk->Push(gc,path);
+                            return false;
+                        }
+                        else {
+                            cgi->document_root= std::nullopt;
+                            stk->Push(gc,nullptr);
+                            return false;
+                        }
+
+                    }
+                    if(key == "AdminEmail")
+                    {
+                        std::string str;
+                        if(GetObject(value,str))
+                        {
+                            cgi->adminEmail = str;
+                            stk->Push(gc,str);
+                            return false;
+                        }
+                        else {
+                            cgi->adminEmail= std::nullopt;
+                            stk->Push(gc,nullptr);
+                            return false;
+                        }
+
+                    }
+                }
+
+                stk->Push(gc, Undefined());
+                return false;
+            }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance))
+            {
+                auto strm = std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance);
+
+                auto netStrm = std::dynamic_pointer_cast<Tesses::Framework::Streams::NetworkStream>(strm);
+                if(netStrm != nullptr)
+                {
+                    bool bc;
+                    if(key == "Broadcast" && GetObject(value,bc))
+                        netStrm->SetBroadcast(bc);
+                    if(key == "NoDelay" && GetObject(value,bc))
+                        netStrm->SetNoDelay(bc);
+                }
+                stk->Push(gc, Undefined());
+                return false;
+            }
+            if(std::holds_alternative<THeapObjectHolder>(instance))
+            {
+                auto obj = std::get<THeapObjectHolder>(instance).obj;
+                
+                auto dict = dynamic_cast<TDictionary*>(obj);
+                auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
+                auto natObj = dynamic_cast<TNativeObject*>(obj);
+                auto cls = dynamic_cast<TClassObject*>(obj);
+                if(cls != nullptr)
+                {
+                    gc->BarrierBegin();
+                    auto obj=cls->GetValue(cse.back()->callable->className,"set"+key);
+                    gc->BarrierEnd();
+                    TClosure* clos;
+                    TCallable* callable;
+                    if(GetObjectHeap(obj,clos)) 
+                    {
+                        this->AddCallStackEntry(ls,clos,{value});
+                        return true;
+                    }
+                    else if(GetObjectHeap(obj,callable))
+                    {
+                        cse.back()->Push(gc,callable->Call(ls,{value}));
+                        return false;
+                    }
+                    gc->BarrierBegin();
+                    cls->SetValue(cse.back()->callable->className,key,value);
+                    gc->BarrierEnd();
+                    cse.back()->Push(gc,value);
+                    return false;
+               
+                }
+                else 
+                if(natObj != nullptr)
+                {
+                    cse.back()->Push(gc,natObj->CallMethod(ls,"set"+key,{value}));
+                    return false;
+                }
+                auto tcallable = dynamic_cast<TCallable*>(obj);
+                if(tcallable != nullptr)
+                {
+                    if(key == "Tag")
+                    {
+                        gc->BarrierBegin();
+                        tcallable->tag = value;
+                        gc->BarrierEnd();
+                        cse.back()->Push(gc,nullptr);
+                        return false;
+                    }
+                }
+                if(dynDict != nullptr)
+                {
+                    if(dynDict->MethodExists(ls,"set" + key))
+                    {
+                        cse.back()->Push(gc,dynDict->CallMethod(ls,"set" + key, {value}));
+                    }
+                    else
+                    {
+                        dynDict->SetField(ls,key,value);
+                        cse.back()->Push(gc,value);
+                    }
+                    return false;
+                }
+                if(dict != nullptr)
+                {
+                    gc->BarrierBegin();
+                    TObject fn = dict->GetValue("set" + key);
+                    gc->BarrierEnd();
+                    if(std::holds_alternative<THeapObjectHolder>(fn) && dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj) != nullptr)
+                    {
+                        return InvokeTwo(ls,fn, dict, value);
+                    }
+                    else
+                    {
+                        gc->BarrierBegin();
+                        dict->SetValue(key, value);
+                        stk->Push(gc, value);
+                        gc->BarrierEnd();
+                        return false;
+                    }
+                }
+                
+            }
+            stk->Push(gc, Undefined());
+      
+        }
+          return false;
+    }
+
+}

src/vm/bc/sub.cpp

@@ -0,0 +1,121 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+namespace Tesses::CrossLang {
+    bool InterperterThread::Sub(GC* gc)
+    {
+        std::vector<CallStackEntry*>& cse=this->call_stack_entries;
+        GCList ls(gc);
+        auto right = cse.back()->Pop(ls);
+        auto left = cse.back()->Pop(ls);
+
+        if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
+        {
+            cse.back()->Push(gc,std::get<int64_t>(left) - std::get<int64_t>(right));
+        }
+        
+        else if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
+        {
+            cse.back()->Push(gc,std::get<double>(left) - std::get<double>(right));
+        }
+        else if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
+        {
+            cse.back()->Push(gc,std::get<double>(left) - std::get<int64_t>(right));
+        }
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
+        {
+            cse.back()->Push(gc,std::get<int64_t>(left) - std::get<double>(right));
+        }
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
+        {
+            cse.back()->Push(gc, (int64_t)(std::get<char>(left) - std::get<char>(right)));
+        }
+        else if(std::holds_alternative<char>(left) && std::holds_alternative<int64_t>(right))
+        {
+            cse.back()->Push(gc, (int64_t)(std::get<char>(left) - std::get<int64_t>(right)));
+        }
+        else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<char>(right))
+        {
+            cse.back()->Push(gc, (int64_t)(std::get<int64_t>(left) - std::get<char>(right)));
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right))
+        {
+            auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
+            auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right);
+            cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::TimeSpan>((*l) - (*r)));
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
+        {
+            auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
+            auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
+            cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::DateTime>((*l) - (*r)));
+        }
+        else if(std::holds_alternative<THeapObjectHolder>(left))
+        {
+            auto obj = std::get<THeapObjectHolder>(left).obj;
+            auto dict = dynamic_cast<TDictionary*>(obj);
+            auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
+
+             auto natObj = dynamic_cast<TNativeObject*>(obj);
+           
+            
+            auto cls = dynamic_cast<TClassObject*>(obj);
+            if(cls != nullptr)
+            {
+                gc->BarrierBegin();
+                auto obj=cls->GetValue(cse.back()->callable->className,"operator-");
+                gc->BarrierEnd();
+                TClosure* clos;
+                TCallable* callable;
+                if(GetObjectHeap(obj,clos)) 
+                {
+                    this->AddCallStackEntry(ls,clos,{right});
+                    return true;
+                }
+                else if(GetObjectHeap(obj,callable))
+                {
+                    cse.back()->Push(gc,callable->Call(ls,{right}));
+                    return false;
+                }
+                cse.back()->Push(gc,Undefined());
+                return false;
+               
+            }
+            else  if(natObj != nullptr)
+            {
+                cse.back()->Push(gc, natObj->CallMethod(ls,"operator-",{right}));
+                return false;
+            }
+            else if(dict != nullptr)
+            {
+                gc->BarrierBegin();
+                TObject fn = dict->GetValue("operator-");
+                gc->BarrierEnd();
+                return InvokeTwo(ls,fn,left,right);
+            }
+            else if(dynDict != nullptr)
+            {
+                cse.back()->Push(gc,dynDict->CallMethod(ls,"operator-",{right}));
+                return false;
+            }
+            else
+            {
+                cse.back()->Push(gc,Undefined());
+            }
+            
+        }
+        else
+        {
+            cse.back()->Push(gc, Undefined());
+        }
+        return false;
+    }
+}

src/vm/bc/tobool.cpp

@@ -0,0 +1,106 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+
+namespace Tesses::CrossLang {
+    bool ToBool(TObject obj)
+    {
+        if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(obj))
+        {
+            return true;
+        }
+        if(std::holds_alternative<TVMVersion>(obj))
+        {
+            auto v = std::get<TVMVersion>(obj);
+            return v.AsLong() != 0;
+        }
+        if(std::holds_alternative<std::string>(obj))
+        {
+            return !std::get<std::string>(obj).empty();
+        }
+        else if(std::holds_alternative<int64_t>(obj))
+        {
+            return std::get<int64_t>(obj) != 0;
+        }
+        else if(std::holds_alternative<double>(obj))
+        {
+            return std::get<double>(obj);
+        }
+        else if(std::holds_alternative<bool>(obj))
+        {
+            return std::get<bool>(obj);
+        }
+        else if(std::holds_alternative<char>(obj))
+        {
+            return std::get<char>(obj) != 0;
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(obj))
+        {
+            auto& dt = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(obj);
+            return !(dt->Year() == 1970 && dt->Month() == 1 && dt->Day() == 1 && dt->Hour() == 0 && dt->Minute() == 0 && dt->Second() == 0 && !dt->IsLocal());
+           
+        }
+        else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(obj))
+        {
+            return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(obj)->TotalSeconds() != 0;
+        }
+        else if(std::holds_alternative<Tesses::Framework::Uuid>(obj))
+        {
+            auto& uuid = std::get<Tesses::Framework::Uuid>(obj);
+            return !uuid.IsEmpty();
+        }
+        else if(std::holds_alternative<THeapObjectHolder>(obj))
+        {
+            auto o = std::get<THeapObjectHolder>(obj).obj;
+            auto ls = dynamic_cast<TList*>(o);
+            auto aarray = dynamic_cast<TAssociativeArray*>(o);
+            auto dict = dynamic_cast<TDictionary*>(o);
+            auto ba = dynamic_cast<TByteArray*>(o);
+            auto nat = dynamic_cast<TNative*>(o);
+            auto thrd = dynamic_cast<ThreadHandle*>(o);
+            auto natObj = dynamic_cast<TNativeObject*>(o);
+
+            auto any = dynamic_cast<TAny*>(o);
+            auto cls = dynamic_cast<TClassObject*>(o);
+            if(cls!=nullptr) return true;
+            if(natObj != nullptr) return natObj->ToBool();
+            if(any != nullptr) return any->any.has_value();
+           
+            if(ls != nullptr)
+            {
+                return ls->Count() != 0;
+            }
+            if(aarray != nullptr)
+            {
+                return aarray->Count() != 0;
+            }
+            else if(dict != nullptr)
+            {
+                return !dict->items.empty();
+            }
+            else if(ba != nullptr)
+            {
+                return !ba->data.empty();
+            }
+            else if(nat != nullptr)
+            {
+                return !nat->GetDestroyed();
+            }
+            else if(thrd != nullptr)
+            {
+                return !thrd->hasReturned;
+            }
+            return true;
+        }
+        
+        return false;
+    }
+}

src/vm/bc/tostring.cpp

@@ -0,0 +1,133 @@
+#include "CrossLang.hpp"
+#include "TessesFramework/Serialization/BitConverter.hpp"
+#include "TessesFramework/Streams/ByteReader.hpp"
+#include "TessesFramework/Uuid.hpp"
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <cmath>
+#include <cstring>
+#include <sstream>
+#include <variant>
+namespace Tesses::CrossLang {
+     std::string ToString(GC* gc, TObject o)
+    {
+        if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(o))
+        {
+            return std::get<Tesses::Framework::Filesystem::VFSPath>(o).ToString();
+        }
+        if(std::holds_alternative<std::string>(o))
+        {
+            return std::get<std::string>(o);
+        }
+        if(std::holds_alternative<TVMVersion>(o))
+        {
+            return std::get<TVMVersion>(o).ToString();
+        }
+        if(std::holds_alternative<int64_t>(o))
+        {
+            return std::to_string(std::get<int64_t>(o));
+        }
+
+        if(std::holds_alternative<double>(o))
+        {
+            return std::to_string(std::get<double>(o));
+        }
+
+        if(std::holds_alternative<char>(o))
+        {
+            return std::string{std::get<char>(o)};
+        }
+        if(std::holds_alternative<std::nullptr_t>(o))
+        {
+            return "null";
+        }
+        if(std::holds_alternative<Undefined>(o))
+        {
+            return "undefined";
+        }
+        if(std::holds_alternative<bool>(o))
+        {
+            return std::get<bool>(o) ? "true" : "false";
+        }
+        if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(o))
+        {
+            return std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(o)->ToString();
+        }
+        if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(o))
+        {
+            return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(o)->ToString(false);
+        }
+        if(std::holds_alternative<Tesses::Framework::Uuid>(o))
+        {
+            return std::get<Tesses::Framework::Uuid>(o).ToString(Framework::UuidStringifyConfig::LowercaseNoCurly);
+        }
+        if(std::holds_alternative<THeapObjectHolder>(o))
+        {
+            auto obj = std::get<THeapObjectHolder>(o).obj;
+            auto dict = dynamic_cast<TDictionary*>(obj);
+            auto list = dynamic_cast<TList*>(obj);
+            auto bArray = dynamic_cast<TByteArray*>(obj);
+            auto natObj = dynamic_cast<TNativeObject*>(obj);
+            auto cls = dynamic_cast<TClassObject*>(obj);
+            auto aArray = dynamic_cast<TAssociativeArray*>(obj);
+            if(aArray != nullptr)
+            {
+
+                std::string str={};
+                
+                gc->BarrierBegin();
+                bool first=true;
+                for(auto item : aArray->items)
+                {
+                    if(!first) str.push_back('\n');
+                    first=false;
+                    str.push_back('[');
+                    str.append(Json_Encode(item.first));
+                    str.append("] = ");
+                    str.append(Json_Encode(item.second));
+                    str.append(";");
+                }
+                gc->BarrierEnd();
+                return str;
+            }
+            if(cls != nullptr)
+            {
+                auto res = cls->GetValue("","ToString");
+                TCallable* call;
+                GCList ls(gc);
+                if(GetObjectHeap(res,call)) return ToString(gc, call->Call(ls,{}));
+                return cls->TypeName();
+            }
+            if(natObj != nullptr)
+            {
+                GCList ls(gc);
+                TObject o=natObj->CallMethod(ls,"ToString",{});
+               
+
+                return ToString(gc, o);
+            }
+            
+            if(dict != nullptr)
+            {
+                GCList ls(gc);
+                if(dict->MethodExists(ls,"ToString"))
+                    return ToString(gc,dict->CallMethod(ls,"ToString",{}));
+                else
+                {
+                    return Json_Encode(dict);
+                }
+            }
+            else if(bArray != nullptr)
+            {
+                return std::string(bArray->data.begin(),bArray->data.end());
+            }
+            else if(list != nullptr) 
+            {
+                return Json_Encode(list);
+            }
+      }
+
+        return "";
+    }
+}