Fix crosslang Stat, StatVFS for custom crosslang filesystems and add queryable

.gitea/workflows/tag.yaml

@@ -5,66 +5,69 @@ on:
       - 'v*'
 
 env:
-  GITEA_AUTH: ${{ secrets.MY_GITEA_AUTH }}
+  PACKAGE_AND_BREW: ${{ secrets.PACKAGE_AND_BREW }} 
+  VERSION: ${{ gitea.ref_name }}
+  RESULT_IMAGE_NAME: tesses50/crosslang
+  GITEA_DOMAIN: git.tesses.org
+  GITEA_REGISTRY_USER: tesses50
 
 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: wget -O /root/repository.key https://git.tesses.org/api/packages/tesses50/arch/repository.key
       - run: pacman-key --add /root/repository.key
       - run: pacman-key --config /opt/cross/ppc/pacman.conf --add /root/repository.key
-      - run: printf "[tesses50.git.tesseslanguage.com]\nSigLevel = Optional TrustAll\nServer = https://git.tesseslanguage.com/api/packages/tesses50/arch/core/\$arch\n" >> /etc/pacman.conf
-      - run: printf "[tesses50.git.tesseslanguage.com]\nSigLevel = Optional TrustAll\nServer = https://git.tesseslanguage.com/api/packages/tesses50/arch/core/\$arch\n" >> /opt/cross/ppc/pacman.conf
-      - run: pacman --noconfirm -Sy mbedtls curl tesses-framework
-      - run: pacman --config /opt/cross/ppc/pacman.conf --noconfirm -Sy mbedtls tesses-framework
+      - run: printf "[tesses50.git.tesses.org]\nSigLevel = Optional TrustAll\nServer = https://git.tesses.org/api/packages/tesses50/arch/core/\$arch\n" >> /etc/pacman.conf
+      - run: printf "[tesses50.git.tesses.org]\nSigLevel = Optional TrustAll\nServer = https://git.tesses.org/api/packages/tesses50/arch/core/\$arch\n" >> /opt/cross/ppc/pacman.conf
+      - run: pacman --noconfirm -Sy mbedtls tessesframework zip zig ninja
+      - run: pacman --config /opt/cross/ppc/pacman.conf --noconfirm -Sy mbedtls tessesframework
       - run: cp Packaging/Linux/PKGBUILD /home/build/PKGBUILD
       - run: cp Packaging/Linux/build-arch.sh /home/build/build-arch.sh
       - run: chmod 755 /home/build/build-arch.sh
       - run: chown build:build /home/build/PKGBUILD
       - run: chown build:build /home/build/build-arch.sh
       - run: su build -c /home/build/build-arch.sh
-  build-jammy:
-    runs-on: deb-builder-jammy
-    steps:
-      - uses: actions/checkout@v4
-      - name: Build for jammy, noble
-        run: |
-          mkdir ../../artifacts
-          apt update -y
-          apt install -y pkg-config git
-          bash build-ubuntu-jammy.sh
-          bash push-ubuntu-jammy.sh
-          bash build-tars.sh
-        working-directory: ./Packaging/Linux
+      - run: env -C Packaging/Slim bash build.sh
       - uses: akkuman/gitea-release-action@v1
         env:
           NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18
         with:
+          prerelease: true
           files: |-
             artifacts/** 
-  build-plucky:
-    runs-on: deb-builder-plucky
+          
+  update-tap:
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - name: Build for plucky, resolute
-        run: |
-          mkdir ../../artifacts
-          apt update -y
-          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
-        working-directory: ./Packaging/Linux
-      
-      - name: Build for windows
-        run: bash build.sh
-          
-        working-directory: ./Packaging/Windows
-      - uses: akkuman/gitea-release-action@v1
-        env:
-          NODE_OPTIONS: '--experimental-fetch' # if nodejs < 18
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      - name: Log in to registry
+        uses: docker/login-action@v3
         with:
-          files: |-
-            artifacts/**
+          registry: ${{ env.GITEA_DOMAIN }}
+          username: ${{ env.GITEA_REGISTRY_USER }}
+          password: ${{ secrets.PACKAGE_AND_BREW }}
+      - name: Build and push image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags:  ${{ env.GITEA_DOMAIN }}/${{ env.RESULT_IMAGE_NAME }}:latest
+      - uses: actions/checkout@v4
+        with:
+          ref: "master"
+          path: "tapdir"
+          repository: "tesses50/tesses-tap.git"
+          token: ${{ env.PACKAGE_AND_BREW }}
+      - run: |
+          cd tapdir
+          bash ../Packaging/edit-formula.sh
+          git config user.name "Tesses Gitea Bot"
+          git config user.email "noreply@tesses.net"
+          git add .
+          git commit -m "Push crosslang=${{ env.VERSION }}"
+          git push

.gitignore

@@ -11,3 +11,6 @@ bin
 *.exe
 build-x86
 build-x64
+build-x86-slim
+build-x64-slim
+crosslang-*-temp

.onedev-buildspec.yml

@@ -1,6 +1,6 @@
 version: 43
 jobs:
-- name: Build for x86_64
+  - name: Build for x86_64
     steps:
       - type: CheckoutStep
         name: Checkout
@@ -10,30 +10,15 @@ jobs:
         withSubmodules: false
         condition: SUCCESSFUL
         optional: false
-  - type: CommandStep
-    name: Execute build
-    runInContainer: true
-    image: onedev.site.tesses.net/tesses-framework/tesses-framework:latest
-    interpreter:
-      type: DefaultInterpreter
-      commands: |
-        mkdir build
-        cd build
-        cmake -S .. -B . -DCROSSLANG_FETCHCONTENT=OFF
-        make -j12
-        make install DESTDIR=../out
-    useTTY: true
-    condition: SUCCESSFUL
-    optional: false
       - type: BuildImageStep
         name: Build Docker Image
-    dockerfile: Dockerfile.run
+        dockerfile: Dockerfile
         output:
           type: RegistryOutput
           tags: onedev.site.tesses.net/crosslang/crosslang:latest onedev.site.tesses.net/crosslang/crosslang:@commit_hash@
         registryLogins:
-    - registryUrl: '@server_url@'
-      userName: '@job_token@'
+          - registryUrl: "@server_url@"
+            userName: "@job_token@"
             passwordSecret: dockersecret
         platforms: linux/amd64
         condition: SUCCESSFUL
@@ -50,7 +35,7 @@ jobs:
         buildProvider:
           type: LastFinishedBuild
           jobName: Build for x86_64
-    artifacts: '*'
+        artifacts: "*"
     retryCondition: never
     maxRetries: 3
     retryDelay: 30

.vscode/launch.json

@@ -8,10 +8,10 @@
             "name": "(gdb) Launch",
             "type": "cppdbg",
             "request": "launch",
-            "program": "${workspaceFolder}/builds/linux/crosslang",
-            "args": ["token"],
+            "program": "${workspaceFolder}/builds/l/crossint",
+            "args": ["queryable.tcross"],
             "stopAtEntry": false,
-            "cwd": "${workspaceFolder}",
+            "cwd": "${workspaceFolder}/builds/l",
             "environment": [],
             "externalConsole": false,
             "MIMode": "gdb",

CMakeLists.txt

@@ -1,8 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 
-set(CROSSLANG_MAJOR_VERSION 0)
-set(CROSSLANG_MINOR_VERSION 0)
-set(CROSSLANG_PATCH_VERSION 2)
+include(cmake/version.cmake)
+include(cmake/options.cmake)
 
 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)
 
@@ -66,7 +39,7 @@ endif()
 include(FetchContent)
 FetchContent_Declare(
     TessesFramework
-    GIT_REPOSITORY https://onedev.site.tesses.net/tesses-framework.git
+    GIT_REPOSITORY https://git.tesses.org/tesses50/tessesframework.git
 )
 FetchContent_MakeAvailable(TessesFramework)
 list(APPEND TessesCrossLangLibs ${TessesFrameworkTargets})
@@ -77,128 +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)
-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_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/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
-)
+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)
+include(cmake/sources.cmake)
 
 if(CROSSLANG_OFFLINE_SHELL_PACKAGE STREQUAL "")
 
@@ -244,173 +102,22 @@ list(APPEND TessesCrossLangLibs crosslang_shared)
 endif()
 
 
-
-
-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)
+if(CROSSLANG_ENABLE_SUPERSLIM)
+include(cmake/slim.cmake)
 else()
-if(CROSSLANG_ENABLE_SHARED)
-install(TARGETS crosslang_shared
-    EXPORT TessesCrossLangTargets
-    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-
-endif()
-endif()
+include(cmake/shared.cmake)
 
 
 
 if(CROSSLANG_ENABLE_BINARIES)
 if(CROSSLANG_ENABLE_SHARED AND CROSSLANG_SHARED_EXECUTABLES)
-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/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()
+include(cmake/shared_exec.cmake)
 elseif(CROSSLANG_ENABLE_STATIC)
-
-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()
+include(cmake/static_exec.cmake)
 else()
-add_executable(crossc src/crosslangcompiler.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-add_executable(crossvm src/crosslangvm.cpp ${CROSSLANG_SOURCE} ${CROSSLANG_WIN32_EXE_SRC})
-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})
+include(cmake/exec.cmake)
+endif()
 
-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}")
@@ -436,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")
@@ -475,5 +183,6 @@ set(CPACK_NSIS_CREATE_ICONS_EXTRA "CreateShortCut '$SMPROGRAMS\\\\$STARTMENU_FOL
 
 
 include(CPack)
-
+if(CROSSLANG_INSTALL_DEVELOPMENT)
 add_subdirectory(pkgconfig)
+endif()

Dockerfile

@@ -1,8 +1,17 @@
-FROM onedev.site.tesses.net/tesses-framework/tesses-framework:latest
-RUN apt update -y && \
-    apt install -y --no-install-recommends \
-    libjansson-dev wget && \
-    apt clean -y && \
-    rm -rf /var/lib/apt/lists/*
-RUN mkdir /src && cd /src && git clone https://onedev.site.tesses.net/crosslang . && cd /src && mkdir build && cd build && cmake -S .. -B . && make -j4 && make install && cd / && rm -r /src
-WORKDIR /
+FROM alpine:latest AS build
+
+RUN apk update
+RUN apk add --no-cache cmake g++ make git
+
+COPY ./ /src
+
+
+RUN cd /src && mkdir build && cd build && cmake -S .. -B . -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_APPS=ON -DCMAKE_BUILD_TYPE=Release ; make -j`nproc` && make install DESTDIR=/out
+
+FROM alpine:latest
+RUN apk update
+RUN apk add --no-cache libstdc++
+COPY --from=build /out/usr /usr
+
+ENV CROSSLANG_CONTAINER=1
+ENTRYPOINT ["/usr/local/bin/crossint"]

Dockerfile.run

@@ -1,2 +0,0 @@
-FROM onedev.site.tesses.net/tesses-framework/tesses-framework:latest
-COPY out /

Packaging/Linux/PKGBUILD

@@ -1,16 +1,16 @@
 # Maintainer: Mike Nolan <tesses@tesses.net>
 pkgname=crosslang # '-bzr', '-git', '-hg' or '-svn'
-pkgver=0.0.2
+pkgver=0.0.5
 pkgrel=1
 pkgdesc=""
 arch=('x86_64' 'powerpc')
-url="https://onedev.site.tesses.net/crosslang"
+url="https://git.tesses.org/tesses50/crosslang"
 license=('GPLv3')
 groups=()
-depends=('mbedtls' 'tesses-framework')
+depends=('mbedtls' 'tessesframework=0.0.3')
 makedepends=('git' 'cmake' 'make' 'base-devel' 'wget') # 'bzr', 'git', 'mercurial' or 'subversion'
 install=
-source=('crosslang::git+https://onedev.site.tesses.net/crosslang')
+source=('crosslang::git+https://git.tesses.org/tesses50/crosslang')
 noextract=()
 sha256sums=('SKIP')
 if [[ -z "$CMAKE_TOOLCHAIN" ]]; then
@@ -32,9 +32,9 @@ build() {
 	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
@@ -49,4 +49,3 @@ package() {
 	cd "$srcdir/${pkgname}/build"
 	make install DESTDIR="$pkgdir/"
 }
-

Packaging/Linux/build-arch.sh

@@ -4,14 +4,14 @@ mkdir x86_64
 cd x86_64
 cp ../PKGBUILD .
 makepkg
-curl --user tesses50:$GITEA_AUTH \
+curl --user tesses50:$PACKAGE_AND_BREW \
      --upload-file *.pkg.tar.zst \
-     https://git.tesseslanguage.com/api/packages/tesses50/arch/core
+     https://git.tesses.org/api/packages/tesses50/arch/core
 cd ..
 mkdir powerpc
 cd powerpc
 cp ../PKGBUILD .
 CARCH=powerpc CMAKE_TOOLCHAIN=/opt/cross/ppc/toolchain.cmake makepkg
-curl --user tesses50:$GITEA_AUTH \
+curl --user tesses50:$PACKAGE_AND_BREW \
      --upload-file *.pkg.tar.zst \
-     https://git.tesseslanguage.com/api/packages/tesses50/arch/core
+     https://git.tesses.org/api/packages/tesses50/arch/core

Packaging/Linux/build-tars.sh

@@ -1,25 +0,0 @@
-#!/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
-make -j`nproc`
-make install DESTDIR=./crosslang-x86_64
-mkdir -p crosslang-x86_64/share/Tesses/CrossLang
-cp ../build/jammy/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm crosslang-x86_64/share/Tesses/CrossLang/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm
-tar cvzf ../../../artifacts/crosslang-linux-x86_64.tar.gz crosslang-x86_64
-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
-make -j`nproc`
-make install DESTDIR=./crosslang-$1
-mkdir -p crosslang-$1\/share/Tesses/CrossLang
-cp ../build/jammy/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm crosslang-$1\/share/Tesses/CrossLang/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm
-tar cvzf ../../../artifacts/crosslang-linux-$1\.tar.gz crosslang-$1
-cd ..
-}
-foreign arm64
-foreign riscv64
-

Packaging/Linux/build-ubuntu-jammy.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-
-source ./version.sh
-mkdir -p build/jammy
-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
-cd build-amd64
-make -j`nproc`
-make install DESTDIR=../crosslang_$DEB_VERSION\_amd64
-apt remove -y tessesframework
-mkdir -p ../crosslang_$DEB_VERSION\_amd64/DEBIAN
-bash ../../../make-control.sh ../crosslang_$DEB_VERSION\_amd64/DEBIAN/control amd64
-cd ../
-mkdir -p crosslang_$DEB_VERSION\_amd64/usr/share/Tesses/CrossLang
-cp Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm crosslang_$DEB_VERSION\_amd64/usr/share/Tesses/CrossLang/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm
-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
-    cd build-$1
-    make -j`nproc`
-    make install DESTDIR=../crosslang_$DEB_VERSION\_$1
-    mkdir -p ../crosslang_$DEB_VERSION\_$1/DEBIAN
-    bash ../../../make-control.sh ../crosslang_$DEB_VERSION\_$1\/DEBIAN/control $1
-    cd ../
-    mkdir -p crosslang_$DEB_VERSION\_$1\/usr/share/Tesses/CrossLang
-    cp Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm crosslang_$DEB_VERSION\_$1\/usr/share/Tesses/CrossLang/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm
-    dpkg-deb --build crosslang_$DEB_VERSION\_$1
-    apt remove -y tessesframework:$1
-}
-
-foreign arm64
-foreign riscv64

Packaging/Linux/build-ubuntu-plucky.sh

@@ -1,38 +0,0 @@
-#!/bin/bash
-source ./version.sh
-mkdir -p build/plucky
-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
-cd build-amd64
-make -j`nproc`
-make install DESTDIR=../crosslang_$DEB_VERSION\_amd64
-apt remove -y tessesframework
-mkdir -p ../crosslang_$DEB_VERSION\_amd64/DEBIAN
-bash ../../../make-control.sh ../crosslang_$DEB_VERSION\_amd64/DEBIAN/control amd64
-cd ../
-mkdir -p crosslang_$DEB_VERSION\_amd64/usr/share/Tesses/CrossLang
-cp Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm crosslang_$DEB_VERSION\_amd64/usr/share/Tesses/CrossLang/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm
-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
-    cd build-$1
-    make -j`nproc`
-    make install DESTDIR=../crosslang_$DEB_VERSION\_$1
-    mkdir -p ../crosslang_$DEB_VERSION\_$1/DEBIAN
-    bash ../../../make-control.sh ../crosslang_$DEB_VERSION\_$1\/DEBIAN/control $1
-    cd ../
-    mkdir -p crosslang_$DEB_VERSION\_$1\/usr/share/Tesses/CrossLang
-    cp Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm crosslang_$DEB_VERSION\_$1\/usr/share/Tesses/CrossLang/Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm
-    dpkg-deb --build crosslang_$DEB_VERSION\_$1
-    apt remove -y tessesframework:$1
-}
-
-foreign arm64
-foreign riscv64
-

Packaging/Linux/make-control.sh

@@ -1,8 +0,0 @@
-echo "Package: crosslang" > "$1"
-echo "Version: $DEB_VERSION" >> "$1"
-echo "Architecture: $2" >> "$1"
-echo "Essential: no" >> "$1"
-echo "Priority: optional" >> "$1"
-echo "Depends: tessesframework, libffi-dev" >> "$1"
-echo "Maintainer: Mike Nolan" >> "$1"
-echo "Description: A programming language" >> "$1"

Packaging/Linux/push-ubuntu-jammy.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-source ./version.sh
-upload() {
-    curl --user tesses50:$GITEA_AUTH -X DELETE \
-    https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/crosslang/$DEB_VERSION/$1
-    curl --user tesses50:$GITEA_AUTH \
-    --upload-file build/jammy/crosslang_$DEB_VERSION\_$1\.deb \
-    https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/jammy/main/upload
-}
-upload amd64
-upload arm64
-upload riscv64
-

Packaging/Linux/push-ubuntu-plucky.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-source ./version.sh
-upload() {
-    curl --user tesses50:$GITEA_AUTH -X DELETE \
-    https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/crosslang/$DEB_VERSION/$1
-    curl --user tesses50:$GITEA_AUTH \
-    --upload-file build/plucky/crosslang_$DEB_VERSION\_$1\.deb \
-    https://git.tesseslanguage.com/api/packages/tesses50/debian/pool/plucky/main/upload
-}
-upload amd64
-upload arm64
-upload riscv64

Packaging/Linux/version.sh

@@ -1,2 +0,0 @@
-
-export DEB_VERSION=0.0.2

Packaging/Slim/build.sh

@@ -0,0 +1,34 @@
+mkdir -p ../../artifacts
+mkdir -p builds
+git clone --depth 1 https://git.tesses.org/tesses50/zig-cross builds/zig-cross
+
+
+
+for tripple in x86_64-linux-musl x86-linux-musl aarch64-linux-musl arm-linux-musleabi riscv64-linux-musl powerpc-linux-musleabihf; do
+    export BUILDDIR=builds/$tripple
+    mkdir -p $BUILDDIR
+    cmake -S ../.. -B $BUILDDIR --toolchain $PWD/builds/zig-cross/$tripple\.cmake -DCMAKE_BUILD_TYPE=Release -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DCROSSLANG_ENABLE_SUPERSLIM=ON -DCMAKE_EXE_LINKER_FLAGS="-static-libgcc -static-libstdc++ -static -Wl,--strip-all" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -GNinja
+    cmake --build $BUILDDIR || exit 1
+    cmake --install $BUILDDIR --prefix $BUILDDIR/out
+    mv $BUILDDIR/out/bin/crosslang ../../artifacts/crosslang-slim-$tripple
+done
+
+for tripple in x86_64-windows-gnu x86-windows-gnu aarch64-windows-gnu; do
+    export BUILDDIR=builds/$tripple
+    mkdir -p $BUILDDIR
+    cmake -S ../.. -B $BUILDDIR --toolchain $PWD/builds/zig-cross/$tripple\.cmake -DCMAKE_BUILD_TYPE=Release  -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DCMAKE_EXE_LINKER_FLAGS="-static-libgcc -static-libstdc++ -static -Wl,--strip-all" -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCROSSLANG_ENABLE_SUPERSLIM=ON -GNinja
+    cmake --build $BUILDDIR || exit 1
+    cmake --install $BUILDDIR --prefix $BUILDDIR/out
+
+    mv $BUILDDIR/out/bin/crosslang.exe ../../artifacts/crosslang-slim-$tripple\.exe
+done
+
+for tripple in x86_64-macos-none aarch64-macos-none; do
+    export BUILDDIR=builds/$tripple
+    mkdir -p $BUILDDIR
+    cmake -S ../.. -B $BUILDDIR --toolchain $PWD/builds/zig-cross/$tripple\.cmake -DCMAKE_BUILD_TYPE=Release -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DCMAKE_POSITION_INDEPENDENT_CODE=ON -DCROSSLANG_ENABLE_SUPERSLIM=ON -GNinja -DCMAKE_EXE_LINKER_FLAGS="-Wl,--strip-all"
+    cmake --build $BUILDDIR || exit 1
+    cmake --install $BUILDDIR --prefix $BUILDDIR/out
+
+    mv $BUILDDIR/out/bin/crosslang ../../artifacts/crosslang-slim-$tripple
+done

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,7 +7,7 @@ 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

Packaging/edit-formula.sh

@@ -0,0 +1,19 @@
+export HASH=`curl https://git.tesses.org/tesses50/crosslang/archive/$VERSION.tar.gz 2> /dev/null | shasum -a 256 | awk '{print $1}'`
+
+echo "class Crosslang < Formula" > "Formula/crosslang.rb"
+echo "  desc \"\"" >> "Formula/crosslang.rb"
+echo "  homepage \"\"" >> "Formula/crosslang.rb"
+echo "  url \"https://git.tesses.org/tesses50/crosslang/archive/$VERSION.tar.gz\"" >> "Formula/crosslang.rb"
+echo "  sha256 \"$HASH\"" >> "Formula/crosslang.rb"
+echo "  license \"GPLv3\"" >> "Formula/crosslang.rb"
+echo "  depends_on \"cmake\" => :build" >> "Formula/crosslang.rb"
+echo "  depends_on \"tesses50/tesses-tap/tessesframework\"" >> "Formula/crosslang.rb"
+echo "  def install" >> "Formula/crosslang.rb"
+echo "    system \"cmake\", \"-S\", \".\", \"-B\", \"build\", \"-DCROSSLANG_FETCHCONTENT=OFF\", *std_cmake_args" >> "Formula/crosslang.rb"
+echo "    system \"cmake\", \"--build\", \"build\"" >> "Formula/crosslang.rb"
+echo "    system \"cmake\", \"--install\", \"build\"" >> "Formula/crosslang.rb"
+echo "  end" >> "Formula/crosslang.rb"
+echo "  test do" >> "Formula/crosslang.rb"
+echo "    system \"true\"" >> "Formula/crosslang.rb"
+echo "  end" >> "Formula/crosslang.rb"
+echo "end" >> "Formula/crosslang.rb"

README.md

@@ -6,38 +6,38 @@ Tesses Cross Language
 [WebSite](https://crosslang.tesseslanguage.com/)
 
 ## What is required to build this project
-- [TessesFramework](https://onedev.site.tesses.net/tesses-framework) (if you turn CROSSLANG_FETCHCONTENT off otherwise it will be grabbed automaticly)
+- [TessesFramework](https://git.tesses.org/tesses50/tessesframework) (if you turn CROSSLANG_FETCHCONTENT off otherwise it will be grabbed automaticly)
 - CMake
 
 
 ## Use in docker (use my container)
 ```bash
-    sudo docker pull -t onedev.site.tesses.net/crosslang/crosslang:latest
+    sudo docker pull -t git.tesses.org/tesses50/crosslang:latest
 ```
 
 ## Use in docker (build the container yourself)
 ```bash
-    git clone https://onedev.site.tesses.net/crosslang
+    git clone https://git.tesses.org/tesses50/crosslang
     cd crosslang
     sudo docker build -t crosslang:latest .
 ```
 
 ## To Install
-- Install [mbedtls](https://github.com/Mbed-TLS/mbedtls) (use sudo apt install libmbedtls-dev on debian) for TessesFramework
+- Install [mbedtls](https://github.com/Mbed-TLS/mbedtls) (use sudo apt install libmbedtls-dev on debian) for TessesFramework (no longer works on debian, needs -DTESSESFRAMEWORK_FETCHCONTENT=ON for debian)
 - Follow the commands bellow
 
 ## Run these commands to install crosslang (with plugin support)
 ```bash
-git clone https://onedev.site.tesses.net/tesses-framework
-cd tesses-framework
+git clone https://git.tesses.org/tesses50/tessesframework
+cd tessesframework
 mkdir build 
 cd build
-cmake -S .. -B .
+cmake -S .. -B . -DTESSESFRAMEWORK_FETCHCONTENT=OFF
 make
 sudo make install
 cd ../..
-git clone https://onedev.site.tesses.net/CrossLang
-cd CrossLang
+git clone https://git.tesses.org/tesses50/crosslang
+cd crosslang
 mkdir build 
 cd build
 cmake -S .. -B . -DCROSSLANG_FETCHCONTENT=OFF
@@ -47,31 +47,11 @@ sudo make install
 
 ## Build with shared libs only (self contained dependencies)
 ```bash
-cmake -S ../.. -B . -DTESSESFRAMEWORK_ENABLE_STATIC=OFF -DTESSESFRAMEWORK_ENABLE_SHARED=ON -DTESSESFRAMEWORK_FETCHCONTENT=ON
+cmake -S ../.. -B . -DTESSESFRAMEWORK_ENABLE_STATIC=OFF -DTESSESFRAMEWORK_ENABLE_SHARED=ON
 make -j`nproc`
 sudo make install
 ```
 
-```bash
-git clone https://onedev.site.tesses.net/CrossLang
-cd CrossLang
-mkdir build 
-cd build
-cmake -S .. -B .
-make
-sudo make install
-```
-
-## To Create the binaries and ISO (You need linux for this)
-```bash
-sudo apt install xorriso wget curl mingw-w64 nsis cmake tar zip
-mkdir dvdwork
-cp build-dvd.tcross dvdwork/
-cd dvdwork
-crossint build-dvd.tcross
-bash script.sh # the iso and tarballs will be in Working/Output
-```
-
 ```
 Ye are of God, little children, and have overcome them: because greater is he that is in you, than he that is in the world. (1 John 4:4)
 ```

build-dvd.tcross

@@ -114,11 +114,11 @@ wget -O {mbedversion}.tar.bz2 https://downloads.tesses.net/cache/libraries/sourc
 tar xf {mbedversion}.tar.bz2
 rm {mbedversion}.tar.bz2
 fi
-git clone --depth=1 https://onedev.site.tesses.net/tesses-framework
-git clone --depth=1 https://onedev.site.tesses.net/crosslang
+git clone --depth=1 https://git.tesses.org/tesses50/tessesframework
+git clone --depth=1 https://git.tesses.org/tesses50/crosslang
 zip -r \"{working / \"DvdFiles\" / \"crosslang-source.zip\"}\" ./*
 cp ../DvdFiles/crosslang-source.zip ../Output/crosslang-source.zip
-wget -O \"{working / \"DvdFiles\" / \"Common\" / \"ShellPackage.crvm\"}\" https://downloads.tesses.net/ShellPackage.crvm
+wget -O \"{working / \"DvdFiles\" / \"Common\" / \"ShellPackage.crvm\"}\" https://redirect.tesses.net/crosslang-shell
 ";
     var w32_toolchain = $"
             set(CMAKE_C_COMPILER \"/usr/bin/i686-w64-mingw32-gcc\")

changelog.md

@@ -1,7 +1,16 @@
 # Changelog
 
+## 0.0.5
+Fix crosslang Stat, StatVFS for custom crosslang filesystems and add queryable
+
+## 0.0.4
+Rework for git.tesses.org, GC* is std::shared_ptr maybe will fix crash during exit
+
+## 0.0.3
+Fixed cmake, unnecessary itteration on dictionary, and a crosslang binary bug when shell is not installed
+
 ## 0.0.2
-Add uuids and bytestreams
+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://git.tesses.org/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,67 @@
+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/types/queryable.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 5)

include/CrossLang.hpp

@@ -40,6 +40,8 @@ namespace Tesses::CrossLang {
     using BitConverter = Tesses::Framework::Serialization::BitConverter;
     constexpr std::string_view VMName = "CrossLangVM";
     constexpr std::string_view VMHowToGet = "https://crosslang.tesseslanguage.com/";
+
+    
     /**
      * @brief Escape a crosslang string (for generating source code)
      *
@@ -1028,6 +1030,11 @@ constexpr std::string_view ForStatement = "forStatement";
  *
  */
 constexpr std::string_view WhileStatement = "whileStatement";
+/**
+ * @brief using statement using(EXPR)
+ *
+ */
+constexpr std::string_view UsingStatement = "usingStatement";
 /**
  * @brief Do statement do(COND)
  *
@@ -1328,7 +1335,7 @@ class Parser {
     SyntaxNode ParseUnary();
     SyntaxNode ParseNullCoalescing();
     void ParseHtml(std::vector<SyntaxNode>& nodes,std::string var);
-    GC* gc;
+    std::shared_ptr<GC> gc;
     TRootEnvironment* env;
     int lastLine=-1;
     std::string lastFile="";
@@ -1341,7 +1348,7 @@ class Parser {
          * @param tokens the tokens from lexer
          */
         Parser(std::vector<LexToken> tokens);
-        Parser(std::vector<LexToken> tokens, GC* gc, TRootEnvironment* env);
+        Parser(std::vector<LexToken> tokens, std::shared_ptr<GC> gc, TRootEnvironment* env);
         /**
          * @brief Turn tokens into abstract syntax tree
          *
@@ -1405,11 +1412,11 @@ 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>,std::shared_ptr<Tesses::Framework::Streams::ByteReader>,std::shared_ptr<Tesses::Framework::Streams::ByteWriter>, Tesses::Framework::Uuid>;
+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>,std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>, std::shared_ptr<Tesses::Framework::TF_Timer_Handle>, Tesses::Framework::Uuid>;
 
 class TRootEnvironment;
-class GC;
-class GC {
+
+class GC : public std::enable_shared_from_this<GC> {
     Tesses::Framework::Threading::Thread* thrd;
     Tesses::Framework::Threading::Mutex* mtx;
     volatile std::atomic<bool> running;
@@ -1417,7 +1424,7 @@ class GC {
     std::vector<THeapObject*> objects;
 
     Tesses::Framework::Lazy<Tesses::Framework::Threading::ThreadPool*>* tpool;
-    std::vector<std::function<void(GC* gc, TRootEnvironment* env)>> register_everything;
+    std::vector<std::function<void(std::shared_ptr<GC> gc, TRootEnvironment* env)>> register_everything;
     public:
         Tesses::Framework::Threading::ThreadPool* GetPool();
         bool UsingNullThreads();
@@ -1432,23 +1439,22 @@ class GC {
         void SetRoot(TObject obj);
         void UnsetRoot(TObject obj);
         static void Mark(TObject obj);
-        void RegisterEverythingCallback(std::function<void(GC* gc, TRootEnvironment* env)> cb);
+        void RegisterEverythingCallback(std::function<void(std::shared_ptr<GC> gc, TRootEnvironment* env)> cb);
         void RegisterEverything(TRootEnvironment* env);
         ~GC();
 };
 
     std::string GetObjectTypeString(TObject obj);
-    std::string ToString(GC* gc, TObject obj);
+    std::string ToString(std::shared_ptr<GC> gc, TObject obj);
 
     class GCList : public THeapObject
     {
         std::vector<THeapObject*> items;
 
-        GC* gc;
+        std::shared_ptr<GC> gc;
         public:
-            GCList(GC* gc);
-            GCList(GC& gc);
-            GC* GetGC();
+            GCList(std::shared_ptr<GC> gc);
+            std::shared_ptr<GC> GetGC();
             void Add(TObject v);
             void Remove(TObject v);
             void Mark();
@@ -1456,7 +1462,7 @@ class GC {
 
 
             ~GCList();
-
+            friend class GC;
     };
 
 
@@ -1545,7 +1551,7 @@ class GC {
             std::string info;
             int32_t icon;
 
-            void Load(GC* gc, std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
+            void Load(std::shared_ptr<GC> gc, std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
             void Skip(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,size_t len);
             void Ensure(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,uint8_t* buffer, size_t len);
             uint32_t EnsureInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
@@ -1564,8 +1570,8 @@ class GC {
             std::vector<std::pair<TObject,TObject>> items;
             static TAssociativeArray* Create(GCList& ls);
             static TAssociativeArray* Create(GCList* ls);
-            void Set(GC* gc, TObject key, TObject value);
-            TObject Get(GC* gc, TObject key);
+            void Set(std::shared_ptr<GC> gc, TObject key, TObject value);
+            TObject Get(std::shared_ptr<GC> gc, TObject key);
             TObject GetKey(int64_t index);
             TObject GetValue(int64_t index);
             void SetKey(int64_t index, TObject key);
@@ -1659,10 +1665,8 @@ class GC {
             virtual TObject GetValue(std::string key);
             virtual void SetValue(std::string key, TObject value);
             virtual void Mark();
-            void DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb);
-            void DeclareFunction(GC& gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb);
-            void DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy);
-            void DeclareFunction(GC& gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy);
+            void DeclareFunction(std::shared_ptr<GC> gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb);
+            void DeclareFunction(std::shared_ptr<GC> gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy);
             TObject CallMethod(GCList& ls, std::string key, std::vector<TObject> args);
             TObject CallMethodWithFatalError(GCList& ls, std::string key, std::vector<TObject> args);
     };
@@ -1681,7 +1685,7 @@ class GC {
             TObject CallWithFatalError(GCList& ls, std::vector<TObject> args);
             virtual void Mark();
 
-            Tesses::Framework::Http::ServerRequestHandler ToRouteServerRequestHandler(GC* gc);
+            Tesses::Framework::Http::ServerRequestHandler ToRouteServerRequestHandler(std::shared_ptr<GC> gc);
     };
 
     void ThrowFatalError(std::exception& ex);
@@ -1692,7 +1696,7 @@ class GC {
         std::vector<std::string> consts;
         public:
             std::vector<TCallable*> defers;
-            TObject LoadFile(GC* gc, TFile* f);
+            TObject LoadFile(std::shared_ptr<GC> gc, TFile* f);
             TObject Eval(GCList& ls,std::string code);
             virtual bool HasVariable(std::string key)=0;
             virtual bool HasVariableRecurse(std::string key)=0;
@@ -1705,22 +1709,20 @@ class GC {
             virtual TObject SetVariable(GCList& ls, std::string key, TObject v)=0;
 
             virtual void SetVariable(std::string key, TObject value)=0;
-            TDictionary* EnsureDictionary(GC* gc, std::string key);
+            TDictionary* EnsureDictionary(std::shared_ptr<GC> gc, std::string key);
             virtual void DeclareVariable(std::string key, TObject value)=0;
             void DeclareConstVariable(std::string key, TObject value);
             bool HasConstForDeclare(std::string key);
             virtual bool HasConstForSet(std::string key);
-            void DeclareVariable(GC* gc,std::vector<std::string> key, TObject value);
+            void DeclareVariable(std::shared_ptr<GC> gc,std::vector<std::string> key, TObject value);
             virtual TRootEnvironment* GetRootEnvironment()=0;
             virtual TEnvironment* GetParentEnvironment()=0;
             virtual TSubEnvironment* GetSubEnvironment(TDictionary* dict);
             TSubEnvironment* GetSubEnvironment(GCList* gc);
             TSubEnvironment* GetSubEnvironment(GCList& gc);
 
-            void DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb);
-            void DeclareFunction(GC& gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb);
-            void DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy);
-            void DeclareFunction(GC& gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy);
+            void DeclareFunction(std::shared_ptr<GC> gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb);
+           void DeclareFunction(std::shared_ptr<GC> gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy);
             TObject CallFunction(GCList& ls, std::string key, std::vector<TObject> args);
             TObject CallFunctionWithFatalError(GCList& ls, std::string key, std::vector<TObject> args);
     };
@@ -1780,10 +1782,10 @@ class GC {
         public:
             EnvironmentPermissions();
             Tesses::Framework::Filesystem::VFSPath sqliteOffsetPath;
+            std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem> localfs;
             bool canRegisterEverything;
             bool canRegisterConsole;
             bool canRegisterIO;
-            bool canRegisterLocalFS;
             bool canRegisterNet;
             bool canRegisterSqlite;
             bool canRegisterVM;
@@ -1806,7 +1808,7 @@ class GC {
         TDictionary* dict;
         TCallable* error=nullptr;
 
-        void LoadDependency(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::pair<std::string,TVMVersion> dep);
+        void LoadDependency(std::shared_ptr<GC> gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::pair<std::string,TVMVersion> dep);
         public:
             EnvironmentPermissions permissions;
 
@@ -1815,8 +1817,8 @@ class GC {
 
             bool TryFindClass(std::vector<std::string>& name, size_t& index);
 
-            void LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile* f);
-            void LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path);
+            void LoadFileWithDependencies(std::shared_ptr<GC> gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile* f);
+            void LoadFileWithDependencies(std::shared_ptr<GC> gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path);
 
             TDictionary* GetDictionary();
             static TRootEnvironment* Create(GCList* gc,TDictionary* dict);
@@ -1835,30 +1837,32 @@ class GC {
             TRootEnvironment* GetRootEnvironment();
             TEnvironment* GetParentEnvironment();
             void RegisterOnError(TCallable* callable);
-            bool HandleException(GC* gc,TEnvironment* env, TObject err);
-            bool HandleBreakpoint(GC* gc,TEnvironment* env, TObject err);
+            bool HandleException(std::shared_ptr<GC> gc,TEnvironment* env, TObject err);
+            bool HandleBreakpoint(std::shared_ptr<GC> gc,TEnvironment* env, TObject err);
             void Mark();
     };
     class TStd {
         private:
-            static void RegisterHelpers(GC* gc, TRootEnvironment* env);
-            static void RegisterUuid(GC* gc, TRootEnvironment* env);
+            static void RegisterHelpers(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterUuid(std::shared_ptr<GC> gc, TRootEnvironment* env);
         public:
-            static void RegisterStd(GC* gc, TRootEnvironment* env);
-            static void RegisterConsole(GC* gc,TRootEnvironment* env);
-            static void RegisterIO(GC* gc,TRootEnvironment* env, bool enableLocalFilesystem=true);
-            static void RegisterNet(GC* gc, TRootEnvironment* env);
-            static void RegisterSqlite(GC* gc,TRootEnvironment* env);
-            static void RegisterVM(GC* gc,TRootEnvironment* env);
-            static void RegisterDictionary(GC* gc, TRootEnvironment* env);
-            static void RegisterJson(GC* gc, TRootEnvironment* env);
-            static void RegisterCrypto(GC* gc,TRootEnvironment* env);
-            static void RegisterRoot(GC* gc, TRootEnvironment* env);
-            static void RegisterPath(GC* gc, TRootEnvironment* env);
-            static void RegisterOGC(GC* gc, TRootEnvironment* env);
-            static void RegisterEnv(GC* gc, TRootEnvironment* env);
-            static void RegisterProcess(GC* gc, TRootEnvironment* env);
-            static void RegisterClass(GC* gc, TRootEnvironment* env);
+            static void RegisterStd(std::shared_ptr<GC> gc, TRootEnvironment* env, std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem> localfs);
+            static void RegisterStd(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterConsole(std::shared_ptr<GC> gc,TRootEnvironment* env);
+            static void RegisterIO(std::shared_ptr<GC> gc,TRootEnvironment* env, std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem> local);
+            static void RegisterIO(std::shared_ptr<GC> gc,TRootEnvironment* env, bool enableLocalFS=true);
+            static void RegisterNet(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterSqlite(std::shared_ptr<GC> gc,TRootEnvironment* env);
+            static void RegisterVM(std::shared_ptr<GC> gc,TRootEnvironment* env);
+            static void RegisterDictionary(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterJson(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterCrypto(std::shared_ptr<GC> gc,TRootEnvironment* env);
+            static void RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterPath(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterOGC(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterEnv(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterProcess(std::shared_ptr<GC> gc, TRootEnvironment* env);
+            static void RegisterClass(std::shared_ptr<GC> gc, TRootEnvironment* env);
 
     };
 
@@ -1931,7 +1935,7 @@ class GC {
     class TEnumerator : public THeapObject
     {
         public:
-            virtual bool MoveNext(GC* ls)=0;
+            virtual bool MoveNext(std::shared_ptr<GC> ls)=0;
             virtual TObject GetCurrent(GCList& ls)=0;
             static TEnumerator* CreateFromObject(GCList& ls, TObject obj);
     };
@@ -1942,7 +1946,7 @@ class GC {
         public:
             static TAssociativeArrayEnumerator* Create(GCList& ls, TAssociativeArray* list);
             static TAssociativeArrayEnumerator* Create(GCList* ls, TAssociativeArray* list);
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
             void Mark();
     };
@@ -1950,7 +1954,7 @@ class GC {
     class TCustomEnumerator : public TEnumerator {
         public:
             TDictionary* dict;
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
             void Mark();
             static TCustomEnumerator* Create(GCList& ls,TDictionary* dict);
@@ -1964,7 +1968,7 @@ class GC {
         TObject enumerator;
         TObject current;
         public:
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
             void Mark();
             static TYieldEnumerator* Create(GCList& ls,TObject v);
@@ -1980,7 +1984,7 @@ class GC {
         public:
             static TStringEnumerator* Create(GCList& ls,std::string str);
             static TStringEnumerator* Create(GCList* ls,std::string str);
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
     };
 
@@ -1991,7 +1995,7 @@ class GC {
         public:
             static TListEnumerator* Create(GCList& ls, TList* list);
             static TListEnumerator* Create(GCList* ls, TList* list);
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
             void Mark();
     };
@@ -2004,7 +2008,7 @@ class GC {
         public:
             static TDynamicListEnumerator* Create(GCList& ls, TDynamicList* list);
             static TDynamicListEnumerator* Create(GCList* ls, TDynamicList* list);
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
             void Mark();
     };
@@ -2014,7 +2018,7 @@ class GC {
         public:
             static TVFSPathEnumerator* Create(GCList& ls, Tesses::Framework::Filesystem::VFSPathEnumerator list);
             static TVFSPathEnumerator* Create(GCList* ls, Tesses::Framework::Filesystem::VFSPathEnumerator list);
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
 
     };
@@ -2026,21 +2030,13 @@ class GC {
         public:
             TObject obj;
             GCList* ls;
-            TObjectVFS(GC* gc, TObject obj);
+            TObjectVFS(std::shared_ptr<GC> gc, TObject obj);
             std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode);
+            Tesses::Framework::Filesystem::FIFOCreationResult CreateFIFO(Tesses::Framework::Filesystem::VFSPath path);
             void CreateDirectory(Tesses::Framework::Filesystem::VFSPath path);
             void DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path);
-            bool RegularFileExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool SymlinkExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool CharacterDeviceExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool BlockDeviceExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool SocketFileExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool FIFOFileExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool FileExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool SpecialFileExists(Tesses::Framework::Filesystem::VFSPath path);
             void CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath symlinkFile);
             void CreateHardlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath newName);
-            bool DirectoryExists(Tesses::Framework::Filesystem::VFSPath path);
             void DeleteFile(Tesses::Framework::Filesystem::VFSPath path);
             void Lock(Tesses::Framework::Filesystem::VFSPath path);
             void Unlock(Tesses::Framework::Filesystem::VFSPath path);
@@ -2052,10 +2048,13 @@ class GC {
             Tesses::Framework::Filesystem::VFSPath ReadLink(Tesses::Framework::Filesystem::VFSPath path);
             std::string VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path);
             Tesses::Framework::Filesystem::VFSPath SystemToVFSPath(std::string path);
-            void GetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime& lastWrite, Tesses::Framework::Date::DateTime& lastAccess);
             void SetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime lastWrite, Tesses::Framework::Date::DateTime lastAccess);
             void Chmod(Tesses::Framework::Filesystem::VFSPath path, uint32_t mode);
+            void Chown(Tesses::Framework::Filesystem::VFSPath path, uint32_t uid, uint32_t gid);
+            
             bool StatVFS(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatVFSData& data);
+
+            bool Stat(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatData& data);
             void Close();
             ~TObjectVFS();
     };
@@ -2066,7 +2065,7 @@ class GC {
         public:
             TObject obj;
             GCList* ls;
-            TObjectStream(GC* gc, TObject obj);
+            TObjectStream(std::shared_ptr<GC> gc, TObject obj);
             bool EndOfStream();
             size_t Read(uint8_t* buff, size_t sz);
             size_t Write(const uint8_t* buff, size_t sz);
@@ -2088,7 +2087,7 @@ class GC {
         public:
             TObject obj;
             GCList* ls;
-            TObjectHttpServer(GC* gc,TObject obj);
+            TObjectHttpServer(std::shared_ptr<GC> gc,TObject obj);
             bool Handle(Tesses::Framework::Http::ServerContext& ctx);
             ~TObjectHttpServer();
     };
@@ -2102,7 +2101,7 @@ class GC {
         public:
             static TDictionaryEnumerator* Create(GCList& ls, TDictionary* dict);
             static TDictionaryEnumerator* Create(GCList* ls, TDictionary* dict);
-            bool MoveNext(GC* ls);
+            bool MoveNext(std::shared_ptr<GC> ls);
             TObject GetCurrent(GCList& ls);
             void Mark();
     };
@@ -2187,7 +2186,7 @@ class GC {
             bool mustReturn;
 
             void Mark();
-            void Push(GC* gc,TObject v);
+            void Push(std::shared_ptr<GC> gc,TObject v);
             TObject Pop(GCList& gcl);
 
             TObject Resume(GCList& ls);
@@ -2196,10 +2195,10 @@ class GC {
     {
         TCallable* cont=nullptr;
         std::exception_ptr ex=nullptr;
-        GC* gc;
+        std::shared_ptr<GC> gc;
         TObject obj=Undefined();
         bool isCompleted=false;
-        TTask(GC* gc);
+        TTask(std::shared_ptr<GC> gc);
         public:
             static TTask* Create(GCList& ls);
             bool IsCompleted();
@@ -2230,84 +2229,84 @@ class GC {
             bool InvokeTwo(GCList& ls,TObject fn, TObject left, TObject right);
             bool InvokeOne(GCList& ls,TObject fn, TObject arg);
             bool InvokeMethod(GCList& ls, TObject fn, TObject instance, std::vector<TObject> args);
-            bool ExecuteMethod2(GC* gc, TObject instance, std::string key, std::vector<TObject> args);
+            bool ExecuteMethod2(std::shared_ptr<GC> gc, TObject instance, std::string key, std::vector<TObject> args);
         protected:
             static void* ThreadCallback(void* ptr);
-            bool JumpIfDefined(GC* gc);
-            bool Add(GC* gc);
-            bool Sub(GC* gc);
-            bool Times(GC* gc);
-            bool Divide(GC* gc);
-            bool Mod(GC* gc);
-            bool Neg(GC* gc);
-            bool Lt(GC* gc);
-            bool Gt(GC* gc);
-            bool Lte(GC* gc);
-            bool Gte(GC* gc);
-            bool Eq(GC* gc);
-            bool NEq(GC* gc);
-            bool LShift(GC* gc);
-            bool RShift(GC* gc);
-            bool BOr(GC* gc);
-            bool XOr(GC* gc);
-            bool LNot(GC* gc);
-            bool BNot(GC* gc);
-            bool BAnd(GC* gc);
-            bool ExecuteFunction(GC* gc);
-            bool ExecuteMethod(GC* gc);
-            bool GetVariable(GC* gc);
-            bool SetVariable(GC* gc);
-            bool GetField(GC* gc);
-            bool SetField(GC* gc);
-            bool GetArray(GC* gc);
-            bool SetArray(GC* gc);
-            bool DeclareVariable(GC* gc);
-            bool DeclareConstVariable(GC* gc);
-            bool PushLong(GC* gc);
-            bool PushDouble(GC* gc);
-            bool PushChar(GC* gc);
-            bool PushString(GC* gc);
-            bool PushClosure(GC* gc);
-            bool PushScopelessClosure(GC* gc);
-            bool PushResource(GC* gc);
-            bool Illegal(GC* gc);
-            bool Throw(GC* gc);
-            bool Yield(GC* gc);
-            bool Jump(GC* gc);
-            bool JumpConditional(GC* gc);
-            bool JumpUndefined(GC* gc);
-            bool Defer(GC* gc);
-            bool TryCatch(GC* gc);
-            bool Return(GC* gc);
-            bool ScopeBegin(GC* gc);
-            bool ScopeEnd(GC* gc);
-            bool ScopeEndTimes(GC* gc);
-            bool PushTrue(GC* gc);
-            bool PushFalse(GC* gc);
-            bool PushNull(GC* gc);
-            bool PushUndefined(GC* gc);
-            bool CreateDictionary(GC* gc);
-            bool CreateArray(GC* gc);
-            bool AppendList(GC* gc);
-            bool AppendDictionary(GC* gc);
-            bool PushRootPath(GC* gc);
-            bool PushRelativePath(GC* gc);
-            bool Pop(GC* gc);
-            bool Dup(GC* gc);
-            bool Nop(GC* gc);
-            bool Breakpoint(GC* gc);
-            bool PushBreak(GC* gc);
-            bool PushContinue(GC* gc);
-            bool JumpIfBreak(GC* gc);
-            bool JumpIfContinue(GC* gc);
-            bool LineInfo(GC* gc);
-            bool PushResourceStream(GC* gc);
-            bool PushResourceDirectory(GC* gc);
+            bool JumpIfDefined(std::shared_ptr<GC> gc);
+            bool Add(std::shared_ptr<GC> gc);
+            bool Sub(std::shared_ptr<GC> gc);
+            bool Times(std::shared_ptr<GC> gc);
+            bool Divide(std::shared_ptr<GC> gc);
+            bool Mod(std::shared_ptr<GC> gc);
+            bool Neg(std::shared_ptr<GC> gc);
+            bool Lt(std::shared_ptr<GC> gc);
+            bool Gt(std::shared_ptr<GC> gc);
+            bool Lte(std::shared_ptr<GC> gc);
+            bool Gte(std::shared_ptr<GC> gc);
+            bool Eq(std::shared_ptr<GC> gc);
+            bool NEq(std::shared_ptr<GC> gc);
+            bool LShift(std::shared_ptr<GC> gc);
+            bool RShift(std::shared_ptr<GC> gc);
+            bool BOr(std::shared_ptr<GC> gc);
+            bool XOr(std::shared_ptr<GC> gc);
+            bool LNot(std::shared_ptr<GC> gc);
+            bool BNot(std::shared_ptr<GC> gc);
+            bool BAnd(std::shared_ptr<GC> gc);
+            bool ExecuteFunction(std::shared_ptr<GC> gc);
+            bool ExecuteMethod(std::shared_ptr<GC> gc);
+            bool GetVariable(std::shared_ptr<GC> gc);
+            bool SetVariable(std::shared_ptr<GC> gc);
+            bool GetField(std::shared_ptr<GC> gc);
+            bool SetField(std::shared_ptr<GC> gc);
+            bool GetArray(std::shared_ptr<GC> gc);
+            bool SetArray(std::shared_ptr<GC> gc);
+            bool DeclareVariable(std::shared_ptr<GC> gc);
+            bool DeclareConstVariable(std::shared_ptr<GC> gc);
+            bool PushLong(std::shared_ptr<GC> gc);
+            bool PushDouble(std::shared_ptr<GC> gc);
+            bool PushChar(std::shared_ptr<GC> gc);
+            bool PushString(std::shared_ptr<GC> gc);
+            bool PushClosure(std::shared_ptr<GC> gc);
+            bool PushScopelessClosure(std::shared_ptr<GC> gc);
+            bool PushResource(std::shared_ptr<GC> gc);
+            bool Illegal(std::shared_ptr<GC> gc);
+            bool Throw(std::shared_ptr<GC> gc);
+            bool Yield(std::shared_ptr<GC> gc);
+            bool Jump(std::shared_ptr<GC> gc);
+            bool JumpConditional(std::shared_ptr<GC> gc);
+            bool JumpUndefined(std::shared_ptr<GC> gc);
+            bool Defer(std::shared_ptr<GC> gc);
+            bool TryCatch(std::shared_ptr<GC> gc);
+            bool Return(std::shared_ptr<GC> gc);
+            bool ScopeBegin(std::shared_ptr<GC> gc);
+            bool ScopeEnd(std::shared_ptr<GC> gc);
+            bool ScopeEndTimes(std::shared_ptr<GC> gc);
+            bool PushTrue(std::shared_ptr<GC> gc);
+            bool PushFalse(std::shared_ptr<GC> gc);
+            bool PushNull(std::shared_ptr<GC> gc);
+            bool PushUndefined(std::shared_ptr<GC> gc);
+            bool CreateDictionary(std::shared_ptr<GC> gc);
+            bool CreateArray(std::shared_ptr<GC> gc);
+            bool AppendList(std::shared_ptr<GC> gc);
+            bool AppendDictionary(std::shared_ptr<GC> gc);
+            bool PushRootPath(std::shared_ptr<GC> gc);
+            bool PushRelativePath(std::shared_ptr<GC> gc);
+            bool Pop(std::shared_ptr<GC> gc);
+            bool Dup(std::shared_ptr<GC> gc);
+            bool Nop(std::shared_ptr<GC> gc);
+            bool Breakpoint(std::shared_ptr<GC> gc);
+            bool PushBreak(std::shared_ptr<GC> gc);
+            bool PushContinue(std::shared_ptr<GC> gc);
+            bool JumpIfBreak(std::shared_ptr<GC> gc);
+            bool JumpIfContinue(std::shared_ptr<GC> gc);
+            bool LineInfo(std::shared_ptr<GC> gc);
+            bool PushResourceStream(std::shared_ptr<GC> gc);
+            bool PushResourceDirectory(std::shared_ptr<GC> gc);
         public:
             static InterperterThread* Create(GCList* ls);
             static InterperterThread* Create(GCList& ls);
             std::vector<CallStackEntry*> call_stack_entries;
-            virtual void Execute(GC* gc);
+            virtual void Execute(std::shared_ptr<GC> gc);
             void AddCallStackEntry(GCList& ls,TClosure* closure, std::vector<TObject> args);
             void Mark();
     };
@@ -2349,7 +2348,7 @@ class GC {
         static T* Create(GCList& ls,TArgs... args)
         {
             T* obj = new T(args...);
-            GC* gc = ls.GetGC();
+            std::shared_ptr<GC> gc = ls.GetGC();
             ls.Add(obj);
             gc->Watch(obj);
             return obj;
@@ -2358,7 +2357,7 @@ class GC {
         static T* Create(GCList* ls,TArgs... args)
         {
             T* obj = new T(args...);
-            GC* gc = ls->GetGC();
+            std::shared_ptr<GC> gc = ls->GetGC();
             ls->Add(obj);
             gc->Watch(obj);
             return obj;
@@ -2367,7 +2366,7 @@ class GC {
         virtual TObject CallMethod(GCList& ls,std::string name, std::vector<TObject> args)=0;
         virtual std::string TypeName()=0;
         virtual bool ToBool();
-        virtual bool Equals(GC* gc, TObject right);
+        virtual bool Equals(std::shared_ptr<GC> gc, TObject right);
         virtual ~TNativeObject();
     };
     class TRandom : public TNativeObject
@@ -2407,7 +2406,7 @@ class GC {
             std::atomic<bool> detached;
             TCallable* callable;
             TObject returnValue;
-            GC* gc;
+            std::shared_ptr<GC> gc;
 
 
             void Mark()
@@ -2445,7 +2444,7 @@ class GC {
             {
             }
 
-            VMByteCodeException(GC* gc,TObject obj, CallStackEntry* ent)
+            VMByteCodeException(std::shared_ptr<GC> gc,TObject obj, CallStackEntry* ent)
             {
                 gcList = std::make_shared<GCList>(gc);
                 gcList->Add(obj);
@@ -2538,16 +2537,16 @@ class GC {
     bool GetObjectAsPath(TObject& obj, Tesses::Framework::Filesystem::VFSPath& path, bool allowString=true);
     bool GetArgumentAsPath(std::vector<TObject>& args, size_t index, Tesses::Framework::Filesystem::VFSPath& path,bool allowString=true);
     bool ToBool(TObject obj);
-    bool Equals(GC* gc, TObject left, TObject right);
-    typedef void (*PluginFunction)(GC* gc,TRootEnvironment* env);
+    bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right);
+    typedef void (*PluginFunction)(std::shared_ptr<GC> gc,TRootEnvironment* env);
     #if !defined(_WIN32)
     #define DLLEXPORT
     #else
     #define DLLEXPORT __declspec(dllexport)
     #endif
-    #define CROSSLANG_PLUGIN(plugin) DLLEXPORT extern "C" void CrossLangPluginInit(GC* gc, TRootEnvironment* env) { plugin(gc,env); }
+    #define CROSSLANG_PLUGIN(plugin) DLLEXPORT extern "C" void CrossLangPluginInit(std::shared_ptr<GC> gc, TRootEnvironment* env) { plugin(gc,env); }
 
-    void LoadPlugin(GC* gc, TRootEnvironment* env, Tesses::Framework::Filesystem::VFSPath sharedObjectPath);
+    void LoadPlugin(std::shared_ptr<GC> gc, TRootEnvironment* env, Tesses::Framework::Filesystem::VFSPath sharedObjectPath);
     std::string Json_Encode(TObject o,bool indent=false);
     TObject Json_Decode(GCList ls,std::string str);
     std::string Json_DocEncode(TObject o,bool indent);
@@ -2557,15 +2556,14 @@ class GC {
         GCList* ls;
         TObject o;
         public:
-            SharedPtrTObject(GC* gc, TObject o);
+            SharedPtrTObject(std::shared_ptr<GC> gc, TObject o);
             TObject& GetObject();
-            GC* GetGC();
+            std::shared_ptr<GC> GetGC();
             ~SharedPtrTObject();
     };
     using MarkedTObject = std::shared_ptr<SharedPtrTObject>;
 
-    MarkedTObject CreateMarkedTObject(GC* gc, TObject o);
-    MarkedTObject CreateMarkedTObject(GC& gc, TObject o);
+    MarkedTObject CreateMarkedTObject(std::shared_ptr<GC> gc, TObject o);
     MarkedTObject CreateMarkedTObject(GCList* gc, TObject o);
     MarkedTObject CreateMarkedTObject(GCList& gc, TObject o);
     std::string JoinPeriod(std::vector<std::string>& p);
@@ -2578,7 +2576,7 @@ class GC {
     Tesses::Framework::Filesystem::VFSPath Merge(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourcePath, std::shared_ptr<Tesses::Framework::Filesystem::VFS> destFS);
 
 
-    std::shared_ptr<Tesses::Framework::Http::IHttpServer> ToHttpServer(GC* gc,TObject obj);
+    std::shared_ptr<Tesses::Framework::Http::IHttpServer> ToHttpServer(std::shared_ptr<GC> gc,TObject obj);
 
     class EmbedStream : public Tesses::Framework::Streams::Stream
     {
@@ -2587,7 +2585,7 @@ class GC {
         uint32_t resource;
 
         public:
-            EmbedStream(GC* gc, TFile* file, uint32_t resource);
+            EmbedStream(std::shared_ptr<GC> gc, TFile* file, uint32_t resource);
             bool CanRead();
             bool CanSeek();
             bool EndOfStream();
@@ -2602,18 +2600,69 @@ class GC {
         MarkedTObject dir;
         TObject getEntry(Tesses::Framework::Filesystem::VFSPath path);
         public:
-            EmbedDirectory(GC* gc, TDictionary* dict);
+            EmbedDirectory(std::shared_ptr<GC> gc, TDictionary* dict);
             std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode);
-            void CreateDirectory(Tesses::Framework::Filesystem::VFSPath path);
-            void DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path);
-            bool RegularFileExists(Tesses::Framework::Filesystem::VFSPath path);
-            bool DirectoryExists(Tesses::Framework::Filesystem::VFSPath path);
-            void DeleteFile(Tesses::Framework::Filesystem::VFSPath path);
+            
             Tesses::Framework::Filesystem::VFSPathEnumerator EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path);
-            void MoveFile(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest);
             std::string VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path);
             Tesses::Framework::Filesystem::VFSPath SystemToVFSPath(std::string path);
+
+            bool Stat(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatData& data);
     };
     
 
+    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);
+    }   
+
+    enum class TQueryableMode {
+        Passthrough,
+        Skip,
+        SkipWhile,
+        Take,
+        TakeWhile,
+        Select,
+        Where
+    };
+
+    class TQueryable : public THeapObject {
+        
+
+        TObject parent;
+        TQueryableMode mode;
+        std::vector<TObject> args;
+            TQueryable(TObject parent);
+            TQueryable(TObject parent, TQueryableMode mode, std::vector<TObject> args);
+
+        public:
+
+            static TQueryable* Create(GCList& ls, TObject parent);
+            static TQueryable* Create(GCList& ls, TObject parent, TQueryableMode mode, std::vector<TObject> args);
+            
+            TQueryable* Skip(GCList& ls,int64_t no);
+            TQueryable* SkipWhile(GCList& ls, TCallable* call);
+            TQueryable* Take(GCList& ls, int64_t no);
+            TQueryable* TakeWhile(GCList& ls, TCallable* call);
+            TQueryable* Select(GCList& ls, TCallable* call);
+            TQueryable* Where(GCList& ls, TCallable* call);
+            void ForEach(std::shared_ptr<GC> gc, TCallable* call);
+            int64_t Count(std::shared_ptr<GC> gc, TCallable* call);
+            int64_t Count(std::shared_ptr<GC> gc);
+            bool Contains(std::shared_ptr<GC>, TObject value);
+            bool Any(std::shared_ptr<GC> gc, TCallable* call);
+            bool All(std::shared_ptr<GC> gc, TCallable* call);
+
+            TList* ToList(GCList& ls);
+            TEnumerator* GetEnumerator(GCList& ls);
+
+            void Mark();
+    };
 };

pkgconfig/CMakeLists.txt

@@ -2,7 +2,7 @@ set(PKGCONFIG_INCLUDEDIR "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
 set(PKGCONFIG_LIBDIR "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
 
 set(PKGCONFIG_PROJECT_DESCRIPTION "A programming language")
-set(PKGCONFIG_PROJECT_HOMEPAGE_URL "https://onedev.site.tesses.net/crosslang")
+set(PKGCONFIG_PROJECT_HOMEPAGE_URL "https://crosslang.tesseslanguage.com/")
 
 if(CROSSLANG_ENABLE_FFI)
 set(PKGCONFIG_DEPS "Requires: libffi")

pkgconfig/crosslang.pc.in

@@ -8,6 +8,7 @@ URL: @PKGCONFIG_PROJECT_HOMEPAGE_URL@
 Version: @PROJECT_VERSION@
 
 @PKGCONFIG_DEPS@
+Requires: tessesframework
 
 Cflags: -I"${includedir}"
 Libs: -L"${libdir}" -lcrosslang_shared

pkgconfig/crosslang_static.pc.in

@@ -8,6 +8,7 @@ URL: @PKGCONFIG_PROJECT_HOMEPAGE_URL@
 Version: @PROJECT_VERSION@
 
 @PKGCONFIG_DEPS@
+Requires: tessesframework_static
 
 Cflags: -I"${includedir}"
 Libs: -L"${libdir}" -lcrosslang_static

src/compiler/codegen.cpp

@@ -1383,6 +1383,104 @@ namespace Tesses::CrossLang
                 instructions.push_back(new LabelInstruction(ifIdEnd));
 
             }
+            else if(adv.nodeName == UsingStatement && adv.nodes.size() == 2)
+            {
+                //using(EXPRESSION) {}
+                //using(EXPRESSION) STATEMENT;
+
+                //{ __compGen = EXPRESSION; defer { __compGen.Dispose(); } {}(unrolled) OR STATEMENT;  }
+
+                if(std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[1]))
+                {
+                    auto asn2 = std::get<AdvancedSyntaxNode>(adv.nodes[1]);
+                    if(asn2.nodeName == ScopeNode)
+                    {
+                        scope++;
+                        instructions.push_back(new SimpleInstruction(SCOPEBEGIN));
+
+                        uint32_t exprId = NewId();
+                        std::string exprStr = "__compGenUsing";
+                        exprStr.append(std::to_string(exprId));
+                        
+                        auto _assign=AdvancedSyntaxNode::Create(AssignExpression,true,{
+                            AdvancedSyntaxNode::Create(DeclareExpression,true,{exprStr}),
+                            adv.nodes[0]
+                        });
+
+                        GenNode(instructions,_assign,scope,contscope,brkscope,contI,brkI);
+                        GenPop(instructions,_assign);
+
+
+                        auto _defer=AdvancedSyntaxNode::Create(DeferStatement,false,{
+                            AdvancedSyntaxNode::Create(ReturnStatement,false,{
+                                AdvancedSyntaxNode::Create(FunctionCallExpression,true,{
+                                    AdvancedSyntaxNode::Create(GetFieldExpression,true,{
+                                        AdvancedSyntaxNode::Create(GetVariableExpression, true, {
+                                            exprStr
+                                        }),
+                                        "Dispose"
+                                    })
+                                })
+                            })
+                        });
+
+
+                        GenNode(instructions,_defer,scope,contscope,brkscope,contI,brkI);
+
+                        for(size_t i = 0; i < asn2.nodes.size(); i++)
+                        {
+                            GenNode(instructions,asn2.nodes[i],scope,contscope,brkscope,contI,brkI);
+                            if(!asn2.isExpression || i < asn2.nodes.size()-1)
+                                GenPop(instructions,asn2.nodes[i]);
+                        }
+                        instructions.push_back(new SimpleInstruction(SCOPEEND));
+                        scope--;
+                        return;
+                    }
+                }
+
+                {
+                    scope++;
+                        instructions.push_back(new SimpleInstruction(SCOPEBEGIN));
+
+                        uint32_t exprId = NewId();
+                        std::string exprStr = "__compGenUsing";
+                        exprStr.append(std::to_string(exprId));
+                        
+                        auto _assign=AdvancedSyntaxNode::Create(AssignExpression,true,{
+                            AdvancedSyntaxNode::Create(DeclareExpression,true,{exprStr}),
+                            adv.nodes[0]
+                        });
+
+                        GenNode(instructions,_assign,scope,contscope,brkscope,contI,brkI);
+                        GenPop(instructions,_assign);
+
+
+                        auto _defer=AdvancedSyntaxNode::Create(DeferStatement,false,{
+                            AdvancedSyntaxNode::Create(ReturnStatement,false,{
+                                AdvancedSyntaxNode::Create(FunctionCallExpression,true,{
+                                    AdvancedSyntaxNode::Create(GetFieldExpression,true,{
+                                        AdvancedSyntaxNode::Create(GetVariableExpression, true, {
+                                            exprStr
+                                        }),
+                                        "Dispose"
+                                    })
+                                })
+                            })
+                        });
+
+
+                        GenNode(instructions,_defer,scope,contscope,brkscope,contI,brkI);
+
+                        
+                        GenNode(instructions,adv.nodes[1],scope,contscope,brkscope,contI,brkI);
+                        if(!adv.isExpression)
+                            GenPop(instructions,adv.nodes[1]);
+                    
+                        instructions.push_back(new SimpleInstruction(SCOPEEND));
+                        scope--;
+                }
+            }
             else if(adv.nodeName == WhileStatement && adv.nodes.size() == 2)
             {
                 auto old_contI = contI;

src/compiler/parser.cpp

@@ -308,7 +308,7 @@ namespace Tesses::CrossLang
     {
         
     }
-    Parser::Parser(std::vector<LexToken> tokens, GC* gc, TRootEnvironment* env)
+    Parser::Parser(std::vector<LexToken> tokens, std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         this->i = 0;
         this->tokens = tokens;
@@ -615,7 +615,7 @@ namespace Tesses::CrossLang
                     EnsureSymbol("(");
                     SyntaxNode list = ParseExpression();
                     SyntaxNode body = nullptr;
-                    if(IsSymbol(":"))
+                    if(IsSymbol(":") || IsIdentifier("in"))
                     {
                         item = list;
                         list = ParseExpression();
@@ -1406,6 +1406,20 @@ namespace Tesses::CrossLang
             }
             return AdvancedSyntaxNode::Create(WhileStatement,false,{cond,body});
         }
+        if(IsIdentifier("using"))
+        {
+            EnsureSymbol("(");
+            SyntaxNode expr = ParseExpression();
+            EnsureSymbol(")");
+
+            SyntaxNode body = nullptr;
+            if(!IsSymbol(";"))
+            {
+                body = ParseNode();
+            }
+
+            return AdvancedSyntaxNode::Create(UsingStatement, false, {expr,body});
+        }
         if(IsIdentifier("do"))
         {
             EnsureSymbol("(");

src/crosslangcompiler.cpp

@@ -212,15 +212,15 @@ int main(int argc, char** argv)
         
     }
 
-    GC* gc=nullptr;
-    GCList* ls=nullptr;
+    std::shared_ptr<GC> gc;
+    std::shared_ptr<GCList> ls;
     TRootEnvironment* env=nullptr;
     if(comptime != "none")
     {
-        gc = new GC();
+        gc = std::make_shared<GC>();
         gc->Start();
-        ls = new GCList(gc);
-        env = TRootEnvironment::Create(ls,TDictionary::Create(ls));
+        ls = std::make_shared<GCList>(gc);
+        env = TRootEnvironment::Create(*ls,TDictionary::Create(*ls));
 
         if(comptime == "secure")
         {
@@ -281,10 +281,5 @@ int main(int argc, char** argv)
     
         gen.Save(strm);
     }
-    if(gc != nullptr)
-    {
-        delete ls;
-        delete gc;
-    }
     return 0;
 }

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/markedtobject.cpp

@@ -2,7 +2,7 @@
 
 namespace Tesses::CrossLang
 {
-    SharedPtrTObject::SharedPtrTObject(GC* gc, TObject o)
+    SharedPtrTObject::SharedPtrTObject(std::shared_ptr<GC> gc, TObject o)
     {
         this->ls = new GCList(gc);
         this->ls->Add(o);
@@ -17,18 +17,15 @@ namespace Tesses::CrossLang
         if(this->ls)
         delete this->ls;
     }
-    GC* SharedPtrTObject::GetGC()
+    std::shared_ptr<GC> SharedPtrTObject::GetGC()
     {
         return this->ls->GetGC();
     }
-    MarkedTObject CreateMarkedTObject(GC* gc, TObject o)
+    MarkedTObject CreateMarkedTObject(std::shared_ptr<GC> gc, TObject o)
     {
         return std::make_shared<SharedPtrTObject>(gc,o);
     }
-    MarkedTObject CreateMarkedTObject(GC& gc, TObject o)
-    {
-        return CreateMarkedTObject(&gc,o);
-    }
+   
     MarkedTObject CreateMarkedTObject(GCList* gc, TObject o)
     {
         return CreateMarkedTObject(gc->GetGC(),o);

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))
@@ -91,3 +92,4 @@ int main(int argc, char** argv)
 
     return 0;
 }
+}

src/program_lib/crossarchiveextract.cpp

@@ -1,30 +1,29 @@
 #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]));
-
-    FILE* f = fopen(argv[1],"rb");
-    if(f == NULL) 
+    auto strm= LocalFS->OpenFile(argv[1], "rb");
+    if(strm->CanRead()) 
     {
-        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;
@@ -32,3 +31,4 @@ int main(int argc, char** argv)
 
     return 0;
 }
+}

src/program_lib/crossdump.cpp

@@ -1,20 +1,20 @@
 #include "CrossLang.hpp"
 #include <iostream>
-using namespace Tesses::CrossLang;
-void Ensure(Tesses::Framework::Streams::Stream& strm,uint8_t* buffer, size_t len)
+namespace Tesses::CrossLang::Programs {
+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,14 +22,8 @@ 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))
-    {
-        try
-        {
-            std::cout << "File: " << p.string() << std::endl;
-            Tesses::Framework::Streams::FileStream strm(p,"rb");
     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.");
@@ -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,28 +1,54 @@
 #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
 {
-    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)? ";
-        std::string line;
-        std::getline(std::cin,line);
-        if(line == "Y" || line == "y")
+
+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.followRedirects=true;
+        req.url = "https://redirect.tesses.net/crosslang-shell";
         req.method = "GET";
         HttpResponse resp(req);
         if(resp.statusCode == StatusCode::OK)
         {
             auto strm = resp.ReadAsStream();
-                CrossArchiveExtract(strm, vfs);
+            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://redirect.tesses.net/crosslang-shell (this may install other stuff as well) (Y/n)? ";
+        std::string line;
+        std::getline(std::cin,line);
+        if(line == "Y" || line == "y")
+        {
+            HttpRequest req;
+            req.followRedirects = true;
+            req.url = "https://redirect.tesses.net/crosslang-shell";
+            req.method = "GET";
+            HttpResponse resp(req);
+            if(resp.statusCode == StatusCode::OK)
+            {
+                auto strm = resp.ReadAsStream();
+                CrossLang::CrossArchiveExtract(strm, vfs);
 
                 return true;
             }
@@ -46,13 +72,8 @@ bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared_ptr<Te
     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();
 
@@ -60,23 +81,24 @@ int main(int argc, char** argv)
 
 
     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);
         HttpRequest req;
-            req.url = "https://downloads.tesses.net/ShellPackage.crvm";
+        req.followRedirects=true;
+            req.url = "https://redirect.tesses.net/crosslang-shell";
             req.method = "GET";
             HttpResponse resp(req);
             if(resp.statusCode == StatusCode::OK)
             {
                 auto strm = resp.ReadAsStream();
-                CrossArchiveExtract(strm, subdir);
+                CrossLang::CrossArchiveExtract(strm, subdir);
 
                 return 0;
             }
@@ -97,7 +119,7 @@ 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
@@ -113,29 +135,24 @@ int main(int argc, char** argv)
     }
 
 
-    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});
-    int64_t iresult;
-    if(GetObject(res,iresult))
-        return (int)iresult;
-    return 0;
+    return env->CallFunctionWithFatalError(ls,"main",{args});
+
+}
+
 }

src/program_lib/crosslangcompiler.cpp

@@ -0,0 +1,285 @@
+#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);
+        
+    }
+
+    std::shared_ptr<GC> gc;
+    std::shared_ptr<GCList> ls;
+    TRootEnvironment* env=nullptr;
+    if(comptime != "none")
+    {
+        std::shared_ptr<GC> gc= std::make_shared<GC>();
+        gc->Start();
+        ls = std::make_shared<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);
+    }
+}
+}

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)
-{
-    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);
 
-    if(argc > 1)
+namespace Tesses::CrossLang::Programs {
+TObject CrossLangInterperter(GCList& ls,TRootEnvironment* env,std::vector<std::string>& argv)
+{
+    std::shared_ptr<GC> gc = ls.GetGC();    
+    if(argv.size() > 1)
     {
         std::ifstream strm(argv[1],std::ios_base::in|std::ios_base::binary);
         std::vector<LexToken> tokens;
@@ -40,22 +33,20 @@ 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);
 
             
             }
         }
 
         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]));
    
-    auto res = env->CallFunctionWithFatalError(ls,"main",{args});
-    int64_t iresult;
-    if(GetObject(res,iresult))
-        return (int)iresult;
+        return env->CallFunctionWithFatalError(ls,"main",{args});
+    
    
     }
     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]);
+    std::shared_ptr<GC> gc= std::make_shared<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,30 @@
+#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::shared_ptr<GC> gc= std::make_shared<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,30 @@
+#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::shared_ptr<GC> gc= std::make_shared<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,176 @@
+#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")
+        {
+           
+            int64_t myi64=0;
+            
+            std::shared_ptr<GC> gc= std::make_shared<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);
+
+                GetObject(res,myi64);
+
+            
+            return (int)myi64;
+        }
+        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")
+        {
+            std::shared_ptr<GC> gc= std::make_shared<GC>();
+            gc->Start();
+            int64_t myi64=0;
+
+            
+            GCList ls(gc);
+            TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
+            TStd::RegisterStd(gc,env);
+            auto res= Programs::CrossLangVM(ls, env, args);
+            GetObject(res,myi64);
+            
+                return (int)myi64;
+
+    }
+    else if(args.size() > 1)
+    {
+
+        if(args[1] == "crossint")
+        {
+            int64_t myi64=0;
+            args.erase(args.begin());
+            std::shared_ptr<GC> gc= std::make_shared<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);
+
+                GetObject(res,myi64);
+            
+            return (int)myi64;
+
+        }
+        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")
+        {
+            int64_t myi64=0;
+
+            args.erase(args.begin());
+            std::shared_ptr<GC> gc= std::make_shared<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);
+                GetObject(res,myi64);
+            
+
+            return (int)myi64;
+        }
+    }
+    {
+         int64_t myi64=0;
+        std::shared_ptr<GC> gc= std::make_shared<GC>();
+        gc->Start();
+            GCList ls(gc);
+            auto res= Programs::CrossLangShell(ls, args);
+
+            GetObject(res,myi64);
+
+
+        
+        return (int)myi64;
+    }
+}

src/runtime_methods/class.cpp

@@ -226,7 +226,7 @@ namespace Tesses::CrossLang
 
         return nullptr;
     }
-    void TStd::RegisterClass(GC* gc, TRootEnvironment* env)
+    void TStd::RegisterClass(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         GCList ls(gc);
         env->permissions.canRegisterClass=true;

src/runtime_methods/console.cpp

@@ -280,7 +280,7 @@ namespace Tesses::CrossLang {
 
         return dict;
     }
-    void TStd::RegisterConsole(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterConsole(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
          env->permissions.canRegisterConsole=true;
         if(env->permissions.customConsole != nullptr)

src/runtime_methods/crypto.cpp

@@ -99,7 +99,7 @@ namespace Tesses::CrossLang
         }
         return nullptr;
     }   
-    void TStd::RegisterCrypto(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterCrypto(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
 
         env->permissions.canRegisterCrypto=true;

src/runtime_methods/dictionary.cpp

@@ -129,7 +129,7 @@ namespace Tesses::CrossLang
         }
         return nullptr;
     }
-    void TStd::RegisterDictionary(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterDictionary(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
 
         env->permissions.canRegisterDictionary=true;

src/runtime_methods/env.cpp

@@ -136,7 +136,7 @@ namespace Tesses::CrossLang
     {
         return Tesses::Framework::Serialization::BitConverter::IsLittleEndian();
     }
-    void TStd::RegisterEnv(GC* gc, TRootEnvironment* env)
+    void TStd::RegisterEnv(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
 
         env->permissions.canRegisterEnv=true;

src/runtime_methods/helpers.cpp

@@ -49,7 +49,7 @@ namespace Tesses::CrossLang {
         }
         return Undefined();
     }
-    void TStd::RegisterHelpers(GC* gc, TRootEnvironment* env)
+    void TStd::RegisterHelpers(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         auto helpers=env->EnsureDictionary(gc,"Helpers");
         helpers->DeclareFunction(gc,"CopyToProgress","Copy Stream to another (but with progress event)",{"src","dest","progressCB","$precision"},Helpers_CopyToProgress);

src/runtime_methods/io.cpp

@@ -4,23 +4,6 @@
 
 namespace Tesses::CrossLang
 {
-    static TObject FS_MakeFull(GCList& ls, std::vector<TObject> args)
-    {
-        Tesses::Framework::Filesystem::VFSPath path;
-        if(GetArgumentAsPath(args,0,path))
-        {
-            if(path.relative)
-            {
-                Tesses::Framework::Filesystem::LocalFilesystem lfs;
-                auto curDir = std::filesystem::current_path();
-                auto myPath = lfs.SystemToVFSPath(curDir.string()) / path;
-                myPath = myPath.CollapseRelativeParents();
-                return myPath;
-            }
-            return path.CollapseRelativeParents();
-        }
-        return nullptr;
-    }
     static TObject FS_CreateArchive(GCList& ls, std::vector<TObject> args)
     {
         std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
@@ -160,17 +143,7 @@ namespace Tesses::CrossLang
         return nullptr;
     }
 
-    static TObject FS_getCurrentPath(GCList& ls, std::vector<TObject> args)
-    {
-        return Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory();
-    }
-    static TObject FS_setCurrentPath(GCList& ls, std::vector<TObject> args)
-    {
-        Tesses::Framework::Filesystem::VFSPath path;
-        if(GetArgumentAsPath(args,0,path))
-        Tesses::Framework::Filesystem::VFSPath::SetAbsoluteCurrentDirectory(path);
-        return nullptr;
-    }
+   
 
     
 
@@ -287,12 +260,22 @@ namespace Tesses::CrossLang
         }
         return nullptr;
     }
-
-    void TStd::RegisterIO(GC* gc,TRootEnvironment* env,bool enableLocalFilesystem)
+    void TStd::RegisterIO(std::shared_ptr<GC> gc,TRootEnvironment* env, bool enable)
+    {
+        if(enable)
+        {
+            RegisterIO(gc,env,std::make_shared<Tesses::Framework::Filesystem::RelativeFilesystem>(Tesses::Framework::Filesystem::LocalFS, Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory()));
+        }
+        else
+        {
+            RegisterIO(gc,env,nullptr);
+        }
+    }
+    void TStd::RegisterIO(std::shared_ptr<GC> gc,TRootEnvironment* env,std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem> fs)
     {
 
         env->permissions.canRegisterIO=true;
-        env->permissions.canRegisterLocalFS = enableLocalFilesystem;
+        env->permissions.localfs = fs;
         GCList ls(gc);
         
         gc->BarrierBegin();
@@ -323,14 +306,42 @@ namespace Tesses::CrossLang
             }
         ));
 
-        if(enableLocalFilesystem)
+        if(fs)
         {
             
         
-            dict->SetValue("Local", Tesses::Framework::Filesystem::LocalFS);
-            dict->DeclareFunction(gc, "MakeFull", "Make absolute path from relative path",{"path"},FS_MakeFull);
-            dict->DeclareFunction(gc,"getCurrentPath","Get current path",{},FS_getCurrentPath);
-            dict->DeclareFunction(gc,"setCurrentPath","Set the current path",{"path"},FS_setCurrentPath);
+            dict->SetValue("Local", fs);
+            dict->DeclareFunction(gc, "MakeFull", "Make absolute path from relative path",{"path"},[fs](GCList& ls, std::vector<TObject> args)->TObject{
+                Tesses::Framework::Filesystem::VFSPath path;
+                if(GetArgumentAsPath(args,0,path))
+                {
+                    if(path.relative)
+                    {
+                        auto myPath = fs->GetWorking() / path;
+                        myPath = myPath.CollapseRelativeParents();
+                        return myPath;
+                    }
+                    return path.CollapseRelativeParents();
+                }
+                return nullptr;
+            });
+            dict->DeclareFunction(gc,"getCurrentPath","Get current path",{},[fs](GCList& ls, std::vector<TObject> args)->TObject{
+                return fs->GetWorking();
+            });
+            dict->DeclareFunction(gc,"setCurrentPath","Set the current path",{"path"}, [fs](GCList& ls, std::vector<TObject> args)->TObject {
+                Tesses::Framework::Filesystem::VFSPath path;
+                if(GetArgumentAsPath(args,0,path))
+                {
+                    if(path.relative)
+                            {
+                                fs->SetWorking(path.MakeAbsolute(fs->GetWorking()));
+                            }
+                            else {
+                                fs->SetWorking(path);
+                            }
+                }
+                return path;
+            });
         }
 
         dict->DeclareFunction(gc, "ReadAllText","Read all text from file", {"fs","filename"},FS_ReadAllText);

src/runtime_methods/json.cpp

@@ -186,7 +186,7 @@ namespace Tesses::CrossLang
     {
         return JsonDeserialize(ls,Json::DocDecode(str));
     }
-    void TStd::RegisterJson(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterJson(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
 
         env->permissions.canRegisterJSON=true;

src/runtime_methods/net.cpp

@@ -379,6 +379,56 @@ namespace Tesses::CrossLang
                         ctx->WithLastModified(*da);
                     return this;
                 }
+                else if(key == "WithDebug")
+                {
+                    bool debug=true;
+                    GetArgument(args,0,debug);
+
+                    ctx->WithDebug(debug);
+
+                    return this;
+                }
+
+                else if(key == "getDebug")
+                {
+                    return ctx->Debug();
+                }
+                else if(key == "SendServerSentEvents")
+                {
+                    if(!args.empty() && std::holds_alternative<std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>>(args[0]))
+                    {
+                        ctx->SendServerSentEvents(std::get<std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>>(args[0]));
+                    }
+                    
+                }
+                else if(key == "WithHeaderIntercepter")
+                {
+                    TCallable* callable;
+                    if(GetArgumentHeap(args, 0, callable))
+                    {
+                        auto marked = CreateMarkedTObject(ls.GetGC(),callable);
+                        ctx->WithHeaderIntercepter([marked](ServerContext& ctx)->bool {
+                            auto obj = marked->GetObject();
+                            TCallable* callable;
+                            if(GetObjectHeap(obj, callable))
+                            {
+                                GCList ls(marked->GetGC());
+
+                                auto ptr=TNativeObject::Create<TServerContext>(ls, &ctx);
+
+                                auto res = callable->Call(ls, {ptr});
+                                ptr->Finish();
+                                bool r0;
+                                if(GetObject(res, r0)) return r0;
+
+
+                            }
+
+                            return false;
+                        });
+                    }
+                    return this;
+                }
                 else if(key == "WithContentDisposition")
                 {
                     std::string filename;
@@ -589,7 +639,7 @@ namespace Tesses::CrossLang
             }
     };
    
-    TObjectHttpServer::TObjectHttpServer(GC* gc,TObject obj)
+    TObjectHttpServer::TObjectHttpServer(std::shared_ptr<GC> gc,TObject obj)
     {
         this->ls=new GCList(gc);
         this->ls->Add(obj);
@@ -598,10 +648,10 @@ namespace Tesses::CrossLang
  
     class TDictionaryHttpRequestBody : public HttpRequestBody
     {
-        GC* gc;
+        std::shared_ptr<GC> gc;
         TDictionary* req;
         public:
-            TDictionaryHttpRequestBody(GC* gc,TDictionary* req)
+            TDictionaryHttpRequestBody(std::shared_ptr<GC> gc,TDictionary* req)
             {
                 this->gc = gc;
                 this->req = req;
@@ -790,7 +840,7 @@ namespace Tesses::CrossLang
             
         }
 
-        if(GetArgument(args,1,pathStr) && env->permissions.canRegisterLocalFS)
+        if(GetArgument(args,1,pathStr) && env->permissions.localfs)
         {
             std::shared_ptr<IHttpServer> httpSvr = ToHttpServer(ls.GetGC(),args[0]);
             
@@ -979,7 +1029,7 @@ namespace Tesses::CrossLang
                 GetObject(_obj,req.followRedirects);
                 _obj = options->GetValue("TrustedRootCertBundle");
                 GetObject(_obj,req.trusted_root_cert_bundle);
-                if(env->permissions.canRegisterLocalFS)
+                if(env->permissions.localfs)
                 {
                     _obj = options->GetValue("UnixSocket");
                     GetObject(_obj,req.unixSocket);
@@ -1403,7 +1453,7 @@ namespace Tesses::CrossLang
         return false;
     }
 
-    std::shared_ptr<IHttpServer> ToHttpServer(GC* gc, TObject obj)
+    std::shared_ptr<IHttpServer> ToHttpServer(std::shared_ptr<GC> gc, TObject obj)
     {
         if(std::holds_alternative<std::shared_ptr<IHttpServer>>(obj)) return std::get<std::shared_ptr<IHttpServer>>(obj);
         TDictionary* dict;
@@ -1523,7 +1573,12 @@ namespace Tesses::CrossLang
         
     }
 
-    void TStd::RegisterNet(GC* gc, TRootEnvironment* env)
+    static TObject New_ServerSentEvents(GCList& ls, std::vector<TObject> args)
+    {
+        return std::make_shared<Tesses::Framework::Http::ServerSentEvents>();
+    }
+    
+    void TStd::RegisterNet(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
 
         env->permissions.canRegisterNet=true;
@@ -1545,6 +1600,7 @@ namespace Tesses::CrossLang
         _new->DeclareFunction(gc, "MountableServer","Create a server you can mount to, must mount parents before child",{"root"}, New_MountableServer);
         _new->DeclareFunction(gc, "NetworkStream","Create a network stream",{"ipv6","datagram"},New_NetworkStream);
         
+        _new->DeclareFunction(gc, "ServerSentEvents", "Create server sent events object",{""},New_ServerSentEvents);
         
 
         TDictionary* http = TDictionary::Create(ls);
@@ -1617,7 +1673,7 @@ namespace Tesses::CrossLang
         gc->BarrierEnd();
     }
 
-    Tesses::Framework::Http::ServerRequestHandler TCallable::ToRouteServerRequestHandler(GC* gc)
+    Tesses::Framework::Http::ServerRequestHandler TCallable::ToRouteServerRequestHandler(std::shared_ptr<GC> gc)
     {
         auto value = CreateMarkedTObject(gc,this);
         return [value,this](ServerContext& ctx)->bool {

src/runtime_methods/ogc.cpp

@@ -46,7 +46,7 @@ namespace Tesses::CrossLang
     }
     #endif
     #endif
-    void TStd::RegisterOGC(GC* gc, TRootEnvironment* env)
+    void TStd::RegisterOGC(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         GCList ls(gc);
         #if defined(GEKKO)

src/runtime_methods/path.cpp

@@ -65,7 +65,7 @@ namespace Tesses::CrossLang
 
         return nullptr;
     }
-    void TStd::RegisterPath(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterPath(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
 
         env->permissions.canRegisterPath=true;

src/runtime_methods/process.cpp

@@ -184,7 +184,7 @@ namespace Tesses::CrossLang
                 return Undefined();
             }
     };
-    static TObject Process_Start(GCList& ls, std::vector<TObject> args)
+    static TObject Process_Start(GCList& ls, std::vector<TObject> args, TRootEnvironment* env)
     {
         
         //Process.Start({
@@ -220,6 +220,10 @@ namespace Tesses::CrossLang
             GetObject(name,process->process.name);
 
             Tesses::Framework::Filesystem::VFSPath wdPath;
+            if(env->permissions.localfs)
+            {
+                process->process.workingDirectory = env->permissions.localfs->GetWorking().ToString();
+            }
             
             if(GetObject(workingDirectory,wdPath))
             {
@@ -274,23 +278,36 @@ namespace Tesses::CrossLang
 
         return nullptr;
     }
-    static TObject New_Process(GCList& ls, std::vector<TObject> args)
-    {
-        return TNativeObject::Create<ProcessObject>(ls,ls);
-    }
     
-    void TStd::RegisterProcess(GC* gc,TRootEnvironment* env)
+
+    void TStd::RegisterProcess(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
 
         env->permissions.canRegisterProcess=true;
         GCList ls(gc);
         TDictionary* dict = TDictionary::Create(ls);
-        dict->DeclareFunction(gc,"Start","Start a process",{"process_object"},Process_Start);
         
         gc->BarrierBegin();
+        auto processStart = TExternalMethod::Create(ls,"Start a process",{"process_object"},[env](GCList& ls, std::vector<TObject> args)->TObject{
+            return Process_Start(ls,args,env);
+        });
+        processStart->watch.push_back(env);
+        dict->SetValue("Start",processStart);
+
+
         env->SetVariable("Process",dict);
         auto process = env->EnsureDictionary(gc,"New");
-        process->DeclareFunction(gc, "Process", "Create process",{},New_Process);
+        auto newProcess = TExternalMethod::Create(ls, "Create process",{},[env](GCList& ls, std::vector<TObject> args)->TObject {
+            auto obj= TNativeObject::Create<ProcessObject>(ls,ls);
+            if(env->permissions.localfs)
+            {
+                obj->process.workingDirectory = env->permissions.localfs->GetWorking().ToString();
+            }
+             return obj;
+        });
+        newProcess->watch.push_back(env);
+        process->SetValue("Process",newProcess);
+        //process->DeclareFunction(gc, "Process", "Create process",{},New_Process);
         process->DeclareFunction(gc, "CGIServer", "Create a CGI Server",{"path"},[](GCList& ls, std::vector<TObject> args)->TObject{
             Tesses::Framework::Filesystem::VFSPath path;
             if(GetArgumentAsPath(args,0,path))

src/runtime_methods/sqlite.cpp

@@ -33,6 +33,58 @@ namespace Tesses::CrossLang {
         return "NULL";
     }
     
+    TObject Sqlite_Prepare(GCList& ls, std::vector<TObject> args)
+    {
+        std::string str;
+        TList* list;
+
+        std::string newStr = "";
+        if(GetArgument(args,0,str) && GetArgumentHeap(args,1,list))
+        {
+            int64_t item = 0;
+
+
+            for(size_t i = 0; i < str.size(); i++)
+            {
+                if(str[i] == '@' && (i+1>=str.size() || str[i+1] != '@'))
+                {
+                    auto v = list->Get(item);
+                    int64_t n;
+                    double d;
+                    bool b;
+
+
+                    std::string str;
+                    if(GetObject(v,str))
+                    {
+                        newStr+= SQLiteDatabase::Escape(str);
+                    }
+                    else if(GetObject(v,n))
+                    {
+                        newStr+= std::to_string(n);
+                    }
+                    else if(GetObject(v,b))
+                    {
+                        newStr+= (b ? "1" : "0");
+                    }
+                    else if(GetObject(v,d))
+                    {
+                        newStr+= std::to_string(d);
+                    }
+                    else {
+
+                    newStr+= "NULL";
+                    }
+                }
+                else {
+                    newStr+=str[i];
+                }
+            }
+
+            
+        }
+        return newStr;
+    }
      
     class SQLiteObject : public TNativeObject
     {   
@@ -65,6 +117,9 @@ namespace Tesses::CrossLang {
                 if(name == "Escape") {
                     return Sqlite_Escape(ls,args);
                 }
+                if(name == "Prepare") {
+                    return Sqlite_Prepare(ls,args);
+                }
                 if(name == "Exec")
                 {
                     std::string arg;
@@ -105,6 +160,7 @@ namespace Tesses::CrossLang {
             }
     };
 
+
     TObject Sqlite_Open(GCList& ls, std::vector<TObject> args,TRootEnvironment* env)
     {
         Tesses::Framework::Filesystem::VFSPath p;
@@ -149,8 +205,9 @@ namespace Tesses::CrossLang {
         return Undefined();
     }
 
+    
     #endif
-    void TStd::RegisterSqlite(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterSqlite(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
 
         env->permissions.canRegisterSqlite=true;
@@ -163,6 +220,7 @@ namespace Tesses::CrossLang {
         dict->DeclareFunction(gc,"Exec","Execute sql (returns dictionary of columns key=value, an error message as string or undefined)",{"handle","sql"},Sqlite_Exec);
         dict->DeclareFunction(gc,"Close","Close sql database",{"handle"},Sqlite_Close);
         dict->DeclareFunction(gc,"Escape","Escape sql text",{"text"},Sqlite_Escape);
+        dict->DeclareFunction(gc,"Prepare", "Prepare sql",{"sql","items"}, Sqlite_Prepare);
        
         gc->BarrierBegin();
         env->DeclareVariable("Sqlite", dict);

src/runtime_methods/std.cpp

@@ -376,7 +376,7 @@ namespace Tesses::CrossLang
     
     
 
-    void RegisterFFI(GC* gc, TDictionary* dict)
+    void RegisterFFI(std::shared_ptr<GC> gc, TDictionary* dict)
     {
         dict->SetValue("SizeOfChar",(int64_t)sizeof(char));
         dict->SetValue("SizeOfShort",(int64_t)sizeof(short));
@@ -485,14 +485,14 @@ namespace Tesses::CrossLang
     }
 
 
-    void LoadPlugin(GC* gc, TRootEnvironment* env, Tesses::Framework::Filesystem::VFSPath sharedObjectPath)
+    void LoadPlugin(std::shared_ptr<GC> gc, TRootEnvironment* env, Tesses::Framework::Filesystem::VFSPath sharedObjectPath)
     {
         
         #if defined(CROSSLANG_ENABLE_SHARED)
         auto ptr = std::make_shared<DL>(GetPluginPath(sharedObjectPath));
         auto cb = ptr->Resolve<PluginFunction>("CrossLangPluginInit");
         if(cb == nullptr) return;
-        gc->RegisterEverythingCallback([ptr,cb](GC* gc, TRootEnvironment* env)-> void{
+        gc->RegisterEverythingCallback([ptr,cb](std::shared_ptr<GC> gc, TRootEnvironment* env)-> void{
             cb(gc,env);
         });
         cb(gc,env);
@@ -610,6 +610,12 @@ namespace Tesses::CrossLang
         std::shared_ptr<Tesses::Framework::Date::TimeSpan> dt;
         return GetArgument(args,0,dt);
     }
+    static TObject TypeIsQueryable(GCList& ls, std::vector<TObject> args)
+    {
+        if(args.empty()) return nullptr;
+        TQueryable* queryable;
+        return GetArgumentHeap(args,0,queryable);
+    }
     static TObject New_SubdirFilesystem(GCList& ls, std::vector<TObject> args)
     {
         std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
@@ -641,10 +647,7 @@ namespace Tesses::CrossLang
         }
         return nullptr;
     }
-    static TObject New_MemoryFilesystem(GCList& ls, std::vector<TObject> args)
-    {
-        return std::make_shared<Tesses::Framework::Filesystem::MemoryFilesystem>();
-    }
+    
 
     static TObject New_Filesystem(GCList& ls, std::vector<TObject> args)
     {
@@ -750,6 +753,9 @@ namespace Tesses::CrossLang
    
     std::string GetObjectTypeString(TObject _obj)
     {
+        if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(_obj)) return "Timer";
+
+        if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>>(_obj)) return "ServerSentEvents";
         if(std::holds_alternative<std::regex>(_obj)) return "Regex";
         if(std::holds_alternative<Undefined>(_obj)) return "Undefined";
         if(std::holds_alternative<std::nullptr_t>(_obj)) return "Null";
@@ -864,11 +870,12 @@ namespace Tesses::CrossLang
             auto vfs = std::get<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(_obj);
             if(vfs != nullptr)
             {
+                auto rfs = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
                 auto localVFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::LocalFilesystem>(vfs);
                 auto mountableVFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::MountableFilesystem>(vfs);
                 auto subFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::SubdirFilesystem>(vfs);
                 auto tempFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::TempFS>(vfs);
-
+                if(rfs) return "RelativeFilesystem";
                 if(localVFS != nullptr) return "LocalFilesystem";
                 if(subFS != nullptr) return "SubdirFilesystem";
                 if(mountableVFS != nullptr) return "MountableFilesystem";
@@ -900,6 +907,8 @@ namespace Tesses::CrossLang
             auto natObj = dynamic_cast<TNativeObject*>(obj);
             auto cobj = dynamic_cast<TClassObject*>(obj);
             auto aarray = dynamic_cast<TAssociativeArray*>(obj);
+            auto file = dynamic_cast<TFile*>(obj);
+            auto queryable = dynamic_cast<TQueryable*>(obj);
 
             if(rootEnv != nullptr) return "RootEnvironment";
             if(subEnv != nullptr) return "SubEnvironment";
@@ -920,6 +929,8 @@ namespace Tesses::CrossLang
             if(byteArray != nullptr) return "ByteArray";
             if(native != nullptr) return "Native";
             if(any != nullptr) return "Any";
+            if(file != nullptr) return "File";
+            if(queryable != nullptr) return "Queryable";
 
             return "HeapObject";
         }
@@ -1016,7 +1027,6 @@ namespace Tesses::CrossLang
         this->canRegisterEnv=false;
         this->canRegisterIO=false;
         this->canRegisterJSON=false;
-        this->canRegisterLocalFS=false;
         this->canRegisterNet=false;
         this->canRegisterOGC=false;
         this->canRegisterPath=false;
@@ -1264,8 +1274,55 @@ namespace Tesses::CrossLang
             return std::make_shared<Tesses::Framework::Streams::ByteWriter>(strm);
         return nullptr;
     }
+    static void empty(){}
+    static TObject New_Timer(GCList& ls, std::vector<TObject> args)
+    {
+        TCallable* callable;
+        if(GetArgumentHeap(args, 0, callable))
+        {
+            int64_t interval = 1000;
+            bool enabled=true;
+            GetArgument(args,1, interval);
+            GetArgument(args,2,enabled);
 
-    void TStd::RegisterRoot(GC* gc, TRootEnvironment* env)
+            auto obj = CreateMarkedTObject(ls.GetGC(), callable);
+
+            return Tesses::Framework::TF_Timer([obj]()->void {
+                TCallable* callable;
+                if(GetObjectHeap(obj->GetObject(), callable))
+                {
+                    GCList ls(obj->GetGC());
+                    callable->Call(ls,{});
+                }
+            }, interval , enabled);
+        }
+        
+
+        return Tesses::Framework::TF_Timer(empty, 1000L, false);
+    }
+
+    static TObject New_RelativeFilesystem(GCList& ls, std::vector<TObject> args)
+    {
+        std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
+        Tesses::Framework::Filesystem::VFSPath path;
+        if(GetArgument(args,0,vfs) && GetArgumentAsPath(args,1,path) && !path.relative)
+        {
+            return std::make_shared<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs,path);
+        }
+        return nullptr;
+    }
+
+    static TObject New_Queryable(GCList& ls, std::vector<TObject> args)
+    {
+        if(!args.empty())
+        {
+            return TQueryable::Create(ls, args.front());
+        }
+        return nullptr;
+    }
+   
+
+    void TStd::RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         GCList ls(gc);      
         
@@ -1327,11 +1384,11 @@ namespace Tesses::CrossLang
         newTypes->DeclareFunction(gc, "SubdirFilesystem","Create a subdir filesystem",{"fs","subdir"}, New_SubdirFilesystem);
         newTypes->DeclareFunction(gc, "MemoryStream","Create a memory stream",{"writable"}, New_MemoryStream);
         newTypes->DeclareFunction(gc, "Filesystem","Create filesystem", {"fs"},New_Filesystem);
+        newTypes->DeclareFunction(gc, "RelativeFilesystem", "Create relativefs",{"parent", "absoluteDir"}, New_RelativeFilesystem);
         newTypes->DeclareFunction(gc, "TempFS","Create a temp directory",{"",""}, New_TempFS);
+        newTypes->DeclareFunction(gc, "Timer", "Create a timer",{"$cb","$interval","$enabled"}, New_Timer);
         newTypes->DeclareFunction(gc, "Stream","Create stream", {"strm"},New_Stream);
 
-        newTypes->DeclareFunction(gc, "MemoryFilesystem","Create in memory filesystem", {},New_MemoryFilesystem);
-
     
         newTypes->DeclareFunction(gc,"Version","Create a version object",{"$major","$minor","$patch","$build","$stage"},[](GCList& ls, std::vector<TObject> args)->TObject{
             int64_t major=1;
@@ -1391,7 +1448,7 @@ namespace Tesses::CrossLang
         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);
-        
+        env->DeclareFunction(gc, "TypeIsQueryable","Get whether object is a Queryable",{"object"},TypeIsQueryable);
         
         newTypes->DeclareFunction(gc, "Regex", "Create regex object",{"regex"},[](GCList& ls,std::vector<TObject> args)->TObject {
             std::string str;
@@ -1437,6 +1494,7 @@ namespace Tesses::CrossLang
             return TAssociativeArray::Create(ls);
         });
         newTypes->DeclareFunction(gc,"ByteArray","Create bytearray, with optional either size (to size it) or string argument (to fill byte array)",{"$data"},ByteArray);
+        newTypes->DeclareFunction(gc, "Queryable", "Create a queryable", {"enumerable"}, New_Queryable);
         
         env->DeclareVariable("Version", TDictionary::Create(ls,{
             TDItem("Parse",TExternalMethod::Create(ls,"Parse version from string",{"versionStr"},[](GCList& ls, std::vector<TObject> args)->TObject{
@@ -1482,14 +1540,19 @@ namespace Tesses::CrossLang
         
         gc->BarrierEnd();
     }
-    void TStd::RegisterStd(GC* gc, TRootEnvironment* env)
+    void TStd::RegisterStd(std::shared_ptr<GC> gc, TRootEnvironment* env)
+    {
+        RegisterStd(gc, env, std::make_shared<Tesses::Framework::Filesystem::RelativeFilesystem>(Tesses::Framework::Filesystem::LocalFS, Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory()));
+    }
+    void TStd::RegisterStd(std::shared_ptr<GC> gc, TRootEnvironment* env,std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem> localfs)
     {
         env->permissions.canRegisterEverything=true;
         RegisterEnv(gc, env);
         RegisterRoot(gc,env);
         RegisterPath(gc,env);
+        
         RegisterConsole(gc, env);
-        RegisterIO(gc, env);
+        RegisterIO(gc, env, localfs);
         RegisterNet(gc, env);
         RegisterSqlite(gc, env);
         RegisterVM(gc, env);

src/runtime_methods/uuid.cpp

@@ -27,7 +27,7 @@ namespace Tesses::CrossLang {
         return nullptr;
     }
     
-    void TStd::RegisterUuid(GC* gc, TRootEnvironment* env)
+    void TStd::RegisterUuid(std::shared_ptr<GC> gc, TRootEnvironment* env)
     {
         gc->BarrierBegin();
         TDictionary* guid = env->EnsureDictionary(gc, "Uuid");

src/runtime_methods/vm.cpp

@@ -317,7 +317,7 @@ namespace Tesses::CrossLang
         }
         return nullptr;
     }
-    void TStd::RegisterVM(GC* gc,TRootEnvironment* env)
+    void TStd::RegisterVM(std::shared_ptr<GC> gc,TRootEnvironment* env)
     {
         env->permissions.canRegisterVM=true;
         GCList ls(gc);
@@ -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/any.cpp

@@ -5,7 +5,7 @@ namespace Tesses::CrossLang {
     {
         TAny* anyObj = new TAny();
         
-        GC* gc = ls.GetGC();
+        std::shared_ptr<GC> gc = ls.GetGC();
         ls.Add(anyObj);
         gc->Watch(anyObj);
         return anyObj;
@@ -14,7 +14,7 @@ namespace Tesses::CrossLang {
     {
          TAny* anyObj = new TAny();
         
-        GC* gc = ls->GetGC();
+        std::shared_ptr<GC> gc = ls->GetGC();
         ls->Add(anyObj);
         gc->Watch(anyObj);
         return anyObj;

src/types/associativearray.cpp

@@ -6,7 +6,7 @@ namespace Tesses::CrossLang
     TAssociativeArray* TAssociativeArray::Create(GCList& ls)
     {
         TAssociativeArray* list=new TAssociativeArray();
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(list);
         _gc->Watch(list);
         return list;
@@ -14,12 +14,12 @@ namespace Tesses::CrossLang
     TAssociativeArray* TAssociativeArray::Create(GCList* ls)
     {
         TAssociativeArray* list=new TAssociativeArray();
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(list);
         _gc->Watch(list);
         return list;
     }
-    void TAssociativeArray::Set(GC* gc, TObject key, TObject value)
+    void TAssociativeArray::Set(std::shared_ptr<GC> gc, TObject key, TObject value)
     {
          if(std::holds_alternative<Undefined>(key)) return;
         gc->BarrierBegin();
@@ -46,7 +46,7 @@ namespace Tesses::CrossLang
         this->items.push_back(std::pair<TObject,TObject>(key,value));
         gc->BarrierEnd();
     }
-    TObject TAssociativeArray::Get(GC* gc, TObject key)
+    TObject TAssociativeArray::Get(std::shared_ptr<GC> gc, TObject key)
     {
         if(std::holds_alternative<Undefined>(key)) return Undefined();
         gc->BarrierBegin();

src/types/async.cpp

@@ -1,7 +1,7 @@
 #include "CrossLang.hpp"
 //THANKS TO https://www.youtube.com/watch?v=R-z2Hv-7nxk
 namespace Tesses::CrossLang {
-    TTask::TTask(GC* gc)
+    TTask::TTask(std::shared_ptr<GC> gc)
     {
         this->gc = gc;
     }
@@ -172,10 +172,10 @@ namespace Tesses::CrossLang {
     }
 
     class TTaskCseObj {
-        GC* gc;
+        std::shared_ptr<GC> gc;
         TTask* task;
         public:
-            TTaskCseObj(GC* gc, TTask* task)
+            TTaskCseObj(std::shared_ptr<GC> gc, TTask* task)
             {
                 this->gc = gc;
                 this->task = task;
@@ -230,7 +230,7 @@ namespace Tesses::CrossLang {
 
         //try {
             GCList ls2(ls.GetGC());
-            GC* gc = ls.GetGC();
+            std::shared_ptr<GC> gc = ls.GetGC();
             
             std::shared_ptr<TTaskCseObj> obj = std::make_shared<TTaskCseObj>(gc,task);
 

src/types/class.cpp

@@ -43,6 +43,9 @@ namespace Tesses::CrossLang
                             return nullptr;
                         }
                             
+                        break;
+                    default:
+                        //DO NOTHING
                         break;
                 }
                 return &item;

src/types/classenvironment.cpp

@@ -13,7 +13,7 @@ namespace Tesses::CrossLang {
         
         TClassEnvironment* env2=new TClassEnvironment(env,obj);
         
-        GC* _gc = gc->GetGC();
+        std::shared_ptr<GC> _gc = gc->GetGC();
         gc->Add(env2);
         _gc->Watch(env2);
         return env2;
@@ -23,7 +23,7 @@ namespace Tesses::CrossLang {
 
         TClassEnvironment* env2=new TClassEnvironment(env,obj);
         
-        GC* _gc = gc.GetGC();
+        std::shared_ptr<GC> _gc = gc.GetGC();
         gc.Add(env2);
         _gc->Watch(env2);
         return env2;

src/types/closure.cpp

@@ -4,7 +4,7 @@ namespace Tesses::CrossLang {
     {
         TArgWrapper* argWrapper = new TArgWrapper();
         argWrapper->callable = callable;
-        GC* gc = ls.GetGC();
+        std::shared_ptr<GC> gc = ls.GetGC();
         ls.Add(argWrapper);
         gc->Watch(argWrapper);
         return argWrapper;
@@ -13,7 +13,7 @@ namespace Tesses::CrossLang {
     {
         TArgWrapper* argWrapper = new TArgWrapper();
         argWrapper->callable = callable;
-        GC* gc = ls->GetGC();
+        std::shared_ptr<GC> gc = ls->GetGC();
         ls->Add(argWrapper);
         gc->Watch(argWrapper);
         return argWrapper;
@@ -54,7 +54,7 @@ namespace Tesses::CrossLang {
         TClosure* closure = new TClosure();
         closure->className="";
         closure->ownScope=ownScope;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(closure);
         _gc->Watch(closure);
         closure->chunkId = chunkId;
@@ -71,7 +71,7 @@ namespace Tesses::CrossLang {
         TClosure* closure = new TClosure();
         closure->className="";
         closure->ownScope=ownScope;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(closure);
         _gc->Watch(closure);
         closure->chunkId = chunkId;

src/types/dictionary.cpp

@@ -6,7 +6,7 @@ namespace Tesses::CrossLang  {
 
         TDynamicDictionary* dict=new TDynamicDictionary();
         dict->cb = callable;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(dict);
         _gc->Watch(dict);
         return dict;
@@ -15,7 +15,7 @@ namespace Tesses::CrossLang  {
     {
         TDynamicDictionary* dict=new TDynamicDictionary();
         dict->cb = callable;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(dict);
         _gc->Watch(dict);
         return dict;
@@ -153,41 +153,27 @@ namespace Tesses::CrossLang  {
         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)
+    void TDictionary::DeclareFunction(std::shared_ptr<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();
         GCList ls(gc);
         this->SetValue(key, TExternalMethod::Create(ls,documentation,argNames,cb));
         gc->BarrierEnd();
     }
-    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();
-        GCList ls(gc);
-        this->SetValue(key, TExternalMethod::Create(ls,documentation,argNames,cb));
-        gc.BarrierEnd();
-    }
-    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,std::function<void()> destroy)
+    
+    void TDictionary::DeclareFunction(std::shared_ptr<GC> gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy)
     {
         gc->BarrierBegin();
         GCList ls(gc);
         this->SetValue(key, TExternalMethod::Create(ls,documentation,argNames,cb,destroy));
         gc->BarrierEnd();
     }
-    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,std::function<void()> destroy)
-    {
-        gc.BarrierBegin();
-        GCList ls(gc);
-        this->SetValue(key, TExternalMethod::Create(ls,documentation,argNames,cb,destroy));
-        gc.BarrierEnd();
-    }
+    
     TObject TDictionary::GetValue(std::string key)
     {
         if(this->items.empty()) return Undefined();
-        for(auto item : this->items)
-        {
-            if(item.first == key) return item.second;
-        }
+        if(this->items.count(key) > 0)
+                return this->items[key];
         return Undefined();
     }
     void TDictionary::SetValue(std::string key, TObject value)
@@ -218,7 +204,7 @@ namespace Tesses::CrossLang  {
     TDictionary* TDictionary::Create(GCList* gc)
     {
         TDictionary* dict=new TDictionary();
-        GC* _gc = gc->GetGC();
+        std::shared_ptr<GC> _gc = gc->GetGC();
         gc->Add(dict);
         _gc->Watch(dict);
         return dict;
@@ -226,7 +212,7 @@ namespace Tesses::CrossLang  {
     TDictionary* TDictionary::Create(GCList& gc)
     {
         TDictionary* dict=new TDictionary();
-        GC* _gc = gc.GetGC();
+        std::shared_ptr<GC> _gc = gc.GetGC();
         gc.Add(dict);
         _gc->Watch(dict);
         return dict;

src/types/embed.cpp

@@ -2,7 +2,7 @@
 
 namespace Tesses::CrossLang {
 
-    EmbedStream::EmbedStream(GC* gc, TFile* file, uint32_t resource)
+    EmbedStream::EmbedStream(std::shared_ptr<GC> gc, TFile* file, uint32_t resource)
     {
         this->offset = 0;
         this->resource = resource;
@@ -124,17 +124,58 @@ namespace Tesses::CrossLang {
         }
         return nullptr;
 	}
-	bool EmbedDirectory::RegularFileExists(Tesses::Framework::Filesystem::VFSPath path)
-	{
-		auto ent = getEntry(path);
-		TCallable* call;
-		return GetObjectHeap(ent,call);
-	}
-    bool EmbedDirectory::DirectoryExists(Tesses::Framework::Filesystem::VFSPath path)
+	
+    bool EmbedDirectory::Stat(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatData& data)
 	{
 		auto ent = getEntry(path);
+
+
 		TDictionary* dict;
-		return GetObjectHeap(ent,dict);
+		if(GetObjectHeap(ent,dict))
+        {
+            data.Size = 0;
+            data.Mode = Tesses::Framework::Filesystem::MODE_DIRECTORY | 0755;
+            data.BlockCount = 0;
+            data.BlockSize = 0;
+            data.Device = 0;
+            data.DeviceId = 0;
+            data.GroupId = 0;
+            data.HardLinks = 1;
+            data.Inode = 0;
+            data.LastAccess = Tesses::Framework::Date::DateTime(0);
+            data.LastModified = Tesses::Framework::Date::DateTime(0);
+            data.LastStatus = Tesses::Framework::Date::DateTime(0);
+            data.UserId = 0;
+            
+            return true;
+        }
+        TCallable* cal;
+        if(GetObjectHeap(ent, cal))
+        {
+            GCList ls(this->dir->GetGC());
+            auto fileO= cal->Call(ls, {});
+            std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
+            if(GetObject(fileO,strm)) {
+
+            data.Size = (uint64_t)strm->GetLength();
+            data.Mode = Tesses::Framework::Filesystem::MODE_REGULAR | 0755; 
+            data.BlockSize = 512;
+            data.BlockCount = data.Size / data.BlockSize;
+           
+            data.Device = 0;
+            data.DeviceId = 0;
+            data.GroupId = 0;
+            data.HardLinks = 1;
+            data.Inode = 0;
+            data.LastAccess = Tesses::Framework::Date::DateTime(0);
+            data.LastModified = Tesses::Framework::Date::DateTime(0);
+            data.LastStatus = Tesses::Framework::Date::DateTime(0);
+            data.UserId = 0;
+            
+            return true;
+            }
+        }
+        return false;
 	}
 
     class DICT_DIRENUM
@@ -148,7 +189,7 @@ namespace Tesses::CrossLang {
             {
                 return this->current->first;
             }
-            DICT_DIRENUM(GC* gc, TDictionary* dict) : ls(gc), dict(dict)
+            DICT_DIRENUM(std::shared_ptr<GC> gc, TDictionary* dict) : ls(gc), dict(dict)
             {
                 ls.Add(dict);
             }
@@ -197,26 +238,11 @@ namespace Tesses::CrossLang {
         return Tesses::Framework::Filesystem::VFSPathEnumerator();
     }
 
-    EmbedDirectory::EmbedDirectory(GC* gc, TDictionary* dict)
+    EmbedDirectory::EmbedDirectory(std::shared_ptr<GC> gc, TDictionary* dict)
     {
         this->dir = CreateMarkedTObject(gc, dict);
     }
-    void EmbedDirectory::CreateDirectory(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        //DO NOTHING
-    }
-    void EmbedDirectory::DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path)
-    {
     
-    }
-    void EmbedDirectory::DeleteFile(Tesses::Framework::Filesystem::VFSPath path)
-    {
-
-    }
-    void EmbedDirectory::MoveFile(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest)
-    {
-
-    }
     std::string EmbedDirectory::VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path)
     {
         return path.ToString();

src/types/ittr.cpp

@@ -2,7 +2,7 @@
 
 namespace Tesses::CrossLang
 {
-    bool TYieldEnumerator::MoveNext(GC* ls)
+    bool TYieldEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         CallStackEntry* ent;
         GCList ls2(ls);
@@ -56,7 +56,7 @@ namespace Tesses::CrossLang
         yieldEnum->hasStarted=false;
         yieldEnum->enumerator = v;
         
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(yieldEnum);
         _gc->Watch(yieldEnum);
         return yieldEnum;
@@ -69,13 +69,13 @@ namespace Tesses::CrossLang
         yieldEnum->hasStarted=false;
         yieldEnum->enumerator = v;
         
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(yieldEnum);
         _gc->Watch(yieldEnum);
         return yieldEnum;
     }
     
-    bool TCustomEnumerator::MoveNext(GC* ls)
+    bool TCustomEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {   
         GCList ls2(ls);
         auto res = this->dict->CallMethod(ls2,"MoveNext",{});
@@ -110,7 +110,7 @@ namespace Tesses::CrossLang
     {
         TCustomEnumerator* customEnum = new TCustomEnumerator();
         customEnum->dict = dict;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(customEnum);
         _gc->Watch(customEnum);
         return customEnum;
@@ -119,7 +119,7 @@ namespace Tesses::CrossLang
     {
         TCustomEnumerator* customEnum = new TCustomEnumerator();
         customEnum->dict = dict;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(customEnum);
         _gc->Watch(customEnum);
         return customEnum;
@@ -132,6 +132,7 @@ namespace Tesses::CrossLang
         TDynamicDictionary* dynDict;
         TDictionary* dict;
         TEnumerator* enumerator;
+        TQueryable* q;
         if(GetObject(obj,str))
         {
             return TStringEnumerator::Create(ls, str);
@@ -156,13 +157,21 @@ namespace Tesses::CrossLang
                 return enumerator;
             }
         }
+        else if(GetObjectHeap(obj, q))
+        {
+            return q->GetEnumerator(ls);
+        }
+        else if(GetObjectHeap(obj, enumerator))
+        {
+            return enumerator;
+        }
         return nullptr;
     }
     TVFSPathEnumerator* TVFSPathEnumerator::Create(GCList& ls, Tesses::Framework::Filesystem::VFSPathEnumerator enumerator)
     {
         TVFSPathEnumerator* vfspathe = new TVFSPathEnumerator();
         vfspathe->enumerator = enumerator;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(vfspathe);
         _gc->Watch(vfspathe);
         return vfspathe;
@@ -171,12 +180,12 @@ namespace Tesses::CrossLang
     {
         TVFSPathEnumerator* vfspathe = new TVFSPathEnumerator();
         vfspathe->enumerator = enumerator;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(vfspathe);
         _gc->Watch(vfspathe);
         return vfspathe;
     }
-    bool TVFSPathEnumerator::MoveNext(GC* ls)
+    bool TVFSPathEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         return enumerator.MoveNext();
     }
@@ -189,7 +198,7 @@ namespace Tesses::CrossLang
         TDictionaryEnumerator* dicte=new TDictionaryEnumerator();
         dicte->dict = dict;
         dicte->hasStarted=false;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(dicte);
         _gc->Watch(dicte);
         return dicte;
@@ -199,13 +208,13 @@ namespace Tesses::CrossLang
         TDictionaryEnumerator* dicte=new TDictionaryEnumerator();
         dicte->dict = dict;
         dicte->hasStarted=false;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(dicte);
         _gc->Watch(dicte);
         return dicte;
     }
     
-    bool TDictionaryEnumerator::MoveNext(GC* ls)
+    bool TDictionaryEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         if(!this->hasStarted)
         {
@@ -248,7 +257,7 @@ namespace Tesses::CrossLang
         TListEnumerator* liste=new TListEnumerator();
         liste->ls = list;
         liste->index = -1;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(liste);
         _gc->Watch(liste);
         return liste;
@@ -258,12 +267,12 @@ namespace Tesses::CrossLang
         TListEnumerator* liste=new TListEnumerator();
         liste->ls = list;
         liste->index = -1;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(liste);
         _gc->Watch(liste);
         return liste;
     }
-    bool TListEnumerator::MoveNext(GC* ls)
+    bool TListEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         this->index++;
         return this->index >= 0 && this->index < this->ls->Count();
@@ -291,7 +300,7 @@ namespace Tesses::CrossLang
         TAssociativeArrayEnumerator* liste=new TAssociativeArrayEnumerator();
         liste->ls = list;
         liste->index = -1;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(liste);
         _gc->Watch(liste);
         return liste;
@@ -301,12 +310,12 @@ namespace Tesses::CrossLang
         TAssociativeArrayEnumerator* liste=new TAssociativeArrayEnumerator();
         liste->ls = list;
         liste->index = -1;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(liste);
         _gc->Watch(liste);
         return liste;
     }
-    bool TAssociativeArrayEnumerator::MoveNext(GC* ls)
+    bool TAssociativeArrayEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         this->index++;
         return this->index >= 0 && this->index < this->ls->Count();
@@ -338,7 +347,7 @@ namespace Tesses::CrossLang
         TDynamicListEnumerator* liste=new TDynamicListEnumerator();
         liste->ls = list;
         liste->index = -1;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(liste);
         _gc->Watch(liste);
         return liste;
@@ -348,12 +357,12 @@ namespace Tesses::CrossLang
         TDynamicListEnumerator* liste=new TDynamicListEnumerator();
         liste->ls = list;
         liste->index = -1;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(liste);
         _gc->Watch(liste);
         return liste;
     }
-    bool TDynamicListEnumerator::MoveNext(GC* ls)
+    bool TDynamicListEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         this->index++;
         GCList ls2(ls);
@@ -384,7 +393,7 @@ namespace Tesses::CrossLang
         TStringEnumerator* stre=new TStringEnumerator();
         stre->str = str;
         stre->hasStarted=false;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(stre);
         _gc->Watch(stre);
         return stre;
@@ -394,12 +403,12 @@ namespace Tesses::CrossLang
         TStringEnumerator* stre=new TStringEnumerator();
         stre->str = str;
         stre->hasStarted=false;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(stre);
         _gc->Watch(stre);
         return stre;
     }
-    bool TStringEnumerator::MoveNext(GC* ls)
+    bool TStringEnumerator::MoveNext(std::shared_ptr<GC> ls)
     {
         if(!this->hasStarted)
         {

src/types/list.cpp

@@ -4,7 +4,7 @@ namespace Tesses::CrossLang {
     {
         TDynamicList* list=new TDynamicList();
         list->cb = callable;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(list);
         _gc->Watch(list);
         return list;
@@ -13,7 +13,7 @@ namespace Tesses::CrossLang {
     {
         TDynamicList* list=new TDynamicList();
         list->cb = callable;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(list);
         _gc->Watch(list);
         return list;
@@ -140,7 +140,7 @@ namespace Tesses::CrossLang {
     TByteArray* TByteArray::Create(GCList& ls)
     {
          TByteArray* arr=new TByteArray();
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(arr);
         _gc->Watch(arr);
         return arr;
@@ -149,7 +149,7 @@ namespace Tesses::CrossLang {
     TByteArray* TByteArray::Create(GCList* ls)
     {
          TByteArray* arr=new TByteArray();
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(arr);
         _gc->Watch(arr);
         return arr;
@@ -157,7 +157,7 @@ namespace Tesses::CrossLang {
     TList* TList::Create(GCList* gc)
     {
         TList* list=new TList();
-        GC* _gc = gc->GetGC();
+        std::shared_ptr<GC> _gc = gc->GetGC();
         gc->Add(list);
         _gc->Watch(list);
         return list;
@@ -165,7 +165,7 @@ namespace Tesses::CrossLang {
     TList* TList::Create(GCList& gc)
     {
         TList* list=new TList();
-        GC* _gc = gc.GetGC();
+        std::shared_ptr<GC> _gc = gc.GetGC();
         gc.Add(list);
         _gc->Watch(list);
         return list;

src/types/native.cpp

@@ -43,7 +43,7 @@ namespace Tesses::CrossLang
     {
         return true;
     }
-    bool TNativeObject::Equals(GC* gc, TObject right)
+    bool TNativeObject::Equals(std::shared_ptr<GC> gc, TObject right)
     {
         if(std::holds_alternative<THeapObjectHolder>(right))
         {
@@ -54,7 +54,7 @@ namespace Tesses::CrossLang
     TNative* TNative::Create(GCList& ls, void* ptr,std::function<void(void*)> destroy)
     {
         TNative* native = new TNative(ptr,destroy);
-        GC* gc = ls.GetGC();
+        std::shared_ptr<GC> gc = ls.GetGC();
         ls.Add(native);
         gc->Watch(native);
         return native;
@@ -62,7 +62,7 @@ namespace Tesses::CrossLang
     TNative* TNative::Create(GCList* ls, void* ptr,std::function<void(void*)> destroy)
     {
         TNative* native = new TNative(ptr,destroy);
-        GC* gc = ls->GetGC();
+        std::shared_ptr<GC> gc = ls->GetGC();
         ls->Add(native);
         gc->Watch(native);
         return native;

src/types/queryable.cpp

@@ -0,0 +1,522 @@
+#include "CrossLang.hpp"
+
+namespace Tesses::CrossLang 
+{
+    TQueryable::TQueryable(TObject parent) : TQueryable(parent,TQueryableMode::Passthrough, {})
+    {
+
+    }
+    TQueryable::TQueryable(TObject parent, TQueryableMode mode, std::vector<TObject> args): parent(parent), mode(mode), args(args)
+    {
+
+    }
+
+    TQueryable* TQueryable::Skip(GCList& ls,int64_t no)
+    {
+        return TQueryable::Create(ls,this,TQueryableMode::Skip, {no});
+    }
+    TQueryable* TQueryable::SkipWhile(GCList& ls, TCallable* call)
+    {
+        return TQueryable::Create(ls,this,TQueryableMode::SkipWhile, {call});
+    }
+    TQueryable* TQueryable::Take(GCList& ls, int64_t no)
+    {
+        return TQueryable::Create(ls,this,TQueryableMode::Take, {no});
+    }
+    TQueryable* TQueryable::TakeWhile(GCList& ls, TCallable* call)
+    {
+        return TQueryable::Create(ls,this,TQueryableMode::TakeWhile, {call});
+    }
+    TQueryable* TQueryable::Select(GCList& ls, TCallable* call)
+    {
+        return TQueryable::Create(ls,this,TQueryableMode::Select, {call});
+    }
+    TQueryable* TQueryable::Where(GCList& ls, TCallable* call)
+    {
+        return TQueryable::Create(ls,this,TQueryableMode::Where, {call});
+    }
+    
+    TList* TQueryable::ToList(GCList& ls)
+    {
+        auto gc = ls.GetGC();
+        GCList ls2(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return nullptr;
+        auto list = TList::Create(ls);
+        while(enumerator->MoveNext(gc))
+        {
+            gc->BarrierBegin();
+            list->Add(enumerator->GetCurrent(ls));
+            gc->BarrierEnd();
+        }
+        return list;
+    }
+    TQueryable* TQueryable::Create(GCList& ls, TObject parent)
+    {
+        TQueryable* queryable = new TQueryable(parent);
+        std::shared_ptr<GC> gc = ls.GetGC();
+        ls.Add(queryable);
+        gc->Watch(queryable);
+        return queryable;
+    }
+    TQueryable* TQueryable::Create(GCList& ls, TObject parent, TQueryableMode mode, std::vector<TObject> args)
+    {
+        TQueryable* queryable = new TQueryable(parent, mode,args);
+        std::shared_ptr<GC> gc = ls.GetGC();
+        ls.Add(queryable);
+        gc->Watch(queryable);
+        return queryable;
+    }
+    
+
+    void TQueryable::Mark()
+    {
+        if(this->marked) return;
+        this->marked=true;
+        
+        GC::Mark(this->parent);
+        for(auto& item : args)
+            GC::Mark(item);
+    }
+
+    void TQueryable::ForEach(std::shared_ptr<GC> gc, TCallable* call)
+    {
+        if(call == nullptr) return;
+        GCList ls(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return;
+        while(enumerator->MoveNext(gc))
+        {
+            GCList ls2(gc);
+            call->Call(ls2,{enumerator->GetCurrent(ls2)});
+        }
+    }
+    int64_t TQueryable::Count(std::shared_ptr<GC> gc, TCallable* call)
+    {
+        if(call == nullptr) return 0;
+        GCList ls(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return 0;
+        int64_t count=0;
+        while(enumerator->MoveNext(gc))
+        {
+            GCList ls2(gc);
+            if(ToBool(call->Call(ls2,{enumerator->GetCurrent(ls2)}))) count++;
+        }
+        return count;
+    }
+    int64_t TQueryable::Count(std::shared_ptr<GC> gc)
+    {
+        GCList ls(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return 0;
+        int64_t count=0;
+        while(enumerator->MoveNext(gc))
+        {
+            count++;
+        }
+        return count;
+    }
+    bool TQueryable::Contains(std::shared_ptr<GC> gc, TObject value)
+    {
+        GCList ls(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return false;
+        while(enumerator->MoveNext(gc))
+        {
+            GCList ls2(gc);
+            
+
+            if(Equals(gc,value,enumerator->GetCurrent(ls2)))
+                return true;
+            
+        }
+        return false;
+    }
+    bool TQueryable::Any(std::shared_ptr<GC> gc, TCallable* call)
+    {
+        if(call == nullptr) return false;
+        GCList ls(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return false;
+       
+        while(enumerator->MoveNext(gc))
+        {
+            GCList ls2(gc);
+            if(ToBool(call->Call(ls2,{enumerator->GetCurrent(ls2)}))) return true;
+        }
+        return false;
+    }
+    bool TQueryable::All(std::shared_ptr<GC> gc, TCallable* call)
+    {
+        if(call == nullptr) return true;
+        GCList ls(gc);
+        auto enumerator = this->GetEnumerator(ls);
+        if(enumerator == nullptr) return true;
+       
+        while(enumerator->MoveNext(gc))
+        {
+            GCList ls2(gc);
+            if(!ToBool(call->Call(ls2,{enumerator->GetCurrent(ls2)}))) return false;
+        }
+        return true;
+    }
+
+    class SkipItterator : public TEnumerator {
+        private:
+            TEnumerator* parentEnum;
+            int64_t skipCount;
+            SkipItterator(TEnumerator* parentEnum, int64_t skipCount) : parentEnum(parentEnum), skipCount(skipCount)
+            {
+
+            }
+        public:
+            static SkipItterator* Create(GCList& ls, TEnumerator* parentEnum, int64_t skipCount)
+            {
+                SkipItterator* queryable = new SkipItterator(parentEnum, skipCount);
+                std::shared_ptr<GC> gc = ls.GetGC();
+                ls.Add(queryable);
+                gc->Watch(queryable);
+                return queryable;
+            }
+            bool MoveNext(std::shared_ptr<GC> ls)
+            {
+                if(this->parentEnum == nullptr) return false;
+                while(skipCount > 0)
+                {
+                    if(!this->parentEnum->MoveNext(ls)) {
+                        skipCount=0;
+                        return false;
+                    }
+                    skipCount--;
+                }
+                return this->parentEnum->MoveNext(ls);
+            }
+            TObject GetCurrent(GCList& ls)
+            {
+                return this->parentEnum->GetCurrent(ls);
+            }
+            void Mark()
+            {
+                if(this->marked) return;
+                this->marked=true;
+
+                if(parentEnum != nullptr) parentEnum->Mark();
+            }
+    };
+    class TakeItterator : public TEnumerator {
+        private:
+            TEnumerator* parentEnum;
+            int64_t takeCount;
+            TakeItterator(TEnumerator* parentEnum, int64_t takeCount) : parentEnum(parentEnum), takeCount(takeCount)
+            {
+
+            }
+        public:
+            static TakeItterator* Create(GCList& ls, TEnumerator* parentEnum, int64_t takeCount)
+            {
+                TakeItterator* queryable = new TakeItterator(parentEnum, takeCount);
+                std::shared_ptr<GC> gc = ls.GetGC();
+                ls.Add(queryable);
+                gc->Watch(queryable);
+                return queryable;
+            }
+            bool MoveNext(std::shared_ptr<GC> ls)
+            {
+                if(this->parentEnum == nullptr) return false;
+                if(takeCount > 0)
+                {
+                    takeCount--;
+                    return this->parentEnum->MoveNext(ls);
+                }
+                return false;
+            }
+            TObject GetCurrent(GCList& ls)
+            {
+                return this->parentEnum->GetCurrent(ls);
+            }
+            void Mark()
+            {
+                if(this->marked) return;
+                this->marked=true;
+
+                if(parentEnum != nullptr) parentEnum->Mark();
+            }
+    };
+    class SkipWhileItterator : public TEnumerator {
+        private:
+            TEnumerator* parentEnum;
+            TCallable* callable;
+            SkipWhileItterator(TEnumerator* parentEnum, TCallable* callable) : parentEnum(parentEnum), callable(callable)
+            {
+
+            }
+        public:
+            static SkipWhileItterator* Create(GCList& ls, TEnumerator* parentEnum, TCallable* callable)
+            {
+                SkipWhileItterator* queryable = new SkipWhileItterator(parentEnum, callable);
+                std::shared_ptr<GC> gc = ls.GetGC();
+                ls.Add(queryable);
+                gc->Watch(queryable);
+                return queryable;
+            }
+            bool MoveNext(std::shared_ptr<GC> ls)
+            {
+                if(this->parentEnum == nullptr) return false;
+                ls->BarrierBegin();
+                auto callable = this->callable;
+                ls->BarrierEnd();
+                
+                if(callable != nullptr)
+                {
+                    while(true)
+                    {
+                        if(this->parentEnum->MoveNext(ls))
+                        {
+                            GCList ls2(ls);
+                            auto result = callable->Call(ls2,{this->parentEnum->GetCurrent(ls2)});
+                            if(!ToBool(result))
+                            {
+                                ls->BarrierBegin();
+                                this->callable=nullptr;
+                                ls->BarrierEnd();
+                                return true;
+                            }
+                    
+                        } 
+                        else 
+                        { 
+                            ls->BarrierBegin();
+                            this->callable=nullptr;
+                            ls->BarrierEnd();
+                            return false;
+                        }
+                    }
+                }
+                else {
+                    return this->parentEnum->MoveNext(ls);
+                }
+                return false;
+            }
+            TObject GetCurrent(GCList& ls)
+            {
+                return this->parentEnum->GetCurrent(ls);
+            }
+            void Mark()
+            {
+                if(this->marked) return;
+                this->marked=true;
+
+                if(parentEnum != nullptr) parentEnum->Mark();
+                if(callable != nullptr) callable->Mark();
+            }
+    };
+    class TakeWhileItterator : public TEnumerator {
+        private:
+            TEnumerator* parentEnum;
+            TCallable* callable;
+            TakeWhileItterator(TEnumerator* parentEnum, TCallable* callable) : parentEnum(parentEnum), callable(callable)
+            {
+
+            }
+        public:
+            static TakeWhileItterator* Create(GCList& ls, TEnumerator* parentEnum, TCallable* callable)
+            {
+                TakeWhileItterator* queryable = new TakeWhileItterator(parentEnum, callable);
+                std::shared_ptr<GC> gc = ls.GetGC();
+                ls.Add(queryable);
+                gc->Watch(queryable);
+                return queryable;
+            }
+            bool MoveNext(std::shared_ptr<GC> ls)
+            {
+                if(this->parentEnum == nullptr) return false;
+                ls->BarrierBegin();
+                auto callable = this->callable;
+                ls->BarrierEnd();
+                if(callable != nullptr)
+                {
+                    if(this->parentEnum->MoveNext(ls))
+                    {
+                        GCList ls2(ls);
+                        auto result = callable->Call(ls2,{this->parentEnum->GetCurrent(ls2)});
+                        if(!ToBool(result))
+                        {
+                            ls->BarrierBegin();
+                            this->callable=nullptr;
+                            ls->BarrierEnd();
+                            return false;
+                        }
+                        return true;
+                    }
+                }
+                return false;
+            }
+            TObject GetCurrent(GCList& ls)
+            {
+                return this->parentEnum->GetCurrent(ls);
+            }
+            void Mark()
+            {
+                if(this->marked) return;
+                this->marked=true;
+
+                if(parentEnum != nullptr) parentEnum->Mark();
+                if(callable != nullptr) callable->Mark();
+            }
+    };
+    class WhereItterator : public TEnumerator {
+        private:
+            TEnumerator* parentEnum;
+            TCallable* callable;
+            WhereItterator(TEnumerator* parentEnum, TCallable* callable) : parentEnum(parentEnum), callable(callable)
+            {
+
+            }
+        public:
+            static WhereItterator* Create(GCList& ls, TEnumerator* parentEnum, TCallable* callable)
+            {
+                WhereItterator* queryable = new WhereItterator(parentEnum, callable);
+                std::shared_ptr<GC> gc = ls.GetGC();
+                ls.Add(queryable);
+                gc->Watch(queryable);
+                return queryable;
+            }
+            bool MoveNext(std::shared_ptr<GC> ls)
+            {
+                if(this->parentEnum == nullptr || this->callable == nullptr) return false;
+                while(this->parentEnum->MoveNext(ls)) 
+                {
+                    GCList ls2(ls);
+                    auto cur = this->parentEnum->GetCurrent(ls2);
+                    if(ToBool(callable->Call(ls2,{cur})))
+                        return true;
+                    
+                }
+                return false;
+            }
+            TObject GetCurrent(GCList& ls)
+            {
+                return this->parentEnum->GetCurrent(ls);
+            }
+            void Mark()
+            {
+                if(this->marked) return;
+                this->marked=true;
+
+                if(parentEnum != nullptr) parentEnum->Mark();
+                if(callable != nullptr) callable->Mark();
+            }
+    };
+    class SelectItterator : public TEnumerator {
+        private:
+            TEnumerator* parentEnum;
+            TCallable* callable;
+            TObject value;
+            SelectItterator(TEnumerator* parentEnum, TCallable* callable) : parentEnum(parentEnum), callable(callable)
+            {
+
+            }
+        public:
+            static SelectItterator* Create(GCList& ls, TEnumerator* parentEnum, TCallable* callable)
+            {
+                SelectItterator* queryable = new SelectItterator(parentEnum, callable);
+                std::shared_ptr<GC> gc = ls.GetGC();
+                ls.Add(queryable);
+                gc->Watch(queryable);
+                return queryable;
+            }
+            bool MoveNext(std::shared_ptr<GC> ls)
+            {
+                if(this->parentEnum == nullptr || this->callable == nullptr) return false;
+                if(this->parentEnum->MoveNext(ls)) 
+                {
+                    GCList ls2(ls);
+                    auto cur = this->parentEnum->GetCurrent(ls2);
+                    auto value = this->callable->Call(ls2,{cur});
+
+                    ls->BarrierBegin();
+                    this->value = value;
+                    ls->BarrierEnd();
+
+                    return true;
+                }
+                return false;
+            }
+            TObject GetCurrent(GCList& ls)
+            {
+                ls.GetGC()->BarrierBegin();
+                auto value=this->value;
+                ls.GetGC()->BarrierEnd();
+                return value;
+            }
+            void Mark()
+            {
+                if(this->marked) return;
+                this->marked=true;
+
+                if(parentEnum != nullptr) parentEnum->Mark();
+                if(callable != nullptr) callable->Mark();
+
+                GC::Mark(this->value);
+            }
+    };
+    
+   
+    TEnumerator* TQueryable::GetEnumerator(GCList& ls)
+    {
+        switch(this->mode)
+        {
+            case TQueryableMode::Skip:
+            {
+                int64_t skipCount;
+                if(GetArgument(args,0,skipCount))
+                    return SkipItterator::Create(ls,  TEnumerator::CreateFromObject(ls, this->parent), skipCount);
+            }
+                break;
+            case TQueryableMode::Take:
+            {
+                int64_t takeCount;
+                if(GetArgument(args,0,takeCount))
+                    return TakeItterator::Create(ls,  TEnumerator::CreateFromObject(ls, this->parent), takeCount);
+           
+            }
+                break;
+            case TQueryableMode::SkipWhile:
+            {
+                TCallable* callable;
+                if(GetArgumentHeap(args,0,callable))
+                    return SkipWhileItterator::Create(ls,  TEnumerator::CreateFromObject(ls, this->parent), callable);
+           
+            }
+                break;
+            case TQueryableMode::TakeWhile:
+            {
+                TCallable* callable;
+                if(GetArgumentHeap(args,0,callable))
+                    return TakeWhileItterator::Create(ls,  TEnumerator::CreateFromObject(ls, this->parent), callable);
+           
+            }
+                break;
+            case TQueryableMode::Select:
+            {
+                TCallable* callable;
+                if(GetArgumentHeap(args,0,callable))
+                    return SelectItterator::Create(ls,  TEnumerator::CreateFromObject(ls, this->parent), callable);
+           
+            }
+                break;
+            case TQueryableMode::Where:
+            {
+                TCallable* callable;
+                if(GetArgumentHeap(args,0,callable))
+                    return WhereItterator::Create(ls,  TEnumerator::CreateFromObject(ls, this->parent), callable);
+           
+            }
+                break;
+        }
+
+        return TEnumerator::CreateFromObject(ls, this->parent);
+    }
+
+}

src/types/rootenvironment.cpp

@@ -86,7 +86,7 @@ namespace Tesses::CrossLang {
         return value;
     }
             
-    void TRootEnvironment::LoadDependency(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::pair<std::string,TVMVersion> dep)
+    void TRootEnvironment::LoadDependency(std::shared_ptr<GC> gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::pair<std::string,TVMVersion> dep)
     {
          for(auto item : this->dependencies)
             if(item.first == dep.first && item.second.CompareTo(dep.second) >= 0) return;
@@ -129,7 +129,7 @@ namespace Tesses::CrossLang {
             f->Load(ls.GetGC(),ms);
         return this->LoadFile(ls.GetGC(), f);
     }
-    TDictionary* TEnvironment::EnsureDictionary(GC* gc, std::string key)
+    TDictionary* TEnvironment::EnsureDictionary(std::shared_ptr<GC> gc, std::string key)
     {
         TObject item = this->GetVariable(key);
         TDictionary* dict;
@@ -139,7 +139,7 @@ namespace Tesses::CrossLang {
         this->DeclareVariable(key, dict);
         return dict;
     }
-    void TEnvironment::DeclareVariable(GC* gc, std::vector<std::string> name, TObject o)
+    void TEnvironment::DeclareVariable(std::shared_ptr<GC> gc, std::vector<std::string> name, TObject o)
     {
         if(name.size() == 0)
                 throw VMException("name can't be empty.");
@@ -209,7 +209,7 @@ namespace Tesses::CrossLang {
             }
     }
 
-    TObject TEnvironment::LoadFile(GC* gc, TFile* file)
+    TObject TEnvironment::LoadFile(std::shared_ptr<GC> gc, TFile* file)
     {
         file->EnsureCanRunInCrossLang();
         for(size_t i = 0; i < file->classes.size(); i++)
@@ -266,7 +266,7 @@ namespace Tesses::CrossLang {
         }
         return nullptr;
     }
-    void TRootEnvironment::LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile* file)
+    void TRootEnvironment::LoadFileWithDependencies(std::shared_ptr<GC> gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile* file)
     {
         this->dependencies.push_back(std::pair<std::string,TVMVersion>(file->name,file->version));
         for(auto item : file->dependencies)
@@ -276,7 +276,7 @@ namespace Tesses::CrossLang {
         LoadFile(gc, file);
       
     }
-    void TRootEnvironment::LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path)
+    void TRootEnvironment::LoadFileWithDependencies(std::shared_ptr<GC> gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path)
     {
        
 
@@ -344,7 +344,7 @@ namespace Tesses::CrossLang {
     TRootEnvironment* TRootEnvironment::Create(GCList* gc,TDictionary* dict)
     {
         TRootEnvironment* env=new TRootEnvironment(dict);
-        GC* _gc = gc->GetGC();
+        std::shared_ptr<GC> _gc = gc->GetGC();
         gc->Add(env);
         _gc->Watch(env);
         return env;
@@ -352,13 +352,13 @@ namespace Tesses::CrossLang {
     TRootEnvironment* TRootEnvironment::Create(GCList& gc,TDictionary* dict)
     {
         TRootEnvironment* env=new TRootEnvironment(dict);
-        GC* _gc = gc.GetGC();
+        std::shared_ptr<GC> _gc = gc.GetGC();
         gc.Add(env);
         _gc->Watch(env);
         return env;
     }
 
-    bool TRootEnvironment::HandleException(GC* gc,TEnvironment* env, TObject err)
+    bool TRootEnvironment::HandleException(std::shared_ptr<GC> gc,TEnvironment* env, TObject err)
     {
         if(error != nullptr)
         {
@@ -373,7 +373,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool TRootEnvironment::HandleBreakpoint(GC* gc,TEnvironment* env, TObject err)
+    bool TRootEnvironment::HandleBreakpoint(std::shared_ptr<GC> gc,TEnvironment* env, TObject err)
     {
         if(error != nullptr)
         {

src/types/streamheapobject.cpp

@@ -6,7 +6,7 @@ namespace Tesses::CrossLang
     {
         return Tesses::Framework::Streams::Stream::GetLength();
     }
-    TObjectStream::TObjectStream(GC* gc, TObject obj)
+    TObjectStream::TObjectStream(std::shared_ptr<GC> gc, TObject obj)
     {
         this->ls = new GCList(gc);
         this->ls->Add(obj);
@@ -205,7 +205,7 @@ namespace Tesses::CrossLang
         TDictionary* dict;
         if(GetObjectHeap(this->obj, dict))
         {
-            dict->CallMethod(*ls,"Close",{});
+            dict->CallMethod(*ls,"Dispose",{});
         }
     }
     TObjectStream::~TObjectStream()
@@ -213,7 +213,7 @@ namespace Tesses::CrossLang
         TDictionary* dict;
         if(GetObjectHeap(this->obj, dict))
         {
-            dict->CallMethod(*ls,"Close",{});
+            dict->CallMethod(*ls,"Dispose",{});
         }
         delete this->ls;
     }

src/types/subenvironment.cpp

@@ -180,7 +180,7 @@ namespace Tesses::CrossLang  {
     {
         auto dict=TDictionary::Create(gc);
         TSubEnvironment* sEnv = this->GetSubEnvironment(dict);
-        GC* _gc = gc->GetGC();
+        std::shared_ptr<GC> _gc = gc->GetGC();
         gc->Add(sEnv);
         _gc->Watch(sEnv);
         return sEnv;
@@ -189,7 +189,7 @@ namespace Tesses::CrossLang  {
     {
         auto dict=TDictionary::Create(gc);
         TSubEnvironment* sEnv = this->GetSubEnvironment(dict);
-        GC* _gc = gc.GetGC();
+        std::shared_ptr<GC> _gc = gc.GetGC();
         gc.Add(sEnv);
         _gc->Watch(sEnv);
         return sEnv;
@@ -197,7 +197,7 @@ namespace Tesses::CrossLang  {
     TSubEnvironment* TSubEnvironment::Create(GCList* gc, TEnvironment* env, TDictionary* dict)
     {
         TSubEnvironment* senv = new TSubEnvironment(env,dict);
-        GC* _gc = gc->GetGC();
+        std::shared_ptr<GC> _gc = gc->GetGC();
         gc->Add(senv);
         _gc->Watch(senv);
         return senv;
@@ -205,7 +205,7 @@ namespace Tesses::CrossLang  {
     TSubEnvironment* TSubEnvironment::Create(GCList& gc, TEnvironment* env, TDictionary* dict)
     {
         TSubEnvironment* senv = new TSubEnvironment(env,dict);
-        GC* _gc = gc.GetGC();
+        std::shared_ptr<GC> _gc = gc.GetGC();
         gc.Add(senv);
         _gc->Watch(senv);
         return senv;
@@ -227,32 +227,20 @@ namespace Tesses::CrossLang  {
         this->env->Mark();
         for(auto defer : defers) defer->Mark();
     }
-    void TEnvironment::DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb)
+    void TEnvironment::DeclareFunction(std::shared_ptr<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();
         GCList ls(gc);
         this->DeclareVariable(key, TExternalMethod::Create(ls,documentation,argNames,cb));
         gc->BarrierEnd();
     }
-    void TEnvironment::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();
-        GCList ls(gc);
-        this->DeclareVariable(key, TExternalMethod::Create(ls,documentation,argNames,cb));
-        gc.BarrierEnd();
-    }
-    void TEnvironment::DeclareFunction(GC* gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy)
+    
+    void TEnvironment::DeclareFunction(std::shared_ptr<GC> gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy)
     {
         gc->BarrierBegin();
         GCList ls(gc);
         this->DeclareVariable(key, TExternalMethod::Create(ls,documentation,argNames,cb,destroy));
         gc->BarrierEnd();
     }
-    void TEnvironment::DeclareFunction(GC& gc,std::string key,std::string documentation, std::vector<std::string> argNames, std::function<TObject(GCList& ls, std::vector<TObject> args)> cb,std::function<void()> destroy)
-    {
-        gc.BarrierBegin();
-        GCList ls(gc);
-        this->DeclareVariable(key, TExternalMethod::Create(ls,documentation,argNames,cb,destroy));
-        gc.BarrierEnd();
-    }
+    
 };

src/types/vfsheapobject.cpp

@@ -2,135 +2,28 @@
 
 namespace Tesses::CrossLang {
 
-    TObjectVFS::TObjectVFS(GC* gc, TObject obj)
+    TObjectVFS::TObjectVFS(std::shared_ptr<GC> gc, TObject obj)
     {
         this->ls = new GCList(gc);
         this->ls->Add(obj);
         this->obj = obj;
+        
+        
+    }
+    Tesses::Framework::Filesystem::FIFOCreationResult TObjectVFS::CreateFIFO(Tesses::Framework::Filesystem::VFSPath path)
+    {
         TDictionary* dict;
-        if(GetObjectHeap(obj,dict))
+        
+        if(GetObjectHeap(this->obj, dict))
         {
-            gc->BarrierBegin();
-            if(!dict->HasValue("OpenFile"))
-            {
-                dict->DeclareFunction(gc,"OpenFile","Open a file",{"path","mode"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    return nullptr;
-                });
+            GCList ls(this->ls->GetGC());
+            auto res = dict->CallMethod(ls, "CreateFIFO",{path});
+            int64_t n=0;
+            if(GetObject(res, n)) return (Tesses::Framework::Filesystem::FIFOCreationResult)n;
         }
-            if(!dict->HasValue("EnumeratePaths"))
-            {
-                dict->DeclareFunction(gc,"EnumeratePaths","Enumerate paths",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    return TVFSPathEnumerator::Create(ls,Tesses::Framework::Filesystem::VFSPathEnumerator());
-                });
-            }
-            if(!dict->HasValue("ReadLink"))
-            {
-                dict->DeclareFunction(gc,"ReadLink","Read a symlink",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    return Tesses::Framework::Filesystem::VFSPath();
-                });
+        return Tesses::Framework::Filesystem::FIFOCreationResult::UnknownError;
     }
             
-            if(!dict->HasValue("VFSPathToSystem"))
-            {
-                dict->DeclareFunction(gc,"VFSPathToSystem","Convert path to system",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    Tesses::Framework::Filesystem::VFSPath path;
-                    if(GetArgumentAsPath(args,0,path))
-                    {
-                        return path.ToString();
-                    }
-                    return "/";
-                });
-            }
-            if(!dict->HasValue("SystemToVFSPath"))
-            {
-                dict->DeclareFunction(gc,"SystemToVFSPath","Convert system to path",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    std::string p;
-                    if(GetArgument(args,0,p))
-                    {
-                        return Tesses::Framework::Filesystem::VFSPath(p);
-                    }
-                    return Tesses::Framework::Filesystem::VFSPath();
-                });
-            }
-            if(!dict->HasValue("GetDate"))
-            {
-                dict->DeclareFunction(gc,"GetDate","Get date from file",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    auto dict = TDictionary::Create(ls);
-                    ls.GetGC()->BarrierBegin();
-                    dict->SetValue("LastWrite", (int64_t)time(NULL));
-                    dict->SetValue("LastAccess", (int64_t)time(NULL));
-                    ls.GetGC()->BarrierEnd();
-                    return dict;    
-                });
-            }
-            if(!dict->HasValue("RegularFileExists"))
-            {
-                dict->DeclareFunction(gc,"RegularFileExists","Regular file exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("SymlinkExists"))
-            {
-                dict->DeclareFunction(gc,"SymlinkExists","Symlink exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("CharacterDeviceExists"))
-            {
-                dict->DeclareFunction(gc,"CharacterDeviceExists","Character file exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("BlockDeviceExists"))
-            {
-                dict->DeclareFunction(gc,"BlockDeviceExists","Block file exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("SocketFileExists"))
-            {
-                dict->DeclareFunction(gc,"SocketFileExists","Socket file exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-
-            if(!dict->HasValue("FIFOFileExists"))
-            {
-                dict->DeclareFunction(gc,"FIFOFileExists","FIFO file exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("FileExists"))
-            {
-                dict->DeclareFunction(gc,"FileExists","File exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("SpecialFileExists"))
-            {
-                dict->DeclareFunction(gc,"SpecialFileExists","Special file exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            if(!dict->HasValue("DirectoryExists"))
-            {
-                dict->DeclareFunction(gc,"DirectoryExists","Directory exists",{"path"}, [](GCList& ls, std::vector<TObject> args)->TObject {
-                    
-                    return false;
-                });
-            }
-            gc->BarrierEnd();
-        }
-        
-    }
     std::shared_ptr<Tesses::Framework::Streams::Stream> TObjectVFS::OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode)
     {
         TDictionary* dict;
@@ -189,135 +82,6 @@ namespace Tesses::CrossLang {
             
         }
     }
-    bool TObjectVFS::RegularFileExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-
-        TDictionary* dict;
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "RegularFileExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-
-    bool TObjectVFS::SymlinkExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "SymlinkExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-    bool TObjectVFS::CharacterDeviceExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "CharacterDeviceExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-    bool TObjectVFS::BlockDeviceExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "BlockDeviceExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-    bool TObjectVFS::SocketFileExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "SocketFileExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-    bool TObjectVFS::FIFOFileExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "FIFOFileExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-    bool TObjectVFS::FileExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "FileExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
-    bool TObjectVFS::SpecialFileExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "SpecialFileExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
   void TObjectVFS::CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath symlinkFile)
     {
         TDictionary* dict;
@@ -340,21 +104,6 @@ namespace Tesses::CrossLang {
             
         }
     }
-    bool TObjectVFS::DirectoryExists(Tesses::Framework::Filesystem::VFSPath path)
-    {
-        TDictionary* dict;
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "DirectoryExists",{path});
-            bool out;
-            if(GetObject(res,out))
-            {
-                return out;
-            }
-        }
-        return false;
-    }
    void TObjectVFS::DeleteFile(Tesses::Framework::Filesystem::VFSPath path)
     {
         TDictionary* dict;
@@ -484,31 +233,6 @@ namespace Tesses::CrossLang {
         }
         return Tesses::Framework::Filesystem::VFSPath();
     }
-    void TObjectVFS::GetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime& lastWrite, Tesses::Framework::Date::DateTime& lastAccess)
-    {
-
-        TDictionary* dict;
-        if(GetObjectHeap(this->obj, dict))
-        {
-            GCList ls(this->ls->GetGC());
-            auto res = dict->CallMethod(ls, "GetDate",{path});
-            if(GetObjectHeap(res,dict))
-            {
-                this->ls->GetGC()->BarrierBegin();
-                res = dict->GetValue("LastWrite");
-                std::shared_ptr<Tesses::Framework::Date::DateTime> d;
-                if(GetObject(res,d))
-                    lastWrite =*d;
-
-                res = dict->GetValue("LastAccess");
-                
-                if(GetObject(res,d))
-                lastWrite = *d;
-
-                this->ls->GetGC()->BarrierEnd();
-            }
-        }
-    }
     void TObjectVFS::SetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime lastWrite, Tesses::Framework::Date::DateTime lastAccess)
     {
 
@@ -532,6 +256,80 @@ namespace Tesses::CrossLang {
             
         }
     }
+    void TObjectVFS::Chown(Tesses::Framework::Filesystem::VFSPath path, uint32_t uid, uint32_t gid)
+    {
+        TDictionary* dict;
+        
+        if(GetObjectHeap(this->obj, dict))
+        {
+            GCList ls(this->ls->GetGC());
+            dict->CallMethod(ls, "Chown",{path,(int64_t)uid, (int64_t)gid});
+            
+        }
+    }
+    bool TObjectVFS::Stat(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatData& data)
+    {
+        TDictionary* dict;
+        
+        if(GetObjectHeap(this->obj, dict))
+        {
+            GCList ls(this->ls->GetGC());
+            auto res = dict->CallMethod(ls, "Stat",{path});
+            int64_t _num;
+            TDictionary* _dict;
+            TObject _o;
+            if(GetObjectHeap(res,_dict))
+            {
+                this->ls->GetGC()->BarrierBegin();
+                _o = _dict->GetValue("BlockSize");
+                if(GetObject(_o,_num)) data.BlockSize = (uint64_t)_num;
+
+                _o = _dict->GetValue("BlockCount");
+                if(GetObject(_o,_num)) data.BlockCount = (uint64_t)_num;
+                
+                _o = _dict->GetValue("Device");
+                if(GetObject(_o,_num)) data.Device = (uint64_t)_num;
+                
+                _o = _dict->GetValue("DeviceId");
+                if(GetObject(_o,_num)) data.DeviceId = (uint64_t)_num;
+                
+                _o = _dict->GetValue("GroupId");
+                if(GetObject(_o,_num)) data.GroupId = (uint32_t)_num;
+                
+                _o = _dict->GetValue("HardLinks");
+                if(GetObject(_o,_num)) data.HardLinks = (uint64_t)_num;
+                std::shared_ptr<Tesses::Framework::Date::DateTime> dt;
+                _o = _dict->GetValue("LastAccess");
+                if(GetObject(_o,dt)) data.LastAccess = dt ? *dt : Tesses::Framework::Date::DateTime(0);
+                
+
+                _o = _dict->GetValue("LastModified");
+                if(GetObject(_o,dt)) data.LastModified = dt ? *dt : Tesses::Framework::Date::DateTime(0);
+                
+                
+
+                _o = _dict->GetValue("LastStatus");
+                if(GetObject(_o,dt)) data.LastStatus = dt ? *dt : Tesses::Framework::Date::DateTime(0);
+                
+
+
+                _o = _dict->GetValue("Mode");
+                if(GetObject(_o,_num)) data.Mode = (uint32_t)_num;
+                
+                _o = _dict->GetValue("Size");
+                if(GetObject(_o,_num)) data.Size = (uint64_t)_num;
+                
+                _o = _dict->GetValue("UserId");
+                if(GetObject(_o,_num)) data.UserId = (uint32_t)_num;
+
+
+                this->ls->GetGC()->BarrierEnd();
+                return true;
+            }
+        }
+
+        return false;
+    }
     bool TObjectVFS::StatVFS(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatVFSData& data)
     {
         TDictionary* dict;
@@ -546,28 +344,28 @@ namespace Tesses::CrossLang {
             if(GetObjectHeap(res,_dict))
             {
                 this->ls->GetGC()->BarrierBegin();
-                _o = dict->GetValue("BlockSize");
+                _o = _dict->GetValue("BlockSize");
                 if(GetObject(_o,_num)) data.BlockSize = (uint64_t)_num;
 
-                _o = dict->GetValue("FragmentSize");
+                _o = _dict->GetValue("FragmentSize");
                 if(GetObject(_o,_num)) data.FragmentSize = (uint64_t)_num;
-                _o = dict->GetValue("Blocks");
+                _o = _dict->GetValue("Blocks");
                 if(GetObject(_o,_num)) data.Blocks = (uint64_t)_num;
-                _o = dict->GetValue("BlocksFree");
+                _o = _dict->GetValue("BlocksFree");
                 if(GetObject(_o,_num)) data.BlocksFree = (uint64_t)_num;
-                _o = dict->GetValue("BlocksAvailable");
+                _o = _dict->GetValue("BlocksAvailable");
                 if(GetObject(_o,_num)) data.BlocksAvailable = (uint64_t)_num;
-                _o = dict->GetValue("TotalInodes");
+                _o = _dict->GetValue("TotalInodes");
                 if(GetObject(_o,_num)) data.TotalInodes = (uint64_t)_num;
-                _o = dict->GetValue("FreeInodes");
+                _o = _dict->GetValue("FreeInodes");
                 if(GetObject(_o,_num)) data.FreeInodes = (uint64_t)_num;
-                _o = dict->GetValue("AvailableInodes");
+                _o = _dict->GetValue("AvailableInodes");
                 if(GetObject(_o,_num)) data.AvailableInodes = (uint64_t)_num;
-                _o = dict->GetValue("Id");
+                _o = _dict->GetValue("Id");
                 if(GetObject(_o,_num)) data.Id = (uint64_t)_num;
-                _o = dict->GetValue("Flags");
+                _o = _dict->GetValue("Flags");
                 if(GetObject(_o,_num)) data.Flags = (uint64_t)_num;
-                _o = dict->GetValue("MaxNameLength");
+                _o = _dict->GetValue("MaxNameLength");
                 if(GetObject(_o,_num)) data.MaxNameLength = (uint64_t)_num;
                 
                 
@@ -588,7 +386,7 @@ namespace Tesses::CrossLang {
         if(GetObjectHeap(this->obj, dict))
         {
             GCList ls(this->ls->GetGC());
-            dict->CallMethod(ls,"Close",{});
+            dict->CallMethod(ls,"Dispose",{});
         }
     }
     TObjectVFS::~TObjectVFS()
@@ -597,7 +395,7 @@ namespace Tesses::CrossLang {
         if(GetObjectHeap(this->obj, dict))
         {
             GCList ls(this->ls->GetGC());
-            dict->CallMethod(ls,"Close",{});
+            dict->CallMethod(ls,"Dispose",{});
         }
         delete this->ls;
     }

src/vm/bc/add.cpp

@@ -10,7 +10,7 @@
 #include <sstream>
 #include <variant>
 namespace Tesses::CrossLang {
-    bool InterperterThread::Add(GC* gc)
+    bool InterperterThread::Add(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);

src/vm/bc/equals.cpp

@@ -13,7 +13,7 @@
 
 namespace Tesses::CrossLang {
 
-    bool Equals(GC* gc, TObject left, TObject right)
+    bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right)
     {
         GCList ls(gc);
         if(std::holds_alternative<std::nullptr_t>(left) && std::holds_alternative<std::nullptr_t>(right))

src/vm/bc/executemethod2.cpp

@@ -14,7 +14,7 @@
 namespace Tesses::CrossLang {
     extern bool IHttpServer_Handle(std::shared_ptr<Tesses::Framework::Http::IHttpServer> svr,std::vector<TObject>& args);
     
-     bool InterperterThread::ExecuteMethod2(GC* gc, TObject instance, std::string key, std::vector<TObject> args)
+     bool InterperterThread::ExecuteMethod2(std::shared_ptr<GC> gc, TObject instance, std::string key, std::vector<TObject> args)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -395,7 +395,7 @@ namespace Tesses::CrossLang {
                     cse.back()->Push(gc, path.GetExtension());
                     return false;
                 }
-                if(cse.back()->env->GetRootEnvironment()->permissions.canRegisterLocalFS && key == "MakeAbsolute")
+                if(cse.back()->env->GetRootEnvironment()->permissions.localfs && key == "MakeAbsolute")
                 {
                     Tesses::Framework::Filesystem::VFSPath p;
                     if(GetArgumentAsPath(args,0,p))
@@ -405,11 +405,11 @@ namespace Tesses::CrossLang {
                     }
                     else
                     {
-                        cse.back()->Push(gc,path.MakeAbsolute());
+                        cse.back()->Push(gc,path.MakeAbsolute(cse.back()->env->GetRootEnvironment()->permissions.localfs->GetWorking()));
                         return false;
                     }
                 }
-                if(cse.back()->env->GetRootEnvironment()->permissions.canRegisterLocalFS && key == "MakeRelative")
+                if(cse.back()->env->GetRootEnvironment()->permissions.localfs && key == "MakeRelative")
                 {
                     Tesses::Framework::Filesystem::VFSPath p;
                     if(GetArgumentAsPath(args,0,p))
@@ -419,7 +419,7 @@ namespace Tesses::CrossLang {
                     }
                     else
                     {
-                        cse.back()->Push(gc,path.MakeRelative());
+                        cse.back()->Push(gc,path.MakeRelative(cse.back()->env->GetRootEnvironment()->permissions.localfs->GetWorking()));
                         return false;
                     }
                 }
@@ -668,7 +668,8 @@ namespace Tesses::CrossLang {
                         {
                             if(str[i] != c) break;
                         }
-                         cse.back()->Push(gc,str.substr(i));
+
+                         cse.back()->Push(gc,(!str.empty() && i < str.size()) ? str.substr(i) : "");
                          return false;
                     }
                 }
@@ -682,7 +683,8 @@ namespace Tesses::CrossLang {
                         {
                             if(str[i] != c) break;
                         }
-                         cse.back()->Push(gc,str.substr(0,i+1));
+
+                         cse.back()->Push(gc, (!str.empty() && i < str.size())  ? str.substr(0,i+1) : "");
                          return false;
                     }
                 }
@@ -1199,6 +1201,48 @@ namespace Tesses::CrossLang {
                 cse.back()->Push(gc,Undefined());
                 return false;
             }
+            else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>>(instance))
+            {
+                auto& sse = std::get<std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>>(instance);
+                if(sse != nullptr)
+                {
+                    std::string text;
+                    std::string text2;
+                    if(key == "SendComment" && GetArgument(args, 0, text))
+                    {
+                        sse->SendComment(text);
+                    }
+                    else if(key == "SendCustomEvent" && GetArgument(args, 0, text) && GetArgument(args,1,text2)) {
+                        sse->SendCustomEvent(text,text2);
+                    }
+                    else if(key == "SendCustomEvent" && GetArgument(args, 0, text)) {
+                        if(GetArgument(args,1,text2))
+                        sse->SendData(text,text2);
+                        else
+                        sse->SendData(text);
+                    }
+                    else if(key == "SendId" && GetArgument(args, 0, text))
+                    {
+                        sse->SendId(text);
+                    }
+                    else if(key == "SendRetry")
+                    {
+                        std::shared_ptr<Tesses::Framework::Date::TimeSpan> ts;
+                        int64_t num;
+                        if(GetArgument(args,0,ts) && ts)
+                        {
+                            sse->SendRetry(*ts);
+                        }
+                        else if(GetArgument(args,0,num))
+                        {
+                            sse->SendRetry((uint32_t)num);
+                        }
+                    }
+                }
+
+                cse.back()->Push(gc, Undefined());
+                return false;
+            }
             else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance))
             {
                 auto& strm = std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance);
@@ -1234,6 +1278,18 @@ namespace Tesses::CrossLang {
                     }
                     if(netStrm != nullptr)
                     {
+                        if(key == "SetMulticastMembership")
+                        {
+                            std::string ma;
+                            std::string ifaceIP = "0.0.0.0";
+                            if(GetArgument(args,0,ma))
+                            {
+                                GetArgument(args,1,ifaceIP);
+                                netStrm->SetMulticastMembership(ma,ifaceIP);
+                            }
+                            cse.back()->Push(gc, Undefined());
+                            return false;
+                        }
                         if(key == "GetPort")
                         {
                             cse.back()->Push(gc, (int64_t)netStrm->GetPort());
@@ -1623,6 +1679,8 @@ namespace Tesses::CrossLang {
                     auto myvfs = std::dynamic_pointer_cast<TObjectVFS>(vfs);
 
                     auto mountable = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::MountableFilesystem>(vfs);
+
+                   
                     if(myvfs != nullptr)
                     {
                         TDictionary* dict2;
@@ -1997,6 +2055,38 @@ namespace Tesses::CrossLang {
                         cse.back()->Push(gc, nullptr);
                         return false;
                     }
+                    if(key == "Stat")
+                    {
+                        Tesses::Framework::Filesystem::VFSPath path;
+                        
+                        if(GetArgumentAsPath(args,0,path))
+                        {
+                            Tesses::Framework::Filesystem::StatData data;
+                            if(vfs->Stat(path,data))
+                            {
+                                cse.back()->Push(gc, TDictionary::Create(ls,{
+                                    TDItem("BlockCount", (int64_t)data.BlockCount),
+                                    TDItem("BlockSize", (int64_t)data.BlockSize),
+                                    TDItem("Device", (int64_t)data.Device),
+                                    TDItem("DeviceId", (int64_t)data.DeviceId),
+                                    TDItem("GroupId", (int64_t)data.GroupId),
+                                    TDItem("HardLinks", (int64_t)data.HardLinks),
+                                    TDItem("Inode", (int64_t)data.Inode),
+                                    TDItem("LastAccess", std::make_shared<Tesses::Framework::Date::DateTime>(data.LastAccess)),
+                                    TDItem("LastModified", std::make_shared<Tesses::Framework::Date::DateTime>(data.LastModified)),
+                                    TDItem("LastStatus", std::make_shared<Tesses::Framework::Date::DateTime>(data.LastStatus)),
+                                    TDItem("Mode", (int64_t)data.Mode),
+                                    TDItem("Size", (int64_t)data.Size),
+                                    TDItem("UserId", (int64_t)data.UserId)
+                                }));
+                                return false;
+                            }
+                        }
+
+                        cse.back()->Push(gc, nullptr);
+                        return false;
+                    }
+                    
                     if(key == "StatVFS")
                     {
                         Tesses::Framework::Filesystem::VFSPath path;
@@ -2080,6 +2170,136 @@ namespace Tesses::CrossLang {
                 auto ttask = dynamic_cast<TTask*>(obj);
                 auto file = dynamic_cast<TFile*>(obj);
 
+                auto queryable = dynamic_cast<TQueryable*>(obj);
+
+                if(queryable != nullptr)
+                {
+                    if(key == "Skip")
+                    {
+                        int64_t count;
+                        if(GetArgument(args,0,count))
+                        {
+                            cse.back()->Push(gc, queryable->Skip(ls,count));
+                            return false;
+                        }
+                    }
+                    if(key == "Take")
+                    {
+                        int64_t count;
+                        if(GetArgument(args,0,count))
+                        {
+                            cse.back()->Push(gc, queryable->Take(ls,count));
+                            return false;
+                        }
+                    }
+                    if(key == "SkipWhile")
+                    {
+                        TCallable* callable;
+                        if(GetArgumentHeap(args, 0, callable))
+                        {
+                            cse.back()->Push(gc, queryable->SkipWhile(ls,callable));
+                            return false;
+                        }
+                    }
+                    if(key == "TakeWhile")
+                    {
+                        TCallable* callable;
+                        if(GetArgumentHeap(args, 0, callable))
+                        {
+                            cse.back()->Push(gc, queryable->TakeWhile(ls,callable));
+                            return false;
+                        }
+                    }
+                    if(key == "Select")
+                    {
+                        TCallable* callable;
+                        if(GetArgumentHeap(args, 0, callable))
+                        {
+                            cse.back()->Push(gc, queryable->Select(ls,callable));
+                            return false;
+                        }
+                    }
+                    if(key == "Where")
+                    {
+                        TCallable* callable;
+                        if(GetArgumentHeap(args, 0, callable))
+                        {
+                            cse.back()->Push(gc, queryable->Where(ls,callable));
+                            return false;
+                        }
+                    }
+                    if(key == "ToList")
+                    {
+                        cse.back()->Push(gc, queryable->ToList(ls));
+                        return false;
+                    }
+
+                    
+
+                    if(key == "ForEach")
+                    {
+                        TCallable* call;
+                        if(GetArgumentHeap(args,0,call))
+                        {
+                            queryable->ForEach(gc, call);
+                        }
+
+                        cse.back()->Push(gc, Undefined());
+                        return false;
+                    }
+
+                   
+
+                    if(key == "Count")
+                    {
+                        TCallable* call;
+                        if(GetArgumentHeap(args,0,call))
+                        {
+                            cse.back()->Push(gc, queryable->Count(gc, call));
+                            return false;
+                        }
+                        else {
+                            cse.back()->Push(gc, queryable->Count(gc));
+                            return false;
+                        }
+                    }
+                    if(key == "Contains")
+                    {
+                        if(!args.empty())
+                        {
+                            cse.back()->Push(gc, queryable->Contains(gc, args[0]));
+                            return false;
+                        }
+                    }
+                    if(key == "All")
+                    {
+                        TCallable* call;
+                        if(GetArgumentHeap(args,0,call))
+                        {
+                            cse.back()->Push(gc, queryable->All(gc, call));
+                            return false;
+                        }
+                    }
+                    if(key == "Any")
+                    {
+                        TCallable* call;
+                        if(GetArgumentHeap(args,0,call))
+                        {
+                            cse.back()->Push(gc, queryable->Any(gc, call));
+                            return false;
+                        }
+                    }
+
+                    if(key == "GetEnumerator")
+                    {
+                        cse.back()->Push(gc, queryable->GetEnumerator(ls));
+                        return false;
+                    }
+
+                    cse.back()->Push(gc, Undefined());
+                    return false;
+                }
+
                 if(file != nullptr)
                 {
                     if(key == "MetadataDecode")
@@ -2198,9 +2418,36 @@ namespace Tesses::CrossLang {
                     }
                     if(key == "RegisterEverything")
                     {
+                        if(rootEnv->permissions.locked)
+                        {
+                            cse.back()->Push(gc,nullptr);
+                            return false;
+                        }
+
                         if(myEnv->permissions.canRegisterEverything)
                         {
-                            TStd::RegisterStd(gc, rootEnv);
+                            std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
+                            if(GetArgument(args,0, vfs))
+                            {
+
+                                auto rfs = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
+                                if(rfs)
+                                {
+                                    TStd::RegisterStd(gc,rootEnv, rfs);
+                                    cse.back()->Push(gc,nullptr);
+                                    return false;
+                                }
+                            }
+                            
+                            if(myEnv->permissions.localfs)
+                                TStd::RegisterStd(gc, rootEnv, std::make_shared<Tesses::Framework::Filesystem::RelativeFilesystem>(myEnv->permissions.localfs->GetVFS(),myEnv->permissions.localfs->GetWorking()));
+                            else
+                                TStd::RegisterStd(gc, rootEnv, nullptr);
+                            
+                            
+
+                            cse.back()->Push(gc,nullptr);
+                            return false;
                         } 
                         else
                         {
@@ -2218,7 +2465,15 @@ namespace Tesses::CrossLang {
 
 
                         if(myEnv->permissions.canRegisterIO && !rootEnv->permissions.locked)
-                            TStd::RegisterIO(gc, rootEnv, myEnv->permissions.canRegisterLocalFS);
+                        {
+                            if(myEnv->permissions.localfs)
+                            {
+                                TStd::RegisterIO(gc, rootEnv, std::make_shared<Tesses::Framework::Filesystem::RelativeFilesystem>(myEnv->permissions.localfs->GetVFS(),myEnv->permissions.localfs->GetWorking()));
+                            }
+                            else {
+                                TStd::RegisterIO(gc, rootEnv, nullptr);
+                            }
+                        }
                         
                         if(myEnv->permissions.canRegisterJSON && !rootEnv->permissions.locked)
                         TStd::RegisterJson(gc, rootEnv);
@@ -2293,11 +2548,29 @@ namespace Tesses::CrossLang {
                     }
                     if(key == "RegisterIO")
                     {
+                        std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
+                        
                         bool r;
                         if(GetArgument(args,0,r))
                         {
                             if((myEnv->permissions.canRegisterEverything || myEnv->permissions.canRegisterIO) && !rootEnv->permissions.locked)
-                                TStd::RegisterIO(gc, rootEnv, myEnv->permissions.canRegisterLocalFS ? r : false);
+                            {
+                                if(myEnv->permissions.localfs)
+                                {
+                                    TStd::RegisterIO(gc, rootEnv, std::make_shared<Tesses::Framework::Filesystem::RelativeFilesystem>(myEnv->permissions.localfs->GetVFS(),myEnv->permissions.localfs->GetWorking()));
+                                }
+                                else {
+                                    TStd::RegisterIO(gc, rootEnv, nullptr);
+                                }
+                            }
+                        }
+                        if(GetArgument(args,0,vfs))
+                        {
+                            auto rfs = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
+                            if(rfs && (myEnv->permissions.canRegisterEverything || myEnv->permissions.canRegisterIO) && !rootEnv->permissions.locked)
+                            {
+                                TStd::RegisterIO(gc, rootEnv, rfs);
+                            }
                         }
                         cse.back()->Push(gc,nullptr);
                         return false;

src/vm/bc/getfield.cpp

@@ -10,7 +10,7 @@
 #include <sstream>
 #include <variant>
 namespace Tesses::CrossLang {
-    bool InterperterThread::GetField(GC* gc)
+    bool InterperterThread::GetField(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -47,10 +47,52 @@ namespace Tesses::CrossLang {
                 cse.back()->Push(gc, Undefined());
                 return false;
             }
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(instance))
+            {
+                auto timer = std::get<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(instance);
+                if(timer)
+                {
+                    if(key == "Interval")
+                    {
+                        cse.back()->Push(gc, timer->GetIntervalMilliseconds());
+                        return false;
+                    }    
+                    if(key == "Enabled")
+                    {
+                        cse.back()->Push(gc, timer->GetEnabled());
+                        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);
+                auto relative = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
+                auto myFS = std::dynamic_pointer_cast<TObjectVFS>(vfs);
+                if(relative)
+                {
+                    if(key == "Working")
+                    {
+                        cse.back()->Push(gc, relative->GetWorking());
+                        return false;
+                    }
+                    if(key == "Filesystem")
+                    {
+                        cse.back()->Push(gc, relative->GetVFS());
+                        return false;
+                    }
+                }
+                if(myFS)
+                {
+                    if(key == "Inner")
+                    {
+                        cse.back()->Push(gc, myFS->obj);
+                        return false;
+                    }
+                }
                 if(tmpFS)
                 {
                     if(key == "TempDirectoryName")

src/vm/bc/setfield.cpp

@@ -11,7 +11,11 @@
 #include <variant>
 namespace Tesses::CrossLang {
      
-    bool InterperterThread::SetField(GC* gc)
+    static void empty()
+    {
+
+    }
+    bool InterperterThread::SetField(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -30,6 +34,60 @@ namespace Tesses::CrossLang {
             }
 
             std::string key = std::get<std::string>(_key);
+            if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(instance))
+            {
+                auto handle = std::get<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(instance);
+                if(handle)
+                {
+                    int64_t ms;
+                    bool b;
+                    if(key == "Enabled" && GetObject(value,b))
+                    {
+
+                        handle->SetEnabled(b);
+
+                        cse.back()->Push(gc,b);
+                        return false;
+                    }
+
+                    if(key == "Interval" && GetObject(value, ms))
+                    {
+                        handle->SetIntervalFromMilliseconds(ms);
+
+                        cse.back()->Push(gc,ms);
+                        return false;
+                    }
+                    if(key == "Callback")
+                    {
+                        TCallable* callable;
+                        if(GetObjectHeap(value,callable))
+                        {
+
+                            auto obj = CreateMarkedTObject(ls.GetGC(), callable);
+                            handle->SetCallback([obj]()->void {
+                                TCallable* callable;
+                                if(GetObjectHeap(obj->GetObject(), callable))
+                                {
+                                    GCList ls(obj->GetGC());
+                                    callable->Call(ls,{});
+                                }
+                            });
+                            cse.back()->Push(gc, callable);
+                            return false;
+                        }
+                        else
+                        {
+                            handle->SetCallback(empty);
+                            cse.back()->Push(gc, nullptr);
+                            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);
@@ -58,6 +116,34 @@ namespace Tesses::CrossLang {
                 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 relative = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
+                
+                if(relative)
+                {
+                    if(key == "Working")
+                    {
+                        Tesses::Framework::Filesystem::VFSPath path;
+                        if(GetObjectAsPath(value,path))
+                        {
+                            if(path.relative)
+                            {
+                                relative->SetWorking(path.MakeAbsolute(relative->GetWorking()));
+                            }
+                            else {
+                                relative->SetWorking(path);
+                            }
+                        }
+                    }
+                }
+
+
+                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);
@@ -177,11 +263,19 @@ namespace Tesses::CrossLang {
                 auto netStrm = std::dynamic_pointer_cast<Tesses::Framework::Streams::NetworkStream>(strm);
                 if(netStrm != nullptr)
                 {
+                    int64_t n0;
                     bool bc;
                     if(key == "Broadcast" && GetObject(value,bc))
                         netStrm->SetBroadcast(bc);
                     if(key == "NoDelay" && GetObject(value,bc))
                         netStrm->SetNoDelay(bc);
+                    if(key == "ReuseAddress" && GetObject(value,bc))
+                        netStrm->SetReuseAddress(bc);
+                    if(key == "ReusePort" && GetObject(value,bc))
+                        netStrm->SetReusePort(bc);
+                    if(key == "MulticastTTL" && GetObject(value,n0))
+                        netStrm->SetMulticastTTL((uint8_t)n0);
+                    
                 }
                 stk->Push(gc, Undefined());
                 return false;

src/vm/bc/sub.cpp

@@ -10,7 +10,7 @@
 #include <sstream>
 #include <variant>
 namespace Tesses::CrossLang {
-    bool InterperterThread::Sub(GC* gc)
+    bool InterperterThread::Sub(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);

src/vm/bc/tostring.cpp

@@ -10,7 +10,7 @@
 #include <sstream>
 #include <variant>
 namespace Tesses::CrossLang {
-     std::string ToString(GC* gc, TObject o)
+     std::string ToString(std::shared_ptr<GC> gc, TObject o)
     {
         if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(o))
         {

src/vm/filereader.cpp

@@ -11,7 +11,7 @@ namespace Tesses::CrossLang
     {
         TFile* f = new TFile();
         f->icon = -1;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(f);
         _gc->Watch(f);
         return f;
@@ -20,7 +20,7 @@ namespace Tesses::CrossLang
     {
         TFile* f = new TFile();
         f->icon=-1;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(f);
         _gc->Watch(f);
         return f;
@@ -35,7 +35,7 @@ namespace Tesses::CrossLang
     TFileChunk* TFileChunk::Create(GCList& ls)
     {
         TFileChunk* chk = new TFileChunk();
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(chk);
         _gc->Watch(chk);
         return chk;
@@ -43,7 +43,7 @@ namespace Tesses::CrossLang
     TFileChunk* TFileChunk::Create(GCList* ls)
     {
         TFileChunk* chk = new TFileChunk();
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(chk);
         _gc->Watch(chk);
         return chk;
@@ -280,7 +280,7 @@ namespace Tesses::CrossLang
         return nullptr;
     }
 
-    void TFile::Load(GC* gc, std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
+    void TFile::Load(std::shared_ptr<GC> gc, std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
     {
         
         uint8_t main_header[18];

src/vm/gc.cpp

@@ -24,11 +24,6 @@ namespace Tesses::CrossLang
     GC::GC()
     {
 
-        this->tpool=new Tesses::Framework::Lazy<Tesses::Framework::Threading::ThreadPool*>([]()->Tesses::Framework::Threading::ThreadPool*{
-            auto threads = Tesses::Framework::Threading::ThreadPool::GetNumberOfCores();
-            if(threads < 4) threads=4;
-            return new Tesses::Framework::Threading::ThreadPool(threads);
-        },[](Tesses::Framework::Threading::ThreadPool* p)->void{delete p;});
     }
     TDictionary* CreateThread(GCList& ls, TCallable* callable,bool detached)
     {
@@ -76,7 +71,7 @@ namespace Tesses::CrossLang
 
         ls.GetGC()->BarrierEnd();
         th->thrd =new Thread([th]()->void {
-            GC* gc=th->gc;
+            std::shared_ptr<GC> gc=th->gc;
             GCList ls(gc);
             ls.Add(th);
             th->hasInit=true;
@@ -91,6 +86,12 @@ namespace Tesses::CrossLang
     }
     void GC::Start()
     {
+
+        this->tpool=new Tesses::Framework::Lazy<Tesses::Framework::Threading::ThreadPool*>([]()->Tesses::Framework::Threading::ThreadPool*{
+            auto threads = Tesses::Framework::Threading::ThreadPool::GetNumberOfCores();
+            if(threads < 4) threads=4;
+            return new Tesses::Framework::Threading::ThreadPool(threads);
+        },[](Tesses::Framework::Threading::ThreadPool* p)->void{delete p;});
         this->mtx=new Mutex();
         this->running = true;
         this->thrd = new Thread([this]()->void {
@@ -203,6 +204,7 @@ namespace Tesses::CrossLang
     {
         return this->tpool->GetValue();
     }
+
     void GC::UnsetRoot(TObject obj)
     {
         if(std::holds_alternative<THeapObjectHolder>(obj))
@@ -224,24 +226,29 @@ namespace Tesses::CrossLang
     GC::~GC()
     {
         GC::BarrierBegin();
+
         this->roots.clear();
         GC::BarrierEnd();
+
+
+
         this->running=false;
         this->thrd->Join();
         delete this->thrd;
         for(auto item : objects) delete item;
-        delete this->mtx;
+
         delete this->tpool;
+        delete this->mtx;
     }
 
-    void GC::RegisterEverythingCallback(std::function<void(GC* gc, TRootEnvironment* env)> cb)
+    void GC::RegisterEverythingCallback(std::function<void(std::shared_ptr<GC> gc, TRootEnvironment* env)> cb)
     {
         this->register_everything.push_back(cb);
     }
     void GC::RegisterEverything(TRootEnvironment* env)
     {
         for(auto item : this->register_everything)
-            item(this,env);
+            item(this->shared_from_this(),env);
     }
     void GC::Collect()
     {

src/vm/gclist.cpp

@@ -2,21 +2,15 @@
 
 namespace Tesses::CrossLang
 {
-    GCList::GCList(GC* gc)
+    GCList::GCList(std::shared_ptr<GC> gc)
     {
         gc->BarrierBegin();
         this->gc = gc;
         gc->SetRoot(this);
         gc->BarrierEnd();
     }
-    GCList::GCList(GC& gc)
-    {
-        gc.BarrierBegin();
-        this->gc = &gc;
-        gc.SetRoot(this);
-        gc.BarrierEnd();
-    }
-    GC* GCList::GetGC()
+    
+    std::shared_ptr<GC> GCList::GetGC()
     {
         return this->gc;
     }

src/vm/vm.cpp

@@ -36,9 +36,9 @@ namespace Tesses::CrossLang {
 
     #define TVM_HANDLER(hndl) if(hndl(gc)) goto execute
 
-    typedef bool (InterperterThread::*opcode)(GC* gc);
+    typedef bool (InterperterThread::*opcode)(std::shared_ptr<GC> gc);
 
-    bool InterperterThread::InterperterThread::Breakpoint(GC* gc)
+    bool InterperterThread::InterperterThread::Breakpoint(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -53,7 +53,7 @@ namespace Tesses::CrossLang {
         return false;
     }
     
-    bool InterperterThread::Times(GC* gc)
+    bool InterperterThread::Times(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -138,7 +138,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Divide(GC* gc)
+    bool InterperterThread::Divide(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -253,7 +253,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::Mod(GC* gc)
+    bool InterperterThread::Mod(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -340,7 +340,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Neg(GC* gc)
+    bool InterperterThread::Neg(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -414,7 +414,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::LNot(GC* gc)
+    bool InterperterThread::LNot(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -499,7 +499,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::BNot(GC* gc)
+    bool InterperterThread::BNot(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -571,7 +571,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Lt(GC* gc)
+    bool InterperterThread::Lt(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -691,7 +691,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Gt(GC* gc)
+    bool InterperterThread::Gt(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -812,7 +812,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Lte(GC* gc)
+    bool InterperterThread::Lte(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -933,7 +933,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Gte(GC* gc)
+    bool InterperterThread::Gte(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1056,7 +1056,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::Eq(GC* gc)
+    bool InterperterThread::Eq(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1242,7 +1242,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::NEq(GC* gc)
+    bool InterperterThread::NEq(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1420,7 +1420,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::LShift(GC* gc)
+    bool InterperterThread::LShift(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1491,7 +1491,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::RShift(GC* gc)
+    bool InterperterThread::RShift(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1563,7 +1563,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::BOr(GC* gc)
+    bool InterperterThread::BOr(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1635,7 +1635,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::XOr(GC* gc)
+    bool InterperterThread::XOr(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1707,7 +1707,7 @@ namespace Tesses::CrossLang {
  
         return false;
     }
-    bool InterperterThread::BAnd(GC* gc)
+    bool InterperterThread::BAnd(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -1812,7 +1812,7 @@ namespace Tesses::CrossLang {
         return false;
     }
     
-    bool InterperterThread::ExecuteFunction(GC* gc)
+    bool InterperterThread::ExecuteFunction(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -1889,7 +1889,7 @@ namespace Tesses::CrossLang {
         return false;
     }
     
-    bool InterperterThread::Yield(GC* gc)
+    bool InterperterThread::Yield(std::shared_ptr<GC> gc)
     {
         GCList ls(gc);
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -1902,7 +1902,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::ExecuteMethod(GC* gc)
+    bool InterperterThread::ExecuteMethod(std::shared_ptr<GC> gc)
     {
          GCList ls(gc);
          std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -1939,7 +1939,7 @@ namespace Tesses::CrossLang {
         return false;
     }
    
-    bool InterperterThread::GetVariable(GC* gc)
+    bool InterperterThread::GetVariable(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -1961,7 +1961,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::SetVariable(GC* gc)
+    bool InterperterThread::SetVariable(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2120,7 +2120,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::DeclareVariable(GC* gc)
+    bool InterperterThread::DeclareVariable(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2279,7 +2279,7 @@ namespace Tesses::CrossLang {
     }
   
 
-    bool InterperterThread::DeclareConstVariable(GC* gc)
+    bool InterperterThread::DeclareConstVariable(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2436,7 +2436,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::PushResourceStream(GC* gc)
+    bool InterperterThread::PushResourceStream(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2466,7 +2466,7 @@ namespace Tesses::CrossLang {
         return false;
     }
 
-    bool InterperterThread::PushResource(GC* gc)
+    bool InterperterThread::PushResource(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2495,7 +2495,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::Throw(GC* gc)
+    bool InterperterThread::Throw(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -2509,7 +2509,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::PushResourceDirectory(GC* gc)
+    bool InterperterThread::PushResourceDirectory(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         GCList ls(gc);
@@ -2524,7 +2524,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::JumpIfDefined(GC* gc)
+    bool InterperterThread::JumpIfDefined(std::shared_ptr<GC> gc)
     {
         
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2550,7 +2550,7 @@ namespace Tesses::CrossLang {
             throw VMException("Can't read jmpifdefined pc.");
         return false;
     }
-    bool InterperterThread::JumpIfBreak(GC* gc)
+    bool InterperterThread::JumpIfBreak(std::shared_ptr<GC> gc)
     {
         
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2576,7 +2576,7 @@ namespace Tesses::CrossLang {
         return false;
     }
 
-    bool InterperterThread::JumpIfContinue(GC* gc)
+    bool InterperterThread::JumpIfContinue(std::shared_ptr<GC> gc)
     {
         
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2601,7 +2601,7 @@ namespace Tesses::CrossLang {
             throw VMException("Can't read jmpifcontinue pc.");
         return false;
     }
-    bool InterperterThread::JumpUndefined(GC* gc)
+    bool InterperterThread::JumpUndefined(std::shared_ptr<GC> gc)
     {
         
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2626,7 +2626,7 @@ namespace Tesses::CrossLang {
             throw VMException("Can't read jmpundefined pc.");
         return false;
     }
-    bool InterperterThread::Jump(GC* gc)
+    bool InterperterThread::Jump(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2641,7 +2641,7 @@ namespace Tesses::CrossLang {
             throw VMException("Can't read jmp pc.");
         return false;
     }
-    bool InterperterThread::PushNull(GC* gc)
+    bool InterperterThread::PushNull(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2650,7 +2650,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,nullptr);
         return false;
     }
-    bool InterperterThread::PushBreak(GC* gc)
+    bool InterperterThread::PushBreak(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2659,7 +2659,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,TBreak());
         return false;
     }
-    bool InterperterThread::PushContinue(GC* gc)
+    bool InterperterThread::PushContinue(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2668,7 +2668,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,TContinue());
         return false;
     }
-     bool InterperterThread::PushUndefined(GC* gc)
+     bool InterperterThread::PushUndefined(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2677,7 +2677,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,Undefined());
         return false;
     }
-    bool InterperterThread::LineInfo(GC* gc)
+    bool InterperterThread::LineInfo(std::shared_ptr<GC> gc)
     {
         GCList ls(gc);
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2695,7 +2695,7 @@ namespace Tesses::CrossLang {
 
         return false;
     }
-      bool InterperterThread::PushFalse(GC* gc)
+      bool InterperterThread::PushFalse(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2704,7 +2704,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,false);
         return false;
     }
-      bool InterperterThread::PushTrue(GC* gc)
+      bool InterperterThread::PushTrue(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2713,7 +2713,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,true);
         return false;
     }
-    bool InterperterThread::CreateDictionary(GC* gc)
+    bool InterperterThread::CreateDictionary(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2723,11 +2723,11 @@ namespace Tesses::CrossLang {
         stk->Push(gc,dict);
         return false;
     }
-     bool InterperterThread::Nop(GC* gc)
+     bool InterperterThread::Nop(std::shared_ptr<GC> gc)
     {
         return false;
     }   
-    bool InterperterThread::AppendList(GC* gc)
+    bool InterperterThread::AppendList(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2760,7 +2760,7 @@ namespace Tesses::CrossLang {
                         gc->BarrierEnd();
         return false;
     }
-     bool InterperterThread::AppendDictionary(GC* gc)
+     bool InterperterThread::AppendDictionary(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2800,7 +2800,7 @@ namespace Tesses::CrossLang {
                         gc->BarrierEnd();
         return false;
     }
-     bool InterperterThread::CreateArray(GC* gc)
+     bool InterperterThread::CreateArray(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2810,7 +2810,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc,dict);
         return false;
     }
-    bool InterperterThread::Pop(GC* gc)
+    bool InterperterThread::Pop(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2819,7 +2819,7 @@ namespace Tesses::CrossLang {
         stk->Pop(ls);
         return false;
     }
-    bool InterperterThread::TryCatch(GC* gc)
+    bool InterperterThread::TryCatch(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2861,7 +2861,7 @@ namespace Tesses::CrossLang {
                         }
         return false;
     }
-    bool InterperterThread::JumpConditional(GC* gc)
+    bool InterperterThread::JumpConditional(std::shared_ptr<GC> gc)
     {
 
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2884,7 +2884,7 @@ namespace Tesses::CrossLang {
             throw VMException("Can't read jmpc pc.");
         return false;
     }
-    bool InterperterThread::PushClosure(GC* gc)
+    bool InterperterThread::PushClosure(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2912,7 +2912,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::PushScopelessClosure(GC* gc)
+    bool InterperterThread::PushScopelessClosure(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2941,7 +2941,7 @@ namespace Tesses::CrossLang {
         return false;
     }
     
-    bool InterperterThread::PushString(GC* gc)
+    bool InterperterThread::PushString(std::shared_ptr<GC> gc)
     {
         
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -2962,7 +2962,7 @@ namespace Tesses::CrossLang {
         return false;
     }
     
-    bool InterperterThread::PushLong(GC* gc)
+    bool InterperterThread::PushLong(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2978,7 +2978,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::PushChar(GC* gc)
+    bool InterperterThread::PushChar(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -2994,7 +2994,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::PushDouble(GC* gc)
+    bool InterperterThread::PushDouble(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
         if(!cse.empty())
@@ -3010,7 +3010,7 @@ namespace Tesses::CrossLang {
         }
         return false;
     }
-    bool InterperterThread::Return(GC* gc)
+    bool InterperterThread::Return(std::shared_ptr<GC> gc)
     {
 
 
@@ -3020,7 +3020,7 @@ namespace Tesses::CrossLang {
              stk->ip = (uint32_t)stk->callable->closure->code.size();
             return false;
     }
-    bool InterperterThread::ScopeBegin(GC* gc)
+    bool InterperterThread::ScopeBegin(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3034,7 +3034,7 @@ namespace Tesses::CrossLang {
         
         return false;
     }
-     bool InterperterThread::Defer(GC* gc)
+     bool InterperterThread::Defer(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3050,7 +3050,7 @@ namespace Tesses::CrossLang {
         
         return false;
     }
-     bool InterperterThread::Dup(GC* gc)
+     bool InterperterThread::Dup(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3062,7 +3062,7 @@ namespace Tesses::CrossLang {
 
         return false;
     }
-    bool InterperterThread::ScopeEndTimes(GC* gc)
+    bool InterperterThread::ScopeEndTimes(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3097,7 +3097,7 @@ namespace Tesses::CrossLang {
         
         return false;
     }
-     bool InterperterThread::ScopeEnd(GC* gc)
+     bool InterperterThread::ScopeEnd(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3127,7 +3127,7 @@ namespace Tesses::CrossLang {
         
         return false;
     }
-    bool InterperterThread::PushRelativePath(GC* gc)
+    bool InterperterThread::PushRelativePath(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3138,7 +3138,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc, p);
         return false;
     }
-    bool InterperterThread::PushRootPath(GC* gc)
+    bool InterperterThread::PushRootPath(std::shared_ptr<GC> gc)
     {
         std::vector<CallStackEntry*>& cse=this->call_stack_entries;
 
@@ -3149,7 +3149,7 @@ namespace Tesses::CrossLang {
         stk->Push(gc, p);
         return false;
     }
-    bool InterperterThread::Illegal(GC* gc)
+    bool InterperterThread::Illegal(std::shared_ptr<GC> gc)
     {
 
 
@@ -3162,7 +3162,7 @@ namespace Tesses::CrossLang {
                     
     }
 
-    void InterperterThread::Execute(GC* gc)
+    void InterperterThread::Execute(std::shared_ptr<GC> gc)
     {
 
        std::vector<CallStackEntry*>& cse=this->call_stack_entries;
@@ -3342,7 +3342,7 @@ namespace Tesses::CrossLang {
         this->callable->Mark();
         for(auto item : this->stack) GC::Mark(item);
     }
-    void CallStackEntry::Push(GC* gc,TObject o)
+    void CallStackEntry::Push(std::shared_ptr<GC> gc,TObject o)
     {
         gc->BarrierBegin();
         this->stack.push_back(o);
@@ -3376,7 +3376,7 @@ namespace Tesses::CrossLang {
     InterperterThread* InterperterThread::Create(GCList& ls)
     {
         InterperterThread* it = new InterperterThread();
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(it);
         _gc->Watch(it);
         return it;
@@ -3384,7 +3384,7 @@ namespace Tesses::CrossLang {
     InterperterThread* InterperterThread::Create(GCList* ls)
     {
         InterperterThread* it = new InterperterThread();
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(it);
         _gc->Watch(it);
         return it;
@@ -3396,7 +3396,7 @@ namespace Tesses::CrossLang {
         cse->srcline = -1;
         cse->srcfile = "";
         cse->thread=nullptr;
-        GC* _gc = ls.GetGC();
+        std::shared_ptr<GC> _gc = ls.GetGC();
         ls.Add(cse);
         _gc->Watch(cse);
         return cse;
@@ -3409,7 +3409,7 @@ namespace Tesses::CrossLang {
         cse->srcline = -1;
         cse->srcfile = "";
         cse->thread=nullptr;
-        GC* _gc = ls->GetGC();
+        std::shared_ptr<GC> _gc = ls->GetGC();
         ls->Add(cse);
         _gc->Watch(cse);
         return cse;