tesses50/crosslang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Compare commits

base: tesses50:v0.0.3
Branches Tags
tesses50:master tesses50:development
tesses50:v0.0.5 tesses50:v0.0.4 tesses50:v0.0.3 tesses50:v0.0.2 tesses50:v0.0.1
...
compare: tesses50:37fd44fd781ceeb95630d5040e15877560a65214
Branches Tags
tesses50:development tesses50:master
tesses50:v0.0.5 tesses50:v0.0.4 tesses50:v0.0.3 tesses50:v0.0.2 tesses50:v0.0.1

6 Commits
v0.0.3 ... 37fd44fd78

Author SHA1 Message Date
Mike Nolan
37fd44fd78 Rework for git.tesses.org, GC* is std::shared_ptr maybe will fix crash during exit
All checks were successful
Build and Deploy on Tag / build-arch (push) Successful in 16m40s
Details
Build and Deploy on Tag / update-tap (push) Successful in 6m26s
Details
2026-04-30 17:05:53 -05:00
Mike Nolan
06f1aff2b4 Rework for git.tesses.org, GC* is std::shared_ptr maybe will fix crash during exit
Some checks failed
Build and Deploy on Tag / build-arch (push) Successful in 17m48s
Details
Build and Deploy on Tag / update-tap (push) Failing after 6m19s
Details
2026-04-30 16:30:32 -05:00
Mike Nolan
991f2a217d Rework for git.tesses.org, GC* is std::shared_ptr maybe will fix crash during exit
Some checks failed
Build and Deploy on Tag / update-tap (push) Has been cancelled
Details
Build and Deploy on Tag / build-arch (push) Has been cancelled
Details
2026-04-30 16:00:00 -05:00
Mike Nolan
fca18e63a6 Commit before replacing GC* with std::shared_ptr<GC> 2026-04-30 10:07:14 -05:00
Mike Nolan
63b00ebbcb Use alpine for Docker 2026-04-16 22:24:18 -05:00
Mike Nolan
7badbeb217 Use alpine for Docker 2026-04-16 22:18:53 -05:00
81 changed files with 1736 additions and 1507 deletions
Expand all files Collapse all files

85
.gitea/workflows/tag.yaml
View File

@@ -5,68 +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:
- 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 curl 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
prerelease: true
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
bash build-slims.sh
working-directory: ./Packaging/Linux
- name: Build for windows
run: bash build.sh
working-directory: ./Packaging/Windows
- uses: akkuman/gitea-release-action@v1
prerelease: true
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

23
.onedev-buildspec.yml
View File

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

2
CMakeLists.txt
View File

@@ -39,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})

25
Dockerfile
View File

@@ -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"]

2
Dockerfile.run
View File

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

39
Dockerfile.superslim
View File

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

8
Packaging/Linux/PKGBUILD
View File

@@ -1,16 +1,16 @@
# Maintainer: Mike Nolan <tesses@tesses.net>
pkgname=crosslang # '-bzr', '-git', '-hg' or '-svn'
pkgver=0.0.3
pkgver=0.0.4
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=0.0.2')
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

8
Packaging/Linux/build-arch.sh
View File

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

32
Packaging/Linux/build-slim.sh
View File

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

8
Packaging/Linux/build-slims.sh
View File

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

25
Packaging/Linux/build-tars.sh
View File

@@ -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 -DCMAKE_BUILD_TYPE=Release
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 -DCMAKE_RELEASE_TYPE=Release
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

38
Packaging/Linux/build-ubuntu-jammy.sh
View File

@@ -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 -DCMAKE_BUILD_TYPE=Release
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 -DCMAKE_BUILD_TYPE=Release
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

38
Packaging/Linux/build-ubuntu-plucky.sh
View File

@@ -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 -DCMAKE_BUILD_TYPE=Release
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 -DCMAKE_BUILD_TYPE=Release
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

8
Packaging/Linux/make-control.sh
View File

@@ -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"

13
Packaging/Linux/push-ubuntu-jammy.sh
View File

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

12
Packaging/Linux/push-ubuntu-plucky.sh
View File

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

2
Packaging/Linux/version.sh
View File

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

34
Packaging/Slim/build.sh Normal file
View File

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

10
Packaging/Windows/build.sh
View File

@@ -14,13 +14,3 @@ cpack -G NSIS
cpack -G ZIP
mv TessesCrossLang-*-win64.exe ../../../artifacts/crosslang-win64.exe
mv TessesCrossLang-*-win64.zip ../../../artifacts/crosslang-win64.zip
cmake -S ../.. -B build-x86-slim -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x86.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x86 -DCMAKE_BUILD_TYPE=Release -DCROSSLANG_ENABLE_SUPERSLIM=ON
cd build-x86-slim
make -j`nproc`
mv crosslang.exe ../../../artifacts/crosslang-slim-win32.exe
cd ..
cmake -S ../.. -B build-x64-slim -DCMAKE_TOOLCHAIN_FILE=`pwd`/WindowsToolchains/x64.cmake -DTESSESFRAMEWORK_FETCHCONTENT=ON -DTESSESFRAMEWORK_ENABLE_APPS=OFF -DTESSESFRAMEWORK_ENABLE_EXAMPLES=OFF -DTESSESFRAMEWORK_ENABLE_STATIC=ON -DTESSESFRAMEWORK_ENABLE_SHARED=OFF -DCMAKE_INSTALL_PREFIX=tmp-x64 -DCMAKE_BUILD_TYPE=Release -DCROSSLANG_ENABLE_SUPERSLIM=ON
cd build-x64-slim
make -j`nproc`
mv crosslang.exe ../../../artifacts/crosslang-slim-win64.exe

19
Packaging/edit-formula.sh Normal file
View File

@@ -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 \"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"

40
README.md
View File

@@ -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)
```

6
build-dvd.tcross
View File

@@ -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\")

3
changelog.md
View File

@@ -1,5 +1,8 @@
# Changelog
## 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

2
cmake/options.cmake
View File

@@ -15,4 +15,4 @@ option(CROSSLANG_CUSTOM_CONSOLE "Enable custom Console" OFF)
set(CROSSLANG_OFFLINE_SHELL_PACKAGE "" CACHE FILEPATH "Path to the shell package generated from https://onedev.site.tesses.net/CrossLang/CrossLangExtras")
set(CROSSLANG_OFFLINE_SHELL_PACKAGE "" CACHE FILEPATH "Path to the shell package generated from https://git.tesses.org/crosslangextras")

1
cmake/sources.cmake
View File

@@ -49,6 +49,7 @@ src/types/streamheapobject.cpp
src/types/class.cpp
src/types/classenvironment.cpp
src/types/random.cpp
src/types/relativefs.cpp
src/vm/filereader.cpp
src/vm/gc.cpp
src/vm/gclist.cpp

2
cmake/version.cmake
View File

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

376
include/CrossLang.hpp
View File

@@ -40,6 +40,53 @@ namespace Tesses::CrossLang {
using BitConverter = Tesses::Framework::Serialization::BitConverter;
constexpr std::string_view VMName = "CrossLangVM";
constexpr std::string_view VMHowToGet = "https://crosslang.tesseslanguage.com/";
class RelativeFilesystem : public Tesses::Framework::Filesystem::VFS
{
private:
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
Tesses::Framework::Filesystem::VFSPath path;
Tesses::Framework::Threading::Mutex mtx;
public:
RelativeFilesystem(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath working);
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);
void DeleteFile(Tesses::Framework::Filesystem::VFSPath path);
void CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath symlinkFile);
Tesses::Framework::Filesystem::VFSPathEnumerator EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path);
void CreateHardlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath newName);
void MoveFile(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest);
void MoveDirectory(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest);
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 SetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime lastWrite, Tesses::Framework::Date::DateTime lastAccess);
bool Stat(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatData& stat);
bool StatVFS(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatVFSData& vfsData);
void Chmod(Tesses::Framework::Filesystem::VFSPath path, uint32_t mode);
void Chown(Tesses::Framework::Filesystem::VFSPath path, uint32_t uid, uint32_t gid);
void Lock(Tesses::Framework::Filesystem::VFSPath path);
void Unlock(Tesses::Framework::Filesystem::VFSPath path);
Tesses::Framework::Filesystem::FIFOCreationResult CreateFIFO(Tesses::Framework::Filesystem::VFSPath path, uint32_t mod);
Tesses::Framework::Filesystem::VFSPath GetWorking();
void SetWorking(Tesses::Framework::Filesystem::VFSPath working);
std::shared_ptr<Tesses::Framework::Filesystem::VFS> GetVFS();
protected:
std::shared_ptr<Tesses::Framework::Filesystem::FSWatcher> CreateWatcher(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path);
};
/**
* @brief Escape a crosslang string (for generating source code)
*
@@ -1328,7 +1375,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 +1388,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 +1452,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 +1464,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 +1479,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 +1502,7 @@ class GC {
~GCList();
friend class GC;
};
@@ -1545,7 +1591,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 +1610,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 +1705,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 +1725,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 +1736,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 +1749,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 +1822,10 @@ class GC {
public:
EnvironmentPermissions();
Tesses::Framework::Filesystem::VFSPath sqliteOffsetPath;
std::shared_ptr<RelativeFilesystem> localfs;
bool canRegisterEverything;
bool canRegisterConsole;
bool canRegisterIO;
bool canRegisterLocalFS;
bool canRegisterNet;
bool canRegisterSqlite;
bool canRegisterVM;
@@ -1806,7 +1848,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 +1857,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 +1877,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<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<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 +1975,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 +1986,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 +1994,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 +2008,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 +2024,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 +2035,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 +2048,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 +2058,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 +2070,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 +2088,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 +2105,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 +2127,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 +2141,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 +2226,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 +2235,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 +2269,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 +2388,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 +2397,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 +2406,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 +2446,7 @@ class GC {
std::atomic<bool> detached;
TCallable* callable;
TObject returnValue;
GC* gc;
std::shared_ptr<GC> gc;
void Mark()
@@ -2445,7 +2484,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 +2577,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 +2596,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 +2616,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 +2625,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,19 +2640,17 @@ 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);

2
pkgconfig/CMakeLists.txt
View File

@@ -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")

2
src/compiler/parser.cpp
View File

@@ -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;

15
src/crosslangcompiler.cpp
View File

@@ -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;
}

11
src/markedtobject.cpp
View File

@@ -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);

11
src/program_lib/crosslang.cpp
View File

@@ -15,7 +15,8 @@ static bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared
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)
@@ -34,13 +35,14 @@ static bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared
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::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.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)
@@ -89,7 +91,8 @@ TObject CrossLangShell(GCList& ls, std::vector<std::string>& argv)
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)

15
src/program_lib/crosslangcompiler.cpp
View File

@@ -212,15 +212,15 @@ void CrossLangCompiler(std::vector<std::string>& 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();
std::shared_ptr<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 @@ void CrossLangCompiler(std::vector<std::string>& argv)
gen.Save(strm);
}
if(gc != nullptr)
{
delete ls;
delete gc;
}
}
}

2
src/program_lib/crosslanginterperter.cpp
View File

@@ -9,7 +9,7 @@ using namespace Tesses::Framework::Filesystem;
namespace Tesses::CrossLang::Programs {
TObject CrossLangInterperter(GCList& ls,TRootEnvironment* env,std::vector<std::string>& argv)
{
GC* gc = ls.GetGC();
std::shared_ptr<GC> gc = ls.GetGC();
if(argv.size() > 1)
{
std::ifstream strm(argv[1],std::ios_base::in|std::ios_base::binary);

4
src/programs/crosslang.cpp
View File

@@ -8,8 +8,8 @@ int main(int argc, char** argv)
TF_InitWithConsole();
if(argc > 0)
TF_AllowPortable(argv[0]);
GC gc;
gc.Start();
std::shared_ptr<GC> gc= std::make_shared<GC>();
gc->Start();
GCList ls(gc);

7
src/programs/crosslanginterperter.cpp
View File

@@ -6,16 +6,17 @@
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();
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);
TStd::RegisterStd(gc,env);
std::vector<std::string> args(argc);
for(int i = 0; i < argc; i++)

7
src/programs/crosslangvm.cpp
View File

@@ -6,16 +6,17 @@
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();
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);
TStd::RegisterStd(gc,env);
std::vector<std::string> args(argc);
for(int i = 0; i < argc; i++)

78
src/programs/slim.cpp
View File

@@ -26,16 +26,20 @@ int main(int argc, char** argv)
args[i] = argv[i];
if(programName == "crossint")
{
GC gc;
gc.Start();
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);
TStd::RegisterStd(gc,env);
auto res= Programs::CrossLangInterperter(ls, env, args);
int64_t myi64;
if(GetObject(res,myi64))
GetObject(res,myi64);
return (int)myi64;
return 0;
}
else if(programName == "crossc")
{
@@ -71,33 +75,38 @@ int main(int argc, char** argv)
}
else if(programName == "crossvm")
{
GC gc;
gc.Start();
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);
TStd::RegisterStd(gc,env);
auto res= Programs::CrossLangVM(ls, env, args);
int64_t myi64;
if(GetObject(res,myi64))
GetObject(res,myi64);
return (int)myi64;
return 0;
}
else if(args.size() > 1)
{
if(args[1] == "crossint")
{
int64_t myi64=0;
args.erase(args.begin());
GC gc;
gc.Start();
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);
TStd::RegisterStd(gc,env);
auto res= Programs::CrossLangInterperter(ls, env, args);
int64_t myi64;
if(GetObject(res,myi64))
GetObject(res,myi64);
return (int)myi64;
return 0;
}
else if(args[1] == "crossc")
{
@@ -136,29 +145,32 @@ int main(int argc, char** argv)
}
else if(args[1] == "crossvm")
{
int64_t myi64=0;
args.erase(args.begin());
GC gc;
gc.Start();
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);
TStd::RegisterStd(gc,env);
auto res= Programs::CrossLangVM(ls, env, args);
int64_t myi64;
if(GetObject(res,myi64))
GetObject(res,myi64);
return (int)myi64;
return 0;
}
}
GC gc;
gc.Start();
{
int64_t myi64=0;
std::shared_ptr<GC> gc= std::make_shared<GC>();
gc->Start();
GCList ls(gc);
auto res= Programs::CrossLangShell(ls, args);
int64_t myi64;
if(GetObject(res,myi64))
return (int)myi64;
return 0;
return 0;
GetObject(res,myi64);
return (int)myi64;
}
}

2
src/runtime_methods/class.cpp
View File

@@ -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;

2
src/runtime_methods/console.cpp
View File

@@ -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)

2
src/runtime_methods/crypto.cpp
View File

@@ -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;

2
src/runtime_methods/dictionary.cpp
View File

@@ -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;

2
src/runtime_methods/env.cpp
View File

@@ -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;

2
src/runtime_methods/helpers.cpp
View File

@@ -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);

77
src/runtime_methods/io.cpp
View File

@@ -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<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<RelativeFilesystem> fs)
{
env->permissions.canRegisterIO=true;
env->permissions.canRegisterLocalFS = enableLocalFilesystem;
env->permissions.localfs = fs;
GCList ls(gc);
gc->BarrierBegin();
@@ -323,14 +306,36 @@ 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))
{
fs->SetWorking(path);
}
return path;
});
}
dict->DeclareFunction(gc, "ReadAllText","Read all text from file", {"fs","filename"},FS_ReadAllText);

2
src/runtime_methods/json.cpp
View File

@@ -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;

72
src/runtime_methods/net.cpp
View File

@@ -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 {

2
src/runtime_methods/ogc.cpp
View File

@@ -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)

2
src/runtime_methods/path.cpp
View File

@@ -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;

33
src/runtime_methods/process.cpp
View File

@@ -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))

2
src/runtime_methods/sqlite.cpp
View File

@@ -150,7 +150,7 @@ namespace Tesses::CrossLang {
}
#endif
void TStd::RegisterSqlite(GC* gc,TRootEnvironment* env)
void TStd::RegisterSqlite(std::shared_ptr<GC> gc,TRootEnvironment* env)
{
env->permissions.canRegisterSqlite=true;

67
src/runtime_methods/std.cpp
View File

@@ -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);
@@ -641,10 +641,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 +747,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 +864,20 @@ namespace Tesses::CrossLang
auto vfs = std::get<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(_obj);
if(vfs != nullptr)
{
auto rfs = std::dynamic_pointer_cast<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)
{
auto fs=rfs->GetVFS();
if(fs)
{
return GetObjectTypeString(fs);
}
return "RelativeFilesystem";
}
if(localVFS != nullptr) return "LocalFilesystem";
if(subFS != nullptr) return "SubdirFilesystem";
if(mountableVFS != nullptr) return "MountableFilesystem";
@@ -900,6 +909,7 @@ 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);
if(rootEnv != nullptr) return "RootEnvironment";
if(subEnv != nullptr) return "SubEnvironment";
@@ -920,6 +930,7 @@ namespace Tesses::CrossLang
if(byteArray != nullptr) return "ByteArray";
if(native != nullptr) return "Native";
if(any != nullptr) return "Any";
if(file != nullptr) return "File";
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,34 @@ 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);
}
void TStd::RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment* env)
{
GCList ls(gc);
@@ -1328,10 +1364,9 @@ namespace Tesses::CrossLang
newTypes->DeclareFunction(gc, "MemoryStream","Create a memory stream",{"writable"}, New_MemoryStream);
newTypes->DeclareFunction(gc, "Filesystem","Create filesystem", {"fs"},New_Filesystem);
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;
@@ -1482,14 +1517,18 @@ 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<RelativeFilesystem>(Tesses::Framework::Filesystem::LocalFS, Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory()));
}
void TStd::RegisterStd(std::shared_ptr<GC> gc, TRootEnvironment* env,std::shared_ptr<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);

2
src/runtime_methods/uuid.cpp
View File

@@ -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");

2
src/runtime_methods/vm.cpp
View File

@@ -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);

4
src/types/any.cpp
View File

@@ -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;

8
src/types/associativearray.cpp
View File

@@ -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();

8
src/types/async.cpp
View File

@@ -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);

3
src/types/class.cpp
View File

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

4
src/types/classenvironment.cpp
View File

@@ -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;

8
src/types/closure.cpp
View File

@@ -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;

28
src/types/dictionary.cpp
View File

@@ -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,34 +153,22 @@ 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();
@@ -216,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;
@@ -224,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;

78
src/types/embed.cpp
View File

@@ -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();

48
src/types/ittr.cpp
View File

@@ -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;
@@ -162,7 +162,7 @@ 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;
@@ -171,12 +171,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 +189,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 +199,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 +248,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 +258,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 +291,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 +301,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 +338,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 +348,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 +384,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 +394,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)
{

12
src/types/list.cpp
View File

@@ -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;

6
src/types/native.cpp
View File

@@ -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;

275
src/types/relativefs.cpp Normal file
View File

@@ -0,0 +1,275 @@
#include "CrossLang.hpp"
namespace Tesses::CrossLang
{
RelativeFilesystem::RelativeFilesystem(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath working)
{
this->vfs = vfs;
this->path = working;
}
std::shared_ptr<Tesses::Framework::Streams::Stream> RelativeFilesystem::OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode)
{
if(path.relative)
{
return this->vfs->OpenFile(path.MakeAbsolute(GetWorking()), mode);
}
else
{
return this->vfs->OpenFile(path,mode);
}
}
void RelativeFilesystem::CreateDirectory(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
this->vfs->CreateDirectory(path.MakeAbsolute(GetWorking()));
}
else
{
this->vfs->CreateDirectory(path);
}
}
void RelativeFilesystem::DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
this->vfs->DeleteDirectory(path.MakeAbsolute(GetWorking()));
}
else
{
this->vfs->DeleteDirectory(path);
}
}
void RelativeFilesystem::DeleteFile(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
this->vfs->DeleteFile(path.MakeAbsolute(GetWorking()));
}
else
{
this->vfs->DeleteFile(path);
}
}
void RelativeFilesystem::CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath symlinkFile)
{
if(symlinkFile.relative)
{
this->vfs->CreateSymlink(existingFile,symlinkFile.MakeAbsolute(GetWorking()));
}
else
{
this->vfs->CreateSymlink(existingFile, symlinkFile);
}
}
Tesses::Framework::Filesystem::VFSPathEnumerator RelativeFilesystem::EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
return this->vfs->EnumeratePaths(path.MakeAbsolute(GetWorking()));
}
else
{
return this->vfs->EnumeratePaths(path);
}
}
void RelativeFilesystem::CreateHardlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath newName)
{
auto working = GetWorking();
if(existingFile.relative)
{
existingFile = existingFile.MakeAbsolute(working);
existingFile = existingFile.CollapseRelativeParents();
}
if(newName.relative)
{
newName = newName.MakeAbsolute(working);
newName = newName.CollapseRelativeParents();
}
this->vfs->CreateHardlink(existingFile, newName);
}
void RelativeFilesystem::MoveFile(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest)
{
auto working = GetWorking();
if(src.relative)
{
src = src.MakeAbsolute(working);
src = src.CollapseRelativeParents();
}
if(dest.relative)
{
dest = dest.MakeAbsolute(working);
dest = dest.CollapseRelativeParents();
}
this->vfs->MoveFile(src, dest);
}
void RelativeFilesystem::MoveDirectory(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest)
{
auto working = GetWorking();
if(src.relative)
{
src = src.MakeAbsolute(working);
src = src.CollapseRelativeParents();
}
if(dest.relative)
{
dest = dest.MakeAbsolute(working);
dest = dest.CollapseRelativeParents();
}
this->vfs->MoveFile(src, dest);
}
Tesses::Framework::Filesystem::VFSPath RelativeFilesystem::ReadLink(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
return this->vfs->ReadLink(path.MakeAbsolute(GetWorking()));
}
else
{
return this->vfs->ReadLink(path);
}
}
std::string RelativeFilesystem::VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path)
{
return this->vfs->VFSPathToSystem(path);
}
Tesses::Framework::Filesystem::VFSPath RelativeFilesystem::SystemToVFSPath(std::string path)
{
return this->vfs->SystemToVFSPath(path);
}
void RelativeFilesystem::SetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime lastWrite, Tesses::Framework::Date::DateTime lastAccess)
{
if(path.relative)
{
this->vfs->SetDate(path.MakeAbsolute(GetWorking()), lastWrite,lastAccess);
}
else
{
this->vfs->SetDate(path,lastWrite,lastAccess);
}
}
bool RelativeFilesystem::Stat(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatData& stat)
{
if(path.relative)
{
return this->vfs->Stat(path.MakeAbsolute(GetWorking()), stat);
}
else
{
return this->vfs->Stat(path,stat);
}
}
bool RelativeFilesystem::StatVFS(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Filesystem::StatVFSData& vfsData)
{
if(path.relative)
{
return this->vfs->StatVFS(path.MakeAbsolute(GetWorking()), vfsData);
}
else
{
return this->vfs->StatVFS(path,vfsData);
}
}
void RelativeFilesystem::Chmod(Tesses::Framework::Filesystem::VFSPath path, uint32_t mode)
{
if(path.relative)
{
this->vfs->Chmod(path.MakeAbsolute(GetWorking()), mode);
}
else
{
this->vfs->Chmod(path,mode);
}
}
void RelativeFilesystem::Chown(Tesses::Framework::Filesystem::VFSPath path, uint32_t uid, uint32_t gid)
{
if(path.relative)
{
this->vfs->Chown(path.MakeAbsolute(GetWorking()), uid, gid);
}
else
{
this->vfs->Chown(path,uid,gid);
}
}
void RelativeFilesystem::Lock(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
this->vfs->Lock(path.MakeAbsolute(GetWorking()));
}
else
{
this->vfs->Lock(path);
}
}
void RelativeFilesystem::Unlock(Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
this->vfs->Unlock(path.MakeAbsolute(GetWorking()));
}
else
{
this->vfs->Unlock(path);
}
}
Tesses::Framework::Filesystem::FIFOCreationResult RelativeFilesystem::CreateFIFO(Tesses::Framework::Filesystem::VFSPath path, uint32_t mod)
{
if(path.relative)
{
return this->vfs->CreateFIFO(path.MakeAbsolute(GetWorking()), mod);
}
else
{
return this->vfs->CreateFIFO(path, mod);
}
}
Tesses::Framework::Filesystem::VFSPath RelativeFilesystem::GetWorking()
{
mtx.Lock();
auto path = this->path;
mtx.Unlock();
return path;
}
void RelativeFilesystem::SetWorking(Tesses::Framework::Filesystem::VFSPath working)
{
mtx.Lock();
this->path = working;
mtx.Unlock();
}
std::shared_ptr<Tesses::Framework::Filesystem::VFS> RelativeFilesystem::GetVFS()
{
return this->vfs;
}
std::shared_ptr<Tesses::Framework::Filesystem::FSWatcher> RelativeFilesystem::CreateWatcher(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path)
{
if(path.relative)
{
return Tesses::Framework::Filesystem::FSWatcher::Create(vfs, path.MakeAbsolute(GetWorking()));
}
else
{
return Tesses::Framework::Filesystem::FSWatcher::Create(vfs,path);
}
}
}

20
src/types/rootenvironment.cpp
View File

@@ -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)
{

2
src/types/streamheapobject.cpp
View File

@@ -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);

28
src/types/subenvironment.cpp
View File

@@ -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();
}
};

376
src/types/vfsheapobject.cpp
View File

@@ -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;

2
src/vm/bc/add.cpp
View File

@@ -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);

2
src/vm/bc/equals.cpp
View File

@@ -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))

121
src/vm/bc/executemethod2.cpp
View File

@@ -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;
}
}
@@ -1199,6 +1199,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 +1276,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());
@@ -1997,6 +2051,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;
@@ -2198,9 +2284,10 @@ namespace Tesses::CrossLang {
}
if(key == "RegisterEverything")
{
if(myEnv->permissions.canRegisterEverything)
if(myEnv->permissions.canRegisterEverything && myEnv->permissions.localfs)
{
TStd::RegisterStd(gc, rootEnv);
TStd::RegisterStd(gc, rootEnv, std::make_shared<RelativeFilesystem>(myEnv->permissions.localfs->GetVFS(),myEnv->permissions.localfs->GetWorking()));
}
else
{
@@ -2218,7 +2305,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<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);
@@ -2297,7 +2392,15 @@ namespace Tesses::CrossLang {
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<RelativeFilesystem>(myEnv->permissions.localfs->GetVFS(),myEnv->permissions.localfs->GetWorking()));
}
else {
TStd::RegisterIO(gc, rootEnv, nullptr);
}
}
}
cse.back()->Push(gc,nullptr);
return false;

21
src/vm/bc/getfield.cpp
View File

@@ -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,6 +47,25 @@ 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);

68
src/vm/bc/setfield.cpp
View File

@@ -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);
@@ -177,11 +235,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;

2
src/vm/bc/sub.cpp
View File

@@ -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);

2
src/vm/bc/tostring.cpp
View File

@@ -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))
{

10
src/vm/filereader.cpp
View File

@@ -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];

25
src/vm/gc.cpp
View File

@@ -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()
{

12
src/vm/gclist.cpp
View File

@@ -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;
}

142
src/vm/vm.cpp
View File

@@ -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;