diff options
| author | Sergio Garcia Murillo <sergio.garcia.murillo@gmail.com> | 2021-11-29 16:12:38 +0100 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2021-11-29 16:12:38 +0100 |
| commit | 975a36d5a55d69fdd96693e5f8e3f9ac559f70a7 (patch) | |
| tree | d3a027a098f0a093f7435770fea91e1a445deb36 | |
| parent | 56e7455af91911c06210cf551729df61a428e5a6 (diff) | |
| parent | 0304bdb82baaf5da94b6273c93e2623f1522a2a0 (diff) | |
| download | swig-975a36d5a55d69fdd96693e5f8e3f9ac559f70a7.tar.gz | |
Merge branch 'fix-cast' into master
537 files changed, 6390 insertions, 29139 deletions
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 000000000..ab8c68d1f --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,430 @@ +name: CI + +on: + push: + paths-ignore: + - 'CHANGES*' + - 'Doc/**' + - 'appveyor.yml' + pull_request: + branches: master + paths-ignore: + - 'CHANGES*' + - 'Doc/**' + - 'appveyor.yml' + +jobs: + build: + + # When continue-on-error is true for an individual build, that build can fail (it'll show red), + # but it won't fail the overall build + continue-on-error: ${{ matrix.continue-on-error || false }} + + runs-on: ${{ matrix.os || 'ubuntu-20.04' }} + + # By default, the name of the build is the language used and SWIG options, but matrix entries + # can define the additional "desc" field with any additional information to include in the name. + name: ${{ matrix.SWIGLANG || 'none' }}${{ matrix.PY3 }} ${{ matrix.ENGINE}} ${{ matrix.VER }} ${{ matrix.SWIG_FEATURES }} ${{ (matrix.compiler || 'gcc') }}${{ matrix.GCC }} ${{ matrix.CPPSTD }} ${{ matrix.CSTD }} ${{ matrix.desc }} ${{ matrix.continue-on-error && '(can fail)' }} + + strategy: + matrix: + include: + - SWIGLANG: "" + - SWIGLANG: "" + GCC: 7 + - SWIGLANG: "" + GCC: 8 + - SWIGLANG: "" + GCC: 9 + - SWIGLANG: "" + GCC: 10 + - SWIGLANG: "" + GCC: 11 + - SWIGLANG: "" + compiler: clang + - SWIGLANG: csharp + # D support can't be enabled because dmd 2.066 fails to build anything + # under Ubuntu 18.04 due to its standard library (libphobos2.a) not + # being compiled with -FPIC, but system gcc using -fpie by default, + # resulting in linking errors for any output. And later versions, such + # as 2.086.1, are not supported and result in errors in SWIG test suite. + # + # - SWIGLANG: d + # VER: '2.066.0' + # os: ubuntu-18.04 # This dlang version doesn't work under 20.04. + - SWIGLANG: go + VER: '1.6' + CSTD: gnu11 + - SWIGLANG: go + VER: '1.8' + - SWIGLANG: go + VER: '1.12' + CSTD: gnu11 + - SWIGLANG: go + VER: '1.17' + - SWIGLANG: guile + - SWIGLANG: java + - SWIGLANG: javascript + ENGINE: node + VER: '12' + CPPSTD: c++11 + - SWIGLANG: javascript + ENGINE: node + VER: '17' + CPPSTD: c++14 + - SWIGLANG: javascript + ENGINE: jsc + - SWIGLANG: javascript + ENGINE: v8 + os: ubuntu-18.04 # libv8-dev only actually provides v8 in 18.04. + - SWIGLANG: lua + - SWIGLANG: lua + VER: '5.3' + - SWIGLANG: octave + CPPSTD: c++11 + - SWIGLANG: perl5 + - SWIGLANG: php + VER: '7.4' + - SWIGLANG: php + - SWIGLANG: python + - SWIGLANG: python + PY3: 3 + VER: '3.2' + os: ubuntu-18.04 # Python < 3.5 not available for 20.04. + - SWIGLANG: python + PY3: 3 + VER: '3.3' + os: ubuntu-18.04 # Python < 3.5 not available for 20.04. + - SWIGLANG: python + PY3: 3 + VER: '3.4' + os: ubuntu-18.04 # Python < 3.5 not available for 20.04. + - SWIGLANG: python + PY3: 3 + VER: '3.5' + - SWIGLANG: python + PY3: 3 + VER: '3.6' + - SWIGLANG: python + PY3: 3 + VER: '3.7' + - SWIGLANG: python + PY3: 3 + VER: '3.8' + - SWIGLANG: python + PY3: 3 + VER: '3.9' + - SWIGLANG: python + PY3: 3 + VER: '3.10' + - SWIGLANG: python + SWIG_FEATURES: -builtin + - SWIGLANG: python + SWIG_FEATURES: -builtin -O + - SWIGLANG: python + PY3: 3 + SWIG_FEATURES: -builtin + - SWIGLANG: python + PY3: 3 + SWIG_FEATURES: -builtin -O + - SWIGLANG: r + - SWIGLANG: ruby + VER: '1.9' + os: ubuntu-18.04 + - SWIGLANG: ruby + VER: '2.0' + os: ubuntu-18.04 + - SWIGLANG: ruby + VER: '2.1' + os: ubuntu-18.04 + - SWIGLANG: ruby + VER: '2.2' + os: ubuntu-18.04 + - SWIGLANG: ruby + VER: '2.3' + os: ubuntu-18.04 + - SWIGLANG: ruby + VER: '2.4' + - SWIGLANG: ruby + VER: '2.5' + - SWIGLANG: ruby + VER: '2.6' + - SWIGLANG: ruby + VER: '2.7' + - SWIGLANG: ruby + VER: '3.0' + CPPSTD: c++11 + - SWIGLANG: scilab + os: ubuntu-18.04 # scilab-6.1 in ubuntu-20.04 not yet working + - SWIGLANG: tcl + # c++11 testing + - SWIGLANG: csharp + CPPSTD: c++11 + - SWIGLANG: go + VER: '1.17' + CPPSTD: c++11 + CSTD: gnu11 + - SWIGLANG: guile + CPPSTD: c++11 + - SWIGLANG: java + CPPSTD: c++11 + - SWIGLANG: javascript + ENGINE: node + VER: '14' + CPPSTD: c++11 + - SWIGLANG: lua + CPPSTD: c++11 + # - SWIGLANG: octave + # CPPSTD: c++11 + - SWIGLANG: perl5 + CPPSTD: c++11 + - SWIGLANG: php + CPPSTD: c++11 + CSTD: gnu11 + - SWIGLANG: python + CPPSTD: c++11 + PY3: 3 + - SWIGLANG: r + CPPSTD: c++11 + - SWIGLANG: ruby + CPPSTD: c++11 + - SWIGLANG: scilab + CPPSTD: c++11 + os: ubuntu-18.04 # scilab-6.1 in ubuntu-20.04 not yet working + - SWIGLANG: tcl + CPPSTD: c++11 + # c++14 testing + - SWIGLANG: csharp + CPPSTD: c++14 + - SWIGLANG: go + VER: '1.17' + CPPSTD: c++14 + CSTD: gnu11 + - SWIGLANG: guile + CPPSTD: c++14 + - SWIGLANG: java + CPPSTD: c++14 + - SWIGLANG: javascript + ENGINE: node + VER: '16' + CPPSTD: c++14 + - SWIGLANG: lua + CPPSTD: c++14 + - SWIGLANG: octave + CPPSTD: c++14 + - SWIGLANG: perl5 + CPPSTD: c++14 + - SWIGLANG: php + CPPSTD: c++14 + CSTD: gnu11 + - SWIGLANG: python + CPPSTD: c++14 + PY3: 3 + - SWIGLANG: r + CPPSTD: c++14 + - SWIGLANG: ruby + CPPSTD: c++14 + - SWIGLANG: scilab + CPPSTD: c++14 + os: ubuntu-18.04 # scilab-6.1 in ubuntu-20.04 not yet working + - SWIGLANG: tcl + CPPSTD: c++14 + # c++17 testing (using gcc11) + - SWIGLANG: csharp + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: go + VER: '1.17' + CPPSTD: c++17 + GCC: 11 + CSTD: gnu17 + - SWIGLANG: guile + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: java + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: javascript + ENGINE: node + VER: '17' + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: lua + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: octave + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: perl5 + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: php + CPPSTD: c++17 + CSTD: gnu17 + GCC: 11 + - SWIGLANG: python + CPPSTD: c++17 + GCC: 11 + PY3: 3 + - SWIGLANG: r + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: ruby + CPPSTD: c++17 + GCC: 11 + - SWIGLANG: scilab + CPPSTD: c++17 + GCC: 11 + os: ubuntu-18.04 # scilab-6.1 in ubuntu-20.04 not yet working + - SWIGLANG: tcl + CPPSTD: c++17 + GCC: 11 + # Experimental languages (these are allowed to fail) + - SWIGLANG: mzscheme + continue-on-error: true + - SWIGLANG: ocaml + continue-on-error: true + os: ubuntu-18.04 # ocaml-4.08 in ubuntu-20.04 not yet working + # Run all of them, as opposed to aborting when one fails + fail-fast: false + + env: + SWIGLANG: ${{ matrix.SWIGLANG }} + PY3: ${{ matrix.PY3 }} + VER: ${{ matrix.VER }} + ENGINE: ${{ matrix.ENGINE }} + SWIG_FEATURES: ${{ matrix.SWIG_FEATURES }} + GCC: ${{ matrix.GCC }} + CSTD: ${{ matrix.CSTD }} + CPPSTD: ${{ matrix.CPPSTD }} + + steps: + - name: Checkout + uses: actions/checkout@v2 + with: + submodules: recursive + + - name: Install CCache + uses: hendrikmuhs/ccache-action@v1 + with: + key: ${{ matrix.os || 'ubuntu-20.04' }}-${{ matrix.compiler || 'gcc' }}${{ matrix.GCC }} + + - name: Install Dependencies + run: | + set -x + export PATH="/usr/lib/ccache:/usr/local/opt/ccache/libexec:$PATH" + echo PATH="$PATH" >> $GITHUB_ENV + + source $GITHUB_WORKSPACE/Tools/GHA-linux-install.sh + echo WITHLANG="$WITHLANG" >> $GITHUB_ENV + + case $(uname) in + Linux) + cpu_count=$(nproc) + ;; + + Darwin) + cpu_count=$(sysctl -n hw.ncpu) + ;; + + *) + cpu_count=1 + ;; + esac + + if [[ $cpu_count != 1 ]]; then + echo SWIGJOBS=-j$cpu_count >> $GITHUB_ENV + fi + + if test '${{ matrix.compiler }}' = 'clang'; then + CC="clang" + CXX="clang++" + + CFLAGS="$CFLAGS -fPIE" + CXXFLAGS="$CXXFLAGS -fPIE" + elif test -n "$GCC"; then + CC="gcc-$GCC" + CXX="g++-$GCC" + else + CC="gcc" + CXX="g++" + fi + + export CC CXX + + echo CC="$CC" >> $GITHUB_ENV + echo CXX="$CXX" >> $GITHUB_ENV + + ls -la $(which $CC) $(which $CXX) + $CC --version + $CXX --version + + - name: Configure + run: | + source $GITHUB_WORKSPACE/Tools/CI-linux-environment.sh + set -x + + if [[ -z "$CSTD" ]]; then + case "$CPPSTD" in + c++11) export CSTD=c11 ;; + c++14) export CSTD=c11 ;; + c++17) export CSTD=c17 ;; + esac + echo CSTD="$CSTD" >> $GITHUB_ENV + fi + if test -n "$CPPSTD"; then CONFIGOPTS+=(--enable-cpp11-testing "CXXFLAGS=-std=$CPPSTD $CXXFLAGS"); fi + if test -n "$CSTD"; then CONFIGOPTS+=("CFLAGS=-std=$CSTD $CFLAGS"); fi + if test -n "$SWIGLANG"; then CONFIGOPTS+=(--without-alllang --with-$WITHLANG); fi + echo "${CONFIGOPTS[@]}" + ./autogen.sh && mkdir -p build/build && cd build/build && ../../configure "${CONFIGOPTS[@]}" + + - name: Build + working-directory: build/build + run: | + set -x + make -s $SWIGJOBS + ./swig -version && ./swig -pcreversion + + - name: Test + working-directory: build/build + run: | + source $GITHUB_WORKSPACE/Tools/CI-linux-environment.sh + set -x + + if test -z "$SWIGLANG"; then + make $SWIGJOBS check-ccache + make $SWIGJOBS check-errors-test-suite + else + case "$SWIGLANG" in + javascript) + case "$ENGINE" in + v8 | jsc) + # Running tests using v8 or jsc involves creating a custom + # interpreter in Tools/javascript, which is currently broken + # for parallel builds (we attempt to update this interpreter + # while running, resulting in "Text file busy" error). + unset SWIGJOBS + esac + ;; + esac + + # Stricter compile flags for examples. Various headers and SWIG generated code prevents full use of -pedantic. + cflags=$($GITHUB_WORKSPACE/Tools/testflags.py --language $SWIGLANG --cflags --std=$CSTD --compiler=$CC) && echo $cflags + cxxflags=$($GITHUB_WORKSPACE/Tools/testflags.py --language $SWIGLANG --cxxflags --std=$CPPSTD --compiler=$CC) && echo $cxxflags + make check-$SWIGLANG-version + make check-$SWIGLANG-enabled + make $SWIGJOBS check-$SWIGLANG-examples CFLAGS="$cflags" CXXFLAGS="$cxxflags" + make $SWIGJOBS check-$SWIGLANG-test-suite CFLAGS="$cflags" CXXFLAGS="$cxxflags" + fi + + - name: Install + working-directory: build/build + run: | + set -x + if test -z "$SWIGLANG"; then sudo make install && swig -version && ccache-swig -V; fi + + - name: Clean + working-directory: build/build + run: | + set -x + make check-maintainer-clean && ../../configure diff --git a/.gitignore b/.gitignore index 5df510547..b51da0fdf 100644 --- a/.gitignore +++ b/.gitignore @@ -150,6 +150,8 @@ Examples/guile/*/my-guile # Java Examples/test-suite/java/*/ +Examples/test-suite/java/expected.txt +Examples/test-suite/java/got.txt Examples/java/*/*.java !Examples/java/*/runme.java Examples/java/doxygen/javadocs @@ -182,11 +184,8 @@ Examples/perl5/*/*.pm # PHP Examples/test-suite/php/php_*.h -Examples/test-suite/php/*.php -!Examples/test-suite/php/*runme.php -!Examples/test-suite/php/skel.php Examples/php/*/php_*.h -Examples/php/*/example.php +Examples/php/pragmas/example.php # Python # Based on https://github.com/github/gitignore/blob/master/Python.gitignore diff --git a/.travis.yml b/.travis.yml index 3ed261b6e..c11479fed 100644 --- a/.travis.yml +++ b/.travis.yml @@ -5,10 +5,6 @@ matrix: os: linux env: SWIGLANG= dist: xenial - - compiler: clang - os: linux - env: SWIGLANG= BUILDSYSTEM=cmake - dist: xenial - compiler: gcc os: linux env: SWIGLANG= @@ -44,6 +40,9 @@ matrix: - os: linux env: SWIGLANG= GCC=9 dist: xenial + - os: linux + env: SWIGLANG= GCC=10 + dist: focal - compiler: gcc os: linux env: SWIGLANG=csharp @@ -66,7 +65,11 @@ matrix: dist: xenial - compiler: gcc os: linux - env: SWIGLANG=go VER=1.12 + env: SWIGLANG=go VER=1.12 CSTD=gnu99 + dist: xenial + - compiler: gcc + os: linux + env: SWIGLANG=go VER=1.16 CSTD=gnu99 dist: xenial - compiler: gcc os: linux @@ -91,7 +94,14 @@ matrix: - compiler: gcc os: linux env: SWIGLANG=javascript ENGINE=node VER=12 CPP11=1 - sudo: required + dist: xenial + - compiler: gcc + os: linux + env: SWIGLANG=javascript ENGINE=node VER=14 CPP11=1 + dist: xenial + - compiler: gcc + os: linux + env: SWIGLANG=javascript ENGINE=node VER=16 CPP14=1 dist: xenial - compiler: gcc os: linux @@ -131,20 +141,36 @@ matrix: dist: xenial - compiler: gcc os: linux - env: SWIGLANG=php VER=7.0 + env: SWIGLANG=php VER=7.4 dist: xenial - compiler: gcc os: linux - env: SWIGLANG=php VER=7.1 + env: SWIGLANG=php VER=8.0 dist: xenial - compiler: gcc os: linux - env: SWIGLANG=php VER=7.2 - dist: xenial + env: SWIGLANG=php VER=7.0 CONFIGOPTS=--enable-cpp11-testing CPPSTD=c++11 + dist: bionic - compiler: gcc os: linux - env: SWIGLANG=php VER=7.3 - dist: xenial + env: SWIGLANG=php VER=7.1 CONFIGOPTS=--enable-cpp11-testing CPPSTD=c++11 + dist: bionic + - compiler: gcc + os: linux + env: SWIGLANG=php VER=7.2 CONFIGOPTS=--enable-cpp11-testing CPPSTD=c++11 + dist: bionic + - compiler: gcc + os: linux + env: SWIGLANG=php VER=7.3 CONFIGOPTS=--enable-cpp11-testing CPPSTD=c++11 + dist: bionic + - compiler: gcc + os: linux + env: SWIGLANG=php VER=7.4 CONFIGOPTS=--enable-cpp11-testing CPPSTD=c++11 + dist: bionic + - compiler: gcc + os: linux + env: SWIGLANG=php VER=8.0 CONFIGOPTS=--enable-cpp11-testing CPPSTD=c++11 + dist: bionic - compiler: gcc os: linux env: SWIGLANG=python # 2.7 @@ -273,6 +299,10 @@ matrix: dist: xenial - compiler: gcc os: linux + env: SWIGLANG=ruby VER=3.0 CSTD=c99 + dist: xenial + - compiler: gcc + os: linux env: SWIGLANG=scilab dist: xenial - compiler: gcc @@ -350,11 +380,9 @@ matrix: os: osx osx_image: xcode12.2 env: SWIGLANG= - - compiler: gcc - os: osx - env: SWIGLANG= BUILDSYSTEM=cmake - compiler: clang os: osx + osx_image: xcode12.2 env: SWIGLANG= BUILDSYSTEM=cmake - compiler: clang os: osx @@ -367,7 +395,7 @@ matrix: - compiler: clang os: osx osx_image: xcode12.2 - env: SWIGLANG=go + env: SWIGLANG=go CSTD=gnu99 - compiler: clang os: osx osx_image: xcode12.2 @@ -420,11 +448,6 @@ matrix: os: linux env: SWIGLANG=d VER=2.086.1 dist: xenial - # seg fault in director_basic testcase - - compiler: gcc - os: linux - env: SWIGLANG=php VER=7.2 - dist: xenial # Experimental languages - compiler: gcc os: linux @@ -447,11 +470,11 @@ install: - if test "$TRAVIS_OS_NAME" = "osx"; then source Tools/travis-osx-install.sh; fi - ls -la $(which $CC) $(which $CXX) && $CC --version && $CXX --version script: - - if test "$BUILDSYSTEM" = "cmake"; then mkdir -p build/build && cd build/build && cmake -DCMAKE_INSTALL_PREFIX=~/.local ../.. && make install && ctest --output-on-failure -V && exit 0; fi + - if test "$BUILDSYSTEM" = "cmake"; then cmake --version && mkdir -p build/build && cd build/build && CXXFLAGS="-Wall -Wextra -Werror" CFLAGS="-Wall -Wextra -Werror" cmake -DCMAKE_INSTALL_PREFIX=~/.local ../.. && make install && ctest --output-on-failure -V && exit 0; fi - echo 'Configuring...' && echo -en 'travis_fold:start:script.1\\r' - - if test -n "$CPP11"; then CONFIGOPTS+=(--enable-cpp11-testing --without-maximum-compile-warnings "CXXFLAGS=-std=c++11 -Wall -Wextra" "CFLAGS=-std=c11 -Wall -Wextra") && export CSTD=c11 && export CPPSTD=c++11; fi - - if test -n "$CPP14"; then CONFIGOPTS+=(--enable-cpp11-testing --without-maximum-compile-warnings "CXXFLAGS=-std=c++14 -Wall -Wextra" "CFLAGS=-std=c11 -Wall -Wextra") && export CSTD=c11 && export CPPSTD=c++14; fi - - if test -n "$CPP17"; then CONFIGOPTS+=(--enable-cpp11-testing --without-maximum-compile-warnings "CXXFLAGS=-std=c++17 -Wall -Wextra" "CFLAGS=-std=c17 -Wall -Wextra") && export CSTD=c17 && export CPPSTD=c++17; fi + - if test -n "$CPP11"; then CONFIGOPTS+=(--enable-cpp11-testing "CXXFLAGS=-std=c++11 $CXXFLAGS" "CFLAGS=-std=c11 $CFLAGS") && export CSTD=c11 && export CPPSTD=c++11; fi + - if test -n "$CPP14"; then CONFIGOPTS+=(--enable-cpp11-testing "CXXFLAGS=-std=c++14 $CXXFLAGS" "CFLAGS=-std=c11 $CFLAGS") && export CSTD=c11 && export CPPSTD=c++14; fi + - if test -n "$CPP17"; then CONFIGOPTS+=(--enable-cpp11-testing "CXXFLAGS=-std=c++17 $CXXFLAGS" "CFLAGS=-std=c17 $CFLAGS") && export CSTD=c17 && export CPPSTD=c++17; fi - if test -n "$SWIGLANG"; then CONFIGOPTS+=(--without-alllang --with-$WITHLANG); fi - echo "${CONFIGOPTS[@]}" - ./autogen.sh && mkdir -p build/build && cd build/build && ../../configure "${CONFIGOPTS[@]}" diff --git a/CCache/README.swig b/CCache/README.swig index aea0f3d82..82055d146 100644 --- a/CCache/README.swig +++ b/CCache/README.swig @@ -2,7 +2,7 @@ This directory contains a version of ccache. The initial version was based on cc debian patches 01-02, 04-14, see the debian/patches subdirectory. The ccache-win32-2.4 modifications to ccache-2.4 have also been merged in. -Changes have been made to support cacheing the output from SWIG. The ability to cache c/c++ compiler +Changes have been made to support caching the output from SWIG. The ability to cache c/c++ compiler output has been retained. Additional features added are the CCACHE_VERBOSE and CCACHE_SWIG environment variables, see docs. diff --git a/CCache/configure.ac b/CCache/configure.ac index e1c761860..2db3553ce 100644 --- a/CCache/configure.ac +++ b/CCache/configure.ac @@ -1,12 +1,12 @@ dnl Process this file with autoconf to produce a configure script. -AC_INIT([ccache-swig], [0.0]) # Get version from SWIG in ccache_swig_config.h.in -AC_PREREQ(2.52) +AC_INIT([ccache-swig],[0.0]) # Get version from SWIG in ccache_swig_config.h.in +AC_PREREQ([2.60]) AC_CONFIG_SRCDIR([ccache.h]) AC_MSG_NOTICE([Configuring ccache]) -AC_CONFIG_HEADER(config.h) +AC_CONFIG_HEADERS([config.h]) AC_CONFIG_FILES([config_win32.h]) dnl Checks for programs. @@ -41,7 +41,7 @@ else fi AC_HEADER_DIRENT -AC_HEADER_TIME + AC_HEADER_SYS_WAIT AC_CHECK_HEADERS(ctype.h strings.h stdlib.h string.h pwd.h sys/time.h) @@ -51,19 +51,16 @@ AC_CHECK_FUNCS(gethostname getpwuid) AC_CHECK_FUNCS(utimes) AC_CACHE_CHECK([for compar_fn_t in stdlib.h],ccache_cv_COMPAR_FN_T, [ - AC_TRY_COMPILE( -[#include <stdlib.h>], -[ + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[#include <stdlib.h>]], [[ void test_fn(void) { qsort(NULL, 0, 0, (__compar_fn_t)NULL); } -], - ccache_cv_COMPAR_FN_T=yes,ccache_cv_COMPAR_FN_T=no)]) +]])],[ccache_cv_COMPAR_FN_T=yes],[ccache_cv_COMPAR_FN_T=no])]) if test x"$ccache_cv_COMPAR_FN_T" = x"yes"; then AC_DEFINE(HAVE_COMPAR_FN_T, 1, [ ]) fi dnl Note: This could be replaced by AC_FUNC_SNPRINTF() in the autoconf macro archive AC_CACHE_CHECK([for C99 vsnprintf],ccache_cv_HAVE_C99_VSNPRINTF,[ -AC_TRY_RUN([ +AC_RUN_IFELSE([AC_LANG_SOURCE([[ #include <sys/types.h> #include <stdarg.h> void foo(const char *format, ...) { @@ -81,8 +78,7 @@ void foo(const char *format, ...) { exit(0); } main() { foo("hello"); } -], -ccache_cv_HAVE_C99_VSNPRINTF=yes,ccache_cv_HAVE_C99_VSNPRINTF=no,ccache_cv_HAVE_C99_VSNPRINTF=cross)]) +]])],[ccache_cv_HAVE_C99_VSNPRINTF=yes],[ccache_cv_HAVE_C99_VSNPRINTF=no],[ccache_cv_HAVE_C99_VSNPRINTF=cross])]) if test x"$ccache_cv_HAVE_C99_VSNPRINTF" = x"yes"; then AC_DEFINE(HAVE_C99_VSNPRINTF, 1, [ ]) fi diff --git a/CCache/execute.c b/CCache/execute.c index 6df025e95..8c65e0ce0 100644 --- a/CCache/execute.c +++ b/CCache/execute.c @@ -137,7 +137,7 @@ int execute(char **argv, _dup2(fd, 2); _close(fd); - /* Spawn process (_exec* familly doesn't return) */ + /* Spawn process (_exec* family doesn't return) */ status = _spawnv(_P_WAIT, argv[0], (const char **)argv); /* Restore descriptors */ diff --git a/CCache/snprintf.c b/CCache/snprintf.c index 9bf8a817b..1a76c7d1b 100644 --- a/CCache/snprintf.c +++ b/CCache/snprintf.c @@ -16,7 +16,7 @@ * for string length. This covers a nasty loophole. * * The other functions are there to prevent NULL pointers from - * causing nast effects. + * causing nasty effects. * * More Recently: * Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43 @@ -30,7 +30,7 @@ * probably requires libm on most operating systems. Don't yet * support the exponent (e,E) and sigfig (g,G). Also, fmtint() * was pretty badly broken, it just wasn't being exercised in ways - * which showed it, so that's been fixed. Also, formated the code + * which showed it, so that's been fixed. Also, formatted the code * to mutt conventions, and removed dead code left over from the * original. Also, there is now a builtin-test, just compile with: * gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm diff --git a/CCache/web/index.html b/CCache/web/index.html index 4af839135..bc46916d2 100644 --- a/CCache/web/index.html +++ b/CCache/web/index.html @@ -34,7 +34,7 @@ on the new options.<p> You can get this release from the <a href="http://ccache.samba.org/ftp/ccache/">download directory</a> -<p>NOTE! This release changes the hash input slighly, so you will +<p>NOTE! This release changes the hash input slightly, so you will probably find that you will not get any hits against your existing cache when you upgrade. diff --git a/CHANGES.current b/CHANGES.current index 0f69796f2..0abed204a 100644 --- a/CHANGES.current +++ b/CHANGES.current @@ -7,6 +7,198 @@ the issue number to the end of the URL: https://github.com/swig/swig/issues/ Version 4.1.0 (in progress) =========================== +2021-11-12: wsfulton + [Javascript] v8 and node only. Fix mismatched new char[] and free() + when wrapping C code char arrays. Now calloc is now used instead of + new char[] in SWIG_AsCharPtrAndSize. + +2021-10-03: ajrh1 + [Perl] #2074: Avoid -Wmisleading-indentation in generated code + when using gcc11. + +2021-10-03: jschueller + [CMake] #2065: Add option to enable or disable PCRE support. + +2021-09-16: ianlancetaylor + [Go] Improved _cgo_panic implementation. + +2021-09-16: ianlancetaylor + [Go] Don't use crosscall2 for panicking. Instead rely on documented + and exported interfaces. + +2021-09-14: ianlancetaylor + [Go] Remove -no-cgo option (long unsupported in Go) + +2021-05-04: olly + [PHP] #2014 Throw PHP exceptions instead of using PHP errors + + PHP exceptions can be caught and handled if desired, but if they + aren't caught then PHP exits in much the same way as it does for a + PHP error. + + In particular this means parameter type errors and some other cases + in SWIG-generated wrappers now throw a PHP exception, which matches + how PHP's native parameter handling deals with similar situations. + + `SWIG_ErrorCode()`, `SWIG_ErrorMsg()`, `SWIG_FAIL()` and `goto thrown;` + are no longer supported (these are really all internal implementation + details and none are documented aside from brief mentions in CHANGES + for the first three). I wasn't able to find any uses in user interface + files at least in FOSS code via code search tools. + + If you are using these: + + Use `SWIG_PHP_Error(code,msg);` instead of `SWIG_ErrorCode(code); + SWIG_ErrorMsg(msg);` (which will throw a PHP exception in SWIG >= 4.1 + and do the same as the individual calls in older SWIG). + + `SWIG_FAIL();` and `goto thrown;` can typically be replaced with + `SWIG_fail;`. This will probably also work with older SWIG, but + please test with your wrappers if this is important to you. + + *** POTENTIAL INCOMPATIBILITY *** + +2021-05-17: adr26 + [Python] #1985 Fix memory leaks: + + 1. Python object references were being incorrectly retained by + SwigPyClientData, causing swig_varlink_dealloc() never to run / free + memory. SwigPyClientData_New() / SwigPyClientData_Del() were updated + to fix the object reference counting, causing swig_varlink_dealloc() + to run and the memory swig_varlink owns to be freed. + + 2. SwigPyClientData itself was not freed by SwigPyClientData_Del(), + causing another heap leak. The required free() was added to + SwigPyClientData_Del() + + 3. Fix reference counting/leak of python cached type query + + 4. Fix reference counting/leak of SwigPyObject dict (-builtin) + + 5. Python object reference counting fixes for out-of-memory + scenarios were added to: SWIG_Python_RaiseOrModifyTypeError(), + SWIG_Python_AppendOutput(), SwigPyClientData_New(), + SwigPyObject_get___dict__() and SwigPyObject_format() + + 6. Add error handling for PyModule_AddObject() to + SWIG_Python_SetModule() (failure could be caused by OOM or a name + clash caused by malicious code) + +2021-05-13: olly + [UFFI] #2009 Remove code for Common Lisp UFFI. We dropped support + for it in SWIG 4.0.0 and nobody has stepped forward to revive it in + over 2 years. + +2021-05-13: olly + [S-EXP] #2009 Remove code for Common Lisp S-Exp. We dropped + support for it in SWIG 4.0.0 and nobody has stepped forward to + revive it in over 2 years. + +2021-05-13: olly + [Pike] #2009 Remove code for Pike. We dropped support for it in + SWIG 4.0.0 and nobody has stepped forward to revive it in over 2 + years. + +2021-05-13: olly + [Modula3] #2009 Remove code for Modula3. We dropped support for it + in SWIG 4.0.0 and nobody has stepped forward to revive it in over 2 + years. + +2021-05-13: olly + [CLISP] #2009 Remove code for GNU Common Lisp. We dropped support + for it in SWIG 4.0.0 and nobody has stepped forward to revive it in + over 2 years. + +2021-05-13: olly + [Chicken] #2009 Remove code for Chicken. We dropped support for it + in SWIG 4.0.0 and nobody has stepped forward to revive it in over 2 + years. + +2021-05-13: olly + [Allegrocl] #2009 Remove code for Allegro Common Lisp. We dropped + support for it in SWIG 4.0.0 and nobody has stepped forward to + revive it in over 2 years. + +2021-05-04: olly + [PHP] #1982 #1457 https://sourceforge.net/p/swig/bugs/1339/ + SWIG now only use PHP's C API to implement its wrappers, and no + longer generates PHP code to define classes. The wrappers should + be almost entirely compatible with those generated before, but + faster and without some previously hard-to-fix bugs. + + The main notable difference is SWIG no longer generates a .php + wrapper at all by default (only if %pragma(php) code=... or + %pragma(php) include=... are specified in the interface file). + This also means you need to load the module via extension=... + in php.ini, rather than letting the dl() in the generated + .php wrapper load it (but dl() has only worked for command-line + PHP for some years now). + + *** POTENTIAL INCOMPATIBILITY *** + +2021-04-30: olly + #1984 Remove support for $source and $target. + These were officially deprecated in 2001, and attempts to use them have + resulted in a warning (including a pointer to what to update them to) + for most if not all of that time. + +2021-04-27: wsfulton + #1987 [Java] Fix %interface family of macros for returning by const + pointer reference. + +2021-04-19: olly + Fix use of uninitialised variable in the generated code for an + empty typecheck typemap, such as the dummy one we include for + std::initializer_list. + +2021-04-12: olly + #1777 [Python] Specifying -py3 now generates a check for Python + version >= 3.0. + +2021-03-26: olly + [PHP] Add PHP keywords 'fn' (added in 7.4) and 'match' (added in + 8.0) to the list SWIG knows to automatically rename. + +2021-03-23: wsfulton + #1942 [Python] Fix compilation error in wrappers when using -builtin + and wrapping varargs in constructors. + +2021-03-22: goto40 + #1977 Fix handling of template template parameters. + +2021-03-21: olly + #1929, #1978 [PHP] Add support for PHP 8. + +2021-03-19: wsfulton + #1610 Remove -ansi from default compilation flags. + +2021-03-19: dot-asm + #1934 [Java] Clean up typemaps for long long arrays. + +2021-03-19: olly + #1527 [PHP] Improve PHP object creation in directorin case. + Reportedly the code we were using in this case gave segfaults in + PHP 7.2 and later - we've been unable to reproduce these, but the + new approach is also simpler and should be bit faster too. + +2021-03-18: olly + #1655 [PHP] Fix char* typecheck typemap to accept PHP Null like the + corresponding in typemap does. + +2021-03-18: olly + #1900, #1905 [PHP] Fix wrapping of overloaded directed methods with + non-void return. + +2021-03-11: murillo128 + #1498 [Javascript] Support type conversion. + +2021-03-06: nshmyrev + #872 [Javascript] Various typemap issues in arrays_javascript.i fixed. + +2021-03-03: vaughamhong + #577 [Javascript] Implemented SetModule/GetModule for JSC to allow type sharing + across modules. + 2021-03-01: xantares, Oliver Buchtala, geographika #1040 Add support for building SWIG with CMake. See documentation in Windows.html. @@ -25,8 +217,14 @@ Version 4.1.0 (in progress) unsigned long long values. 2021-02-24: tomleavy, yegorich, tungntpham - #1746 [Javascript] Add support for Node v12. - SWIG support is now for Node v6 and later only. + #1746 [Javascript] Add support for Node v12, v14 and v16. + SWIG support for Node is now for v6 and later only. + +2020-02-09: ZackerySpytz + #1872 Fix typos in attribute2ref macros. + +2020-10-10: wsfulton + [Javascript] Fix so that ccomplex.i interface to file can be used. 2020-10-10: wsfulton #252 complex can now be used as a C identifier and doesn't give a syntax error. diff --git a/CMakeLists.txt b/CMakeLists.txt index b36f441fe..8a195de54 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -69,15 +69,20 @@ check_include_file_cxx ("boost/shared_ptr.hpp" HAVE_BOOST) check_library_exists (dl dlopen "" HAVE_LIBDL) check_function_exists (popen HAVE_POPEN) -set (PCRE_REQUIRED_ARG "REQUIRED" CACHE STRING "required arg") -find_package (PCRE ${PCRE_REQUIRED_ARG}) -if (PCRE_FOUND) +if (MSVC) + set (CMAKE_CXX_FLAGS "/EHsc ${CMAKE_CXX_FLAGS}") +endif () + +option (WITH_PCRE "Enable pcre" ON) +if (WITH_PCRE) + find_package (PCRE REQUIRED) set (HAVE_PCRE 1) include_directories (${PCRE_INCLUDE_DIRS}) endif() if (WIN32) file (TO_NATIVE_PATH ${CMAKE_INSTALL_PREFIX}/${SWIG_LIB} SWIG_LIB_WIN_UNIX) + string (REGEX REPLACE "\\\\" "\\\\\\\\" SWIG_LIB_WIN_UNIX "${SWIG_LIB_WIN_UNIX}") endif () configure_file (${SWIG_ROOT}/Tools/cmake/swigconfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/Source/Include/swigconfig.h) diff --git a/Doc/Manual/Allegrocl.html b/Doc/Manual/Allegrocl.html deleted file mode 100644 index 4069ecd8b..000000000 --- a/Doc/Manual/Allegrocl.html +++ /dev/null @@ -1,2150 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> -<html> -<head> -<title>SWIG and Allegro Common Lisp</title> -<link rel="stylesheet" type="text/css" href="style.css"> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -</head> - -<body bgcolor="#ffffff"> - -<H1><a name="Allegrocl">20 SWIG and Allegro Common Lisp</a></H1> -<!-- INDEX --> -<div class="sectiontoc"> -<ul> -<li><a href="#Allegrocl_nn2">Basics</a> -<ul> -<li><a href="#Allegrocl_nn3">Running SWIG</a> -<li><a href="#Allegrocl_nn4">Command Line Options</a> -<li><a href="#Allegrocl_nn5">Inserting user code into generated files</a> -</ul> -<li><a href="#Allegrocl_nn6">Wrapping Overview</a> -<ul> -<li><a href="#Allegrocl_nn7">Function Wrapping</a> -<li><a href="#Allegrocl_nn8">Foreign Wrappers</a> -<li><a href="#Allegrocl_nn9">FFI Wrappers</a> -<li><a href="#Allegrocl_nn10">Non-overloaded Defuns</a> -<li><a href="#Allegrocl_nn11">Overloaded Defuns</a> -<li><a href="#Allegrocl_nn12">What about constant and variable access?</a> -<li><a href="#Allegrocl_nn13">Object Wrapping</a> -</ul> -<li><a href="#Allegrocl_nn14">Wrapping Details</a> -<ul> -<li><a href="#Allegrocl_nn15">Namespaces</a> -<li><a href="#Allegrocl_nn16">Constants</a> -<li><a href="#Allegrocl_nn17">Variables</a> -<li><a href="#Allegrocl_nn18">Enumerations</a> -<li><a href="#Allegrocl_nn19">Arrays</a> -<li><a href="#Allegrocl_nn20">Classes and Structs and Unions (oh my!)</a> -<ul> -<li><a href="#Allegrocl_nn21">CLOS wrapping of</a> -<li><a href="#Allegrocl_nn22">CLOS Inheritance</a> -<li><a href="#Allegrocl_nn23">Member fields and functions</a> -<li><a href="#Allegrocl_nn24">Why not directly access C++ classes using foreign types?</a> -</ul> -<li><a href="#Allegrocl_nn25">Templates</a> -<ul> -<li><a href="#Allegrocl_nn26">Generating wrapper code for templates</a> -<li><a href="#Allegrocl_nn27">Implicit Template instantiation</a> -</ul> -<li><a href="#Allegrocl_nn28">Typedef, Templates, and Synonym Types</a> -<ul> -<li><a href="#Allegrocl_nn29">Choosing a primary type</a> -</ul> -<li><a href="#Allegrocl_nn30">Function overloading/Parameter defaulting</a> -<li><a href="#Allegrocl_nn31">Operator wrapping and Operator overloading</a> -<li><a href="#Allegrocl_nn32">Varargs</a> -<li><a href="#Allegrocl_nn33">C++ Exceptions</a> -<li><a href="#Allegrocl_nn34">Pass by value, pass by reference</a> -</ul> -<li><a href="#Allegrocl_nn35">Typemaps</a> -<ul> -<li><a href="#Allegrocl_nn36">Code Generation in the C++ Wrapper</a> -<ul> -<li><a href="#Allegrocl_nn37">IN Typemap</a> -<li><a href="#Allegrocl_nn38">OUT Typemap</a> -<li><a href="#Allegrocl_nn39">CTYPE Typemap</a> -</ul> -<li><a href="#Allegrocl_nn40">Code generation in Lisp wrappers</a> -<ul> -<li><a href="#Allegrocl_nn41">LIN Typemap</a> -<li><a href="#Allegrocl_nn42">LOUT Typemap</a> -<li><a href="#Allegrocl_nn43">FFITYPE Typemap</a> -<li><a href="#Allegrocl_nn44">LISPTYPE Typemap</a> -<li><a href="#Allegrocl_nn45">LISPCLASS Typemap</a> -</ul> -<li><a href="#Allegrocl_nn46">Modifying SWIG behavior using typemaps</a> -</ul> -<li><a href="#Allegrocl_nn47">Identifier Converter functions</a> -<ul> -<li><a href="#Allegrocl_nn48">Creating symbols in the lisp environment</a> -<li><a href="#Allegrocl_nn49">Existing identifier-converter functions</a> -<ul> -<li><a href="#Allegrocl_nn50">identifier-convert-null</a> -<li><a href="#Allegrocl_nn51">identifier-convert-lispify</a> -<li><a href="#Allegrocl_nn52">Default identifier to symbol conversions</a> -</ul> -<li><a href="#Allegrocl_nn53">Defining your own identifier-converter</a> -<li><a href="#Allegrocl_nn54">Instructing SWIG to use a particular identifier-converter</a> -</ul> -</ul> -</div> -<!-- INDEX --> - - - -<p> -This chapter describes SWIG's support of Allegro Common Lisp. Allegro -CL is a full-featured implementation of the Common Lisp language -standard that includes many vendor-specific enhancements and add-on -modules for increased usability. -</p> - -<p> -One such module included in Allegro CL is the Foreign Functions -Interface (FFI). This module, tailored primarily toward interfacing -with C/C++ and, historically, Fortran, provides a means by which -compiled foreign code can be loaded into a running lisp -environment and executed. The interface supports the calling of -foreign functions and methods, allows for executing lisp routines -from foreign code (callbacks), and the passing of data between foreign -and lisp code. -</p> - -<p> -The goal of this module is to make it possible to quickly generate the -necessary foreign function definitions so one can make use of C/C++ -foreign libraries directly from lisp without the tedium of having to -code them by hand. When necessary, it will also generate further C/C++ -code that will need to be linked with the intended library for proper -interfacing from lisp. It has been designed with an eye toward -flexibility. Some foreign function calls may release the heap, while -other should not. Some foreign functions should automatically convert -lisp strings into native strings, while others should not. These -adjustments and many more are possible with the current module. -</p> - -<p> -It is significant to note that, while this is a vendor-specific -module, we would like to acknowledge the current and ongoing -work by developers in the open source lisp community that are -working on similar interfaces to implementation-independent -foreign function interfaces (CFFI, for example). Such -work can only benefit the lisp community, and we would not -be unhappy to see some enterprising folk use this work to add -to it. -</p> - -<H2><a name="Allegrocl_nn2">20.1 Basics</a></H2> - - -<H3><a name="Allegrocl_nn3">20.1.1 Running SWIG</a></H3> - - -<p> -If you're reading this, you must have some library you need to -generate an interface for. In order for SWIG to do this work, however, -it needs a bit of information about how it should go about creating -your interface, and what you are interfacing to. -</p> - -<p> -SWIG expects a description of what in the foreign interface you wish -to connect to. It must consisting of C/C++ declarations and special -SWIG directives. SWIG can be furnished with a header file, but an -interface can also be generated without library headers by supplying a -simple text file--called the interface file, which is typically named -with a <tt>.i</tt> extension--containing any foreign declarations of -identifiers you wish to use. The most common approach is to use an -interface file with directives to parse the needed headers. A straight -parse of library headers will result in usable code, but SWIG -directives provides much freedom in how a user might tailor the -generated code to their needs or style of coding. -</p> - -<p> -Note that SWIG does not require any function definitions; the -declarations of those functions is all that is necessary. Be careful -when tuning the interface as it is quite possible to generate code -that will not load or compile. -</p> - -<p> -An example interface file is shown below. It makes use of two SWIG -directives, one of which requests that the declarations in a header -file be used to generate part of the interface, and also includes an -additional declaration to be added.</p> - -<div class="code">example.i -<pre> -%module example - -%include "header.h" - -int fact(int n); -</pre> -</div> - -<p>The contents of header.h are very simple:</p> -<div class="code">header.h -<pre> -int fact(char *statement); // pass it a fact, and it will rate it. -</pre> -</div> - -<p>The contents of example.cl will look like this:</p> - -<div class="targetlang">example.cl -<pre> -(defpackage :example - (:use :common-lisp :swig :ff :excl)) - - ... helper routines for defining the interface ... - -(swig-in-package ()) - -(swig-defun ("fact") - ((PARM0_statement cl:string (* :char) )) - (:returning (:int ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_statement)) - (swig-ff-call SWIG_arg0))) - -(swig-defun ("fact") - ((PARM0_n cl:integer :int )) - (:returning (:int ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_n)) - (swig-ff-call SWIG_arg0))) - -(swig-dispatcher ("fact" :type :function :arities (1))) -</pre> -</div> - -<p> -The generated file contains calls to internal swig helper -functions. In this case there are two calls to swig-defun. -These calls will expand into code that will make the appropriate -definitions using the Allegro FFI. Note also, that this code is -<b>erroneous</b>. Function overloading is not supported in C, and this -code will not compile even though SWIG did not complain. -</p> - -<p> -In order to generate a C interface to Allegro CL using this code run -swig using the <tt>-allegrocl</tt> option, as below: -</p> - -<div class="shell"> -<pre> -% swig -allegrocl example.i -</pre> -</div> - -<p> -When building an interface to C++ code, include the <tt>-c++</tt> option: -</p> - -<div class="shell"> -<pre> -% swig -allegrocl -c++ example.i -</pre> -</div> - -<p> -As a result of running one of the above commands, a file named <tt>example.cl</tt> -will be generated containing the lisp side of the interface. As well, a file -<tt>example_wrap.cxx</tt> is also generated, containing C/C++ wrapper code to -facilitate access to C++ methods, enumeration values, and constant values. -Wrapper functions are necessary in C++ due to the lack of a standard for mangling -the names of symbols across all C++ compilers. These wrapper functions are -exported from the shared library as appropriate, using the C name mangling -convention. The lisp code that is generated will interface to your foreign -library through these wrappers. -</p> - -<p> -It is possible to disable the creation of the .cxx file when generating a C -interface by using the -nocwrap command-line argument. For interfaces that -don't contain complex enum or constant expressions, contain nested struct/union -declarations, or doesn't need to use many of the SWIG customization featuers, -this will result in a more streamlined, direct interface to the -intended module. -</p> - -<p> -The generated wrapper file is below. It contains very simple -wrappers by default, that simply pass the arguments to the -actual function. -</p> - -<div class="code">example_wrap.i -<pre> - ... lots of SWIG internals ... - -EXPORT int ACL___fact__SWIG_0 (char *larg1) { - int lresult = (int)0 ; - char *arg1 = (char *) 0 ; - int result; - - arg1 = larg1; - try { - result = (int)fact(arg1); - - lresult = result; - return lresult; - } catch (...) { - return (int)0; - } -} - - -EXPORT int ACL___fact__SWIG_1 (int larg1) { - int lresult = (int)0 ; - int arg1 ; - int result; - - arg1 = larg1; - try { - result = (int)fact(arg1); - - lresult = result; - return lresult; - } catch (...) { - return (int)0; - } -} -</pre> -</div> - -<p> -And again, the generated lisp code. Note that it differs from -what is generated when parsing C code: -</p> - -<div class="targetlang"> -<pre> - ... - -(swig-in-package ()) - -(swig-defmethod ("fact" "ACL___fact__SWIG_0" :type :function :arity 1) - ((PARM0_statement cl:string (* :char) )) - (:returning (:int ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_statement)) - (swig-ff-call SWIG_arg0))) - -(swig-defmethod ("fact" "ACL___fact__SWIG_1" :type :function :arity 1) - ((PARM0_n cl:integer :int )) - (:returning (:int ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_n)) - (swig-ff-call SWIG_arg0))) - -(swig-dispatcher ("fact" :type :function :arities (1))) -</pre> -</div> - -<p>In this case, the interface generates two swig-defmethod forms and -a swig-dispatcher form. This provides a single functional interface for -all overloaded routines. A more detailed description of this features -is to be found in the section titled <b>Function overloading/Parameter defaulting</b>. - -<p> -In order to load a C++ interface, you will need to build a shared library -from example_wrap.cxx. Be sure to link in the actual library you created -the interface for, as well as any other dependent shared libraries. For -example, if you intend to be able to call back into lisp, you will also -need to link in the Allegro shared library. The library you create from -the C++ wrapper will be what you then load into Allegro CL. -</p> - -<H3><a name="Allegrocl_nn4">20.1.2 Command Line Options</a></H3> - - -<p> -There are three Allegro CL specific command-line option: -</p> - -<div class="shell"> -<pre> -swig -allegrocl [ options ] filename - - -identifier-converter [name] - Binds the variable swig:*swig-identifier-convert* - in the generated .cl file to <tt>name</tt>. - This function is used to generate symbols - for the lisp side of the interface. - - -cwrap - [default] Generate a .cxx file containing C wrapper function when - wrapping C code. The interface generated is similar to what is - done for C++ code. - -nocwrap - Explicitly turn off generation of .cxx wrappers for C code. Reasonable - for modules with simple interfaces. Can not handle all legal enum - and constant constructs, or take advantage of SWIG customization features. - - -isolate - With this command-line argument, all lisp helper functions are defined - in a unique package named <tt>swig.<module-name></tt> rather than - <tt>swig</tt>. This prevents conflicts when the module is - intended to be used with other swig generated interfaces that may, - for instance, make use of different identifier converters. -</pre> -</div> - -<p> -See <a href="#Allegrocl_nn47">Section 17.5 Identifier converter -functions</a> for more details. -</p> - -<H3><a name="Allegrocl_nn5">20.1.3 Inserting user code into generated files</a></H3> - - -<p> -It is often necessary to include user-defined code into the -automatically generated interface files. For example, when building -a C++ interface, example_wrap.cxx will likely not compile unless -you add a <tt>#include "header.h"</tt> directive. This can be done -using the SWIG <tt>%insert(section) %{ ...code... %}</tt> directive: -</p> - -<div class="code"> -<pre> -%module example - -%{ -#include "header.h" -%} - -%include "header.h" - -int fact(int n); -</pre> -</div> - -<p> -Additional sections have been added for inserting into the -generated lisp interface file -</p> -<ul> - <li><tt>lisphead</tt> - inserts before type declarations</li> - <li><tt>lisp</tt> - inserts after type declarations according to - where it appears in the .i file</li> -</ul> -<p> -Note that the block <tt>%{ ... %}</tt> is effectively a shortcut for -<tt>%insert("header") %{ ... %}</tt>. -</p> - - -<H2><a name="Allegrocl_nn6">20.2 Wrapping Overview</a></H2> - - -<p> -New users to SWIG are encouraged to read -<a href="SWIG.html#SWIG">SWIG Basics</a>, and -<a href="SWIGPlus.html#SWIGPlus">SWIG and C++</a>, for those -interested in generating an interface to C++. -</p> - -<H3><a name="Allegrocl_nn7">20.2.1 Function Wrapping</a></H3> - - - <p> - Writing lisp code that directly invokes functions at the foreign - function interface level can be cumbersome. Data must often be - translated between lisp and foreign types, data extracted from - objects, foreign objects allocated and freed upon completion of - the foreign call. Dealing with pointers can be unwieldy when it - comes to keeping them distinct from other valid integer values. - </p> - - <p> - We make an attempt to ease some of these burdens by making the - interface to foreign code much more lisp-like, rather than C - like. How this is done is described in later chapters. The - layers themselves, appear as follows: - </p> - - <div class="diagram"> - <pre> - ______________ - | | (foreign side) - | Foreign Code | What we're generating an interface to. - |______________| - | - | - _______v______ - | | (foreign side) - | Wrapper code | extern "C" wrappers calling C++ - |______________| functions and methods. - | - . . . - - + - - . . . - _______v______ - | | (lisp side) - | FFI Layer | Low level lisp interface. ff:def-foreign-call, - |______________| ff:def-foreign-variable - | - +---------------------------- - _______v______ _______v______ - | | | | (lisp side) - | Defuns | | Defmethods | wrapper for overloaded - |______________| |______________| functions or those with - (lisp side) | defaulted arguments - Wrapper for non-overloaded | - functions and methods _______v______ - | | (lisp side) - | Defuns | dispatch function - |______________| to overloads based - on arity - </pre> - </div> - -<H3><a name="Allegrocl_nn8">20.2.2 Foreign Wrappers</a></H3> - - - <p> - These wrappers are as generated by SWIG default. The types of - function parameters can be transformed in place using the CTYPE - typemap. This is use for converting pass-by-value parameters to - pass-by-reference where necessary. All wrapper parameters are then - bound to local variables for possible transformation of values - (see LIN typemap). Return values can be transformed via the OUT - typemap. - </p> - -<H3><a name="Allegrocl_nn9">20.2.3 FFI Wrappers</a></H3> - - - <p> - These are the generated ff:def-foreign-call forms. No typemaps are - applicable to this layer, but the <tt>%ffargs</tt> directive is - available for use in .i files, to specify which keyword arguments - should be specified for a given function. - </p> - - <div class="code">ffargs.i: - <pre> -%module ffargs - -%ffargs(strings_convert="nil", call_direct="t") foo; -%ffargs(strings_convert="nil", release_heap=":never", optimize_for_space="t") bar; - -int foo(float f1, float f2); -int foo(float f1, char c2); - -void bar(void *lisp_fn); - -char *xxx(); - </pre> - </div> - - <p>Generates: - </p> - <div class="targetlang">ffargs.cl: - <pre> -(swig-in-package ()) - -(swig-defmethod ("foo" "ACL___foo__SWIG_0" :type :function :arity 2) - ((PARM0_f1 cl:single-float :float ) - (PARM1_f2 cl:single-float :float )) - (:returning (:int ) - :call-direct t - :strings-convert nil) - (let ((SWIG_arg0 PARM0_f1)) - (let ((SWIG_arg1 PARM1_f2)) - (swig-ff-call SWIG_arg0 SWIG_arg1)))) - -(swig-defmethod ("foo" "ACL___foo__SWIG_1" :type :function :arity 2) - ((PARM0_f1 cl:single-float :float ) - (PARM1_c2 cl:character :char character)) - (:returning (:int ) - :call-direct t - :strings-convert nil) - (let ((SWIG_arg0 PARM0_f1)) - (let ((SWIG_arg1 PARM1_c2)) - (swig-ff-call SWIG_arg0 SWIG_arg1)))) - -(swig-dispatcher ("foo" :type :function :arities (2))) -(swig-defun ("bar" "ACL___bar__SWIG_0" :type :function) - ((PARM0_lisp_fn (* :void) )) - (:returning (:void ) - :release-heap :never - :optimize-for-space t - :strings-convert nil) - (let ((SWIG_arg0 PARM0_lisp_fn)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("xxx" "ACL___xxx__SWIG_0" :type :function) - (:void) - (:returning ((* :char) ) - :strings-convert t) - (swig-ff-call)) - </pre> - </div> - - <div class="code"> - <pre>%ffargs(strings_convert="t");</pre> - </div> - - <p> - Is the only default value specified in <tt>allegrocl.swg</tt> to force - the muffling of warnings about automatic string conversion when defining - ff:def-foreign-call's. - </p> - -<H3><a name="Allegrocl_nn10">20.2.4 Non-overloaded Defuns</a></H3> - - - <p> - These are simple defuns. There is no typechecking of arguments. - Parameters are bound to local variables for possible - transformation of values, such as pulling values out of instance - slots or allocating temporary stack allocated structures, via the - <tt>lin</tt> typemap. These arguments are then passed to the - foreign-call (where typechecking may occur). The return value from - this function can be manipulated via the <tt>lout</tt> typemap. - </p> - -<H3><a name="Allegrocl_nn11">20.2.5 Overloaded Defuns</a></H3> - - - <p> - In the case of overloaded functions, multiple layers are - generated. First, all the overloads for a given name are separated - out into groups based on arity, and are wrapped in - defmethods. Each method calls a distinct wrapper function, but are - themselves distinguished by the types of their arguments - (see <tt>lispclass</tt> typemap). These are further wrapped in a - dispatching function (defun) which will invoke the appropriate - generic-function based on arity. This provides a single functional - interface to all overloads. The return value from this function - can be manipulated via the <tt>lout</tt> typemap. - </p> - -<H3><a name="Allegrocl_nn12">20.2.6 What about constant and variable access?</a></H3> - - - <p> - Along with the described functional layering, when creating a .cxx wrapper, - this module will generate getter and--if not immutable--setter, - functions for variables and constants. If the -nocwrap option is used, - <tt>defconstant</tt> and <tt>ff:def-foreign-variable</tt> forms will be - generated for accessing constants and global variables. These, along with - the <tt>defuns</tt> listed above are the intended API for calling - into the foreign module. - </p> - -<H3><a name="Allegrocl_nn13">20.2.7 Object Wrapping</a></H3> - - - <p> - All non-primitive types (Classes, structs, unions, and typedefs - involving same) have a corresponding foreign-type defined on the - lisp side via ff:def-foreign-type. - </p> - - <p> - All non-primitive types are further represented by a CLOS class, - created via defclass. An attempt is made to create the same class - hierarchy, with all classes inheriting directly or indirectly from - ff:foreign-pointer. Further, wherever it is apparent, all pointers - returned from foreign code are wrapped in a CLOS instance of the - appropriate class. For ff:def-foreign-calls that have been defined - to expect a :foreign-address type as argument, these CLOS instances - can legally be passed and the pointer to the C++ object - automatically extracted. This is a natural feature of Allegro's - foreign function interface. - </p> - -<H2><a name="Allegrocl_nn14">20.3 Wrapping Details</a></H2> - - - <p> - In this section is described how particular C/C++ constructs are - translated into lisp. - </p> - -<H3><a name="Allegrocl_nn15">20.3.1 Namespaces</a></H3> - - - <p> - C++ namespaces are translated into Lisp packages by SWIG. The - Global namespace is mapped to a package named by the <tt>%module</tt> - directive or the <tt>-module</tt> command-line argument. Further - namespaces are generated by the <tt>swig-defpackage</tt> utility - function and given names based on Allegro CLs nested namespace - convention. For example: - </p> - - <div class="code">foo.i: - <pre> -%module foo - -%{ -#include "foo.h" -%} - -%include "foo.h" - -namespace car { - ... - namespace tires { - int do_something(int n); - } -} - </pre> - </div> - <p>Generates the following code. - </p> - <div class="targetlang">foo.cl - <pre> -(defpackage :foo - (:use :common-lisp :swig :ff :excl)) - -... - -(swig-defpackage ("car")) -(swig-defpackage ("car" "tires")) - -... - -(swig-in-package ("car" "tires")) -(swig-defun ("do_something" "ACL_car_tires__do_something__SWIG_0" :type :function) - ((PARM0_n :int )) - (:returning (:int ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_n)) - (swig-ff-call SWIG_arg0))) - </pre> - </div> - - <p> - The above interface file would cause packages foo, foo.car, and - foo.car.tires to be created. One would find the function wrapper - for do_something defined in the foo.car.tires package(*). - </p> - - <p>(<b>*</b>) Except for the package named by the module, all - namespace names are passed to the identifier-converter-function - as strings with a <tt>:type</tt> of <tt>:namespace</tt>. It is the - job of this function to generate the desired symbol, accounting for - case preferences, additional naming cues, etc. - </p> - - <p> - Note that packages created by <tt>swig-defpackage</tt> do not - use the COMMON-LISP or EXCL package. This reduces possible - conflicts when defining foreign types via the SWIG interface - in <b>all but the toplevel modules package</b>. This may - lead to confusion if, for example, the current package is - <tt>foo.car.tires</tt> and you attempt to use a common-lisp - function such as <tt>(car '(1 2 3)</tt>. - </p> - -<H3><a name="Allegrocl_nn16">20.3.2 Constants</a></H3> - - - - <p> - Constants, as declared by the preprocessor #define macro or SWIG - <tt>%constant</tt> directive, are included in SWIG's parse tree - when it can be determined that they are, or could be reduced to, - a literal value. Such values are translated into defconstant - forms in the generated lisp wrapper when the -nocwrap command-line - options is used. Else, wrapper functions are generated as in the - case of variable access (see section below). - </p> - <p> - Here are examples of simple preprocessor constants when using -nocwrap. - </p> - <div class="code"> - <pre> -#define A 1 => (swig-defconstant "A" 1) -#define B 'c' => (swig-defconstant "B" #\c) -#define C B => (swig-defconstant "C" #\c) -#define D 1.0e2 => (swig-defconstant "D" 1.0d2) -#define E 2222 => (swig-defconstant "E" 2222) -#define F (unsigned int)2222 => no code generated -#define G 1.02e2f => (swig-defconstant "G" 1.02f2) -#define H foo => no code generated - </pre> - </div> - - <p> - Note that where SWIG is unable to determine if a constant is - a literal, no node is added to the SWIG parse tree, and so - no values can be generated. - </p> - - <p> - For preprocessor constants containing expressions which can be - reduced to literal values, nodes are created, but with no simplification - of the constant value. A very very simple infix to prefix converter - has been implemented that tries to do the right thing for simple cases, but - does not for more complex expressions. If the literal parser determines - that something is wrong, a warning will be generated and the literal - expression will be included in the generated code, but commented out. - </p> - - <div class="code"> - <pre> -#define I A + E => (swig-defconstant "I" (+ 1 2222)) -#define J 1|2 => (swig-defconstant "J" (logior 1 2)) -#define Y 1 + 2 * 3 + 4 => (swig-defconstant "Y" (* (+ 1 2) (+ 3 4))) -#define Y1 (1 + 2) * (3 + 4) => (swig-defconstant "Y1" (* (+ 1 2) (+ 3 4))) -#define Y2 1 * 2 + 3 * 4 => (swig-defconstant "Y2" (* 1 (+ 2 3) 4)) ;; WRONG -#define Y3 (1 * 2) + (3 * 4) => (swig-defconstant "Y3" (* 1 (+ 2 3) 4)) ;; WRONG -#define Z 1 + 2 - 3 + 4 * 5 => (swig-defconstant "Z" (* (+ 1 (- 2 3) 4) 5)) ;; WRONG - </pre> - </div> - <p> - Users are cautioned to get to know their constants before use, or - not use the <tt>-nocwrap</tt> command-line option. - </p> - -<H3><a name="Allegrocl_nn17">20.3.3 Variables</a></H3> - - - <p> - For C wrapping, a def-foreign-variable call is generated for access - to global variables. - </p> - <p> - When wrapping C++ code, both global and member variables, getter - wrappers are generated for accessing their value, and if not immutable, - setter wrappers as well. In the example below, note the lack of a - setter wrapper for global_var, defined as const. - </p> - - <div class="code">vars.h - <pre> -namespace nnn { - int const global_var = 2; - float glob_float = 2.0; -} - </pre> - </div> - - <p> - Generated code: - </p> - <div class="targetlang">vars.cl - <pre> -(swig-in-package ("nnn")) -(swig-defun ("global_var" "ACL_nnn__global_var_get__SWIG_0" :type :getter) - (:void) - (:returning (:int ) - :strings-convert t) - (swig-ff-call)) - - -(swig-defun ("glob_float" "ACL_nnn__glob_float_set__SWIG_0" :type :setter) - ((PARM0_glob_float :float )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_glob_float)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("glob_float" "ACL_nnn__glob_float_get__SWIG_0" :type :getter) - (:void) - (:returning (:float ) - :strings-convert t) - (swig-ff-call)) - </pre> - </div> - - <p> - Note also, that where applicable, setter wrappers are implemented - as setf methods on the getter function, providing a lispy interface - to the foreign code. - </p> - - <div class="targetlang"> - <pre> -user> (load "globalvar.dll") -; Foreign loading globalvar.dll. -t -user> (load "globalvar.cl") -; Loading c:\mikel\src\swig\test\globalvar.cl -t -user> -globalvar> (globalvar.nnn::global_var) -2 -globalvar> (globalvar.nnn::glob_float) -2.0 -globalvar> (setf (globalvar.nnn::glob_float) 3.0) -3.0 -globalvar> (globalvar.nnn::glob_float) -3.0 - </pre> - </div> - -<H3><a name="Allegrocl_nn18">20.3.4 Enumerations</a></H3> - - - <p> - In C, an enumeration value is an integer value, while in C++ an - enumeration value is implicitly convertible to an integer value, - but can also be distinguished by its enum type. For each enum - declaration a def-foreign-type is generated, assigning the enum - a default type of :int. Users may adjust the foreign type of - enums via SWIG <tt>typemaps</tt>. - </p> - - <p> - Enum values are a bit trickier as they can be initialized using - any valid C/C++ expression. In C with the -nocwrap command-line option, - we handle the typical cases (simple integer initialization) and - generate a defconstant form for each enum value. This has the advantage - of it not being necessary to probe into foreign space to retrieve enum - values. When generating a .cxx wrapper file, a more general solution is - employed. A wrapper variable is created in the module_wrap.cxx file, and - a ff:def-foreign-variable call is generated to retrieve its value into lisp. - </p> - - <p>For example, the following header file - <div class="code">enum.h: - <pre> -enum COL { RED, GREEN, BLUE }; -enum FOO { FOO1 = 10, FOO2, FOO3 }; - </pre> - </div> - <p> - In -nocwrap mode, generates - </p> - <div class="targetlang">enum.cl: - <pre> -(swig-def-foreign-type "COL" :int) -(swig-defconstant "RED" 0) -(swig-defconstant "GREEN" (+ #.(swig-insert-id "RED" () :type :constant) 1)) -(swig-defconstant "BLUE" (+ #.(swig-insert-id "GREEN" () :type :constant) 1)) - -(swig-def-foreign-type "FOO" :int) -(swig-defconstant "FOO1" 10) -(swig-defconstant "FOO2" (+ #.(swig-insert-id "FOO1" () :type :constant) 1)) -(swig-defconstant "FOO3" (+ #.(swig-insert-id "FOO2" () :type :constant) 1)) - </pre> - </div> - - <p>And when generating a .cxx wrapper - <div class="code">enum_wrap.cxx: - <pre> -EXPORT const int ACL_ENUM___RED__SWIG_0 = RED; -EXPORT const int ACL_ENUM___GREEN__SWIG_0 = GREEN; -EXPORT const int ACL_ENUM___BLUE__SWIG_0 = BLUE; -EXPORT const int ACL_ENUM___FOO1__SWIG_0 = FOO1; -EXPORT const int ACL_ENUM___FOO2__SWIG_0 = FOO2; -EXPORT const int ACL_ENUM___FOO3__SWIG_0 = FOO3; - </pre> - </div> - <p> - and - </p> - <div class="targetlang">enum.cl: - <pre> -(swig-def-foreign-type "COL" :int) -(swig-defvar "RED" "ACL_ENUM___RED__SWIG_0" :type :constant) -(swig-defvar "GREEN" "ACL_ENUM___GREEN__SWIG_0" :type :constant) -(swig-defvar "BLUE" "ACL_ENUM___BLUE__SWIG_0" :type :constant) - -(swig-def-foreign-type "FOO" :int) -(swig-defvar "FOO1" "ACL_ENUM___FOO1__SWIG_0" :type :constant) -(swig-defvar "FOO2" "ACL_ENUM___FOO2__SWIG_0" :type :constant) -(swig-defvar "FOO3" "ACL_ENUM___FOO3__SWIG_0" :type :constant) - - </pre> - </div> - -<H3><a name="Allegrocl_nn19">20.3.5 Arrays</a></H3> - - - <p> - One limitation in the Allegro CL foreign-types module, is that, - without macrology, expressions may not be used to specify the - dimensions of an array declaration. This is not a horrible - drawback unless it is necessary to allocate foreign structures - based on the array declaration using ff:allocate-fobject. When it - can be determined that an array bound is a valid numeric value, - SWIG will include this in the generated array declaration on the - lisp side, otherwise the value will be included, but commented out. - </p> - - <p> - Below is a comprehensive example, showing a number of legal - C/C++ array declarations and how they are translated - into foreign-type specifications in the generated lisp code. - </p> - <div class="code">array.h - <pre> -#define MAX_BUF_SIZE 1024 - -namespace FOO { - int global_var1[13]; - float global_var2[MAX_BUF_SIZE]; - -} - -enum COLOR { RED = 10, GREEN = 20, BLUE, PURPLE = 50, CYAN }; - -namespace BAR { - char global_var3[MAX_BUF_SIZE + 1]; - float global_var4[MAX_BUF_SIZE][13]; - signed short global_var5[MAX_BUF_SIZE + MAX_BUF_SIZE]; - - int enum_var5[GREEN]; - int enum_var6[CYAN]; - - COLOR enum_var7[CYAN][MAX_BUF_SIZE]; -} - </pre> - </div> - - <p> - Generates: - </p> - - <div class="targetlang">array.cl - <pre> -(in-package #.*swig-module-name*) - -(swig-defpackage ("FOO")) -(swig-defpackage ("BAR")) - -(swig-in-package ()) -(swig-def-foreign-type "COLOR" :int) -(swig-defvar "RED" "ACL_ENUM___RED__SWIG_0" :type :constant) -(swig-defvar "GREEN" "ACL_ENUM___GREEN__SWIG_0" :type :constant) -(swig-defvar "BLUE" "ACL_ENUM___BLUE__SWIG_0" :type :constant) -(swig-defvar "PURPLE" "ACL_ENUM___PURPLE__SWIG_0" :type :constant) -(swig-defvar "CYAN" "ACL_ENUM___CYAN__SWIG_0" :type :constant) - -(swig-in-package ()) - -(swig-defconstant "MAX_BUF_SIZE" 1024) -(swig-in-package ("FOO")) - -(swig-defun ("global_var1" "ACL_FOO__global_var1_get__SWIG_0" :type :getter) - (:void) - (:returning ((* :int) ) - :strings-convert t) - (make-instance 'ff:foreign-pointer :foreign-address (swig-ff-call))) - - -(swig-defun ("global_var2" "ACL_FOO__global_var2_set__SWIG_0" :type :setter) - ((global_var2 (:array :float 1024) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 global_var2)) - (swig-ff-call SWIG_arg0))) - - -(swig-in-package ()) -(swig-in-package ("BAR")) -(swig-defun ("global_var3" "ACL_BAR__global_var3_set__SWIG_0" :type :setter) - ((global_var3 (:array :char #|1024+1|#) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 global_var3)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("global_var4" "ACL_BAR__global_var4_set__SWIG_0" :type :setter) - ((global_var4 (:array (:array :float 13) 1024) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 global_var4)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("global_var4" "ACL_BAR__global_var4_get__SWIG_0" :type :getter) - (:void) - (:returning ((* (:array :float 13)) ) - :strings-convert t) - (make-instance 'ff:foreign-pointer :foreign-address (swig-ff-call))) - - -(swig-defun ("global_var5" "ACL_BAR__global_var5_set__SWIG_0" :type :setter) - ((global_var5 (:array :short #|1024+1024|#) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 global_var5)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("enum_var5" "ACL_BAR__enum_var5_set__SWIG_0" :type :setter) - ((enum_var5 (:array :int #|GREEN|#) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 enum_var5)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("enum_var6" "ACL_BAR__enum_var6_set__SWIG_0" :type :setter) - ((enum_var6 (:array :int #|CYAN|#) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 enum_var6)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("enum_var7" "ACL_BAR__enum_var7_set__SWIG_0" :type :setter) - ((enum_var7 (:array (:array #.(swig-insert-id "COLOR" ()) 1024) #|CYAN|#) )) - (:returning (:void ) - :strings-convert t) - (let ((SWIG_arg0 enum_var7)) - (swig-ff-call SWIG_arg0))) - - -(swig-defun ("enum_var7" "ACL_BAR__enum_var7_get__SWIG_0" :type :getter) - (:void) - (:returning ((* (:array #.(swig-insert-id "COLOR" ()) 1024)) ) - :strings-convert t) - (make-instance 'ff:foreign-pointer :foreign-address (swig-ff-call))) - </pre> - </div> - -<H3><a name="Allegrocl_nn20">20.3.6 Classes and Structs and Unions (oh my!)</a></H3> - - -<H4><a name="Allegrocl_nn21">20.3.6.1 CLOS wrapping of</a></H4> - - - <p> - Classes, unions, and structs are all treated the same way by the - interface generator. For any of these objects, a - def-foreign-type and a defclass form are generated. For every - function that returns an object (or pointer/reference) of C/C++ - type <tt>X</tt>, the wrapping defun (or defmethod) on the Lisp - side will automatically wrap the pointer returned in an instance - of the appropriate class. This makes it much easier to write and - debug code than if pointers were passed around as a jumble of - integer values. - </p> - -<H4><a name="Allegrocl_nn22">20.3.6.2 CLOS Inheritance</a></H4> - - - <p> - The CLOS class schema generated by the interface mirrors the - inheritance of the classes in foreign code, with the - ff:foreign-pointer class at its root. ff:foreign-pointer is a thin - wrapper for pointers that is made available by the foreign function - interface. Its key benefit is that it may be passed as an argument - to any ff:def-foreign-call that is expecting a pointer as the - parameter. - </p> - -<H4><a name="Allegrocl_nn23">20.3.6.3 Member fields and functions</a></H4> - - - <p> - All public fields will have accessor getter/setter functions - generated for them, as appropriate. All public member functions - will have wrapper functions generated. - </p> - - <p> - We currently ignore anything that isn't <tt>public</tt> (i.e. - <tt>private</tt> or <tt>protected</tt>), because the C++ compiler - won't allow the wrapper functions to access such fields. Likewise, - the interface does nothing for <tt>friend</tt> directives, - </p> - -<H4><a name="Allegrocl_nn24">20.3.6.4 Why not directly access C++ classes using foreign types?</a></H4> - - - <p> - The def-foreign-type generated by the SWIG interface is - currently incomplete. We can reliably generate the object layout - of simple structs and unions; they can be allocated via - ff:allocate-fobject, and their member variables accessed - directly using the various ff:fslot-value-* functions. However, - the layout of C++ classes is more complicated. Different - compilers adjust class layout based on inheritance patterns, and - the presence of virtual member functions. The size of member - function pointers vary across compilers as well. As a result, it - is recommended that users of any generated interface not attempt - to access C++ instances via the foreign type system, but instead - use the more robust wrapper functions. - </p> - -<H3><a name="Allegrocl_nn25">20.3.7 Templates</a></H3> - - - -<H4><a name="Allegrocl_nn26">20.3.7.1 Generating wrapper code for templates</a></H4> - - -<p> -SWIG provides support for dealing with templates, but by -default, it will not generate any member variable or function -wrappers for templated classes. In order to create these -wrappers, you need to explicitly tell SWIG to instantiate -them. This is done via the -<a href="SWIGPlus.html#SWIGPlus_nn30"><tt>%template</tt></a> -directive. -</p> - -<H4><a name="Allegrocl_nn27">20.3.7.2 Implicit Template instantiation</a></H4> - - -<p> -While no wrapper code is generated for accessing member -variables, or calling member functions, type code is generated -to include these templated classes in the foreign-type and CLOS -class schema. -</p> - -<H3><a name="Allegrocl_nn28">20.3.8 Typedef, Templates, and Synonym Types</a></H3> - - - <p> - In C/C++ it is possible, via typedef, to have many names refer to - the same <tt>type</tt>. In general, this is not a problem, though - it can lead to confusion. Assume the below C++ header file: - </p> - - <div class="code">synonyms.h - <pre> -class A { - int x; - int y; -}; - -typedef A Foo; - -A *xxx(int i); /* sets A->x = A->y = i */ -Foo *yyy(int i); /* sets Foo->x = Foo->y = i */ - -int zzz(A *inst = 0); /* return inst->x + inst->y */ - </pre> - </div> - - <p> - The function <tt>zzz</tt> is an overloaded functions; the - foreign function call to it will be wrapped in a - generic-function whose argument will be checked against a type - of <tt>A</tt>. Assuming a simple implementation, a call - to <tt>xxx(1)</tt> will return a pointer to an A object, which - will be wrapped in a CLOS instance of class <tt>A</tt>, and a - call to <tt>yyy(1)</tt> will result in a CLOS instance of - type <tt>Foo</tt> being returned. Without establishing a clear - type relationship between <tt>Foo</tt> and <tt>A</tt>, an - attempt to call <tt>zzz(yyy(1))</tt> will result in an error. - </p> - - <p> - We resolve this issue, by noting synonym relationships between - types while generating the interface. A Primary type is selected - (more on this below) from the candidate list of synonyms. For - all other synonyms, instead of generating a distinct CLOS class - definition, we generate a form that expands to: - </p> - <div class="targetlang"> - <tt>(setf (find-class <synonym>) <primary>)</tt> - </div> - <p> - The result is that all references to synonym types in foreign - code, are wrapped in the same CLOS wrapper, and, in particular, - method specialization in wrapping generic functions works as - expected. - </p> - - <p> - Given the above header file, synonym.h, a Lisp session would - appear as follows: - </p> - <div class="targetlang"> - <pre> -CL-USER> (load "synonym.dll") -; Foreign loading synonym.dll. -t -CL-USER> (load "synonym.cl") -; Loading c:\mikel\src\swig\test\synonym.cl -t -CL-USER> -synonym> (setf a (xxx 3)) -#<A nil #x3261a0 @ #x207299da> -synonym> (setf foo (yyy 10)) -#<A nil #x3291d0 @ #x2072e982> -synonym> (zzz a) -6 -synonym> (zzz foo) -20 -synonym> - </pre> - </div> - -<H4><a name="Allegrocl_nn29">20.3.8.1 Choosing a primary type</a></H4> - - - <p> - The choice of a primary type is selected by the following - criteria from a set of synonym types. - </p> - <ul> - <li> - If a synonym type has a class definition, it is the primary type. - </li> - <li> - If a synonym type is a class template and has been explicitly - instantiated via <tt>%template</tt>, it is the primary type. - </li> - <li> - For all other sets of synonymous types, the synonym which is - parsed first becomes the primary type. - </li> - </ul> - -<H3><a name="Allegrocl_nn30">20.3.9 Function overloading/Parameter defaulting</a></H3> - - - <p> - For each possible argument combination, a distinct wrapper - function is created in the .cxx file. On the Lisp side, a - generic functions is defined for each possible arity the - overloaded/defaulted call may have. Each distinct wrapper is - then called from within a defmethod on the appropriate generic - function. These are further wrapped inside a dispatch function - that checks the number of arguments it is called with and passes - them via apply to the appropriate generic-function. This allows - for a single entry point to overloaded functions on the lisp - side. - </p> - - <p>Example: - </p> - <div class="code">overload.h: - <pre> - -class A { - public: - int x; - int y; -}; - -float xxx(int i, int x = 0); /* return i * x */ -float xxx(A *inst, int x); /* return x + A->x + A->y */ - </pre> - </div> - - <p>Creates the following three wrappers, for each of the possible argument - combinations - </p> - <div class="code">overload_wrap.cxx - <pre> -EXPORT void ACL___delete_A__SWIG_0 (A *larg1) { - A *arg1 = (A *) 0 ; - - arg1 = larg1; - try { - delete arg1; - - } catch (...) { - - } -} - - -EXPORT float ACL___xxx__SWIG_0 (int larg1, int larg2) { - float lresult = (float)0 ; - int arg1 ; - int arg2 ; - float result; - - arg1 = larg1; - arg2 = larg2; - try { - result = (float)xxx(arg1, arg2); - - lresult = result; - return lresult; - } catch (...) { - return (float)0; - } -} - - -EXPORT float ACL___xxx__SWIG_1 (int larg1) { - float lresult = (float)0 ; - int arg1 ; - float result; - - arg1 = larg1; - try { - result = (float)xxx(arg1); - - lresult = result; - return lresult; - } catch (...) { - return (float)0; - } -} - - -EXPORT float ACL___xxx__SWIG_2 (A *larg1, int larg2) { - float lresult = (float)0 ; - A *arg1 = (A *) 0 ; - int arg2 ; - float result; - - arg1 = larg1; - arg2 = larg2; - try { - result = (float)xxx(arg1, arg2); - - lresult = result; - return lresult; - } catch (...) { - return (float)0; - } -} - </pre> - </div> - - <p> - And the following foreign-function-call and method definitions on the - lisp side: - </p> - <div class="targetlang">overload.cl - <pre> -(swig-defmethod ("xxx" "ACL___xxx__SWIG_0" :type :function :arity 2) - ((PARM0_i cl:integer :int ) - (PARM1_x cl:integer :int )) - (:returning (:float ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_i)) - (let ((SWIG_arg1 PARM1_x)) - (swig-ff-call SWIG_arg0 SWIG_arg1)))) - -(swig-defmethod ("xxx" "ACL___xxx__SWIG_1" :type :function :arity 1) - ((PARM0_i cl:integer :int )) - (:returning (:float ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_i)) - (swig-ff-call SWIG_arg0))) - -(swig-defmethod ("xxx" "ACL___xxx__SWIG_2" :type :function :arity 2) - ((PARM0_inst #.(swig-insert-id "A" () :type :class) (* #.(swig-insert-id "A" ())) ) - (PARM1_x cl:integer :int )) - (:returning (:float ) - :strings-convert t) - (let ((SWIG_arg0 PARM0_inst)) - (let ((SWIG_arg1 PARM1_x)) - (swig-ff-call SWIG_arg0 SWIG_arg1)))) - -(swig-dispatcher ("xxx" :type :function :arities (1 2))) - </pre> - </div> - - <p>And their usage in a sample lisp session: - </p> - <div class="targetlang"> - <pre> -overload> (setf a (new_A)) -#<A nil #x329268 @ #x206cf612> -overload> (setf (A_x a) 10) -10 -overload> (setf (A_y a) 20) -20 -overload> (xxx 1) -0.0 -overload> (xxx 3 10) -30.0 -overload> (xxx a 1) -31.0 -overload> (xxx a 2) -32.0 -overload> - </pre> - </div> - -<H3><a name="Allegrocl_nn31">20.3.10 Operator wrapping and Operator overloading</a></H3> - - - <p> - Wrappers to defined C++ Operators are automatically renamed, using - <tt>%rename</tt>, to the following defaults: - </p> - <div class="code"> - <pre> -/* name conversion for overloaded operators. */ -#ifdef __cplusplus -%rename(__add__) *::operator+; -%rename(__pos__) *::operator+(); -%rename(__pos__) *::operator+() const; - -%rename(__sub__) *::operator-; -%rename(__neg__) *::operator-() const; -%rename(__neg__) *::operator-(); - -%rename(__mul__) *::operator*; -%rename(__deref__) *::operator*(); -%rename(__deref__) *::operator*() const; - -%rename(__div__) *::operator/; -%rename(__mod__) *::operator%; -%rename(__logxor__) *::operator^; -%rename(__logand__) *::operator&; -%rename(__logior__) *::operator|; -%rename(__lognot__) *::operator~(); -%rename(__lognot__) *::operator~() const; - -%rename(__not__) *::operator!(); -%rename(__not__) *::operator!() const; - -%rename(__assign__) *::operator=; - -%rename(__add_assign__) *::operator+=; -%rename(__sub_assign__) *::operator-=; -%rename(__mul_assign__) *::operator*=; -%rename(__div_assign__) *::operator/=; -%rename(__mod_assign__) *::operator%=; -%rename(__logxor_assign__) *::operator^=; -%rename(__logand_assign__) *::operator&=; -%rename(__logior_assign__) *::operator|=; - -%rename(__lshift__) *::operator<<; -%rename(__lshift_assign__) *::operator<<=; -%rename(__rshift__) *::operator>>; -%rename(__rshift_assign__) *::operator>>=; - -%rename(__eq__) *::operator==; -%rename(__ne__) *::operator!=; -%rename(__lt__) *::operator<; -%rename(__gt__) *::operator>; -%rename(__lte__) *::operator<=; -%rename(__gte__) *::operator>=; - -%rename(__and__) *::operator&&; -%rename(__or__) *::operator||; - -%rename(__preincr__) *::operator++(); -%rename(__postincr__) *::operator++(int); -%rename(__predecr__) *::operator--(); -%rename(__postdecr__) *::operator--(int); - -%rename(__comma__) *::operator,(); -%rename(__comma__) *::operator,() const; - -%rename(__member_ref__) *::operator->; -%rename(__member_func_ref__) *::operator->*; - -%rename(__funcall__) *::operator(); -%rename(__aref__) *::operator[]; - </pre> - </div> - - <p> - Name mangling occurs on all such renamed identifiers, so that wrapper name - generated by <tt>B::operator=</tt> will be <tt>B___eq__</tt>, i.e. - <tt><class-or-namespace>_</tt> has been added. Users may modify - these default names by adding <tt>%rename</tt> directives in their own .i files. - </p> - - <p> - Operator overloading can be achieved by adding functions based - on the mangled names of the function. In the following example, - a class B is defined with a Operator== method defined. The - swig <tt>%extend</tt> directive is used to add an overload method - on Operator==. - </p> - - <div class="code">opoverload.h - <pre> -class B { - public: - int x; - int y; - bool operator==(B const& other) const; -}; - </pre> - </div> - - <p> - and - </p> - <div class="code">opoverload.i - <pre> -%module opoverload - -%{ -#include <fstream> -#include "opoverload.h" -%} - -%{ -bool B___eq__(B const *inst, int const x) -{ - // insert the function definition into the wrapper code before - // the wrapper for it. - // ... do stuff ... -} -%} - -%include "opoverload.h" - -%extend B { - public: - bool __eq__(int const x) const; -}; - </pre> - </div> - - <p> - Either operator can be called via a single call - to the dispatch function: - </p> - <div class="targetlang"> - <pre> -opoverload> (B___eq__ x1 x2) -nil -opoverload> (B___eq__ x1 3) -nil -opoverload> - </pre> - </div> - -<H3><a name="Allegrocl_nn32">20.3.11 Varargs</a></H3> - - - <p> - Variable length argument lists are not supported, by default. If - such a function is encountered, a warning will generated to - stderr. Varargs are supported via the SWIG <tt>%varargs</tt> - directive. This directive allows you to specify a (finite) - argument list which will be inserted into the wrapper in place - of the variable length argument indicator. As an example, - consider the function <tt>printf()</tt>. Its declaration would - appear as follows: - </p> - - <p> - See the following section - on <a href="Varargs.html#Varargs">Variable Length arguments</a> - provides examples on how <tt>%varargs</tt> can be used, along - with other ways such functions can be wrapped. - </p> - -<H3><a name="Allegrocl_nn33">20.3.12 C++ Exceptions</a></H3> - - - <p> - Each C++ wrapper includes a handler to catch any exceptions that may - be thrown while in foreign code. This helps prevent simple C++ errors - from killing the entire lisp process. There is currently no mechanism - to have these exceptions forwarded to the lisp condition system, nor - has any explicit support of the exception related SWIG typemaps been - implemented. - </p> - -<H3><a name="Allegrocl_nn34">20.3.13 Pass by value, pass by reference</a></H3> - - - <p> - Allegro CL does not support the passing of non-primitive foreign - structures by value. As a result, SWIG must automatically detect - and convert function parameters and return values to pointers - whenever necessary. This is done via the use of <tt>typemaps</tt>, - and should not require any fine tuning by the user, even for - newly defined types. - </p> - -<H2><a name="Allegrocl_nn35">20.4 Typemaps</a></H2> - - -<p> - SWIG Typemaps provide a powerful tool for automatically generating - code to handle various menial tasks required of writing an interface - to foreign code. The purpose of this section is to describe each of - the typemaps used by the Allegro CL module. Please read the chapter - on <a href="Typemaps.html#Typemaps">Typemaps</a> for more information. -</p> - -<H3><a name="Allegrocl_nn36">20.4.1 Code Generation in the C++ Wrapper</a></H3> - - - - <p> - Every C++ wrapper generated by SWIG takes the following form: - </p> - - <div class="diagram"> - <pre> -return-val wrapper-name(parm0, parm1, ..., parmN) -{ - return-val lresult; /* return value from wrapper */ - <local-declaration> - ... results; /* return value from function call */ - - <binding locals to parameters> - - try { - result = function-name(local0, local1, ..., localN); - - <convert and bind result to lresult> - - return lresult; - catch (...) { - return (int)0; - } - </pre> - </div> - -<H4><a name="Allegrocl_nn37">20.4.1.1 IN Typemap</a></H4> - - - <p> - the <tt>in</tt> typemap is used to generate code to convert parameters - passed to C++ wrapper functions into the arguments desired for the - call being wrapped. That is, it fills in the code for the - <tt><binding locals to parameters></tt> section above. We - use this map to automatically convert parameters passed by - reference to the wrapper function into by-value arguments for - the wrapped call, and also to convert boolean values, which are - passed as integers from lisp (by default), into the appropriate - type for the language of code being wrapped. - </p> - - <p>These are the default specifications for the IN typemap. Here, - <tt>$input</tt> refers to the parameter code is being generated - for, and <tt>$1</tt> is the local variable to which it is - being assigned. The default settings of this typemap are as follows: - </p> - - <div class="code"> - <pre> -%typemap(in) bool "$1 = (bool)$input;"; -%typemap(in) char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, void, - enum SWIGTYPE, SWIGTYPE *, - SWIGTYPE[ANY], SWIGTYPE & "$1 = $input;"; -%typemap(in) SWIGTYPE "$1 = *$input;"; - </pre> - </div> - -<H4><a name="Allegrocl_nn38">20.4.1.2 OUT Typemap</a></H4> - - - <p> - The <tt>out</tt> typemap is used to generate code to form the - return value of the wrapper from the return value of the wrapped - function. This code is placed in the <convert and bind result to lresult> - section of the above code diagram. Its default mapping is as follows: - </p> - - <div class="code"> - <pre> -%typemap(out) bool "$result = (int)$1;"; -%typemap(out) char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, void, - enum SWIGTYPE, SWIGTYPE *, - SWIGTYPE[ANY], SWIGTYPE & "$result = $1;"; -%typemap(out) SWIGTYPE "$result = new $1_type($1);"; - </pre> - </div> - -<H4><a name="Allegrocl_nn39">20.4.1.3 CTYPE Typemap</a></H4> - - - <p> - This typemap is not used for code generation, but purely for the - transformation of types in the parameter list of the wrapper function. - Its primary use is to handle by-value to by-reference conversion in the - wrappers parameter list. Its default settings are: - </p> - - <div class="code"> - <pre> -%typemap(ctype) bool "int"; -%typemap(ctype) char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, void, - enum SWIGTYPE, SWIGTYPE *, - SWIGTYPE[ANY], SWIGTYPE & "$1_ltype"; -%typemap(ctype) SWIGTYPE "$&1_type"; - </pre> - </div> - - <p> - These three typemaps are specifically employed by the - Allegro CL interface generator. SWIG also implements a number of - other typemaps that can be used for generating code in the C/C++ - wrappers. You can read about - these <a href="Typemaps.html#Typemaps_nn25">common typemaps</a> here. - </p> - -<H3><a name="Allegrocl_nn40">20.4.2 Code generation in Lisp wrappers</a></H3> - - - <p> - A number of custom typemaps have also been added to facilitate - the generation of code in the lisp side of the interface. These - are described below. The basic code generation structure is - applied as a series of nested expressions, one for each - parameter, then one for manipulating the return value, and last, - the foreign function call itself. - </p> - - <p> - Note that the typemaps below use fully qualified symbols where - necessary. Users writing their own typemaps should do likewise. - See the explanation in the last paragraph of - <a href="#Allegrocl_nn15">16.3.1 Namespaces</a> for details. - </p> - -<H4><a name="Allegrocl_nn41">20.4.2.1 LIN Typemap</a></H4> - - - <p> - The LIN typemap allows for the manipulating the lisp objects - passed as arguments to the wrapping defun before passing them to - the foreign function call. For example, when passing lisp - strings to foreign code, it is often necessary to copy the - string into a foreign structure of type (:char *) of appropriate - size, and pass this copy to the foreign call. Using the LIN - typemap, one could arrange for the stack-allocation of a foreign - char array, copy your string into it, and not have to worry - about freeing the copy after the function returns. - </p> - - <p>The LIN typemap accepts the following <tt>$variable</tt> references. - </p> - <ul> - <li><tt>$in</tt> - expands to the name of the parameter being - applied to this typemap - </li> - <li><tt>$out</tt> - expands to the name of the local variable - assigned to this typemap - </li> - <li><tt>$in_fftype</tt> - the foreign function type of the C type.</li> - <li><tt>$*in_fftype</tt> - the foreign function type of the C type - with one pointer removed. If there is no pointer, then $*in_fftype - is the same as $in_fftype. - </li> - <li><tt>$body</tt> - very important. Instructs SWIG where - subsequent code generation steps should be inserted into the - current typemap. Leaving out a <tt>$body</tt> reference - will result in lisp wrappers that do very little by way of - calling into foreign code. Not recommended. - </li> - </ul> - - <div class="code"> - <pre> -%typemap(lin) SWIGTYPE "(cl:let (($out $in))\n $body)"; - </pre> - </div> - -<H4><a name="Allegrocl_nn42">20.4.2.2 LOUT Typemap</a></H4> - - - <p> - The LOUT typemap is the means by which we effect the wrapping of - foreign pointers in CLOS instances. It is applied after all LIN - typemaps, and immediately before the actual foreign-call. - </p> - - <p>The LOUT typemap uses the following $variable - </p> - <ul> - <li><tt>$lclass</tt> - Expands to the CLOS class that - represents foreign-objects of the return type matching this - typemap. - </li> - <li><tt>$body</tt> - Same as for the LIN map. Place this - variable where you want the foreign-function call to occur. - </li> - <li><tt>$ldestructor</tt> - Expands to the symbol naming the destructor for this - class ($lclass) of object. Allows you to insert finalization or automatic garbage - collection into the wrapper code (see default mappings below). - </li> - </ul> - - <div class="code"> - <pre> -%typemap(lout) bool, char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, void, - enum SWIGTYPE "$body"; -%typemap(lout) SWIGTYPE[ANY], SWIGTYPE *, - SWIGTYPE & "(cl:make-instance '$lclass :foreign-address $body)"; -%typemap(lout) SWIGTYPE "(cl:let* ((address $body)\n - (ACL_result (cl:make-instance '$lclass :foreign-address address)))\n - (cl:unless (cl::zerop address)\n - (excl:schedule-finalization ACL_result #'$ldestructor))\n - ACL_result)"; - </pre> - </div> - -<H4><a name="Allegrocl_nn43">20.4.2.3 FFITYPE Typemap</a></H4> - - - - <p> - The FFITYPE typemap works as a helper for a body of code that - converts C/C++ type specifications into Allegro CL foreign-type - specifications. These foreign-type specifications appear in - ff:def-foreing-type declarations, and in the argument list and - return values of ff:def-foreign-calls. You would modify this - typemap if you want to change how the FFI passes through - arguments of a given type. For example, if you know that a - particular compiler represents booleans as a single byte, you - might add an entry for: - </p> - - <div class="code"> - <pre> -%typemap(ffitype) bool ":unsigned-char"; - </pre> - </div> - - <p> - Note that this typemap is pure type transformation, and is not - used in any code generations step the way the LIN and LOUT - typemaps are. The default mappings for this typemap are: - </p> - - <div class="code"> - <pre> -%typemap(ffitype) bool ":int"; -%typemap(ffitype) char ":char"; -%typemap(ffitype) unsigned char ":unsigned-char"; -%typemap(ffitype) signed char ":char"; -%typemap(ffitype) short, signed short ":short"; -%typemap(ffitype) unsigned short ":unsigned-short"; -%typemap(ffitype) int, signed int ":int"; -%typemap(ffitype) unsigned int ":unsigned-int"; -%typemap(ffitype) long, signed long ":long"; -%typemap(ffitype) unsigned long ":unsigned-long"; -%typemap(ffitype) float ":float"; -%typemap(ffitype) double ":double"; -%typemap(ffitype) char * "(* :char)"; -%typemap(ffitype) void * "(* :void)"; -%typemap(ffitype) void ":void"; -%typemap(ffitype) enum SWIGTYPE ":int"; -%typemap(ffitype) SWIGTYPE & "(* :void)"; - </pre> - </div> - -<H4><a name="Allegrocl_nn44">20.4.2.4 LISPTYPE Typemap</a></H4> - - - <p> - This is another type only transformation map, and is used to - provide the lisp-type, which is the optional third argument in - argument specifier in a ff:def-foreign-call form. Specifying a - lisp-type allows the foreign call to perform type checking on - the arguments passed in. The default entries in this typemap are: - </p> - - <div class="code"> - <pre> -%typemap(lisptype) bool "cl:boolean"; -%typemap(lisptype) char "cl:character"; -%typemap(lisptype) unsigned char "cl:integer"; -%typemap(lisptype) signed char "cl:integer"; - </pre> - </div> - -<H4><a name="Allegrocl_nn45">20.4.2.5 LISPCLASS Typemap</a></H4> - - - <p> - The LISPCLASS typemap is used to generate the method signatures - for the generic-functions which wrap overloaded functions and - functions with defaulted arguments. The default entries are: - </p> - - <div class="code"> - <pre> -%typemap(lispclass) bool "t"; -%typemap(lispclass) char "cl:character"; -%typemap(lispclass) unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - enum SWIGTYPE "cl:integer"; -%typemap(lispclass) float "cl:single-float"; -%typemap(lispclass) double "cl:double-float"; -%typemap(lispclass) char * "cl:string"; - </pre> - </div> - -<H3><a name="Allegrocl_nn46">20.4.3 Modifying SWIG behavior using typemaps</a></H3> - - - <p> - The following example shows how we made use of the above - typemaps to add support for the wchar_t type. - </p> - - <div class="code"> - <pre> -%typecheck(SWIG_TYPECHECK_UNICHAR) wchar_t { $1 = 1; }; - -%typemap(in) wchar_t "$1 = $input;"; -%typemap(lin) wchar_t "(cl:let (($out (cl:char-code $in)))\n $body)"; -%typemap(lin) wchar_t* "(excl:with-native-string - ($out $in - :external-format #+little-endian :fat-le - #-little-endian :fat)\n - $body)" - -%typemap(out) wchar_t "$result = $1;"; -%typemap(lout) wchar_t "(cl:code-char $body)"; -%typemap(lout) wchar_t* "(excl:native-to-string $body - :external-format #+little-endian :fat-le - #-little-endian :fat)"; - -%typemap(ffitype) wchar_t ":unsigned-short"; -%typemap(lisptype) wchar_t ""; -%typemap(ctype) wchar_t "wchar_t"; -%typemap(lispclass) wchar_t "cl:character"; -%typemap(lispclass) wchar_t* "cl:string"; - </pre> - </div> - -<H2><a name="Allegrocl_nn47">20.5 Identifier Converter functions</a></H2> - - -<H3><a name="Allegrocl_nn48">20.5.1 Creating symbols in the lisp environment</a></H3> - - -<p> - Various symbols must be generated in the lisp environment to which - class definitions, functions, constants, variables, etc. must be - bound. Rather than force a particular convention for naming these - symbols, an identifier (to symbol) conversion function is used. A - user-defined identifier-converter can then implement any symbol - naming, case-modifying, scheme desired. -</p> - -<p> - In generated SWIG code, whenever some interface object must be - referenced by its lisp symbol, a macro is inserted that calls the - identifier-converter function to generate the appropriate symbol - reference. It is therefore expected that the identifier-converter - function reliably return the same (eq) symbol given the same set - of arguments. -</p> - -<H3><a name="Allegrocl_nn49">20.5.2 Existing identifier-converter functions</a></H3> - - - <p>Two basic identifier routines have been defined. -<H4><a name="Allegrocl_nn50">20.5.2.1 identifier-convert-null</a></H4> - - - <p> - No modification of the identifier string is performed. Based on - other arguments, the identifier may be concatenated with other - strings, from which a symbol will be created. - </p> - -<H4><a name="Allegrocl_nn51">20.5.2.2 identifier-convert-lispify</a></H4> - - - <p> - All underscores in the identifier string are converted to - hyphens. Otherwise, identifier-convert-lispify performs the - same symbol transformations. - </p> - -<H4><a name="Allegrocl_nn52">20.5.2.3 Default identifier to symbol conversions</a></H4> - - - <p> - Check the definitions of the above two default - identifier-converters in <tt>Lib/allegrocl/allegrocl.swg</tt> for - default naming conventions. - </p> - -<H3><a name="Allegrocl_nn53">20.5.3 Defining your own identifier-converter</a></H3> - - -<p> - A user-defined identifier-converter function should conform to the following - specification: -</p> - -<div class="targetlang"> -<pre> -(defun identifier-convert-fn (id &key type class arity) ...body...) -result ==> symbol or (setf symbol) -</pre> -</div> - -<p>The <tt>ID</tt> argument is a string representing an identifier in the -foreign environment. -</p> - -<p> -The :type keyword argument provides more information on the type of -identifier. Its value is a symbol. This allows the -identifier-converter to apply different heuristics when mapping -different types of identifiers to symbols. SWIG will generate calls -to your identifier-converter using the following types. -</p> - -<ul> - <li>:class - names a CLOS class.</li> - <li>:constant - names a defconstant</li> - <li>:constructor - names a function for creating a foreign object</li> - <li>:destructor - names a function for freeing a foreign object</li> - <li>:function - names a CLOS wrapping defmethod or defun.</li> - <li>:ff-operator - names a foreign call defined via ff:def-foreign-call</li> - <li>:getter - getter function</li> - <li>:namespace - names a C++ namespace</li> - <li>:setter - names a setter function. May return a (setf symbol) reference</li> - <li>:operator - names a C++ operator, such as Operator=, Operator*.</li> - <li>:slot - names a slot in a struct/class/union declaration.</li> - <li>:type - names a foreign-type defined via ff:def-foreign-type.</li> - <li>:variable - names a variable defined via ff:def-foreign-variable.</li> -</ul> - -<p> -The :class keyword argument is a string naming a foreign -class. When non-nil, it indicates that the current identifier has -scope in the specified class. -</p> - -<p> -The :arity keyword argument only appears in swig:swig-defmethod forms -generated for overloaded functions. Its value is an integer -indicating the number of arguments passed to the routine indicated by -this identifier. -</p> - -<H3><a name="Allegrocl_nn54">20.5.4 Instructing SWIG to use a particular identifier-converter</a></H3> - - -<p> - By default, SWIG will use identifier-converter-null. To specify - another convert function, use the <tt>-identifier-converter</tt> - command-line argument. The value should be a string naming the - function you wish the interface to use instead, when generating - symbols. ex: -</p> - -<div class="code"> -<pre> -% swig -allegrocl -c++ -module mymodule -identifier-converter my-identifier-converter -</pre> -</div> - - -</body> -</html> diff --git a/Doc/Manual/Chicken.html b/Doc/Manual/Chicken.html deleted file mode 100644 index 3a80811bd..000000000 --- a/Doc/Manual/Chicken.html +++ /dev/null @@ -1,597 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> -<html> -<head> -<title>SWIG and Chicken</title> -<link rel="stylesheet" type="text/css" href="style.css"> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -</head> - -<body bgcolor="#ffffff"> - -<H1><a name="Chicken">23 SWIG and Chicken</a></H1> -<!-- INDEX --> -<div class="sectiontoc"> -<ul> -<li><a href="#Chicken_nn2">Preliminaries</a> -<ul> -<li><a href="#Chicken_nn3">Running SWIG in C mode</a> -<li><a href="#Chicken_nn4">Running SWIG in C++ mode</a> -</ul> -<li><a href="#Chicken_nn5">Code Generation</a> -<ul> -<li><a href="#Chicken_nn6">Naming Conventions</a> -<li><a href="#Chicken_nn7">Modules</a> -<li><a href="#Chicken_nn8">Constants and Variables</a> -<li><a href="#Chicken_nn9">Functions</a> -<li><a href="#Chicken_nn10">Exceptions</a> -</ul> -<li><a href="#Chicken_nn11">TinyCLOS</a> -<li><a href="#Chicken_nn12">Linkage</a> -<ul> -<li><a href="#Chicken_nn13">Static binary or shared library linked at compile time</a> -<li><a href="#Chicken_nn14">Building chicken extension libraries</a> -<li><a href="#Chicken_nn15">Linking multiple SWIG modules with TinyCLOS</a> -</ul> -<li><a href="#Chicken_nn16">Typemaps</a> -<li><a href="#Chicken_nn17">Pointers</a> -<ul> -<li><a href="#Chicken_collection">Garbage collection</a> -</ul> -<li><a href="#Chicken_nn18">Unsupported features and known problems</a> -<ul> -<li><a href="#Chicken_nn19">TinyCLOS problems with Chicken version <= 1.92</a> -</ul> -</ul> -</div> -<!-- INDEX --> - - - - <p> - This chapter describes SWIG's support of CHICKEN. CHICKEN is a - Scheme-to-C compiler supporting most of the language features as - defined in the <i>Revised^5 Report on Scheme</i>. Its main - attributes are that it - </p> - - <ol> - <li>generates portable C code</li> - <li>includes a customizable interpreter</li> - <li>links to C libraries with a simple Foreign Function Interface</li> - <li>supports full tail-recursion and first-class continuations</li> - </ol> - - <p> - When confronted with a large C library, CHICKEN users can use - SWIG to generate CHICKEN wrappers for the C library. However, - the real advantages of using SWIG with CHICKEN are its - <strong>support for C++</strong> -- object-oriented code is - difficult to wrap by hand in CHICKEN -- and its <strong>typed - pointer representation</strong>, essential for C and C++ - libraries involving structures or classes. - - </p> - -<H2><a name="Chicken_nn2">23.1 Preliminaries</a></H2> - - - <p> - CHICKEN support was introduced to SWIG in version 1.3.18. SWIG - relies on some recent additions to CHICKEN, which are only - present in releases of CHICKEN with version number - <strong>greater than or equal to 1.89</strong>. - To use a chicken version between 1.40 and 1.89, see the <a href="#Chicken_collection">Garbage collection</a> - section below. - </p> - - <p> - You may want to look at any of the examples in Examples/chicken/ - directory for the basic steps to run SWIG CHICKEN. - </p> - -<H3><a name="Chicken_nn3">23.1.1 Running SWIG in C mode</a></H3> - - - <p> - To run SWIG CHICKEN in C mode, use - the -chicken option. - </p> - - <div class="shell"> - <pre>% swig -chicken example.i</pre> - </div> - - <p> - To allow the wrapper to take advantage of future CHICKEN code - generation improvements, part of the wrapper is direct CHICKEN - function calls (<tt>example_wrap.c</tt>) and part is CHICKEN - Scheme (<tt>example.scm</tt>). The basic Scheme code must - be compiled to C using your system's CHICKEN compiler or - both files can be compiled directly using the much simpler <tt>csc</tt>. - </p> - - <div class="shell"> -<pre> -% chicken example.scm -output-file oexample.c -</pre> - </div> - - <p> - So for the C mode of SWIG CHICKEN, <tt>example_wrap.c</tt> and - <tt>oexample.c</tt> are the files that must be compiled to - object files and linked into your project. - </p> - -<H3><a name="Chicken_nn4">23.1.2 Running SWIG in C++ mode</a></H3> - - - <p> - To run SWIG CHICKEN in C++ mode, use - the -chicken -c++ option. - </p> - - <div class="shell"> - <pre>% swig -chicken -c++ example.i</pre> - </div> - - <p> - This will generate <tt>example_wrap.cxx</tt> and - <tt>example.scm</tt>. The basic Scheme code must be - compiled to C using your system's CHICKEN compiler or - both files can be compiled directly using the much simpler <tt>csc</tt>. - </p> - - <div class="shell"> - <pre>% chicken example.scm -output-file oexample.c</pre> - </div> - - <p> - So for the C++ mode of SWIG CHICKEN, <tt>example_wrap.cxx</tt> - and <tt>oexample.c</tt> are the files that must be compiled to - object files and linked into your project. - </p> - -<H2><a name="Chicken_nn5">23.2 Code Generation</a></H2> - - -<H3><a name="Chicken_nn6">23.2.1 Naming Conventions</a></H3> - - - <p> - Given a C variable, function or constant declaration named - <tt>Foo_Bar</tt>, the declaration will be available - in CHICKEN as an identifier ending with - <tt>Foo-Bar</tt>. That is, an underscore is converted - to a dash. - </p> - - <p> - You may control what the CHICKEN identifier will be by using the - <tt>%rename</tt> SWIG directive in the SWIG interface file. - </p> - -<H3><a name="Chicken_nn7">23.2.2 Modules</a></H3> - - - <p> - The name of the module must be declared one of two ways: - <ul> - <li>Placing <tt>%module example</tt> in the SWIG interface - file.</li> - <li>Using <tt>-module example</tt> on the SWIG command - line.</li> - </ul> - - <p> - The generated example.scm file then exports <code>(declare (unit modulename))</code>. - If you do not want SWIG to export the <code>(declare (unit modulename))</code>, pass - the -nounit option to SWIG. - - <p> - CHICKEN will be able to access the module using the <code>(declare - (uses <i>modulename</i>))</code> CHICKEN Scheme form. - </p> - -<H3><a name="Chicken_nn8">23.2.3 Constants and Variables</a></H3> - - - <p> - Constants may be created using any of the four constructs in - the interface file: - </p> - <ol> - <li><code>#define MYCONSTANT1 ...</code></li> - <li><code>%constant int MYCONSTANT2 = ...</code></li> - <li><code>const int MYCONSTANT3 = ...</code></li> - <li><code>enum { MYCONSTANT4 = ... };</code></li> - </ol> - - <p> - In all cases, the constants may be accessed from within CHICKEN - using the form <tt>(MYCONSTANT1)</tt>; that is, the constants - may be accessed using the read-only parameter form. - </p> - - <p> - Variables are accessed using the full parameter form. - For example, to set the C variable "int my_variable;", use the - Scheme form <tt>(my-variable 2345)</tt>. To get the C variable, - use <tt>(my-variable)</tt>. - </p> - - <p> - The <tt>%feature("constasvar")</tt> can be applied to any constant - or immutable variable. Instead of exporting the constant as - a function that must be called, the constant will appear as a - scheme variable. This causes the generated .scm file to just contain the code - <tt>(set! MYCONSTANT1 (MYCONSTANT1))</tt>. See - <a href="Customization.html#Customization_features">Features and the %feature directive</a> - for info on how to apply the %feature. - </p> - -<H3><a name="Chicken_nn9">23.2.4 Functions</a></H3> - - - <p> - C functions declared in the SWIG interface file will have - corresponding CHICKEN Scheme procedures. For example, the C - function "int sqrt(double x);" will be available using the - Scheme form <tt>(sqrt 2345.0)</tt>. A <code>void</code> return - value will give C_SCHEME_UNDEFINED as a result. - </p> - <p> - A function may return more than one value by using the - <code>OUTPUT</code> specifier (see Lib/chicken/typemaps.i). - They will be returned as multiple values using <code>(values)</code> if there is more than one - result (that is, a non-void return value and at least one argout - parameter, or a void return value and at least two argout - parameters). The return values can then be accessed with <code>(call-with-values)</code>. - </p> - -<H3><a name="Chicken_nn10">23.2.5 Exceptions</a></H3> - - - <p>The SWIG chicken module has support for exceptions thrown from - C or C++ code to be caught in scheme. - See <a href="Customization.html#Customization_exception">Exception handling with %exception</a> - for more information about declaring exceptions in the interface file. - </p> - - <p>Chicken supports both the <code>SWIG_exception(int code, const char *msg)</code> interface - as well as a <code>SWIG_ThrowException(C_word val)</code> function for throwing exceptions from - inside the %exception blocks. <code>SWIG_exception</code> will throw a list consisting of the code - (as an integer) and the message. Both of these will throw an exception using <code>(abort)</code>, - which can be handled by <code>(handle-exceptions)</code>. See - the Chicken manual on Exceptions - and <a href="http://srfi.schemers.org/srfi-12/srfi-12.html">SFRI-12</a>. Since the exception values are thrown - directly, if <code>(condition-case)</code> is used to catch an exception the exception will come through in the <code>val ()</code> case. - </p> - - <p>The following simple module</p> - -<div class="code"><pre> -%module exception_test - -%inline %{ - void test_throw(int i) throws (int) { - if (i == 1) throw 15; - } -%} -</pre></div> - - <p>could be run with</p> - -<div class="targetlang"><pre> -(handle-exceptions exvar - (if (= exvar 15) - (print "Correct!") - (print "Threw something else " exvar)) - (test-throw 1)) -</pre></div> - - -<H2><a name="Chicken_nn11">23.3 TinyCLOS</a></H2> - - - <p> - The author of TinyCLOS, Gregor Kiczales, describes TinyCLOS as: - "Tiny CLOS is a Scheme implementation of a 'kernelized' CLOS, with a - metaobject protocol. The implementation is even simpler than - the simple CLOS found in 'The Art of the Metaobject Protocol', - weighing in at around 850 lines of code, including (some) - comments and documentation." - </p> - - <p> - Almost all good Scheme books describe how to use metaobjects and - generic procedures to implement an object-oriented Scheme - system. Please consult a Scheme book if you are unfamiliar - with the concept. - </p> - - <p> - - CHICKEN has a modified version of TinyCLOS, which SWIG CHICKEN - uses if the -proxy argument is given. If -proxy is passed, then - the generated example.scm file will contain TinyCLOS class definitions. - A class named Foo is declared as <Foo>, and each member variable - is allocated a slot. Member functions are exported as generic functions. - - <p> - - Primitive symbols and functions (the interface that would be presented if - -proxy was not passed) are hidden and no longer accessible. If the -unhideprimitive - command line argument is passed to SWIG, then the primitive symbols will be - available, but each will be prefixed by the string "primitive:" - - <p> - - The exported symbol names can be controlled with the -closprefix and -useclassprefix arguments. - If -useclassprefix is passed to SWIG, every member function will be generated with the class name - as a prefix. If the -closprefix mymod: argument is passed to SWIG, then the exported functions will - be prefixed by the string "mymod:". If -useclassprefix is passed, -closprefix is ignored. - - </p> - -<H2><a name="Chicken_nn12">23.4 Linkage</a></H2> - - - <p> - Please refer to <em>CHICKEN - A practical and portable Scheme - system - User's manual</em> for detailed help on how to link - object files to create a CHICKEN Scheme program. Briefly, to - link object files, be sure to add <tt>`chicken-config - -extra-libs -libs`</tt> or <tt>`chicken-config -shared - -extra-libs -libs`</tt>to your linker options. Use the - <tt>-shared</tt> option if you want to create a dynamically - loadable module. You might also want to use the much simpler - <tt>csc</tt> or <tt>csc.bat</tt>. - </p> - - <p>Each scheme file that is generated - by SWIG contains <code>(declare (uses <i>modname</i>))</code>. This means that to load the - module from scheme code, the code must include <code>(declare (uses <i>modname</i>))</code>. - </p> - - -<H3><a name="Chicken_nn13">23.4.1 Static binary or shared library linked at compile time</a></H3> - - - <p>We can easily use csc to build a static binary.</p> - -<div class="shell"> -<pre> -$ swig -chicken example.i -$ csc -v example.scm example_impl.c example_wrap.c test_script.scm -o example -$ ./example -</pre> -</div> - -<p>Similar to the above, any number of <tt>module.scm</tt> files could be compiled -into a shared library, and then that shared library linked when compiling the -main application.</p> - -<div class="shell"> -<pre> -$ swig -chicken example.i -$ csc -sv example.scm example_wrap.c example_impl.c -o example.so -</pre> -</div> - -<p>The <tt>example.so</tt> file can then linked with <tt>test_script.scm</tt> when it -is compiled, in which case <tt>test_script.scm</tt> must have <code>(declare (uses example))</code>. -Multiple SWIG modules could have been linked into <tt>example.so</tt> and each -one accessed with a <code>(declare (uses ... ))</code>. -</p> - -<div class="shell"> -<pre> -$ csc -v test_script.scm -lexample -</pre> -</div> - -<p>An alternative is that the test_script.scm can have the code <code>(load-library 'example "example.so")</code>, -in which case the test script does not need to be linked with example.so. The test_script.scm file can then -be run with <tt>csi</tt>. -</p> - -<H3><a name="Chicken_nn14">23.4.2 Building chicken extension libraries</a></H3> - - -<p>Building a shared library like in the above section only works if the library -is linked at compile time with a script containing <code>(declare (uses ...))</code> or is -loaded explicitly with <code>(load-library 'example "example.so")</code>. It is -not the format that CHICKEN expects for extension libraries and eggs. The problem is the -<code>(declare (unit <i>modname</i>))</code> inside the <tt>modname.scm</tt> file. There are -two possible solutions to this.</p> - -<p>First, SWIG accepts a <tt>-nounit</tt> argument, in which case the <code>(declare (unit <i>modname</i>))</code> -is not generated. Then, the <tt>modname.scm</tt> and <tt>modname_wrap.c</tt> files <b>must</b> be compiled into -their own shared library.</p> - -<div class="shell"> -<pre> -$ csc -sv modname.scm modname_wrap.c modname_impl.c -o modname.so -</pre> -</div> - -<p>This library can then be loaded by scheme code with the <code>(require 'modname)</code> function. -See the -Loading-extension-libraries in the eval unit inside the CHICKEN manual for more information.</p> - -<p>Another alternative is to run SWIG normally and create a scheme file that contains <code>(declare (uses <i>modname</i>))</code> -and then compile that file into the shared library as well. For example, inside the <tt>mod_load.scm</tt> file,</p> - -<div class="targetlang"> -<pre> -(declare (uses mod1)) -(declare (uses mod2)) -</pre> -</div> - -<p>Which would then be compiled with</p> - -<div class="shell"> -<pre> -$ swig -chicken mod1.i -$ swig -chicken mod2.i -$ csc -sv mod_load.scm mod1.scm mod2.scm mod1_wrap.c mod2_wrap.c mod1_impl.c mod2_impl.c -o mod.so -</pre> -</div> - -<p>Then the extension library can be loaded with <code>(require 'mod)</code>. As we can see here, -<tt>mod_load.scm</tt> contains the code that gets executed when the module is loaded. All this code -does is load both mod1 and mod2. As we can see, this technique is more useful when you want to -combine a few SWIG modules into one chicken extension library, especially if modules are related by -<code>%import</code></p> - -<p>In either method, the files that are compiled into the shared library could also be -packaged into an egg. The <tt>mod1_wrap.c</tt> and <tt>mod2_wrap.c</tt> files that are created by SWIG -are stand alone and do not need SWIG to be installed to be compiled. Thus the egg could be -distributed and used by anyone, even if SWIG is not installed.</p> - -<p>See the <tt>Examples/chicken/egg</tt> directory in the SWIG source for an example that builds -two eggs, one using the first method and one using the second method.</p> - -<H3><a name="Chicken_nn15">23.4.3 Linking multiple SWIG modules with TinyCLOS</a></H3> - - -<p>Linking together multiple modules that share type information using the <code>%import</code> -directive while also using <tt>-proxy</tt> is more complicated. For example, if <tt>mod2.i</tt> imports <tt>mod1.i</tt>, then the -<tt>mod2.scm</tt> file contains references to symbols declared in <tt>mod1.scm</tt>, -and thus a <code>(declare (uses <i>mod1</i>))</code> or <code>(require '<i>mod1</i>)</code> must be exported -to the top of <tt>mod2.scm</tt>. By default, when SWIG encounters an <code>%import "modname.i"</code> directive, -it exports <code>(declare (uses <i>modname</i>))</code> into the scm file. This works fine unless mod1 was compiled with -the <tt>-nounit</tt> argument or was compiled into an extension library with other modules under a different name.</p> - -<p>One option is to override the automatic generation of <code>(declare (uses mod1))</code> -by passing the <tt>-noclosuses</tt> option to SWIG when compiling <tt>mod2.i</tt>. -SWIG then provides the <code>%insert(closprefix) %{ %}</code> directive. Any scheme code inside that directive is inserted into the -generated .scm file, and if <tt>mod1</tt> was compiled with <tt>-nounit</tt>, the directive should contain <code>(require 'mod1)</code>. -This option allows for mixed loading as well, where some modules are imported with <code>(declare (uses <i>modname</i>))</code> -(which means they were compiled without -nounit) and some are imported with <code>(require 'modname)</code>.</p> - -<p>The other option is to use the second idea in the above section. Compile all the modules normally, without any -<code>%insert(closprefix)</code>, <tt>-nounit</tt>, or <tt>-noclosuses</tt>. Then the modules will import each other correctly -with <code>(declare (uses ...))</code>. -To create an extension library or an egg, just create a <tt>module_load.scm</tt> file that <code>(declare (uses ...))</code> -all the modules.</p> - -<H2><a name="Chicken_nn16">23.5 Typemaps</a></H2> - - - <p> - The Chicken module handles all types via typemaps. This information is - read from <code>Lib/chicken/typemaps.i</code> and - <code>Lib/chicken/chicken.swg</code>. - </p> - -<H2><a name="Chicken_nn17">23.6 Pointers</a></H2> - - - <p> - For pointer types, SWIG uses CHICKEN tagged pointers. - - A tagged pointer is an ordinary CHICKEN pointer with an - extra slot for a void *. With SWIG - CHICKEN, this void * is a pointer to a type-info - structure. So each pointer used as input or output from - the SWIG-generated CHICKEN wrappers will have type - information attached to it. This will let the wrappers - correctly determine which method should be called - according to the object type hierarchy exposed in the SWIG - interface files. - </p> - <p> - To construct a Scheme object from a C pointer, the wrapper code - calls the function - <code>SWIG_NewPointerObj(void *ptr, swig_type_info *type, int owner)</code>, - The function that calls <code>SWIG_NewPointerObj</code> must have a variable declared - <code>C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER);</code> - It is ok to call <code>SWIG_NewPointerObj</code> more than once, - just make sure known_space has enough space for all the created pointers. - </p> - <p> - To get the pointer represented by a CHICKEN tagged pointer, the - wrapper code calls the function - <code>SWIG_ConvertPtr(C_word s, void **result, swig_type_info *type, int flags)</code>, - passing a pointer to a struct representing the expected pointer - type. flags is either zero or SWIG_POINTER_DISOWN (see below). - </p> - -<H3><a name="Chicken_collection">23.6.1 Garbage collection</a></H3> - - - <p>If the owner flag passed to <code>SWIG_NewPointerObj</code> is 1, <code>NewPointerObj</code> will add a - finalizer to the type which will call the destructor or delete method of - that type. The destructor and delete functions are no longer exported for - use in scheme code, instead SWIG and chicken manage pointers. - In situations where SWIG knows that a function is returning a type that should - be garbage collected, SWIG will automatically set the owner flag to 1. For other functions, - the <code>%newobject</code> directive must be specified for functions whose return values - should be garbage collected. See - <a href="Customization.html#Customization_ownership">Object ownership and %newobject</a> for more information. - </p> - - <p>In situations where a C or C++ function will assume ownership of a pointer, and thus - chicken should no longer garbage collect it, SWIG provides the <code>DISOWN</code> input typemap. - After applying this typemap (see the <a href="Typemaps.html#Typemaps">Typemaps chapter</a> for more information on how to apply typemaps), - any pointer that gets passed in will no longer be garbage collected. - An object is disowned by passing the <code>SWIG_POINTER_DISOWN</code> flag to <code>SWIG_ConvertPtr</code>. - <b>Warning:</b> Since the lifetime of the object is now controlled by the underlying code, the object might - get deleted while the scheme code still holds a pointer to it. Further use of this pointer - can lead to a crash. - </p> - - <p>Adding a finalizer function from C code was added to chicken in the 1.89 release, so garbage collection - does not work for chicken versions below 1.89. If you would like the SWIG generated code to work with - chicken 1.40 to 1.89, pass the <code>-nocollection</code> argument to SWIG. This will not export code - inside the _wrap.c file to register finalizers, and will then export destructor functions which - must be called manually. - </p> - -<H2><a name="Chicken_nn18">23.7 Unsupported features and known problems</a></H2> - - - <ul> - <li>No director support.</li> - <li>No support for c++ standard types like std::vector.</li> - <li>The TinyCLOS wrappers for overloaded functions will not work correctly when using - <a href="SWIGPlus.html#SWIGPlus_default_args">%feature(compactdefaultargs)</a>.</li> - </ul> - -<H3><a name="Chicken_nn19">23.7.1 TinyCLOS problems with Chicken version <= 1.92</a></H3> - - - <p>In Chicken versions equal to or below 1.92, TinyCLOS has a limitation such that generic methods do not properly work on methods - with different number of specializers: TinyCLOS assumes that every method added to a generic function - will have the same number of specializers. SWIG generates functions with different lengths of specializers - when C/C++ functions are overloaded. For example, the code</p> - -<div class="code"> -<pre> -class Foo {}; -int foo(int a, Foo *b); -int foo(int a); -</pre></div> - -<p>will produce scheme code</p> - -<div class="targetlang"> -<pre> -(define-method (foo (arg0 <top>) (arg1 <Foo>)) (<i>call primitive function</i>)) -(define-method (foo (arg0 <top>)) (<i>call primitive function</i>)) -</pre></div> - -<p>Using unpatched TinyCLOS, the second <code>(define-method)</code> will replace the first one, -so calling <code>(foo 3 f)</code> will produce an error.</p> - -<p>There are three solutions to this. The easist is to upgrade to the latest Chicken version. Otherwise, the -file <tt>Lib/chicken/tinyclos-multi-generic.patch</tt> in the SWIG source contains a patch against -tinyclos.scm inside the 1.92 chicken source to add support into TinyCLOS for multi-argument generics. (This patch was accepted into Chicken) -This requires chicken to be rebuilt and custom install of chicken. An alternative is the <tt>Lib/chicken/multi-generic.scm</tt> -file in the SWIG source. This file can be loaded after TinyCLOS is loaded, and it will override some functions -inside TinyCLOS to correctly support multi-argument generics. Please see the comments at the top of both files for more information.</p> - - </body> -</html> diff --git a/Doc/Manual/Contents.html b/Doc/Manual/Contents.html index 0370d4724..47b41186e 100644 --- a/Doc/Manual/Contents.html +++ b/Doc/Manual/Contents.html @@ -96,6 +96,7 @@ <li><a href="Windows.html#Windows_swig_exe">Building swig.exe on Windows</a> <ul> <li><a href="Windows.html#Windows_cmake">Building swig.exe using CMake</a> +<li><a href="Windows.html#Windows_mingw_msys">Building swig.exe using MSYS2</a> <li><a href="Windows.html#Windows_mingw_msys">Building swig.exe using MinGW and MSYS</a> <li><a href="Windows.html#Windows_cygwin">Building swig.exe using Cygwin</a> </ul> diff --git a/Doc/Manual/Doxygen.html b/Doc/Manual/Doxygen.html index 53238c24d..e7fd4c359 100644 --- a/Doc/Manual/Doxygen.html +++ b/Doc/Manual/Doxygen.html @@ -1354,7 +1354,7 @@ Here is the list of all Doxygen tags and the description of how they are transla </tr> <tr> <td>\throws</td> -<td>replaced wih ':raises:'</td> +<td>replaced with ':raises:'</td> </tr> <tr> <td>\todo</td> diff --git a/Doc/Manual/Extending.html b/Doc/Manual/Extending.html index 7c2a6c66c..5749f37ce 100644 --- a/Doc/Manual/Extending.html +++ b/Doc/Manual/Extending.html @@ -3613,7 +3613,7 @@ A target language is given the 'Supported' status when Examples must be available and run successfully. </li> <li> - The examples and test-suite must be fully functioning on the Travis Continuous Integration platform. + The examples and test-suite must be fully functioning on the Github Actions Continuous Integration platform. </li> </ul> @@ -3660,9 +3660,9 @@ Some minimum requirements and notes about languages with the 'Experimental' stat The number of tests in these lists should be no greater than half of the number of tests in the full test-suite. </li> <li> - The examples and test-suite must also be fully functioning on the Travis Continuous Integration platform. - However, experimental languages will be set as 'allow_failures'. - This means that pull requests and normal development commits will not break the entire Travis build should an experimental language fail. + The examples and test-suite must also be fully functioning on the Github Actions Continuous Integration platform. + However, experimental languages will be flagged as 'continue-on-error'. + This means that pull requests and normal development commits will not break the entire Github Actions build should an experimental language fail. </li> <li> Any new failed tests will be fixed on a 'best effort' basis by core developers with no promises made. diff --git a/Doc/Manual/Go.html b/Doc/Manual/Go.html index 1a5bb08c7..4e230c78b 100644 --- a/Doc/Manual/Go.html +++ b/Doc/Manual/Go.html @@ -71,6 +71,7 @@ code. SWIG fills this gap. There are (at least) two different Go compilers. The first is the gc compiler of the <a href="https://golang.org/doc/install">Go distribution</a>, normally invoked via the <a href="https://golang.org/cmd/go/">go tool</a>. +SWIG supports the gc compiler version 1.2 or later. The second Go compiler is the <a href="https://golang.org/doc/install/gccgo"> gccgo compiler</a>, which is a frontend to the GCC compiler suite. The interface to C/C++ code is completely different for the two Go compilers. @@ -142,44 +143,6 @@ You will now have a Go package that you can import from other Go packages as usual. </p> -<p> -SWIG can be used without cgo, via the <tt>-no-cgo</tt> option, but -more steps are required. This only works with Go versions before 1.5. -When using Go version 1.2 or later, or when using gccgo, the code -generated by SWIG can be linked directly into the Go program. A -typical command sequence when using the Go compiler of the Go -distribution would look like this: -</p> - -<div class="code"><pre> -% swig -go -no-cgo example.i -% gcc -c code.c # The C library being wrapped. -% gcc -c example_wrap.c -% go tool 6g example.go -% go tool 6c example_gc.c -% go tool pack grc example.a example.6 example_gc.6 code.o example_wrap.o -% go tool 6g main.go -% go tool 6l main.6 -</pre></div> - -<p> -You can also put the wrapped code into a shared library, and when using the Go -versions before 1.2 this is the only supported option. A typical command -sequence for this approach would look like this: -</p> - -<div class="code"><pre> -% swig -go -no-cgo -use-shlib example.i -% gcc -c -fpic example.c -% gcc -c -fpic example_wrap.c -% gcc -shared example.o example_wrap.o -o example.so -% go tool 6g example.go -% go tool 6c example_gc.c -% go tool pack grc example.a example.6 example_gc.6 -% go tool 6g main.go # your code, not generated by SWIG -% go tool 6l main.6 -</pre></div> - <H3><a name="Go_commandline">25.3.1 Go-specific Commandline Options</a></H3> @@ -206,9 +169,7 @@ swig -go -help <tr> <td>-no-cgo</td> -<td>Generate files that can be used directly, rather than via the Go - cgo tool. This option does not work with Go 1.5 or later. It is - required for versions of Go before 1.2.</td> +<td>This option is no longer supported.</td> </tr> <tr> @@ -279,13 +240,10 @@ swig -go -help <H3><a name="Go_outputs">25.3.2 Generated Wrapper Files</a></H3> -<p>There are two different approaches to generating wrapper files, - controlled by SWIG's <tt>-no-cgo</tt> option. The <tt>-no-cgo</tt> - option only works with version of Go before 1.5. It is required - when using versions of Go before 1.2.</p> - -<p>With or without the <tt>-no-cgo</tt> option, SWIG will generate the - following files when generating wrapper code:</p> +<p> +SWIG will generate the following files when generating wrapper +code: +</p> <ul> <li> @@ -308,17 +266,6 @@ or C++ compiler. </li> </ul> -<p>When the <tt>-no-cgo</tt> option is used, and the <tt>-gccgo</tt> - option is not used, SWIG will also generate an additional file:</p> - -<ul> -<li> -MODULE_gc.c will contain C code which should be compiled with the C -compiler distributed as part of the gc compiler. It should then be -combined with the compiled MODULE.go using go tool pack. -</li> -</ul> - <H2><a name="Go_basic_tour">25.4 A tour of basic C/C++ wrapping</a></H2> diff --git a/Doc/Manual/Guile.html b/Doc/Manual/Guile.html index 9d55b632b..26679dc4b 100644 --- a/Doc/Manual/Guile.html +++ b/Doc/Manual/Guile.html @@ -183,7 +183,7 @@ information by including a directive like this in the interface file: </div> <p> -(The <code>%scheme</code> directive allows to insert arbitrary Scheme +(The <code>%scheme</code> directive allows inserting arbitrary Scheme code into the generated file <code><var>module.scm</var></code>; it is placed between the <code>define-module</code> form and the <code>export</code> form.) diff --git a/Doc/Manual/Java.html b/Doc/Manual/Java.html index dc403a98c..2591b27b5 100644 --- a/Doc/Manual/Java.html +++ b/Doc/Manual/Java.html @@ -9095,7 +9095,7 @@ This method normally calls the C++ destructor or <tt>free()</tt> for C code. <p> The generated code can be debugged using both a Java debugger and a C++ debugger using the usual debugging techniques. Breakpoints can be set in either Java or C++ code and so both can be debugged simultaneously. -Most debuggers do not understand both Java and C++, with one noteable exception of Sun Studio, +Most debuggers do not understand both Java and C++, with one notable exception of Sun Studio, where it is possible to step from Java code into a JNI method within one environment. </p> diff --git a/Doc/Manual/Javascript.html b/Doc/Manual/Javascript.html index cce5b5e2e..54bd68521 100644 --- a/Doc/Manual/Javascript.html +++ b/Doc/Manual/Javascript.html @@ -89,19 +89,24 @@ $ swig -javascript -jsc example.i</pre> <pre> $ swig -c++ -javascript -jsc example.i</pre> </div> -<p>The V8 code that SWIG generates should work with most versions from 3.11.10 up to 3.29.14 and later.</p> -<p>The API headers for V8 >= 4.3.0 define constants which SWIG can use to -determine the V8 version it is compiling for. For versions < 4.3.0, you +<p>The V8 code that SWIG generates should work with most versions from 3.11.10. +However, the only early version that receives some testing is 3.14.5, which is +still shipped with Ubuntu for some reason. Other than that it's probably safer +to assume that versions earlier than 5.0 are no longer supported. Keep in mind +that these are V8 versions, not Node.js. To give some perspective, Node.js v6.0 +uses V8 5.0, v12.0 - 7.4, v14.0 - 8.1...</p> +<p>The API headers for V8 >= 4.3.10 define constants which SWIG can use to +determine the V8 version it is compiling for. For versions < 4.3.10, you need to specify the V8 version when running SWIG. This is specified as a hex constant, but the constant is read as pairs of decimal digits, so for V8 3.25.30 use constant 0x032530. This scheme can't represent components > 99, -but this constant is only useful for V8 < 4.3.0, and no V8 versions from +but this constant is only useful for V8 < 4.3.10, and no V8 versions from that era had a component > 99. For example:</p> <div class="shell"> <pre> $ swig -c++ -javascript -v8 -DV8_VERSION=0x032530 example.i</pre> </div> -<p>If you're targeting V8 >= 4.3.0, you would just run swig like so:</p> +<p>If you're targeting V8 >= 4.3.10, you would just run swig like so:</p> <div class="shell"> <pre> $ swig -c++ -javascript -v8 example.i</pre> @@ -401,7 +406,7 @@ the main window.</p> <p> As known from <code>node.js</code> one can use <code>require</code> to load javascript modules. -Additionally, <code>node-webkit</code> provides an API that allows to manipulate the window's menu, +Additionally, <code>node-webkit</code> provides an API that allows manipulating the window's menu, open new windows, and many more things. </p> diff --git a/Doc/Manual/Modula3.html b/Doc/Manual/Modula3.html deleted file mode 100644 index fc4ffa03c..000000000 --- a/Doc/Manual/Modula3.html +++ /dev/null @@ -1,942 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> -<html> -<head> -<title>SWIG and Modula-3</title> -<link rel="stylesheet" type="text/css" href="style.css"> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -</head> -<body bgcolor="#FFFFFF"> -<H1><a name="Modula3">31 SWIG and Modula-3</a></H1> -<!-- INDEX --> -<div class="sectiontoc"> -<ul> -<li><a href="#Modula3_modula3_overview">Overview</a> -<ul> -<li><a href="#Modula3_motivation">Motivation</a> -</ul> -<li><a href="#Modula3_conception">Conception</a> -<ul> -<li><a href="#Modula3_cinterface">Interfaces to C libraries</a> -<li><a href="#Modula3_cppinterface">Interfaces to C++ libraries</a> -</ul> -<li><a href="#Modula3_preliminaries">Preliminaries</a> -<ul> -<li><a href="#Modula3_compilers">Compilers</a> -<li><a href="#Modula3_commandline">Additional Commandline Options</a> -</ul> -<li><a href="#Modula3_typemaps">Modula-3 typemaps</a> -<ul> -<li><a href="#Modula3_inoutparam">Inputs and outputs</a> -<li><a href="#Modula3_ordinals">Subranges, Enumerations, Sets</a> -<li><a href="#Modula3_class">Objects</a> -<li><a href="#Modula3_imports">Imports</a> -<li><a href="#Modula3_exceptions">Exceptions</a> -<li><a href="#Modula3_typemap_example">Example</a> -</ul> -<li><a href="#Modula3_hints">More hints to the generator</a> -<ul> -<li><a href="#Modula3_features">Features</a> -<li><a href="#Modula3_pragmas">Pragmas</a> -</ul> -<li><a href="#Modula3_remarks">Remarks</a> -</ul> -</div> -<!-- INDEX --> - - - -<p> -This chapter describes SWIG's support for -<a href="http://modula3.org/">Modula-3</a>. -You should be familiar with the -<a href="SWIG.html#SWIG">basics</a> -of SWIG, -especially -<a href="Typemaps.html#Typemaps">typemaps</a>. -</p> - -<H2><a name="Modula3_modula3_overview">31.1 Overview</a></H2> - - -<p> -Modula-3 is a compiled language in the tradition of Niklaus Wirth's Modula 2, -which is in turn a successor to Pascal. -</p> - -<p> -SWIG's Modula-3 support is currently very basic and highly experimental! -Many features are still not designed satisfyingly -and I need more discussion about the odds and ends. -Don't rely on any feature, incompatible changes are likely in the future! -However, the Modula-3 generator was already useful for interfacing -to the libraries: -</p> - -<ol> -<li> -<a href="http://www.elegosoft.com/cgi-bin/cvsweb.cgi/cm3/m3-libs/plplot/"> -PLPlot -</a> -</li> -<li> -<a href="http://www.elegosoft.com/cgi-bin/cvsweb.cgi/cm3/m3-libs/fftw/"> -FFTW -</a> -</li> -</ol> - -<H3><a name="Modula3_motivation">31.1.1 Motivation</a></H3> - - -<p> -Although it is possible to write Modula-3 code that performs as well as C/C++ -most existing libraries are not written in Modula-3 but in C or C++, and -even libraries in other languages may provide C header files. -</p> - -<p> -Fortunately Modula-3 can call C functions, but you have to write Modula-3 -interfaces to them, and to make things comfortable you will also need -wrappers that convert between high-level features of Modula-3 (garbage -collecting, exceptions) and the explicit tracking of allocated memory and -exception codes used by C APIs. -</p> - -<p> -SWIG converts C headers to Modula-3 interfaces for you, and using typemaps -you can pass <tt>TEXT</tt>s or open arrays, and convert error return codes -into exceptions. -</p> - -<p> -If the library API is ill designed -writing appropriate typemaps can still be time-consuming. -E.g. C programmers are very creative to work-around -missing data types like (real) enumerations and sets. -You should turn such work-arounds back to the Modula-3 way -otherwise you lose static safety and consistency. -</p> - -<p> -Without SWIG you would probably never consider trying to call C++ libraries -from Modula-3, but with SWIG this is becomes feasible. -SWIG can generate C wrappers to C++ functions and object methods -that may throw exceptions, and then wrap these C wrappers for Modula-3. -To make it complete you can then hide the C interface with Modula-3 classes and -exceptions. -</p> - -<p> -SWIG allows you to call C and C++ libraries from Modula-3 (even with call back -functions), but it doesn't allow you to easily integrate a Modula-3 module into -a C/C++ project. -</p> - -<H2><a name="Modula3_conception">31.2 Conception</a></H2> - - -<H3><a name="Modula3_cinterface">31.2.1 Interfaces to C libraries</a></H3> - - -<p> -Modula-3 has integrated support for calling C functions. -This is also extensively used by the standard Modula-3 libraries -to call OS functions. -The Modula-3 part of SWIG and the corresponding SWIG library -modula3.swg -contain code that uses these features. -Because of the built-in support there is no need -for calling the SWIG kernel to generate wrappers written in C. -All conversion and argument checking can be done in Modula-3 -and the interfacing is quite efficient. -All you have to do is to write pieces of Modula-3 code -that SWIG puts together. -</p> - -<table border summary="Modula-3 C library support"> -<tr><th colspan=2>C library support integrated in Modula-3<th></tr> -<tr> -<td>Pragma <tt><* EXTERNAL *></tt></td> -<td>Precedes a declaration of a PROCEDURE that is implemented -in an external library instead of a Modula-3 module.</td> -</tr> -<tr> -<td>Pragma <tt><* CALLBACK *></tt></td> -<td>Precedes a declaration of a PROCEDURE that should be called -by external library code.</td> -</tr> -<tr> -<td>Module <tt>Ctypes</tt></td> -<td>Contains Modula-3 types that match some basic C types.</td> -</tr> -<tr> -<td>Module <tt>M3toC</tt></td> -<td>Contains routines that convert between Modula-3's <tt>TEXT</tt> type -and C's <tt>char *</tt> type.</td> -</tr> -</table> - -<p> -In each run of SWIG the Modula-3 part -generates several files: -</p> -<table border summary="Modula-3 generated files"> -<tr> - <th>Module name scheme</th> - <th>Identifier for <tt>%insert</tt></th> - <th>Description</th> -</tr> -<tr> - <td>Module<tt>Raw.i3</tt></td> - <td><tt>m3rawintf</tt></td> - <td>Declaration of types that are equivalent to those of the C library, - <tt>EXTERNAL</tt> procedures as interface to the C library functions</td> -</tr> -<tr> - <td>Module<tt>Raw.m3</tt></td> - <td><tt>m3rawimpl</tt></td> - <td>Almost empty.</td> -</tr> -<tr> - <td>Module<tt>.i3</tt></td> - <td><tt>m3wrapintf</tt></td> - <td>Declaration of comfortable wrappers to the C library functions.</td> -</tr> -<tr> - <td>Module<tt>.m3</tt></td> - <td><tt>m3wrapimpl</tt></td> - <td>Implementation of the wrappers that - convert between Modula-3 and C types, - check for validity of values, - hand-over resource management to the garbage collector using <tt>WeakRef</tt>s - and raises exceptions.</td> -</tr> -<tr> - <td><tt>m3makefile</tt></td> - <td><tt>m3makefile</tt></td> - <td>Add the modules above to the Modula-3 project and - specify the name of the Modula-3 wrapper library - to be generated. - - Today I'm not sure if it is a good idea - to create a <tt>m3makefile</tt> in each run, - because SWIG must be started for each Modula-3 module it creates. - Thus the m3makefile is overwritten each time. :-( - </td> -</tr> -</table> - -<p> -Here's a scheme of how the function calls to Modula-3 wrappers -are redirected to C library functions: -</p> - -<table summary="Modula-3 C library"> -<tr> - <td align=center> - Modula-3 wrapper<br> - Module<tt>.i3</tt><br> - generated by Modula-3 part of SWIG - </td> - <td></td> - <td align=center></td> -</tr> -<tr> - <td align=center> - <!-- pre tag overrides centering --> - |<br> - v - </td> - <td></td> - <td align=center></td> -</tr> -<tr> - <td align=center> - Modula-3 interface to C<br> - Module<tt>Raw.i3</tt><br> - generated by Modula-3 part of SWIG - </td> - <td>--></td> - <td align=center> - C library - </td> -</tr> -</table> - - -<p> -I have still no good conception how one can split C library interfaces -into type oriented interfaces. -A Module in Modula-3 represents an Abstract DataType -(or call it a static classes, i.e. a class without virtual methods). -E.g. if you have a principal type, say <tt>Database</tt>, -it is good Modula-3 style to set up one Module with the name <tt>Database</tt> -where the database type is declared with the name <tt>T</tt> -and where all functions are declared that operates on it. -</p> - -<p> -The normal operation of SWIG is to generate a fixed set of files per call. -To generate multiple modules one has to write one SWIG interface -(different SWIG interfaces can share common data) per module. -Identifiers belonging to a different module may ignored (<tt>%ignore</tt>) -and the principal type must be renamed (<tt>%typemap</tt>). -</p> - - -<H3><a name="Modula3_cppinterface">31.2.2 Interfaces to C++ libraries</a></H3> - - -<p> -Interfaces to C++ files are much more complicated and -there are some more design decisions that are not made, yet. -Modula-3 has no support for C++ functions -but C++ compilers should support generating C++ functions -with a C interface. -</p> - -<p> -Here's a scheme of how the function calls to Modula-3 wrappers -are redirected to C library functions: -</p> - -<table summary="Modula-3 C++ library"> -<tr> - <td align=center> - Modula-3 wrapper<br> - Module<tt>.i3</tt><br> - generated by Modula-3 part of SWIG - </td> - <td></td> - <td align=center>C++ library</td> -</tr> -<tr> - <td align=center> - <!-- pre tag overrides centering --> - |<br> - v - </td> - <td></td> - <td align=center> - ^<br> - | - </td> -</tr> -<tr> - <td align=center> - Modula-3 interface to C<br> - Module<tt>Raw.i3</tt><br> - generated by Modula-3 part of SWIG - </td> - <td>--></td> - <td align=center> - C interface to C++<br> - module<tt>_wrap.cxx</tt><br> - generated by the SWIG core - </td> -</tr> -</table> - -<p> -Wrapping C++ libraries arises additional problems: -</p> -<ul> -<li> -Is it sensible to wrap C++ classes with Modula-3 classes? -</li> -<li> -How to find the wrapping Modula-3 class -for a class pointer that is returned by a C++ routine? -</li> -<li> -How to deal with multiple inheritance -which was neglected for Modula-3 for good reasons? -</li> -<li> -Is it possible to sub-class C++ classes with Modula-3 code? -This issue is addressed by directors, -a feature that was experimentally added to some Language modules -like -<a href="Java.html#Java_directors">Java</a> and -<a href="Python.html#Python_directors">Python</a>. -</li> -<li> -How to manage storage with the garbage collector of Modula-3? -Support for -<a href="Customization.html#Customization_ownership"> -<tt>%newobject</tt> and <tt>%typemap(newfree)</tt></a> -isn't implemented, yet. -What's about resources that are managed by the garbage collector -but shall be passed back to the storage management of the C++ library? -This is a general issue which is not solved in a satisfying fashion -as far as I know. -</li> -<li> -How to turn C++ exceptions into Modula-3 exceptions? -There's also no support for -<a href="Customization.html#Customization_exception"> -<tt>%exception</tt></a>, yet. -</li> -</ul> - -<p> -Be warned: -There is no C++ library I wrote a SWIG interface for, -so I'm not sure if this is possible or sensible, yet. -</p> - -<H2><a name="Modula3_preliminaries">31.3 Preliminaries</a></H2> - - -<H3><a name="Modula3_compilers">31.3.1 Compilers</a></H3> - - -<p> -There are different Modula-3 compilers around: -cm3, pm3, ezm3, Klagenfurth Modula-3, Cambridge Modula-3. -SWIG itself does not contain compiler specific code -but the modula3.swg library file -may do so. -For testing examples I use Critical Mass cm3. -</p> - - -<H3><a name="Modula3_commandline">31.3.2 Additional Commandline Options</a></H3> - - -<p> -There are some experimental command line options -that prevent SWIG from generating interface files. -Instead files are emitted that may assist you -when writing SWIG interface files. -</p> - -<table border summary="Modula-3 specific options"> -<tr> -<th>Modula-3 specific options</th> -<th>Description</th> -</tr> - -<tr> -<td valign=top>-generateconst <file></td> -<td> -Disable generation of interfaces and wrappers. -Instead write code for computing numeric values of constants -to the specified file. -<br> -C code may contain several constant definitions -written as preprocessor macros. -Other language modules of SWIG use -compute-once-use-readonly variables or -functions to wrap such definitions. -All of them can invoke C code dynamically -for computing the macro values. -But if one wants to turn them into Modula-3 -integer constants, enumerations or set types, -the values of these expressions has to be known statically. -Although definitions like <tt>(1 << FLAG_MAXIMIZEWINDOW)</tt> -must be considered as good C style -they are hard to convert to Modula-3 -since the value computation can use every feature of C. -<br> -Thus I implemented these switch -to extract all constant definitions -and write a C program that output the values of them. -It works for numeric constants only -and treats all of them as <tt>double</tt>. -Future versions may generate a C++ program -that can detect the type of the macros -by overloaded output functions. -Then strings can also be processed. -</td> -</tr> - -<tr> -<td valign=top>-generaterename <file></td> -<td> -Disable generation of interfaces and wrappers. -Instead generate suggestions for <tt>%rename</tt>. -<br> -C libraries use a naming style -that is neither homogeneous nor similar to that of Modula-3. -C function names often contain a prefix denoting the library -and some name components separated by underscores -or capitalization changes. -To get library interfaces that are really Modula-3 like -you should rename the function names with the <tt>%rename</tt> directive. -This switch outputs a list of such directives -with a name suggestion generated by a simple heuristic. -</td> -</tr> - -<tr> -<td valign=top>-generatetypemap <file></td> -<td> -Disable generation of interfaces and wrappers. -Instead generate templates for some basic typemaps. -</td> -</tr> -</table> - -<H2><a name="Modula3_typemaps">31.4 Modula-3 typemaps</a></H2> - - -<H3><a name="Modula3_inoutparam">31.4.1 Inputs and outputs</a></H3> - - -<p> -Each C procedure has a bunch of inputs and outputs. -Inputs are passed as function arguments, -outputs are updated referential arguments and -the function value. -</p> - -<p> -Each C type can have several typemaps -that apply only in case if a type is used -for an input argument, for an output argument, -or for a return value. -A further typemap may specify -the direction that is used for certain parameters. -I have chosen this separation -in order to be able to write general typemaps for the modula3.swg typemap library. -In the library code the final usage of the type is not known. -Using separate typemaps for each possible use -allows appropriate definitions for each case. -If these pre-definitions are fine -then the direction of the function parameter -is the only hint the user must give. -</p> - -<p> -The typemaps specific to Modula-3 have a common name scheme: -A typemap name starts with "m3", -followed by "raw" or "wrap" -depending on whether it controls the generation -of the Module<tt>Raw.i3</tt> or the Module<tt>.i3</tt>, respectively. -It follows an "in" for typemaps applied to input argument, -"out" for output arguments, "arg" for all kind of arguments, -"ret" for returned values. -</p> - -<p> -The main task of SWIG is to build wrapper function, -i.e. functions that convert values between C and Modula-3 -and call the corresponding C function. -Modula-3 wrapper functions generated by SWIG -consist of the following parts: -</p> -<ul> -<li>Generate <tt>PROCEDURE</tt> signature.</li> -<li>Declare local variables.</li> -<li>Convert input values from Modula-3 to C.</li> -<li>Check for input value integrity.</li> -<li>Call the C function.</li> -<li>Check returned values, e.g. error codes.</li> -<li>Convert and write back values into Modula-3 records.</li> -<li>Free temporary storage.</li> -<li>Return values.</li> -</ul> - -<table border summary="Modula-3 typemaps"> -<tr> - <th>Typemap</th> - <th>Example</th> - <th>Description</th> -</tr> -<tr> - <td>m3wrapargvar</td> - <td><tt>$1: INTEGER := $1_name;</tt></td> - <td> - Declaration of some variables needed for temporary results. - </td> -</tr> -<tr> - <td>m3wrapargconst</td> - <td><tt>$1 = "$1_name";</tt></td> - <td> - Declaration of some constant, maybe for debug purposes. - </td> -</tr> -<tr> - <td>m3wrapargraw</td> - <td><tt>ORD($1_name)</tt></td> - <td> - The expression that should be passed as argument to the raw Modula-3 interface function. - </td> -</tr> -<tr> - <td>m3wrapargdir</td> - <td><tt>out</tt></td> - <td> - Referential arguments can be used for input, output, update. - ??? - </td> -</tr> -<tr> - <td>m3wrapinmode</td> - <td><tt>READONLY</tt></td> - <td> - One of Modula-3 parameter modes - <tt>VALUE</tt> (or empty), - <tt>VAR</tt>, - <tt>READONLY</tt> - </td> -</tr> -<tr> - <td>m3wrapinname</td> - <td></td> - <td> - New name of the input argument. - </td> -</tr> -<tr> - <td>m3wrapintype</td> - <td></td> - <td> - Modula-3 type of the input argument. - </td> -</tr> -<tr> - <td>m3wrapindefault</td> - <td></td> - <td> - Default value of the input argument - </td> -</tr> -<tr> - <td>m3wrapinconv</td> - <td><tt>$1 := M3toC.SharedTtoS($1_name);</tt></td> - <td> - Statement for converting the Modula-3 input value to C compliant value. - </td> -</tr> -<tr> - <td>m3wrapincheck</td> - <td><tt>IF Text.Length($1_name) > 10 THEN RAISE E("str too long"); END;</tt></td> - <td> - Check the integrity of the input value. - </td> -</tr> -<tr> - <td>m3wrapoutname</td> - <td></td> - <td> - Name of the <tt>RECORD</tt> field to be used for returning multiple values. - This applies to referential output arguments that shall be turned - into return values. - </td> -</tr> -<tr> - <td>m3wrapouttype</td> - <td></td> - <td> - Type of the value that is returned instead of a referential output argument. - </td> -</tr> -<tr> - <td>m3wrapoutconv</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapoutcheck</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapretraw</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapretname</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wraprettype</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapretvar</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapretconv</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapretcheck</td> - <td></td> - <td> - </td> -</tr> -<tr> - <td>m3wrapfreearg</td> - <td><tt>M3toC.FreeSharedS(str, arg1);</tt></td> - <td> - Free resources that were temporarily used in the wrapper. - Since this step should never be skipped, - SWIG will put it in the <tt>FINALLY</tt> branch - of a <tt>TRY .. FINALLY</tt> structure. - </td> -</tr> -</table> - - -<H3><a name="Modula3_ordinals">31.4.2 Subranges, Enumerations, Sets</a></H3> - - -<p> -Subranges, enumerations, and sets are machine oriented types -that make Modula very strong and expressive compared -with the type systems of many other languages. -</p> - -<ul> -<li> -Subranges are used for statically restricted choices of integers. -</li> -<li> -Enumerations are used for named choices. -</li> -<li> -Sets are commonly used for flag (option) sets. -</li> -</ul> - -<p> -Using them extensively makes Modula code very safe and readable. -</p> - -<p> -C supports enumerations, too, but they are not as safe as the ones of Modula. -Thus they are abused for many things: -For named choices, for integer constant definitions, for sets. -To make it complete every way of defining a value in C -(<tt>#define</tt>, <tt>const int</tt>, <tt>enum</tt>) -is somewhere used for defining something -that must be handled completely different in Modula-3 -(<tt>INTEGER</tt>, enumeration, <tt>SET</tt>). -</p> - -<p> -I played around with several <tt>%feature</tt>s and <tt>%pragma</tt>s -that split the task up into converting -the C bit patterns (integer or bit set) -into Modula-3 bit patterns (integer or bit set) -and change the type as requested. -See the corresponding example in the -Examples/modula3/enum/example.i file. -This is quite messy and not satisfying. -So the best what you can currently do is -to rewrite constant definitions manually. -Though this is a tedious work -that I'd like to automate. -</p> - - -<H3><a name="Modula3_class">31.4.3 Objects</a></H3> - - -<p> -Declarations of C++ classes are mapped to <tt>OBJECT</tt> types -while it is tried to retain the access hierarchy -"public - protected - private" using partial revelation. -Though the example in -Examples/modula3/class/example.i -is not really useful, yet. -</p> - - -<H3><a name="Modula3_imports">31.4.4 Imports</a></H3> - - -<p> -Pieces of Modula-3 code provided by typemaps -may contain identifiers from foreign modules. -If the typemap <tt>m3wrapinconv</tt> for <tt>blah *</tt> -contains code using the function <tt>M3toC.SharedTtoS</tt> -you may declare <tt>%typemap("m3wrapinconv:import") blah * %{M3toC%}</tt>. -Then the module <tt>M3toC</tt> is imported -if the <tt>m3wrapinconv</tt> typemap for <tt>blah *</tt> -is used at least once. -Use <tt>%typemap("m3wrapinconv:import") blah * %{MyConversions AS M3toC%}</tt> -if you need module renaming. -Unqualified import is not supported. -</p> - -<p> -It is cumbersome to add this typemap to each piece of Modula-3 code. -It is especially useful when writing general typemaps -for the modula3.swg typemap library. -For a monolithic module you might be better off -if you add the imports directly: -</p> - -<div class="code"> -<pre> -%insert(m3rawintf) %{ -IMPORT M3toC; -%} -</pre></div> - - -<H3><a name="Modula3_exceptions">31.4.5 Exceptions</a></H3> - - -<p> -Modula-3 provides another possibility -of an output of a function: exceptions. -</p> - -<p> -Any piece of Modula-3 code that SWIG inserts -due to a typemap can raise an exception. -This way you can also convert an error code -from a C function into a Modula-3 exception. -</p> - -<p> -The <tt>RAISES</tt> clause is controlled -by typemaps with the <tt>throws</tt> extension. -If the typemap <tt>m3wrapinconv</tt> for <tt>blah *</tt> -contains code that may raise the exceptions <tt>OSError.E</tt> -you should declare -<tt>%typemap("m3wrapinconv:throws") blah * %{OSError.E%}</tt>. -</p> - -<H3><a name="Modula3_typemap_example">31.4.6 Example</a></H3> - - -<p> -The generation of wrappers in Modula-3 needs very fine control -to take advantage of the language features. -Here is an example of a generated wrapper -where almost everything is generated by a typemap: -</p> - -<div class="code"><pre> -<I> (* %relabel m3wrapinmode m3wrapinname m3wrapintype m3wrapindefault *)</I> - PROCEDURE Name (READONLY str : TEXT := "" ) -<I> (* m3wrapoutcheck:throws *)</I> - : NameResult RAISES {E} = - CONST - arg1name = "str"; <I>(* m3wrapargconst *)</I> - VAR - arg0 : C.char_star; <I>(* m3wrapretvar *)</I> - arg1 : C.char_star; <I>(* m3wrapargvar *)</I> - arg2 : C.int; - result : RECORD -<I> (*m3wrapretname m3wraprettype*)</I> - unixPath : TEXT; -<I> (*m3wrapoutname m3wrapouttype*)</I> - checksum : CARDINAL; - END; - BEGIN - TRY - arg1 := M3toC.SharedTtoS(str); <I>(* m3wrapinconv *)</I> - IF Text.Length(arg1) > 10 THEN <I>(* m3wrapincheck *)</I> - RAISE E("str too long"); - END; -<I> (* m3wrapretraw m3wrapargraw *)</I> - arg0 := MessyToUnix (arg1, arg2); - result.unixPath := M3toC.CopyStoT(arg0); <I>(* m3wrapretconv *)</I> - result.checksum := arg2; <I>(* m3wrapoutconv *)</I> - IF result.checksum = 0 THEN <I>(* m3wrapoutcheck *)</I> - RAISE E("invalid checksum"); - END; - FINALLY - M3toC.FreeSharedS(str, arg1); <I>(* m3wrapfreearg *)</I> - END; - END Name; -</pre></div> - - -<H2><a name="Modula3_hints">31.5 More hints to the generator</a></H2> - - -<H3><a name="Modula3_features">31.5.1 Features</a></H3> - - -<table border summary="Modula-3 features"> -<tr> - <th>Feature</th> - <th>Example</th> - <th>Description</th> -</tr> -<tr> - <td>multiretval</td> - <td><tt>%m3multiretval get_box;</tt> or - <tt>%feature("modula3:multiretval") get_box;</tt></td> - <td>Let the denoted function return a <tt>RECORD</tt> - rather than a plain value. - This <tt>RECORD</tt> contains all arguments with "out" direction - including the return value of the C function (if there is one). - If more than one argument is "out" - then the function <b>must</b> have the <tt>multiretval</tt> feature activated, - but it is explicitly requested from the user to prevent mistakes.</td> -</tr> -<tr> - <td>constnumeric</td> - <td><tt>%constnumeric(12) twelve;</tt> or - <tt>%feature("constnumeric", "12") twelve;</tt></td> - <td>This feature can be used to tell Modula-3's back-end of SWIG - the value of an identifier. - This is necessary in the cases - where it was defined by a non-trivial C expression. - This feature is used by the - <tt>-generateconst</tt> <a href="#Modula3_commandline">option</a>. - In future it may be generalized to other kind of values - such as strings. - </td> -</tr> -</table> - -<H3><a name="Modula3_pragmas">31.5.2 Pragmas</a></H3> - - -<table border summary="Modula-3 pragmas"> -<tr> - <th>Pragma</th> - <th>Example</th> - <th>Description</th> -</tr> -<tr> - <td>unsafe</td> - <td><tt>%pragma(modula3) unsafe="true";</tt></td> - <td>Mark the raw interface modules as <tt>UNSAFE</tt>. - This will be necessary in many cases.</td> -</tr> -<tr> - <td>library</td> - <td><tt>%pragma(modula3) library="m3fftw";</tt></td> - <td>Specifies the library name for the wrapper library to be created. - It should be distinct from the name of the library to be wrapped.</td> -</tr> -</table> - -<H2><a name="Modula3_remarks">31.6 Remarks</a></H2> - - -<ul> -<li> -The Modula-3 part of SWIG doesn't try to generate nicely formatted code. -If you need to read the generated code, use <tt>m3pp</tt> to postprocess the -Modula files. -</li> -</ul> - -</body> -</html> diff --git a/Doc/Manual/Perl5.html b/Doc/Manual/Perl5.html index 1e7bd9f86..85c2545cf 100644 --- a/Doc/Manual/Perl5.html +++ b/Doc/Manual/Perl5.html @@ -2243,7 +2243,7 @@ can be done using the <tt>EXTEND()</tt> macro as in: EXTEND(sp, 1); /* Extend the stack by 1 object */ } $result = sv_newmortal(); - sv_setiv($target, (IV) *($1)); + sv_setiv($result, (IV) *($1)); argvi++; } </pre></div> diff --git a/Doc/Manual/Php.html b/Doc/Manual/Php.html index 09c514e94..5aea878b2 100644 --- a/Doc/Manual/Php.html +++ b/Doc/Manual/Php.html @@ -51,12 +51,12 @@ <p> In this chapter, we discuss SWIG's support of PHP. SWIG currently supports -generating wrappers for PHP7. Support for PHP5 was removed in SWIG 4.0.0 -and support for PHP4 was removed in SWIG 1.3.37. +generating wrappers for PHP7 and PHP8. Support for PHP5 was removed in SWIG +4.0.0 and support for PHP4 was removed in SWIG 1.3.37. </p> <p> -Currently any PHP7 release should work. +Currently any PHP7 or PHP8 release should work. </p> <p> @@ -84,16 +84,21 @@ swig -php7 example.i </pre></div> <p> -This will produce 3 files example_wrap.c, php_example.h and -example.php. The first file, <tt>example_wrap.c</tt> contains all of +This will produce 2 files: example_wrap.c and php_example.h. +The first file, <tt>example_wrap.c</tt> contains all of the C code needed to build a PHP extension. The second file, <tt>php_example.h</tt> contains the header information needed if you wish to statically link the extension into the php interpreter. -The third file, -<tt>example.php</tt> can be included by PHP scripts. It attempts to -dynamically load the extension and contains extra php code specified -in the interface file. If wrapping C++ code with PHP classes, it will -also contain PHP class wrappers. +</p> + +<p> +If the interface file uses <tt>%pragma(php) include=</tt>... or +<tt>%pragma(php) code=</tt>... then SWIG will also generate a third file, +<tt>example.php</tt> to contain what these specify. In SWIG < 4.1.0, +this third file was always generated as it defined the PHP classes, etc +(but this is now done via C code in <tt>example_wrap.c</tt>) and also +contained code to dynamically load the extension (but this used the +PHP <tt>dl()</tt> function, which isn't recommended nowadays). </p> <p> @@ -139,47 +144,43 @@ least work for Linux though): <p> To test the extension from a PHP script, you first need to tell PHP to -load it. To do this, add a line like this to the <tt>[PHP]</tt> section of -<tt>php.ini</tt>: +load it. Assuming you're using PHP 7.2 or higher, the recommended (and +simplest!) way to do this is to copy it to PHP's default extension directory +and add a line like this to the <tt>[PHP]</tt> section of <tt>php.ini</tt>: </p> <div class="code"><pre> - extension=/path/to/modulename.so + extension=modulename </pre></div> <p> -If the module is in PHP's default extension directory, you can omit the path. -</p> - -<p> -For some SAPIs (for example, the CLI SAPI) you can instead use the -<a href="https://www.php.net/manual/en/function.dl.php">dl() function</a> to load -an extension at run time, by adding a line like this to the start of each -PHP script which uses your extension: +PHP < 7.2 doesn't support loading by just the module name, so you need +to specify the filename of the module to be specified, which varies +between platforms. And for any PHP version, if the module is not in PHP's +default extension directory, you also need to specify the path, for example: </p> <div class="code"><pre> - dl("/path/to/modulename.so"); // Load the module + extension=/path/to/modulename.so </pre></div> <p> -But note that <tt>dl()</tt> isn't supported when running PHP through a -webserver - you'll need to use <tt>extension</tt> in <tt>php.ini</tt> as -described above. -</p> - -<p> -The PHP module which SWIG generates will also attempt to do the <tt>dl()</tt> -call for you if the extension isn't already loaded: +If you're using the PHP CLI SAPI it's possible (but not recommended) to use the +<a href="https://www.php.net/manual/en/function.dl.php">dl() function</a> to +load an extension at run time, by adding a line like this to the start of each +PHP script which uses your extension: </p> <div class="code"><pre> - include("example.php"); + dl("/path/to/modulename.so"); // Load the module </pre></div> <p> -This PHP module also defines the PHP classes for the wrapped API, so you'll -almost certainly want to include it anyway. +But to do this portably you need to take into account that pathnames and the +filename extension vary by platform, and for security reasons PHP no longer +supports <tt>dl()</tt> when running PHP through a webserver. Overall it's +better to instead use <tt>extension</tt> in <tt>php.ini</tt> as described +above. </p> <H2><a name="Php_nn2">32.2 Basic PHP interface</a></H2> @@ -219,24 +220,19 @@ you can access the constants in your PHP script like this, </p> <div class="code"><pre> -include("example.php"); - echo "PI = " . PI . "\n"; - echo "E = " . E . "\n"; - </pre> </div> <p> -There's one peculiarity of how constants work in PHP which it is useful -to note (this is not specific to SWIG though) - if you try to use an undeclared -constant, PHP will emit a warning (or a notice in PHP 7.1 and earlier) and then -expand the constant to a string version of the constant's name. Unfortunately -it is easy to miss the warning message if you're using PHP in a webserver as -it will probably end up in error.log or similar. Apparently this will throw -an Error in a future version of PHP, but until then it's something to be -aware of. +There's one peculiarity of how constants work in PHP prior to PHP 8 +which it is useful to note (this is not specific to SWIG though) - if you try +to use an undeclared constant, PHP will emit a warning (or a notice in PHP 7.1 +and earlier) and then expand the constant to a string version of the constant's +name. Unfortunately it is easy to miss the warning message if you're using PHP +in a webserver as it will probably end up in error.log or similar. PHP 8.0 +made this an error. </p> <p> @@ -256,8 +252,6 @@ accessed incorrectly in PHP, <div class="code"> <pre> -include("example.php"); - if(EASY_TO_MISPEL) { ... } else { @@ -298,7 +292,6 @@ is accessed as follows: </p> <div class="code"><pre> -include("example.php"); print seki_get(); seki_set( seki_get() * 2); # The C variable is now 4. print seki_get(); @@ -306,8 +299,10 @@ print seki_get(); <p> SWIG supports global variables of all C datatypes including pointers -and complex objects. Additional types can be supported by using the -<tt>varinit</tt> typemap. +and complex objects. To support additional types, you just need to +supply the standard <tt>in</tt> and <tt>out</tt> typemaps, which get +used because of the wrapping as <tt>_get()</tt> and <tt>_set()</tt> +functions. </p> <p> @@ -342,7 +337,6 @@ Will be accessed in PHP like this : </p> <div class="code"><pre> -include("example.php"); $a = foo(2); $b = bar(3.5, -1.5); $c = bar(3.5); # Use default argument for 2nd parameter @@ -432,10 +426,12 @@ taking the integer argument. <H3><a name="Php_nn2_5">32.2.5 Pointers and References</a></H3> - <p> -Pointers to C/C++ objects are represented -as PHP resources, rather like MySQL connection handles. +Since SWIG 4.1.0, SWIG wraps C/C++ classes directly with PHP objects. +Pointers to other types are also wrapped as PHP objects - mostly this is an +implementation detail, but it's visible from PHP via <tt>is_object()</tt> and +similar. In earlier SWIG versions, PHP resources were used to wrap both +classes and pointers to other types. </p> <p> @@ -467,8 +463,6 @@ This will result in the following usage in PHP: <div class="code"><pre> <?php -include("example.php"); - $in1=copy_intp(3); $in2=copy_intp(5); $result=new_intp(); @@ -476,7 +470,6 @@ $result=new_intp(); add( $in1, $in2, $result ); echo "The sum " . intp_value($in1) . " + " . intp_value($in2) . " = " . intp_value( $result) . "\n"; -?> </pre></div> <p> @@ -501,14 +494,11 @@ This will result in the following usage in PHP: <div class="code"><pre> <?php -include("example.php"); - $in1 = 3; $in2 = 5; $result= add($in1, $in2); # Note using variables for the input is unnecessary. echo "The sum $in1 + $in2 = $result\n"; -?> </pre></div> <p> @@ -539,15 +529,12 @@ This will result in the following usage in PHP: <div class="code"><pre> <?php -include("example.php"); - $in1 = 3; $in2 = 5; $result = 0; add($in1, $in2, $result); echo "The sum $in1 + $in2 = $result\n"; -?> </pre></div> <p> @@ -572,11 +559,16 @@ variable, or assigning <tt>NULL</tt> to a variable. <p> -SWIG defaults to wrapping C++ structs and classes with PHP classes - this -is done by generating a PHP wrapper script which defines proxy classes -which calls a set of flat functions which actually wrap the C++ class. -You can disable this wrapper layer by passing the command-line option -"-noproxy" in which case you'll just get the flat functions. +SWIG defaults to wrapping C++ structs and classes with PHP classes. +Since SWIG 4.1.0, this is done entirely via PHP's C API - earlier SWIG +versions generated a PHP wrapper script which defined proxy classes +which called a set of flat functions which actually wrapped the C++ class. +</p> + +<p> +If you don't want the class wrappers, you can pass the command-line option +"-noproxy" in which case you'll get C++ classes wrapped as flat functions +as described below. </p> <p> @@ -605,7 +597,6 @@ Would be used in the following way from PHP: <div class="code"><pre> <?php - require "vector.php"; $v = new Vector(); $v->x = 3; @@ -622,7 +613,6 @@ Would be used in the following way from PHP: $c->im = 0; # $c destructor called when $c goes out of scope. -?> </pre></div> <p> @@ -667,8 +657,8 @@ constructor to execute. </p> <p> -Because PHP uses reference counting to manage resources, simple -assignment of one variable to another such as: +Because PHP uses reference counting, simple assignment of one variable to +another such as: </p> <div class="code"><pre> @@ -721,8 +711,6 @@ would be accessed in PHP as, </p> <div class="code"><pre> -include("example.php"); - echo "There have now been " . Ko::threats() . " threats\n"; </pre></div> @@ -756,7 +744,6 @@ class Ko { would be executed in PHP as, <div class="code"><pre> -include("example.php"); Ko::threats(); </pre></div> @@ -783,9 +770,8 @@ If there are multiple interfaces, just list them separated by commas. <p> -To place PHP code in the generated "example.php" file one can use the -<b>code</b> pragma. The code is inserted after loading the shared -object. +You can get SWIG to generate an "example.php" file by specifying +the code to put in it using the <b>code</b> pragma. </p> <div class="code"><pre> @@ -883,7 +869,7 @@ into the request init (PHP_RINIT_FUNCTION) and request shutdown (PHP_RSHUTDOWN_F Proxy classes provide a more natural, object-oriented way to access extension classes. As described above, each proxy instance has an associated C++ instance, and method calls to the proxy are passed to the -C++ instance transparently via C wrapper functions. +C++ instance transparently. </p> <p> @@ -989,8 +975,6 @@ then at the PHP side you can define <div class="targetlang"> <pre> -require("mymodule.php"); - class MyFoo extends Foo { function one() { print "one from php\n"; @@ -1012,8 +996,8 @@ that derives from both the class in question and a special <tt>Swig::Director</tt> class. These new classes, referred to as director classes, can be loosely thought of as the C++ equivalent of the PHP proxy classes. The director classes store a pointer to their underlying -PHP object. Indeed, this is quite similar to the "_cPtr" and "thisown" -members of the PHP proxy classes. +PHP object. Indeed, this is quite similar to <tt>struct swig_object_wrapper</tt> +which is used to implement the PHP proxy classes. </p> <p> @@ -1068,12 +1052,12 @@ infinite loop. <p> One more point needs to be made about the relationship between director classes and proxy classes. When a proxy class instance is created in -PHP, SWIG creates an instance of the original C++ class and assigns it -to <tt>->_cPtr</tt>. This is exactly what happens without directors -and is true even if directors are enabled for the particular class in -question. When a class <i>derived</i> from a proxy class is created, -however, SWIG then creates an instance of the corresponding C++ director -class. The reason for this difference is that user-defined subclasses +PHP, SWIG creates an instance of the original C++ class and stores it +in the <tt>struct swig_object_wrapper</tt>. This is true whether or not +directors are enabled for the particular class in question. However +when a class <i>derived</i> from a proxy class is created, SWIG instead +creates an instance of the corresponding C++ director class. +The reason for this difference is that user-defined subclasses may override or extend methods of the original class, so the director class is needed to route calls to these methods correctly. For unmodified proxy classes, all methods are ultimately implemented in C++ @@ -1161,7 +1145,12 @@ should suffice in most cases: <div class="code"> <pre> %feature("director:except") { - if ($error == FAILURE) { +#if SWIG_VERSION >= 0x040100 + if ($error != NULL) +#else + if ($error == FAILURE) +#endif + { throw Swig::DirectorMethodException(); } } @@ -1169,6 +1158,20 @@ should suffice in most cases: </div> <p> +If you only need to support SWIG >= 4.1.0, you can just use the +<tt>($error != NULL)</tt> condition. +</p> + +<p> +In SWIG 4.1.0, <tt>$error</tt> was changed in the SWIG/PHP director +implementation to make it work more like how it does for other languages. +Previously, <tt>$error</tt> didn't actually indicate an exception, but instead +was only set to <tt>FAILURE</tt> if there was a problem calling the PHP method. +Now <tt>$error</tt> indicates if the PHP method threw a PHP exception, and +directorout typemaps for PHP no longer need to be gated by <tt>if (EG(exception))</tt>. +</p> + +<p> This code will check the PHP error state after each method call from a director into PHP, and throw a C++ exception if an error occurred. This exception can be caught in C++ to implement an error handler. diff --git a/Doc/Manual/Pike.html b/Doc/Manual/Pike.html deleted file mode 100644 index 2b8432399..000000000 --- a/Doc/Manual/Pike.html +++ /dev/null @@ -1,246 +0,0 @@ -<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> -<html> -<head> -<title>SWIG and Pike</title> -<link rel="stylesheet" type="text/css" href="style.css"> -<meta http-equiv="content-type" content="text/html; charset=UTF-8"> -</head> - -<body bgcolor="#ffffff"> -<H1><a name="Pike">37 SWIG and Pike</a></H1> -<!-- INDEX --> -<div class="sectiontoc"> -<ul> -<li><a href="#Pike_nn2">Preliminaries</a> -<ul> -<li><a href="#Pike_nn3">Running SWIG</a> -<li><a href="#Pike_nn4">Getting the right header files</a> -<li><a href="#Pike_nn5">Using your module</a> -</ul> -<li><a href="#Pike_nn6">Basic C/C++ Mapping</a> -<ul> -<li><a href="#Pike_nn7">Modules</a> -<li><a href="#Pike_nn8">Functions</a> -<li><a href="#Pike_nn9">Global variables</a> -<li><a href="#Pike_nn10">Constants and enumerated types</a> -<li><a href="#Pike_nn11">Constructors and Destructors</a> -<li><a href="#Pike_nn12">Static Members</a> -</ul> -</ul> -</div> -<!-- INDEX --> - - - -<p> -This chapter describes SWIG support for Pike. As of this writing, the -SWIG Pike module is still under development and is not considered -ready for prime time. The Pike module is being developed against the -Pike 7.4.10 release and may not be compatible with previous versions -of Pike. -</p> - -<p> -This chapter covers most SWIG features, but certain low-level details -are covered in less depth than in earlier chapters. At the very -least, make sure you read the "<a href="SWIG.html#SWIG">SWIG Basics</a>" -chapter.<br> -</p> - -<H2><a name="Pike_nn2">37.1 Preliminaries</a></H2> - - -<H3><a name="Pike_nn3">37.1.1 Running SWIG</a></H3> - - -<p> -Suppose that you defined a SWIG module such as the following: -</p> - -<div class="code"> - <pre>%module example<br><br>%{<br>#include "example.h"<br>%}<br><br>int fact(int n);<br></pre> -</div> - -<p> -To build a C extension module for Pike, run SWIG using the <tt>-pike</tt> option : -</p> - -<div class="code"> - <pre>$ <b>swig -pike example.i</b><br></pre> -</div> - -<p> -If you're building a C++ extension, be sure to add the <tt>-c++</tt> option: -</p> - -<div class="code"> - <pre>$ <b>swig -c++ -pike example.i</b><br></pre> -</div> - -<p> -This creates a single source file named <tt>example_wrap.c</tt> (or <tt>example_wrap.cxx</tt>, if you -ran SWIG with the <tt>-c++</tt> option). -The SWIG-generated source file contains the low-level wrappers that need -to be compiled and linked with the rest of your C/C++ application to -create an extension module. -</p> - -<p> -The name of the wrapper file is derived from the name of the input -file. For example, if the input file is <tt>example.i</tt>, the name -of the wrapper file is <tt>example_wrap.c</tt>. To change this, you -can use the <tt>-o</tt> option: -</p> - -<div class="code"> - <pre>$ <b>swig -pike -o pseudonym.c example.i</b><br></pre> -</div> -<H3><a name="Pike_nn4">37.1.2 Getting the right header files</a></H3> - - -<p> -In order to compile the C/C++ wrappers, the compiler needs to know the -path to the Pike header files. These files are usually contained in a -directory such as -</p> - -<div class="code"> - <pre>/usr/local/pike/7.4.10/include/pike<br></pre> -</div> - -<p> -There doesn't seem to be any way to get Pike itself to reveal the -location of these files, so you may need to hunt around for them. -You're looking for files with the names <tt>global.h</tt>, <tt>program.h</tt> -and so on. -</p> - -<H3><a name="Pike_nn5">37.1.3 Using your module</a></H3> - - -<p> -To use your module, simply use Pike's <tt>import</tt> statement: -</p> - -<div class="code"><pre> -$ <b>pike</b> -Pike v7.4 release 10 running Hilfe v3.5 (Incremental Pike Frontend) -> <b>import example;</b> -> <b>fact(4);</b> -(1) Result: 24 -</pre></div> - -<H2><a name="Pike_nn6">37.2 Basic C/C++ Mapping</a></H2> - - -<H3><a name="Pike_nn7">37.2.1 Modules</a></H3> - - -<p> -All of the code for a given SWIG module is wrapped into a single Pike -module. Since the name of the shared library that implements your -module ultimately determines the module's name (as far as Pike is -concerned), SWIG's <tt>%module</tt> directive doesn't really have any -significance. -</p> - -<H3><a name="Pike_nn8">37.2.2 Functions</a></H3> - - -<p> -Global functions are wrapped as new Pike built-in functions. For -example, -</p> - -<div class="code"><pre> -%module example - -int fact(int n); -</pre></div> - -<p> -creates a new built-in function <tt>example.fact(n)</tt> that works -exactly as you'd expect it to: -</p> - -<div class="code"><pre> -> <b>import example;</b> -> <b>fact(4);</b> -(1) Result: 24 -</pre></div> - -<H3><a name="Pike_nn9">37.2.3 Global variables</a></H3> - - -<p> -Global variables are currently wrapped as a pair of functions, one to get -the current value of the variable and another to set it. For example, the -declaration -</p> - -<div class="code"><pre> -%module example - -double Foo; -</pre></div> - -<p> -will result in two functions, <tt>Foo_get()</tt> and <tt>Foo_set()</tt>: -</p> - -<div class="code"><pre> -> <b>import example;</b> -> <b>Foo_get();</b> -(1) Result: 3.000000 -> <b>Foo_set(3.14159);</b> -(2) Result: 0 -> <b>Foo_get();</b> -(3) Result: 3.141590 -</pre></div> - -<H3><a name="Pike_nn10">37.2.4 Constants and enumerated types</a></H3> - - -<p> -Enumerated types in C/C++ declarations are wrapped as Pike constants, -not as Pike enums. -</p> - -<H3><a name="Pike_nn11">37.2.5 Constructors and Destructors</a></H3> - - -<p> -Constructors are wrapped as <tt>create()</tt> methods, and destructors are -wrapped as <tt>destroy()</tt> methods, for Pike classes. -</p> - -<H3><a name="Pike_nn12">37.2.6 Static Members</a></H3> - - -<p> -Since Pike doesn't support static methods or data for Pike classes, static -member functions in your C++ classes are wrapped as regular functions and -static member variables are wrapped as pairs of functions (one to get the -value of the static member variable, and another to set it). The names of -these functions are prepended with the name of the class. -For example, given this C++ class declaration: -</p> - -<div class="code"><pre> -class Shape -{ -public: - static void print(); - static int nshapes; -}; -</pre></div> - -<p> -SWIG will generate a <tt>Shape_print()</tt> method that invokes the static -<tt>Shape::print()</tt> member function, as well as a pair of methods, -<tt>Shape_nshapes_get()</tt> and <tt>Shape_nshapes_set()</tt>, to get and set -the value of <tt>Shape::nshapes</tt>. -</p> - -</body> -</html> diff --git a/Doc/Manual/Preprocessor.html b/Doc/Manual/Preprocessor.html index 51cc06378..7611ea40c 100644 --- a/Doc/Manual/Preprocessor.html +++ b/Doc/Manual/Preprocessor.html @@ -123,7 +123,7 @@ SWIGOCAML Defined when using OCaml SWIGOCTAVE Defined when using Octave SWIGPERL Defined when using Perl SWIGPHP Defined when using PHP (any version) -SWIGPHP7 Defined when using PHP7 +SWIGPHP7 Defined when using PHP 7 or later (with a compatible C API) SWIGPYTHON Defined when using Python SWIGR Defined when using R SWIGRUBY Defined when using Ruby diff --git a/Doc/Manual/Python.html b/Doc/Manual/Python.html index c132afc8a..1bd7b1e3c 100644 --- a/Doc/Manual/Python.html +++ b/Doc/Manual/Python.html @@ -1608,7 +1608,7 @@ public: </div> <p> -In Python, the static member can be access in three different ways: +In Python, the static member can be accessed in three different ways: </p> <div class="targetlang"> @@ -1616,7 +1616,7 @@ In Python, the static member can be access in three different ways: >>> example.Spam_foo() # Spam::foo() >>> s = example.Spam() >>> s.foo() # Spam::foo() via an instance ->>> example.Spam.foo() # Spam::foo(). Python-2.2 only +>>> example.Spam.foo() # Spam::foo() using Python-2.2 and later </pre> </div> @@ -1627,16 +1627,31 @@ last technique is only available in Python-2.2 and later versions. <p> Static member variables are currently accessed as global variables. This means, -they are accessed through <tt>cvar</tt> like this: +they are accessed through <tt>cvar</tt> or via an instance property: </p> <div class="targetlang"> <pre> ->>> print example.cvar.Spam_bar +>>> example.cvar.Spam_bar # Spam::bar +7 +>>> s = example.Spam() +>>> s.bar # Spam::bar via an instance property +7 +</pre> +</div> + +<p> +The <tt>-builtin</tt> option uses a metaclass to additionally provide access as follows: +</p> + +<div class="targetlang"> +<pre> +>>> example.Spam.bar # Spam::bar using -builtin option only 7 </pre> </div> + <H3><a name="Python_nn21">33.3.8 C++ inheritance</a></H3> diff --git a/Doc/Manual/R.html b/Doc/Manual/R.html index e44fe432c..9b05922fd 100644 --- a/Doc/Manual/R.html +++ b/Doc/Manual/R.html @@ -196,7 +196,7 @@ slices) <p> Wrapping of C++ classes for R works quite well. R has a special type, known as an external reference, that can be used as a pointer -to arbitary things, including C++ classes. The proxy layers generated +to arbitrary things, including C++ classes. The proxy layers generated for other classes are not required. </p> @@ -265,7 +265,7 @@ v2$Axles [1] 4 v1$Available [1] FALSE -# Set availabilty +# Set availability v1$Available <- TRUE v1$Available [1] TRUE diff --git a/Doc/Manual/SWIG.html b/Doc/Manual/SWIG.html index c54d117e0..876c0ac17 100644 --- a/Doc/Manual/SWIG.html +++ b/Doc/Manual/SWIG.html @@ -127,7 +127,7 @@ Supported Target Language Options -lua - Generate Lua wrappers -octave - Generate Octave wrappers -perl5 - Generate Perl 5 wrappers - -php7 - Generate PHP 7 wrappers + -php7 - Generate PHP 7 or later wrappers -python - Generate Python wrappers -r - Generate R (aka GNU S) wrappers -ruby - Generate Ruby wrappers @@ -2020,7 +2020,7 @@ and a more descriptive one, but the two functions are otherwise equivalent: <tr> <td><span style="white-space: nowrap;"><tt>regex:/pattern/subst/</tt></span></td> <td>String after (Perl-like) regex substitution operation. This function - allows to apply arbitrary regular expressions to the identifier names. The + allows applying arbitrary regular expressions to the identifier names. The <i>pattern</i> part is a regular expression in Perl syntax (as supported by the <a href="http://www.pcre.org/">Perl Compatible Regular Expressions (PCRE)</a>) library and the <i>subst</i> string diff --git a/Doc/Manual/SWIGPlus.html b/Doc/Manual/SWIGPlus.html index 0c259e393..2244a0508 100644 --- a/Doc/Manual/SWIGPlus.html +++ b/Doc/Manual/SWIGPlus.html @@ -3632,7 +3632,7 @@ Alternatively, you could expand the constructor template in selected instantiati // Create default and conversion constructors %extend pair<double, double> { - %template(paird) pair<double, dobule>; // Default constructor + %template(paird) pair<double, double>; // Default constructor %template(pairc) pair<int, int>; // Conversion constructor }; </pre> @@ -3647,7 +3647,7 @@ instead: <pre> // Create default and conversion constructors %extend pair<double, double> { - %template(pair) pair<double, dobule>; // Default constructor + %template(pair) pair<double, double>; // Default constructor %template(pair) pair<int, int>; // Conversion constructor }; </pre> diff --git a/Doc/Manual/Warnings.html b/Doc/Manual/Warnings.html index 0cf2a1066..02197f1cb 100644 --- a/Doc/Manual/Warnings.html +++ b/Doc/Manual/Warnings.html @@ -483,7 +483,7 @@ example.i(4) : Syntax error in input(1). <li>401. Nothing known about class 'name'. Ignored. <li>402. Base class 'name' is incomplete. <li>403. Class 'name' might be abstract. -<li>450. Deprecated typemap feature ($source/$target). +<li>450. Reserved <li>451. Setting const char * variable may leak memory. <li>452. Reserved <li>453. Can't apply (pattern). No typemaps are defined. diff --git a/Doc/Manual/Windows.html b/Doc/Manual/Windows.html index 001d0ef46..eae9ffb84 100644 --- a/Doc/Manual/Windows.html +++ b/Doc/Manual/Windows.html @@ -34,6 +34,7 @@ <li><a href="#Windows_swig_exe">Building swig.exe on Windows</a> <ul> <li><a href="#Windows_cmake">Building swig.exe using CMake</a> +<li><a href="#Windows_mingw_msys">Building swig.exe using MSYS2</a> <li><a href="#Windows_mingw_msys">Building swig.exe using MinGW and MSYS</a> <li><a href="#Windows_cygwin">Building swig.exe using Cygwin</a> </ul> @@ -250,7 +251,8 @@ For fully working build steps always check the Continuous Integration setups cur and save to a folder e.g. C:\Tools\Bison </li> <li> - Install PCRE using Nuget using the following command: <pre>C:\Tools\nuget install pcre -Version 8.33.0.1 -OutputDirectory C:\Tools\pcre</pre> + Install PCRE using Nuget using the following command: <pre>C:\Tools\nuget install pcre -Version 8.33.0.1 -OutputDirectory C:\Tools\pcre</pre>. + Alternatively, use <tt>WITH_PCRE</tt> option to disable PCRE support if you are sure not to need it. </li> <li> We will also need the SWIG source code. Either download a zipped archive from GitHub, or if git is installed clone the latest codebase @@ -296,7 +298,59 @@ swig.exe -help <pre>-python -c++ -o C:\Temp\doxygen_parsing.cpp C:\swig\Examples\test-suite\doxygen_parsing.i</pre> </div> -<H4><a name="Windows_mingw_msys">3.3.1.2 Building swig.exe using MinGW and MSYS</a></H4> +<H4><a name="Windows_mingw_msys">3.3.1.2 Building swig.exe using MSYS2</a></H4> + + +<p> +Download and install MSYS2 from <a href="https://www.msys2.org/">www.msys2.org</a> (tested with version msys2-x86_64-20201109). +Launch the MSYS2 shell. +</p> +<p> +Install the packages needed to build swig:<br> +</p> + +<div class="shell"> +<pre> +pacman -S git autoconf automake bison gcc make pcre-devel +</pre> +</div> + +<p> +Clone the repository to /usr/src/: +</p> + +<div class="shell"> +<pre> +mkdir /usr/src/ +cd /usr/src/ +git clone https://github.com/swig/swig.git +</pre> +</div> + +<p> +Configure and build: +</p> + +<div class="shell"> +<pre> +cd /usr/src/swig +./autogen.sh +./configure +make +</pre> +</div> + +<p> +Finally you may also want to install SWIG: +</p> + +<div class="shell"> +<pre> +make install +</pre> +</div> + +<H4><a name="Windows_mingw_msys">3.3.1.3 Building swig.exe using MinGW and MSYS</a></H4> <p> @@ -414,7 +468,7 @@ make </ol> -<H4><a name="Windows_cygwin">3.3.1.3 Building swig.exe using Cygwin</a></H4> +<H4><a name="Windows_cygwin">3.3.1.4 Building swig.exe using Cygwin</a></H4> <p> diff --git a/Examples/Makefile.in b/Examples/Makefile.in index 3f6140b5e..eeb7a25a5 100644 --- a/Examples/Makefile.in +++ b/Examples/Makefile.in @@ -165,6 +165,7 @@ TCL_SO = @TCL_SO@ TCLLDSHARED = @TCLLDSHARED@ TCLCXXSHARED = @TCLCXXSHARED@ TCL_SCRIPT = $(SRCDIR)$(RUNME).tcl +TCL_LINK = @TCLLINK@ # ----------------------------------------------------------- # Build a new version of the tclsh shell @@ -187,7 +188,7 @@ tclsh_cpp: $(SRCDIR_SRCS) tcl: $(SRCDIR_SRCS) $(SWIG) -tcl8 $(SWIGOPT) $(TCL_SWIGOPTS) -o $(ISRCS) $(INTERFACEPATH) $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(TCL_INCLUDE) - $(TCLLDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO) + $(TCLLDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO) $(TCL_LINK) # ----------------------------------------------------------- # Build a Tcl7.5 dynamic loadable module for C++ @@ -196,7 +197,7 @@ tcl: $(SRCDIR_SRCS) tcl_cpp: $(SRCDIR_SRCS) $(SWIG) -tcl8 -c++ $(SWIGOPT) $(TCL_SWIGOPTS) -o $(ICXXSRCS) $(INTERFACEPATH) $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(TCL_INCLUDE) - $(TCLCXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO) + $(TCLCXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(TCL_DLNK) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(TCL_SO) $(TCL_LINK) # ----------------------------------------------------------------- # Run Tcl example @@ -1045,20 +1046,21 @@ ruby_clean: rm -f *.@OBJEXT@ *$(RUBY_SO) ################################################################## -##### PHP7 ###### +##### PHP ###### ################################################################## PHP = @PHP@ PHP_INCLUDE = @PHPINC@ PHP_SO = @PHP_SO@ PHP_SCRIPT = $(SRCDIR)$(RUNME).php +PHP_EXTENSION = example$(PHP_SO) # ------------------------------------------------------------------- # Build a PHP dynamically loadable module (C) # ------------------------------------------------------------------- php: $(SRCDIR_SRCS) - $(SWIG) -php7 $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH) + $(SWIG) -php $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH) $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(SRCDIR_SRCS) $(ISRCS) $(INCLUDES) $(PHP_INCLUDE) $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO) @@ -1067,7 +1069,7 @@ php: $(SRCDIR_SRCS) # -------------------------------------------------------------------- php_cpp: $(SRCDIR_SRCS) - $(SWIG) -php7 -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH) + $(SWIG) -php -c++ $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH) $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(ICXXSRCS) $(INCLUDES) $(PHP_INCLUDE) $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(PHP_SO) @@ -1076,7 +1078,7 @@ php_cpp: $(SRCDIR_SRCS) # ----------------------------------------------------------------- php_run: - $(RUNTOOL) $(PHP) -n -q -d extension_dir=. -d safe_mode=Off -d display_errors=stderr $(PHP_SCRIPT) $(RUNPIPE) + $(RUNTOOL) $(PHP) -n -d extension_dir=. -d extension=$(PHP_EXTENSION) -d display_errors=stderr -r 'set_error_handler(function($$n,$$s,$$f,$$l){if($$f!==Null){print$$f;if($$l!==Null)print":$$l";print": ";}print"$$s\n";exit(1);});include($$argv[1]);' $(PHP_SCRIPT) $(RUNPIPE) # ----------------------------------------------------------------- # Version display @@ -1249,46 +1251,6 @@ lua_clean: rm -f *.@OBJEXT@ *$(LUA_SO) ################################################################## -##### ALLEGRO CL ###### -################################################################## - -ALLEGROCL = @ALLEGROCLBIN@ -ALLEGROCL_SCRIPT=$(RUNME).lisp - -allegrocl: $(SRCDIR_SRCS) - $(SWIG) -allegrocl -cwrap $(SWIGOPT) -o $(ISRCS) $(INTERFACEPATH) - $(CC) -c $(CCSHARED) $(CPPFLAGS) $(CFLAGS) $(ISRCS) $(INCLUDES) $(SRCDIR_SRCS) - $(LDSHARED) $(CFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) -o $(LIBPREFIX)$(TARGET)$(SO) - -allegrocl_cpp: $(SRCDIR_SRCS) - $(SWIG) -c++ -allegrocl $(SWIGOPT) -o $(ICXXSRCS) $(INTERFACEPATH) - $(CXX) -c $(CCSHARED) $(CPPFLAGS) $(CXXFLAGS) $(ICXXSRCS) $(SRCDIR_SRCS) $(SRCDIR_CXXSRCS) $(INCLUDES) - $(CXXSHARED) $(CXXFLAGS) $(LDFLAGS) $(OBJS) $(IOBJS) $(LIBS) $(CPP_DLLIBS) -o $(LIBPREFIX)$(TARGET)$(SO) - -# ----------------------------------------------------------------- -# Run ALLEGRO CL example -# ----------------------------------------------------------------- - -allegrocl_run: - $(RUNTOOL) $(ALLEGROCL) -batch -s $(ALLEGROCL_SCRIPT) $(RUNPIPE) - -# ----------------------------------------------------------------- -# Version display -# ----------------------------------------------------------------- - -allegrocl_version: - $(ALLEGROCL) --version - -# ----------------------------------------------------------------- -# Cleaning the ALLEGRO CL examples -# ----------------------------------------------------------------- - -allegrocl_clean: - rm -f *_wrap* *~ .~* - rm -f core @EXTRA_CLEAN@ - rm -f *.@OBJEXT@ *@SO@ - -################################################################## ##### CFFI ###### ################################################################## diff --git a/Examples/chicken/README b/Examples/chicken/README deleted file mode 100644 index d4f91baf6..000000000 --- a/Examples/chicken/README +++ /dev/null @@ -1,12 +0,0 @@ -This directory contains examples for CHICKEN. - -class -- illustrates the proxy class C++ interface -constants -- handling #define and %constant literals -egg -- examples of building chicken extension libraries -multimap -- typemaps with multiple sub-types -overload -- C++ function overloading -simple -- the simple example from the user manual -zlib -- a wrapping of the zlib compression library - -You should be able to run make in each of the examples. By default, a shared -library will be built. Run make check to execute the test. diff --git a/Examples/chicken/check.list b/Examples/chicken/check.list deleted file mode 100644 index 9ea022bfb..000000000 --- a/Examples/chicken/check.list +++ /dev/null @@ -1,6 +0,0 @@ -# see top-level Makefile.in -class -constants -multimap -overload -simple diff --git a/Examples/chicken/class/Makefile b/Examples/chicken/class/Makefile deleted file mode 100644 index ea2d8b62e..000000000 --- a/Examples/chicken/class/Makefile +++ /dev/null @@ -1,40 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -INTERFACE = example.i -SRCS = -CXXSRCS = example.cxx -TARGET = class -INCLUDE = -SWIGOPT = -VARIANT = - -# uncomment the following lines to build a static exe (only pick one of the CHICKEN_MAIN lines) -#CHICKEN_MAIN = runme-lowlevel.scm -#CHICKEN_MAIN = runme-tinyclos.scm -#VARIANT = _static - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CHICKEN_SCRIPT='runme-lowlevel.scm' chicken_run - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CHICKEN_SCRIPT='runme-tinyclos.scm' chicken_run - -build: $(TARGET) $(TARGET)_proxy - -$(TARGET): $(INTERFACE) $(SRCS) - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \ - SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \ - INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp - -$(TARGET)_proxy: $(INTERFACE) $(SRCS) - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \ - SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT) -proxy' TARGET='$(TARGET)_proxy' \ - INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean - rm -f example.scm - rm -f $(TARGET) diff --git a/Examples/chicken/class/example.cxx b/Examples/chicken/class/example.cxx deleted file mode 100644 index 046304519..000000000 --- a/Examples/chicken/class/example.cxx +++ /dev/null @@ -1,28 +0,0 @@ -/* File : example.cxx */ - -#include "example.h" -#define M_PI 3.14159265358979323846 - -/* Move the shape to a new location */ -void Shape::move(double dx, double dy) { - x += dx; - y += dy; -} - -int Shape::nshapes = 0; - -double Circle::area() { - return M_PI*radius*radius; -} - -double Circle::perimeter() { - return 2*M_PI*radius; -} - -double Square::area() { - return width*width; -} - -double Square::perimeter() { - return 4*width; -} diff --git a/Examples/chicken/class/example.h b/Examples/chicken/class/example.h deleted file mode 100644 index 5bad31693..000000000 --- a/Examples/chicken/class/example.h +++ /dev/null @@ -1,41 +0,0 @@ -/* File : example.h */ - -class Shape { -public: - Shape() { - nshapes++; - } - virtual ~Shape() { - nshapes--; - } - double x, y; - void move(double dx, double dy); - virtual double area() = 0; - virtual double perimeter() = 0; - static int nshapes; - - enum SomeEnum { - First = 0, - Second, - Third, - Last = 1000 - }; -}; - -class Circle : public Shape { -private: - double radius; -public: - Circle(double r) : radius(r) { } - virtual double area(); - virtual double perimeter(); -}; - -class Square : public Shape { -private: - double width; -public: - Square(double w) : width(w) { } - virtual double area(); - virtual double perimeter(); -}; diff --git a/Examples/chicken/class/example.i b/Examples/chicken/class/example.i deleted file mode 100644 index fbdf7249f..000000000 --- a/Examples/chicken/class/example.i +++ /dev/null @@ -1,9 +0,0 @@ -/* File : example.i */ -%module example - -%{ -#include "example.h" -%} - -/* Let's just grab the original header file here */ -%include "example.h" diff --git a/Examples/chicken/class/runme-lowlevel.scm b/Examples/chicken/class/runme-lowlevel.scm deleted file mode 100644 index 7c59c0aaa..000000000 --- a/Examples/chicken/class/runme-lowlevel.scm +++ /dev/null @@ -1,76 +0,0 @@ -;; This file illustrates the low-level C++ interface generated -;; by SWIG. - -(load-library 'example "class.so") -(declare (uses example)) - -;; ----- Object creation ----- - -(display "Creating some objects:\n") -(define c (new-Circle 10.0)) -(display " Created circle ") -(display c) -(display "\n") -(define s (new-Square 10.0)) -(display " Created square ") -(display s) -(display "\n") - -;; ----- Access a static member ----- - -(display "\nA total of ") -(display (Shape-nshapes)) -(display " shapes were created\n") - -;; ----- Member data access ----- - -;; Set the location of the object - -(Shape-x-set c 20.0) -(Shape-y-set c 30.0) - -(Shape-x-set s -10.0) -(Shape-y-set s 5.0) - -(display "\nHere is their current position:\n") -(display " Circle = (") -(display (Shape-x-get c)) -(display ", ") -(display (Shape-y-get c)) -(display ")\n") -(display " Square = (") -(display (Shape-x-get s)) -(display ", ") -(display (Shape-y-get s)) -(display ")\n") - -;; ----- Call some methods ----- - -(display "\nHere are some properties of the shapes:\n") -(let - ((disp (lambda (o) - (display " ") - (display o) - (display "\n") - (display " area = ") - (display (Shape-area o)) - (display "\n") - (display " perimeter = ") - (display (Shape-perimeter o)) - (display "\n")))) - (disp c) - (disp s)) - -(display "\nGuess I'll clean up now\n") - -;; Note: this invokes the virtual destructor -(set! c #f) -(set! s #f) -(gc #t) - -(set! s 3) -(display (Shape-nshapes)) -(display " shapes remain\n") -(display "Goodbye\n") - -(exit) diff --git a/Examples/chicken/class/runme-tinyclos.scm b/Examples/chicken/class/runme-tinyclos.scm deleted file mode 100644 index 5ba1d6adb..000000000 --- a/Examples/chicken/class/runme-tinyclos.scm +++ /dev/null @@ -1,76 +0,0 @@ -;; This file illustrates the proxy C++ interface generated -;; by SWIG. - -(load-library 'example "class_proxy.so") -(declare (uses example)) -(declare (uses tinyclos)) - -;; ----- Object creation ----- - -(display "Creating some objects:\n") -(define c (make <Circle> 10.0)) -(display " Created circle ") -(display c) -(display "\n") -(define s (make <Square> 10.0)) -(display " Created square ") -(display s) -(display "\n") - -;; ----- Access a static member ----- - -(display "\nA total of ") -(display (Shape-nshapes)) -(display " shapes were created\n") - -;; ----- Member data access ----- - -;; Set the location of the object - -(slot-set! c 'x 20.0) -(slot-set! c 'y 30.0) - -(slot-set! s 'x -10.0) -(slot-set! s 'y 5.0) - -(display "\nHere is their current position:\n") -(display " Circle = (") -(display (slot-ref c 'x)) -(display ", ") -(display (slot-ref c 'y)) -(display ")\n") -(display " Square = (") -(display (slot-ref s 'x)) -(display ", ") -(display (slot-ref s 'y)) -(display ")\n") - -;; ----- Call some methods ----- - -(display "\nHere are some properties of the shapes:\n") -(let - ((disp (lambda (o) - (display " ") - (display o) - (display "\n") - (display " area = ") - (display (area o)) - (display "\n") - (display " perimeter = ") - (display (perimeter o)) - (display "\n")))) - (disp c) - (disp s)) - -(display "\nGuess I'll clean up now\n") - -;; Note: Invoke the virtual destructors by forcing garbage collection -(set! c 77) -(set! s 88) -(gc #t) - -(display (Shape-nshapes)) -(display " shapes remain\n") -(display "Goodbye\n") - -(exit) diff --git a/Examples/chicken/constants/Makefile b/Examples/chicken/constants/Makefile deleted file mode 100644 index 2fdde0a58..000000000 --- a/Examples/chicken/constants/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -INTERFACE = example.i -SRCS = -CXXSRCS = -TARGET = constants -INCLUDE = -SWIGOPT = -VARIANT = - -# uncomment the following two lines to build a static exe -#CHICKEN_MAIN = runme.scm -#VARIANT = _static - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run - -build: $(TARGET) - -$(TARGET): $(INTERFACE) $(SRCS) - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \ - SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \ - INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT) - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean - rm -f example.scm - rm -f $(TARGET) diff --git a/Examples/chicken/constants/example.i b/Examples/chicken/constants/example.i deleted file mode 100644 index 0995c19b9..000000000 --- a/Examples/chicken/constants/example.i +++ /dev/null @@ -1,27 +0,0 @@ -/* File : example.i */ -%module example - -/* A few preprocessor macros */ - -#define ICONST 42 -#define FCONST 2.1828 -#define CCONST 'x' -#define CCONST2 '\n' -#define SCONST "Hello World" -#define SCONST2 "\"Hello World\"" - -/* This should work just fine */ -#define EXPR ICONST + 3*(FCONST) - -/* This shouldn't do anything */ -#define EXTERN extern - -/* Neither should this (BAR isn't defined) */ -#define FOO (ICONST + BAR) - -/* The following directives also produce constants. Remember that - CHICKEN is normally case-insensitive, so don't rely on differing - case to differentiate variable names */ - -%constant int iconstX = 37; -%constant double fconstX = 3.14; diff --git a/Examples/chicken/constants/runme.scm b/Examples/chicken/constants/runme.scm deleted file mode 100644 index 1b10b2605..000000000 --- a/Examples/chicken/constants/runme.scm +++ /dev/null @@ -1,16 +0,0 @@ -;; feel free to uncomment and comment sections - -(load-library 'example "./constants.so") - -(display "starting test ... you will see 'finished' if successful.\n") -(or (= (ICONST) 42) (exit 1)) -(or (< (abs (- (FCONST) 2.1828)) 0.00001) (exit 1)) -(or (char=? (CCONST) #\x) (exit 1)) -(or (char=? (CCONST2) #\newline) (exit 1)) -(or (string=? (SCONST) "Hello World") (exit 1)) -(or (string=? (SCONST2) "\"Hello World\"") (exit 1)) -(or (< (abs (- (EXPR) (+ (ICONST) (* 3 (FCONST))))) 0.00001) (exit 1)) -(or (= (iconstX) 37) (exit 1)) -(or (< (abs (- (fconstX) 3.14)) 0.00001) (exit 1)) -(display "finished test.\n") -(exit 0) diff --git a/Examples/chicken/egg/Makefile b/Examples/chicken/egg/Makefile deleted file mode 100644 index 0137dc0a7..000000000 --- a/Examples/chicken/egg/Makefile +++ /dev/null @@ -1,41 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib - -check: build - cd eggs/install && csi ../../test.scm - -build: single multi - -# This creates an egg which contains only the single module. Any additional implementation files -# that implement the interface being wrapped should also be added to this egg -single: single_wrap.cxx - mkdir -p eggs - tar czf eggs/single.egg single.setup single.scm single_wrap.cxx - rm -f single.scm single_wrap.cxx - -# compile the single module with -nounit -single_wrap.cxx: single.i - $(SWIGEXE) -chicken -c++ -proxy -nounit single.i - -# Now build both mod1 and mod2 into a single egg -multi: mod1_wrap.cxx mod2_wrap.cxx - mkdir -p eggs - tar czf eggs/multi.egg multi.setup multi_init.scm mod1.scm mod1_wrap.cxx mod2.scm mod2_wrap.cxx - rm -f mod1.scm mod1_wrap.cxx mod2.scm mod2_wrap.cxx - -mod1_wrap.cxx: mod1.i - $(SWIGEXE) -chicken -c++ -proxy mod1.i - -mod2_wrap.cxx: mod2.i - $(SWIGEXE) -chicken -c++ -proxy mod2.i - -clean: - rm -rf eggs - -# this part is for testing... -setup: - cd eggs && \ - mkdir -p install && \ - chicken-setup -repository `pwd`/install single.egg && \ - chicken-setup -repository `pwd`/install multi.egg diff --git a/Examples/chicken/egg/README b/Examples/chicken/egg/README deleted file mode 100644 index b5df0e631..000000000 --- a/Examples/chicken/egg/README +++ /dev/null @@ -1,19 +0,0 @@ -These examples show how to build a chicken extension module in the form of an -egg. There are two eggs that get built, single.egg which contains a single -module which is built with -nounit and multi.egg, which contains two modules -mod1 and mod2. These are built normally, and multi_init.scm loads them both. -Read section "17.4.2 Building chicken extension libraries" in the manual -for a description of these two techniques. - -To build: - -$ make -$ make setup -$ make run - -$ make clean - -The eggs are built into an eggs subdirectory, because chicken-setup has -problems installing eggs when there are other files named similar in -the same directory. The make setup step runs chicken-setup to install -the eggs into the eggs/install directory. diff --git a/Examples/chicken/egg/mod1.i b/Examples/chicken/egg/mod1.i deleted file mode 100644 index 6a2940b89..000000000 --- a/Examples/chicken/egg/mod1.i +++ /dev/null @@ -1,8 +0,0 @@ -%module mod1 - -%inline %{ -class Bar { - public: - int b; -}; -%} diff --git a/Examples/chicken/egg/mod2.i b/Examples/chicken/egg/mod2.i deleted file mode 100644 index e9ae4a6a8..000000000 --- a/Examples/chicken/egg/mod2.i +++ /dev/null @@ -1,17 +0,0 @@ -%module mod2 - -%import "mod1.i" - -%{ -class Bar { - public: - int b; -}; -%} - -%inline %{ - class Bar2 : public Bar { - public: - int c; - }; -%} diff --git a/Examples/chicken/egg/multi.setup b/Examples/chicken/egg/multi.setup deleted file mode 100644 index 95aeb001c..000000000 --- a/Examples/chicken/egg/multi.setup +++ /dev/null @@ -1,2 +0,0 @@ -(run (csc -s -o multi.so multi_init.scm mod1.scm mod1_wrap.cxx mod2.scm mod2_wrap.cxx)) -(install-extension 'multi '("multi.so")) diff --git a/Examples/chicken/egg/multi_init.scm b/Examples/chicken/egg/multi_init.scm deleted file mode 100644 index 600491d5b..000000000 --- a/Examples/chicken/egg/multi_init.scm +++ /dev/null @@ -1,2 +0,0 @@ -(declare (uses mod1)) -(declare (uses mod2)) diff --git a/Examples/chicken/egg/single.i b/Examples/chicken/egg/single.i deleted file mode 100644 index 46266b4bf..000000000 --- a/Examples/chicken/egg/single.i +++ /dev/null @@ -1,8 +0,0 @@ -%module single - -%inline %{ -class Foo { - public: - int a; -}; -%} diff --git a/Examples/chicken/egg/single.setup b/Examples/chicken/egg/single.setup deleted file mode 100644 index 4b503ec21..000000000 --- a/Examples/chicken/egg/single.setup +++ /dev/null @@ -1,2 +0,0 @@ -(run (csc -s -o single.so single.scm single_wrap.cxx)) -(install-extension 'single '("single.so")) diff --git a/Examples/chicken/egg/test.scm b/Examples/chicken/egg/test.scm deleted file mode 100644 index 4ec94ed18..000000000 --- a/Examples/chicken/egg/test.scm +++ /dev/null @@ -1,18 +0,0 @@ -(require-extension single) -(require-extension multi) - -(define f (make <Foo>)) -(slot-set! f 'a 3) -(print (slot-ref f 'a)) - -(define b (make <Bar>)) -(slot-set! b 'b 2) -(print (slot-ref b 'b)) - -(define b2 (make <Bar2>)) -(slot-set! b2 'b 4) -(slot-set! b2 'c 6) -(print (slot-ref b2 'b)) -(print (slot-ref b2 'c)) - -(exit 0) diff --git a/Examples/chicken/multimap/Makefile b/Examples/chicken/multimap/Makefile deleted file mode 100644 index 551d1c74d..000000000 --- a/Examples/chicken/multimap/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -INTERFACE = example.i -SRCS = example.c -CXXSRCS = -TARGET = multimap -INCLUDE = -SWIGOPT = -VARIANT = - -# uncomment the following two lines to build a static exe -#CHICKEN_MAIN = runme.scm -#VARIANT = _static - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run - -build: $(TARGET) - -$(TARGET): $(INTERFACE) $(SRCS) - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \ - SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \ - INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT) - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean - rm -f example.scm - rm -f $(TARGET) diff --git a/Examples/chicken/multimap/example.c b/Examples/chicken/multimap/example.c deleted file mode 100644 index b8360fa8a..000000000 --- a/Examples/chicken/multimap/example.c +++ /dev/null @@ -1,53 +0,0 @@ -/* File : example.c */ -#include <stdio.h> -#include <stdlib.h> -#include <ctype.h> - -/* Compute the greatest common divisor of positive integers */ -int gcd(int x, int y) { - int g; - g = y; - while (x > 0) { - g = x; - x = y % x; - y = g; - } - return g; -} - -int gcdmain(int argc, char *argv[]) { - int x,y; - if (argc != 3) { - printf("usage: gcd x y\n"); - return -1; - } - x = atoi(argv[1]); - y = atoi(argv[2]); - printf("gcd(%d,%d) = %d\n", x,y,gcd(x,y)); - return 0; -} - -int count(char *bytes, int len, char c) { - int i; - int count = 0; - for (i = 0; i < len; i++) { - if (bytes[i] == c) count++; - } - return count; -} - -void capitalize(char *str, int len) { - int i; - for (i = 0; i < len; i++) { - str[i] = (char)toupper(str[i]); - } -} - -void circle(double x, double y) { - double a = x*x + y*y; - if (a > 1.0) { - printf("Bad points %g, %g\n", x,y); - } else { - printf("Good points %g, %g\n", x,y); - } -} diff --git a/Examples/chicken/multimap/example.i b/Examples/chicken/multimap/example.i deleted file mode 100644 index 02567f48f..000000000 --- a/Examples/chicken/multimap/example.i +++ /dev/null @@ -1,96 +0,0 @@ -/* File : example.i */ -%module example - -%{ -extern int gcd(int x, int y); -extern int gcdmain(int argc, char *argv[]); -extern int count(char *bytes, int len, char c); -extern void capitalize (char *str, int len); -extern void circle (double cx, double cy); -extern int squareCubed (int n, int *OUTPUT); -%} - -%include exception.i -%include typemaps.i - -extern int gcd(int x, int y); - -%typemap(in) (int argc, char *argv[]) { - int i; - if (!C_swig_is_vector ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument $input is not a vector"); - } - $1 = C_header_size ($input); - $2 = (char **) malloc(($1+1)*sizeof(char *)); - for (i = 0; i < $1; i++) { - C_word o = C_block_item ($input, i); - if (!C_swig_is_string (o)) { - char err[50]; - free($2); - sprintf (err, "$input[%d] is not a string", i); - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, err); - } - $2[i] = C_c_string (o); - } - $2[i] = 0; -} - -%typemap(freearg) (int argc, char *argv[]) { - free($2); -} -extern int gcdmain(int argc, char *argv[]); - -%typemap(in) (char *bytes, int len) { - if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument $input is not a string"); - } - $1 = C_c_string ($input); - $2 = C_header_size ($input); -} - -extern int count(char *bytes, int len, char c); - - -/* This example shows how to wrap a function that mutates a string */ - -%typemap(in) (char *str, int len) -%{ if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument $input is not a string"); - } - $2 = C_header_size ($input); - $1 = (char *) malloc ($2+1); - memmove ($1, C_c_string ($input), $2); -%} - -/* Return the mutated string as a new object. Notice the if MANY construct ... they must be at column 0. */ - -%typemap(argout) (char *str, int len) (C_word *scmstr) -%{ scmstr = C_alloc (C_SIZEOF_STRING ($2)); - SWIG_APPEND_VALUE(C_string (&scmstr, $2, $1)); - free ($1); -%} - -extern void capitalize (char *str, int len); - -/* A multi-valued constraint. Force two arguments to lie - inside the unit circle */ - -%typemap(check) (double cx, double cy) { - double a = $1*$1 + $2*$2; - if (a > 1.0) { - SWIG_exception (SWIG_ValueError, "cx and cy must be in unit circle"); - } -} - -extern void circle (double cx, double cy); - -/* Test out multiple return values */ - -extern int squareCubed (int n, int *OUTPUT); -%{ -/* Returns n^3 and set n2 to n^2 */ -int squareCubed (int n, int *n2) { - *n2 = n * n; - return (*n2) * n; -}; -%} diff --git a/Examples/chicken/multimap/runme.scm b/Examples/chicken/multimap/runme.scm deleted file mode 100644 index ebe644004..000000000 --- a/Examples/chicken/multimap/runme.scm +++ /dev/null @@ -1,58 +0,0 @@ -;; feel free to uncomment and comment sections - -(load-library 'example "multimap.so") - -(display "(gcd 90 12): ") -(display (gcd 90 12)) -(display "\n") - -(display "(circle 0.5 0.5): ") -(display (circle 0.5 0.5)) -(display "\n") - -(display "(circle 1.0 1.0): ") -(handle-exceptions exvar - (if (= (car exvar) 9) - (display "success: exception thrown") - (display "an incorrect exception was thrown")) - (begin - (circle 1.0 1.0) - (display "an exception was not thrown when it should have been"))) -(display "\n") - -(display "(circle 1 1): ") -(handle-exceptions exvar - (if (= (car exvar) 9) - (display "success: exception thrown") - (display "an incorrect exception was thrown")) - (begin - (circle 1 1) - (display "an exception was not thrown when it should have been"))) -(display "\n") - -(display "(capitalize \"will this be all capital letters?\"): ") -(display (capitalize "will this be all capital letters?")) -(display "\n") - -(display "(count \"jumpity little spider\" #\\t): ") -(display (count "jumpity little spider" #\t)) -(display "\n") - -(display "(gcdmain '#(\"hi\" \"there\")): ") -(display (gcdmain '#("hi" "there"))) -(display "\n") - -(display "(gcdmain '#(\"gcd\" \"9\" \"28\")): ") -(gcdmain '#("gcd" "9" "28")) -(display "\n") - -(display "(gcdmain '#(\"gcd\" \"12\" \"90\")): ") -(gcdmain '#("gcd" "12" "90")) -(display "\n") - -(display "squarecubed 3: ") -(call-with-values (lambda() (squareCubed 3)) - (lambda (a b) (printf "~A ~A" a b))) -(display "\n") - -(exit) diff --git a/Examples/chicken/overload/Makefile b/Examples/chicken/overload/Makefile deleted file mode 100644 index 019390192..000000000 --- a/Examples/chicken/overload/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -INTERFACE = example.i -SRCS = -CXXSRCS = example.cxx -TARGET = overload -INCLUDE = -SWIGOPT = -proxy -unhideprimitive -VARIANT = - -# uncomment the following lines to build a static exe -#CHICKEN_MAIN = runme.scm -#VARIANT = _static - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run - -build: $(TARGET) - -$(TARGET): $(INTERFACE) $(SRCS) - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \ - SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \ - INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT)_cpp - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean - rm -f example.scm - rm -f $(TARGET) diff --git a/Examples/chicken/overload/README b/Examples/chicken/overload/README deleted file mode 100644 index 9487c3f3e..000000000 --- a/Examples/chicken/overload/README +++ /dev/null @@ -1,2 +0,0 @@ -Overloading example from Chapter 5.14 of SWIG Core Documentation for -version 1.3. diff --git a/Examples/chicken/overload/example.cxx b/Examples/chicken/overload/example.cxx deleted file mode 100644 index 65e743941..000000000 --- a/Examples/chicken/overload/example.cxx +++ /dev/null @@ -1,33 +0,0 @@ -/* File : example.c */ - -#include "example.h" -#include <stdio.h> - -void foo(int x) { - printf("x is %d\n", x); -} - -void foo(char *x) { - printf("x is '%s'\n", x); -} - -Foo::Foo () { - myvar = 55; - printf ("Foo constructor called\n"); -} - -Foo::Foo (const Foo &) { - myvar = 66; - printf ("Foo copy constructor called\n"); -} - -void Foo::bar (int x) { - printf ("Foo::bar(x) method ... \n"); - printf("x is %d\n", x); -} - -void Foo::bar (char *s, int y) { - printf ("Foo::bar(s,y) method ... \n"); - printf ("s is '%s'\n", s); - printf ("y is %d\n", y); -} diff --git a/Examples/chicken/overload/example.h b/Examples/chicken/overload/example.h deleted file mode 100644 index 1c135d509..000000000 --- a/Examples/chicken/overload/example.h +++ /dev/null @@ -1,14 +0,0 @@ -/* File : example.h */ - -extern void foo (int x); -extern void foo (char *x); - -class Foo { - private: - int myvar; - public: - Foo(); - Foo(const Foo &); // Copy constructor - void bar(int x); - void bar(char *s, int y); -}; diff --git a/Examples/chicken/overload/example.i b/Examples/chicken/overload/example.i deleted file mode 100644 index 23a29986e..000000000 --- a/Examples/chicken/overload/example.i +++ /dev/null @@ -1,16 +0,0 @@ -/* File : example.i */ -%module example - -%{ -#include "example.h" -%} - -/* Let "Foo" objects be converted back and forth from TinyCLOS into - low-level CHICKEN SWIG procedures */ - -%typemap(clos_in) Foo * = SIMPLE_CLOS_OBJECT *; -%typemap(clos_out) Foo * = SIMPLE_CLOS_OBJECT *; - -/* Let's just grab the original header file here */ -%include "example.h" - diff --git a/Examples/chicken/overload/runme.scm b/Examples/chicken/overload/runme.scm deleted file mode 100644 index 168490f76..000000000 --- a/Examples/chicken/overload/runme.scm +++ /dev/null @@ -1,45 +0,0 @@ -;; This file demonstrates the overloading capabilities of SWIG - -(load-library 'example "overload.so") - -;; Low level -;; --------- - -(display " -Trying low level code ... - (foo 1) - (foo \"some string\") - (define A-FOO (new-Foo)) - (define ANOTHER-FOO (new-Foo A-FOO)) ;; copy constructor - (Foo-bar A-FOO 2) - (Foo-bar ANOTHER-FOO \"another string\" 3) -") - -(primitive:foo 1) -(primitive:foo "some string") -(define A-FOO (slot-ref (primitive:new-Foo) 'swig-this)) -(define ANOTHER-FOO (slot-ref (primitive:new-Foo A-FOO) 'swig-this)) ;; copy constructor -(primitive:Foo-bar A-FOO 2) -(primitive:Foo-bar ANOTHER-FOO "another string" 3) - -;; TinyCLOS -;; -------- - -(display " -Trying TinyCLOS code ... - (+foo+ 1) - (+foo+ \"some string\") - (define A-FOO (make <Foo>)) - (define ANOTHER-FOO (make <Foo> A-FOO)) ;; copy constructor - (-bar- A-FOO 2) - (-bar- ANOTHER-FOO \"another string\" 3) -") - -(foo 1) -(foo "some string") -(define A-FOO (make <Foo>)) -(define ANOTHER-FOO (make <Foo> A-FOO)) ;; copy constructor -(bar A-FOO 2) -(bar ANOTHER-FOO "another string" 3) - -(exit) diff --git a/Examples/chicken/simple/Makefile b/Examples/chicken/simple/Makefile deleted file mode 100644 index f5dd1a966..000000000 --- a/Examples/chicken/simple/Makefile +++ /dev/null @@ -1,31 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -INTERFACE = example.i -SRCS = example.c -CXXSRCS = -TARGET = simple -INCLUDE = -SWIGOPT = -VARIANT = - -# uncomment the following two lines to build a static exe -#CHICKEN_MAIN = runme.scm -#VARIANT = _static - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_run - -build: $(TARGET) - -$(TARGET): $(INTERFACE) $(SRCS) - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' \ - SRCS='$(SRCS)' CXXSRCS='$(CXXSRCS)' CHICKEN_MAIN='$(CHICKEN_MAIN)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - INCLUDE='$(INCLUDE)' SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' \ - INTERFACE='$(INTERFACE)' CHICKENOPTS='$(CHICKENOPTS)' chicken$(VARIANT) - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' chicken_clean - rm -f example.scm example-generic.scm example-clos.scm - rm -f $(TARGET) diff --git a/Examples/chicken/simple/README b/Examples/chicken/simple/README deleted file mode 100644 index 07e8da069..000000000 --- a/Examples/chicken/simple/README +++ /dev/null @@ -1 +0,0 @@ -Simple example from users manual. diff --git a/Examples/chicken/simple/example.c b/Examples/chicken/simple/example.c deleted file mode 100644 index f2b074781..000000000 --- a/Examples/chicken/simple/example.c +++ /dev/null @@ -1,24 +0,0 @@ -/* Simple example from documentation */ -/* File : example.c */ - -#include <time.h> - -double My_variable = 3.0; - -/* Compute factorial of n */ -int fact(int n) { - if (n <= 1) return 1; - else return n*fact(n-1); -} - -/* Compute n mod m */ -int my_mod(int n, int m) { - return (n % m); -} - - -char *get_time() { - long ltime; - time(<ime); - return ctime(<ime); -} diff --git a/Examples/chicken/simple/example.i b/Examples/chicken/simple/example.i deleted file mode 100644 index 5b3e95580..000000000 --- a/Examples/chicken/simple/example.i +++ /dev/null @@ -1,16 +0,0 @@ -/* File : example.i */ -%module example -%{ -/* Put headers and other declarations here */ -%} - -%include typemaps.i - -%rename(mod) my_mod; - -%inline %{ -extern double My_variable; -extern int fact(int); -extern int my_mod(int n, int m); -extern char *get_time(); -%} diff --git a/Examples/chicken/simple/runme.scm b/Examples/chicken/simple/runme.scm deleted file mode 100644 index 05aa87081..000000000 --- a/Examples/chicken/simple/runme.scm +++ /dev/null @@ -1,28 +0,0 @@ -;; feel free to uncomment and comment sections -(load-library 'example "simple.so") - -(display "(My-variable): ") -(display (My-variable)) -(display "\n") - -(display "(My-variable 3.141259): ") -(display (My-variable 3.141259)) -(display "\n") - -(display "(My-variable): ") -(display (My-variable)) -(display "\n") - -(display "(fact 5): ") -(display (fact 5)) -(display "\n") - -(display "(mod 75 7): ") -(display (mod 75 7)) -(display "\n") - -(display "(get-time): ") -(display (get-time)) -(display "\n") - -(exit) diff --git a/Examples/guile/matrix/example.i b/Examples/guile/matrix/example.i index 3f801dcdf..6f8fa8859 100644 --- a/Examples/guile/matrix/example.i +++ b/Examples/guile/matrix/example.i @@ -14,4 +14,8 @@ %include math.i -extern double drand48(); +%{ +/* Add drand48 declaration as it is posix only and is not in stdlib.h when using strict c99 and later */ +extern double drand48(void); +%} +extern double drand48(void); diff --git a/Examples/javascript/exception/example.h b/Examples/javascript/exception/example.h index bc744cda7..c76c46a5d 100644 --- a/Examples/javascript/exception/example.h +++ b/Examples/javascript/exception/example.h @@ -10,7 +10,7 @@ class Exc { public: Exc(int c, const char *m) { code = c; - strncpy(msg,m,256); + strncpy(msg,m,255); } int code; char msg[256]; diff --git a/Examples/lua/exception/example.h b/Examples/lua/exception/example.h index bc744cda7..c76c46a5d 100644 --- a/Examples/lua/exception/example.h +++ b/Examples/lua/exception/example.h @@ -10,7 +10,7 @@ class Exc { public: Exc(int c, const char *m) { code = c; - strncpy(msg,m,256); + strncpy(msg,m,255); } int code; char msg[256]; diff --git a/Examples/modula3/check.list b/Examples/modula3/check.list deleted file mode 100644 index 37ac8c105..000000000 --- a/Examples/modula3/check.list +++ /dev/null @@ -1,7 +0,0 @@ -# see top-level Makefile.in -class -enum -exception -reference -simple -typemap diff --git a/Examples/modula3/class/Makefile b/Examples/modula3/class/Makefile deleted file mode 100644 index b25f636c3..000000000 --- a/Examples/modula3/class/Makefile +++ /dev/null @@ -1,26 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = -TARGET = example -PLATFORM = LINUXLIBC6 -INTERFACE = example.i -SWIGOPT = -c++ -MODULA3SRCS = *.[im]3 - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3 - m3ppinplace $(MODULA3SRCS) -# compilation of example_wrap.cxx is started by cm3 -# $(CXX) -c $(TARGET)_wrap.cxx - mv example_wrap.cxx m3makefile $(MODULA3SRCS) src/ - ln -sf ../example.h src/example.h - cm3 - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean diff --git a/Examples/modula3/class/example.cxx b/Examples/modula3/class/example.cxx deleted file mode 100644 index 046304519..000000000 --- a/Examples/modula3/class/example.cxx +++ /dev/null @@ -1,28 +0,0 @@ -/* File : example.cxx */ - -#include "example.h" -#define M_PI 3.14159265358979323846 - -/* Move the shape to a new location */ -void Shape::move(double dx, double dy) { - x += dx; - y += dy; -} - -int Shape::nshapes = 0; - -double Circle::area() { - return M_PI*radius*radius; -} - -double Circle::perimeter() { - return 2*M_PI*radius; -} - -double Square::area() { - return width*width; -} - -double Square::perimeter() { - return 4*width; -} diff --git a/Examples/modula3/class/example.h b/Examples/modula3/class/example.h deleted file mode 100644 index 0dff185b2..000000000 --- a/Examples/modula3/class/example.h +++ /dev/null @@ -1,34 +0,0 @@ -/* File : example.h */ - -class Shape { -public: - Shape() { - nshapes++; - } - virtual ~Shape() { - nshapes--; - } - double x, y; - void move(double dx, double dy); - virtual double area() = 0; - virtual double perimeter() = 0; - static int nshapes; -}; - -class Circle : public Shape { -private: - double radius; -public: - Circle(double r) : radius(r) { } - virtual double area(); - virtual double perimeter(); -}; - -class Square : public Shape { -private: - double width; -public: - Square(double w) : width(w) { } - virtual double area(); - virtual double perimeter(); -}; diff --git a/Examples/modula3/class/example.i b/Examples/modula3/class/example.i deleted file mode 100644 index 2fafadbd6..000000000 --- a/Examples/modula3/class/example.i +++ /dev/null @@ -1,32 +0,0 @@ -/* File : example.i */ -%module Example - -%{ -#include "example.h" -%} - -%insert(m3makefile) %{template("../swig") -cxx_source("example_wrap")%} - -%typemap(m3rawinmode) Shape *, Circle *, Square * "" -%typemap(m3rawrettype) Shape *, Circle *, Square * "$1_basetype" - -%typemap(m3wrapinmode) Shape *, Circle *, Square * "" -%typemap(m3wrapargraw) Shape *, Circle *, Square * "self.cxxObj" - -%typemap(m3wrapretvar) Circle *, Square * "cxxObj : ExampleRaw.$1_basetype;" -%typemap(m3wrapretraw) Circle *, Square * "cxxObj" -%typemap(m3wrapretconv) Circle *, Square * "NEW($1_basetype,cxxObj:=cxxObj)" -%typemap(m3wraprettype) Circle *, Square * "$1_basetype" - -/* Should work with and without renaming -%rename(M3Shape) Shape; -%rename(M3Circle) Circle; -%rename(M3Square) Square; -%typemap(m3wrapintype) Shape *, Circle *, Square * "M3$1_basetype" -%typemap(m3wraprettype) Shape *, Circle *, Square * "M3$1_basetype" -%typemap(m3wrapretconv) Circle *, Square * "NEW(M3$1_basetype,cxxObj:=cxxObj)" -*/ - -/* Let's just grab the original header file here */ -%include "example.h" diff --git a/Examples/modula3/class/swig.tmpl b/Examples/modula3/class/swig.tmpl deleted file mode 100644 index e3e9bf178..000000000 --- a/Examples/modula3/class/swig.tmpl +++ /dev/null @@ -1,11 +0,0 @@ - -readonly proc cxx_source (X) is - local cxxfile = X&".cxx" - local objfile = X&".o" - %exec("echo $PWD") - if stale(objfile,cxxfile) - exec("cd",path(),"; g++ -I.. -c -o",objfile,cxxfile) - end - import_obj(X) - %unlink_file(path()&SL&objfile) -end diff --git a/Examples/modula3/enum/Makefile b/Examples/modula3/enum/Makefile deleted file mode 100644 index 2c5c9b0a5..000000000 --- a/Examples/modula3/enum/Makefile +++ /dev/null @@ -1,27 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = -TARGET = example -INTERFACE = example.i -CONSTNUMERIC = example_const -SWIGOPT = -c++ -MODULA3SRCS = *.[im]3 - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run - -build: - $(SWIGEXE) -modula3 $(SWIGOPT) -module Example -generateconst $(CONSTNUMERIC) $(TARGET).h - $(CXX) -Wall $(CONSTNUMERIC).c -o $(CONSTNUMERIC) - $(CONSTNUMERIC) >$(CONSTNUMERIC).i - - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3 - m3ppinplace $(MODULA3SRCS) - mv m3makefile $(MODULA3SRCS) src/ - cm3 - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean diff --git a/Examples/modula3/enum/example.cxx b/Examples/modula3/enum/example.cxx deleted file mode 100644 index bd808ff7c..000000000 --- a/Examples/modula3/enum/example.cxx +++ /dev/null @@ -1,32 +0,0 @@ -/* File : example.cxx */ - -#include "example.h" -#include <stdio.h> - -void Foo::enum_test(speed s) { - if (s == IMPULSE) { - printf("IMPULSE speed\n"); - } else if (s == WARP) { - printf("WARP speed\n"); - } else if (s == LUDICROUS) { - printf("LUDICROUS speed\n"); - } else if (s == HYPER) { - printf("HYPER speed\n"); - } else { - printf("Unknown speed\n"); - } -} - -void enum_test(color c, Foo::speed s) { - if (c == RED) { - printf("color = RED, "); - } else if (c == BLUE) { - printf("color = BLUE, "); - } else if (c == GREEN) { - printf("color = GREEN, "); - } else { - printf("color = Unknown color!, "); - } - Foo obj; - obj.enum_test(s); -} diff --git a/Examples/modula3/enum/example.h b/Examples/modula3/enum/example.h deleted file mode 100644 index 2f44a6ccf..000000000 --- a/Examples/modula3/enum/example.h +++ /dev/null @@ -1,83 +0,0 @@ -/* File : example.h */ - -#define PI 3.141 - -#define DAY_MONDAY 0 -#define DAY_TUESDAY 1 -#define DAY_WEDNESDAY 2 -#define DAY_THURSDAY 3 -#define DAY_FRIDAY 4 -#define DAY_SATURDAY 5 -#define DAY_SUNDAY 6 - -enum color { BLUE, RED, GREEN }; - -#define CLB_BLACK 0 -#define CLB_BLUE 1 -#define CLB_RED 2 -#define CLB_MAGENTA 3 -#define CLB_GREEN 4 -#define CLB_CYAN 5 -#define CLB_YELLOW 6 -#define CLB_WHITE 7 - -/* Using this would be good style - which cannot be expected for general C header files. - Instead I want to demonstrate how to live without it. -enum month { - MTHF_JANUARY, - MTHF_FEBRUARY, - MTHF_MARCH, - MTHF_APRIL, - MTHF_MAY, - MTHF_JUNE, - MTHF_JULY, - MTHF_AUGUST, - MTHF_SEPTEMBER, - MTHF_OCTOBER, - MTHF_NOVEMBER, - MTHF_DECEMBER, -} -*/ - -/* Since there are no compile time constants in C / C++ - it is a common abuse - to declare bit set (flag) constants - as enumerations. */ -enum calendar { - MTHB_JANUARY = 1 << 0, /* 1 << MTHF_JANUARY, */ - MTHB_FEBRUARY = 1 << 1, /* 1 << MTHF_FEBRUARY, */ - MTHB_MARCH = 1 << 2, /* 1 << MTHF_MARCH, */ - MTHB_APRIL = 1 << 3, /* 1 << MTHF_APRIL, */ - MTHB_MAY = 1 << 4, /* 1 << MTHF_MAY, */ - MTHB_JUNE = 1 << 5, /* 1 << MTHF_JUNE, */ - MTHB_JULY = 1 << 6, /* 1 << MTHF_JULY, */ - MTHB_AUGUST = 1 << 7, /* 1 << MTHF_AUGUST, */ - MTHB_SEPTEMBER = 1 << 8, /* 1 << MTHF_SEPTEMBER, */ - MTHB_OCTOBER = 1 << 9, /* 1 << MTHF_OCTOBER, */ - MTHB_NOVEMBER = 1 << 10, /* 1 << MTHF_NOVEMBER, */ - MTHB_DECEMBER = 1 << 11, /* 1 << MTHF_DECEMBER, */ - - MTHB_SPRING = MTHB_MARCH | MTHB_APRIL | MTHB_MAY, - MTHB_SUMMER = MTHB_JUNE | MTHB_JULY | MTHB_AUGUST, - MTHB_AUTUMN = MTHB_SEPTEMBER | MTHB_OCTOBER | MTHB_NOVEMBER, - MTHB_WINTER = MTHB_DECEMBER | MTHB_JANUARY | MTHB_FEBRUARY, -}; - - -namespace Answer { - enum { - UNIVERSE_AND_EVERYTHING = 42, - SEVENTEEN_AND_FOUR = 21, - TWOHUNDRED_PERCENT_OF_NOTHING = 0, - }; - - class Foo { - public: - Foo() { } - enum speed { IMPULSE = -2, WARP = 0, HYPER, LUDICROUS = 3}; - void enum_test(speed s); - }; -}; - -void enum_test(color c, Answer::Foo::speed s); diff --git a/Examples/modula3/enum/example.i b/Examples/modula3/enum/example.i deleted file mode 100644 index f5947b3bc..000000000 --- a/Examples/modula3/enum/example.i +++ /dev/null @@ -1,72 +0,0 @@ -/* File : example.i */ -%module Example - -%{ -#include "example.h" -%} - -%include "example_const.i" - -// such features are generated by the following pragmas -#if 0 -%feature("modula3:enumitem:enum","Days") DAY_MONDAY; -%feature("modula3:enumitem:name","monday") DAY_MONDAY; -%feature("modula3:enumitem:conv","int:int") DAY_MONDAY; - -%feature("modula3:enumitem:enum","Month") MTHB_JANUARY; -%feature("modula3:enumitem:name","january") MTHB_JANUARY; -%feature("modula3:enumitem:conv","set:int") MTHB_JANUARY; -//%feature("modula3:constset:type","MonthSet") MTHB_JANUARY; /*type in the constant definition*/ -%feature("modula3:constset:set", "MonthSet") MTHB_JANUARY; /*remarks that the 'type' is a set type*/ -%feature("modula3:constset:base","Month") MTHB_JANUARY; -%feature("modula3:constset:name","monthsJanuary") MTHB_JANUARY; -%feature("modula3:constset:conv","set:set") MTHB_JANUARY; /*conversion of the bit pattern: no change*/ - -%feature("modula3:enumitem:enum","Color") BLUE; -%feature("modula3:enumitem:name","blue") BLUE; -%feature("modula3:enumitem:conv","int:int") BLUE; - -%feature("modula3:constint:type","INTEGER") Foo::IMPULSE; -%feature("modula3:constint:name","impulse") Foo::IMPULSE; -%feature("modula3:constint:conv","int:int") Foo::IMPULSE; -#endif - -%rename(pi) PI; - -%pragma(modula3) enumitem="prefix=DAY_;int;srcstyle=underscore;Day"; - -%pragma(modula3) enumitem="enum=color;int;srcstyle=underscore;Color"; -%pragma(modula3) makesetofenum="Color"; -%pragma(modula3) constset="prefix=CLB_;set;srcstyle=underscore,prefix=clb;ColorSet,Color"; - -%pragma(modula3) enumitem="prefix=MTHB_,enum=calendar;set;srcstyle=underscore;Month"; -%pragma(modula3) makesetofenum="Month"; -%pragma(modula3) constset="prefix=MTHB_,enum=calendar;set;srcstyle=underscore,prefix=monthset;MonthSet,Month"; - -%pragma(modula3) constint="prefix=Answer::Foo::,enum=Answer::Foo::speed;int;srcstyle=underscore,prefix=speed;INTEGER"; - -%pragma(modula3) constint="prefix=Answer::,enum=Answer::;int;srcstyle=underscore,prefix=answer;CARDINAL"; - -%rename(AnswerFoo) Answer::Foo; -%typemap("m3rawrettype") Answer::Foo * %{AnswerFoo%} -%typemap("m3rawintype") Answer::Foo * %{AnswerFoo%} -%typemap("m3rawinmode") Answer::Foo * %{%} -%typemap("m3wraprettype") Answer::Foo * %{AnswerFoo%} -%typemap("m3wrapintype") Answer::Foo * %{AnswerFoo%} -%typemap("m3wrapinmode") Answer::Foo * %{%} -%typemap("m3wrapargraw") Answer::Foo * %{self.cxxObj%} - -%typemap("m3wrapretvar") Answer::Foo * %{cxxObj : ExampleRaw.AnswerFoo;%} -%typemap("m3wrapretraw") Answer::Foo * %{cxxObj%} -%typemap("m3wrapretconv") Answer::Foo * %{NEW(AnswerFoo,cxxObj:=cxxObj)%} - - -%typemap("m3rawintype") Answer::Foo::speed %{C.int%}; -%typemap("m3rawintype:import") Answer::Foo::speed %{Ctypes AS C%}; -%typemap("m3wrapintype") Answer::Foo::speed %{[-2..3]%}; - -%typemap("m3wrapintype") color %{Color%}; -%typemap("m3wrapargraw") color %{ORD($1_name)%}; - -/* Let's just grab the original header file here */ -%include "example.h" diff --git a/Examples/modula3/exception/Makefile b/Examples/modula3/exception/Makefile deleted file mode 100644 index 8d12ef19e..000000000 --- a/Examples/modula3/exception/Makefile +++ /dev/null @@ -1,24 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -CXXSRCS = example.cxx -TARGET = example -INTERFACE = example.i -SWIGOPT = -MODULA3SRCS = *.[im]3 -MODULA3FLAGS= -o runme - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3_cpp -# $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' MODULA3SRCS='$(MODULA3SRCS)' MODULA3FLAGS='$(MODULA3FLAGS)' modula3_compile - m3ppinplace $(MODULA3SRCS) - mv m3makefile $(MODULA3SRCS) src/ - cm3 - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean diff --git a/Examples/modula3/exception/example.h b/Examples/modula3/exception/example.h deleted file mode 100644 index 0e9e0e81d..000000000 --- a/Examples/modula3/exception/example.h +++ /dev/null @@ -1,18 +0,0 @@ -/* File : example.h */ - -enum error {OK, OVERFLOW, DIVISION_BY_ZERO, NEGATIVE_RADICAND, NEGATIVE_BASE}; -typedef error errorstate; /* just to separate the typemaps */ - -error acc_add (double &x, double y); -error acc_sub (double &x, double y); -error acc_mul (double &x, double y); -error acc_div (double &x, double y); - -double op_add (double x, double y, errorstate &err); -double op_sub (double x, double y, errorstate &err); -double op_mul (double x, double y, errorstate &err); -double op_div (double x, double y, errorstate &err); -double op_sqrt (double x, errorstate &err); -double op_pow (double x, double y, errorstate &err); - -double op_noexc (double x, double y); diff --git a/Examples/modula3/exception/example.i b/Examples/modula3/exception/example.i deleted file mode 100644 index 92a716fae..000000000 --- a/Examples/modula3/exception/example.i +++ /dev/null @@ -1,43 +0,0 @@ -/* File : example.i */ -%module Example - -%{ -#include "example.h" -%} - -%insert(m3wrapintf) %{ -EXCEPTION E(Error); -%} -%insert(m3wrapimpl) %{ -IMPORT Ctypes AS C; -%} - -%pragma(modula3) enumitem="enum=error;int;srcstyle=underscore;Error"; - -%typemap("m3rawintype") double & %{C.double%}; -%typemap("m3wrapintype") double & %{LONGREAL%}; - -%typemap("m3wraprettype") error "" -%typemap("m3wrapretvar") error "rawerr: C.int;" -%typemap("m3wrapretraw") error "rawerr" -%typemap("m3wrapretcheck:throws") error "E" -%typemap("m3wrapretcheck") error -%{VAR err := VAL(rawerr, Error); -BEGIN -IF err # Error.ok THEN -RAISE E(err); -END; -END;%} - -%typemap("m3rawintype") errorstate & %{C.int%}; -%typemap("m3wrapintype",numinputs=0) errorstate & %{%}; -%typemap("m3wrapargvar") errorstate & %{err:C.int:=ORD(Error.ok);%}; -%typemap("m3wrapoutcheck:throws") errorstate & "E"; -%typemap("m3wrapoutcheck") errorstate & -%{IF VAL(err,Error) # Error.ok THEN -RAISE E(VAL(err,Error)); -END;%} - -/* Let's just grab the original header file here */ - -%include "example.h" diff --git a/Examples/modula3/reference/Makefile b/Examples/modula3/reference/Makefile deleted file mode 100644 index eaceceb1f..000000000 --- a/Examples/modula3/reference/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = -TARGET = example -INTERFACE = example.i -SWIGOPT = -c++ -MODULA3SRCS = *.[im]3 - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3 - m3ppinplace $(MODULA3SRCS) - mv m3makefile $(MODULA3SRCS) src/ - cm3 - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean diff --git a/Examples/modula3/reference/example.cxx b/Examples/modula3/reference/example.cxx deleted file mode 100644 index 9dbaed2ee..000000000 --- a/Examples/modula3/reference/example.cxx +++ /dev/null @@ -1,46 +0,0 @@ -/* File : example.cxx */ - -/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) -# define _CRT_SECURE_NO_DEPRECATE -#endif - -#include "example.h" -#include <stdio.h> -#include <stdlib.h> - -Vector operator+(const Vector &a, const Vector &b) { - Vector r; - r.x = a.x + b.x; - r.y = a.y + b.y; - r.z = a.z + b.z; - return r; -} - -char *Vector::print() { - static char temp[512]; - sprintf(temp,"Vector %p (%g,%g,%g)", (void *)this, x,y,z); - return temp; -} - -VectorArray::VectorArray(int size) { - items = new Vector[size]; - maxsize = size; -} - -VectorArray::~VectorArray() { - delete [] items; -} - -Vector &VectorArray::operator[](int index) { - if ((index < 0) || (index >= maxsize)) { - printf("Panic! Array index out of bounds.\n"); - exit(1); - } - return items[index]; -} - -int VectorArray::size() { - return maxsize; -} - diff --git a/Examples/modula3/reference/example.h b/Examples/modula3/reference/example.h deleted file mode 100644 index 7b4ba8fb8..000000000 --- a/Examples/modula3/reference/example.h +++ /dev/null @@ -1,22 +0,0 @@ -/* File : example.h */ - -struct Vector { -private: - double x,y,z; -public: - Vector() : x(0), y(0), z(0) { } - Vector(double x, double y, double z) : x(x), y(y), z(z) { } - Vector operator+(const Vector &b) const; - char *print(); -}; - -struct VectorArray { -private: - Vector *items; - int maxsize; -public: - VectorArray(int maxsize); - ~VectorArray(); - Vector &operator[](int); - int size(); -}; diff --git a/Examples/modula3/reference/example.i b/Examples/modula3/reference/example.i deleted file mode 100644 index 002090918..000000000 --- a/Examples/modula3/reference/example.i +++ /dev/null @@ -1,32 +0,0 @@ -/* File : example.i */ - -/* This file has a few "typical" uses of C++ references. */ - -%module Example - -%{ -#include "example.h" -%} - -%pragma(modula3) unsafe="1"; - -%insert(m3wrapintf) %{FROM ExampleRaw IMPORT Vector, VectorArray;%} -%insert(m3wrapimpl) %{FROM ExampleRaw IMPORT Vector, VectorArray;%} - -%typemap(m3wrapretvar) Vector %{vec: UNTRACED REF Vector;%} -%typemap(m3wrapretraw) Vector %{vec%} -%typemap(m3wrapretconv) Vector %{vec^%} - - -/* This helper function calls an overloaded operator */ -%inline %{ -Vector addv(const Vector &a, const Vector &b) { - return a+b; -} -%} - -%rename(Vector_Clear) Vector::Vector(); -%rename(Add) Vector::operator+; -%rename(GetItem) VectorArray::operator[]; - -%include "example.h" diff --git a/Examples/modula3/simple/Makefile b/Examples/modula3/simple/Makefile deleted file mode 100644 index 3ba35d18b..000000000 --- a/Examples/modula3/simple/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = -TARGET = example -INTERFACE = example.i -SWIGOPT = -MODULA3SRCS = *.[im]3 - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3 - m3ppinplace $(MODULA3SRCS) - mv m3makefile $(MODULA3SRCS) src/ - cm3 - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean diff --git a/Examples/modula3/simple/example.c b/Examples/modula3/simple/example.c deleted file mode 100644 index 1c2af789c..000000000 --- a/Examples/modula3/simple/example.c +++ /dev/null @@ -1,18 +0,0 @@ -/* File : example.c */ - -/* A global variable */ -double Foo = 3.0; - -/* Compute the greatest common divisor of positive integers */ -int gcd(int x, int y) { - int g; - g = y; - while (x > 0) { - g = x; - x = y % x; - y = g; - } - return g; -} - - diff --git a/Examples/modula3/simple/example.i b/Examples/modula3/simple/example.i deleted file mode 100644 index 1694e6dbe..000000000 --- a/Examples/modula3/simple/example.i +++ /dev/null @@ -1,7 +0,0 @@ -/* File : example.i */ -%module Example - -%inline %{ -extern int gcd(int x, int y); -extern double Foo; -%} diff --git a/Examples/modula3/typemap/Makefile b/Examples/modula3/typemap/Makefile deleted file mode 100644 index 3ba35d18b..000000000 --- a/Examples/modula3/typemap/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = -TARGET = example -INTERFACE = example.i -SWIGOPT = -MODULA3SRCS = *.[im]3 - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' modula3 - m3ppinplace $(MODULA3SRCS) - mv m3makefile $(MODULA3SRCS) src/ - cm3 - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' modula3_clean diff --git a/Examples/modula3/typemap/example.i b/Examples/modula3/typemap/example.i deleted file mode 100644 index 2f454eff3..000000000 --- a/Examples/modula3/typemap/example.i +++ /dev/null @@ -1,90 +0,0 @@ -/* File : example.i */ -%module Example - -%pragma(modula3) unsafe="true"; - -%insert(m3wrapintf) %{FROM ExampleRaw IMPORT Window, Point; -%} -%insert(m3wrapimpl) %{FROM ExampleRaw IMPORT Window, Point; -IMPORT M3toC; -IMPORT Ctypes AS C; -%} - -/* Typemap applied to patterns of multiple arguments */ - -%typemap(m3rawinmode) (char *outstr) %{VAR%} -%typemap(m3rawintype) (char *outstr) %{CHAR%} -%typemap(m3wrapinmode) (char *outstr, int size) %{VAR%} -%typemap(m3wrapintype) (char *outstr, int size) %{ARRAY OF CHAR%} -%typemap(m3wrapargraw) (char *outstr, int size) %{$1_name[0], NUMBER($1_name)%} - - -%typemap(m3rawinmode) (const struct Window *) %{READONLY%} -%typemap(m3wrapinmode) (const struct Window *) %{READONLY%} -%typemap(m3rawintype) ( struct Window *) %{Window%} -%typemap(m3wrapintype) ( struct Window *) %{Window%} - -%typemap(m3rawinmode) (const char *str []) %{READONLY%} -%typemap(m3wrapinmode) (const char *str []) %{READONLY%} -%typemap(m3rawintype) (const char *str []) %{(*ARRAY OF*) C.char_star%} -%typemap(m3wrapintype) (const char *str []) %{ARRAY OF TEXT%} -%typemap(m3wrapargvar) (const char *str []) %{$1: REF ARRAY OF C.char_star;%} -%typemap(m3wrapargraw) (const char *str []) %{$1[0]%} -%typemap(m3wrapinconv) (const char *str []) %{$1:= NEW(REF ARRAY OF C.char_star,NUMBER($1_name)); -FOR i:=FIRST($1_name) TO LAST($1_name) DO -$1[i]:=M3toC.SharedTtoS($1_name[i]); -END;%} -%typemap(m3wrapfreearg) (const char *str []) -%{FOR i:=FIRST($1_name) TO LAST($1_name) DO -M3toC.FreeSharedS($1_name[i],$1[i]); -END;%} - -%typemap(m3wraprettype) char * %{TEXT%} -%typemap(m3wrapretvar) char * %{result_string: C.char_star;%} -%typemap(m3wrapretraw) char * %{result_string%} -%typemap(m3wrapretconv) char * %{M3toC.CopyStoT(result_string)%} - -struct Window { - char *label; - int left,top,width,height; -}; - - -%typemap(m3wrapinname) (int x, int y) %{p%} -%typemap(m3wrapinmode) (int x, int y) %{READONLY%} -%typemap(m3wrapintype) (int x, int y) %{Point%} -%typemap(m3wrapargraw) (int x, int y) %{p.$1_name, p.$2_name%} - -%typemap(m3wrapargraw) (int &x, int &y) %{p.$1_name, p.$2_name%} -%typemap(m3wrapintype) (int &x, int &y) %{Point%} -%typemap(m3wrapoutname) (int &x, int &y) %{p%} -%typemap(m3wrapouttype) (int &x, int &y) %{Point%} -%typemap(m3wrapargdir) (int &x, int &y) "out" - - -%typemap(m3wrapargvar) int &left, int &top, int &width, int &height "$1:C.int;" -%typemap(m3wrapargraw) int &left, int &top, int &width, int &height "$1" -%typemap(m3wrapoutconv) int &left, int &top, int &width, int &height "$1" - -%typemap(m3wrapargdir) int &left, int &top "out" - -%typemap(m3wrapouttype) int &width, int &height "CARDINAL" -%typemap(m3wrapargdir) int &width, int &height "out" - -struct Point { - int x,y; -}; - -%m3multiretval get_box; - -void set_label ( struct Window *win, const char *str, bool activate); -void set_multi_label ( struct Window *win, const char *str []); -void write_label (const struct Window *win, char *outstr, int size); -int get_label (const struct Window *win, char *outstr, int size); -char *get_label_ptr (const struct Window *win); -void move(struct Window *win, int x, int y); -int get_area(const struct Window *win); -void get_box(const struct Window *win, int &left, int &top, int &width, int &height); -void get_left(const struct Window *win, int &left); -void get_mouse(const struct Window *win, int &x, int &y); -int get_attached_data(const struct Window *win, const char *id); diff --git a/Examples/ocaml/shapes/example.i b/Examples/ocaml/shapes/example.i index ac0fa4a56..a261b92e7 100644 --- a/Examples/ocaml/shapes/example.i +++ b/Examples/ocaml/shapes/example.i @@ -1,10 +1,8 @@ /* File : example.i */ %module(directors="1") example -#ifndef SWIGSEXP %{ #include "example.h" %} -#endif %feature("director"); %include "example.h" diff --git a/Examples/php/callback/runme.php b/Examples/php/callback/runme.php index 2be71994f..e7093209c 100644 --- a/Examples/php/callback/runme.php +++ b/Examples/php/callback/runme.php @@ -2,8 +2,6 @@ # This file illustrates the cross language polymorphism using directors. -require("example.php"); - # Class, which overwrites Callback::run(). class PhpCallback extends Callback { @@ -43,5 +41,3 @@ $caller->delCallback(); # All done. print "php exit\n"; - -?> diff --git a/Examples/php/class/runme.php b/Examples/php/class/runme.php index 99c253b46..0f667695b 100644 --- a/Examples/php/class/runme.php +++ b/Examples/php/class/runme.php @@ -2,8 +2,6 @@ # This example illustrates how member variables are wrapped. -require("example.php"); - # ----- Object creation ----- print "Creating some objects:\n"; @@ -56,5 +54,3 @@ $o = NULL; print Shape::nshapes() . " shapes remain\n"; print "Goodbye\n"; - -?> diff --git a/Examples/php/constants/runme.php b/Examples/php/constants/runme.php index 91c597a40..e561626d8 100644 --- a/Examples/php/constants/runme.php +++ b/Examples/php/constants/runme.php @@ -1,7 +1,5 @@ <?php -require "example.php"; - print "ICONST = " . ICONST . " (should be 42)\n"; print "FCONST = " . FCONST . " (should be 2.1828)\n"; print "CCONST = " . CCONST . " (should be 'x')\n"; @@ -19,6 +17,3 @@ if (array_key_exists("EXTERN", $c)) { if (array_key_exists("FOO", $c)) { print "FOO = " . $c["FOO"] . " (Arg! This shouldn't print anything)\n"; } - - -?> diff --git a/Examples/php/cpointer/runme.php b/Examples/php/cpointer/runme.php index 22e8a681a..f552ed78a 100644 --- a/Examples/php/cpointer/runme.php +++ b/Examples/php/cpointer/runme.php @@ -1,7 +1,5 @@ <?php - require "example.php"; - # First create some objects using the pointer library. print "Testing the pointer library\n"; @@ -43,5 +41,3 @@ # $q = $a[0] # $r = $a[1] # print " 42/37 = $q remainder $r\n"; - -?> diff --git a/Examples/php/disown/runme.php b/Examples/php/disown/runme.php index a70d7b061..e847dc71d 100644 --- a/Examples/php/disown/runme.php +++ b/Examples/php/disown/runme.php @@ -4,8 +4,6 @@ # created by SWIG. In this case, all of our C++ classes # get converted into function calls. -require("example.php"); - # ----- Object creation ----- print "Creating some objects:\n"; @@ -45,5 +43,3 @@ $container = NULL; print "\nA total of " . Shape::nshapes() . " shapes remain\n"; print "Goodbye\n"; - -?> diff --git a/Examples/php/enum/runme.php b/Examples/php/enum/runme.php index 813476645..bf5ba881f 100644 --- a/Examples/php/enum/runme.php +++ b/Examples/php/enum/runme.php @@ -1,7 +1,5 @@ <?php -require "example.php"; - # ----- Object creation ----- # Print out the value of some enums @@ -28,5 +26,3 @@ $f = new Foo(); $f->enum_test(Foo::IMPULSE); $f->enum_test(Foo::WARP); $f->enum_test(Foo::LUDICROUS); - -?> diff --git a/Examples/php/extend/runme.php b/Examples/php/extend/runme.php index 158683142..93eedee99 100644 --- a/Examples/php/extend/runme.php +++ b/Examples/php/extend/runme.php @@ -2,8 +2,6 @@ # This file illustrates the cross language polymorphism using directors. -require("example.php"); - # CEO class, which overrides Employee::getPosition(). class CEO extends Manager { @@ -72,5 +70,3 @@ print "----------------------\n"; # All done. print "php exit\n"; - -?> diff --git a/Examples/php/funcptr/runme.php b/Examples/php/funcptr/runme.php index 712d4147c..d76a19bc7 100644 --- a/Examples/php/funcptr/runme.php +++ b/Examples/php/funcptr/runme.php @@ -1,7 +1,5 @@ <?php -require "example.php"; - $a = 37; $b = 42; @@ -10,15 +8,11 @@ $b = 42; print "Trying some C callback functions\n"; print " a = $a\n"; print " b = $b\n"; -print " ADD(a,b) = ". do_op($a,$b,ADD)."\n"; -print " SUB(a,b) = ". do_op($a,$b,SUB)."\n"; -print " MUL(a,b) = ". do_op($a,$b,MUL)."\n"; +print " ADD(a,b) = ". do_op($a,$b,example::ADD)."\n"; +print " SUB(a,b) = ". do_op($a,$b,example::SUB)."\n"; +print " MUL(a,b) = ". do_op($a,$b,example::MUL)."\n"; print "Here is what the C callback function objects look like in php\n"; -print "Using swig style string pointers as we need them registered as constants\n"; -print " ADD = " . ADD . "\n"; -print " SUB = " . SUB . "\n"; -print " MUL = " . MUL . "\n"; - -?> - +print " ADD = " . example::ADD . "\n"; +print " SUB = " . example::SUB . "\n"; +print " MUL = " . example::MUL . "\n"; diff --git a/Examples/php/overloading/runme.php b/Examples/php/overloading/runme.php index 56d515138..d4df899f0 100644 --- a/Examples/php/overloading/runme.php +++ b/Examples/php/overloading/runme.php @@ -4,8 +4,6 @@ # created by SWIG. In this case, all of our C++ classes # get converted into function calls. -include("example.php"); - # ----- Object creation ----- print "Creating some objects:\n"; @@ -54,5 +52,3 @@ $s = 42; print Shape::nshapes() . " shapes remain\n"; print "Goodbye\n"; - -?> diff --git a/Examples/php/pointer/example.i b/Examples/php/pointer/example.i index 1f0059406..31d2a03e0 100644 --- a/Examples/php/pointer/example.i +++ b/Examples/php/pointer/example.i @@ -21,10 +21,5 @@ extern void sub(int *INPUT, int *INPUT, int *OUTPUT); /* Next we'll use typemaps and the %apply directive */ -//%apply int *OUTPUT { int *r }; -//extern int divide(int n, int d, int *r); - - - - - +%apply int *OUTPUT { int *r }; +extern int divide(int n, int d, int *r); diff --git a/Examples/php/pointer/runme.php b/Examples/php/pointer/runme.php index e79b23810..8dc3ab887 100644 --- a/Examples/php/pointer/runme.php +++ b/Examples/php/pointer/runme.php @@ -1,7 +1,5 @@ <?php - require "example.php"; - # First create some objects using the pointer library. print "Testing the pointer library\n"; @@ -14,7 +12,7 @@ print " b = $b\n"; print " c = $c\n"; - # Call the add() function wuth some pointers + # Call the add() function with some pointers add($a,$b,$c); print " $a + $b = $c\n"; @@ -28,8 +26,8 @@ print " 37 - 42 = $r\n"; # Now try the version with multiple return values - # print "Testing multiple return values\n"; - # ($q,$r) = divide(42,37); - # print " 42/37 = $q remainder $r\n"; - -?> + print "Testing multiple return values\n"; + $a = divide(42,37); + $q = $a[0]; + $r = $a[1]; + print " 42/37 = $q remainder $r\n"; diff --git a/Examples/php/pragmas/include.php b/Examples/php/pragmas/include.php index 11d985d66..442f8e2e0 100644 --- a/Examples/php/pragmas/include.php +++ b/Examples/php/pragmas/include.php @@ -2,6 +2,3 @@ # This code is inserted into example.php echo "This is include.php\n"; - - -?> diff --git a/Examples/php/pragmas/runme.php b/Examples/php/pragmas/runme.php index 7b2c179cb..e2b276313 100644 --- a/Examples/php/pragmas/runme.php +++ b/Examples/php/pragmas/runme.php @@ -6,4 +6,3 @@ set_include_path(realpath(dirname(__FILE__)) . PATH_SEPARATOR . get_include_path require "example.php"; echo "Version - " . ((new ReflectionExtension('example'))->getVersion()) . "\n"; -?> diff --git a/Examples/php/proxy/runme.php b/Examples/php/proxy/runme.php index e70ab229f..0f156b6ad 100644 --- a/Examples/php/proxy/runme.php +++ b/Examples/php/proxy/runme.php @@ -4,8 +4,6 @@ # created by SWIG. In this case, all of our C++ classes # get converted into function calls. -include("example.php"); - # ----- Object creation ----- print "Creating some objects:\n"; @@ -64,5 +62,3 @@ Shape::nshapes(42); print Shape::get_nshapes() ." == 42\n"; print "Goodbye\n"; - -?> diff --git a/Examples/php/reference/runme.php b/Examples/php/reference/runme.php index 5d264ee43..5c7fc9a88 100644 --- a/Examples/php/reference/runme.php +++ b/Examples/php/reference/runme.php @@ -2,8 +2,6 @@ # This file illustrates the manipulation of C++ references in PHP. -require "example.php"; - # ----- Object creation ----- print "Creating some objects:\n"; @@ -45,5 +43,3 @@ print "Getting some array values\n"; for ($i = 0; $i < 5; $i++) { print " va[$i] = {$va->get($i)->as_string()}\n"; } - -?> diff --git a/Examples/php/simple/runme.php b/Examples/php/simple/runme.php index 0e96fe800..2795f32a0 100644 --- a/Examples/php/simple/runme.php +++ b/Examples/php/simple/runme.php @@ -1,7 +1,5 @@ <?php -require "example.php"; - # Call our gcd() function $x = "42 aaa"; @@ -21,5 +19,3 @@ Foo_set(3.1415926); # manual for why. ) print "Foo = " . Foo_get() . "\n"; print_Foo(); - -?> diff --git a/Examples/php/sync/example.cxx b/Examples/php/sync/example.cxx index 0942279b2..2001a5b4e 100644 --- a/Examples/php/sync/example.cxx +++ b/Examples/php/sync/example.cxx @@ -1,13 +1,19 @@ #include "example.h" -#include <stdio.h> +#include <iostream> int x = 42; -char *s = (char *)"Test"; +std::string s = "Test"; -void Sync::printer(void) { +void Sync::printer() { + std::cout << "The value of global s is " << ::s << '\n'; + std::cout << "The value of global x is " << ::x << '\n'; + std::cout << "The value of class s is " << this->s << '\n'; + std::cout << "The value of class x is " << this->x << '\n'; +} - printf("The value of global s is %s\n", s); - printf("The value of global x is %d\n", x); - printf("The value of class s is %s\n", s); - printf("The value of class x is %d\n", x); +void Sync::all_change() { + ::s = "global change"; + ++::x; + this->s = "local change"; + ++this->x; } diff --git a/Examples/php/sync/example.h b/Examples/php/sync/example.h index d67ec21dc..381473f2e 100644 --- a/Examples/php/sync/example.h +++ b/Examples/php/sync/example.h @@ -1,9 +1,14 @@ -extern char *s; +#include <string> + +extern std::string s; extern int x; class Sync { - public: - int x; - char *s; - void printer(void); + public: + int x; + std::string s; + void printer(); + void all_change(); + + Sync() : x(0) { } }; diff --git a/Examples/php/sync/example.i b/Examples/php/sync/example.i index 17ff87cf3..bc10e0fb7 100644 --- a/Examples/php/sync/example.i +++ b/Examples/php/sync/example.i @@ -1,5 +1,7 @@ %module example +%include <std_string.i> + %{ #include "example.h" %} diff --git a/Examples/php/sync/runme.php b/Examples/php/sync/runme.php index a7c43474f..f01a9b3f6 100644 --- a/Examples/php/sync/runme.php +++ b/Examples/php/sync/runme.php @@ -1,15 +1,29 @@ <? -// Load module and PHP classes. -include("example.php"); +echo "PHP reading globals: string is '", s_get(), "' and value is ", x_get(), "\n"; +$o = new Sync(); echo "Got new object\n"; -echo "Got string $s and value $x \n"; -$s = new Sync(); -echo "Got new object\n"; +echo "PHP reading object: string is '", $o->s, "' and value is ", $o->x, "\n"; + +$o->printer(); + +example::s_set("global string"); +example::x_set(42); + +$o->s = "object string"; +$o->x = 1234; + +echo "PHP reading globals: string is '", example::s_get(), "' and int is ", example::x_get(), "\n"; +echo "PHP reading object: string is '", $o->s, "' and int is ", $o->x, "\n"; + +$o->printer(); -$s->printer(); +echo "Calling all_change() method\n"; +$o->all_change(); -?> +echo "PHP reading globals: string is '", example::s_get(), "' and int is ", example::x_get(), "\n"; +echo "PHP reading object: string is '", $o->s, "' and int is ", $o->x, "\n"; +$o->printer(); diff --git a/Examples/php/value/runme.php b/Examples/php/value/runme.php index 569c87cf5..754f94233 100644 --- a/Examples/php/value/runme.php +++ b/Examples/php/value/runme.php @@ -1,8 +1,5 @@ <?php - require "example.php"; - - $v = new Vector(); $v->x = 1.0; $v->y = 2.0; @@ -34,10 +31,6 @@ echo "\nNow I'm going to clean up the return result\n"; -# free($r); + unset($r); echo "Good\n"; - -?> - - diff --git a/Examples/php/variables/runme.php b/Examples/php/variables/runme.php index 14f27f389..a14fede72 100644 --- a/Examples/php/variables/runme.php +++ b/Examples/php/variables/runme.php @@ -1,6 +1,5 @@ <?php - require "example.php"; echo "\nVariables (values printed from C)\n"; print_vars(); @@ -91,6 +90,3 @@ /* And this */ //status_set(0); echo "Status = ".status_get()."\n"; - -?> - diff --git a/Examples/pike/check.list b/Examples/pike/check.list deleted file mode 100644 index d6c8e2e7b..000000000 --- a/Examples/pike/check.list +++ /dev/null @@ -1,7 +0,0 @@ -# see top-level Makefile.in -class -constants -enum -overload -simple -template diff --git a/Examples/pike/class/Makefile b/Examples/pike/class/Makefile deleted file mode 100644 index e5319dbe2..000000000 --- a/Examples/pike/class/Makefile +++ /dev/null @@ -1,23 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -CXXSRCS = example.cxx -TARGET = example -INTERFACE = example.i -LIBS = -lm - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp - -static: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/pike/class/example.cxx b/Examples/pike/class/example.cxx deleted file mode 100644 index 046304519..000000000 --- a/Examples/pike/class/example.cxx +++ /dev/null @@ -1,28 +0,0 @@ -/* File : example.cxx */ - -#include "example.h" -#define M_PI 3.14159265358979323846 - -/* Move the shape to a new location */ -void Shape::move(double dx, double dy) { - x += dx; - y += dy; -} - -int Shape::nshapes = 0; - -double Circle::area() { - return M_PI*radius*radius; -} - -double Circle::perimeter() { - return 2*M_PI*radius; -} - -double Square::area() { - return width*width; -} - -double Square::perimeter() { - return 4*width; -} diff --git a/Examples/pike/class/example.h b/Examples/pike/class/example.h deleted file mode 100644 index 0dff185b2..000000000 --- a/Examples/pike/class/example.h +++ /dev/null @@ -1,34 +0,0 @@ -/* File : example.h */ - -class Shape { -public: - Shape() { - nshapes++; - } - virtual ~Shape() { - nshapes--; - } - double x, y; - void move(double dx, double dy); - virtual double area() = 0; - virtual double perimeter() = 0; - static int nshapes; -}; - -class Circle : public Shape { -private: - double radius; -public: - Circle(double r) : radius(r) { } - virtual double area(); - virtual double perimeter(); -}; - -class Square : public Shape { -private: - double width; -public: - Square(double w) : width(w) { } - virtual double area(); - virtual double perimeter(); -}; diff --git a/Examples/pike/class/example.i b/Examples/pike/class/example.i deleted file mode 100644 index fbdf7249f..000000000 --- a/Examples/pike/class/example.i +++ /dev/null @@ -1,9 +0,0 @@ -/* File : example.i */ -%module example - -%{ -#include "example.h" -%} - -/* Let's just grab the original header file here */ -%include "example.h" diff --git a/Examples/pike/class/runme.pike b/Examples/pike/class/runme.pike deleted file mode 100644 index a6377600e..000000000 --- a/Examples/pike/class/runme.pike +++ /dev/null @@ -1,53 +0,0 @@ -import .example; - -int main() -{ - // ----- Object creation ----- - - write("Creating some objects:\n"); - Circle c = Circle(10.0); - write(" Created circle.\n"); - Square s = Square(10.0); - write(" Created square.\n"); - - // ----- Access a static member ----- - - write("\nA total of " + Shape_nshapes_get() + " shapes were created\n"); - - // ----- Member data access ----- - - // Set the location of the object - - c->x_set(20.0); - c->y_set(30.0); - - s->x_set(-10.0); - s->y_set(5.0); - - write("\nHere is their current position:\n"); - write(" Circle = (%f, %f)\n", c->x_get(), c->y_get()); - write(" Square = (%f, %f)\n", s->x_get(), s->y_get()); - - // ----- Call some methods ----- - - write("\nHere are some properties of the shapes:\n"); - write(" The circle:\n"); - write(" area = %f.\n", c->area()); - write(" perimeter = %f.\n", c->perimeter()); - write(" The square:\n"); - write(" area = %f.\n", s->area()); - write(" perimeter = %f.\n", s->perimeter()); - - write("\nGuess I'll clean up now\n"); - - /* See if we can force 's' to be garbage-collected */ - s = 0; - - /* Now we should be down to only 1 shape */ - write("%d shapes remain\n", Shape_nshapes_get()); - - /* Done */ - write("Goodbye\n"); - - return 0; -} diff --git a/Examples/pike/constants/Makefile b/Examples/pike/constants/Makefile deleted file mode 100644 index 45da7d269..000000000 --- a/Examples/pike/constants/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = -TARGET = example -INTERFACE = example.i - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike - -static: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='mypike' INTERFACE='$(INTERFACE)' pike_static - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/pike/constants/example.i b/Examples/pike/constants/example.i deleted file mode 100644 index 4f7b1a4d7..000000000 --- a/Examples/pike/constants/example.i +++ /dev/null @@ -1,27 +0,0 @@ -/* File : example.i */ -%module example - -/* A few preprocessor macros */ - -#define ICONST 42 -#define FCONST 2.1828 -#define CCONST 'x' -#define CCONST2 '\n' -#define SCONST "Hello World" -#define SCONST2 "\"Hello World\"" - -/* This should work just fine */ -#define EXPR ICONST + 3*(FCONST) - -/* This shouldn't do anything */ -#define EXTERN extern - -/* Neither should this (BAR isn't defined) */ -#define FOO (ICONST + BAR) - -/* The following directives also produce constants */ - -%constant int iconst = 37; -%constant double fconst = 3.14; - - diff --git a/Examples/pike/constants/runme.pike b/Examples/pike/constants/runme.pike deleted file mode 100644 index a8d9f944f..000000000 --- a/Examples/pike/constants/runme.pike +++ /dev/null @@ -1,24 +0,0 @@ -int main() -{ - write("ICONST = %d (should be 42)\n", .example.ICONST); - write("FCONST = %f (should be 2.1828)\n", .example.FCONST); - write("CCONST = %c (should be 'x')\n", .example.CCONST); - write("CCONST2 = %c (this should be on a new line)\n", .example.CCONST2); - write("SCONST = %s (should be 'Hello World')\n", .example.SCONST); - write("SCONST2 = %s (should be '\"Hello World\"')\n", .example.SCONST2); - write("EXPR = %f (should be 48.5484)\n", .example.EXPR); - write("iconst = %d (should be 37)\n", .example.iconst); - write("fconst = %f (should be 3.14)\n", .example.fconst); - - if (search(indices(.example), "EXTERN") == -1) - write("EXTERN isn't defined (good)\n"); - else - write("EXTERN is defined (bad)\n"); - - if (search(indices(.example), "FOO") == -1) - write("FOO isn't defined (good)\n"); - else - write("FOO is defined (bad)\n"); - - return 0; -} diff --git a/Examples/pike/enum/Makefile b/Examples/pike/enum/Makefile deleted file mode 100644 index e5319dbe2..000000000 --- a/Examples/pike/enum/Makefile +++ /dev/null @@ -1,23 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -CXXSRCS = example.cxx -TARGET = example -INTERFACE = example.i -LIBS = -lm - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp - -static: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/pike/enum/README b/Examples/pike/enum/README deleted file mode 100644 index 055aa9fce..000000000 --- a/Examples/pike/enum/README +++ /dev/null @@ -1,13 +0,0 @@ -This example will not compile with Pike versions 7.4.20 unless you first -patch the Pike sources. The problem is for line 91 of Pike's "stralloc.h" -(usually installed as /usr/local/pike/7.4.10/include/pike/stralloc.h). That -line reads: - - tmp.ptr=ptr; - -but should be patched to read: - - tmp.ptr=(p_wchar0 *) ptr; - -This bug has been reported to the Pike developers. - diff --git a/Examples/pike/enum/example.cxx b/Examples/pike/enum/example.cxx deleted file mode 100644 index 6785e57ac..000000000 --- a/Examples/pike/enum/example.cxx +++ /dev/null @@ -1,37 +0,0 @@ -/* File : example.c */ - -#include "example.h" -#include <stdio.h> - -void Foo::enum_test(speed s) { - if (s == IMPULSE) { - printf("IMPULSE speed\n"); - } else if (s == WARP) { - printf("WARP speed\n"); - } else if (s == LUDICROUS) { - printf("LUDICROUS speed\n"); - } else { - printf("Unknown speed\n"); - } -} - -void enum_test(color c, Foo::speed s) { - if (c == RED) { - printf("color = RED, "); - } else if (c == BLUE) { - printf("color = BLUE, "); - } else if (c == GREEN) { - printf("color = GREEN, "); - } else { - printf("color = Unknown color!, "); - } - if (s == Foo::IMPULSE) { - printf("speed = IMPULSE speed\n"); - } else if (s == Foo::WARP) { - printf("speed = WARP speed\n"); - } else if (s == Foo::LUDICROUS) { - printf("speed = LUDICROUS speed\n"); - } else { - printf("speed = Unknown speed!\n"); - } -} diff --git a/Examples/pike/enum/example.h b/Examples/pike/enum/example.h deleted file mode 100644 index 525d62afc..000000000 --- a/Examples/pike/enum/example.h +++ /dev/null @@ -1,13 +0,0 @@ -/* File : example.h */ - -enum color { RED, BLUE, GREEN }; - -class Foo { - public: - Foo() { } - enum speed { IMPULSE, WARP, LUDICROUS }; - void enum_test(speed s); -}; - -void enum_test(color c, Foo::speed s); - diff --git a/Examples/pike/enum/example.i b/Examples/pike/enum/example.i deleted file mode 100644 index 23ee8a822..000000000 --- a/Examples/pike/enum/example.i +++ /dev/null @@ -1,11 +0,0 @@ -/* File : example.i */ -%module example - -%{ -#include "example.h" -%} - -/* Let's just grab the original header file here */ - -%include "example.h" - diff --git a/Examples/pike/enum/runme.pike b/Examples/pike/enum/runme.pike deleted file mode 100644 index 4846356b3..000000000 --- a/Examples/pike/enum/runme.pike +++ /dev/null @@ -1,28 +0,0 @@ -int main() -{ - write("*** color ***\n"); - write(" RED = " + .example.RED + "\n"); - write(" BLUE = " + .example.BLUE + "\n"); - write(" GREEN = " + .example.GREEN + "\n"); - - write("\n*** Foo::speed ***\n"); - write(" Foo_IMPULSE = " + .example.Foo.IMPULSE + "\n"); - write(" Foo_WARP = " + .example.Foo.WARP + "\n"); - write(" Foo_LUDICROUS = " + .example.Foo.LUDICROUS + "\n"); - - write("\nTesting use of enums with functions\n\n"); - - .example.enum_test(.example.RED, .example.Foo.IMPULSE); - .example.enum_test(.example.BLUE, .example.Foo.WARP); - .example.enum_test(.example.GREEN, .example.Foo.LUDICROUS); - .example.enum_test(1234, 5678); - - write("\nTesting use of enum with class method\n"); - .example.Foo f = .example.Foo(); - - f->enum_test(.example.Foo.IMPULSE); - f->enum_test(.example.Foo.WARP); - f->enum_test(.example.Foo.LUDICROUS); - - return 0; -} diff --git a/Examples/pike/overload/Makefile b/Examples/pike/overload/Makefile deleted file mode 100644 index 5e5fe669b..000000000 --- a/Examples/pike/overload/Makefile +++ /dev/null @@ -1,23 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -CXXSRCS = example.cxx -TARGET = example -INTERFACE = example.i -LIBS = -lstdc++ -lm - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp - -static: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/pike/overload/example.cxx b/Examples/pike/overload/example.cxx deleted file mode 100644 index 3760fdd49..000000000 --- a/Examples/pike/overload/example.cxx +++ /dev/null @@ -1,115 +0,0 @@ -#include <iostream> - -#include "example.h" - -// Overloaded constructors for class Bar -Bar::Bar() { - std::cout << "Called Bar::Bar()" << std::endl; -} - -Bar::Bar(const Bar&) { - std::cout << "Called Bar::Bar(const Bar&)" << std::endl; -} - -Bar::Bar(double x) { - std::cout << "Called Bar::Bar(double) with x = " << x << std::endl; -} - -Bar::Bar(double x, char *y) { - std::cout << "Called Bar::Bar(double, char *) with x, y = " << x << ", \"" << y << "\"" << std::endl; -} - -Bar::Bar(int x, int y) { - std::cout << "Called Bar::Bar(int, int) with x, y = " << x << ", " << y << std::endl; -} - -Bar::Bar(char *x) { - std::cout << "Called Bar::Bar(char *) with x = \"" << x << "\"" << std::endl; -} - -Bar::Bar(int x) { - std::cout << "Called Bar::Bar(int) with x = " << x << std::endl; -} - -Bar::Bar(long x) { - std::cout << "Called Bar::Bar(long) with x = " << x << std::endl; -} - -Bar::Bar(Bar *x) { - std::cout << "Called Bar::Bar(Bar *) with x = " << x << std::endl; -} - -// Overloaded member functions -void Bar::foo(const Bar& x) { - std::cout << "Called Bar::foo(const Bar&) with &x = " << &x << std::endl; -} - -void Bar::foo(double x) { - std::cout << "Called Bar::foo(double) with x = " << x << std::endl; -} - -void Bar::foo(double x, char *y) { - std::cout << "Called Bar::foo(double, char *) with x, y = " << x << ", \"" << y << "\"" << std::endl; -} - -void Bar::foo(int x, int y) { - std::cout << "Called Bar::foo(int, int) with x, y = " << x << ", " << y << std::endl; -} - -void Bar::foo(char *x) { - std::cout << "Called Bar::foo(char *) with x = \"" << x << "\"" << std::endl; -} - -void Bar::foo(int x) { - std::cout << "Called Bar::foo(int) with x = " << x << std::endl; -} - -void Bar::foo(long x) { - std::cout << "Called Bar::foo(long) with x = " << x << std::endl; -} - -void Bar::foo(Bar *x) { - std::cout << "Called Bar::foo(Bar *) with x = " << x << std::endl; -} - -void Bar::spam(int x, int y, int z) { - std::cout << "Called Bar::spam(int, int, int) with x, y, z = " << x << ", " << y << ", " << z << std::endl; -} - -void Bar::spam(double x, int y, int z) { - std::cout << "Called Bar::spam(double, int, int) with x, y, z = " << x << ", " << y << ", " << z << std::endl; -} - -// Overloaded global methods -void foo(const Bar& x) { - std::cout << "Called foo(const Bar& x) with &x = " << &x << std::endl; -} - -void foo(double x) { - std::cout << "Called foo(double) with x = " << x << std::endl; -} - -void foo(double x, char *y) { - std::cout << "Called foo(double, char *) with x, y = " << x << ", \"" << y << "\"" << std::endl; -} - -void foo(int x, int y) { - std::cout << "Called foo(int, int) with x, y = " << x << ", " << y << std::endl; -} - -void foo(char *x) { - std::cout << "Called foo(char *) with x = \"" << x << "\"" << std::endl; -} - -void foo(int x) { - std::cout << "Called foo(int) with x = " << x << std::endl; -} - -void foo(long x) { - std::cout << "Called foo(long) with x = " << x << std::endl; -} - -void foo(Bar *x) { - std::cout << "Called foo(Bar *) with x = " << x << std::endl; -} - diff --git a/Examples/pike/overload/example.h b/Examples/pike/overload/example.h deleted file mode 100644 index e47a122ee..000000000 --- a/Examples/pike/overload/example.h +++ /dev/null @@ -1,41 +0,0 @@ -#ifndef EXAMPLE_H -#define EXAMPLE_H - -class Bar { -public: - Bar(); - Bar(const Bar&); - Bar(double); - Bar(double, char *); - Bar(int, int); - Bar(char *); - Bar(long); - Bar(int); - Bar(Bar *); - - void foo(const Bar&); - void foo(double); - void foo(double, char *); - void foo(int, int); - void foo(char *); - void foo(long); - void foo(int); - void foo(Bar *); - - void spam(int x, int y=2, int z=3); - void spam(double x, int y=2, int z=3); -}; - -void foo(const Bar&); -void foo(double); -void foo(double, char *); -void foo(int, int); -void foo(char *); -void foo(int); -void foo(long); -void foo(Bar *); - -void spam(int x, int y=2, int z=3); -void spam(double x, int y=2, int z=3); - -#endif diff --git a/Examples/pike/overload/example.i b/Examples/pike/overload/example.i deleted file mode 100644 index ddcd006be..000000000 --- a/Examples/pike/overload/example.i +++ /dev/null @@ -1,28 +0,0 @@ -/* File : example.i */ -%module example - -%{ -#include "example.h" -%} - -/** - * These overloaded declarations conflict with other overloads (as far as - * SWIG's Ruby module's implementation for overloaded methods is concerned). - * One option is use the %rename directive to rename the conflicting methods; - * here, we're just using %ignore to avoid wrapping some of the overloaded - * functions altogether. - */ - -%ignore Bar; - -%ignore Bar::Bar(Bar *); -%ignore Bar::Bar(long); - -%ignore Bar::foo(const Bar&); -%ignore Bar::foo(long); - -%ignore ::foo(const Bar&); -%ignore ::foo(int); - -/* Let's just grab the original header file here */ -%include "example.h" diff --git a/Examples/pike/overload/runme.pike b/Examples/pike/overload/runme.pike deleted file mode 100644 index d30e947b3..000000000 --- a/Examples/pike/overload/runme.pike +++ /dev/null @@ -1,83 +0,0 @@ -// import .example; - -int main() -{ - // This should invoke foo(double) - .example.foo(3.14159); - - // This should invoke foo(double, char *) - .example.foo(3.14159, "Pi"); - - // This should invoke foo(int, int) - .example.foo(3, 4); - - // This should invoke foo(char *) - .example.foo("This is a test"); - - // This should invoke foo(long) - .example.foo(42); - - /* - // This should invoke Bar::Bar() followed by foo(Bar *) - foo(Bar.new); - - // Skip a line - write("\n"); - - // This should invoke Bar::Bar(double) - Bar.new(3.14159); - - // This should invoke Bar::Bar(double, char *) - Bar.new(3.14159, "Pi"); - - // This should invoke Bar::Bar(int, int) - Bar.new(3, 4); - - // This should invoke Bar::Bar(char *) - Bar.new("This is a test"); - - // This should invoke Bar::Bar(int) - Bar.new(42); - - // This should invoke Bar::Bar() for the input argument, - // followed by Bar::Bar(const Bar&). - Bar.new(Bar.new); - - // Skip a line - write("\n"); - */ - - // Construct a new Bar instance (invokes Bar::Bar()) - /* - bar = Bar.new; - - // This should invoke Bar::foo(double) - bar.foo(3.14159); - - // This should invoke Bar::foo(double, char *) - bar.foo(3.14159, "Pi"); - - // This should invoke Bar::foo(int, int) - bar.foo(3, 4); - - // This should invoke Bar::foo(char *) - bar.foo("This is a test"); - - // This should invoke Bar::foo(int) - bar.foo(42); - - // This should invoke Bar::Bar() to construct the input - // argument, followed by Bar::foo(Bar *). - bar.foo(Example::Bar.new); - - // This should invoke Bar::spam(int x, int y, int z) - bar.spam(1); - - // This should invoke Bar::spam(double x, int y, int z) - bar.spam(3.14159); - */ - - write("Goodbye\n"); - - return 0; -} diff --git a/Examples/pike/simple/Makefile b/Examples/pike/simple/Makefile deleted file mode 100644 index 8b49b4ea5..000000000 --- a/Examples/pike/simple/Makefile +++ /dev/null @@ -1,22 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -SRCS = example.c -TARGET = example -INTERFACE = example.i - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike - -static: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' SRCS='$(SRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - TARGET='mypike' INTERFACE='$(INTERFACE)' pike_static - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/pike/simple/example.c b/Examples/pike/simple/example.c deleted file mode 100644 index 1c2af789c..000000000 --- a/Examples/pike/simple/example.c +++ /dev/null @@ -1,18 +0,0 @@ -/* File : example.c */ - -/* A global variable */ -double Foo = 3.0; - -/* Compute the greatest common divisor of positive integers */ -int gcd(int x, int y) { - int g; - g = y; - while (x > 0) { - g = x; - x = y % x; - y = g; - } - return g; -} - - diff --git a/Examples/pike/simple/example.i b/Examples/pike/simple/example.i deleted file mode 100644 index 24093b9bf..000000000 --- a/Examples/pike/simple/example.i +++ /dev/null @@ -1,7 +0,0 @@ -/* File : example.i */ -%module example - -%inline %{ -extern int gcd(int x, int y); -extern double Foo; -%} diff --git a/Examples/pike/simple/runme.pike b/Examples/pike/simple/runme.pike deleted file mode 100644 index a6a78e9e7..000000000 --- a/Examples/pike/simple/runme.pike +++ /dev/null @@ -1,20 +0,0 @@ -int main() -{ - /* Call our gcd() function */ - int x = 42; - int y = 105; - int g = .example.gcd(x, y); - write("The gcd of %d and %d is %d\n", x, y, g); - - /* Manipulate the Foo global variable */ - /* Output its current value */ - write("Foo = %f\n", .example->Foo_get()); - - /* Change its value */ - .example->Foo_set(3.1415926); - - /* See if the change took effect */ - write("Foo = %f\n", .example->Foo_get()); - - return 0; -} diff --git a/Examples/pike/template/Makefile b/Examples/pike/template/Makefile deleted file mode 100644 index 513dc3b4b..000000000 --- a/Examples/pike/template/Makefile +++ /dev/null @@ -1,24 +0,0 @@ -TOP = ../.. -SWIGEXE = $(TOP)/../swig -SWIG_LIB_DIR = $(TOP)/../$(TOP_BUILDDIR_TO_TOP_SRCDIR)Lib -CXXSRCS = -TARGET = example -INTERFACE = example.i -LIBS = -lm -SWIGOPT = - -check: build - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_run - -build: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='$(TARGET)' INTERFACE='$(INTERFACE)' pike_cpp - -static: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' CXXSRCS='$(CXXSRCS)' \ - SWIG_LIB_DIR='$(SWIG_LIB_DIR)' SWIGEXE='$(SWIGEXE)' \ - SWIGOPT='$(SWIGOPT)' TARGET='mypike' INTERFACE='$(INTERFACE)' pike_cpp_static - -clean: - $(MAKE) -f $(TOP)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/pike/template/example.h b/Examples/pike/template/example.h deleted file mode 100644 index 7401df650..000000000 --- a/Examples/pike/template/example.h +++ /dev/null @@ -1,32 +0,0 @@ -/* File : example.h */ - -// Some template definitions - -template<class T> T max(T a, T b) { return a>b ? a : b; } - -template<class T> class vector { - T *v; - int sz; - public: - vector(int _sz) { - v = new T[_sz]; - sz = _sz; - } - T &get(int index) { - return v[index]; - } - void set(int index, T &val) { - v[index] = val; - } -#ifdef SWIG - %extend { - T getitem(int index) { - return $self->get(index); - } - void setitem(int index, T val) { - $self->set(index,val); - } - } -#endif -}; - diff --git a/Examples/pike/template/example.i b/Examples/pike/template/example.i deleted file mode 100644 index 8f94c4da1..000000000 --- a/Examples/pike/template/example.i +++ /dev/null @@ -1,17 +0,0 @@ -/* File : example.i */ -%module example - -%{ -#include "example.h" -%} - -/* Let's just grab the original header file here */ -%include "example.h" - -/* Now instantiate some specific template declarations */ - -%template(maxint) max<int>; -%template(maxdouble) max<double>; -%template(vecint) vector<int>; -%template(vecdouble) vector<double>; - diff --git a/Examples/pike/template/runme.pike b/Examples/pike/template/runme.pike deleted file mode 100644 index 36825c3e3..000000000 --- a/Examples/pike/template/runme.pike +++ /dev/null @@ -1,33 +0,0 @@ -int main() -{ - // Call some templated functions - write(sprintf("%d\n", .example.maxint(3, 7))); - write(sprintf("%f\n", .example.maxdouble(3.14, 2.18))); - - // Create some objects - .example.vecint iv = .example.vecint(100); - .example.vecdouble dv = .example.vecdouble(1000); - - for (int i = 0; i < 100; i++) { - iv->setitem(i, 2*i); - } - - for (int i = 0; i < 1000; i++) { - dv->setitem(i, 1.0/(i+1)); - } - - int isum = 0; - for (int i = 0; i < 100; i++) { - isum += iv->getitem(i); - } - - write(sprintf("%d\n", isum)); - - float fsum = 0.0; - for (int i = 0; i < 1000; i++) { - fsum += dv->getitem(i); - } - write(sprintf("%f\n", fsum)); - - return 0; -} diff --git a/Examples/python/exception/example.h b/Examples/python/exception/example.h index bc744cda7..c76c46a5d 100644 --- a/Examples/python/exception/example.h +++ b/Examples/python/exception/example.h @@ -10,7 +10,7 @@ class Exc { public: Exc(int c, const char *m) { code = c; - strncpy(msg,m,256); + strncpy(msg,m,255); } int code; char msg[256]; diff --git a/Examples/s-exp/uffi.lisp b/Examples/s-exp/uffi.lisp deleted file mode 100644 index aea9a1405..000000000 --- a/Examples/s-exp/uffi.lisp +++ /dev/null @@ -1,389 +0,0 @@ -;;; This is experimental code that uses the s-expression -;;; representation of a C/C++ library interface to generate Foreign -;;; Function Interface definitions for use with Kevin Rosenberg's -;;; UFFI. -;;; -;;; Written by Matthias Koeppe <mkoeppe@mail.math.uni-magdeburg.de> - -(eval-when (:compile-toplevel :load-toplevel :execute) - (require 'port) ; from CLOCC - (require 'uffi)) - -(in-package :cl-user) - -;; Interaction with the SWIG binary - -(defvar *swig-source-directory* #p"/home/mkoeppe/s/swig1.3/") - -(defvar *swig-program* (merge-pathnames "swig" *swig-source-directory*)) - -(defun run-swig (swig-interface-file-name &key directory-search-list module - ignore-errors c++) - (let ((temp-file-name "/tmp/swig.lsp")) - (let ((process - (port:run-prog (namestring *swig-program*) - :output t - :args `(,@(and c++ '("-c++")) - "-sexp" - ,@(mapcar (lambda (dir) - (concatenate 'string - "-I" (namestring dir))) - directory-search-list) - ,@(and module - `("-module" ,module)) - "-o" ,temp-file-name - ,(namestring swig-interface-file-name))))) - #+cmu (unless (or (zerop (ext:process-exit-code process)) - ignore-errors) - (error "Process swig exited abnormally")) - (with-open-file (s temp-file-name) - (read s))))) - -;; Type system - -(defun parse-swigtype (type-string &key start end junk-ok) - "Parse TYPE-STRING as SWIG's internal representation of C/C++ -types. Return two values: The type description (an improper list) and -the terminating index into TYPE-STRING." - ;; SWIG's internal representation is described in Source/Swig/stype.c - (unless start - (setq start 0)) - (unless end - (setq end (length type-string))) - (flet ((prefix-match (prefix) - (let ((position (mismatch prefix type-string :start2 start :end2 end))) - (or (not position) - (= position (length prefix))))) - (bad-type-error (reason) - (error "Bad SWIG type (~A): ~A" reason - (subseq type-string start end))) - (type-char (index) - (and (< index (length type-string)) - (char type-string index))) - (cons-and-recurse (prefix start end) - (multiple-value-bind (type-description index) - (parse-swigtype type-string :start start :end end - :junk-ok junk-ok) - (values (cons prefix type-description) - index)))) - (cond - ((prefix-match "p.") ; pointer - (cons-and-recurse '* (+ start 2) end)) - ((prefix-match "r.") ; C++ reference - (cons-and-recurse '& (+ start 2) end)) - ((prefix-match "a(") ; array - (let ((closing-paren (position #\) type-string - :start (+ start 2) - :end end))) - (unless closing-paren - (bad-type-error "missing right paren")) - (unless (eql (type-char (+ closing-paren 1)) #\.) - (bad-type-error "missing dot")) - (cons-and-recurse (list 'ARRAY (subseq type-string (+ start 2) closing-paren)) - (+ closing-paren 2) end))) - ((prefix-match "q(") ; qualifier (const, volatile) - (let ((closing-paren (position #\) type-string - :start (+ start 2) - :end end))) - (unless closing-paren - (bad-type-error "missing right paren")) - (unless (eql (type-char (+ closing-paren 1)) #\.) - (bad-type-error "missing dot")) - (cons-and-recurse (list 'QUALIFIER (subseq type-string (+ start 2) closing-paren)) - (+ closing-paren 2) end))) - ((prefix-match "m(") ; C++ member pointer - (multiple-value-bind (class-type class-end-index) - (parse-swigtype type-string :junk-ok t - :start (+ start 2) :end end) - (unless (eql (type-char class-end-index) #\)) - (bad-type-error "missing right paren")) - (unless (eql (type-char (+ class-end-index 1)) #\.) - (bad-type-error "missing dot")) - (cons-and-recurse (list 'MEMBER-POINTER class-type) - (+ class-end-index 2) end))) - ((prefix-match "f(") ; function - (loop with index = (+ start 2) - until (eql (type-char index) #\)) - collect (multiple-value-bind (arg-type arg-end-index) - (parse-swigtype type-string :junk-ok t - :start index :end end) - (case (type-char arg-end-index) - (#\, (setq index (+ arg-end-index 1))) - (#\) (setq index arg-end-index)) - (otherwise (bad-type-error "comma or right paren expected"))) - arg-type) - into arg-types - finally (unless (eql (type-char (+ index 1)) #\.) - (bad-type-error "missing dot")) - (return (cons-and-recurse (cons 'FUNCTION arg-types) - (+ index 2) end)))) - ((prefix-match "v(") ;varargs - (let ((closing-paren (position #\) type-string - :start (+ start 2) - :end end))) - (unless closing-paren - (bad-type-error "missing right paren")) - (values (list 'VARARGS (subseq type-string (+ start 2) closing-paren)) - (+ closing-paren 1)))) - (t (let ((junk-position (position-if (lambda (char) - (member char '(#\, #\( #\) #\.))) - type-string - :start start :end end))) - (cond (junk-position ; found junk - (unless junk-ok - (bad-type-error "trailing junk")) - (values (subseq type-string start junk-position) - junk-position)) - (t - (values (subseq type-string start end) - end)))))))) - -(defun swigtype-function-p (swigtype) - "Check whether SWIGTYPE designates a function. If so, the second -value is the list of argument types, and the third value is the return -type." - (if (and (consp swigtype) - (consp (first swigtype)) - (eql (first (first swigtype)) 'FUNCTION)) - (values t (rest (first swigtype)) (rest swigtype)) - (values nil nil nil))) - - -;; UFFI - -(defvar *uffi-definitions* '()) - -(defconstant *uffi-default-primitive-type-alist* - '(("char" . :char) - ("unsigned char" . :unsigned-byte) - ("signed char" . :byte) - ("short" . :short) - ("signed short" . :short) - ("unsigned short" . :unsigned-short) - ("int" . :int) - ("signed int" . :int) - ("unsigned int" . :unsigned-int) - ("long" . :long) - ("signed long" . :long) - ("unsigned long" . :unsigned-long) - ("float" . :float) - ("double" . :double) - ((* . "char") . :cstring) - ((* . "void") . :pointer-void) - ("void" . :void))) - -(defvar *uffi-primitive-type-alist* *uffi-default-primitive-type-alist*) - -(defun uffi-type-spec (type-list) - "Return the UFFI type spec equivalent to TYPE-LIST, or NIL if there -is no representation." - (let ((primitive-type-pair - (assoc type-list *uffi-primitive-type-alist* :test 'equal))) - (cond - (primitive-type-pair - (cdr primitive-type-pair)) - ((and (consp type-list) - (eql (first type-list) '*)) - (let ((base-type-spec (uffi-type-spec (rest type-list)))) - (cond - ((not base-type-spec) - :pointer-void) - (t - (list '* base-type-spec))))) - (t nil)))) - -;; Parse tree - -(defvar *uffi-output* nil) - -(defun emit-uffi-definition (uffi-definition) - (format *uffi-output* "~&~S~%" uffi-definition) - (push uffi-definition *uffi-definitions*)) - -(defun make-cl-symbol (c-identifier &key uninterned) - (let ((name (substitute #\- #\_ (string-upcase c-identifier)))) - (if uninterned - (make-symbol name) - (intern name)))) - -(defvar *class-scope* '() "A stack of names of nested C++ classes.") - -(defvar *struct-fields* '()) - -(defvar *linkage* :C "NIL or :C") - -(defgeneric handle-node (node-type &key &allow-other-keys) - (:documentation "Handle a node of SWIG's parse tree of a C/C++ program")) - -(defmethod handle-node ((node-type t) &key &allow-other-keys) - ;; do nothing for unknown node types - nil) - -(defmethod handle-node ((node-type (eql 'cdecl)) &key name decl storage parms type &allow-other-keys) - (let ((swigtype (parse-swigtype (concatenate 'string decl type)))) - (let ((*print-pretty* nil) ; or FUNCTION would be printed as #' by cmucl - (*print-circle* t)) - (format *uffi-output* "~&;; C Declaration: ~A ~A ~A ~A~%;; with-parms ~W~%;; of-type ~W~%" - storage type name decl parms swigtype)) - (multiple-value-bind (function-p arg-swigtype-list return-swigtype) - (swigtype-function-p swigtype) - (declare (ignore arg-swigtype-list)) - (cond - ((and (null *class-scope*) function-p - (or (eql *linkage* :c) - (string= storage "externc"))) - ;; ordinary top-level function with C linkage - (let ((argnum 0) - (argname-list '())) - (flet ((unique-argname (name) - ;; Sometimes the functions in SWIG interfaces - ;; do not have unique names. Make them unique - ;; by adding a suffix. Also avoid symbols - ;; that are specially bound. - (unless name - (setq name (format nil "arg~D" argnum))) - (let ((argname (make-cl-symbol name))) - (when (boundp argname) ;specially bound - (setq argname (make-cl-symbol name :uninterned t))) - (push argname argname-list) - argname))) - (let ((uffi-arg-list - (mapcan (lambda (param) - (incf argnum) - (destructuring-bind (&key name type &allow-other-keys) param - (let ((uffi-type (uffi-type-spec (parse-swigtype type)))) - (cond - ((not uffi-type) - (format *uffi-output* "~&;; Warning: Cannot handle type ~S of argument `~A'~%" - type name) - (return-from handle-node)) - ((eq uffi-type :void) - '()) - (t - (let ((symbol (unique-argname name))) - (list `(,symbol ,uffi-type)))))))) - parms)) - (uffi-return-type - (uffi-type-spec return-swigtype))) - (unless uffi-return-type - (format *uffi-output* "~&;; Warning: Cannot handle return type `~S'~%" - return-swigtype) - (return-from handle-node)) - (emit-uffi-definition `(UFFI:DEF-FUNCTION ,name ,uffi-arg-list :RETURNING ,uffi-return-type)))))) - ((and (not (null *class-scope*)) (null (rest *class-scope*)) - (not function-p)) ; class/struct member (no nested structs) - (let ((uffi-type (uffi-type-spec swigtype))) - (unless uffi-type - (format *uffi-output* "~&;; Warning: Cannot handle type ~S of struct field `~A'~%" - type name) - (return-from handle-node)) - (push `(,(make-cl-symbol name) ,uffi-type) *struct-fields*))))))) - -(defmethod handle-node ((node-type (eql 'class)) &key name children kind &allow-other-keys) - (format *uffi-output* "~&;; Class ~A~%" name) - (let ((*class-scope* (cons name *class-scope*)) - (*struct-fields* '())) - (dolist (child children) - (apply 'handle-node child)) - (emit-uffi-definition `(,(if (string= kind "union") - 'UFFI:DEF-UNION - 'UFFI:DEF-STRUCT) - ,(make-cl-symbol name) ,@(nreverse *struct-fields*))))) - -(defmethod handle-node ((node-type (eql 'top)) &key children &allow-other-keys) - (dolist (child children) - (apply 'handle-node child))) - -(defmethod handle-node ((node-type (eql 'include)) &key name children &allow-other-keys) - (format *uffi-output* ";; INCLUDE ~A~%" name) - (dolist (child children) - (apply 'handle-node child))) - -(defmethod handle-node ((node-type (eql 'extern)) &key name children &allow-other-keys) - (format *uffi-output* ";; EXTERN \"C\" ~A~%" name) - (let ((*linkage* :c)) - (dolist (child children) - (apply 'handle-node child)))) - -;;(defun compute-uffi-definitions (swig-interface) -;; (let ((*uffi-definitions* '())) -;; (handle-node swig-interface) -;; *uffi-definitions*)) - -;; Test instances - -;;; Link to SWIG itself - -#|| - -(defparameter *c++-compiler* "g++") - -(defun stdc++-library (&key env) - (let ((error-output (make-string-output-stream))) - (let ((name-output (make-string-output-stream))) - (let ((proc (ext:run-program - *c++-compiler* - '("-print-file-name=libstdc++.so") - :env env - :input nil - :output name-output - :error error-output))) - (unless proc - (error "Could not run ~A" *c++-compiler*)) - (unless (zerop (ext:process-exit-code proc)) - (system:serve-all-events 0) - (error "~A failed:~%~A" *c++-compiler* - (get-output-stream-string error-output)))) - (string-right-trim '(#\Newline) (get-output-stream-string name-output))))) - -(defvar *swig-interface* nil) - -(defvar *swig-uffi-pathname* #p"/tmp/swig-uffi.lisp") - -(defun link-swig () - (setq *swig-interface* - (run-swig (merge-pathnames "Source/swig.i" *swig-source-directory*) - :directory-search-list - (list (merge-pathnames "Source/" *swig-source-directory*)) - :module "swig" - :ignore-errors t - :c++ t)) - (with-open-file (f *swig-uffi-pathname* :direction :output) - (let ((*linkage* :c++) - (*uffi-definitions* '()) - (*uffi-output* f) - (*uffi-primitive-type-alist* *uffi-default-primitive-type-alist*)) - (apply 'handle-node *swig-interface*))) - (compile-file *swig-uffi-pathname*) - (alien:load-foreign (merge-pathnames "Source/libswig.a" - *swig-source-directory*) - :libraries (list (stdc++-library))) - ;; FIXME: UFFI stuffes a "-l" in front of the passed library names - ;; (uffi:load-foreign-library (merge-pathnames "Source/libswig.a" - ;; *swig-source-directory*) - ;; :supporting-libraries - ;; (list (stdc++-library))) - (load (compile-file-pathname *swig-uffi-pathname*))) - -||# - -;;;; TODO: - -;; * How to do type lookups? Is everything important that SWIG knows -;; about the types written out? What to make of typemaps? -;; -;; * Wrapped functions should probably automatically COERCE their -;; arguments (as of type DOUBLE-FLOAT), to make the functions more -;; flexible? -;; -;; * Why are the functions created by FFI interpreted? -;; -;; * We can't deal with more complicated structs and C++ classes -;; directly with the FFI; we have to emit SWIG wrappers that access -;; those classes. -;; -;; * A CLOS layer where structure fields are mapped as slots. It -;; looks like we need MOP functions to implement this. -;; -;; * Maybe modify SWIG so that key-value hashes are distinguished from -;; value-value hashes. diff --git a/Examples/test-suite/allegrocl/Makefile.in b/Examples/test-suite/allegrocl/Makefile.in deleted file mode 100644 index b13d546da..000000000 --- a/Examples/test-suite/allegrocl/Makefile.in +++ /dev/null @@ -1,126 +0,0 @@ -####################################################################### -# Makefile for allegrocl test-suite -####################################################################### - -LANGUAGE = allegrocl -ALLEGROCL = @ALLEGROCLBIN@ -SCRIPTSUFFIX = _runme.lisp - -srcdir = @srcdir@ -top_srcdir = @top_srcdir@ -top_builddir = @top_builddir@ - - -# these cpp tests generate warnings/errors when compiling -# the wrapper .cxx file. -CPP_TEST_BROKEN_CXX = -# the error is wrap:action code generated by swig. \ -# error: can't convert [std::string] 'b' to 'bool' \ -# might just need a bool overload op for std::string. \ - global_vars \ -# same as w/ global_vars but with more errors in cxx file \ - naturalvar \ - -# these cpp tests aren't working. Fix 'em -# need to further separate these into tests requiring -# std libraries, or the $ldestructor problem. -CPP_TEST_BROKEN_ACL = \ - contract \ - allprotected \ -# 'throws' typemap entries. \ - cplusplus_throw \ -# 'throws' typemap entries. \ - default_args \ -# missing typemaps. suspect module support needed \ - dynamic_cast \ - extend_variable \ -# cdata.i support needed \ - li_cdata_cpp \ -# warning generated. otherwise all good. \ - operator_overload \ -# std_common.i support \ - sizet \ -# std_vector.i support. \ - template_default \ -# *** line 31. can't copy typemap?? \ - typemap_namespace \ - -# these aren't working due to longlong support. (low hanging fruit) -CPP_TEST_BROKEN_LONGLONG = \ - arrays_dimensionless \ - arrays_global \ - arrays_global_twodim \ - li_typemaps \ - li_windows \ - long_long_apply \ - primitive_ref \ - reference_global_vars \ - template_default_arg - -# These are currently unsupported. -CPP_TEST_CASES_ACL_UNSUPPORTED = \ -# contract support \ - aggregate \ -# directors support \ - apply_signed_char \ -# contract support \ - contract \ - director_exception \ - director_protected \ - exception_order \ -# 'throws' typemap support \ - extern_throws \ - throw_exception \ - using_pointers \ - -C_TEST_CASES_ACL_BROKEN = \ -# 'cdate.i' module support \ - li_cdata \ -# adding an existing type defnition... \ - typedef_struct \ -# swigrun.swg support. \ - typemap_subst - -C_TEST_BROKEN_LONGLONG = \ - long_long - - -# std lib support hasn't been done yet. -SKIP_CPP_STD_CASES = Yes - -include $(srcdir)/../common.mk - -# Overridden variables here -# SWIGOPT += -debug-module 4 - -# Custom tests - tests with additional commandline options -# none! - -# Rules for the different types of tests -%.cpptest: - $(setup) - +$(swig_and_compile_cpp) - $(run_testcase) - -%.ctest: - $(setup) - +$(swig_and_compile_c) - $(run_testcase) - -%.multicpptest: - $(setup) - +$(swig_and_compile_multi_cpp) - $(run_testcase) - -# Runs the testcase. A testcase is only run if -# a file is found which has _runme.lisp appended after the testcase name. -run_testcase = \ - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ - env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(ALLEGROCLBIN) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ - fi - -%.clean: - @rm -f $*.cl - -clean: - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR="$(SRCDIR)" allegrocl_clean diff --git a/Examples/test-suite/allowexcept.i b/Examples/test-suite/allowexcept.i index c901295df..229e65cc9 100644 --- a/Examples/test-suite/allowexcept.i +++ b/Examples/test-suite/allowexcept.i @@ -26,17 +26,6 @@ UVW Bar::static_member_variable; struct XYZ { }; -// The operator& trick doesn't work for SWIG/PHP because the generated code -// takes the address of the variable in the code in the "vinit" section. -#ifdef SWIGPHP -%{ -struct XYZ { - void foo() {} -private: - XYZ& operator=(const XYZ& other); // prevent assignment used in normally generated set method -}; -%} -#else %{ struct XYZ { void foo() {} @@ -45,7 +34,6 @@ private: XYZ* operator&(); // prevent dereferencing used in normally generated get method }; %} -#endif #if defined(SWIGUTL) %exception { /* diff --git a/Examples/test-suite/apply_strings.i b/Examples/test-suite/apply_strings.i index 695dd068f..14283bb11 100644 --- a/Examples/test-suite/apply_strings.i +++ b/Examples/test-suite/apply_strings.i @@ -44,8 +44,6 @@ // unsigned char* as strings #if defined(SWIGJAVA) || defined(SWIGCSHARP) -/* Note: Chicken does not allow unsigned char * in strings */ - %apply char [ANY] {TAscii[ANY]} %apply char [] {TAscii []} %apply char * {TAscii *} diff --git a/Examples/test-suite/chicken/Makefile.in b/Examples/test-suite/chicken/Makefile.in deleted file mode 100644 index b3dccc9c3..000000000 --- a/Examples/test-suite/chicken/Makefile.in +++ /dev/null @@ -1,101 +0,0 @@ -####################################################################### -# Makefile for chicken test-suite -####################################################################### - -LANGUAGE = chicken -VARIANT = -SCRIPTSUFFIX = _runme.ss -PROXYSUFFIX = _runme_proxy.ss - -srcdir = @srcdir@ -top_srcdir = @top_srcdir@ -top_builddir = @top_builddir@ - -CHICKEN_CSI = @CHICKEN_CSI@ -quiet -batch -no-init -SO = @SO@ - -#C_TEST_CASES = long_long list_vector pointer_in_out multivalue - -# Skip the STD cases for now, except for li_std_string.i -SKIP_CPP_STD_CASES = Yes - -CPP_TEST_CASES += li_std_string - -EXTRA_TEST_CASES += chicken_ext_test.externaltest - -include $(srcdir)/../common.mk - -# Overridden variables here -SWIGOPT += -nounit - -# Custom tests - tests with additional commandline options -# If there exists a PROXYSUFFIX runme file, we also generate the wrapper -# with the -proxy argument -%.cppproxy: SWIGOPT += -proxy -%.cppproxy: SCRIPTSUFFIX = $(PROXYSUFFIX) - -%.cproxy: SWIGOPT += -proxy -%.cproxy: SCRIPTSUFFIX = $(PROXYSUFFIX) - -%.multiproxy: SWIGOPT += -proxy -noclosuses -%.multiproxy: SCRIPTSUFFIX = $(PROXYSUFFIX) - -# Rules for the different types of tests -%.cpptest: - $(setup) - +$(swig_and_compile_cpp) - $(run_testcase) - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \ - $(MAKE) $*.cppproxy; \ - fi - -%.ctest: - $(setup) - +$(swig_and_compile_c) - $(run_testcase) - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \ - $(MAKE) $*.cproxy; \ - fi - -%.multicpptest: - $(setup) - +$(swig_and_compile_multi_cpp) - $(run_testcase) - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(PROXYSUFFIX) ]; then \ - $(MAKE) $*.multiproxy; \ - fi - -%.externaltest: - $(setup) - +$(swig_and_compile_external) - $(run_testcase) - -%.cppproxy: - echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test) with -proxy" - +$(swig_and_compile_cpp) - $(run_testcase) - -%.cproxy: - echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test) with -proxy" - +$(swig_and_compile_c) - $(run_testcase) - -%.multiproxy: - echo "$(ACTION)ing $(LANGUAGE) testcase $* (with run test) with -proxy" - +$(swig_and_compile_multi_cpp) - $(run_testcase) - -# Runs the testcase. A testcase is only run if -# a file is found which has _runme.scm appended after the testcase name. -run_testcase = \ - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ - env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CHICKEN_CSI) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ - fi - -# Clean -%.clean: - @exit 0 - -clean: - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' chicken_clean - rm -f *.scm diff --git a/Examples/test-suite/chicken/README b/Examples/test-suite/chicken/README deleted file mode 100644 index aad730ec4..000000000 --- a/Examples/test-suite/chicken/README +++ /dev/null @@ -1,11 +0,0 @@ -See ../README for common README file. - -Any testcases which have _runme.ss appended after the testcase name will be detected and run. -NOTE: I had to use _runme.ss because otherwise it would be hard to implement make clean -Since when SWIG runs it generates an example.scm file for every test, to clean those files -I needed to add a rm -f *.scm to make clean. But we don't want the runme scripts to -disappear as well! - -Any testcases which have _runme_proxy.ss appended after the testcase name will be detected -and run with the -proxy argument passed to SWIG. SWIG will not be run with the -unhide-primitive -option, so the _runme_proxy.ss file must use only the tinyclos exported interface. diff --git a/Examples/test-suite/chicken/casts_runme.ss b/Examples/test-suite/chicken/casts_runme.ss deleted file mode 100644 index 2eca46149..000000000 --- a/Examples/test-suite/chicken/casts_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "casts.so") -(include "../schemerunme/casts.scm") diff --git a/Examples/test-suite/chicken/char_constant_runme.ss b/Examples/test-suite/chicken/char_constant_runme.ss deleted file mode 100644 index 50dff3018..000000000 --- a/Examples/test-suite/chicken/char_constant_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "char_constant.so") -(include "../schemerunme/char_constant.scm") diff --git a/Examples/test-suite/chicken/chicken_ext_test_external.cxx b/Examples/test-suite/chicken/chicken_ext_test_external.cxx deleted file mode 100644 index 1dd6a7d53..000000000 --- a/Examples/test-suite/chicken/chicken_ext_test_external.cxx +++ /dev/null @@ -1,21 +0,0 @@ -#include <chicken/chicken_ext_test_wrap_hdr.h> -#include <imports_a.h> - -void test_create(C_word,C_word,C_word) C_noret; -void test_create(C_word argc, C_word closure, C_word continuation) { - C_word resultobj; - swig_type_info *type; - A *newobj; - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - - C_trace("test-create"); - if (argc!=2) C_bad_argc(argc,2); - - - newobj = new A(); - - type = SWIG_TypeQuery("A *"); - resultobj = SWIG_NewPointerObj(newobj, type, 1); - - C_kontinue(continuation, resultobj); -} diff --git a/Examples/test-suite/chicken/chicken_ext_test_runme.ss b/Examples/test-suite/chicken/chicken_ext_test_runme.ss deleted file mode 100644 index 65fa4e085..000000000 --- a/Examples/test-suite/chicken/chicken_ext_test_runme.ss +++ /dev/null @@ -1,5 +0,0 @@ -(load "chicken_ext_test.so") - -(define a (test-create)) - -(A-hello a) diff --git a/Examples/test-suite/chicken/class_ignore_runme.ss b/Examples/test-suite/chicken/class_ignore_runme.ss deleted file mode 100644 index ba84810a3..000000000 --- a/Examples/test-suite/chicken/class_ignore_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "class_ignore.so") -(include "../schemerunme/class_ignore.scm") diff --git a/Examples/test-suite/chicken/clientdata_prop_runme_proxy.ss b/Examples/test-suite/chicken/clientdata_prop_runme_proxy.ss deleted file mode 100644 index 62f2c2053..000000000 --- a/Examples/test-suite/chicken/clientdata_prop_runme_proxy.ss +++ /dev/null @@ -1,95 +0,0 @@ -(require 'clientdata_prop_a) -(require 'clientdata_prop_b) - -(define a (make <A>)) -(test-A a) -(test-tA a) -(test-t2A a) -(test-t3A a) -(fA a) - -(define b (make <B>)) -(test-A b) -(test-tA b) -(test-t2A b) -(test-t3A b) -(test-B b) -(fA b) -(fB b) - -(define c (make <C>)) -(test-A c) -(test-tA c) -(test-t2A c) -(test-t3A c) -(test-C c) -(fA c) -(fC c) - -(define d (make <D>)) -(test-A d) -(test-tA d) -(test-t2A d) -(test-t3A d) -(test-D d) -(test-tD d) -(test-t2D d) -(fA d) -(fD d) - -;; here are the real tests... if the clientdata is correctly -;; propegated, new-tA, new-t2A, should all return wrapped proxy's -;; of class <A> - -(define a2 (new-tA)) -(if (not (eq? (class-of a2) <A>)) - (error "Error 1")) -(test-A a2) -(test-tA a2) -(test-t2A a2) -(test-t3A a2) -(fA a2) - -(define a3 (new-t2A)) -(if (not (eq? (class-of a3) <A>)) - (error "Error 2")) -(test-A a3) -(test-tA a3) -(test-t2A a3) -(test-t3A a3) -(fA a3) - -(define a4 (new-t3A)) -(if (not (eq? (class-of a4) <A>)) - (error "Error 3")) -(test-A a4) -(test-tA a4) -(test-t2A a4) -(test-t3A a4) -(fA a4) - -(define d2 (new-tD)) -(if (not (eq? (class-of d2) <D>)) - (error "Error 4")) -(test-A d2) -(test-tA d2) -(test-t2A d2) -(test-t3A d2) -(test-D d2) -(test-tD d2) -(fA d2) -(fD d2) - -(define d3 (new-t2D)) -(if (not (eq? (class-of d3) <D>)) - (error "Error 5")) -(test-A d3) -(test-tA d3) -(test-t2A d3) -(test-t3A d3) -(test-D d3) -(test-tD d3) -(fA d3) -(fD d3) - -(exit 0) diff --git a/Examples/test-suite/chicken/constover_runme.ss b/Examples/test-suite/chicken/constover_runme.ss deleted file mode 100644 index eb39c7ff0..000000000 --- a/Examples/test-suite/chicken/constover_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "constover.so") -(include "../schemerunme/constover.scm") diff --git a/Examples/test-suite/chicken/contract_runme.ss b/Examples/test-suite/chicken/contract_runme.ss deleted file mode 100644 index 006bcfdec..000000000 --- a/Examples/test-suite/chicken/contract_runme.ss +++ /dev/null @@ -1,3 +0,0 @@ -(load "contract.so") -(include "testsuite.ss") -(include "../schemerunme/contract.scm") diff --git a/Examples/test-suite/chicken/cpp_basic_runme_proxy.ss b/Examples/test-suite/chicken/cpp_basic_runme_proxy.ss deleted file mode 100644 index 7b0b6d722..000000000 --- a/Examples/test-suite/chicken/cpp_basic_runme_proxy.ss +++ /dev/null @@ -1,64 +0,0 @@ -(require 'cpp_basic) - -(define-macro (check test) - `(if (not ,test) (error "Error in test " ',test))) - -(define f (make <Foo> 4)) -(check (= (slot-ref f 'num) 4)) -(slot-set! f 'num -17) -(check (= (slot-ref f 'num) -17)) - -(define b (make <Bar>)) - -(slot-set! b 'fptr f) -(check (= (slot-ref (slot-ref b 'fptr) 'num) -17)) -(check (= (test b -3 (slot-ref b 'fptr)) -5)) -(slot-set! f 'num 12) -(check (= (slot-ref (slot-ref b 'fptr) 'num) 12)) - -(check (= (slot-ref (slot-ref b 'fref) 'num) -4)) -(check (= (test b 12 (slot-ref b 'fref)) 23)) -;; references don't take ownership, so if we didn't define this here it might get garbage collected -(define f2 (make <Foo> 23)) -(slot-set! b 'fref f2) -(check (= (slot-ref (slot-ref b 'fref) 'num) 23)) -(check (= (test b -3 (slot-ref b 'fref)) 35)) - -(check (= (slot-ref (slot-ref b 'fval) 'num) 15)) -(check (= (test b 3 (slot-ref b 'fval)) 33)) -(slot-set! b 'fval (make <Foo> -15)) -(check (= (slot-ref (slot-ref b 'fval) 'num) -15)) -(check (= (test b 3 (slot-ref b 'fval)) -27)) - -(define f3 (testFoo b 12 (slot-ref b 'fref))) -(check (= (slot-ref f3 'num) 32)) - -;; now test global -(define f4 (make <Foo> 6)) -(Bar-global-fptr f4) -(check (= (slot-ref (Bar-global-fptr) 'num) 6)) -(slot-set! f4 'num 8) -(check (= (slot-ref (Bar-global-fptr) 'num) 8)) - -(check (= (slot-ref (Bar-global-fref) 'num) 23)) -(Bar-global-fref (make <Foo> -7)) -(check (= (slot-ref (Bar-global-fref) 'num) -7)) - -(check (= (slot-ref (Bar-global-fval) 'num) 3)) -(Bar-global-fval (make <Foo> -34)) -(check (= (slot-ref (Bar-global-fval) 'num) -34)) - -;; Now test function pointers -(define func1ptr (get-func1-ptr)) -(define func2ptr (get-func2-ptr)) - -(slot-set! f 'num 4) -(check (= (func1 f 2) 16)) -(check (= (func2 f 2) -8)) - -(slot-set! f 'func-ptr func1ptr) -(check (= (test-func-ptr f 2) 16)) -(slot-set! f 'func-ptr func2ptr) -(check (= (test-func-ptr f 2) -8)) - -(exit 0) diff --git a/Examples/test-suite/chicken/cpp_enum_runme.ss b/Examples/test-suite/chicken/cpp_enum_runme.ss deleted file mode 100644 index 4d4ec7623..000000000 --- a/Examples/test-suite/chicken/cpp_enum_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "cpp_enum.so") -(include "../schemerunme/cpp_enum.scm") diff --git a/Examples/test-suite/chicken/cpp_namespace_runme.ss b/Examples/test-suite/chicken/cpp_namespace_runme.ss deleted file mode 100644 index 800172ed8..000000000 --- a/Examples/test-suite/chicken/cpp_namespace_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "cpp_namespace.so") -(include "../schemerunme/cpp_namespace.scm") diff --git a/Examples/test-suite/chicken/dynamic_cast_runme.ss b/Examples/test-suite/chicken/dynamic_cast_runme.ss deleted file mode 100644 index 1e81d5555..000000000 --- a/Examples/test-suite/chicken/dynamic_cast_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "dynamic_cast.so") -(include "../schemerunme/dynamic_cast.scm") diff --git a/Examples/test-suite/chicken/global_vars_runme.ss b/Examples/test-suite/chicken/global_vars_runme.ss deleted file mode 100644 index 802205b7c..000000000 --- a/Examples/test-suite/chicken/global_vars_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(require 'global_vars) -(load "../schemerunme/global_vars.scm") diff --git a/Examples/test-suite/chicken/global_vars_runme_proxy.ss b/Examples/test-suite/chicken/global_vars_runme_proxy.ss deleted file mode 100644 index 3c4500d6b..000000000 --- a/Examples/test-suite/chicken/global_vars_runme_proxy.ss +++ /dev/null @@ -1,2 +0,0 @@ -(require 'global_vars) -(load "../schemerunme/global_vars_proxy.scm") diff --git a/Examples/test-suite/chicken/import_nomodule_runme.ss b/Examples/test-suite/chicken/import_nomodule_runme.ss deleted file mode 100644 index 7e64053bc..000000000 --- a/Examples/test-suite/chicken/import_nomodule_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "import_nomodule.so") -(include "../schemerunme/import_nomodule.scm") diff --git a/Examples/test-suite/chicken/imports_runme.ss b/Examples/test-suite/chicken/imports_runme.ss deleted file mode 100644 index ac5fb9890..000000000 --- a/Examples/test-suite/chicken/imports_runme.ss +++ /dev/null @@ -1,3 +0,0 @@ -(load "imports_a.so") -(load "imports_b.so") -(include "../schemerunme/imports.scm") diff --git a/Examples/test-suite/chicken/inherit_missing_runme.ss b/Examples/test-suite/chicken/inherit_missing_runme.ss deleted file mode 100644 index 50a084a95..000000000 --- a/Examples/test-suite/chicken/inherit_missing_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "inherit_missing.so") -(include "../schemerunme/inherit_missing.scm") diff --git a/Examples/test-suite/chicken/li_std_string_runme.ss b/Examples/test-suite/chicken/li_std_string_runme.ss deleted file mode 100644 index cc64287dd..000000000 --- a/Examples/test-suite/chicken/li_std_string_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "li_std_string.so") -(include "../schemerunme/li_std_string.scm") diff --git a/Examples/test-suite/chicken/li_std_string_runme_proxy.ss b/Examples/test-suite/chicken/li_std_string_runme_proxy.ss deleted file mode 100644 index e1e240970..000000000 --- a/Examples/test-suite/chicken/li_std_string_runme_proxy.ss +++ /dev/null @@ -1,47 +0,0 @@ -(load "li_std_string.so") - -(define x "hello") - -(if (not (string=? (test-value x) x)) - (begin (error "Error 1") (exit 1))) - -(if (not (string=? (test-const-reference x) x)) - (begin (error "Error 2") (exit 1))) - -(define y (test-pointer-out)) -(test-pointer y) -(define z (test-const-pointer-out)) -(test-const-pointer z) - -(define a (test-reference-out)) -(test-reference a) - -;; test global variables -(GlobalString "whee") -(if (not (string=? (GlobalString) "whee")) - (error "Error 3")) -(if (not (string=? (GlobalString2) "global string 2")) - (error "Error 4")) - -(define struct (make <Structure>)) - -;; MemberString should be a wrapped class -(if (not (string=? (slot-ref struct 'MemberString) "")) - (error "Error 4.5")) -;(slot-set! (slot-ref struct 'MemberString) "and how") -;;(if (not (string=? (slot-ref struct 'MemberString) "and how")) -;; (error "Error 5")) -(if (not (string=? (slot-ref struct 'MemberString2) "member string 2")) - (error "Error 6")) -(Structure-StaticMemberString "static str") -(if (not (string=? (Structure-StaticMemberString) "static str")) - (error "Error 7")) -(if (not (string=? (Structure-StaticMemberString2) "static member string 2")) - (error "Error 8")) - -;(if (not (string=? (Structure-ConstMemberString-get struct) "const member string")) -; (error "Error 9")) -(if (not (string=? (Structure-ConstStaticMemberString) "const static member string")) - (error "Error 10")) - -(exit 0) diff --git a/Examples/test-suite/chicken/li_typemaps_runme.ss b/Examples/test-suite/chicken/li_typemaps_runme.ss deleted file mode 100644 index 1ad6e921e..000000000 --- a/Examples/test-suite/chicken/li_typemaps_runme.ss +++ /dev/null @@ -1,12 +0,0 @@ -(require 'li_typemaps) -(load "../schemerunme/li_typemaps.scm") - -(call-with-values (lambda () (inoutr-int2 3 -2)) - (lambda (a b) - (if (not (and (= a 3) (= b -2))) - (error "Error in inoutr-int2")))) -(call-with-values (lambda () (out-foo 4)) - (lambda (a b) - (if (not (and (= (Foo-a-get a) 4) (= b 8))) - (error "Error in out-foo")))) -(exit 0) diff --git a/Examples/test-suite/chicken/li_typemaps_runme_proxy.ss b/Examples/test-suite/chicken/li_typemaps_runme_proxy.ss deleted file mode 100644 index 52997c6fe..000000000 --- a/Examples/test-suite/chicken/li_typemaps_runme_proxy.ss +++ /dev/null @@ -1,13 +0,0 @@ -(require 'li_typemaps) -(load "../schemerunme/li_typemaps_proxy.scm") - -(call-with-values (lambda () (inoutr-int2 3 -2)) - (lambda (a b) - (if (not (and (= a 3) (= b -2))) - (error "Error in inoutr-int2")))) -(call-with-values (lambda () (out-foo 4)) - (lambda (a b) - (if (not (and (= (slot-ref a 'a) 4) (= b 8))) - (error "Error in out-foo")))) - -(exit 0) diff --git a/Examples/test-suite/chicken/list_vector_runme.ss b/Examples/test-suite/chicken/list_vector_runme.ss deleted file mode 100644 index 67d52f609..000000000 --- a/Examples/test-suite/chicken/list_vector_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "list_vector.so") -(include "../schemerunme/list_vector.scm") diff --git a/Examples/test-suite/chicken/member_pointer_runme.ss b/Examples/test-suite/chicken/member_pointer_runme.ss deleted file mode 100644 index f2226b20a..000000000 --- a/Examples/test-suite/chicken/member_pointer_runme.ss +++ /dev/null @@ -1,28 +0,0 @@ -(require 'member_pointer) - -(define (check-eq? msg expected actual) - (if (not (= expected actual)) - (error "Error " msg ": expected " expected " got " actual))) - -(define area-pt (areapt)) -(define perim-pt (perimeterpt)) - -(define s (new-Square 10)) - -(check-eq? "Square area" 100.0 (do-op s area-pt)) -(check-eq? "Square perim" 40.0 (do-op s perim-pt)) - -(check-eq? "Square area" 100.0 (do-op s (areavar))) -(check-eq? "Square perim" 40.0 (do-op s (perimetervar))) - -;; Set areavar to return value of function -(areavar perim-pt) -(check-eq? "Square perim" 40 (do-op s (areavar))) - -(check-eq? "Square area" 100.0 (do-op s (AREAPT))) -(check-eq? "Square perim" 40.0 (do-op s (PERIMPT))) - -(define test (NULLPT)) - -(perimetervar (AREAPT)) -(check-eq? "Square area" 100.0 (do-op s (perimetervar))) diff --git a/Examples/test-suite/chicken/multiple_inheritance_runme_proxy.ss b/Examples/test-suite/chicken/multiple_inheritance_runme_proxy.ss deleted file mode 100644 index 313157c70..000000000 --- a/Examples/test-suite/chicken/multiple_inheritance_runme_proxy.ss +++ /dev/null @@ -1,2 +0,0 @@ -(require 'multiple_inheritance) -(load "../schemerunme/multiple_inheritance_proxy.scm") diff --git a/Examples/test-suite/chicken/multivalue_runme.ss b/Examples/test-suite/chicken/multivalue_runme.ss deleted file mode 100644 index f5aafcbf4..000000000 --- a/Examples/test-suite/chicken/multivalue_runme.ss +++ /dev/null @@ -1,4 +0,0 @@ -;; this doesn't work yet :( -(load "multivalue.so") -(include "../schemerunme/multivalue.scm") -(exit 0) diff --git a/Examples/test-suite/chicken/name_runme.ss b/Examples/test-suite/chicken/name_runme.ss deleted file mode 100644 index 938915dcb..000000000 --- a/Examples/test-suite/chicken/name_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "name.so") -(include "../schemerunme/name.scm") diff --git a/Examples/test-suite/chicken/newobject1_runme_proxy.ss b/Examples/test-suite/chicken/newobject1_runme_proxy.ss deleted file mode 100644 index 7bc5a241a..000000000 --- a/Examples/test-suite/chicken/newobject1_runme_proxy.ss +++ /dev/null @@ -1,30 +0,0 @@ -(require 'newobject1) - -(define-macro (check-count val) - `(if (not (= (Foo-fooCount) ,val)) (error "Error checking val " ,val " != " ,(Foo-fooCount)))) - -(define f (Foo-makeFoo)) - -(check-count 1) - -(define f2 (makeMore f)) - -(check-count 2) - -(set! f #f) -(gc #t) - -(check-count 1) - -(define f3 (makeMore f2)) - -(check-count 2) - -(set! f3 #f) -(set! f2 #f) - -(gc #t) - -(check-count 0) - -(exit 0) diff --git a/Examples/test-suite/chicken/newobject2_runme.ss b/Examples/test-suite/chicken/newobject2_runme.ss deleted file mode 100644 index cc445f477..000000000 --- a/Examples/test-suite/chicken/newobject2_runme.ss +++ /dev/null @@ -1,29 +0,0 @@ -(load "newobject2.so") - -(define f (new-Foo)) - -(Foo-dummy-set f 14) -(if (not (= (Foo-dummy-get f) 14)) - (error "Bad dummy value")) - -(if (not (= (fooCount) 0)) - (error "Bad foo count 1")) - -(define f2 (makeFoo)) - -(if (not (= (fooCount) 1)) - (error "Bad foo count 2")) - -(Foo-dummy-set f2 16) -(if (not (= (Foo-dummy-get f2) 16)) - (error "Bad dummy value for f2")) - -(set! f #f) -(set! f2 #f) - -(gc #t) - -(if (not (= (fooCount) -1)) - (error "Bad foo count 3")) - -(exit 0) diff --git a/Examples/test-suite/chicken/newobject2_runme_proxy.ss b/Examples/test-suite/chicken/newobject2_runme_proxy.ss deleted file mode 100644 index 36b8cda7f..000000000 --- a/Examples/test-suite/chicken/newobject2_runme_proxy.ss +++ /dev/null @@ -1,29 +0,0 @@ -(load "newobject2.so") - -(define f (make <Foo>)) - -(slot-set! f 'dummy 14) -(if (not (= (slot-ref f 'dummy) 14)) - (error "Bad dummy value")) - -(if (not (= (fooCount) 0)) - (error "Bad foo count 1")) - -(define f2 (makeFoo)) - -(if (not (= (fooCount) 1)) - (error "Bad foo count 2")) - -(slot-set! f2 'dummy 16) -(if (not (= (slot-ref f2 'dummy) 16)) - (error "Bad dummy value for f2")) - -(set! f #f) -(set! f2 #f) - -(gc #t) - -(if (not (= (fooCount) -1)) - (error "Bad foo count 3")) - -(exit 0) diff --git a/Examples/test-suite/chicken/overload_complicated_runme.ss b/Examples/test-suite/chicken/overload_complicated_runme.ss deleted file mode 100644 index f89f70bde..000000000 --- a/Examples/test-suite/chicken/overload_complicated_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "overload_complicated.so") -(include "../schemerunme/overload_complicated.scm") diff --git a/Examples/test-suite/chicken/overload_copy_runme.ss b/Examples/test-suite/chicken/overload_copy_runme.ss deleted file mode 100644 index 4ec542205..000000000 --- a/Examples/test-suite/chicken/overload_copy_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "overload_copy.so") -(include "../schemerunme/overload_copy.scm") diff --git a/Examples/test-suite/chicken/overload_copy_runme_proxy.ss b/Examples/test-suite/chicken/overload_copy_runme_proxy.ss deleted file mode 100644 index 5f4808070..000000000 --- a/Examples/test-suite/chicken/overload_copy_runme_proxy.ss +++ /dev/null @@ -1,6 +0,0 @@ -(load "./overload_copy.so") - -(define f (make <Foo>)) -(define g (make <Foo> f)) - -(exit 0) diff --git a/Examples/test-suite/chicken/overload_extend_c_runme.ss b/Examples/test-suite/chicken/overload_extend_c_runme.ss deleted file mode 100644 index 75c0ea8a8..000000000 --- a/Examples/test-suite/chicken/overload_extend_c_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "overload_extend_c.so") -(include "../schemerunme/overload_extend_c.scm") diff --git a/Examples/test-suite/chicken/overload_extend_runme.ss b/Examples/test-suite/chicken/overload_extend_runme.ss deleted file mode 100644 index a19cb29a9..000000000 --- a/Examples/test-suite/chicken/overload_extend_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "overload_extend.so") -(include "../schemerunme/overload_extend.scm") diff --git a/Examples/test-suite/chicken/overload_extend_runme_proxy.ss b/Examples/test-suite/chicken/overload_extend_runme_proxy.ss deleted file mode 100644 index 2a6867e22..000000000 --- a/Examples/test-suite/chicken/overload_extend_runme_proxy.ss +++ /dev/null @@ -1,14 +0,0 @@ -(load "./overload_extend.so") - -(define f (make <Foo>)) - -(if (not (= (test f 3) 1)) - (error "test integer bad")) - -(if (not (= (test f "hello") 2)) - (error "test string bad")) - -(if (not (= (test f 3.5 2.5) 6.0)) - (error "test reals bad")) - -(exit 0) diff --git a/Examples/test-suite/chicken/overload_simple_runme.ss b/Examples/test-suite/chicken/overload_simple_runme.ss deleted file mode 100644 index 24fa67aec..000000000 --- a/Examples/test-suite/chicken/overload_simple_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "overload_simple.so") -(include "../schemerunme/overload_simple.scm") diff --git a/Examples/test-suite/chicken/overload_simple_runme_proxy.ss b/Examples/test-suite/chicken/overload_simple_runme_proxy.ss deleted file mode 100644 index 0ae3e6215..000000000 --- a/Examples/test-suite/chicken/overload_simple_runme_proxy.ss +++ /dev/null @@ -1,56 +0,0 @@ -(load "overload_simple.so") - -(define-macro (check test) - `(if (not ,test) (error ',test))) - -(check (string=? (foo) "foo:")) -(check (string=? (foo 3) "foo:int")) -(check (string=? (foo 3.01) "foo:double")) -(check (string=? (foo "hey") "foo:char *")) - -(define f (make <Foo>)) -(define b (make <Bar>)) -(define b2 (make <Bar> 3)) - -(check (= (slot-ref b 'num) 0)) -(check (= (slot-ref b2 'num) 3)) - -(check (string=? (foo f) "foo:Foo *")) -(check (string=? (foo b) "foo:Bar *")) -(check (string=? (foo f 3) "foo:Foo *,int")) -(check (string=? (foo 3.2 b) "foo:double,Bar *")) - -;; now check blah -(check (string=? (blah 2.01) "blah:double")) -(check (string=? (blah "hey") "blah:char *")) - -;; now check spam member functions -(define s (make <Spam>)) -(define s2 (make <Spam> 3)) -(define s3 (make <Spam> 3.2)) -(define s4 (make <Spam> "whee")) -(define s5 (make <Spam> f)) -(define s6 (make <Spam> b)) - -(check (string=? (slot-ref s 'type) "none")) -(check (string=? (slot-ref s2 'type) "int")) -(check (string=? (slot-ref s3 'type) "double")) -(check (string=? (slot-ref s4 'type) "char *")) -(check (string=? (slot-ref s5 'type) "Foo *")) -(check (string=? (slot-ref s6 'type) "Bar *")) - -;; now check Spam member functions -(check (string=? (foo s 2) "foo:int")) -(check (string=? (foo s 2.1) "foo:double")) -(check (string=? (foo s "hey") "foo:char *")) -(check (string=? (foo s f) "foo:Foo *")) -(check (string=? (foo s b) "foo:Bar *")) - -;; check static member funcs -(check (string=? (Spam-bar 3) "bar:int")) -(check (string=? (Spam-bar 3.2) "bar:double")) -(check (string=? (Spam-bar "hey") "bar:char *")) -(check (string=? (Spam-bar f) "bar:Foo *")) -(check (string=? (Spam-bar b) "bar:Bar *")) - -(exit 0) diff --git a/Examples/test-suite/chicken/overload_subtype_runme.ss b/Examples/test-suite/chicken/overload_subtype_runme.ss deleted file mode 100644 index b3663b719..000000000 --- a/Examples/test-suite/chicken/overload_subtype_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "overload_subtype.so") -(include "../schemerunme/overload_subtype.scm") diff --git a/Examples/test-suite/chicken/overload_subtype_runme_proxy.ss b/Examples/test-suite/chicken/overload_subtype_runme_proxy.ss deleted file mode 100644 index d83d59a11..000000000 --- a/Examples/test-suite/chicken/overload_subtype_runme_proxy.ss +++ /dev/null @@ -1,12 +0,0 @@ -(load "./overload_subtype.so") - -(define f (make <Foo>)) -(define b (make <Bar>)) - -(if (not (= (spam f) 1)) - (error "Error in foo")) - -(if (not (= (spam b) 2)) - (error "Error in bar")) - -(exit 0) diff --git a/Examples/test-suite/chicken/pointer_in_out_runme.ss b/Examples/test-suite/chicken/pointer_in_out_runme.ss deleted file mode 100644 index 807c4ebad..000000000 --- a/Examples/test-suite/chicken/pointer_in_out_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "pointer_in_out.so") -(include "../schemerunme/pointer_in_out.scm") diff --git a/Examples/test-suite/chicken/reference_global_vars_runme.ss b/Examples/test-suite/chicken/reference_global_vars_runme.ss deleted file mode 100644 index 1e1914be3..000000000 --- a/Examples/test-suite/chicken/reference_global_vars_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "reference_global_vars.so") -(include "../schemerunme/reference_global_vars.scm") diff --git a/Examples/test-suite/chicken/testsuite.ss b/Examples/test-suite/chicken/testsuite.ss deleted file mode 100644 index e1152a6fe..000000000 --- a/Examples/test-suite/chicken/testsuite.ss +++ /dev/null @@ -1,12 +0,0 @@ -(define (lookup-ext-tag tag) - (cond - ((equal? tag '(quote swig-contract-assertion-failed)) - '( ((exn type) #f)) ) - (#t '()))) - -(define-macro (expect-throw tag-form form) - `(if (condition-case (begin ,form #t) - ,@(lookup-ext-tag tag-form) - ((exn) (print "The form threw a different error than expected: " ',form) (exit 1)) - (var () (print "The form did not error as expected: " ',form) (exit 1))) - (begin (print "The form returned normally when it was expected to throw an error: " ',form) (exit 1)))) diff --git a/Examples/test-suite/chicken/throw_exception_runme.ss b/Examples/test-suite/chicken/throw_exception_runme.ss deleted file mode 100644 index 62bc7befb..000000000 --- a/Examples/test-suite/chicken/throw_exception_runme.ss +++ /dev/null @@ -1,29 +0,0 @@ -(load "throw_exception.so") - -(define-macro (check-throw expr check) - `(if (handle-exceptions exvar (if ,check #f (begin (print "Error executing: " ',expr " " exvar) (exit 1))) ,expr #t) - (print "Expression did not throw an error: " ',expr))) - -(define f (new-Foo)) - -(check-throw (Foo-test-int f) (= exvar 37)) -(check-throw (Foo-test-msg f) (string=? exvar "Dead")) -(check-throw (Foo-test-cls f) (test-is-Error exvar)) -(check-throw (Foo-test-cls-ptr f) (test-is-Error exvar)) -(check-throw (Foo-test-cls-ref f) (test-is-Error exvar)) -(check-throw (Foo-test-cls-td f) (test-is-Error exvar)) -(check-throw (Foo-test-cls-ptr-td f) (test-is-Error exvar)) -(check-throw (Foo-test-cls-ref-td f) (test-is-Error exvar)) -(check-throw (Foo-test-enum f) (= exvar (enum2))) - -; don't know how to test this... it is returning a SWIG wrapped int * -;(check-throw (Foo-test-array f) (equal? exvar '(0 1 2 3 4 5 6 7 8 9))) - -(check-throw (Foo-test-multi f 1) (= exvar 37)) -(check-throw (Foo-test-multi f 2) (string=? exvar "Dead")) -(check-throw (Foo-test-multi f 3) (test-is-Error exvar)) - -(set! f #f) -(gc #t) - -(exit 0) diff --git a/Examples/test-suite/chicken/typedef_inherit_runme.ss b/Examples/test-suite/chicken/typedef_inherit_runme.ss deleted file mode 100644 index 111296d60..000000000 --- a/Examples/test-suite/chicken/typedef_inherit_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "typedef_inherit.so") -(include "../schemerunme/typedef_inherit.scm") diff --git a/Examples/test-suite/chicken/typename_runme.ss b/Examples/test-suite/chicken/typename_runme.ss deleted file mode 100644 index 60fc3203b..000000000 --- a/Examples/test-suite/chicken/typename_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "typename.so") -(include "../schemerunme/typename.scm") diff --git a/Examples/test-suite/chicken/unions_runme.ss b/Examples/test-suite/chicken/unions_runme.ss deleted file mode 100644 index 465784a43..000000000 --- a/Examples/test-suite/chicken/unions_runme.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "unions.so") -(include "../schemerunme/unions.scm") diff --git a/Examples/test-suite/chicken/unions_runme_proxy.ss b/Examples/test-suite/chicken/unions_runme_proxy.ss deleted file mode 100644 index 4dd14148d..000000000 --- a/Examples/test-suite/chicken/unions_runme_proxy.ss +++ /dev/null @@ -1,2 +0,0 @@ -(load "unions.so") -(include "../schemerunme/unions_proxy.scm") diff --git a/Examples/test-suite/chicken_ext_test.i b/Examples/test-suite/chicken_ext_test.i deleted file mode 100644 index b4f726cc7..000000000 --- a/Examples/test-suite/chicken_ext_test.i +++ /dev/null @@ -1,21 +0,0 @@ -%module chicken_ext_test - -/* just use the imports_a.h header... for this test we only need a class */ -%{ -#include "imports_a.h" -%} - -%include "imports_a.h" - -%{ -void test_create(C_word,C_word,C_word) C_noret; -%} - -%init %{ - { - C_word *space = C_alloc(2 + C_SIZEOF_INTERNED_SYMBOL(11)); - sym = C_intern (&space, 11, "test-create"); - C_mutate ((C_word*)sym+1, (*space=C_CLOSURE_TYPE|1, space[1]=(C_word)test_create, tmp=(C_word)space, space+=2, tmp)); - } -%} - diff --git a/Examples/test-suite/clisp/Makefile.in b/Examples/test-suite/clisp/Makefile.in deleted file mode 100644 index 3d207178f..000000000 --- a/Examples/test-suite/clisp/Makefile.in +++ /dev/null @@ -1,51 +0,0 @@ -####################################################################### -# Makefile for clisp test-suite -####################################################################### - -LANGUAGE = clisp -CLISP = @CLISPBIN@ -SCRIPTSUFFIX = _runme.lisp - -srcdir = @srcdir@ -top_srcdir = @top_srcdir@ -top_builddir = @top_builddir@ - -include $(srcdir)/../common.mk - -# Overridden variables here -# no C++ tests for now -CPP_TEST_CASES = -#C_TEST_CASES += - -# Custom tests - tests with additional commandline options -# none! - -# Rules for the different types of tests -%.cpptest: - $(setup) - +$(swig_and_compile_cpp) - $(run_testcase) - -%.ctest: - $(setup) - +$(swig_and_compile_c) - $(run_testcase) - -%.multicpptest: - $(setup) - +$(swig_and_compile_multi_cpp) - $(run_testcase) - -# Runs the testcase. A testcase is only run if -# a file is found which has _runme.lisp appended after the testcase name. -run_testcase = \ - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ - env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(CLISP) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ - fi - -# Clean: (does nothing, we dont generate extra clisp code) -%.clean: - @exit 0 - -clean: - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' clisp_clean diff --git a/Examples/test-suite/common.mk b/Examples/test-suite/common.mk index be3453df7..5a44980cc 100644 --- a/Examples/test-suite/common.mk +++ b/Examples/test-suite/common.mk @@ -330,7 +330,7 @@ CPP_TEST_CASES += \ nested_ignore \ nested_inheritance_interface \ nested_in_template \ - nested_scope \ + nested_scope_flat \ nested_template_base \ nested_workaround \ newobject1 \ @@ -418,6 +418,7 @@ CPP_TEST_CASES += \ struct_value \ swig_exception \ symbol_clash \ + sym \ template_arg_replace \ template_arg_scope \ template_arg_typename \ @@ -460,6 +461,7 @@ CPP_TEST_CASES += \ template_using_directive_and_declaration_forward \ template_using_directive_typedef \ template_nested \ + template_nested_flat \ template_nested_typemaps \ template_ns \ template_ns2 \ @@ -675,7 +677,7 @@ ifndef SKIP_CPP_STD_CASES CPP_TEST_CASES += ${CPP_STD_TEST_CASES} endif -ifneq (,$(HAVE_CXX11_COMPILER)) +ifeq (1,$(HAVE_CXX11)) CPP_TEST_CASES += $(CPP11_TEST_CASES) endif @@ -859,8 +861,6 @@ setup = \ echo "$(ACTION)ing $(LANGUAGE) testcase $*" ; \ fi - - ####################################################################### # Clean ####################################################################### diff --git a/Examples/test-suite/cpp11_final_override.i b/Examples/test-suite/cpp11_final_override.i index c31ae73b6..849655b16 100644 --- a/Examples/test-suite/cpp11_final_override.i +++ b/Examples/test-suite/cpp11_final_override.i @@ -90,7 +90,7 @@ struct FinalOverrideMethods { virtual void override(int) {} virtual ~FinalOverrideMethods() = default; }; -struct FinalOverrideVariables { +struct FinalOverrideVars { int final; double override; }; diff --git a/Examples/test-suite/cpp11_lambda_functions.i b/Examples/test-suite/cpp11_lambda_functions.i index 3d7d76d60..0096eef11 100644 --- a/Examples/test-suite/cpp11_lambda_functions.i +++ b/Examples/test-suite/cpp11_lambda_functions.i @@ -56,7 +56,7 @@ auto lambda4 = [](int x, int y) { return x+y; }; auto lambda5 = []() { return thing; }; #endif -void fn() { +void fn1() { int stuff = 0; auto lambdaxxxx = [=,&stuff]() { return thing; }; } diff --git a/Examples/test-suite/cpp11_raw_string_literals.i b/Examples/test-suite/cpp11_raw_string_literals.i index b50b768b9..813374928 100644 --- a/Examples/test-suite/cpp11_raw_string_literals.i +++ b/Examples/test-suite/cpp11_raw_string_literals.i @@ -21,6 +21,11 @@ %include <std_wstring.i> #endif +#if defined(SWIGLUA) +// Lua uses a parameter called L in every wrapper function +%ignore L; +#endif + %inline %{ #include <iostream> #include <string> diff --git a/Examples/test-suite/cpp11_rvalue_reference3.i b/Examples/test-suite/cpp11_rvalue_reference3.i index 8ebf45366..55a55bac9 100644 --- a/Examples/test-suite/cpp11_rvalue_reference3.i +++ b/Examples/test-suite/cpp11_rvalue_reference3.i @@ -24,19 +24,19 @@ void takeit3(Thing const*&& t) {} void takeit4(Thing *const&& t) {} void takeit5(Thing const*const&& t) {} -struct Containing { - Thing && member_rvalue_ref; - Thing *&& member_rvalue_ref_ptr1; - Thing const*&& member_rvalue_ref_ptr2; - Thing *const&& member_rvalue_ref_ptr3; - Thing const*const &&member_rvalue_ref_ptr4; +struct Contain { + Thing && m_ref; + Thing *&& m_ref_ptr1; + Thing const*&& m_ref_ptr2; + Thing *const&& m_ref_ptr3; + Thing const*const &&m_ref_ptr4; - Containing(Thing&&r, Thing*&& r1, Thing const*&& r2, Thing *const&& r3, Thing const*const && r4) : - member_rvalue_ref(std::move(r)), - member_rvalue_ref_ptr1(std::move(r1)), - member_rvalue_ref_ptr2(std::move(r2)), - member_rvalue_ref_ptr3(std::move(r3)), - member_rvalue_ref_ptr4(std::move(r4)) + Contain(Thing&&r, Thing*&& r1, Thing const*&& r2, Thing *const&& r3, Thing const*const && r4) : + m_ref(std::move(r)), + m_ref_ptr1(std::move(r1)), + m_ref_ptr2(std::move(r2)), + m_ref_ptr3(std::move(r3)), + m_ref_ptr4(std::move(r4)) {} }; %} @@ -61,19 +61,19 @@ void int_takeit3(int const*&& t) {} void int_takeit4(int *const&& t) {} void int_takeit5(int const*const&& t) {} -struct IntContaining { - int && member_rvalue_ref; - int *&& member_rvalue_ref_ptr1; - int const*&& member_rvalue_ref_ptr2; - int *const&& member_rvalue_ref_ptr3; - int const*const &&member_rvalue_ref_ptr4; +struct IContain { + int && m_ref; + int *&& m_ref_ptr1; + int const*&& m_ref_ptr2; + int *const&& m_ref_ptr3; + int const*const &&m_ref_ptr4; - IntContaining(int&& r, int*&& r1, int const*&& r2, int *const&& r3, int const*const && r4) : - member_rvalue_ref(std::move(r)), - member_rvalue_ref_ptr1(std::move(r1)), - member_rvalue_ref_ptr2(std::move(r2)), - member_rvalue_ref_ptr3(std::move(r3)), - member_rvalue_ref_ptr4(std::move(r4)) + IContain(int&& r, int*&& r1, int const*&& r2, int *const&& r3, int const*const && r4) : + m_ref(std::move(r)), + m_ref_ptr1(std::move(r1)), + m_ref_ptr2(std::move(r2)), + m_ref_ptr3(std::move(r3)), + m_ref_ptr4(std::move(r4)) {} }; %} diff --git a/Examples/test-suite/cpp11_template_double_brackets.i b/Examples/test-suite/cpp11_template_double_brackets.i index ba5caa5c5..d7522c9f0 100644 --- a/Examples/test-suite/cpp11_template_double_brackets.i +++ b/Examples/test-suite/cpp11_template_double_brackets.i @@ -1,5 +1,5 @@ /* This interface checks whether SWIG supports the new double angled brackets - in the template syntax without having a space inbetween. This feature was + in the template syntax without having a space in between. This feature was introduced in new C++11 standard. */ %module cpp11_template_double_brackets diff --git a/Examples/test-suite/cpp11_type_aliasing.i b/Examples/test-suite/cpp11_type_aliasing.i index abc1642c4..ea4048408 100644 --- a/Examples/test-suite/cpp11_type_aliasing.i +++ b/Examples/test-suite/cpp11_type_aliasing.i @@ -63,12 +63,14 @@ using IntArray = Int[]; // Test that SWIG understands these new types +%{ +Int mult2(Int x) { return x * 2; } +%} %callback("%s_cb"); Int mult2(Int x); %nocallback; %inline %{ -Int mult2(Int x) { return x * 2; } IntPtr allocate_int() { return new Int(12); } void free_int(int* ptr) { delete ptr; } void inplace_mult2(IntRef x) { x *= 2; } diff --git a/Examples/test-suite/cpp_basic.i b/Examples/test-suite/cpp_basic.i index a228af289..f2537e109 100644 --- a/Examples/test-suite/cpp_basic.i +++ b/Examples/test-suite/cpp_basic.i @@ -1,4 +1,4 @@ -/* This is a basic test of proxy classes, used by chicken */ +/* This is a basic test of proxy classes */ %warnfilter(SWIGWARN_TYPEMAP_SWIGTYPELEAK); /* memory leak when setting a ptr/ref variable */ diff --git a/Examples/test-suite/cpp_typedef.i b/Examples/test-suite/cpp_typedef.i index b782a3bd3..d77485c77 100644 --- a/Examples/test-suite/cpp_typedef.i +++ b/Examples/test-suite/cpp_typedef.i @@ -3,6 +3,9 @@ %module cpp_typedef %{ +#if defined(_MSC_VER) + #pragma warning( disable : 5208) // warning C5208: unnamed class used in typedef name cannot declare members other than non-static data members, member enumerations, or member classes +#endif class Bar { public: diff --git a/Examples/test-suite/csharp/Makefile.in b/Examples/test-suite/csharp/Makefile.in index b0ad0c7cf..02dcaafb0 100644 --- a/Examples/test-suite/csharp/Makefile.in +++ b/Examples/test-suite/csharp/Makefile.in @@ -28,6 +28,7 @@ CPP_TEST_CASES = \ enum_thorough_typesafe \ exception_partial_info \ intermediary_classname \ + nested_scope \ li_boost_intrusive_ptr \ li_std_list \ diff --git a/Examples/test-suite/csharp/multiple_inheritance_abstract_runme.cs b/Examples/test-suite/csharp/multiple_inheritance_abstract_runme.cs index 4584be399..512fbf2db 100644 --- a/Examples/test-suite/csharp/multiple_inheritance_abstract_runme.cs +++ b/Examples/test-suite/csharp/multiple_inheritance_abstract_runme.cs @@ -216,6 +216,7 @@ public class multiple_inheritance_abstract_runme { check(multiple_inheritance_abstract.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed"); check(multiple_inheritance_abstract.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed"); check(multiple_inheritance_abstract.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed"); + // Return pointers check(multiple_inheritance_abstract.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed"); check(multiple_inheritance_abstract.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed"); @@ -234,6 +235,15 @@ public class multiple_inheritance_abstract_runme { check(multiple_inheritance_abstract.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed"); check(multiple_inheritance_abstract.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed"); + // Return const pointer references + check(multiple_inheritance_abstract.MakeConstPtrRefDerived1_CBase1().cbase1y()!=3, "MakeConstPtrRefDerived1_CBase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived1_CBase2().cbase2()!=4, "MakeConstPtrRefDerived1_CBase2 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived2_CBase1().cbase1y()!=6, "MakeConstPtrRefDerived2_CBase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived2_ABase1().abase1()!=5, "MakeConstPtrRefDerived2_ABase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived3_ABase1().abase1()!=9, "MakeConstPtrRefDerived3_ABase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived3_CBase1().cbase1y()!=7, "MakeConstPtrRefDerived3_CBase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived3_CBase2().cbase2()!=8, "MakeConstPtrRefDerived3_CBase2 failed"); + // Return by value (sliced objects) check(multiple_inheritance_abstract.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed"); check(multiple_inheritance_abstract.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed"); diff --git a/Examples/test-suite/csharp/multiple_inheritance_nspace_runme.cs b/Examples/test-suite/csharp/multiple_inheritance_nspace_runme.cs index 6ed13a6ff..c2792517d 100644 --- a/Examples/test-suite/csharp/multiple_inheritance_nspace_runme.cs +++ b/Examples/test-suite/csharp/multiple_inheritance_nspace_runme.cs @@ -217,6 +217,7 @@ public class multiple_inheritance_nspace_runme { check(multiple_inheritance_nspace.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed"); check(multiple_inheritance_nspace.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed"); check(multiple_inheritance_nspace.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed"); + // Return pointers check(multiple_inheritance_nspace.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed"); check(multiple_inheritance_nspace.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed"); @@ -235,6 +236,15 @@ public class multiple_inheritance_nspace_runme { check(multiple_inheritance_nspace.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed"); check(multiple_inheritance_nspace.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed"); + // Return const pointer references + check(multiple_inheritance_nspace.MakeConstPtrRefDerived1_CBase1().cbase1y()!=3, "MakeConstPtrRefDerived1_CBase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived1_CBase2().cbase2()!=4, "MakeConstPtrRefDerived1_CBase2 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived2_CBase1().cbase1y()!=6, "MakeConstPtrRefDerived2_CBase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived2_ABase1().abase1()!=5, "MakeConstPtrRefDerived2_ABase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived3_ABase1().abase1()!=9, "MakeConstPtrRefDerived3_ABase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived3_CBase1().cbase1y()!=7, "MakeConstPtrRefDerived3_CBase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived3_CBase2().cbase2()!=8, "MakeConstPtrRefDerived3_CBase2 failed"); + // Return by value (sliced objects) check(multiple_inheritance_nspace.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed"); check(multiple_inheritance_nspace.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed"); diff --git a/Examples/test-suite/csharp/multiple_inheritance_shared_ptr_runme.cs b/Examples/test-suite/csharp/multiple_inheritance_shared_ptr_runme.cs index 13ffc62a4..fc2263ef5 100644 --- a/Examples/test-suite/csharp/multiple_inheritance_shared_ptr_runme.cs +++ b/Examples/test-suite/csharp/multiple_inheritance_shared_ptr_runme.cs @@ -301,6 +301,15 @@ public class multiple_inheritance_shared_ptr_runme { check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed"); check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed"); + // Return const pointer references + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived1_CBase1().cbase1y()!=3, "MakeConstPtrRefDerived1_CBase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived1_CBase2().cbase2()!=4, "MakeConstPtrRefDerived1_CBase2 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived2_CBase1().cbase1y()!=6, "MakeConstPtrRefDerived2_CBase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived2_ABase1().abase1()!=5, "MakeConstPtrRefDerived2_ABase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived3_ABase1().abase1()!=9, "MakeConstPtrRefDerived3_ABase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived3_CBase1().cbase1y()!=7, "MakeConstPtrRefDerived3_CBase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived3_CBase2().cbase2()!=8, "MakeConstPtrRefDerived3_CBase2 failed"); + // Return by value (sliced objects) check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed"); check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed"); diff --git a/Examples/test-suite/csharp/template_nested_flat_runme.cs b/Examples/test-suite/csharp/template_nested_flat_runme.cs new file mode 100644 index 000000000..afdbe5ff6 --- /dev/null +++ b/Examples/test-suite/csharp/template_nested_flat_runme.cs @@ -0,0 +1,25 @@ +using System; +using template_nested_flatNamespace; +#pragma warning disable 219 + +public class runme { + static void Main() { + new T_NormalTemplateNormalClass().tmethod(new NormalClass()); + new OuterClass().T_OuterTMethodNormalClass(new NormalClass()); + + TemplateFuncs tf = new TemplateFuncs(); + if (tf.T_TemplateFuncs1Int(-10) != -10) + throw new Exception("it failed"); + if (tf.T_TemplateFuncs2Double(-12.3) != -12.3) + throw new Exception("it failed"); + + T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble(); + if (tn.hohum(-12.3) != -12.3) + throw new Exception("it failed"); + T_OuterClassInner1Int inner1 = new OuterClass().useInner1(new T_OuterClassInner1Int()); + T_OuterClassInner2NormalClass inner2 = new T_OuterClassInner2NormalClass(); + inner2.embeddedVar = 2; + T_OuterClassInner2NormalClass inner22 = new OuterClass().useInner2Again(inner2); + } +} + diff --git a/Examples/test-suite/d/li_std_vector_runme.2.d b/Examples/test-suite/d/li_std_vector_runme.2.d index f4a666716..3f97062f1 100644 --- a/Examples/test-suite/d/li_std_vector_runme.2.d +++ b/Examples/test-suite/d/li_std_vector_runme.2.d @@ -47,7 +47,7 @@ void main() { enforce(countUntil(vector[], i * 10) == i, "indexOf test failed, i: " ~ to!string(i)); } - enforce(countUntil(vector[], 42) == -1, "non-existant item indexOf test failed"); + enforce(countUntil(vector[], 42) == -1, "non-existent item indexOf test failed"); vector.clear(); enforce(vector.length == 0, "clear test failed"); diff --git a/Examples/test-suite/director_exception.i b/Examples/test-suite/director_exception.i index 71366bef0..9ff7f3842 100644 --- a/Examples/test-suite/director_exception.i +++ b/Examples/test-suite/director_exception.i @@ -18,22 +18,7 @@ namespace Swig { %include "std_string.i" -#ifdef SWIGPHP - -%feature("director:except") { - if ($error == FAILURE) { - Swig::DirectorMethodException::raise("$symname"); - } -} - -%exception { - try { $action } - catch (Swig::DirectorException &) { SWIG_fail; } -} - -#endif - -#ifdef SWIGPYTHON +#if defined SWIGPHP || defined SWIGPYTHON %feature("director:except") { if ($error != NULL) { diff --git a/Examples/test-suite/director_nspace.i b/Examples/test-suite/director_nspace.i index f24227c68..016f61ddf 100644 --- a/Examples/test-suite/director_nspace.i +++ b/Examples/test-suite/director_nspace.i @@ -15,7 +15,6 @@ namespace TopLevel class FooBar { public: FooBar() {} - FooBar(const FooBar&) {} virtual ~FooBar() {} std::string FooBarDo() { return "Bar::Foo2::Foo2Bar()"; } @@ -56,7 +55,6 @@ namespace TopLevel class FooBar { public: FooBar(); - FooBar(const FooBar&); virtual ~FooBar(); std::string FooBarDo(); diff --git a/Examples/test-suite/director_overload.i b/Examples/test-suite/director_overload.i index 604ffe5ca..d6feb122b 100644 --- a/Examples/test-suite/director_overload.i +++ b/Examples/test-suite/director_overload.i @@ -47,5 +47,14 @@ public: virtual void notover(int *p) const {} }; -%} +class OverloadedGetSet +{ + int v; +public: + OverloadedGetSet() : v(42) { } + virtual ~OverloadedGetSet() { } + virtual int rw() const { return v; } + virtual void rw(int new_v) { v = new_v; } +}; +%} diff --git a/Examples/test-suite/director_overload2.i b/Examples/test-suite/director_overload2.i index e467c18ce..ddfa65bb4 100644 --- a/Examples/test-suite/director_overload2.i +++ b/Examples/test-suite/director_overload2.i @@ -14,11 +14,15 @@ struct OverloadDerived1 : OverloadBase { virtual void nnn(int vvv) {} #if defined(__SUNPRO_CC) virtual void nnn() {} +#elif defined(SWIGPHP) // FIXME: Hack to stop director_overload2 failing for PHP8 + virtual void nnn() {} #endif }; struct OverloadDerived2 : OverloadBase { #if defined(__SUNPRO_CC) virtual void nnn(int vvv) {} +#elif defined(SWIGPHP) // FIXME: Hack to stop director_overload2 failing for PHP8 + virtual void nnn(int vvv) {} #endif virtual void nnn() {} }; diff --git a/Examples/test-suite/director_protected.i b/Examples/test-suite/director_protected.i index 0299b238d..122addb70 100644 --- a/Examples/test-suite/director_protected.i +++ b/Examples/test-suite/director_protected.i @@ -11,13 +11,6 @@ %newobject *::create(); -#ifdef SWIGPHP -// TODO: Currently we do not track the dynamic type of returned objects -// in PHP, so we need the factory helper. -%include factory.i -%factory(Foo *Bar::create, Bar); -#endif - %rename(a) Bar::hello; %rename(s) Foo::p; %rename(q) Foo::r; diff --git a/Examples/test-suite/director_stl.i b/Examples/test-suite/director_stl.i index 46946e513..cbcb4ba85 100644 --- a/Examples/test-suite/director_stl.i +++ b/Examples/test-suite/director_stl.i @@ -17,11 +17,7 @@ %feature("director") Foo; %feature("director:except") { -#ifndef SWIGPHP if ($error != NULL) { -#else - if ($error == FAILURE) { -#endif throw Swig::DirectorMethodException(); } } diff --git a/Examples/test-suite/errors/swig_typemap_old.stderr b/Examples/test-suite/errors/swig_typemap_old.stderr index 23741164e..91bf1151d 100644 --- a/Examples/test-suite/errors/swig_typemap_old.stderr +++ b/Examples/test-suite/errors/swig_typemap_old.stderr @@ -1,5 +1,5 @@ -swig_typemap_old.i:6: Warning 450: Deprecated typemap feature ($source/$target). -swig_typemap_old.i:6: Warning 450: The use of $source and $target in a typemap declaration is deprecated. +swig_typemap_old.i:6: Error: Obsolete typemap feature ($source/$target). +swig_typemap_old.i:6: Error: The use of $source and $target in a typemap declaration is no longer supported. For typemaps related to argument input (in,ignore,default,arginit,check), replace $source by $input and $target by $1. For typemaps related to return values (out, argout,ret,except), replace $source by $1 and $target by $result. See the file diff --git a/Examples/test-suite/exception_partial_info.i b/Examples/test-suite/exception_partial_info.i index 3ac465cf6..0ff6abc26 100644 --- a/Examples/test-suite/exception_partial_info.i +++ b/Examples/test-suite/exception_partial_info.i @@ -30,8 +30,6 @@ class ex2 : public myException #if !defined(SWIGUTL) -#if !defined(SWIGCHICKEN) - %inline %{ class Impl { @@ -42,10 +40,6 @@ class Impl %} #else -#warning "Chicken needs fixing for partial exception information" -#endif - -#else #warning "UTL needs fixing for partial exception information" #endif diff --git a/Examples/test-suite/global_vars.i b/Examples/test-suite/global_vars.i index d562d1eaa..46133fed9 100644 --- a/Examples/test-suite/global_vars.i +++ b/Examples/test-suite/global_vars.i @@ -33,4 +33,8 @@ b = "string b"; x = 1234; } + + int read_x() { return x; } + + std::string read_b() { return b; } %} diff --git a/Examples/test-suite/grouping.i b/Examples/test-suite/grouping.i index 5632231d0..24acf6922 100644 --- a/Examples/test-suite/grouping.i +++ b/Examples/test-suite/grouping.i @@ -14,7 +14,7 @@ int *(test2)(int x) { return &y; } -int (test3) = 37; +int test3 = 37; typedef Integer (UnaryOp)(Integer); diff --git a/Examples/test-suite/guile/overload_null_runme.scm b/Examples/test-suite/guile/overload_null_runme.scm index f764d9c20..6824707d0 100644 --- a/Examples/test-suite/guile/overload_null_runme.scm +++ b/Examples/test-suite/guile/overload_null_runme.scm @@ -39,15 +39,15 @@ ;(check (=~ 15 (Overload-byval2cpr o #nil))) ;(check (=~ 16 (Overload-byval2cpr o x))) -; forward class declaration -(check (=~ 17 (Overload-byval1forwardptr o x))) -(check (=~ 18 (Overload-byval1forwardptr o #nil))) +; fwd class declaration +(check (=~ 17 (Overload-byval1fwdptr o x))) +(check (=~ 18 (Overload-byval1fwdptr o #nil))) -(check (=~ 19 (Overload-byval2forwardptr o #nil))) -(check (=~ 20 (Overload-byval2forwardptr o x))) +(check (=~ 19 (Overload-byval2fwdptr o #nil))) +(check (=~ 20 (Overload-byval2fwdptr o x))) -(check (=~ 21 (Overload-byval1forwardref o x))) +(check (=~ 21 (Overload-byval1fwdref o x))) -(check (=~ 22 (Overload-byval2forwardref o x))) +(check (=~ 22 (Overload-byval2fwdref o x))) (exit 0) diff --git a/Examples/test-suite/import_nomodule.i b/Examples/test-suite/import_nomodule.i index 60ef7e0f6..48e119517 100644 --- a/Examples/test-suite/import_nomodule.i +++ b/Examples/test-suite/import_nomodule.i @@ -8,7 +8,7 @@ %import "import_nomodule.h" -#if !defined(SWIGJAVA) && !defined(SWIGRUBY) && !defined(SWIGCSHARP) && !defined(SWIGD) && !defined(SWIGPYTHON_BUILTIN) +#if !defined(SWIGJAVA) && !defined(SWIGRUBY) && !defined(SWIGCSHARP) && !defined(SWIGD) && !defined(SWIGPYTHON_BUILTIN) && !defined(SWIGPHP) /** * The proxy class does not have Bar derived from Foo, yet an instance of Bar @@ -16,8 +16,8 @@ * language modules). * * This violation of the type system is not possible in Java, C# and D due to - * static type checking. It's also not (currently) possible in Ruby, but this may - * be fixable (needs more investigation). + * static type checking. It's also not (currently) possible in PHP or Ruby, but + * this may be fixable (needs more investigation). */ %newobject create_Foo; diff --git a/Examples/test-suite/java/Makefile.in b/Examples/test-suite/java/Makefile.in index a449f287c..e2a3d2472 100644 --- a/Examples/test-suite/java/Makefile.in +++ b/Examples/test-suite/java/Makefile.in @@ -44,8 +44,8 @@ CPP_TEST_CASES = \ java_throws \ java_typemaps_proxy \ java_typemaps_typewrapper \ + nested_scope \ li_std_list \ - li_std_map \ li_std_set \ # li_boost_intrusive_ptr diff --git a/Examples/test-suite/java/multiple_inheritance_abstract_runme.java b/Examples/test-suite/java/multiple_inheritance_abstract_runme.java index 1489d92a7..4230e7b9a 100644 --- a/Examples/test-suite/java/multiple_inheritance_abstract_runme.java +++ b/Examples/test-suite/java/multiple_inheritance_abstract_runme.java @@ -224,6 +224,7 @@ public class multiple_inheritance_abstract_runme { check(multiple_inheritance_abstract.InputCPtrRefBottom1(b1)!=103+104, "InputCPtrRefBottom1() failed"); check(multiple_inheritance_abstract.InputCPtrRefBottom2(b2)!=206+205, "InputCPtrRefBottom2() failed"); check(multiple_inheritance_abstract.InputCPtrRefBottom3(b3)!=307+308+309, "InputCPtrRefBottom3() failed"); + // Return pointers check(multiple_inheritance_abstract.MakePtrDerived1_CBase1().cbase1y()!=3, "MakePtrDerived1_CBase1 failed"); check(multiple_inheritance_abstract.MakePtrDerived1_CBase2().cbase2()!=4, "MakePtrDerived1_CBase2 failed"); @@ -242,6 +243,15 @@ public class multiple_inheritance_abstract_runme { check(multiple_inheritance_abstract.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed"); check(multiple_inheritance_abstract.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed"); + // Return const pointer references + check(multiple_inheritance_abstract.MakeConstPtrRefDerived1_CBase1().cbase1y()!=3, "MakeConstPtrRefDerived1_CBase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived1_CBase2().cbase2()!=4, "MakeConstPtrRefDerived1_CBase2 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived2_CBase1().cbase1y()!=6, "MakeConstPtrRefDerived2_CBase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived2_ABase1().abase1()!=5, "MakeConstPtrRefDerived2_ABase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived3_ABase1().abase1()!=9, "MakeConstPtrRefDerived3_ABase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived3_CBase1().cbase1y()!=7, "MakeConstPtrRefDerived3_CBase1 failed"); + check(multiple_inheritance_abstract.MakeConstPtrRefDerived3_CBase2().cbase2()!=8, "MakeConstPtrRefDerived3_CBase2 failed"); + // Return by value (sliced objects) check(multiple_inheritance_abstract.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed"); check(multiple_inheritance_abstract.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed"); diff --git a/Examples/test-suite/java/multiple_inheritance_nspace_runme.java b/Examples/test-suite/java/multiple_inheritance_nspace_runme.java index 461c7a131..ed2d3377a 100644 --- a/Examples/test-suite/java/multiple_inheritance_nspace_runme.java +++ b/Examples/test-suite/java/multiple_inheritance_nspace_runme.java @@ -244,6 +244,15 @@ public class multiple_inheritance_nspace_runme { check(multiple_inheritance_nspace.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed"); check(multiple_inheritance_nspace.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed"); + // Return const pointer references + check(multiple_inheritance_nspace.MakeConstPtrRefDerived1_CBase1().cbase1y()!=3, "MakeConstPtrRefDerived1_CBase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived1_CBase2().cbase2()!=4, "MakeConstPtrRefDerived1_CBase2 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived2_CBase1().cbase1y()!=6, "MakeConstPtrRefDerived2_CBase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived2_ABase1().abase1()!=5, "MakeConstPtrRefDerived2_ABase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived3_ABase1().abase1()!=9, "MakeConstPtrRefDerived3_ABase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived3_CBase1().cbase1y()!=7, "MakeConstPtrRefDerived3_CBase1 failed"); + check(multiple_inheritance_nspace.MakeConstPtrRefDerived3_CBase2().cbase2()!=8, "MakeConstPtrRefDerived3_CBase2 failed"); + // Return by value (sliced objects) check(multiple_inheritance_nspace.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed"); check(multiple_inheritance_nspace.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed"); diff --git a/Examples/test-suite/java/multiple_inheritance_shared_ptr_runme.java b/Examples/test-suite/java/multiple_inheritance_shared_ptr_runme.java index 6472a911e..910913027 100644 --- a/Examples/test-suite/java/multiple_inheritance_shared_ptr_runme.java +++ b/Examples/test-suite/java/multiple_inheritance_shared_ptr_runme.java @@ -309,6 +309,15 @@ public class multiple_inheritance_shared_ptr_runme { check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase1().cbase1y()!=7, "MakeRefDerived3_CBase1 failed"); check(multiple_inheritance_shared_ptr.MakeRefDerived3_CBase2().cbase2()!=8, "MakeRefDerived3_CBase2 failed"); + // Return const pointer references + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived1_CBase1().cbase1y()!=3, "MakeConstPtrRefDerived1_CBase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived1_CBase2().cbase2()!=4, "MakeConstPtrRefDerived1_CBase2 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived2_CBase1().cbase1y()!=6, "MakeConstPtrRefDerived2_CBase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived2_ABase1().abase1()!=5, "MakeConstPtrRefDerived2_ABase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived3_ABase1().abase1()!=9, "MakeConstPtrRefDerived3_ABase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived3_CBase1().cbase1y()!=7, "MakeConstPtrRefDerived3_CBase1 failed"); + check(multiple_inheritance_shared_ptr.MakeConstPtrRefDerived3_CBase2().cbase2()!=8, "MakeConstPtrRefDerived3_CBase2 failed"); + // Return by value (sliced objects) check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase1().cbase1y()!=1, "MakeValDerived1_CBase1 failed"); check(multiple_inheritance_shared_ptr.MakeValDerived1_CBase2().cbase2()!=2, "MakeValDerived1_CBase2 failed"); diff --git a/Examples/test-suite/java/rname_runme.java b/Examples/test-suite/java/rname_runme.java index dac0a1ecf..4af6581c2 100644 --- a/Examples/test-suite/java/rname_runme.java +++ b/Examples/test-suite/java/rname_runme.java @@ -25,7 +25,7 @@ public class rname_runme { bar.foo_u((long)10); RenamedBase base = new RenamedBase(); - base.fn(base, base, base); + base.fn1(base, base, base); if (!base.newname(10.0).equals("Base")) throw new RuntimeException("base.newname"); diff --git a/Examples/test-suite/java/template_nested_flat_runme.java b/Examples/test-suite/java/template_nested_flat_runme.java new file mode 100644 index 000000000..023c18590 --- /dev/null +++ b/Examples/test-suite/java/template_nested_flat_runme.java @@ -0,0 +1,35 @@ + +import template_nested_flat.*; + +public class template_nested_flat_runme { + + static { + try { + System.loadLibrary("template_nested_flat"); + } catch (UnsatisfiedLinkError e) { + System.err.println("Native code library failed to load. See the chapter on Dynamic Linking Problems in the SWIG Java documentation for help.\n" + e); + System.exit(1); + } + } + + public static void main(String argv[]) { + new T_NormalTemplateNormalClass().tmethod(new NormalClass()); + new OuterClass().T_OuterTMethodNormalClass(new NormalClass()); + + TemplateFuncs tf = new TemplateFuncs(); + if (tf.T_TemplateFuncs1Int(-10) != -10) + throw new RuntimeException("it failed"); + if (tf.T_TemplateFuncs2Double(-12.3) != -12.3) + throw new RuntimeException("it failed"); + + T_NestedOuterTemplateDouble tn = new T_NestedOuterTemplateDouble(); + if (tn.hohum(-12.3) != -12.3) + throw new RuntimeException("it failed"); + T_OuterClassInner1Int inner1 = new OuterClass().useInner1(new T_OuterClassInner1Int()); + T_OuterClassInner2NormalClass inner2 = new T_OuterClassInner2NormalClass(); + inner2.setEmbeddedVar(2); + T_OuterClassInner2NormalClass inner22 = new OuterClass().useInner2Again(inner2); + T_OuterClassInner1Double inner3 = new T_OuterClassInner1Double(); + } +} + diff --git a/Examples/test-suite/java/template_template_parameters_runme.java b/Examples/test-suite/java/template_template_parameters_runme.java index 42135b982..613f9087c 100644 --- a/Examples/test-suite/java/template_template_parameters_runme.java +++ b/Examples/test-suite/java/template_template_parameters_runme.java @@ -14,15 +14,33 @@ public class template_template_parameters_runme { } public static void main(String argv[]) { + // Test first part ListFastBool listBool = new ListFastBool(); listBool.setItem(true); + boolean x_boolean = listBool.getAllotype(); if (listBool.getItem() != true) throw new RuntimeException("Failed"); ListDefaultDouble listDouble = new ListDefaultDouble(); listDouble.setItem(10.2); + double x_double = listDouble.getAllotype(); if (listDouble.getItem() != 10.2) throw new RuntimeException("Failed"); + + // Test second part + FloatTestStruct floatTestStruct = new FloatTestStruct(); + FloatContainer2 floatContainer2 = floatTestStruct.getX(); + floatContainer2.setX(8.1f); + IntTestStruct intTestStruct = new IntTestStruct(); + IntContainer1 intContainer1 = intTestStruct.getX(); + intContainer1.setX(91); + if (intContainer1.getX() != 91) + throw new RuntimeException("Failed"); + if (intTestStruct.getX().getX() != 91) + throw new RuntimeException("Failed"); + IntTestStruct intTestStructReturned = template_template_parameters.TestStructContainer1Method(intTestStruct); + if (intTestStructReturned.getX().getX() != 101) + throw new RuntimeException("Failed"); } } diff --git a/Examples/test-suite/javascript/Makefile.in b/Examples/test-suite/javascript/Makefile.in index fed028388..0e11f3d9d 100644 --- a/Examples/test-suite/javascript/Makefile.in +++ b/Examples/test-suite/javascript/Makefile.in @@ -13,8 +13,8 @@ srcdir = @srcdir@ top_srcdir = @top_srcdir@ top_builddir = @top_builddir@ -C_TEST_CASES += \ - ccomplextest \ +CPP_TEST_CASES += \ + javascript_lib_arrays \ SWIGEXE = $(top_builddir)/swig SWIG_LIB_DIR = $(top_srcdir)/Lib @@ -54,8 +54,10 @@ ifeq (node,$(JSENGINE)) # dunno... ignoring generously apply_signed_char.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\" constant_pointers.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\" + cpp11_ref_qualifiers.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\" director_basic.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\" enum_thorough.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\" + member_funcptr_galore.cpptest: GYP_CFLAGS = \"-Wno-ignored-qualifiers\" setup_node = \ test -d $* || mkdir $* && \ diff --git a/Examples/test-suite/javascript/inherit_missing_runme.js b/Examples/test-suite/javascript/inherit_missing_runme.js new file mode 100644 index 000000000..05f5760e2 --- /dev/null +++ b/Examples/test-suite/javascript/inherit_missing_runme.js @@ -0,0 +1,19 @@ +var inherit_missing = require("inherit_missing"); + +a = inherit_missing.new_Foo() +b = new inherit_missing.Bar() +c = new inherit_missing.Spam() + +x = inherit_missing.do_blah(a) +if (x != "Foo::blah") + throw new Error("Whoa! Bad return {}".format(x)) + +x = inherit_missing.do_blah(b) +if (x != "Bar::blah") + throw new Error("Whoa! Bad return {}".format(x)) + +x = inherit_missing.do_blah(c) +if (x != "Spam::blah") + throw new Error("Whoa! Bad return {}".format(x)) + +inherit_missing.delete_Foo(a) diff --git a/Examples/test-suite/javascript/javascript_lib_arrays_runme.js b/Examples/test-suite/javascript/javascript_lib_arrays_runme.js new file mode 100644 index 000000000..1eb586134 --- /dev/null +++ b/Examples/test-suite/javascript/javascript_lib_arrays_runme.js @@ -0,0 +1,20 @@ +var javascript_lib_arrays = require("javascript_lib_arrays"); + +var arr = [1, 2, 3, 4, 5]; + +function check(a, b) { + if (a !== b) { + throw new Error("Not equal: " + a + " " + b) + } +} + +function check_array(a, b) { + if (a.length != b.length) + throw new Error("Array length mismatch " + a.length + " " + b.length) + if (!a.every(function(element, index) { return element === b[index]; })) + throw new Error("Arrays don't match a:" + a + " b:" + b) +} + +check(15, javascript_lib_arrays.sum1(arr, arr.length)); +check(6, javascript_lib_arrays.sum2(arr)); +check_array([1, 2, 3, 4], javascript_lib_arrays.data3) diff --git a/Examples/test-suite/javascript/overload_null_runme.js b/Examples/test-suite/javascript/overload_null_runme.js index f1e35cac7..f6c31a436 100644 --- a/Examples/test-suite/javascript/overload_null_runme.js +++ b/Examples/test-suite/javascript/overload_null_runme.js @@ -37,13 +37,13 @@ check(13, o.byval1cpr(x)); // check(15, o.byval2cpr(null)); check(16, o.byval2cpr(x)); -// forward class declaration -check(17, o.byval1forwardptr(x)); -// check(18, o.byval1forwardptr(null)); +// fwd class declaration +check(17, o.byval1fwdptr(x)); +// check(18, o.byval1fwdptr(null)); -// check(19, o.byval2forwardptr(null)); -check(20, o.byval2forwardptr(x)); +// check(19, o.byval2fwdptr(null)); +check(20, o.byval2fwdptr(x)); -check(21, o.byval1forwardref(x)); +check(21, o.byval1fwdref(x)); -check(22, o.byval2forwardref(x)); +check(22, o.byval2fwdref(x)); diff --git a/Examples/test-suite/javascript/types_directive_runme.js b/Examples/test-suite/javascript/types_directive_runme.js new file mode 100644 index 000000000..f4f0a2b7a --- /dev/null +++ b/Examples/test-suite/javascript/types_directive_runme.js @@ -0,0 +1,14 @@ +var types_directive = require("types_directive"); + +d1 = new types_directive.Time1(2001, 2, 3, 60) +// check that a Time1 instance is accepted where Date is expected +newDate = types_directive.add(d1, 7) +if (newDate.day != 10) + throw new Error("newDate mismatch") + +d2 = new types_directive.Time2(1999, 8, 7, 60) +// check that a Time2 instance is accepted where Date is expected +newDate = types_directive.add(d2, 7) +if (newDate.day != 14) + throw new Error("newDate mismatch") + diff --git a/Examples/test-suite/javascript/virtual_derivation_runme.js b/Examples/test-suite/javascript/virtual_derivation_runme.js new file mode 100644 index 000000000..be87a5d9a --- /dev/null +++ b/Examples/test-suite/javascript/virtual_derivation_runme.js @@ -0,0 +1,8 @@ +var virtual_derivation = require("virtual_derivation"); +// +// very innocent example +// +b = new virtual_derivation.B(3) +if (b.get_a() != b.get_b()) + throw new Error("something is really wrong") + diff --git a/Examples/test-suite/javascript_lib_arrays.i b/Examples/test-suite/javascript_lib_arrays.i new file mode 100644 index 000000000..512084ad5 --- /dev/null +++ b/Examples/test-suite/javascript_lib_arrays.i @@ -0,0 +1,30 @@ +%module javascript_lib_arrays + +%include <arrays_javascript.i> + +%apply int[] { int *data1 } +%apply int[3] { int data2[3] } +%apply int[4] { int data3[4] } + +%inline %{ + +int sum1(int *data1, int size) { + int sum = 0; + for (int i = 0; i < size; i++) { + sum += data1[i]; + } + return sum; +} + +int sum2(int data2[3]) { + int sum = 0; + for (int i = 0; i < 3; i++) { + sum += data2[i]; + } + return sum; +} + +int data3[4] = {1, 2, 3, 4}; + +%} + diff --git a/Examples/test-suite/keyword_rename.i b/Examples/test-suite/keyword_rename.i index 23c01087d..645f02661 100644 --- a/Examples/test-suite/keyword_rename.i +++ b/Examples/test-suite/keyword_rename.i @@ -27,7 +27,7 @@ KW(synchronized, final) /* C# Keywords */ KW(string, out) -struct sealed {int i;}; +struct stackalloc {int i;}; /* Go Keywords */ KW(go, defer) diff --git a/Examples/test-suite/kwargs_feature.i b/Examples/test-suite/kwargs_feature.i index 2b662caeb..dd5b2638d 100644 --- a/Examples/test-suite/kwargs_feature.i +++ b/Examples/test-suite/kwargs_feature.i @@ -126,3 +126,21 @@ struct Extending2 {}; struct ExtendingOptArgs1 {}; struct ExtendingOptArgs2 {}; %} + +// Varargs +%warnfilter(SWIGWARN_LANG_VARARGS_KEYWORD) VarargConstructor::VarargConstructor; // Can't wrap varargs with keyword arguments enabled +%warnfilter(SWIGWARN_LANG_VARARGS_KEYWORD) VarargConstructor::vararg_method; // Can't wrap varargs with keyword arguments enabled +%inline %{ +struct VarargConstructor { + char *str; + VarargConstructor(const char *fmt, ...) { + str = new char[strlen(fmt) + 1]; + strcpy(str, fmt); + } + void vararg_method(const char *fmt, ...) { + delete [] str; + str = new char[strlen(fmt) + 1]; + strcpy(str, fmt); + } +}; +%} diff --git a/Examples/test-suite/li_math.i b/Examples/test-suite/li_math.i index 3aa3db303..db39cd3de 100644 --- a/Examples/test-suite/li_math.i +++ b/Examples/test-suite/li_math.i @@ -1,7 +1,2 @@ %module li_math -#ifdef SWIGPHP -// PHP already provides these functions with the same names, so just kill that -// warning. -%warnfilter(SWIGWARN_PARSE_KEYWORD); -#endif %include math.i diff --git a/Examples/test-suite/lua/overload_null_runme.lua b/Examples/test-suite/lua/overload_null_runme.lua index 69b7de2db..9b5ef5674 100644 --- a/Examples/test-suite/lua/overload_null_runme.lua +++ b/Examples/test-suite/lua/overload_null_runme.lua @@ -29,13 +29,13 @@ assert(14 == o:byval1cpr(nil)) assert(15 == o:byval2cpr(nil)) assert(16 == o:byval2cpr(x)) --- forward class declaration -assert(17 == o:byval1forwardptr(x)) -assert(18 == o:byval1forwardptr(nil)) +-- fwd class declaration +assert(17 == o:byval1fwdptr(x)) +assert(18 == o:byval1fwdptr(nil)) -assert(19 == o:byval2forwardptr(nil)) -assert(20 == o:byval2forwardptr(x)) +assert(19 == o:byval2fwdptr(nil)) +assert(20 == o:byval2fwdptr(x)) -assert(21 == o:byval1forwardref(x)) +assert(21 == o:byval1fwdref(x)) -assert(22 == o:byval2forwardref(x)) +assert(22 == o:byval2fwdref(x)) diff --git a/Examples/test-suite/memberin_extend_c.i b/Examples/test-suite/memberin_extend_c.i index 0599e65a0..c7e017305 100644 --- a/Examples/test-suite/memberin_extend_c.i +++ b/Examples/test-suite/memberin_extend_c.i @@ -32,7 +32,8 @@ char *Person_name_get(Person *p) { } void Person_name_set(Person *p, char *val) { - strncpy(p->name,val,50); + p->name[0] = '\0'; + strncat(p->name, val, sizeof(p->name) - 1); make_upper(p->name); } %} diff --git a/Examples/test-suite/multiple_inheritance_abstract.i b/Examples/test-suite/multiple_inheritance_abstract.i index b54a37dea..9ac16a235 100644 --- a/Examples/test-suite/multiple_inheritance_abstract.i +++ b/Examples/test-suite/multiple_inheritance_abstract.i @@ -1,9 +1,8 @@ // This is a copy of the multiple_inheritance_abstract test -%module multiple_inheritance_abstract +%module(ruby_minherit="1") multiple_inheritance_abstract -%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE, - SWIGWARN_D_MULTIPLE_INHERITANCE, - SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */ +%warnfilter(SWIGWARN_D_MULTIPLE_INHERITANCE, + SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance */ #if defined(SWIGJAVA) || defined(SWIGCSHARP) %include "swiginterface.i" @@ -23,7 +22,7 @@ namespace Space { struct CBase1 { virtual void cbase1x() { return; - } + } virtual int cbase1y() { return 1; } @@ -307,6 +306,36 @@ namespace Space { return d; } + // Return const pointer references + CBase1 *const&MakeConstPtrRefDerived1_CBase1() { + static CBase1 *d = new Derived1(); + return d; + } + CBase2 *const&MakeConstPtrRefDerived1_CBase2() { + static CBase2 *const& d = new Derived1(); + return d; + } + CBase1 *const&MakeConstPtrRefDerived2_CBase1() { + static CBase1 *const& d = new Derived2(); + return d; + } + ABase1 *const&MakeConstPtrRefDerived2_ABase1() { + static ABase1 *const& d = new Derived2(); + return d; + } + ABase1 *const&MakeConstPtrRefDerived3_ABase1() { + static ABase1 *const& d = new Derived3(); + return d; + } + CBase1 *const&MakeConstPtrRefDerived3_CBase1() { + static CBase1 *const& d = new Derived3(); + return d; + } + CBase2 *const&MakeConstPtrRefDerived3_CBase2() { + static CBase2 *const& d = new Derived3(); + return d; + } + // Return by value (sliced objects) CBase1 MakeValDerived1_CBase1() { return Derived1(); diff --git a/Examples/test-suite/multiple_inheritance_interfaces.i b/Examples/test-suite/multiple_inheritance_interfaces.i index 98ec37b4f..6bb1d50cb 100644 --- a/Examples/test-suite/multiple_inheritance_interfaces.i +++ b/Examples/test-suite/multiple_inheritance_interfaces.i @@ -1,8 +1,7 @@ -%module multiple_inheritance_interfaces +%module(ruby_minherit="1") multiple_inheritance_interfaces -%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE, - SWIGWARN_D_MULTIPLE_INHERITANCE, - SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */ +%warnfilter(SWIGWARN_D_MULTIPLE_INHERITANCE, + SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance */ #if defined(SWIGJAVA) || defined(SWIGCSHARP) %include "swiginterface.i" diff --git a/Examples/test-suite/multiple_inheritance_nspace.i b/Examples/test-suite/multiple_inheritance_nspace.i index 4faef5749..002e6d6ee 100644 --- a/Examples/test-suite/multiple_inheritance_nspace.i +++ b/Examples/test-suite/multiple_inheritance_nspace.i @@ -1,9 +1,8 @@ // This is a copy of the multiple_inheritance_abstract test -%module multiple_inheritance_nspace +%module(ruby_minherit="1") multiple_inheritance_nspace -%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE, - SWIGWARN_D_MULTIPLE_INHERITANCE, - SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */ +%warnfilter(SWIGWARN_D_MULTIPLE_INHERITANCE, + SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance */ // nspace feature only supported by these languages #if defined(SWIGJAVA) || defined(SWIGCSHARP) || defined(SWIGD) || defined(SWIGLUA) || defined(SWIGJAVASCRIPT) @@ -32,7 +31,7 @@ namespace Space { struct CBase1 { virtual void cbase1x() { return; - } + } virtual int cbase1y() { return 1; } @@ -316,6 +315,36 @@ namespace Space { return d; } + // Return const pointer references + CBase1 *const&MakeConstPtrRefDerived1_CBase1() { + static CBase1 *d = new Derived1(); + return d; + } + CBase2 *const&MakeConstPtrRefDerived1_CBase2() { + static CBase2 *const& d = new Derived1(); + return d; + } + CBase1 *const&MakeConstPtrRefDerived2_CBase1() { + static CBase1 *const& d = new Derived2(); + return d; + } + ABase1 *const&MakeConstPtrRefDerived2_ABase1() { + static ABase1 *const& d = new Derived2(); + return d; + } + ABase1 *const&MakeConstPtrRefDerived3_ABase1() { + static ABase1 *const& d = new Derived3(); + return d; + } + CBase1 *const&MakeConstPtrRefDerived3_CBase1() { + static CBase1 *const& d = new Derived3(); + return d; + } + CBase2 *const&MakeConstPtrRefDerived3_CBase2() { + static CBase2 *const& d = new Derived3(); + return d; + } + // Return by value (sliced objects) CBase1 MakeValDerived1_CBase1() { return Derived1(); diff --git a/Examples/test-suite/multiple_inheritance_shared_ptr.i b/Examples/test-suite/multiple_inheritance_shared_ptr.i index 3c061e1a9..061db57d9 100644 --- a/Examples/test-suite/multiple_inheritance_shared_ptr.i +++ b/Examples/test-suite/multiple_inheritance_shared_ptr.i @@ -1,9 +1,8 @@ // This is a copy of the multiple_inheritance_abstract test and extended for testing %shared_ptr and %interface_impl -%module multiple_inheritance_shared_ptr +%module(ruby_minherit="1") multiple_inheritance_shared_ptr -%warnfilter(SWIGWARN_RUBY_MULTIPLE_INHERITANCE, - SWIGWARN_D_MULTIPLE_INHERITANCE, - SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance or %interface */ +%warnfilter(SWIGWARN_D_MULTIPLE_INHERITANCE, + SWIGWARN_PHP_MULTIPLE_INHERITANCE); /* languages not supporting multiple inheritance */ // Typemap changes required to mix %shared_ptr and %interface_impl // Note we don't have a way to use $javainterfacename/$csinterfacename (yet), @@ -425,6 +424,36 @@ namespace Space { return d; } + // Return const pointer references + CBase1 *const&MakeConstPtrRefDerived1_CBase1() { + static CBase1 *d = new Derived1(); + return d; + } + CBase2 *const&MakeConstPtrRefDerived1_CBase2() { + static CBase2 *const& d = new Derived1(); + return d; + } + CBase1 *const&MakeConstPtrRefDerived2_CBase1() { + static CBase1 *const& d = new Derived2(); + return d; + } + ABase1 *const&MakeConstPtrRefDerived2_ABase1() { + static ABase1 *const& d = new Derived2(); + return d; + } + ABase1 *const&MakeConstPtrRefDerived3_ABase1() { + static ABase1 *const& d = new Derived3(); + return d; + } + CBase1 *const&MakeConstPtrRefDerived3_CBase1() { + static CBase1 *const& d = new Derived3(); + return d; + } + CBase2 *const&MakeConstPtrRefDerived3_CBase2() { + static CBase2 *const& d = new Derived3(); + return d; + } + // Return by value (sliced objects) CBase1 MakeValDerived1_CBase1() { return Derived1(); diff --git a/Examples/test-suite/nested_scope.i b/Examples/test-suite/nested_scope.i index bd66eec73..dabea310e 100644 --- a/Examples/test-suite/nested_scope.i +++ b/Examples/test-suite/nested_scope.i @@ -1,9 +1,5 @@ %module nested_scope -#if !defined(SWIGCSHARP) && !defined(SWIGJAVA) -%feature ("flatnested"); -#endif - %inline %{ namespace ns { // "global" is a case-insensitive keyword in PHP. @@ -31,9 +27,9 @@ namespace ns { public: struct Nested2; #ifdef __clang__ - struct Nested2 { - int data; - }; + struct Nested2 { + int data; + }; #endif template <class T> class AbstractClass; class Real; diff --git a/Examples/test-suite/nested_scope_flat.i b/Examples/test-suite/nested_scope_flat.i new file mode 100644 index 000000000..6aab72349 --- /dev/null +++ b/Examples/test-suite/nested_scope_flat.i @@ -0,0 +1,5 @@ +%module nested_scope_flat + +%feature ("flatnested"); + +%include "nested_scope.i" diff --git a/Examples/test-suite/octave/overload_null_runme.m b/Examples/test-suite/octave/overload_null_runme.m index a7c346c26..83c11a199 100644 --- a/Examples/test-suite/octave/overload_null_runme.m +++ b/Examples/test-suite/octave/overload_null_runme.m @@ -40,13 +40,13 @@ check(14, o.byval1cpr(null)); check(15, o.byval2cpr(null)); check(16, o.byval2cpr(x)); -# forward class declaration -check(17, o.byval1forwardptr(x)); -check(18, o.byval1forwardptr(null)); +# fwd class declaration +check(17, o.byval1fwdptr(x)); +check(18, o.byval1fwdptr(null)); -check(19, o.byval2forwardptr(null)); -check(20, o.byval2forwardptr(x)); +check(19, o.byval2fwdptr(null)); +check(20, o.byval2fwdptr(x)); -check(21, o.byval1forwardref(x)); +check(21, o.byval1fwdref(x)); -check(22, o.byval2forwardref(x)); +check(22, o.byval2fwdref(x)); diff --git a/Examples/test-suite/overload_arrays.i b/Examples/test-suite/overload_arrays.i index 272c96a3d..e6bd09adf 100644 --- a/Examples/test-suite/overload_arrays.i +++ b/Examples/test-suite/overload_arrays.i @@ -2,10 +2,6 @@ // Based on overload_simple testcase %module overload_arrays -#ifdef SWIGCHICKEN -%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) fbool; -#endif - #ifdef SWIGLUA // lua only has one numeric type, so most of the overloads shadow each other creating warnings %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) foo; diff --git a/Examples/test-suite/overload_null.i b/Examples/test-suite/overload_null.i index d4879fdb5..0ec970399 100644 --- a/Examples/test-suite/overload_null.i +++ b/Examples/test-suite/overload_null.i @@ -35,18 +35,18 @@ struct Overload { int byval2cpr(Y*const& y) { return 15; } int byval2cpr(X x) { return 16; } - // forward class declaration - int byval1forwardptr(X x) { return 17; } - int byval1forwardptr(F* f) { return 18; } + // fwd class declaration + int byval1fwdptr(X x) { return 17; } + int byval1fwdptr(F* f) { return 18; } - int byval2forwardptr(F* f) { return 19; } - int byval2forwardptr(X x) { return 20; } + int byval2fwdptr(F* f) { return 19; } + int byval2fwdptr(X x) { return 20; } - int byval1forwardref(X x) { return 21; } - int byval1forwardref(F& f) { return -21; } + int byval1fwdref(X x) { return 21; } + int byval1fwdref(F& f) { return -21; } - int byval2forwardref(F& f) { return -22; } - int byval2forwardref(X x) { return 22; } + int byval2fwdref(F& f) { return -22; } + int byval2fwdref(X x) { return 22; } }; %} diff --git a/Examples/test-suite/overload_polymorphic.i b/Examples/test-suite/overload_polymorphic.i index ac004f948..72aabd840 100644 --- a/Examples/test-suite/overload_polymorphic.i +++ b/Examples/test-suite/overload_polymorphic.i @@ -23,4 +23,7 @@ class Unknown; int test2(Unknown* unknown) { return 0; } int test2(Base* base) { return 1; } +int test3(const char*, const Base* = 0, bool = false) { return 0; } +int test3(Base&, const char* = 0, const Base* = 0, bool = false) { return 1; } + %} diff --git a/Examples/test-suite/overload_simple.i b/Examples/test-suite/overload_simple.i index ba1900b40..fa2e335bb 100644 --- a/Examples/test-suite/overload_simple.i +++ b/Examples/test-suite/overload_simple.i @@ -1,10 +1,6 @@ // Simple tests of overloaded functions %module overload_simple -#ifdef SWIGCHICKEN -%warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) fbool; -#endif - #ifdef SWIGLUA // lua only has one numeric type, so most of the overloads shadow each other creating warnings %warnfilter(SWIGWARN_LANG_OVERLOAD_SHADOW) foo; diff --git a/Examples/test-suite/perl5/Makefile.in b/Examples/test-suite/perl5/Makefile.in index 48d5fa5d1..6388e5b32 100644 --- a/Examples/test-suite/perl5/Makefile.in +++ b/Examples/test-suite/perl5/Makefile.in @@ -16,11 +16,13 @@ CPP_TEST_CASES += \ li_cstring \ li_cdata_carrays_cpp \ li_reference \ + memberin1 \ director_nestedmodule \ C_TEST_CASES += \ li_cstring \ li_cdata_carrays \ + multivalue \ include $(srcdir)/../common.mk diff --git a/Examples/test-suite/perl5/multivalue_runme.pl b/Examples/test-suite/perl5/multivalue_runme.pl new file mode 100644 index 000000000..b58a58a11 --- /dev/null +++ b/Examples/test-suite/perl5/multivalue_runme.pl @@ -0,0 +1,20 @@ +use strict; +use warnings; +use Test::More tests => 8; + +BEGIN { use_ok('multivalue') } +require_ok('multivalue'); + +my ($q, $r); + +($q, $r) = multivalue::divide_l(37, 5); +is($q, 7, "Test divide_l quotient"); +is($r, 2, "Test divide_l remainder"); + +($q, $r) = multivalue::divide_v(41, 7); +is($q, 5, "Test divide_v quotient"); +is($r, 6, "Test divide_v remainder"); + +($q, $r) = multivalue::divide_mv(91, 13); +is($q, 7, "Test divide_mv quotient"); +is($r, 0, "Test divide_mv remainder"); diff --git a/Examples/test-suite/perl5/overload_null_runme.pl b/Examples/test-suite/perl5/overload_null_runme.pl index 7cc5090de..6c01b58a2 100644 --- a/Examples/test-suite/perl5/overload_null_runme.pl +++ b/Examples/test-suite/perl5/overload_null_runme.pl @@ -32,13 +32,13 @@ is(14, $o->byval1cpr(undef)); is(15, $o->byval2cpr(undef)); is(16, $o->byval2cpr($x)); -# forward class declaration -is(17, $o->byval1forwardptr($x)); -is(18, $o->byval1forwardptr(undef)); +# fwd class declaration +is(17, $o->byval1fwdptr($x)); +is(18, $o->byval1fwdptr(undef)); -is(19, $o->byval2forwardptr(undef)); -is(20, $o->byval2forwardptr($x)); +is(19, $o->byval2fwdptr(undef)); +is(20, $o->byval2fwdptr($x)); -is(21, $o->byval1forwardref($x)); +is(21, $o->byval1fwdref($x)); -is(22, $o->byval2forwardref($x)); +is(22, $o->byval2fwdref($x)); diff --git a/Examples/test-suite/php/Makefile.in b/Examples/test-suite/php/Makefile.in index 693615bc6..b64918df7 100644 --- a/Examples/test-suite/php/Makefile.in +++ b/Examples/test-suite/php/Makefile.in @@ -11,10 +11,19 @@ top_builddir = @top_builddir@ CPP_TEST_CASES += \ callback \ + director_stl \ + exception_partial_info \ + inout \ + li_cdata_carrays_cpp \ li_factory \ php_iterator \ php_namewarn_rename \ php_pragma \ + prefix \ + +C_TEST_CASES += \ + li_cdata_carrays \ + multivalue \ include $(srcdir)/../common.mk @@ -62,9 +71,9 @@ missingtests: missingcpptests missingctests # found, runs testcase.php, except for multicpptests. run_testcase = \ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_SCRIPT=$(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) RUNTOOL='$(RUNTOOL)' php_run; \ + $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_EXTENSION=$(TARGETPREFIX)$*@PHP_SO@ PHP_SCRIPT=$(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) RUNTOOL='$(RUNTOOL)' php_run; \ elif [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*.php -a ! -f $(top_srcdir)/$(EXAMPLES)/$(TEST_SUITE)/$*.list ]; then \ - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_SCRIPT=$(SCRIPTDIR)/$(SCRIPTPREFIX)$*.php RUNTOOL='$(RUNTOOL)' php_run; \ + $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile PHP_EXTENSION=$(TARGETPREFIX)$*@PHP_SO@ PHP_SCRIPT=$(SCRIPTDIR)/$(SCRIPTPREFIX)$*.php RUNTOOL='$(RUNTOOL)' php_run; \ fi # Clean: remove the generated .php file diff --git a/Examples/test-suite/php/abstract_inherit_ok_runme.php b/Examples/test-suite/php/abstract_inherit_ok_runme.php index c2c343dac..6cfea2341 100644 --- a/Examples/test-suite/php/abstract_inherit_ok_runme.php +++ b/Examples/test-suite/php/abstract_inherit_ok_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "abstract_inherit_ok.php"; check::classes(array('Foo','Spam')); $spam=new Spam(); @@ -9,4 +8,3 @@ $spam=new Spam(); check::equal(0,$spam->blah(),"spam object method"); check::done(); -?> diff --git a/Examples/test-suite/php/abstract_inherit_runme.php b/Examples/test-suite/php/abstract_inherit_runme.php index 514bbc3b0..6a0180d78 100644 --- a/Examples/test-suite/php/abstract_inherit_runme.php +++ b/Examples/test-suite/php/abstract_inherit_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "abstract_inherit.php"; check::classes(array('Foo','Bar','Spam','NRFilter_i','NRRCFilter_i','NRRCFilterpro_i','NRRCFilterpri_i')); // This constructor attempt should fail as there isn't one @@ -11,4 +10,3 @@ check::classes(array('Foo','Bar','Spam','NRFilter_i','NRRCFilter_i','NRRCFilterp //check::equal(0,Spam::blah($spam),"spam class method"); check::done(); -?> diff --git a/Examples/test-suite/php/add_link_runme.php b/Examples/test-suite/php/add_link_runme.php index 3e16fa1df..073dee36d 100644 --- a/Examples/test-suite/php/add_link_runme.php +++ b/Examples/test-suite/php/add_link_runme.php @@ -1,10 +1,9 @@ <?php require "tests.php"; -require "add_link.php"; -// No new functions, except the flat functions -check::functions(array('new_foo','foo_blah')); +// No new functions +check::functions(array()); check::classes(array('Foo')); @@ -19,4 +18,3 @@ check::is_a($foo_blah,'foo'); //check::is_a($class_foo_blah,foo); check::done(); -?> diff --git a/Examples/test-suite/php/argout_runme.php b/Examples/test-suite/php/argout_runme.php index 8b66613fd..d233cf0f6 100644 --- a/Examples/test-suite/php/argout_runme.php +++ b/Examples/test-suite/php/argout_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "argout.php"; check::functions(array('incp','incr','inctr','new_intp','copy_intp','delete_intp','intp_assign','intp_value','voidhandle','handle')); @@ -22,17 +21,10 @@ check::equal(4,inctr($tr),"4==incr($tr)"); check::equal(5,intp_value($tr),"5==$tr"); # Check the voidhandle call, first with null -unset($handle); -# FIXME: Call-time pass-by-reference has been deprecated for ages, and was -# removed in PHP 5.4. We need to rework -#voidhandle(&$handle); -#check::resource($handle,"_p_void",'$handle is not _p_void'); -#$handledata=handle($handle); -#check::equal($handledata,"Here it is","\$handledata != \"Here it is\""); - $handle=NULL; voidhandle($handle); -check::isnull($handle,'$handle not null'); +check::equal(get_class($handle),"SWIG\\_p_void",'$handle is not _p_void'); +$handledata=handle($handle); +check::equal($handledata,"Here it is","\$handledata != \"Here it is\""); check::done(); -?> diff --git a/Examples/test-suite/php/arrayptr_runme.php b/Examples/test-suite/php/arrayptr_runme.php deleted file mode 100644 index 86b7f8628..000000000 --- a/Examples/test-suite/php/arrayptr_runme.php +++ /dev/null @@ -1,14 +0,0 @@ -<?php - -require "tests.php"; -require "arrayptr.php"; - -// No new functions -check::functions(array('foo')); -// No new classes -check::classes(array()); -// now new vars -check::globals(array()); - -check::done(); -?> diff --git a/Examples/test-suite/php/arrays_global_runme.php b/Examples/test-suite/php/arrays_global_runme.php index 95a300775..6a97db91e 100644 --- a/Examples/test-suite/php/arrays_global_runme.php +++ b/Examples/test-suite/php/arrays_global_runme.php @@ -1,11 +1,11 @@ <?php require "tests.php"; -require "arrays_global.php"; -check::functions(array('test_a','test_b','new_simplestruct','new_material')); +check::functions(array('test_a','test_b')); check::classes(array('arrays_global','SimpleStruct','Material')); -check::globals(array('array_c','array_sc','array_uc','array_s','array_us','array_i','array_ui','array_l','array_ul','array_ll','array_f','array_d','array_struct','array_structpointers','array_ipointers','array_enum','array_enumpointers','array_const_i','beginstring_fix44a','beginstring_fix44b','beginstring_fix44c','beginstring_fix44d','beginstring_fix44e','beginstring_fix44f','chitmat','hitmat_val','hitmat','simplestruct_double_field')); +check::globals(array('array_c','array_sc','array_uc','array_s','array_us','array_i','array_ui','array_l','array_ul','array_ll','array_f','array_d','array_struct','array_structpointers','array_ipointers','array_enum','array_enumpointers','array_const_i','BeginString_FIX44a','BeginString_FIX44b','BeginString_FIX44c','BeginString_FIX44d','BeginString_FIX44e','BeginString_FIX44f','chitMat','hitMat_val','hitMat')); + // The size of array_c is 2, but the last byte is \0, so we can only store a // single byte string in it. check::set("array_c","Z"); @@ -16,4 +16,3 @@ check::set("array_c","h"); check::equal("h",check::get("array_c"),"set array_c"); check::done(); -?> diff --git a/Examples/test-suite/php/arrays_global_twodim_runme.php b/Examples/test-suite/php/arrays_global_twodim_runme.php index d9f50a6de..e6fbf52d9 100644 --- a/Examples/test-suite/php/arrays_global_twodim_runme.php +++ b/Examples/test-suite/php/arrays_global_twodim_runme.php @@ -1,11 +1,11 @@ <?php require "tests.php"; -require "arrays_global_twodim.php"; -check::functions(array('fn_taking_arrays','get_2d_array','new_simplestruct','new_material')); +check::functions(array('fn_taking_arrays','get_2d_array',)); check::classes(array('arrays_global_twodim','SimpleStruct','Material')); -check::globals(array('array_c','array_sc','array_uc','array_s','array_us','array_i','array_ui','array_l','array_ul','array_ll','array_f','array_d','array_struct','array_structpointers','array_ipointers','array_enum','array_enumpointers','array_const_i','chitmat','hitmat_val','hitmat','simplestruct_double_field')); +check::globals(array('array_c','array_sc','array_uc','array_s','array_us','array_i','array_ui','array_l','array_ul','array_ll','array_f','array_d','array_struct','array_structpointers','array_ipointers','array_enum','array_enumpointers','array_const_i','chitMat','hitMat_val','hitMat')); + $a1=array(10,11,12,13); $a2=array(14,15,16,17); $a=array($a1,$a2); @@ -19,4 +19,3 @@ for($x=0;$x<count($a1);$x++) { } check::done(); -?> diff --git a/Examples/test-suite/php/arrays_runme.php b/Examples/test-suite/php/arrays_runme.php index c6e9e8f70..eb06fbfd8 100644 --- a/Examples/test-suite/php/arrays_runme.php +++ b/Examples/test-suite/php/arrays_runme.php @@ -1,10 +1,10 @@ <?php + require "tests.php"; -require "arrays.php"; check::functions(array('fn_taking_arrays','newintpointer','setintfrompointer','getintfrompointer','array_pointer_func')); check::classes(array('arrays','SimpleStruct','ArrayStruct','CartPoseData_t')); -check::globals(array('simplestruct_double_field','arraystruct_array_c','arraystruct_array_sc','arraystruct_array_uc','arraystruct_array_s','arraystruct_array_us','arraystruct_array_i','arraystruct_array_ui','arraystruct_array_l','arraystruct_array_ul','arraystruct_array_ll','arraystruct_array_f','arraystruct_array_d','arraystruct_array_struct','arraystruct_array_structpointers','arraystruct_array_ipointers','arraystruct_array_enum','arraystruct_array_enumpointers','arraystruct_array_const_i','cartposedata_t_p')); +check::globals(array()); $ss=new simplestruct(); check::classname('simplestruct',$ss); @@ -15,4 +15,3 @@ check::equal($as->array_c,"a",'$as->array_c=="a"'); check::equal(isset($as->array_const_i),TRUE,'isset($as->array_const_i)'); check::done(); -?> diff --git a/Examples/test-suite/php/arrays_scope_runme.php b/Examples/test-suite/php/arrays_scope_runme.php index 11c180870..f18037ca7 100644 --- a/Examples/test-suite/php/arrays_scope_runme.php +++ b/Examples/test-suite/php/arrays_scope_runme.php @@ -1,16 +1,14 @@ <?php require "tests.php"; -require "arrays_scope.php"; -// New functions -check::functions(array('new_bar','bar_blah')); +// No new functions +check::functions(array()); // New classes check::classes(array('arrays_scope','Bar')); -// New vars -check::globals(array('bar_adata','bar_bdata','bar_cdata')); +// No new globals +check::globals(array()); $bar=new bar(); check::done(); -?> diff --git a/Examples/test-suite/php/callback_runme.php b/Examples/test-suite/php/callback_runme.php index fefa32502..717185649 100644 --- a/Examples/test-suite/php/callback_runme.php +++ b/Examples/test-suite/php/callback_runme.php @@ -1,9 +1,10 @@ <?php require "tests.php"; -require "callback.php"; + // In 2.0.6 and earlier, the constant was misnamed. -if (gettype(callback::FOO_I_Cb_Ptr) !== 'resource') die("callback::FOO_I_Cb_Ptr not a resource\n"); +check::equal(gettype(callback::FOO_I_Cb_Ptr), 'object', "callback::FOO_I_Cb_Ptr not an object"); + +check::equal(get_class(callback::FOO_I_Cb_Ptr), 'SWIG\_p_f_int__int', "callback::FOO_I_Cb_Ptr not expected class"); check::done(); -?> diff --git a/Examples/test-suite/php/casts_runme.php b/Examples/test-suite/php/casts_runme.php index a9623a328..6234f0fab 100644 --- a/Examples/test-suite/php/casts_runme.php +++ b/Examples/test-suite/php/casts_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "casts.php"; // No new functions -check::functions(array('new_a','a_hello','new_b')); -// No new classes +check::functions(array()); +// New classes check::classes(array('A','B')); -// now new vars +// No new vars check::globals(array()); # Make sure $b inherits hello() from class A @@ -15,4 +14,3 @@ $b=new B(); $b->hello(); check::done(); -?> diff --git a/Examples/test-suite/php/char_strings_runme.php b/Examples/test-suite/php/char_strings_runme.php index e06ee9d2b..7dc8fe74d 100644 --- a/Examples/test-suite/php/char_strings_runme.php +++ b/Examples/test-suite/php/char_strings_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "char_strings.php"; $CPLUSPLUS_MSG = "A message from the deep dark world of C++, where anything is possible."; $OTHERLAND_MSG_10 = "Little message from the safe world.10"; @@ -40,4 +39,3 @@ check::equal(GetConstCharPointerRef(), $CPLUSPLUS_MSG, "failed GetConstCharPoint check::equal(SetConstCharPointerRef($OTHERLAND_MSG_10, 10), true, "failed SetConstCharPointerRef"); check::done(); -?> diff --git a/Examples/test-suite/php/class_ignore_runme.php b/Examples/test-suite/php/class_ignore_runme.php index ae4881f27..f52bc1a13 100644 --- a/Examples/test-suite/php/class_ignore_runme.php +++ b/Examples/test-suite/php/class_ignore_runme.php @@ -1,9 +1,8 @@ <?php require "tests.php"; -require "class_ignore.php"; -check::functions(array('do_blah','new_bar','bar_blah','new_boo','boo_away','new_far','new_hoo')); +check::functions(array('do_blah')); check::classes(array('class_ignore','Bar','Boo','Far','Hoo')); // No new vars check::globals(array()); @@ -13,4 +12,3 @@ do_blah($bar); check::classparent($bar,""); check::done(); -?> diff --git a/Examples/test-suite/php/conversion_namespace_runme.php b/Examples/test-suite/php/conversion_namespace_runme.php index e21ff7438..858bf89d9 100644 --- a/Examples/test-suite/php/conversion_namespace_runme.php +++ b/Examples/test-suite/php/conversion_namespace_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "conversion_namespace.php"; check::classes(array("Foo","Bar")); $bar=new Bar; @@ -10,4 +9,3 @@ $foo=$bar->toFoo(); check::classname("foo",$foo); check::done(); -?> diff --git a/Examples/test-suite/php/conversion_ns_template_runme.php b/Examples/test-suite/php/conversion_ns_template_runme.php index 9702eedb7..4157b106a 100644 --- a/Examples/test-suite/php/conversion_ns_template_runme.php +++ b/Examples/test-suite/php/conversion_ns_template_runme.php @@ -1,10 +1,8 @@ <?php require "tests.php"; -require "conversion_ns_template.php"; check::classes(array("conversion_ns_template","Foo_One","Bar_One","Hi")); // this is too hard, I'm not sure what to test for, check::done(); -?> diff --git a/Examples/test-suite/php/conversion_runme.php b/Examples/test-suite/php/conversion_runme.php index 1a10ff4f4..858bf89d9 100644 --- a/Examples/test-suite/php/conversion_runme.php +++ b/Examples/test-suite/php/conversion_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "conversion.php"; check::classes(array("Foo","Bar")); $bar=new Bar; @@ -10,4 +9,3 @@ $foo=$bar->toFoo(); check::classname("foo",$foo); check::done(); -?> diff --git a/Examples/test-suite/php/cpp11_strongly_typed_enumerations_runme.php b/Examples/test-suite/php/cpp11_strongly_typed_enumerations_runme.php index bee59b209..82296deb7 100644 --- a/Examples/test-suite/php/cpp11_strongly_typed_enumerations_runme.php +++ b/Examples/test-suite/php/cpp11_strongly_typed_enumerations_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "cpp11_strongly_typed_enumerations.php"; function enumCheck($actual, $expected) { check::equal($actual, $expected, "Enum value mismatch"); @@ -165,5 +164,3 @@ enumCheck($class1->class1Test2(Class1::Enum12_Val5c), 1121); enumCheck(globalTest1(Enum1_Val5a), 13); enumCheck(globalTest2(Class1::Enum12_Val5c), 1121); #enumCheck(globalTest3(Class1::Struct1.Enum12_Val5f), 3121); - -?> diff --git a/Examples/test-suite/php/cpp_basic_runme.php b/Examples/test-suite/php/cpp_basic_runme.php index b24cf7000..fb34bc936 100644 --- a/Examples/test-suite/php/cpp_basic_runme.php +++ b/Examples/test-suite/php/cpp_basic_runme.php @@ -1,14 +1,13 @@ <?php require "tests.php"; -require "cpp_basic.php"; // New functions -check::functions(array('foo_func1','foo_func2','foo___str__','foosubsub___str__','bar_test','bar_testfoo','get_func1_ptr','get_func2_ptr','test_func_ptr','fl_window_show')); +check::functions(array('get_func1_ptr','get_func2_ptr','test_func_ptr')); // New classes check::classes(array('cpp_basic','Foo','FooSub','FooSubSub','Bar','Fl_Window')); -// New vars -check::globals(array('foo_num','foo_func_ptr','bar_fptr','bar_fref','bar_fval','bar_cint','bar_global_fptr','bar_global_fref','bar_global_fval')); +// No new vars +check::globals(array()); $f = new Foo(3); $f->func_ptr = get_func1_ptr(); @@ -16,5 +15,12 @@ check::equal(test_func_ptr($f, 7), 2*7*3, "get_func1_ptr() didn't work"); $f->func_ptr = get_func2_ptr(); check::equal(test_func_ptr($f, 7), -7*3, "get_func2_ptr() didn't work"); +// Test that custom properties work - standard PHP objects support them, +// so PHP developers will expect them to work for SWIG-wrapped objects too. +check::equal($f->custom_prop, NULL, "Test unset custom property"); +$f->custom_prop = "test"; +check::equal($f->custom_prop, "test", "Test custom property setting"); +$f->custom_prop = 42; +check::equal($f->custom_prop, 42, "Test custom property setting"); + check::done(); -?> diff --git a/Examples/test-suite/php/cpp_static_runme.php b/Examples/test-suite/php/cpp_static_runme.php index 20b50dd9e..a1fd85c2e 100644 --- a/Examples/test-suite/php/cpp_static_runme.php +++ b/Examples/test-suite/php/cpp_static_runme.php @@ -1,14 +1,12 @@ <?php require "tests.php"; -require "cpp_static.php"; // New functions -check::functions(array('staticfunctiontest_static_func','staticfunctiontest_static_func_2','staticfunctiontest_static_func_3','is_python_builtin','staticmembertest_grab_int','staticbase_grab_statty_base','staticderived_grab_statty_derived')); +check::functions(array('is_python_builtin')); // New classes check::classes(array('StaticMemberTest','StaticFunctionTest','cpp_static','StaticBase','StaticDerived')); -// New vars -check::globals(array('staticmembertest_static_int','staticbase_statty','staticderived_statty')); +// No new vars +check::globals(array()); check::done(); -?> diff --git a/Examples/test-suite/php/director_abstract_runme.php b/Examples/test-suite/php/director_abstract_runme.php index 1a119cfd5..bb424f9ea 100644 --- a/Examples/test-suite/php/director_abstract_runme.php +++ b/Examples/test-suite/php/director_abstract_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_abstract.php"; -// No new functions -check::functions(array('foo_ping','foo_pong','example0_getxsize','example0_color','example0_get_color','example1_getxsize','example1_color','example1_get_color','example2_getxsize','example2_color','example2_get_color','example4_getxsize','example4_color','example4_get_color','example3_i_color','example3_i_get_color','g','a_f')); -// No new classes +// New functions +check::functions(array('g')); +// New classes check::classes(array('director_abstract','Foo','Example0','Example1','Example2','Example4','Example3_i','A')); -// now new vars +// No new vars check::globals(array()); class MyFoo extends Foo { @@ -59,4 +58,3 @@ $class = new ReflectionClass('Example3_i'); check::equal($class->isAbstract(), true, "Example3_i abstractness failed"); check::done(); -?> diff --git a/Examples/test-suite/php/director_basic_runme.php b/Examples/test-suite/php/director_basic_runme.php index 478a36f80..db7adefc1 100644 --- a/Examples/test-suite/php/director_basic_runme.php +++ b/Examples/test-suite/php/director_basic_runme.php @@ -1,14 +1,12 @@ <?php require "tests.php"; -require "director_basic.php"; // No new functions -check::functions(array('foo_ping','foo_pong','foo_get_self','a_f','a_rg','a1_ff','myclass_method','myclass_vmethod','myclass_pmethod','myclass_cmethod','myclass_get_self','myclass_call_pmethod','myclasst_i_method','myclass_nonvirtual','myclass_nonoverride','myclass_call_nonvirtual','myclass_call_nonoverride','myclass_connect')); -// No new classes -check::classes(array('Foo','A','A1','Bar','MyClass','MyClassT_i')); -// now new vars -check::globals(array('bar_x')); +check::functions(array()); +check::classes(array('Foo','A','A1','Bar','MyClass','MyClassT_i','ConstPtrClass')); +// No new vars +check::globals(array()); class PhpFoo extends Foo { function ping() { @@ -55,4 +53,3 @@ check::equal($bc->x, 34, "bc failed"); check::equal($bd->x, 16, "bd failed"); check::done(); -?> diff --git a/Examples/test-suite/php/director_classic_runme.php b/Examples/test-suite/php/director_classic_runme.php index a44881e04..e2ac1f7a7 100644 --- a/Examples/test-suite/php/director_classic_runme.php +++ b/Examples/test-suite/php/director_classic_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_classic.php"; // No new functions -check::functions(array('being_id','person_id','child_id','grandchild_id','caller_delcallback','caller_setcallback','caller_resetcallback','caller_call','caller_baseclass')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Being','Person','Child','GrandChild','OrphanPerson','OrphanChild','Caller')); -// now new vars +// No new vars check::globals(array()); class TargetLangPerson extends Person { @@ -81,11 +80,7 @@ function mycheck($person, $expected) { $ret = $baseclass->id(); if ($debug) print $ret . "\n"; - # TODO: Currently we do not track the dynamic type of returned - # objects, so in case it's possible that the dynamic type is not equal - # to the static type, we skip this check. - if (get_parent_class($person) === false) - check::equal($ret, $expected, "#3 failed"); + check::equal($ret, $expected, "#3 failed"); $caller->resetCallback(); if ($debug) @@ -147,4 +142,3 @@ mycheck($person, "TargetLangOrphanChild"); unset($person); check::done(); -?> diff --git a/Examples/test-suite/php/director_default_runme.php b/Examples/test-suite/php/director_default_runme.php index c459ce3ec..92e415041 100644 --- a/Examples/test-suite/php/director_default_runme.php +++ b/Examples/test-suite/php/director_default_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_default.php"; // No new functions -check::functions(array('foo_msg','foo_getmsg','bar_msg','bar_getmsg','defaultsbase_defaultargs','defaultsderived_defaultargs')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Foo','Bar','DefaultsBase','DefaultsDerived')); -// now new vars +// No new vars check::globals(array()); $f = new Foo(); @@ -17,4 +16,3 @@ $f = new Bar(); $f = new Bar(1); check::done(); -?> diff --git a/Examples/test-suite/php/director_detect_runme.php b/Examples/test-suite/php/director_detect_runme.php index a6d3aebd6..ae92f7a0c 100644 --- a/Examples/test-suite/php/director_detect_runme.php +++ b/Examples/test-suite/php/director_detect_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_detect.php"; // No new functions -check::functions(array('foo_cloner','foo_get_value','foo_get_class','foo_just_do_it','bar_baseclass','bar_cloner','bar_get_value','bar_get_class','bar_just_do_it')); -// No new classes +check::functions(array()); +// New classes check::classes(array('A','Foo','Bar')); -// now new vars +// No new vars check::globals(array()); class MyBar extends Bar { @@ -52,4 +51,3 @@ check::equal($b->val, 5, "b: Bad virtual detection"); check::equal($vc, 6, "c: Bad virtual detection"); check::done(); -?> diff --git a/Examples/test-suite/php/director_enum_runme.php b/Examples/test-suite/php/director_enum_runme.php index 0571ec0da..21e07a57b 100644 --- a/Examples/test-suite/php/director_enum_runme.php +++ b/Examples/test-suite/php/director_enum_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_enum.php"; // No new functions -check::functions(array('foo_say_hello','foo_say_hi','foo_say_bye','foo_say_hi_ref','foo_ping','foo_ping_ref','foo_ping_member_enum','a_f','a2_f')); -// No new classes +check::functions(array()); +// New classes check::classes(array('director_enum','Foo','A','B','A2','B2')); -// now new vars +// No new vars check::globals(array()); class MyFoo extends Foo { @@ -22,4 +21,3 @@ $a = new MyFoo(); check::equal($a->say_hi(director_enum::hello), $b->say_hello(director_enum::hi), "say failed"); check::done(); -?> diff --git a/Examples/test-suite/php/director_exception_runme.php b/Examples/test-suite/php/director_exception_runme.php index dd2d04e8a..e49c12da6 100644 --- a/Examples/test-suite/php/director_exception_runme.php +++ b/Examples/test-suite/php/director_exception_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_exception.php"; -// No new functions -check::functions(array('foo_ping','foo_pong','launder','bar_ping','bar_pong','returnalltypes_return_int','returnalltypes_return_double','returnalltypes_return_const_char_star','returnalltypes_return_std_string','returnalltypes_return_bar','returnalltypes_call_int','returnalltypes_call_double','returnalltypes_call_const_char_star','returnalltypes_call_std_string','returnalltypes_call_bar','is_python_builtin')); -// No new classes +// New functions +check::functions(array('launder','is_python_builtin')); +// New classes check::classes(array('director_exception','Foo','Exception1','Exception2','Base','Bar','ReturnAllTypes')); -// now new vars +// No new vars check::globals(array()); class MyException extends Exception { @@ -38,9 +37,7 @@ class MyFoo3 extends Foo { # MyFoo.pong(). $ok = 0; $a = new MyFoo(); -# TODO: Currently we do not track the dynamic type of returned -# objects, so we skip the launder() call. -#$b = director_exception::launder($a); +$b = director_exception::launder($a); $b = $a; try { $b->pong(); @@ -124,4 +121,3 @@ try { } check::done(); -?> diff --git a/Examples/test-suite/php/director_extend_runme.php b/Examples/test-suite/php/director_extend_runme.php index 7aa2e0f78..418985476 100644 --- a/Examples/test-suite/php/director_extend_runme.php +++ b/Examples/test-suite/php/director_extend_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_extend.php"; // No new functions -check::functions(array('spobject_getfoobar','spobject_dummy','spobject_exceptionmethod')); -// No new classes +check::functions(array()); +// New classes check::classes(array('SpObject')); -// now new vars +// No new vars check::globals(array()); class MyObject extends SpObject{ @@ -21,4 +20,3 @@ check::equal($m->dummy(), 666, "1st call"); check::equal($m->dummy(), 666, "2st call"); // Locked system check::done(); -?> diff --git a/Examples/test-suite/php/director_finalizer_runme.php b/Examples/test-suite/php/director_finalizer_runme.php index 96bb5c179..f3a0c2c40 100644 --- a/Examples/test-suite/php/director_finalizer_runme.php +++ b/Examples/test-suite/php/director_finalizer_runme.php @@ -1,18 +1,22 @@ <?php require "tests.php"; -require "director_finalizer.php"; -// No new functions -check::functions(array('foo_orstatus','deletefoo','getstatus','launder','resetstatus')); -// No new classes +// New functions +check::functions(array('deleteFoo','getStatus','launder','resetStatus')); +// New classes check::classes(array('director_finalizer','Foo')); -// now new vars +// No new vars check::globals(array()); class MyFoo extends Foo { function __destruct() { - $this->orStatus(2); + # It's not safe to call methods on the C++ object from the PHP destructor + # if the object has been disowned, since the C++ object will already have + # been destroyed by the time the PHP destructor runs. + if ($this->thisown) { + $this->orStatus(2); + } if (method_exists(get_parent_class(), "__destruct")) { parent::__destruct(); } @@ -41,21 +45,24 @@ resetStatus(); $a = new MyFoo(); $a->thisown = 0; +check::equal(getStatus(), 0, "shadow release does not fire destructor of disowned object"); + deleteFoo($a); unset($a); -check::equal(getStatus(), 3, "getStatus() failed #4"); +# getStatus() would ideally return 3 here. +check::equal(getStatus(), 1, "getStatus() failed #4"); resetStatus(); $a = new MyFoo(); $a->thisown = 0; -deleteFoo(launder($a)); +$g = launder($a); unset($a); - -check::equal(getStatus(), 3, "getStatus() failed #5"); +deleteFoo($g); +# getStatus() would ideally return 3 here. +check::equal(getStatus(), 1, "getStatus() failed #5"); resetStatus(); check::done(); -?> diff --git a/Examples/test-suite/php/director_frob_runme.php b/Examples/test-suite/php/director_frob_runme.php index 450a1234b..732b9d500 100644 --- a/Examples/test-suite/php/director_frob_runme.php +++ b/Examples/test-suite/php/director_frob_runme.php @@ -1,14 +1,13 @@ <?php require "tests.php"; -require "director_frob.php"; // No new functions -check::functions(array('alpha_abs_method','bravo_abs_method','charlie_abs_method','ops_opint','ops_opintstarstarconst','ops_opintamp','ops_opintstar','ops_opconstintintstar','prims_ull','prims_callull','corecallbacks_on3dengineredrawn','corecallbacks_on3dengineredrawn2')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Alpha','Bravo','Charlie','Delta','Ops','Prims','corePoint3d','coreCallbacks_On3dEngineRedrawnData','coreCallbacksOn3dEngineRedrawnData','coreCallbacks')); -// now new vars -check::globals(array('corecallbacks_on3dengineredrawndata__eye','corecallbacks_on3dengineredrawndata__at','corecallbackson3dengineredrawndata__eye','corecallbackson3dengineredrawndata__at')); +// No new vars +check::globals(array()); $foo = new Bravo(); $s = $foo->abs_method(); @@ -16,4 +15,3 @@ $s = $foo->abs_method(); check::equal($s, "Bravo::abs_method()", "s failed"); check::done(); -?> diff --git a/Examples/test-suite/php/director_nested_runme.php b/Examples/test-suite/php/director_nested_runme.php index 9a094a182..adf9f6206 100644 --- a/Examples/test-suite/php/director_nested_runme.php +++ b/Examples/test-suite/php/director_nested_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_nested.php"; // No new functions -check::functions(array('foo_int_advance','foo_int_do_advance','bar_step','bar_do_advance','bar_do_step','foobar_int_get_value','foobar_int_get_name','foobar_int_name','foobar_int_get_self','foobar_int_do_advance','foobar_int_do_step')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Foo_int','Bar','FooBar_int')); -// now new vars +// No new vars check::globals(array()); class A extends FooBar_int { @@ -60,10 +59,7 @@ class C extends FooBar_int { } $cc = new C(); -# TODO: Currently we do not track the dynamic type of returned -# objects, so we skip the get_self() call. -#$c = Foobar_int::get_self($cc); -$c = $cc; +$c = Foobar_int::get_self($cc); $c->advance(); check::equal($c->get_name(), "FooBar::get_name hello", "get_name failed"); @@ -71,4 +67,3 @@ check::equal($c->get_name(), "FooBar::get_name hello", "get_name failed"); check::equal($c->name(), "FooBar::get_name hello", "name failed"); check::done(); -?> diff --git a/Examples/test-suite/php/director_overload_runme.php b/Examples/test-suite/php/director_overload_runme.php new file mode 100644 index 000000000..07b485d95 --- /dev/null +++ b/Examples/test-suite/php/director_overload_runme.php @@ -0,0 +1,14 @@ +<?php + +require "tests.php"; + +check::functions(array()); +check::classes(array('OverloadedClass','OverloadedPointers','OverloadedGetSet')); +check::globals(array()); + +$o = new OverloadedGetSet; +check::equal($o->rw(), 42, "get_set() initial value not 42"); +check::equal($o->rw(7), null, "get_set() failed to set"); +check::equal($o->rw(), 7, "get_set() didn't return back set value"); + +check::done(); diff --git a/Examples/test-suite/php/director_pass_by_value_runme.php b/Examples/test-suite/php/director_pass_by_value_runme.php index 8a8b84d67..d3763292f 100644 --- a/Examples/test-suite/php/director_pass_by_value_runme.php +++ b/Examples/test-suite/php/director_pass_by_value_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "director_pass_by_value.php"; $passByVal = null; @@ -21,4 +20,3 @@ if ($ret != 0x12345678) { } check::done(); -?> diff --git a/Examples/test-suite/php/director_profile_runme.php b/Examples/test-suite/php/director_profile_runme.php index c6f4c3c94..219ec815a 100644 --- a/Examples/test-suite/php/director_profile_runme.php +++ b/Examples/test-suite/php/director_profile_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_profile.php"; // No new functions -check::functions(array('b_fn','b_vfi','b_fi','b_fj','b_fk','b_fl','b_get_self','b_vfs','b_fs')); -// No new classes +check::functions(array()); +// New classes check::classes(array('A','B')); -// now new vars +// No new vars check::globals(array()); class MyB extends B { @@ -50,4 +49,3 @@ while ($i) { print $a . "\n"; check::done(); -?> diff --git a/Examples/test-suite/php/director_protected_runme.php b/Examples/test-suite/php/director_protected_runme.php index e759fed25..b73c8f872 100644 --- a/Examples/test-suite/php/director_protected_runme.php +++ b/Examples/test-suite/php/director_protected_runme.php @@ -1,11 +1,12 @@ <?php require "tests.php"; -require "director_protected.php"; -check::functions(array('foo_pong','foo_s','foo_q','foo_ping','foo_pang','foo_used','foo_cheer','bar_create','bar_callping','bar_callcheer','bar_cheer','bar_pong','bar_used','bar_ping','bar_pang','a_draw','b_draw')); +// No new functions +check::functions(array()); check::classes(array('Foo','Bar','PrivateFoo','A','B','AA','BB')); -check::globals(array('bar_a')); +// No new vars +check::globals(array()); class FooBar extends Bar { protected function ping() { @@ -67,4 +68,3 @@ check::equal($fb3->callping(), "Bar::ping();", "bad fb3::callping"); check::equal($fb3->callcheer(), "FooBar3::cheer();", "bad fb3::callcheer"); check::done(); -?> diff --git a/Examples/test-suite/php/director_stl_runme.php b/Examples/test-suite/php/director_stl_runme.php index f7a5c0aa0..654251a30 100644 --- a/Examples/test-suite/php/director_stl_runme.php +++ b/Examples/test-suite/php/director_stl_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "director_stl.php"; // No new functions -check::functions(array('foo_bar','foo_ping','foo_pong','foo_tping','foo_tpong','foo_pident','foo_vident','foo_vsecond','foo_tpident','foo_tvident','foo_tvsecond','foo_vidents','foo_tvidents')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Foo')); -// now new vars +// No new vars check::globals(array()); class MyFoo extends Foo { @@ -57,4 +56,3 @@ $vs; $a->tvidents($vs);*/ check::done(); -?> diff --git a/Examples/test-suite/php/director_string_runme.php b/Examples/test-suite/php/director_string_runme.php index 77e84c9bf..3127f13fb 100644 --- a/Examples/test-suite/php/director_string_runme.php +++ b/Examples/test-suite/php/director_string_runme.php @@ -1,14 +1,13 @@ <?php require "tests.php"; -require "director_string.php"; // No new functions -check::functions(array('a_get_first','a_call_get_first','a_string_length','a_process_text','a_call_process_func','stringvector_size','stringvector_is_empty','stringvector_clear','stringvector_push','stringvector_pop','stringvector_capacity','stringvector_reserve')); -// No new classes +check::functions(array()); +// New classes check::classes(array('A','StringVector')); -// now new vars -check::globals(array('a','a_call','a_m_strings','stringvector')); +// No new vars +check::globals(array()); class B extends A { function get_first() { @@ -31,4 +30,3 @@ $b->call_process_func(); check::equal($b->smem, "hello", "smem failed"); check::done(); -?> diff --git a/Examples/test-suite/php/director_thread_runme.php b/Examples/test-suite/php/director_thread_runme.php index 2a640a022..190dbad71 100644 --- a/Examples/test-suite/php/director_thread_runme.php +++ b/Examples/test-suite/php/director_thread_runme.php @@ -1,18 +1,17 @@ <?php require "tests.php"; -require "director_thread.php"; # Fails in a ZTS-build of PHP5 - see: https://github.com/swig/swig/pull/155 # FIXME: Does this still fail in a threaded build of PHP7? exit(0); -// No new functions +// New functions check::functions(array('millisecondsleep','foo_stop','foo_run','foo_do_foo')); -// No new classes +// New classes check::classes(array('director_thread','Foo')); -// now new vars -check::globals(array('foo_val')); +// No new vars +check::globals(array()); class Derived extends Foo { function do_foo() { @@ -30,4 +29,3 @@ if ($d->val >= 0) { $d->stop(); check::done(); -?> diff --git a/Examples/test-suite/php/director_unroll_runme.php b/Examples/test-suite/php/director_unroll_runme.php index e3101887d..7f94753f5 100644 --- a/Examples/test-suite/php/director_unroll_runme.php +++ b/Examples/test-suite/php/director_unroll_runme.php @@ -1,14 +1,13 @@ <?php require "tests.php"; -require "director_unroll.php"; // No new functions -check::functions(array('foo_ping','foo_pong')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Foo','Bar')); -// now new vars -check::globals(array('bar')); +// No new vars +check::globals(array()); class MyFoo extends Foo { function ping() { @@ -23,10 +22,7 @@ $b = new Bar(); $b->set($a); $c = $b->get(); -// FIXME: This doesn't work for checking that they wrap the same C++ object -// because the two objects have different PHP resources, and we can't easily -// look inside those resources to see which C++ objects they refer to. -//check::equal($a->_cPtr, $c->_cPtr, "_cPtr check failed"); +// FIXME: The python version checks that a.this == c.this, but we don't seem +// to have a way to check this with the PHP bindings we generate. check::done(); -?> diff --git a/Examples/test-suite/php/enum_scope_template_runme.php b/Examples/test-suite/php/enum_scope_template_runme.php index 85ba467b7..d5aed62f7 100644 --- a/Examples/test-suite/php/enum_scope_template_runme.php +++ b/Examples/test-suite/php/enum_scope_template_runme.php @@ -1,15 +1,16 @@ <?php require "tests.php"; -require "enum_scope_template.php"; +check::functions(array("chops")); check::classes(array("enum_scope_template", "TreeInt")); -check::functions(array("chops","treeint_chops")); -check::equal(0,TreeInt_Oak,"0==TreeInt_Oak"); -check::equal(1,TreeInt_Fir,"1==TreeInt_Fir"); -check::equal(2,TreeInt_Cedar,"2==TreeInt_Cedar"); -check::equal(TreeInt_Oak,chops(TreeInt_Oak),"TreeInt_Oak==chops(TreeInt_Oak)"); -check::equal(TreeInt_Fir,chops(TreeInt_Fir),"TreeInt_Fir==chops(TreeInt_Fir)"); -check::equal(TreeInt_Cedar,chops(TreeInt_Cedar),"TreeInt_Cedar==chops(TreeInt_Cedar)"); +// No new vars +check::globals(array()); + +check::equal(0,TreeInt::Oak,"0==TreeInt_Oak"); +check::equal(1,TreeInt::Fir,"1==TreeInt_Fir"); +check::equal(2,TreeInt::Cedar,"2==TreeInt_Cedar"); +check::equal(TreeInt::Oak,chops(TreeInt::Oak),"TreeInt_Oak==chops(TreeInt_Oak)"); +check::equal(TreeInt::Fir,chops(TreeInt::Fir),"TreeInt_Fir==chops(TreeInt_Fir)"); +check::equal(TreeInt::Cedar,chops(TreeInt::Cedar),"TreeInt_Cedar==chops(TreeInt_Cedar)"); check::done(); -?> diff --git a/Examples/test-suite/php/evil_diamond_ns_runme.php b/Examples/test-suite/php/evil_diamond_ns_runme.php index fcce0f767..f2115bf36 100644 --- a/Examples/test-suite/php/evil_diamond_ns_runme.php +++ b/Examples/test-suite/php/evil_diamond_ns_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "evil_diamond_ns.php"; check::classes(array("evil_diamond_ns","foo","bar","baz","spam")); check::functions("test"); @@ -15,4 +14,3 @@ $spam=new spam(); $_spam=test($spam); check::done(); -?> diff --git a/Examples/test-suite/php/evil_diamond_prop_runme.php b/Examples/test-suite/php/evil_diamond_prop_runme.php index 9bdb7435f..611f17d6a 100644 --- a/Examples/test-suite/php/evil_diamond_prop_runme.php +++ b/Examples/test-suite/php/evil_diamond_prop_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "evil_diamond_prop.php"; check::classes(array("evil_diamond_prop","foo","bar","baz","spam")); check::functions("test"); @@ -31,10 +30,7 @@ check::is_a($spam,"spam"); check::equal(1,$spam->_foo,"1==spam->_foo"); check::equal(2,$spam->_bar,"2==spam->_bar"); // multiple inheritance not supported in PHP -set_error_handler(NULL, 0); // Don't complain that _baz is unknown. check::equal(null,$spam->_baz,"null==spam->_baz"); -restore_error_handler(); check::equal(4,$spam->_spam,"4==spam->_spam"); check::done(); -?> diff --git a/Examples/test-suite/php/evil_diamond_runme.php b/Examples/test-suite/php/evil_diamond_runme.php index a587ca359..7d01c98ec 100644 --- a/Examples/test-suite/php/evil_diamond_runme.php +++ b/Examples/test-suite/php/evil_diamond_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "evil_diamond.php"; check::classes(array("evil_diamond","foo","bar","baz","spam")); check::functions("test"); @@ -13,4 +12,3 @@ check::is_a("spam","bar"); //check::is_a("spam","baz"); check::done(); -?> diff --git a/Examples/test-suite/php/exception_order_runme.php b/Examples/test-suite/php/exception_order_runme.php index 77f115fa1..9a2c9118b 100644 --- a/Examples/test-suite/php/exception_order_runme.php +++ b/Examples/test-suite/php/exception_order_runme.php @@ -1,10 +1,9 @@ <? require "tests.php"; -require "exception_order.php"; -check::functions(array('a_foo','a_bar','a_foobar','a_barfoo','is_python_builtin')); +check::functions(array('is_python_builtin')); check::classes(array('A','E1','E2','E3','exception_order','ET_i','ET_d')); -check::globals(array('efoovar','foovar','cfoovar','a_sfoovar','a_foovar','a_efoovar')); +check::globals(array('efoovar','foovar','cfoovar')); $a = new A(); try { @@ -36,4 +35,3 @@ try { } catch (Exception $e) { check::equal($e->getMessage(), 'C++ E2 * exception thrown', ''); } -?> diff --git a/Examples/test-suite/php/extend_template_ns_runme.php b/Examples/test-suite/php/extend_template_ns_runme.php index e6d3e9f73..46158672b 100644 --- a/Examples/test-suite/php/extend_template_ns_runme.php +++ b/Examples/test-suite/php/extend_template_ns_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "extend_template_ns.php"; check::classes(array("extend_template_ns","Foo_One")); $foo=new Foo_One(); @@ -9,4 +8,3 @@ check::equal(2,$foo->test1(2),"test1"); check::equal(3,$foo->test2(3),"test2"); check::done(); -?> diff --git a/Examples/test-suite/php/extend_template_runme.php b/Examples/test-suite/php/extend_template_runme.php index 41bde4458..a6579dce9 100644 --- a/Examples/test-suite/php/extend_template_runme.php +++ b/Examples/test-suite/php/extend_template_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "extend_template.php"; check::classes(array("Foo_0")); $foo=new Foo_0(); @@ -9,4 +8,3 @@ check::equal(2,$foo->test1(2),"test1"); check::equal(3,$foo->test2(3),"test2"); check::done(); -?> diff --git a/Examples/test-suite/php/global_vars_runme.php b/Examples/test-suite/php/global_vars_runme.php new file mode 100644 index 000000000..c3fe7d8aa --- /dev/null +++ b/Examples/test-suite/php/global_vars_runme.php @@ -0,0 +1,27 @@ +<?php + +require "tests.php"; + +check::functions(array('init','read_b','read_x')); +check::classes(array('A','global_vars')); +check::globals(array('b','a','ap','cap','ar','x','xp','c_member','vp','h','hp','hr')); + +$an = new A(); +check::classname('A', $an); +ap_set($an); +check::classname('A', ap_get()); +check::equivalent(ap_get(), $an, "global var assignment"); + +x_set(17); +check::equal(x_get(), 17, "global var assignment"); +check::equal(read_x(), 17, "PHP global var change visible in C++"); +init(); +check::equal(x_get(), 1234, "C++ global var change visible in PHP"); + +b_set('test'); +check::equal(b_get(), 'test', "global var assignment"); +check::equal(read_b(), 'test', "PHP global var change visible in C++"); +init(); +check::equal(b_get(), 'string b', "C++ global var change visible in PHP"); + +check::done(); diff --git a/Examples/test-suite/php/grouping_runme.php b/Examples/test-suite/php/grouping_runme.php index 8bad7cd4c..d2b849d1c 100644 --- a/Examples/test-suite/php/grouping_runme.php +++ b/Examples/test-suite/php/grouping_runme.php @@ -1,11 +1,10 @@ <?php require "tests.php"; -require "grouping.php"; check::functions(array("test1","test2","do_unary","negate")); check::equal(5,test1(5),"5==test1(5)"); -check::resource(test2(7),"_p_int","_p_int==test2(7)"); +check::equal(get_class(test2(7)),"SWIG\\_p_int","test2(7) is _p_int"); check::globals(array('test3')); //check::equal(37,test3_get(),'37==test3_get()'); @@ -19,4 +18,3 @@ check::equal(-5,negate(5),"-5==negate(5)"); check::equal(7,do_unary(-7,NEGATE),"7=do_unary(-7,NEGATE)"); check::done(); -?> diff --git a/Examples/test-suite/php/ignore_parameter_runme.php b/Examples/test-suite/php/ignore_parameter_runme.php index b9c2b777d..d9db2d795 100644 --- a/Examples/test-suite/php/ignore_parameter_runme.php +++ b/Examples/test-suite/php/ignore_parameter_runme.php @@ -1,10 +1,9 @@ <?php require "tests.php"; -require "ignore_parameter.php"; // New functions -check::functions(array('jaguar','lotus','tvr','ferrari','fiat','sportscars_daimler','sportscars_astonmartin','sportscars_bugatti','sportscars_lamborghini','sportscars_maseratti')); +check::functions(array('jaguar','lotus','tvr','ferrari','fiat')); // New classes check::classes(array('ignore_parameter','SportsCars','MiniCooper','MorrisMinor','FordAnglia','AustinAllegro')); // No new vars @@ -35,4 +34,3 @@ $aa=new austinallegro(); check::classname("austinallegro",$aa); check::done(); -?> diff --git a/Examples/test-suite/php/import_nomodule_runme.php b/Examples/test-suite/php/import_nomodule_runme.php index e5ea761f7..e639c781d 100644 --- a/Examples/test-suite/php/import_nomodule_runme.php +++ b/Examples/test-suite/php/import_nomodule_runme.php @@ -1,14 +1,16 @@ <?php + require "tests.php"; -require "import_nomodule.php"; -// No new functions -check::functions(array('create_foo','delete_foo','test1','is_python_builtin')); -// No new classes -check::classes(array('import_nomodule','Bar')); -// now new vars +check::functions(array('is_python_builtin')); +check::classes(array('import_nomodule')); +// No new globals check::globals(array()); +// SWIGPHP doesn't currently support the "violation of the type system" which +// is tested by this testcase. +exit(0); + $f = import_nomodule::create_Foo(); import_nomodule::test1($f,42); import_nomodule::delete_Foo($f); @@ -17,4 +19,3 @@ $b = new Bar(); import_nomodule::test1($b,37); check::done(); -?> diff --git a/Examples/test-suite/php/li_carrays_cpp_runme.php b/Examples/test-suite/php/li_carrays_cpp_runme.php index 3e8a443f6..ccbcf7dde 100644 --- a/Examples/test-suite/php/li_carrays_cpp_runme.php +++ b/Examples/test-suite/php/li_carrays_cpp_runme.php @@ -1,16 +1,16 @@ <?php + require "tests.php"; -require "li_carrays_cpp.php"; // Check functions. -check::functions(array('new_intarray','delete_intarray','intarray_getitem','intarray_setitem','doublearray_getitem','doublearray_setitem','doublearray_cast','doublearray_frompointer','xyarray_getitem','xyarray_setitem','xyarray_cast','xyarray_frompointer','delete_abarray','abarray_getitem','abarray_setitem','shortarray_getitem','shortarray_setitem','shortarray_cast','shortarray_frompointer','sum_array')); +check::functions(array('new_intArray','delete_intArray','intArray_getitem','intArray_setitem','new_ABArray','delete_ABArray','ABArray_getitem','ABArray_setitem','sum_array')); // Check classes. // NB An "li_carrays_cpp" class is created as a mock namespace. check::classes(array('li_carrays_cpp','doubleArray','AB','XY','XYArray','shortArray')); // Check global variables. -check::globals(array('xy_x','xy_y','globalxyarray','ab_a','ab_b','globalabarray')); +check::globals(array('globalXYArray','globalABArray')); $d = new doubleArray(10); @@ -19,4 +19,3 @@ $d->setitem(5, $d->getitem(0) + 3); check::equal($d->getitem(0) + $d->getitem(5), 17., "7+10==17"); check::done(); -?> diff --git a/Examples/test-suite/php/li_carrays_runme.php b/Examples/test-suite/php/li_carrays_runme.php index abe358101..df54e04f5 100644 --- a/Examples/test-suite/php/li_carrays_runme.php +++ b/Examples/test-suite/php/li_carrays_runme.php @@ -1,16 +1,16 @@ <?php + require "tests.php"; -require "li_carrays.php"; // Check functions. -check::functions(array('new_intarray','delete_intarray','intarray_getitem','intarray_setitem','doublearray_getitem','doublearray_setitem','doublearray_cast','doublearray_frompointer','xyarray_getitem','xyarray_setitem','xyarray_cast','xyarray_frompointer','delete_abarray','abarray_getitem','abarray_setitem','shortarray_getitem','shortarray_setitem','shortarray_cast','shortarray_frompointer','sum_array')); +check::functions(array('new_intArray','delete_intArray','intArray_getitem','intArray_setitem','new_ABArray','delete_ABArray','ABArray_getitem','ABArray_setitem','sum_array')); // Check classes. // NB An "li_carrays" class is created as a mock namespace. check::classes(array('li_carrays','doubleArray','AB','XY','XYArray','shortArray')); // Check global variables. -check::globals(array('xy_x','xy_y','globalxyarray','ab_a','ab_b','globalabarray')); +check::globals(array('globalXYArray','globalABArray')); $d = new doubleArray(10); @@ -19,4 +19,3 @@ $d->setitem(5, $d->getitem(0) + 3); check::equal($d->getitem(0) + $d->getitem(5), 17., "7+10==17"); check::done(); -?> diff --git a/Examples/test-suite/php/li_factory_runme.php b/Examples/test-suite/php/li_factory_runme.php index 982d7b1fd..3ccdd035f 100644 --- a/Examples/test-suite/php/li_factory_runme.php +++ b/Examples/test-suite/php/li_factory_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "li_factory.php"; // No new functions -check::functions(array('geometry_draw','geometry_create','geometry_clone_','point_draw','point_width','point_clone_','circle_draw','circle_radius','circle_clone_')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Geometry','Point','Circle')); -// now new vars +// No new vars check::globals(array()); $circle = Geometry::create(Geometry::CIRCLE); @@ -19,4 +18,3 @@ $w = $point->width(); check::equal($w, 1.0, "w failed"); check::done(); -?> diff --git a/Examples/test-suite/php/li_std_string_runme.php b/Examples/test-suite/php/li_std_string_runme.php index 04ee3fc86..680b7ce98 100644 --- a/Examples/test-suite/php/li_std_string_runme.php +++ b/Examples/test-suite/php/li_std_string_runme.php @@ -1,11 +1,34 @@ <?php require "tests.php"; -require "li_std_string.php"; -// Global variables -//$s="initial string"; -//check::equal(GlobalString2_get() ,"global string 2", "GlobalString2 test 1"); +# Checking expected use of %typemap(in) std::string {} +li_std_string::test_value("Fee"); + +# Checking expected result of %typemap(out) std::string {} +check::equal(li_std_string::test_value("Fi"), "Fi", "Test 1"); + +# Checking expected use of %typemap(in) const std::string & {} +li_std_string::test_const_reference("Fo"); + +# Checking expected result of %typemap(out) const std::string& {} +check::equal(li_std_string::test_const_reference("Fum"), "Fum", "Test 3"); + +# Input and output typemaps for pointers and non-const references to +# std::string are *not* supported; the following tests confirm +# that none of these cases are slipping through. + +$stringPtr = li_std_string::test_pointer_out(); + +li_std_string::test_pointer($stringPtr); + +$stringPtr = li_std_string::test_const_pointer_out(); + +li_std_string::test_const_pointer($stringPtr); + +$stringPtr = li_std_string::test_reference_out(); + +li_std_string::test_reference($stringPtr); // Global variables $s = "initial string"; @@ -24,11 +47,9 @@ check::equal($myStructure->ConstMemberString, "const member string", "ConstMembe check::equal(Structure::StaticMemberString2(), "static member string 2", "StaticMemberString2 test 1"); Structure::StaticMemberString2($s); check::equal(Structure::StaticMemberString2(), $s, "StaticMemberString2 test 2"); -// below broken ? -//check::equal(Structure::ConstStaticMemberString(), "const static member string", "ConstStaticMemberString test"); +check::equal(Structure::ConstStaticMemberString(), "const static member string", "ConstStaticMemberString test"); // This used to give "Undefined variable: r" li_std_string::test_const_reference_returning_void("foo"); check::done(); -?> diff --git a/Examples/test-suite/php/li_std_vector_member_var_runme.php b/Examples/test-suite/php/li_std_vector_member_var_runme.php index 238350352..32ce484fc 100644 --- a/Examples/test-suite/php/li_std_vector_member_var_runme.php +++ b/Examples/test-suite/php/li_std_vector_member_var_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "li_std_vector_member_var.php"; $t = new Test(); @@ -27,4 +26,3 @@ check::equal($T->start_t->x, 4, "S::x != 4"); check::equal($T->length, 7, "T::length != 7"); check::done(); -?> diff --git a/Examples/test-suite/php/member_pointer_const_runme.php b/Examples/test-suite/php/member_pointer_const_runme.php new file mode 100644 index 000000000..3f55549a8 --- /dev/null +++ b/Examples/test-suite/php/member_pointer_const_runme.php @@ -0,0 +1,59 @@ +<?php + +require "tests.php"; + +// Check functions. +check::functions(array('do_op','do_op_td','areapt','perimeterpt','perimeterpt_td','call1')); + +// Check classes. +check::classes(array('member_pointer_const','Circle','Funktions','Shape','Square')); + +// Check global variables. +check::globals(array('areavar','perimetervar','perimetervar_td')); + +# Get the pointers + +$area_pt = member_pointer_const::areapt(); +$perim_pt = member_pointer_const::perimeterpt(); + +# Create some objects + +$s = new Square(10); + +# Do some calculations + +check::equal(100.0, member_pointer_const::do_op($s, $area_pt), "Square area"); +check::equal(40.0, member_pointer_const::do_op($s, $perim_pt), "Square perim"); + + +$memberPtr = member_pointer_const::areavar_get(); +$memberPtr = member_pointer_const::perimetervar_get(); + +# Try the variables +check::equal(100.0, member_pointer_const::do_op($s, member_pointer_const::areavar_get()), "Square area"); +check::equal(40.0, member_pointer_const::do_op($s, member_pointer_const::perimetervar_get()), "Square perim"); + +# Modify one of the variables +member_pointer_const::areavar_set($perim_pt); + +check::equal(40.0, member_pointer_const::do_op($s, member_pointer_const::areavar_get()), "Square perimeter"); + +# Try the constants + +/* +$memberPtr = member_pointer_const::AREAPT; +$memberPtr = member_pointer_const::PERIMPT; +$memberPtr = member_pointer_const::NULLPT; + +check::equal(100.0, member_pointer_const::do_op($s, member_pointer_const::AREAPT), "Square area"); +check::equal(40.0, member_pointer_const::do_op($s, member_pointer_const::PERIMPT), "Square perim"); +*/ + +# Typedefs +check::equal(40.0, member_pointer_const::do_op_td($s, $perim_pt), "Square perim"); + +/* +check::equal(3, member_pointer_const::call1(member_pointer_const::ADD_BY_VALUE, 1, 2), "Add by value"); +check::equal(7, member_pointer_const::call2(member_pointer_const::ADD_BY_VALUE, 3, 4), "Add by pointer"); +check::equal(11, member_pointer_const::call3(member_pointer_const::ADD_BY_VALUE, 5, 6), "Add by reference"); + */ diff --git a/Examples/test-suite/php/multivalue_runme.php b/Examples/test-suite/php/multivalue_runme.php new file mode 100644 index 000000000..77e1e1a82 --- /dev/null +++ b/Examples/test-suite/php/multivalue_runme.php @@ -0,0 +1,24 @@ +<?php + +require "tests.php"; + +// New functions +check::functions(array('divide_l','divide_v','divide_mv')); +// New classes +check::classes(array('multivalue')); +// No new vars +check::globals(array()); + +$r = multivalue::divide_l(37, 5); +check::equal($r[0], 7, "Test divide_l quotient"); +check::equal($r[1], 2, "Test divide_l remainder"); + +$r = multivalue::divide_v(41, 7); +check::equal($r[0], 5, "Test divide_v quotient"); +check::equal($r[1], 6, "Test divide_v remainder"); + +$r = multivalue::divide_mv(91, 13); +check::equal($r[0], 7, "Test divide_mv quotient"); +check::equal($r[1], 0, "Test divide_mv remainder"); + +check::done(); diff --git a/Examples/test-suite/php/newobject1_runme.php b/Examples/test-suite/php/newobject1_runme.php index 863e3e423..a495ab15d 100644 --- a/Examples/test-suite/php/newobject1_runme.php +++ b/Examples/test-suite/php/newobject1_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "newobject1.php"; // No new functions -check::functions(array('foo_makefoo','foo_makemore','foo_foocount')); -// No new classes +check::functions(array()); +// New classes check::classes(array('Foo')); -// now new vars +// No new vars check::globals(array()); $foo = Foo::makeFoo(); @@ -16,4 +15,3 @@ $bar = $foo->makeMore(); check::equal(get_class($bar), "Foo", "regular failed"); check::done(); -?> diff --git a/Examples/test-suite/php/newobject3_runme.php b/Examples/test-suite/php/newobject3_runme.php index edd5d8608..8efa9891d 100644 --- a/Examples/test-suite/php/newobject3_runme.php +++ b/Examples/test-suite/php/newobject3_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "newobject3.php"; $factory = new factory(); @@ -14,5 +13,3 @@ check::isnull($factory->create(0), "create(0) should be NULL"); check::isnull($factory->create(7, -1), "create(7, -1) should be NULL"); check::isnull($factory->create(0, -1), "create(0, -1) should be NULL"); check::isnull($factory->create("bad", -1), "create(\"bad\", -1) should be NULL"); - -?> diff --git a/Examples/test-suite/php/overload_null_runme.php b/Examples/test-suite/php/overload_null_runme.php index 22824d4fb..7afafeacd 100644 --- a/Examples/test-suite/php/overload_null_runme.php +++ b/Examples/test-suite/php/overload_null_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "overload_null.php"; $o = new Overload(); $x = new X(); @@ -31,16 +30,15 @@ check::equal(14, $o->byval1cpr(null), "test 14"); check::equal(15, $o->byval2cpr(null), "test 15"); check::equal(16, $o->byval2cpr($x), "test 16"); -# forward class declaration -check::equal(17, $o->byval1forwardptr($x), "test 17"); -check::equal(18, $o->byval1forwardptr(null), "test 18"); +# fwd class declaration +check::equal(17, $o->byval1fwdptr($x), "test 17"); +check::equal(18, $o->byval1fwdptr(null), "test 18"); -check::equal(19, $o->byval2forwardptr(null), "test 19"); -check::equal(20, $o->byval2forwardptr($x), "test 20"); +check::equal(19, $o->byval2fwdptr(null), "test 19"); +check::equal(20, $o->byval2fwdptr($x), "test 20"); -check::equal(21, $o->byval1forwardref($x), "test 21"); +check::equal(21, $o->byval1fwdref($x), "test 21"); -check::equal(22, $o->byval2forwardref($x), "test 22"); +check::equal(22, $o->byval2fwdref($x), "test 22"); check::done(); -?> diff --git a/Examples/test-suite/php/overload_polymorphic_runme.php b/Examples/test-suite/php/overload_polymorphic_runme.php new file mode 100644 index 000000000..908988291 --- /dev/null +++ b/Examples/test-suite/php/overload_polymorphic_runme.php @@ -0,0 +1,12 @@ +<?php + +require "tests.php"; + +$t = new Derived(); + +check::equal(overload_polymorphic::test($t), 0, "test(Derived)"); +check::equal(overload_polymorphic::test(1), 1, "test(1)"); +check::equal(overload_polymorphic::test2($t), 1, "test2(Derived)"); +check::equal(overload_polymorphic::test3($t, null, $t), 1, "test3(Derived, null, Derived)"); + +check::done(); diff --git a/Examples/test-suite/php/overload_rename_runme.php b/Examples/test-suite/php/overload_rename_runme.php index 0357f91a6..c2df99034 100644 --- a/Examples/test-suite/php/overload_rename_runme.php +++ b/Examples/test-suite/php/overload_rename_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "overload_rename.php"; // No new functions check::functions(array()); -// No new classes +// New classes check::classes(array('Foo')); -// now new vars +// No new vars check::globals(array()); $f = new Foo(1.0); @@ -16,4 +15,3 @@ $f = Foo::Foo_int(1.0,1); $f = Foo::Foo_int(1.0,1,1.0); check::done(); -?> diff --git a/Examples/test-suite/php/overload_return_type_runme.php b/Examples/test-suite/php/overload_return_type_runme.php index 4fa19d22a..5f01bbe19 100644 --- a/Examples/test-suite/php/overload_return_type_runme.php +++ b/Examples/test-suite/php/overload_return_type_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "overload_return_type.php"; $b = new B; check::equal($b->foo(1), 0, ""); @@ -9,5 +8,3 @@ check::classname("A", $b->foo("test")); check::equal(overload_return_type::foo(), 1, "overload_return_type::foo() should be 1"); check::equal(overload_return_type::bar(), 1, "overload_return_type::bar() should be 1"); - -?> diff --git a/Examples/test-suite/php/php_iterator_runme.php b/Examples/test-suite/php/php_iterator_runme.php index fd645ccb2..76b4757fc 100644 --- a/Examples/test-suite/php/php_iterator_runme.php +++ b/Examples/test-suite/php/php_iterator_runme.php @@ -1,9 +1,9 @@ <?php require "tests.php"; -require "php_iterator.php"; -check::functions(array('myiterator_rewind','myiterator_key','myiterator_current','myiterator_next','myiterator_valid')); +// No new functions. +check::functions(array()); check::classes(array('MyIterator')); // No new global variables. check::globals(array()); @@ -21,4 +21,3 @@ foreach (new MyIterator(2, 5) as $k => $v) { check::equal($s, '(0=>2)(1=>3)(2=>4)', 'Simple iteration failed'); check::done(); -?> diff --git a/Examples/test-suite/php/php_pragma_runme.php b/Examples/test-suite/php/php_pragma_runme.php index c76cfc9b5..e70f2ceda 100644 --- a/Examples/test-suite/php/php_pragma_runme.php +++ b/Examples/test-suite/php/php_pragma_runme.php @@ -1,11 +1,7 @@ <?php require "tests.php"; -require "php_pragma.php"; - check::equal('1.5',(new ReflectionExtension('php_pragma'))->getVersion(),"1.5==version(php_pragma)"); check::done(); - -?> diff --git a/Examples/test-suite/php/pointer_reference_runme.php b/Examples/test-suite/php/pointer_reference_runme.php index 52946177e..a8a511271 100644 --- a/Examples/test-suite/php/pointer_reference_runme.php +++ b/Examples/test-suite/php/pointer_reference_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "pointer_reference.php"; $s = pointer_reference::get(); check::equal($s->value, 10, "pointer_reference::get() failed"); @@ -15,4 +14,3 @@ check::equal(pointer_reference::overloading(1), 111, "overload test 1 failed"); check::equal(pointer_reference::overloading($ss), 222, "overload test 2 failed"); check::done(); -?> diff --git a/Examples/test-suite/php/prefix_runme.php b/Examples/test-suite/php/prefix_runme.php index fcf7c66f6..d1c0ab1ea 100644 --- a/Examples/test-suite/php/prefix_runme.php +++ b/Examples/test-suite/php/prefix_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "prefix.php"; // No new functions -check::functions(array('foo_get_self')); -// No new classes -check::classes(array('ProjectFoo')); -// now new vars +check::functions(array()); +// New classes +check::classes(array('ProjectBar','ProjectFoo')); +// No new vars check::globals(array()); $f = new ProjectFoo(); @@ -15,4 +14,3 @@ $f = new ProjectFoo(); $f->get_self(); check::done(); -?> diff --git a/Examples/test-suite/php/preproc_constants_c_runme.php b/Examples/test-suite/php/preproc_constants_c_runme.php index 20868dcc0..a26892b42 100644 --- a/Examples/test-suite/php/preproc_constants_c_runme.php +++ b/Examples/test-suite/php/preproc_constants_c_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "preproc_constants_c.php"; // Same as preproc_constants.i testcase, but bool types are int instead check::equal(gettype(preproc_constants_c::CONST_INT1), "integer", "preproc_constants.CONST_INT1 has unexpected type"); @@ -65,5 +64,3 @@ check::equal(gettype(preproc_constants_c::EXPR_CONDITIONAL), "double", "preproc_ check::equal(gettype(preproc_constants_c::EXPR_MIXED1), "double", "preproc_constants.EXPR_MIXED1 has unexpected type"); check::equal(gettype(preproc_constants_c::EXPR_WCHAR_MAX), "integer", "preproc_constants.EXPR_WCHAR_MAX has unexpected type"); check::equal(gettype(preproc_constants_c::EXPR_WCHAR_MIN), "integer", "preproc_constants.EXPR_WCHAR_MIN has unexpected type"); - -?> diff --git a/Examples/test-suite/php/preproc_constants_runme.php b/Examples/test-suite/php/preproc_constants_runme.php index bd216c269..7f45a1bae 100644 --- a/Examples/test-suite/php/preproc_constants_runme.php +++ b/Examples/test-suite/php/preproc_constants_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "preproc_constants.php"; check::equal(gettype(preproc_constants::CONST_INT1), "integer", "preproc_constants.CONST_INT1 has unexpected type"); check::equal(gettype(preproc_constants::CONST_INT2), "integer", "preproc_constants.CONST_INT2 has unexpected type"); @@ -64,5 +63,3 @@ check::equal(gettype(preproc_constants::EXPR_CONDITIONAL), "double", "preproc_co check::equal(gettype(preproc_constants::EXPR_MIXED1), "double", "preproc_constants.EXPR_MIXED1 has unexpected type"); check::equal(gettype(preproc_constants::EXPR_WCHAR_MAX), "integer", "preproc_constants.EXPR_WCHAR_MAX has unexpected type"); check::equal(gettype(preproc_constants::EXPR_WCHAR_MIN), "integer", "preproc_constants.EXPR_WCHAR_MIN has unexpected type"); - -?> diff --git a/Examples/test-suite/php/primitive_ref_runme.php b/Examples/test-suite/php/primitive_ref_runme.php index 263a28074..9b281cf50 100644 --- a/Examples/test-suite/php/primitive_ref_runme.php +++ b/Examples/test-suite/php/primitive_ref_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "primitive_ref.php"; # A large long long number is too big, so PHP makes treats it as a double, but SWIG opts to return it as a string. # The conversion to double can lose precision so this isn't an exact comparison. @@ -31,4 +30,3 @@ long_long_equal(ref_longlong(0x123456789ABCDEF0), 0x123456789ABCDEF0, "ref_longl long_long_equal(ref_ulonglong(0xF23456789ABCDEF0), 0xF23456789ABCDEF0, "ref_ulonglong failed"); check::done(); -?> diff --git a/Examples/test-suite/php/rename_scope_runme.php b/Examples/test-suite/php/rename_scope_runme.php index df620d796..e1db4f59c 100644 --- a/Examples/test-suite/php/rename_scope_runme.php +++ b/Examples/test-suite/php/rename_scope_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "rename_scope.php"; check::classes(array("rename_scope","Interface_UP","Interface_BP","Natural_UP","Natural_BP","Bucket")); @@ -13,4 +12,3 @@ check::classparent("Natural_UP","Interface_UP"); check::classparent("Natural_BP","Interface_BP"); check::done(); -?> diff --git a/Examples/test-suite/php/skel.php b/Examples/test-suite/php/skel.php index 780a999ed..7fdebc7d6 100644 --- a/Examples/test-suite/php/skel.php +++ b/Examples/test-suite/php/skel.php @@ -2,14 +2,12 @@ // Sample test file require "tests.php"; -require "____.php"; // No new functions check::functions(array()); // No new classes check::classes(array()); -// now new vars +// No new vars check::globals(array()); check::done(); -?> diff --git a/Examples/test-suite/php/smart_pointer_rename_runme.php b/Examples/test-suite/php/smart_pointer_rename_runme.php index 26692dde5..094860386 100644 --- a/Examples/test-suite/php/smart_pointer_rename_runme.php +++ b/Examples/test-suite/php/smart_pointer_rename_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "smart_pointer_rename.php"; check::classes(array("Foo","Bar")); check::classmethods("foo",array("ftest1","ftest2","__set","__isset","__get","__construct")); @@ -24,4 +23,3 @@ check::equal(3,$bar->test(),"bar->test"); check::classname("foo",$bar->__deref__()); check::done(); -?> diff --git a/Examples/test-suite/php/swig_exception_runme.php b/Examples/test-suite/php/swig_exception_runme.php index 76641996e..37a7a59ee 100644 --- a/Examples/test-suite/php/swig_exception_runme.php +++ b/Examples/test-suite/php/swig_exception_runme.php @@ -1,6 +1,5 @@ <?php -require("swig_exception.php"); require("tests.php"); $c = new Circle(10); @@ -29,5 +28,3 @@ $e = NULL; if (Shape::nshapes() != 0) { check::fail("Shape::nshapes() should be 0, actually ".Shape::nshapes()); } - -?> diff --git a/Examples/test-suite/php/sym_runme.php b/Examples/test-suite/php/sym_runme.php index 127d28fd9..7e8f914c1 100644 --- a/Examples/test-suite/php/sym_runme.php +++ b/Examples/test-suite/php/sym_runme.php @@ -1,13 +1,12 @@ <?php require "tests.php"; -require "sym.php"; // No new functions check::functions(array()); -// No new classes -check::classes(array('flim','flam')); -// now new vars +// New classes +check::classes(array('Flim','Flam')); +// No new vars check::globals(array()); $flim=new flim(); @@ -19,4 +18,3 @@ check::equal($flam->jam(),"flam-jam","flam()->jam==flam-jam"); check::equal($flam->jar(),"flam-jar","flam()->jar==flam-jar"); check::done(); -?> diff --git a/Examples/test-suite/php/template_arg_typename_runme.php b/Examples/test-suite/php/template_arg_typename_runme.php index e609240e7..c7fcbbd9d 100644 --- a/Examples/test-suite/php/template_arg_typename_runme.php +++ b/Examples/test-suite/php/template_arg_typename_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "template_arg_typename.php"; // No new functions check::functions(array()); @@ -15,4 +14,3 @@ $bufb=new boolunaryfunction_bool($whatisthis); check::is_a($bufb,"boolunaryfunction_bool"); check::done(); -?> diff --git a/Examples/test-suite/php/template_construct_runme.php b/Examples/test-suite/php/template_construct_runme.php index b227d9fec..d09bc4d37 100644 --- a/Examples/test-suite/php/template_construct_runme.php +++ b/Examples/test-suite/php/template_construct_runme.php @@ -1,11 +1,9 @@ <?php require "tests.php"; -require "template_construct.php"; check::classes(array('Foo_int')); $foo_int=new foo_int(3); check::is_a($foo_int,"foo_int","Made a foo_int"); check::done(); -?> diff --git a/Examples/test-suite/php/tests.php b/Examples/test-suite/php/tests.php index 20fa1ed98..cec6e581f 100644 --- a/Examples/test-suite/php/tests.php +++ b/Examples/test-suite/php/tests.php @@ -1,86 +1,24 @@ <?php -function die_on_error($errno, $errstr, $file, $line) { - if ($file !== Null) { - print $file; - if ($line !== Null) print ":$line"; - print ": "; - } - print "$errstr\n"; - exit(1); -} -set_error_handler("die_on_error", -1); - -$_original_functions=get_defined_functions(); -$_original_globals=1; -$_original_classes=get_declared_classes(); -$_original_globals=array_keys($GLOBALS); - class check { // do we have true global vars or just GETSET functions? // Used to filter out get/set global functions to fake vars... const GETSET = 1; - static function get_extra_classes($ref=FALSE) { - static $extra; - global $_original_classes; - if ($ref===FALSE) $f=$_original_classes; - if (! is_array($extra)) { - $df=array_flip(get_declared_classes()); - foreach($_original_classes as $class) unset($df[$class]); - $extra=array_keys($df); - } - return $extra; - } - - static function get_extra_functions($ref=FALSE,$gs=false) { - static $extra; - static $extrags; // for get/setters - global $_original_functions; - if ($ref===FALSE) $f=$_original_functions; - if (! is_array($extra) || $gs) { - $extra=array(); - $extrags=array(); - $df=get_defined_functions(); - $df=array_flip($df['internal']); - foreach($_original_functions['internal'] as $func) unset($df[$func]); - // Now chop out any get/set accessors - foreach(array_keys($df) as $func) - if ((self::GETSET && preg_match('/_[gs]et$/', $func)) || - preg_match('/^new_/', $func) || - preg_match('/_(alter|get)_newobject$/', $func)) - $extrags[]=$func; - else $extra[]=$func; -// $extra=array_keys($df); + private static $_extension = null; + + // This is called automatically at the end of this file. + static function init() { + foreach(get_included_files() as $f) { + $module_name = preg_filter('/.*\/([^\/]+)_runme\.php$/', '\1', $f); + if ($module_name !== null) break; } - if ($gs) return $extrags; - return $extra; - } - - static function get_extra_globals($ref=FALSE) { - static $extra; - global $_original_globals; - if (! is_array($extra)) { - if (self::GETSET) { - $_extra=array(); - foreach(check::get_extra_functions(false,1) as $global) { - if (preg_match('/^(.*)_[sg]et$/', $global, $match)) - $_extra[$match[1]] = 1; - } - $extra=array_keys($_extra); - } else { - if ($ref===FALSE) $ref=$_original_globals; - if (! is_array($extra)) { - $df=array_flip(array_keys($GLOBALS)); - foreach($_original_globals as $func) unset($df[$func]); - // MASK xxxx_LOADED__ variables - foreach(array_keys($df) as $func) - if (preg_match('/_LOADED__$/', $func)) unset($df[$func]); - $extra=array_keys($df); - } - } + if ($module_name === null) { + print("Failed to determine module name from get_included_files()\n"); + exit(1); } - return $extra; + + self::$_extension = new ReflectionExtension($module_name); } static function classname($string,$object) { @@ -148,7 +86,8 @@ class check { if (! is_array($classes)) $classes=array($classes); $message=array(); $missing=array(); - $extra=array_flip(check::get_extra_classes()); + $extra = array_flip(array_filter(self::$_extension->getClassNames(), + function ($e) { return !preg_match('/^SWIG\\\\/', $e); })); foreach($classes as $class) { if (! class_exists($class)) $missing[]=$class; else unset($extra[$class]); @@ -164,15 +103,16 @@ class check { if (! is_array($functions)) $functions=array($functions); $message=array(); $missing=array(); - $extra=array_flip(check::get_extra_functions()); - + $extra = self::$_extension->getFunctions(); foreach ($functions as $func) { if (! function_exists($func)) $missing[]=$func; else unset($extra[$func]); } + $extra = array_filter(array_keys($extra), + function ($e) { return !preg_match('/_[gs]et$/', $e); }); if ($missing) $message[]=sprintf("Functions missing: %s",join(",",$missing)); if ($message) return check::fail(join("\n ",$message)); - if ($extra) $message[]=sprintf("These extra functions are defined: %s",join(",",array_keys($extra))); + if ($extra) $message[]=sprintf("These extra functions are defined: %s",join(",",$extra)); if ($message) return check::warn(join("\n ",$message)); return TRUE; } @@ -181,19 +121,19 @@ class check { if (! is_array($globals)) $globals=array($globals); $message=array(); $missing=array(); - $extra=array_flip(check::get_extra_globals()); + $extra = self::$_extension->getFunctions(); foreach ($globals as $glob) { - if (self::GETSET) { - if (! isset($extra[$glob])) $missing[]=$glob; - else unset($extra[$glob]); - } else { - if (! isset($GLOBALS[$glob])) $missing[]=$glob; - else unset($extra[$glob]); + if (! function_exists($glob . "_get") && ! function_exists($glob . "_set")) $missing[]=$glob; + else { + unset($extra[$glob . "_get"]); + unset($extra[$glob . "_set"]); } } + $extra = array_filter(array_keys($extra), + function ($e) { return preg_match('/_[gs]et$/', $e); }); if ($missing) $message[]=sprintf("Globals missing: %s",join(",",$missing)); if ($message) return check::fail(join("\n ",$message)); - if ($extra) $message[]=sprintf("These extra globals are defined: %s",join(",",array_keys($extra))); + if ($extra) $message[]=sprintf("These extra globals are defined: %s",join(",",$extra)); if ($message) return check::warn(join("\n ",$message)); return TRUE; @@ -210,24 +150,13 @@ class check { return TRUE; } - static function resource($a,$b,$message) { - $resource=trim(check::var_dump($a)); - if (! preg_match("/^resource\([0-9]+\) of type \($b\)/i", $resource)) - return check::fail($message); + static function equivalent($a,$b,$message) { + if (! ($a==$b)) return check::fail($message . ": '$a'!='$b'"); return TRUE; } static function isnull($a,$message) { - $value=trim(check::var_dump($a)); - return check::equal($value,"NULL",$message); - } - - static function var_dump($arg) { - ob_start(); - var_dump($arg); - $result=ob_get_contents(); - ob_end_clean(); - return $result; + return check::equal($a,NULL,$message); } static function fail($pattern) { @@ -246,4 +175,5 @@ class check { # print $_SERVER[argv][0]." ok\n"; } } -?> + +check::init(); diff --git a/Examples/test-suite/php/threads_exception_runme.php b/Examples/test-suite/php/threads_exception_runme.php index 80717eb88..38873dffd 100644 --- a/Examples/test-suite/php/threads_exception_runme.php +++ b/Examples/test-suite/php/threads_exception_runme.php @@ -1,14 +1,13 @@ <?php require "tests.php"; -require "threads_exception.php"; // Check functions -check::functions(array('test_simple','test_message','test_hosed','test_unknown','test_multi','is_python_builtin')); +check::functions(array('is_python_builtin')); // Check classes. check::classes(array('Exc','Test','threads_exception')); -// Check globals. -check::globals(array('exc_code','exc_msg')); +// No new vars +check::globals(array()); $t = new Test(); try { diff --git a/Examples/test-suite/php/typedef_reference_runme.php b/Examples/test-suite/php/typedef_reference_runme.php index 83e75fb66..8309c3c6f 100644 --- a/Examples/test-suite/php/typedef_reference_runme.php +++ b/Examples/test-suite/php/typedef_reference_runme.php @@ -1,7 +1,6 @@ <?php require "tests.php"; -require "typedef_reference.php"; check::functions(array('somefunc','otherfunc','new_intp','copy_intp','delete_intp','intp_assign','intp_value')); $int2=copy_intp(2); @@ -10,4 +9,3 @@ $int3=copy_intp(3); check::equal(3,otherfunc($int3)," test passing intp to otherfunc"); check::done(); -?> diff --git a/Examples/test-suite/php/typemap_ns_using_runme.php b/Examples/test-suite/php/typemap_ns_using_runme.php index 6a599f008..e15427856 100644 --- a/Examples/test-suite/php/typemap_ns_using_runme.php +++ b/Examples/test-suite/php/typemap_ns_using_runme.php @@ -1,9 +1,8 @@ <?php require "tests.php"; -require "typemap_ns_using.php"; + if (! class_exists("_fooimpl")) die("_fooimpl class not found\n"); if (! 3==spam(3)) die("spam function not working right\n"); check::done(); -?> diff --git a/Examples/test-suite/php/using1_runme.php b/Examples/test-suite/php/using1_runme.php index 51841bc78..e15427856 100644 --- a/Examples/test-suite/php/using1_runme.php +++ b/Examples/test-suite/php/using1_runme.php @@ -1,9 +1,8 @@ <?php require "tests.php"; -require "using1.php"; + if (! class_exists("_fooimpl")) die("_fooimpl class not found\n"); if (! 3==spam(3)) die("spam function not working right\n"); check::done(); -?> diff --git a/Examples/test-suite/php/using2_runme.php b/Examples/test-suite/php/using2_runme.php index 391a98f52..e15427856 100644 --- a/Examples/test-suite/php/using2_runme.php +++ b/Examples/test-suite/php/using2_runme.php @@ -1,9 +1,8 @@ <?php require "tests.php"; -require "using2.php"; + if (! class_exists("_fooimpl")) die("_fooimpl class not found\n"); if (! 3==spam(3)) die("spam function not working right\n"); check::done(); -?> diff --git a/Examples/test-suite/php/valuewrapper_base_runme.php b/Examples/test-suite/php/valuewrapper_base_runme.php index 6a1abdbd2..3f4c38e5b 100644 --- a/Examples/test-suite/php/valuewrapper_base_runme.php +++ b/Examples/test-suite/php/valuewrapper_base_runme.php @@ -1,13 +1,11 @@ <?php require "tests.php"; -require "valuewrapper_base.php"; check::classes(array("valuewrapper_base","Base","Interface_BP")); -check::functions("make_interface_bp"); +check::functions("make_Interface_BP"); $ibp=valuewrapper_base::make_interface_bp(); check::classname("interface_bp",$ibp); check::done(); -?> diff --git a/Examples/test-suite/php/virtual_vs_nonvirtual_base_runme.php b/Examples/test-suite/php/virtual_vs_nonvirtual_base_runme.php index 0d4aa3d5f..abfb4d307 100644 --- a/Examples/test-suite/php/virtual_vs_nonvirtual_base_runme.php +++ b/Examples/test-suite/php/virtual_vs_nonvirtual_base_runme.php @@ -1,11 +1,8 @@ <? require "tests.php"; -require "virtual_vs_nonvirtual_base.php"; $fail = new SimpleClassFail(); $work = new SimpleClassWork(); check::equal($work->getInner()->get(), $fail->getInner()->get(), "should both be 10"); - -?> diff --git a/Examples/test-suite/php/wrapmacro_runme.php b/Examples/test-suite/php/wrapmacro_runme.php index f32da990e..18b2ef1e1 100644 --- a/Examples/test-suite/php/wrapmacro_runme.php +++ b/Examples/test-suite/php/wrapmacro_runme.php @@ -1,12 +1,10 @@ <?php require "tests.php"; -require "wrapmacro.php"; -check::functions(array('guint16_swap_le_be_constant', 'maximum')); +check::functions(array('GUINT16_SWAP_LE_BE_CONSTANT', 'maximum')); check::equal(maximum(2.3, 2.4), 2.4, "maximum() doesn't work"); check::equal(guint16_swap_le_be_constant(0x1234), 0x3412, "GUINT16_SWAP_LE_BE_CONSTANT() doesn't work"); check::done(); -?> diff --git a/Examples/test-suite/php_namewarn_rename.i b/Examples/test-suite/php_namewarn_rename.i index d84e2196f..bb54dba5e 100644 --- a/Examples/test-suite/php_namewarn_rename.i +++ b/Examples/test-suite/php_namewarn_rename.i @@ -5,6 +5,9 @@ %warnfilter(SWIGWARN_PARSE_KEYWORD) stdClass; %warnfilter(SWIGWARN_PARSE_KEYWORD) directory; %warnfilter(SWIGWARN_PARSE_KEYWORD) Hello::empty(); +%warnfilter(SWIGWARN_PARSE_KEYWORD) null; +%warnfilter(SWIGWARN_PARSE_KEYWORD) True; +%warnfilter(SWIGWARN_PARSE_KEYWORD) FALSE; #endif %ignore prev::operator++; @@ -36,4 +39,15 @@ prev operator++(int) { return *this; } }; + class null + { + }; + + class True + { + }; + + class FALSE + { + }; %} diff --git a/Examples/test-suite/pike/Makefile.in b/Examples/test-suite/pike/Makefile.in deleted file mode 100644 index 6e1bdfbff..000000000 --- a/Examples/test-suite/pike/Makefile.in +++ /dev/null @@ -1,49 +0,0 @@ -####################################################################### -# Makefile for Pike test-suite -####################################################################### - -LANGUAGE = pike -PIKE = pike -SCRIPTSUFFIX = _runme.pike - -srcdir = @srcdir@ -top_srcdir = @top_srcdir@ -top_builddir = @top_builddir@ - -include $(srcdir)/../common.mk - -# Overridden variables here -# none! - -# Custom tests - tests with additional commandline options -# none! - -# Rules for the different types of tests -%.cpptest: - $(setup) - +$(swig_and_compile_cpp) - $(run_testcase) - -%.ctest: - $(setup) - +$(swig_and_compile_c) - $(run_testcase) - -%.multicpptest: - $(setup) - +$(swig_and_compile_multi_cpp) - $(run_testcase) - -# Runs the testcase. A testcase is only run if -# a file is found which has _runme.pike appended after the testcase name. -run_testcase = \ - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ - env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(PIKE) $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ - fi - -# Clean: remove the generated .pike file -%.clean: - @rm -f $*.pike; - -clean: - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' pike_clean diff --git a/Examples/test-suite/prefix.i b/Examples/test-suite/prefix.i index b0cb31205..90cdf5593 100644 --- a/Examples/test-suite/prefix.i +++ b/Examples/test-suite/prefix.i @@ -11,4 +11,10 @@ public: } }; +// This failed in git pre 4.1.0 - the calls to the parent class' magic __get, +// __set and __isset methods weren't getting the prefix. +class Bar : public Foo { +public: +}; + %} diff --git a/Examples/test-suite/preproc.i b/Examples/test-suite/preproc.i index 215fdd0ef..1bcdcf7ac 100644 --- a/Examples/test-suite/preproc.i +++ b/Examples/test-suite/preproc.i @@ -298,11 +298,6 @@ inline const char* mangle_macro ## #@__VA_ARGS__ () { /* chiao */ #endif; -#ifdef SWIGCHICKEN -/* define is a scheme keyword (and thus an invalid variable name), so SWIG warns about it */ -%warnfilter(SWIGWARN_PARSE_KEYWORD) define; -#endif - #ifdef SWIGRUBY %rename(ddefined) defined; #endif diff --git a/Examples/test-suite/private_assign.i b/Examples/test-suite/private_assign.i index acc4d0bc9..d9ba70cf4 100644 --- a/Examples/test-suite/private_assign.i +++ b/Examples/test-suite/private_assign.i @@ -14,6 +14,8 @@ return *this; } public: + Foo() { } + Foo(const Foo &f) { } // copy ctor can still be public, however. void bar() { } }; diff --git a/Examples/test-suite/python/kwargs_feature_runme.py b/Examples/test-suite/python/kwargs_feature_runme.py index 31d49d221..387658ec3 100644 --- a/Examples/test-suite/python/kwargs_feature_runme.py +++ b/Examples/test-suite/python/kwargs_feature_runme.py @@ -122,3 +122,18 @@ try: raise RuntimeError("missed exception") except TypeError as e: pass + +# Varargs +f = VarargConstructor(fmt="Ciao") +f.vararg_method(fmt="Bonjour") +try: + f = VarargConstructor(nonexistent="Ciao") + raise RuntimeError("missed exception") +except TypeError as e: + pass + +try: + f.vararg_method(nonexistent="Bonjour") + raise RuntimeError("missed exception") +except TypeError as e: + pass diff --git a/Examples/test-suite/python/overload_null_runme.py b/Examples/test-suite/python/overload_null_runme.py index a34524255..4b69b5c8d 100644 --- a/Examples/test-suite/python/overload_null_runme.py +++ b/Examples/test-suite/python/overload_null_runme.py @@ -32,13 +32,13 @@ check(14, o.byval1cpr(None)) check(15, o.byval2cpr(None)) check(16, o.byval2cpr(x)) -# forward class declaration -check(17, o.byval1forwardptr(x)) -check(18, o.byval1forwardptr(None)) +# fwd class declaration +check(17, o.byval1fwdptr(x)) +check(18, o.byval1fwdptr(None)) -check(19, o.byval2forwardptr(None)) -check(20, o.byval2forwardptr(x)) +check(19, o.byval2fwdptr(None)) +check(20, o.byval2fwdptr(x)) -check(21, o.byval1forwardref(x)) +check(21, o.byval1fwdref(x)) -check(22, o.byval2forwardref(x)) +check(22, o.byval2fwdref(x)) diff --git a/Examples/test-suite/python/python_overload_simple_cast_runme.py b/Examples/test-suite/python/python_overload_simple_cast_runme.py index fc398ab29..7a0174af8 100644 --- a/Examples/test-suite/python/python_overload_simple_cast_runme.py +++ b/Examples/test-suite/python/python_overload_simple_cast_runme.py @@ -9,6 +9,8 @@ class Ai: def __int__(self): return self.x + def __index__(self): + return self.x class Ad: diff --git a/Examples/test-suite/python/template_template_parameters_runme.py b/Examples/test-suite/python/template_template_parameters_runme.py new file mode 100644 index 000000000..4b0e27d9c --- /dev/null +++ b/Examples/test-suite/python/template_template_parameters_runme.py @@ -0,0 +1,30 @@ +from template_template_parameters import * + +# Test first part +listBool = ListFastBool() +listBool.item = True +x_boolean = listBool.allotype +if listBool.item != True: + raise RuntimeError("Failed") + +listDouble = ListDefaultDouble() +listDouble.item = 10.2 +x_double = listDouble.allotype +if listDouble.item != 10.2: + raise RuntimeError("Failed") + +# Test second part +floatTestStruct = FloatTestStruct() +floatContainer2 = floatTestStruct.x +floatContainer2.x = 8.1 +intTestStruct = IntTestStruct() +intContainer1 = intTestStruct.x +intContainer1.x = 91 +if intContainer1.x != 91: + raise RuntimeError("Failed") +if intTestStruct.x.x != 91: + raise RuntimeError("Failed") +intTestStructReturned = TestStructContainer1Method(intTestStruct) +if intTestStructReturned.x.x != 101: + raise RuntimeError("Failed") + diff --git a/Examples/test-suite/python/varargs_runme.py b/Examples/test-suite/python/varargs_runme.py index 8f90d5cde..13f85a75f 100644 --- a/Examples/test-suite/python/varargs_runme.py +++ b/Examples/test-suite/python/varargs_runme.py @@ -3,6 +3,10 @@ import varargs if varargs.test("Hello") != "Hello": raise RuntimeError("Failed") +vc = varargs.VarargConstructor("Hey there") +if vc.str != "Hey there": + raise RuntimeError("Failed") + f = varargs.Foo("Greetings") if f.str != "Greetings": raise RuntimeError("Failed") diff --git a/Examples/test-suite/r/overload_null_runme.R b/Examples/test-suite/r/overload_null_runme.R index d187a1fbb..13dc0c609 100644 --- a/Examples/test-suite/r/overload_null_runme.R +++ b/Examples/test-suite/r/overload_null_runme.R @@ -34,16 +34,16 @@ unittest(12, o$byconstref2(x)) #unittest(15, o$byval2cpr(NULL)) #unittest(16, o$byval2cpr(x)) -# forward class declaration -unittest(17, o$byval1forwardptr(x)) -unittest(18, o$byval1forwardptr(NULL)) +# fwd class declaration +unittest(17, o$byval1fwdptr(x)) +unittest(18, o$byval1fwdptr(NULL)) -unittest(19, o$byval2forwardptr(NULL)) -unittest(20, o$byval2forwardptr(x)) +unittest(19, o$byval2fwdptr(NULL)) +unittest(20, o$byval2fwdptr(x)) -unittest(21, o$byval1forwardref(x)) +unittest(21, o$byval1fwdref(x)) -unittest(22, o$byval2forwardref(x)) +unittest(22, o$byval2fwdref(x)) q(save="no") diff --git a/Examples/test-suite/register_par.i b/Examples/test-suite/register_par.i index 643841455..3be1c7ea0 100644 --- a/Examples/test-suite/register_par.i +++ b/Examples/test-suite/register_par.i @@ -4,6 +4,18 @@ struct swig_tree; %} +%{ +#if defined(__cplusplus) +#if __cplusplus >= 201703L +/* +Fix for languages that compile C tests as C++: + error: ISO C++17 does not allow ‘register’ storage class specifier [-Werror=register] +*/ +#define register +#endif +#endif +%} + // bug # 924413 %inline { void clear_tree_flags(register struct swig_tree *tp, register int i) {} diff --git a/Examples/test-suite/rname.i b/Examples/test-suite/rname.i index 09d6e3e3b..b7cf5d22b 100644 --- a/Examples/test-suite/rname.i +++ b/Examples/test-suite/rname.i @@ -22,7 +22,7 @@ %rename (newname) Space::Base::oldname(double d) const; /* Rename derived class method only */ -%rename (Xfunc) Space::Derived::fn(Base baseValue, Base* basePtr, Base& baseRef); +%rename (Xfunc) Space::Derived::fn1(Base baseValue, Base* basePtr, Base& baseRef); %inline %{ class Bar { @@ -43,14 +43,14 @@ class Base { public: Base(){}; virtual ~Base(){}; - void fn(Base baseValue, Base* basePtr, Base& baseRef){} + void fn1(Base baseValue, Base* basePtr, Base& baseRef){} virtual const char * oldname(double d) const { return "Base"; } }; class Derived : public Base { public: Derived(){} ~Derived(){} - void fn(Base baseValue, Base* basePtr, Base& baseRef){} + void fn1(Base baseValue, Base* basePtr, Base& baseRef){} virtual const char * oldname(double d) const { return "Derived"; } }; } diff --git a/Examples/test-suite/ruby/Makefile.in b/Examples/test-suite/ruby/Makefile.in index 2c59029ec..f982eca1f 100644 --- a/Examples/test-suite/ruby/Makefile.in +++ b/Examples/test-suite/ruby/Makefile.in @@ -84,6 +84,8 @@ ruby_naming.cpptest: SWIGOPT += -autorename run_testcase = \ if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(RUBY) $(RUBYFLAGS) -I$(srcdir):. $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ + elif [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*.so ] ; then \ + env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(RUBY) $(RUBYFLAGS) -I$(srcdir):. -r$(SCRIPTDIR)/$(SCRIPTPREFIX)$*.so -e '' ; \ fi # Clean diff --git a/Examples/test-suite/ruby/constant_directive_runme.rb b/Examples/test-suite/ruby/constant_directive_runme.rb new file mode 100644 index 000000000..ae6cf4fb3 --- /dev/null +++ b/Examples/test-suite/ruby/constant_directive_runme.rb @@ -0,0 +1,16 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' +require 'constant_directive' + +swig_assert("Constant_directive::TYPE1_CONSTANT1.is_a?(Constant_directive::Type1)", binding) +swig_assert("Constant_directive::getType1Instance().is_a?(Constant_directive::Type1)", binding) + +swig_assert_equal('Constant_directive::TYPE1_CONSTANT1.val', '1', binding) +swig_assert_equal('Constant_directive::TYPE1_CONSTANT2.val', '2', binding) +swig_assert_equal('Constant_directive::TYPE1_CONSTANT3.val', '3', binding) +swig_assert_equal('Constant_directive::TYPE1CONST_CONSTANT1.val', '1', binding) +swig_assert_equal('Constant_directive::TYPE1CPTR_CONSTANT1.val', '1', binding) diff --git a/Examples/test-suite/ruby/contract_runme.rb b/Examples/test-suite/ruby/contract_runme.rb new file mode 100644 index 000000000..df7fd3d8f --- /dev/null +++ b/Examples/test-suite/ruby/contract_runme.rb @@ -0,0 +1,69 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' +require 'contract' + +def swig_assert_runtime_error(msg, type, &block) + begin + yield(block) + raise SwigRubyError.new("#{msg} failed") + rescue RuntimeError => e + reason = e.to_s + if reason =~ /\bcontract violation\b/i && reason =~ /\b#{type}\b/i + # OK + else + raise e + end + end +end + +Contract::test_preassert(1, 2) +swig_assert_runtime_error("Preassertions", "require") { Contract::test_preassert(-1, 3) } + +Contract::test_postassert(3) +swig_assert_runtime_error("Postassertions", "ensure") { Contract::test_postassert(-3) } + +Contract::test_prepost(2, 3) +Contract::test_prepost(5, -4) +swig_assert_runtime_error("Preassertions", "require") { Contract::test_prepost(-3, 4) } +swig_assert_runtime_error("Postassertions", "ensure") { Contract::test_prepost(4, -10) } + +f = Contract::Foo.new +f.test_preassert(4, 5) +swig_assert_runtime_error("Method preassertion", "require") { f.test_preassert(-2, 3) } + +f.test_postassert(4) +swig_assert_runtime_error("Method postassertion", "ensure") { f.test_postassert(-4) } + +f.test_prepost(3, 4) +f.test_prepost(4, -3) +swig_assert_runtime_error("Method preassertion", "require") { f.test_prepost(-4, 2) } +swig_assert_runtime_error("Method postassertion", "ensure") { f.test_prepost(4, -10) } + +Contract::Foo.stest_prepost(4, 0) +swig_assert_runtime_error("Static method preassertion", "require") { Contract::Foo.stest_prepost(-4, 2) } +swig_assert_runtime_error("Static method postassertion", "ensure") { Contract::Foo.stest_prepost(4, -10) } + +b = Contract::Bar.new +swig_assert_runtime_error("Inherited preassertion", "require") { b.test_prepost(2, -4) } + +d = Contract::D.new +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.foo(-1, 1, 1, 1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.foo(1, -1, 1, 1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.foo(1, 1, -1, 1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.foo(1, 1, 1, -1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.foo(1, 1, 1, 1, -1) } + +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.bar(-1, 1, 1, 1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.bar(1, -1, 1, 1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.bar(1, 1, -1, 1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.bar(1, 1, 1, -1, 1) } +swig_assert_runtime_error("Inherited preassertion (D)", "require") { d.bar(1, 1, 1, 1, -1) } + +# namespace +Contract::MyClass.new(1) +swig_assert_runtime_error("Constructor preassertion", "require") { Contract::MyClass.new(0) } + diff --git a/Examples/test-suite/ruby/cpp11_alias_nested_template_scoping_runme.rb b/Examples/test-suite/ruby/cpp11_alias_nested_template_scoping_runme.rb new file mode 100644 index 000000000..c6e2b8559 --- /dev/null +++ b/Examples/test-suite/ruby/cpp11_alias_nested_template_scoping_runme.rb @@ -0,0 +1,23 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'cpp11_alias_nested_template_scoping' + +ys = Cpp11_alias_nested_template_scoping::Yshort.new +val = ys.create1 +val = ys.create2 +val = ys.create3 +val = ys.create4 +val = ys.create5 +val = ys.create6 +val = ys.create7 + +val = ys.create13 + +val = ys.create15 +val = ys.create16 +val = ys.create17 + diff --git a/Examples/test-suite/ruby/cpp17_nested_namespaces_runme.rb b/Examples/test-suite/ruby/cpp17_nested_namespaces_runme.rb new file mode 100644 index 000000000..e9e841179 --- /dev/null +++ b/Examples/test-suite/ruby/cpp17_nested_namespaces_runme.rb @@ -0,0 +1,24 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'cpp17_nested_namespaces' + +Cpp17_nested_namespaces::A1Struct.new.A1Method +Cpp17_nested_namespaces::B1Struct.new.B1Method +Cpp17_nested_namespaces::C1Struct.new.C1Method + +Cpp17_nested_namespaces.createA1Struct().A1Method +Cpp17_nested_namespaces.createB1Struct().B1Method +Cpp17_nested_namespaces.createC1Struct().C1Method + +Cpp17_nested_namespaces::B2Struct.new.B2Method +Cpp17_nested_namespaces::C2Struct.new.C2Method +Cpp17_nested_namespaces.createB2Struct().B2Method +Cpp17_nested_namespaces.createC2Struct().C2Method + +Cpp17_nested_namespaces::B3Struct.new.B3Method +Cpp17_nested_namespaces::C3Struct.new.C3Method +Cpp17_nested_namespaces.createB3Struct().B3Method +Cpp17_nested_namespaces.createC3Struct().C3Method diff --git a/Examples/test-suite/ruby/cpp_enum_runme.rb b/Examples/test-suite/ruby/cpp_enum_runme.rb new file mode 100644 index 000000000..0a395e0e0 --- /dev/null +++ b/Examples/test-suite/ruby/cpp_enum_runme.rb @@ -0,0 +1,19 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' +require 'cpp_enum' + +f = Cpp_enum::Foo.new +swig_assert_equal('f.hola', 'Cpp_enum::Foo::Hello', binding) + +f.hola = Cpp_enum::Foo::Hi +swig_assert_equal('f.hola', 'Cpp_enum::Foo::Hi', binding) + +f.hola = Cpp_enum::Foo::Hello +swig_assert_equal('f.hola', 'Cpp_enum::Foo::Hello', binding) + +Cpp_enum::hi = Cpp_enum::Hello +swig_assert_equal('Cpp_enum::hi', 'Cpp_enum::Hello', binding) diff --git a/Examples/test-suite/ruby/cpp_static_runme.rb b/Examples/test-suite/ruby/cpp_static_runme.rb new file mode 100644 index 000000000..85bdb7028 --- /dev/null +++ b/Examples/test-suite/ruby/cpp_static_runme.rb @@ -0,0 +1,26 @@ +#!/usr/bin/env ruby +# +# This test implementation is derived from its Python counterpart. +# + +require 'swig_assert' +require 'cpp_static' + +Cpp_static::StaticFunctionTest.static_func() +Cpp_static::StaticFunctionTest.static_func_2(1) +Cpp_static::StaticFunctionTest.static_func_3(1, 2) + +swig_assert_equal("Cpp_static::StaticMemberTest.static_int", "99", binding) +Cpp_static::StaticMemberTest.static_int = 10 +swig_assert_equal("Cpp_static::StaticMemberTest.static_int", "10", binding) + +swig_assert_equal("Cpp_static::StaticBase.statty", "11", binding) +swig_assert_equal("Cpp_static::StaticBase.grab_statty_base", "11", binding) +swig_assert_equal("Cpp_static::StaticDerived.statty", "111", binding) +swig_assert_equal("Cpp_static::StaticDerived.grab_statty_derived", "111", binding) +Cpp_static::StaticBase.statty = 22 +Cpp_static::StaticDerived.statty = 222 +swig_assert_equal("Cpp_static::StaticBase.statty", "22", binding) +swig_assert_equal("Cpp_static::StaticBase.grab_statty_base", "22", binding) +swig_assert_equal("Cpp_static::StaticDerived.statty", "222", binding) +swig_assert_equal("Cpp_static::StaticDerived.grab_statty_derived", "222", binding) diff --git a/Examples/test-suite/ruby/enums_runme.rb b/Examples/test-suite/ruby/enums_runme.rb index cafac25fa..274d59568 100644 --- a/Examples/test-suite/ruby/enums_runme.rb +++ b/Examples/test-suite/ruby/enums_runme.rb @@ -25,10 +25,7 @@ Enums::BAR1 == 0 Enums::BAR2 == 1 EOF -# -# @bug: -# -# swig_assert_each_line( <<EOF ) -# Enums::IFoo::Phoo == 50 -# Enums::IFoo::Char == 'a'[0] -# EOF +swig_assert_each_line( <<EOF ) +Enums::Phoo == 50 +Enums::Char == 'a'[0] +EOF diff --git a/Examples/test-suite/ruby/import_fragments_runme.rb b/Examples/test-suite/ruby/import_fragments_runme.rb new file mode 100644 index 000000000..a529980c0 --- /dev/null +++ b/Examples/test-suite/ruby/import_fragments_runme.rb @@ -0,0 +1,23 @@ +#!/usr/bin/env ruby +# +# Put description here +# +# +# +# +# + +require 'swig_assert' + +exception_file = nil + +begin + require 'import_fragments' +rescue LoadError => e + # due to missing import_fragments_a + exception_file = e.respond_to?(:path) ? e.path : e.to_s.sub(/.* -- /, '') +end + +swig_assert(exception_file == "import_fragments_a", + msg: "Loading should have failed due to missing 'import_fragments_a'") + diff --git a/Examples/test-suite/ruby/li_std_functors_runme.rb b/Examples/test-suite/ruby/li_std_functors_runme.rb index 5623d49f0..a2a7c6f3d 100644 --- a/Examples/test-suite/ruby/li_std_functors_runme.rb +++ b/Examples/test-suite/ruby/li_std_functors_runme.rb @@ -63,7 +63,9 @@ def test yield method(:_map), Li_std_functors::Map end -# these should fail and not segfault +# these should fail and not segfault but currently do segfault with Ruby 2.6 +# in GitHub Actions environment +if RUBY_VERSION != '2.6.6' begin Li_std_functors::Set.new('sd') rescue @@ -72,5 +74,4 @@ end test do |proc, container| proc.call(container) end - - +end diff --git a/Examples/test-suite/ruby/multiple_inheritance_abstract_runme.rb b/Examples/test-suite/ruby/multiple_inheritance_abstract_runme.rb new file mode 100644 index 000000000..01e9e6e4e --- /dev/null +++ b/Examples/test-suite/ruby/multiple_inheritance_abstract_runme.rb @@ -0,0 +1,243 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'multiple_inheritance_abstract' + +# Test base class as a parameter in Ruby + +def jcbase1b(cb1) + cb1.cbase1y +end + +def jabase1(ab1) + ab1.abase1 +end + +def jcbase2(cb2) + cb2.cbase2 +end + +# test Derived1 +d1 = Multiple_inheritance_abstract::Derived1.new +swig_assert_equal('d1.cbase1y', '3', binding, 'Derived1::cbase1y() failed') +swig_assert_equal('d1.cbase2', '4', binding, 'Derived1::cbase2() failed') + +# test Derived2 +d2 = Multiple_inheritance_abstract::Derived2.new +swig_assert_equal('d2.cbase1y', '6', binding, 'Derived2::cbase1y() failed') +swig_assert_equal('d2.abase1', '5', binding, 'Derived2::cbase1y() failed') + +# test Derived3 +d3 = Multiple_inheritance_abstract::Derived3.new +swig_assert_equal('d3.cbase1y', '7', binding, 'Derived3::cbase1y() failed') +swig_assert_equal('d3.cbase2', '8', binding, 'Derived3::cbase2() failed') +swig_assert_equal('d3.abase1', '9', binding, 'Derived3::abase1() failed') + +# test Bottom1 +b1 = Multiple_inheritance_abstract::Bottom1.new +swig_assert_equal('b1.cbase1y', '103', binding, 'Bottom1::cbase1y() failed') +swig_assert_equal('b1.cbase2', '104', binding, 'Bottom1::cbase2() failed') + +# test Bottom2 +b2 = Multiple_inheritance_abstract::Bottom2.new +swig_assert_equal('b2.cbase1y', '206', binding, 'Bottom2::cbase1y() failed') +swig_assert_equal('b2.abase1', '205', binding, 'Bottom2::abase1() failed') + +# test Bottom3 +b3 = Multiple_inheritance_abstract::Bottom3.new +swig_assert_equal('b3.cbase1y', '307', binding, 'Bottom3::cbase1y() failed') +swig_assert_equal('b3.cbase2', '308', binding, 'Bottom3::cbase2() failed') +swig_assert_equal('b3.abase1', '309', binding, 'Bottom3::abase1() failed') + +# test interfaces from C++ classes +cb1 = Multiple_inheritance_abstract::CBase1.new +cb2 = Multiple_inheritance_abstract::CBase2.new +swig_assert_equal('cb1.cbase1y', '1', binding, 'CBase1::cbase1y() failed') +swig_assert_equal('cb2.cbase2', '2', binding, 'CBase2::cbase2() failed') + +# test nspace class as return value +ab1 = d3.cloneit +swig_assert_equal('ab1.abase1', '9', binding, 'Derived3::abase1() through ABase1 failed') + +# test concrete base class as return value +cb6 = d2.cloneit +cb7 = d1.cloneit +swig_assert_equal('cb6.cbase1y', '6', binding, 'Derived2::cbase1y() through CBase1 failed') +swig_assert_equal('cb7.cbase2', '4', binding, 'Derived1:cbase2() through ABase1 failed') + +# test multi inheritance +cb3 = Multiple_inheritance_abstract::Derived1.new +cb4 = Multiple_inheritance_abstract::Derived3.new +cb5 = Multiple_inheritance_abstract::Derived3.new +ab6 = Multiple_inheritance_abstract::Derived2.new +swig_assert_equal('cb3.cbase1y', '3', binding, 'Derived1::cbase1y() through CBase1 failed') +swig_assert_equal('cb4.cbase1y', '7', binding, 'Derived3::cbase1y() through CBase1 failed') +swig_assert_equal('cb5.cbase2', '8', binding, 'Derived3::cbase2() through CBase2 failed') +swig_assert_equal('ab6.abase1', '5', binding, 'Derived2::abase1() through ABase1 failed') + +# test base classes as parameter in Ruby +swig_assert_equal('jcbase1b(d1)', '3', binding, 'jcbase1b() through Derived1 as parameter failed') +swig_assert_equal('jcbase1b(d2)', '6', binding, 'jcbase1b() through Derived2 as parameter failed') +swig_assert_equal('jcbase1b(d3)', '7', binding, 'jcbase1b() through Derived3 as parameter failed') +swig_assert_equal('jcbase2(d1)', '4', binding, 'jcbase2() through Derived1 as parameter failed') +swig_assert_equal('jcbase2(d3)', '8', binding, 'jcbase2() through Derived3 as parameter failed') +swig_assert_equal('jabase1(d2)', '5', binding, 'jabase1() through Derived2 as parameter failed') +swig_assert_equal('jabase1(d3)', '9', binding, 'jabase1() through Derived3 as parameter failed') + +# value parameters +# test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes) +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(d1)', '1', binding, 'InputValCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(d2)', '1', binding, 'InputValCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(d3)', '1', binding, 'InputValCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase2(d3)', '2', binding, 'InputValCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase2(d1)', '2', binding, 'InputValCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(cb1)', '1', binding, 'InputValCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase2(cb2)', '2', binding, 'InputValCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(b1)', '1', binding, 'InputValCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(b2)', '1', binding, 'InputValCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase1(b3)', '1', binding, 'InputValCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase2(b3)', '2', binding, 'InputValCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValCBase2(b1)', '2', binding, 'InputValCBase2(), Bottom1 as a parameter failed') + +# pointer parameters +# test ABase1 as a parameter +swig_assert_equal('Multiple_inheritance_abstract::InputPtrABase1(d2)', '5', binding, 'InputPtrABase1() through Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrABase1(d3)', '9', binding, 'InputPtrABase1() through Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrABase1(b2)', '205', binding, 'InputPtrABase1() through Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrABase1(b3)', '309', binding, 'InputPtrABase1() through Bottom3 as a parameter failed') + +# test CBase1 CBase2 as parameters +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(d1)', '3', binding, 'InputPtrCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(d2)', '6', binding, 'InputPtrCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(d3)', '7', binding, 'InputPtrCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase2(d3)', '8', binding, 'InputPtrCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase2(d1)', '4', binding, 'InputPtrCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(cb1)', '1', binding, 'InputPtrCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase2(cb2)', '2', binding, 'InputPtrCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(b1)', '103', binding, 'InputPtrCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(b2)', '206', binding, 'InputPtrCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase1(b3)', '307', binding, 'InputPtrCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase2(b3)', '308', binding, 'InputPtrCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrCBase2(b1)', '104', binding, 'InputPtrCBase2(), Bottom1 as a parameter failed') + +# reference parameters +# test ABase1 as a parameter +swig_assert_equal('Multiple_inheritance_abstract::InputRefABase1(d2)', '5', binding, 'InputRefABase1() through Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefABase1(d3)', '9', binding, 'InputRefABase1() through Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefABase1(b2)', '205', binding, 'InputRefABase1() through Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefABase1(b3)', '309', binding, 'InputRefABase1() through Bottom3 as a parameter failed') + +# test CBase1 CBase2 as parameters +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(d1)', '3', binding, 'InputRefCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(d2)', '6', binding, 'InputRefCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(d3)', '7', binding, 'InputRefCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase2(d3)', '8', binding, 'InputRefCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase2(d1)', '4', binding, 'InputRefCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(cb1)', '1', binding, 'InputRefCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase2(cb2)', '2', binding, 'InputRefCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(b1)', '103', binding, 'InputRefCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(b2)', '206', binding, 'InputRefCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase1(b3)', '307', binding, 'InputRefCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase2(b3)', '308', binding, 'InputRefCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefCBase2(b1)', '104', binding, 'InputRefCBase2(), Bottom1 as a parameter failed') + +# const reference pointer parameters +# test ABase1 as a parameter +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefABase1(d2)', '5', binding, 'InputCPtrRefABase1() through Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefABase1(d3)', '9', binding, 'InputCPtrRefABase1() through Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefABase1(b2)', '205', binding, 'InputCPtrRefABase1() through Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefABase1(b3)', '309', binding, 'InputCPtrRefABase1() through Bottom3 as a parameter failed') + +# test CBase1 CBase2 as parameters +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(d1)', '3', binding, 'InputCPtrRefCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(d2)', '6', binding, 'InputCPtrRefCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(d3)', '7', binding, 'InputCPtrRefCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase2(d3)', '8', binding, 'InputCPtrRefCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase2(d1)', '4', binding, 'InputCPtrRefCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(cb1)', '1', binding, 'InputCPtrRefCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase2(cb2)', '2', binding, 'InputCPtrRefCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(b1)', '103', binding, 'InputCPtrRefCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(b2)', '206', binding, 'InputCPtrRefCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase1(b3)', '307', binding, 'InputCPtrRefCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase2(b3)', '308', binding, 'InputCPtrRefCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefCBase2(b1)', '104', binding, 'InputCPtrRefCBase2(), Bottom1 as a parameter failed') + +# derived classes as parameters +swig_assert_equal('Multiple_inheritance_abstract::InputValDerived1(d1)', '3+4', binding, 'InputValDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValDerived2(d2)', '6+5', binding, 'InputValDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValDerived3(d3)', '7+8+9', binding, 'InputValDerived3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputRefDerived1(d1)', '3+4', binding, 'InputRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefDerived2(d2)', '6+5', binding, 'InputRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefDerived3(d3)', '7+8+9', binding, 'InputRefDerived3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputPtrDerived1(d1)', '3+4', binding, 'InputPtrDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrDerived2(d2)', '6+5', binding, 'InputPtrDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrDerived3(d3)', '7+8+9', binding, 'InputPtrDerived3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefDerived1(d1)', '3+4', binding, 'InputCPtrRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefDerived2(d2)', '6+5', binding, 'InputCPtrRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefDerived3(d3)', '7+8+9', binding, 'InputCPtrRefDerived3() failed') + +# bottom classes as Derived parameters +swig_assert_equal('Multiple_inheritance_abstract::InputValDerived1(b1)', '3+4', binding, 'InputValDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValDerived2(b2)', '6+5', binding, 'InputValDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValDerived3(b3)', '7+8+9', binding, 'InputValDerived3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputRefDerived1(b1)', '103+104', binding, 'InputRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefDerived2(b2)', '206+205', binding, 'InputRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefDerived3(b3)', '307+308+309', binding, 'InputRefDerived3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputPtrDerived1(b1)', '103+104', binding, 'InputPtrDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrDerived2(b2)', '206+205', binding, 'InputPtrDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrDerived3(b3)', '307+308+309', binding, 'InputPtrDerived3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefDerived1(b1)', '103+104', binding, 'InputCPtrRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefDerived2(b2)', '206+205', binding, 'InputCPtrRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefDerived3(b3)', '307+308+309', binding, 'InputCPtrRefDerived3() failed') + +# bottom classes as Bottom parameters +swig_assert_equal('Multiple_inheritance_abstract::InputValBottom1(b1)', '103+104', binding, 'InputValBottom1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValBottom2(b2)', '206+205', binding, 'InputValBottom2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputValBottom3(b3)', '307+308+309', binding, 'InputValBottom3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputRefBottom1(b1)', '103+104', binding, 'InputRefBottom1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefBottom2(b2)', '206+205', binding, 'InputRefBottom2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputRefBottom3(b3)', '307+308+309', binding, 'InputRefBottom3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputPtrBottom1(b1)', '103+104', binding, 'InputPtrBottom1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrBottom2(b2)', '206+205', binding, 'InputPtrBottom2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputPtrBottom3(b3)', '307+308+309', binding, 'InputPtrBottom3() failed') + +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefBottom1(b1)', '103+104', binding, 'InputCPtrRefBottom1() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefBottom2(b2)', '206+205', binding, 'InputCPtrRefBottom2() failed') +swig_assert_equal('Multiple_inheritance_abstract::InputCPtrRefBottom3(b3)', '307+308+309', binding, 'InputCPtrRefBottom3() failed') + +# return pointers +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived1_CBase1().cbase1y', '3', binding, 'MakePtrDerived1_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived1_CBase2().cbase2', '4', binding, 'MakePtrDerived1_CBase2 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived2_CBase1().cbase1y', '6', binding, 'MakePtrDerived2_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived2_ABase1().abase1', '5', binding, 'MakePtrDerived2_ABase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived3_ABase1().abase1', '9', binding, 'MakePtrDerived3_ABase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived3_CBase1().cbase1y', '7', binding, 'MakePtrDerived3_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakePtrDerived3_CBase2().cbase2', '8', binding, 'MakePtrDerived3_CBase2 failed') + +# return references +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived1_CBase1().cbase1y', '3', binding, 'MakeRefDerived1_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived1_CBase2().cbase2', '4', binding, 'MakeRefDerived1_CBase2 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived2_CBase1().cbase1y', '6', binding, 'MakeRefDerived2_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived2_ABase1().abase1', '5', binding, 'MakeRefDerived2_ABase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived3_ABase1().abase1', '9', binding, 'MakeRefDerived3_ABase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived3_CBase1().cbase1y', '7', binding, 'MakeRefDerived3_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeRefDerived3_CBase2().cbase2', '8', binding, 'MakeRefDerived3_CBase2 failed') + +# return by value (sliced objects) +swig_assert_equal('Multiple_inheritance_abstract::MakeValDerived1_CBase1().cbase1y', '1', binding, 'MakeValDerived1_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeValDerived1_CBase2().cbase2', '2', binding, 'MakeValDerived1_CBase2 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeValDerived2_CBase1().cbase1y', '1', binding, 'MakeValDerived2_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeValDerived3_CBase1().cbase1y', '1', binding, 'MakeValDerived3_CBase1 failed') +swig_assert_equal('Multiple_inheritance_abstract::MakeValDerived3_CBase2().cbase2', '2', binding, 'MakeValDerived3_CBase2 failed') + diff --git a/Examples/test-suite/ruby/multiple_inheritance_nspace_runme.rb b/Examples/test-suite/ruby/multiple_inheritance_nspace_runme.rb new file mode 100644 index 000000000..fb28a0f83 --- /dev/null +++ b/Examples/test-suite/ruby/multiple_inheritance_nspace_runme.rb @@ -0,0 +1,243 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'multiple_inheritance_nspace' + +# Test base class as a parameter in Ruby + +def jcbase1b(cb1) + cb1.cbase1y +end + +def jabase1(ab1) + ab1.abase1 +end + +def jcbase2(cb2) + cb2.cbase2 +end + +# test Derived1 +d1 = Multiple_inheritance_nspace::Derived1.new +swig_assert_equal('d1.cbase1y', '3', binding, 'Derived1::cbase1y() failed') +swig_assert_equal('d1.cbase2', '4', binding, 'Derived1::cbase2() failed') + +# test Derived2 +d2 = Multiple_inheritance_nspace::Derived2.new +swig_assert_equal('d2.cbase1y', '6', binding, 'Derived2::cbase1y() failed') +swig_assert_equal('d2.abase1', '5', binding, 'Derived2::cbase1y() failed') + +# test Derived3 +d3 = Multiple_inheritance_nspace::Derived3.new +swig_assert_equal('d3.cbase1y', '7', binding, 'Derived3::cbase1y() failed') +swig_assert_equal('d3.cbase2', '8', binding, 'Derived3::cbase2() failed') +swig_assert_equal('d3.abase1', '9', binding, 'Derived3::abase1() failed') + +# test Bottom1 +b1 = Multiple_inheritance_nspace::Bottom1.new +swig_assert_equal('b1.cbase1y', '103', binding, 'Bottom1::cbase1y() failed') +swig_assert_equal('b1.cbase2', '104', binding, 'Bottom1::cbase2() failed') + +# test Bottom2 +b2 = Multiple_inheritance_nspace::Bottom2.new +swig_assert_equal('b2.cbase1y', '206', binding, 'Bottom2::cbase1y() failed') +swig_assert_equal('b2.abase1', '205', binding, 'Bottom2::abase1() failed') + +# test Bottom3 +b3 = Multiple_inheritance_nspace::Bottom3.new +swig_assert_equal('b3.cbase1y', '307', binding, 'Bottom3::cbase1y() failed') +swig_assert_equal('b3.cbase2', '308', binding, 'Bottom3::cbase2() failed') +swig_assert_equal('b3.abase1', '309', binding, 'Bottom3::abase1() failed') + +# test interfaces from C++ classes +cb1 = Multiple_inheritance_nspace::CBase1.new +cb2 = Multiple_inheritance_nspace::CBase2.new +swig_assert_equal('cb1.cbase1y', '1', binding, 'CBase1::cbase1y() failed') +swig_assert_equal('cb2.cbase2', '2', binding, 'CBase2::cbase2() failed') + +# test nspace class as return value +ab1 = d3.cloneit +swig_assert_equal('ab1.abase1', '9', binding, 'Derived3::abase1() through ABase1 failed') + +# test concrete base class as return value +cb6 = d2.cloneit +cb7 = d1.cloneit +swig_assert_equal('cb6.cbase1y', '6', binding, 'Derived2::cbase1y() through CBase1 failed') +swig_assert_equal('cb7.cbase2', '4', binding, 'Derived1:cbase2() through ABase1 failed') + +# test multi inheritance +cb3 = Multiple_inheritance_nspace::Derived1.new +cb4 = Multiple_inheritance_nspace::Derived3.new +cb5 = Multiple_inheritance_nspace::Derived3.new +ab6 = Multiple_inheritance_nspace::Derived2.new +swig_assert_equal('cb3.cbase1y', '3', binding, 'Derived1::cbase1y() through CBase1 failed') +swig_assert_equal('cb4.cbase1y', '7', binding, 'Derived3::cbase1y() through CBase1 failed') +swig_assert_equal('cb5.cbase2', '8', binding, 'Derived3::cbase2() through CBase2 failed') +swig_assert_equal('ab6.abase1', '5', binding, 'Derived2::abase1() through ABase1 failed') + +# test base classes as parameter in Ruby +swig_assert_equal('jcbase1b(d1)', '3', binding, 'jcbase1b() through Derived1 as parameter failed') +swig_assert_equal('jcbase1b(d2)', '6', binding, 'jcbase1b() through Derived2 as parameter failed') +swig_assert_equal('jcbase1b(d3)', '7', binding, 'jcbase1b() through Derived3 as parameter failed') +swig_assert_equal('jcbase2(d1)', '4', binding, 'jcbase2() through Derived1 as parameter failed') +swig_assert_equal('jcbase2(d3)', '8', binding, 'jcbase2() through Derived3 as parameter failed') +swig_assert_equal('jabase1(d2)', '5', binding, 'jabase1() through Derived2 as parameter failed') +swig_assert_equal('jabase1(d3)', '9', binding, 'jabase1() through Derived3 as parameter failed') + +# value parameters +# test CBase1 CBase2 as parameters (note slicing for Derived and Bottom classes) +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(d1)', '1', binding, 'InputValCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(d2)', '1', binding, 'InputValCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(d3)', '1', binding, 'InputValCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase2(d3)', '2', binding, 'InputValCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase2(d1)', '2', binding, 'InputValCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(cb1)', '1', binding, 'InputValCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase2(cb2)', '2', binding, 'InputValCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(b1)', '1', binding, 'InputValCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(b2)', '1', binding, 'InputValCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase1(b3)', '1', binding, 'InputValCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase2(b3)', '2', binding, 'InputValCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValCBase2(b1)', '2', binding, 'InputValCBase2(), Bottom1 as a parameter failed') + +# pointer parameters +# test ABase1 as a parameter +swig_assert_equal('Multiple_inheritance_nspace::InputPtrABase1(d2)', '5', binding, 'InputPtrABase1() through Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrABase1(d3)', '9', binding, 'InputPtrABase1() through Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrABase1(b2)', '205', binding, 'InputPtrABase1() through Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrABase1(b3)', '309', binding, 'InputPtrABase1() through Bottom3 as a parameter failed') + +# test CBase1 CBase2 as parameters +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(d1)', '3', binding, 'InputPtrCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(d2)', '6', binding, 'InputPtrCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(d3)', '7', binding, 'InputPtrCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase2(d3)', '8', binding, 'InputPtrCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase2(d1)', '4', binding, 'InputPtrCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(cb1)', '1', binding, 'InputPtrCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase2(cb2)', '2', binding, 'InputPtrCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(b1)', '103', binding, 'InputPtrCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(b2)', '206', binding, 'InputPtrCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase1(b3)', '307', binding, 'InputPtrCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase2(b3)', '308', binding, 'InputPtrCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrCBase2(b1)', '104', binding, 'InputPtrCBase2(), Bottom1 as a parameter failed') + +# reference parameters +# test ABase1 as a parameter +swig_assert_equal('Multiple_inheritance_nspace::InputRefABase1(d2)', '5', binding, 'InputRefABase1() through Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefABase1(d3)', '9', binding, 'InputRefABase1() through Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefABase1(b2)', '205', binding, 'InputRefABase1() through Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefABase1(b3)', '309', binding, 'InputRefABase1() through Bottom3 as a parameter failed') + +# test CBase1 CBase2 as parameters +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(d1)', '3', binding, 'InputRefCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(d2)', '6', binding, 'InputRefCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(d3)', '7', binding, 'InputRefCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase2(d3)', '8', binding, 'InputRefCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase2(d1)', '4', binding, 'InputRefCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(cb1)', '1', binding, 'InputRefCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase2(cb2)', '2', binding, 'InputRefCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(b1)', '103', binding, 'InputRefCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(b2)', '206', binding, 'InputRefCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase1(b3)', '307', binding, 'InputRefCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase2(b3)', '308', binding, 'InputRefCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefCBase2(b1)', '104', binding, 'InputRefCBase2(), Bottom1 as a parameter failed') + +# const reference pointer parameters +# test ABase1 as a parameter +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefABase1(d2)', '5', binding, 'InputCPtrRefABase1() through Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefABase1(d3)', '9', binding, 'InputCPtrRefABase1() through Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefABase1(b2)', '205', binding, 'InputCPtrRefABase1() through Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefABase1(b3)', '309', binding, 'InputCPtrRefABase1() through Bottom3 as a parameter failed') + +# test CBase1 CBase2 as parameters +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(d1)', '3', binding, 'InputCPtrRefCBase1(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(d2)', '6', binding, 'InputCPtrRefCBase1(), Derived2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(d3)', '7', binding, 'InputCPtrRefCBase1(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase2(d3)', '8', binding, 'InputCPtrRefCBase2(), Derived3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase2(d1)', '4', binding, 'InputCPtrRefCBase2(), Derived1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(cb1)', '1', binding, 'InputCPtrRefCBase1(), CBase1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase2(cb2)', '2', binding, 'InputCPtrRefCBase2(), CBase2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(b1)', '103', binding, 'InputCPtrRefCBase1(), Bottom1 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(b2)', '206', binding, 'InputCPtrRefCBase1(), Bottom2 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase1(b3)', '307', binding, 'InputCPtrRefCBase1(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase2(b3)', '308', binding, 'InputCPtrRefCBase2(), Bottom3 as a parameter failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefCBase2(b1)', '104', binding, 'InputCPtrRefCBase2(), Bottom1 as a parameter failed') + +# derived classes as parameters +swig_assert_equal('Multiple_inheritance_nspace::InputValDerived1(d1)', '3+4', binding, 'InputValDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValDerived2(d2)', '6+5', binding, 'InputValDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValDerived3(d3)', '7+8+9', binding, 'InputValDerived3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputRefDerived1(d1)', '3+4', binding, 'InputRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefDerived2(d2)', '6+5', binding, 'InputRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefDerived3(d3)', '7+8+9', binding, 'InputRefDerived3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputPtrDerived1(d1)', '3+4', binding, 'InputPtrDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrDerived2(d2)', '6+5', binding, 'InputPtrDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrDerived3(d3)', '7+8+9', binding, 'InputPtrDerived3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefDerived1(d1)', '3+4', binding, 'InputCPtrRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefDerived2(d2)', '6+5', binding, 'InputCPtrRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefDerived3(d3)', '7+8+9', binding, 'InputCPtrRefDerived3() failed') + +# bottom classes as Derived parameters +swig_assert_equal('Multiple_inheritance_nspace::InputValDerived1(b1)', '3+4', binding, 'InputValDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValDerived2(b2)', '6+5', binding, 'InputValDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValDerived3(b3)', '7+8+9', binding, 'InputValDerived3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputRefDerived1(b1)', '103+104', binding, 'InputRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefDerived2(b2)', '206+205', binding, 'InputRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefDerived3(b3)', '307+308+309', binding, 'InputRefDerived3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputPtrDerived1(b1)', '103+104', binding, 'InputPtrDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrDerived2(b2)', '206+205', binding, 'InputPtrDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrDerived3(b3)', '307+308+309', binding, 'InputPtrDerived3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefDerived1(b1)', '103+104', binding, 'InputCPtrRefDerived1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefDerived2(b2)', '206+205', binding, 'InputCPtrRefDerived2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefDerived3(b3)', '307+308+309', binding, 'InputCPtrRefDerived3() failed') + +# bottom classes as Bottom parameters +swig_assert_equal('Multiple_inheritance_nspace::InputValBottom1(b1)', '103+104', binding, 'InputValBottom1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValBottom2(b2)', '206+205', binding, 'InputValBottom2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputValBottom3(b3)', '307+308+309', binding, 'InputValBottom3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputRefBottom1(b1)', '103+104', binding, 'InputRefBottom1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefBottom2(b2)', '206+205', binding, 'InputRefBottom2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputRefBottom3(b3)', '307+308+309', binding, 'InputRefBottom3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputPtrBottom1(b1)', '103+104', binding, 'InputPtrBottom1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrBottom2(b2)', '206+205', binding, 'InputPtrBottom2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputPtrBottom3(b3)', '307+308+309', binding, 'InputPtrBottom3() failed') + +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefBottom1(b1)', '103+104', binding, 'InputCPtrRefBottom1() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefBottom2(b2)', '206+205', binding, 'InputCPtrRefBottom2() failed') +swig_assert_equal('Multiple_inheritance_nspace::InputCPtrRefBottom3(b3)', '307+308+309', binding, 'InputCPtrRefBottom3() failed') + +# return pointers +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived1_CBase1().cbase1y', '3', binding, 'MakePtrDerived1_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived1_CBase2().cbase2', '4', binding, 'MakePtrDerived1_CBase2 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived2_CBase1().cbase1y', '6', binding, 'MakePtrDerived2_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived2_ABase1().abase1', '5', binding, 'MakePtrDerived2_ABase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived3_ABase1().abase1', '9', binding, 'MakePtrDerived3_ABase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived3_CBase1().cbase1y', '7', binding, 'MakePtrDerived3_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakePtrDerived3_CBase2().cbase2', '8', binding, 'MakePtrDerived3_CBase2 failed') + +# return references +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived1_CBase1().cbase1y', '3', binding, 'MakeRefDerived1_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived1_CBase2().cbase2', '4', binding, 'MakeRefDerived1_CBase2 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived2_CBase1().cbase1y', '6', binding, 'MakeRefDerived2_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived2_ABase1().abase1', '5', binding, 'MakeRefDerived2_ABase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived3_ABase1().abase1', '9', binding, 'MakeRefDerived3_ABase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived3_CBase1().cbase1y', '7', binding, 'MakeRefDerived3_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeRefDerived3_CBase2().cbase2', '8', binding, 'MakeRefDerived3_CBase2 failed') + +# return by value (sliced objects) +swig_assert_equal('Multiple_inheritance_nspace::MakeValDerived1_CBase1().cbase1y', '1', binding, 'MakeValDerived1_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeValDerived1_CBase2().cbase2', '2', binding, 'MakeValDerived1_CBase2 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeValDerived2_CBase1().cbase1y', '1', binding, 'MakeValDerived2_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeValDerived3_CBase1().cbase1y', '1', binding, 'MakeValDerived3_CBase1 failed') +swig_assert_equal('Multiple_inheritance_nspace::MakeValDerived3_CBase2().cbase2', '2', binding, 'MakeValDerived3_CBase2 failed') + diff --git a/Examples/test-suite/ruby/namespace_chase_runme.rb b/Examples/test-suite/ruby/namespace_chase_runme.rb new file mode 100644 index 000000000..c5f227dfd --- /dev/null +++ b/Examples/test-suite/ruby/namespace_chase_runme.rb @@ -0,0 +1,14 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'namespace_chase' + +s1a = Namespace_chase::Struct1A.new +s1b = Namespace_chase::Struct1B.new +s1c = Namespace_chase::Struct1C.new + +Namespace_chase.sss3a(s1a, s1b, s1c) +Namespace_chase.sss3b(s1a, s1b, s1c) diff --git a/Examples/test-suite/ruby/namespace_class_runme.rb b/Examples/test-suite/ruby/namespace_class_runme.rb new file mode 100644 index 000000000..fd9345814 --- /dev/null +++ b/Examples/test-suite/ruby/namespace_class_runme.rb @@ -0,0 +1,40 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' +require 'namespace_class' + +begin + p = Namespace_class::Private1.new + raise SwigRubyError.new("Private1 is private") +rescue NameError => e + # OK +end + +begin + p = Namespace_class::Private2.new + raise SwigRubyError.new("Private2 is private") +rescue NameError => e + # OK +end + +Namespace_class::EulerT3D.toFrame(1, 1, 1) + +b = Namespace_class::BooT_i.new +b = Namespace_class::BooT_H.new + + +f = Namespace_class::FooT_i.new +f.quack(1) + +f = Namespace_class::FooT_d.new +f.moo(1) + +f = Namespace_class::FooT_H.new +f.foo(Namespace_class::Hi) + +f_type = f.class.to_s +swig_assert_equal('f_type', '"Namespace_class::FooT_H"', binding) + diff --git a/Examples/test-suite/ruby/namespace_forward_declaration_runme.rb b/Examples/test-suite/ruby/namespace_forward_declaration_runme.rb new file mode 100644 index 000000000..0e6b50eb8 --- /dev/null +++ b/Examples/test-suite/ruby/namespace_forward_declaration_runme.rb @@ -0,0 +1,16 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'namespace_forward_declaration' + +xxx = Namespace_forward_declaration::XXX.new +Namespace_forward_declaration.testXXX1(xxx) +Namespace_forward_declaration.testXXX2(xxx) +Namespace_forward_declaration.testXXX3(xxx) +yyy = Namespace_forward_declaration::YYY.new +Namespace_forward_declaration.testYYY1(yyy) +Namespace_forward_declaration.testYYY2(yyy) +Namespace_forward_declaration.testYYY3(yyy) diff --git a/Examples/test-suite/ruby/namespace_virtual_method_runme.rb b/Examples/test-suite/ruby/namespace_virtual_method_runme.rb new file mode 100644 index 000000000..54e4a7a21 --- /dev/null +++ b/Examples/test-suite/ruby/namespace_virtual_method_runme.rb @@ -0,0 +1,8 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'namespace_virtual_method' + +x = Namespace_virtual_method::Spam.new diff --git a/Examples/test-suite/ruby/nested_class_runme.rb b/Examples/test-suite/ruby/nested_class_runme.rb new file mode 100644 index 000000000..2cf3bf96a --- /dev/null +++ b/Examples/test-suite/ruby/nested_class_runme.rb @@ -0,0 +1,54 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'nested_class' + +outer = Nested_class::Outer.new +is1 = outer.makeInnerStruct1 +ic1 = outer.makeInnerClass1 +iu1 = outer.makeInnerUnion1 + +is2 = outer.makeInnerStruct2 +ic2 = outer.makeInnerClass2 +iu2 = outer.makeInnerUnion2 + +ic4 = outer.makeInnerClass4Typedef +is4 = outer.makeInnerStruct4Typedef +iu4 = outer.makeInnerUnion4Typedef + +ic5 = outer.makeInnerClass5 +is5 = outer.makeInnerStruct5 +iu5 = outer.makeInnerUnion5 + +ic5 = outer.makeInnerClass5Typedef +is5 = outer.makeInnerStruct5Typedef +iu5 = outer.makeInnerUnion5Typedef + +im1 = outer.MultipleInstance1 +im2 = outer.MultipleInstance2 +im3 = outer.MultipleInstance3 +im4 = outer.MultipleInstance4 + +im1 = outer.MultipleDerivedInstance1 +im2 = outer.MultipleDerivedInstance2 +im3 = outer.MultipleDerivedInstance3 +im4 = outer.MultipleDerivedInstance4 + +im1 = outer.MultipleDerivedInstance1 +im2 = outer.MultipleDerivedInstance2 +im3 = outer.MultipleDerivedInstance3 +im4 = outer.MultipleDerivedInstance4 + +mat1 = outer.makeInnerMultipleAnonTypedef1 +mat2 = outer.makeInnerMultipleAnonTypedef2 +mat3 = outer.makeInnerMultipleAnonTypedef3 + +mnt = outer.makeInnerMultipleNamedTypedef +mnt1 = outer.makeInnerMultipleNamedTypedef1 +mnt2 = outer.makeInnerMultipleNamedTypedef2 +mnt3 = outer.makeInnerMultipleNamedTypedef3 + +isn = outer.makeInnerSameName diff --git a/Examples/test-suite/ruby/nested_directors_runme.rb b/Examples/test-suite/ruby/nested_directors_runme.rb new file mode 100644 index 000000000..b2020b3d4 --- /dev/null +++ b/Examples/test-suite/ruby/nested_directors_runme.rb @@ -0,0 +1,29 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its C# counterpart. +# + +require 'swig_assert' +require 'nested_directors' + +# nested classes not yet supported +#class CNested < Nested_directors::Base::Nest +# def GetValue +# true +# end +#end + +class CSub < Nested_directors::Sub + def GetValue + super + end + def Test + GetValue() + end +end + +#n = CNested.new +#swig_assert('n.GetValue()', binding) + +s = CSub.new +swig_assert('s.Test()', binding) diff --git a/Examples/test-suite/ruby/nested_in_template_runme.rb b/Examples/test-suite/ruby/nested_in_template_runme.rb new file mode 100644 index 000000000..4d3b721a1 --- /dev/null +++ b/Examples/test-suite/ruby/nested_in_template_runme.rb @@ -0,0 +1,11 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' +require 'nested_in_template' + + +cd = Nested_in_template::ConcreteDerived.new(88) +swig_assert_equal('cd.m_value', '88', binding, 'ConcreteDerived not created correctly') diff --git a/Examples/test-suite/ruby/nested_scope_flat_runme.rb b/Examples/test-suite/ruby/nested_scope_flat_runme.rb new file mode 100644 index 000000000..bd7ee7c91 --- /dev/null +++ b/Examples/test-suite/ruby/nested_scope_flat_runme.rb @@ -0,0 +1,25 @@ +#!/usr/bin/env ruby +# +# Check the availability of expected classes and their member variables. +# + +require 'swig_assert' +require 'nested_scope_flat' + +Nested_scope_flat::Global_.new +Nested_scope_flat::Outer1.new +nested2 = Nested_scope_flat::Nested2.new +nested2.data = 42 +swig_assert_equal("nested2.data", "42", binding) +Nested_scope_flat::Klass.new + +Nested_scope_flat::Abstract_int +cannot_instantiate = false +begin + Nested_scope_flat::Abstract_int.new +rescue TypeError + cannot_instantiate = true +end +swig_assert_simple(cannot_instantiate) + +Nested_scope_flat::Real.new.Method() diff --git a/Examples/test-suite/ruby/nested_template_base_runme.rb b/Examples/test-suite/ruby/nested_template_base_runme.rb new file mode 100644 index 000000000..a4f293365 --- /dev/null +++ b/Examples/test-suite/ruby/nested_template_base_runme.rb @@ -0,0 +1,16 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' +require 'nested_template_base' + +ois = Nested_template_base::InnerS.new(123) +oic = Nested_template_base::InnerC.new + +# Check base method is available +swig_assert_equal('oic.outer(ois).val', '123', binding, 'Wrong value calling outer') + +# Check non-derived class using base class +swig_assert_equal('oic.innerc().outer(ois).val', '123', binding, 'Wrong value calling innerc') diff --git a/Examples/test-suite/ruby/nested_workaround_runme.rb b/Examples/test-suite/ruby/nested_workaround_runme.rb new file mode 100644 index 000000000..645bdd321 --- /dev/null +++ b/Examples/test-suite/ruby/nested_workaround_runme.rb @@ -0,0 +1,21 @@ +#!/usr/bin/env ruby +# +# This test implementation is derived from its Java counterpart. +# + +require 'swig_assert' +require 'nested_workaround' + +begin + inner = Nested_workaround::Inner.new(5) + outer = Nested_workaround::Outer.new + newInner = outer.doubleInnerValue(inner) + swig_assert_equal("newInner.getValue", "10", binding) +end + +begin + outer = Nested_workaround::Outer.new + inner = outer.createInner(3) + newInner = outer.doubleInnerValue(inner) + swig_assert_equal("outer.getInnerValue(newInner)", "6", binding) +end diff --git a/Examples/test-suite/ruby/overload_null_runme.rb b/Examples/test-suite/ruby/overload_null_runme.rb index eabea5e40..e84851a88 100644 --- a/Examples/test-suite/ruby/overload_null_runme.rb +++ b/Examples/test-suite/ruby/overload_null_runme.rb @@ -40,13 +40,13 @@ swig_assert(14 == o.byval1cpr(nil)) swig_assert(15 == o.byval2cpr(nil)) swig_assert(16 == o.byval2cpr(x)) -# forward class declaration -swig_assert(17 == o.byval1forwardptr(x)) -swig_assert(18 == o.byval1forwardptr(nil)) +# fwd class declaration +swig_assert(17 == o.byval1fwdptr(x)) +swig_assert(18 == o.byval1fwdptr(nil)) -swig_assert(19 == o.byval2forwardptr(nil)) -swig_assert(20 == o.byval2forwardptr(x)) +swig_assert(19 == o.byval2fwdptr(nil)) +swig_assert(20 == o.byval2fwdptr(x)) -swig_assert(21 == o.byval1forwardref(x)) +swig_assert(21 == o.byval1fwdref(x)) -swig_assert(22 == o.byval2forwardref(x)) +swig_assert(22 == o.byval2fwdref(x)) diff --git a/Examples/test-suite/ruby/preproc_runme.rb b/Examples/test-suite/ruby/preproc_runme.rb new file mode 100644 index 000000000..4b4a9157d --- /dev/null +++ b/Examples/test-suite/ruby/preproc_runme.rb @@ -0,0 +1,40 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'swig_assert' + +# This extension to the Warning class is intended for suppressing expected +# Ruby warning messages about invalid or redefined Ruby constants - basically +# the equivalent of %warnfilter(SWIGWARN_RUBY_WRONG_NAME) but for the moment +# the wrapper library is loaded by the Ruby interpreter. +# Note: This only works for Ruby 2.4 and later +if Object.const_defined?(:Warning) && Warning.respond_to?(:warn) + module CustomWarningFilter + def warn(*args) + msg = args[0] + if msg =~ /[Aa]lready initialized constant Preproc::A[56]/ || + msg =~ /invalid name .?__GMP_HAVE_/ + # ignore + else + super + end + end + end + Warning.extend CustomWarningFilter +end + +require 'preproc' + +swig_assert_equal('Preproc::endif', '1', binding) +swig_assert_equal('Preproc::define', '1', binding) +swig_assert_equal('Preproc::ddefined', '1', binding) + +swig_assert_equal('2 * Preproc::One', 'Preproc::Two', binding) + +swig_assert_equal('Preproc::methodX(99)', '199', binding) + +t1 = Preproc::TcxMessageTest +t2 = Preproc::TcxMessageBug + diff --git a/Examples/test-suite/ruby/template_nested_flat_runme.rb b/Examples/test-suite/ruby/template_nested_flat_runme.rb new file mode 100644 index 000000000..5d0907f80 --- /dev/null +++ b/Examples/test-suite/ruby/template_nested_flat_runme.rb @@ -0,0 +1,23 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Java counterpart. +# + +require 'swig_assert' +require 'template_nested_flat' + +Template_nested_flat::T_NormalTemplateNormalClass.new.tmethod(Template_nested_flat::NormalClass.new) +Template_nested_flat::OuterClass.new.T_OuterTMethodNormalClass(Template_nested_flat::NormalClass.new) + +tf = Template_nested_flat::TemplateFuncs.new +swig_assert_equal("tf.T_TemplateFuncs1Int(-10)", "-10", binding) +swig_assert_equal("tf.T_TemplateFuncs2Double(-12.3)", "-12.3", binding) + +tn = Template_nested_flat::T_NestedOuterTemplateDouble.new +swig_assert_equal("tn.hohum(-12.3)", "-12.3", binding) + +inner1 = Template_nested_flat::OuterClass.new.useInner1(Template_nested_flat::T_OuterClassInner1Int.new) +inner2 = Template_nested_flat::T_OuterClassInner2NormalClass.new +inner2.embeddedVar = 2 +inner22 = Template_nested_flat::OuterClass.new.useInner2Again(inner2) +inner3 = Template_nested_flat::T_OuterClassInner1Double.new diff --git a/Examples/test-suite/ruby/template_static_runme.rb b/Examples/test-suite/ruby/template_static_runme.rb new file mode 100644 index 000000000..83c40e177 --- /dev/null +++ b/Examples/test-suite/ruby/template_static_runme.rb @@ -0,0 +1,12 @@ +#!/usr/bin/env ruby +# +# This test implementation is directly derived from its Python counterpart. +# + +require 'template_static' + +Template_static::Foo_i.test +Template_static::Foo_d.test +Template_static::Foo::test +Template_static::Foo::bar_double(1) + diff --git a/Examples/test-suite/schemerunme/li_typemaps.scm b/Examples/test-suite/schemerunme/li_typemaps.scm index 161e803bb..a24bbdaf0 100644 --- a/Examples/test-suite/schemerunme/li_typemaps.scm +++ b/Examples/test-suite/schemerunme/li_typemaps.scm @@ -24,8 +24,8 @@ ;(check "ulonglong" 6432 =) ;; The checking of inoutr-int2 and out-foo is done in the individual -;; language runme scripts, since chicken returns multiple values -;; and must be checked with call-with-values, while guile just returns a list +;; language runme scripts, since how multiple values are returned +;; differs between scheme variants. ;(call-with-values (lambda () (inoutr-int2 3 -2)) ; (lambda (a b) diff --git a/Examples/test-suite/schemerunme/li_typemaps_proxy.scm b/Examples/test-suite/schemerunme/li_typemaps_proxy.scm index f61d4fee5..07bb8556f 100644 --- a/Examples/test-suite/schemerunme/li_typemaps_proxy.scm +++ b/Examples/test-suite/schemerunme/li_typemaps_proxy.scm @@ -24,8 +24,8 @@ (check "ulonglong" 6432 =) ;; The checking of inoutr-int2 and out-foo is done in the individual -;; language runme scripts, since chicken returns multiple values -;; and must be checked with call-with-values, while guile just returns a list +;; language runme scripts, since how multiple values are returned +;; differs between scheme variants. ;(call-with-values (lambda () (inoutr-int2 3 -2)) ; (lambda (a b) diff --git a/Examples/test-suite/scilab/overload_null_runme.sci b/Examples/test-suite/scilab/overload_null_runme.sci index e3939ac5c..72a2b7ea6 100644 --- a/Examples/test-suite/scilab/overload_null_runme.sci +++ b/Examples/test-suite/scilab/overload_null_runme.sci @@ -30,16 +30,16 @@ checkequal(14, Overload_byval1cpr(o, NULL), "test 14"); checkequal(15, Overload_byval2cpr(o, NULL), "test 15"); checkequal(16, Overload_byval2cpr(o, x), "test 16"); -// forward class declaration -checkequal(17, Overload_byval1forwardptr(o, x), "test 17"); -checkequal(18, Overload_byval1forwardptr(o, NULL), "test 18"); +// fwd class declaration +checkequal(17, Overload_byval1fwdptr(o, x), "test 17"); +checkequal(18, Overload_byval1fwdptr(o, NULL), "test 18"); -checkequal(19, Overload_byval2forwardptr(o, NULL), "test 19"); -checkequal(20, Overload_byval2forwardptr(o, x), "test 20"); +checkequal(19, Overload_byval2fwdptr(o, NULL), "test 19"); +checkequal(20, Overload_byval2fwdptr(o, x), "test 20"); -checkequal(21, Overload_byval1forwardref(o, x), "test 21"); +checkequal(21, Overload_byval1fwdref(o, x), "test 21"); -checkequal(22, Overload_byval2forwardref(o, x), "test 22"); +checkequal(22, Overload_byval2fwdref(o, x), "test 22"); exec("swigtest.quit", -1); diff --git a/Examples/test-suite/scilab/preproc_constants_runme.sci b/Examples/test-suite/scilab/preproc_constants_runme.sci index d3d0a4b56..3dc1433af 100644 --- a/Examples/test-suite/scilab/preproc_constants_runme.sci +++ b/Examples/test-suite/scilab/preproc_constants_runme.sci @@ -24,7 +24,7 @@ endfunction test_global(); -// Test assignement in enums +// Test assignment in enums checkequal(kValue_get(), 4, "kValue"); exec("swigtest.quit", -1); diff --git a/Examples/test-suite/scilab_identifier_name.i b/Examples/test-suite/scilab_identifier_name.i index 94dde47e0..4e5a574e9 100644 --- a/Examples/test-suite/scilab_identifier_name.i +++ b/Examples/test-suite/scilab_identifier_name.i @@ -7,7 +7,7 @@ // Test truncating variables, constants, functions identifier names %inline %{ -// these identifier names wont be truncated +// these identifier names won't be truncated int gvar_identifier_name = -1; #define CONS_IDENTIFIER_NAME -11 int function_identifier_name() { return -21; }; diff --git a/Examples/test-suite/sizet.i b/Examples/test-suite/sizet.i index 537914155..6b70f680d 100644 --- a/Examples/test-suite/sizet.i +++ b/Examples/test-suite/sizet.i @@ -3,9 +3,7 @@ #include <vector> %} -#ifndef SWIGCHICKEN %include "std_common.i" -#endif %inline { diff --git a/Examples/test-suite/smart_pointer_inherit.i b/Examples/test-suite/smart_pointer_inherit.i index 52df5a92b..26987a5ac 100644 --- a/Examples/test-suite/smart_pointer_inherit.i +++ b/Examples/test-suite/smart_pointer_inherit.i @@ -70,7 +70,10 @@ class ItkVectorContainerUILSNUS2 : public std::vector< ItkLevelSetNodeUS2 > { class ItkVectorContainerUILSNUS2_Pointer { public: - ItkVectorContainerUILSNUS2 * operator->() const { return 0; } + ItkVectorContainerUILSNUS2 * operator->() const { + static ItkVectorContainerUILSNUS2 instance; + return &instance; + } }; %} diff --git a/Examples/test-suite/tcl/imports_runme.tcl b/Examples/test-suite/tcl/imports_runme.tcl index 6b2e77bde..bf2fc8cba 100644 --- a/Examples/test-suite/tcl/imports_runme.tcl +++ b/Examples/test-suite/tcl/imports_runme.tcl @@ -15,8 +15,8 @@ import set x [new_B] A_hello $x -if [ catch { $x nonexistant } ] { +if [ catch { $x nonexistent } ] { } else { - puts stderr "nonexistant method did not throw exception\n" + puts stderr "nonexistent method did not throw exception\n" exit 1 } diff --git a/Examples/test-suite/tcl/overload_null_runme.tcl b/Examples/test-suite/tcl/overload_null_runme.tcl index 3716612ab..075d6046c 100644 --- a/Examples/test-suite/tcl/overload_null_runme.tcl +++ b/Examples/test-suite/tcl/overload_null_runme.tcl @@ -40,13 +40,13 @@ check "testX" 14 [$o byval1cpr "NULL"] check "testX" 15 [$o byval2cpr "NULL"] check "testX" 16 [$o byval2cpr $x] -# forward class declaration -check "testX" 17 [$o byval1forwardptr $x] -check "testX" 18 [$o byval1forwardptr "NULL"] +# fwd class declaration +check "testX" 17 [$o byval1fwdptr $x] +check "testX" 18 [$o byval1fwdptr "NULL"] -check "testX" 19 [$o byval2forwardptr "NULL"] -check "testX" 20 [$o byval2forwardptr $x] +check "testX" 19 [$o byval2fwdptr "NULL"] +check "testX" 20 [$o byval2fwdptr $x] -check "testX" 21 [$o byval1forwardref $x] +check "testX" 21 [$o byval1fwdref $x] -check "testX" 22 [$o byval2forwardref $x] +check "testX" 22 [$o byval2fwdref $x] diff --git a/Examples/test-suite/template_default.i b/Examples/test-suite/template_default.i index d771ef09e..83ffd5427 100644 --- a/Examples/test-suite/template_default.i +++ b/Examples/test-suite/template_default.i @@ -196,7 +196,6 @@ namespace ns1 { %} -#ifndef SWIGCHICKEN %include std_vector.i %{ @@ -211,6 +210,3 @@ void q(double = 0) {} %constant void (*Bf)(std::vector<double> *p = 0) = g; %constant void (*Cf)(double = 0) = q; - - -#endif diff --git a/Examples/test-suite/template_nested.i b/Examples/test-suite/template_nested.i index 67668fb1a..941ec9e3a 100644 --- a/Examples/test-suite/template_nested.i +++ b/Examples/test-suite/template_nested.i @@ -1,11 +1,11 @@ %module template_nested +// Test nested templates - that is template classes and template methods within a class. + #if !defined(SWIGCSHARP) && !defined(SWIGJAVA) -%feature ("flatnested"); +#pragma SWIG nowarn=SWIGWARN_PARSE_NAMED_NESTED_CLASS #endif -// Test nested templates - that is template classes and template methods within a class. - namespace ns { template <class T> struct ForwardTemplate; } diff --git a/Examples/test-suite/template_nested_flat.i b/Examples/test-suite/template_nested_flat.i new file mode 100644 index 000000000..3c1d8bfef --- /dev/null +++ b/Examples/test-suite/template_nested_flat.i @@ -0,0 +1,7 @@ +%module template_nested_flat + +// Test nested templates ("flatnested" version of template_nested.i) + +%feature ("flatnested"); + +%include "template_nested.i" diff --git a/Examples/test-suite/template_static.i b/Examples/test-suite/template_static.i index bbca99490..dafb9ca5c 100644 --- a/Examples/test-suite/template_static.i +++ b/Examples/test-suite/template_static.i @@ -19,6 +19,7 @@ template<class T> int foo<T>::test = 0; namespace toto { class Foo { public: + static int test; template<class T> static double bar(int i) { return 1.0; @@ -28,6 +29,7 @@ namespace toto { int i; }; } +int toto::Foo::test = 5; %} %template(bar_double) toto::Foo::bar<double>; diff --git a/Examples/test-suite/template_template_parameters.i b/Examples/test-suite/template_template_parameters.i index 89197229e..53b18b0b0 100644 --- a/Examples/test-suite/template_template_parameters.i +++ b/Examples/test-suite/template_template_parameters.i @@ -2,6 +2,9 @@ %inline %{ + +/* part 1 */ + namespace pfc { template<typename t_item, template <typename> class t_alloc> class array_t {}; template<typename t_item> class alloc_fast { @@ -16,7 +19,7 @@ class list_tt : public list_impl_t<t_item,pfc::array_t<t_item,t_alloc> > { public: t_item item; -// typename t_alloc<t_item>::alloc_type allotype; // SWIG can't handle this yet + typename t_alloc<t_item>::alloc_type allotype; // SWIG can handle this now void xx() { typename t_alloc<t_item>::alloc_type atype; // this type is the same as t_item type atype = true; @@ -29,11 +32,42 @@ void TestInstantiations() { (void) myArrayInt; (void) myListImplInt; } + +/* part 2 */ + +template<class T> +struct Container1 { + T x; +}; +template<class U> +struct Container2 { + U x; +}; +template<class BaseT, template<class> class TemplateTemplateT> +struct TestStruct { + TemplateTemplateT<BaseT> x; +}; + +TestStruct<int, Container1> TestStructContainer1Method(TestStruct<int, Container1> ts1) { + ts1.x.x += 10; + return ts1; +} + %} +/* part 1 */ %template(ListImplFastBool) list_impl_t<bool, pfc::array_t<bool, pfc::alloc_fast> >; %template(ListFastBool) list_tt<bool, pfc::alloc_fast>; %template(ListImplFastDouble) list_impl_t<double, pfc::array_t<double, pfc::alloc_fast> >; %template(ListDefaultDouble) list_tt<double>; +%template(BoolAllocFast) pfc::alloc_fast<bool>; +%template(DoubleAllocFast) pfc::alloc_fast<double>; + +/* part 2 */ +%template(IntContainer1) Container1<int>; +%template(FloatContainer2) Container2<float>; +%template(IntTestStruct) TestStruct<int, Container1>; +%template(FloatTestStruct) TestStruct<float, Container2>; + diff --git a/Examples/test-suite/typemap_various.i b/Examples/test-suite/typemap_various.i index 3436bac1c..2caff97dc 100644 --- a/Examples/test-suite/typemap_various.i +++ b/Examples/test-suite/typemap_various.i @@ -61,7 +61,11 @@ void CheckRetTypemapUsed() { %inline { class FFoo { public: - char * Bar(bool b) const { return (char *)"x"; } + char * Bar(bool b) const { + char *ret = new char[2]; + strcpy(ret, b ? "1" : "0"); + return ret; + } }; } diff --git a/Examples/test-suite/types_directive.i b/Examples/test-suite/types_directive.i index 26cb6aeeb..530c338ae 100644 --- a/Examples/test-suite/types_directive.i +++ b/Examples/test-suite/types_directive.i @@ -19,10 +19,11 @@ struct Date { }; struct Time1 { - Time1(unsigned int year, unsigned int month, unsigned int day, unsigned int seconds) : date(year, month, day), seconds(seconds) {} + Time1(unsigned int year, unsigned int month, unsigned int day, unsigned int seconds) : padding(), date(year, month, day), seconds(seconds) {} Date &dateFromTime() { return date; } + unsigned int padding; // so that memory layout is not the same as Date Date date; unsigned int seconds; }; diff --git a/Examples/test-suite/uffi/Makefile.in b/Examples/test-suite/uffi/Makefile.in deleted file mode 100644 index 5d6dc110c..000000000 --- a/Examples/test-suite/uffi/Makefile.in +++ /dev/null @@ -1,51 +0,0 @@ -####################################################################### -# Makefile for uffi test-suite -####################################################################### - -LANGUAGE = uffi -UFFI = @UFFIBIN@ -SCRIPTSUFFIX = _runme.lisp - -srcdir = @srcdir@ -top_srcdir = @top_srcdir@ -top_builddir = @top_builddir@ - -include $(srcdir)/../common.mk - -# Overridden variables here -# no C++ tests for now -CPP_TEST_CASES = -#C_TEST_CASES += - -# Custom tests - tests with additional commandline options -# none! - -# Rules for the different types of tests -%.cpptest: - $(setup) - +$(swig_and_compile_cpp) - $(run_testcase) - -%.ctest: - $(setup) - +$(swig_and_compile_c) - $(run_testcase) - -%.multicpptest: - $(setup) - +$(swig_and_compile_multi_cpp) - $(run_testcase) - -# Runs the testcase. A testcase is only run if -# a file is found which has _runme.lisp appended after the testcase name. -run_testcase = \ - if [ -f $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX) ]; then \ - env LD_LIBRARY_PATH=.:$$LD_LIBRARY_PATH $(RUNTOOL) $(UFFI) -batch -s $(SCRIPTDIR)/$(SCRIPTPREFIX)$*$(SCRIPTSUFFIX); \ - fi - -# Clean: (does nothing, we dont generate extra uffi code) -%.clean: - @exit 0 - -clean: - $(MAKE) -f $(top_builddir)/$(EXAMPLES)/Makefile SRCDIR='$(SRCDIR)' uffi_clean diff --git a/Examples/test-suite/varargs.i b/Examples/test-suite/varargs.i index dd56cb073..68c7a1714 100644 --- a/Examples/test-suite/varargs.i +++ b/Examples/test-suite/varargs.i @@ -1,17 +1,31 @@ -// Tests SWIG's *default* handling of varargs (function varargs, not preprocessor varargs). +// Tests SWIG's handling of varargs (function varargs, not preprocessor varargs). // The default behavior is to simply ignore the varargs. %module varargs -%varargs(int mode = 0) test_def; -%varargs(int mode = 0) Foo::Foo; -%varargs(int mode = 0) Foo::statictest(const char*fmt, ...); -%varargs(2, int mode = 0) test_plenty(const char*fmt, ...); +// Default handling of varargs %inline %{ char *test(const char *fmt, ...) { return (char *) fmt; } +struct VarargConstructor { + char *str; + VarargConstructor(const char *fmt, ...) { + str = new char[strlen(fmt) + 1]; + strcpy(str, fmt); + } +}; +%} + +// %varargs support + +%varargs(int mode = 0) test_def; +%varargs(int mode = 0) Foo::Foo; +%varargs(int mode = 0) Foo::statictest(const char*fmt, ...); +%varargs(2, int mode = 0) test_plenty(const char*fmt, ...); + +%inline %{ const char *test_def(const char *fmt, ...) { return fmt; } @@ -40,5 +54,4 @@ public: const char *test_plenty(const char *fmt, ...) { return fmt; } - %} diff --git a/Lib/allegrocl/allegrocl.swg b/Lib/allegrocl/allegrocl.swg deleted file mode 100644 index 524aa7c11..000000000 --- a/Lib/allegrocl/allegrocl.swg +++ /dev/null @@ -1,615 +0,0 @@ -/* Define a C preprocessor symbol that can be used in interface files - to distinguish between the SWIG language modules. */ - -#define SWIG_ALLEGRO_CL - -#define %ffargs(...) %feature("ffargs", "1", ##__VA_ARGS__) -%ffargs(strings_convert="t"); - -/* typemaps for argument and result type conversions. */ -%typemap(lin,numinputs=1) SWIGTYPE "(cl::let (($out $in))\n $body)"; - -%typemap(lout) bool, char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, - enum SWIGTYPE "(cl::setq ACL_ffresult $body)"; -%typemap(lout) void "$body"; -#ifdef __cplusplus -%typemap(lout) SWIGTYPE[ANY], SWIGTYPE *, SWIGTYPE &, SWIGTYPE && -%{ (cl:let* ((address $body) - (new-inst (cl:make-instance '$lclass :foreign-address address))) - (cl:when (cl:and $owner (cl:not (cl:zerop address))) - (excl:schedule-finalization new-inst #'$ldestructor)) - (cl:setq ACL_ffresult new-inst)) %} - -%typemap(lout) SWIGTYPE "(cl::let* ((address $body)\n (new-inst (cl::make-instance '$lclass :foreign-address address)))\n (cl::unless (cl::zerop address)\n (excl:schedule-finalization new-inst #'$ldestructor))\n (cl::setq ACL_ffresult new-inst))"; -#else -%typemap(lout) SWIGTYPE[ANY], SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE -%{ (cl:let* ((address $body) - (new-inst (cl:make-instance '$lclass :foreign-address address))) - (cl:setq ACL_ffresult new-inst)) %} -#endif - -%typemap(lisptype) bool, const bool "cl:boolean"; -%typemap(lisptype) char, const char "cl:character"; -%typemap(lisptype) unsigned char, const unsigned char "cl:integer"; -%typemap(lisptype) signed char, const signed char "cl:integer"; - -%typemap(ffitype) bool, const bool ":int"; -%typemap(ffitype) char, const char, - signed char, const signed char ":char"; -%typemap(ffitype) unsigned char, const unsigned char ":unsigned-char"; -%typemap(ffitype) short, const short, - signed short, const signed short ":short"; -%typemap(ffitype) unsigned short, const unsigned short ":unsigned-short"; -%typemap(ffitype) int, const int, signed int, const signed int ":int"; -%typemap(ffitype) unsigned int, const unsigned int ":unsigned-int"; -%typemap(ffitype) long, const long, signed long, const signed long ":long"; -%typemap(ffitype) unsigned long, const unsigned long ":unsigned-long"; -%typemap(ffitype) float, const float ":float"; -%typemap(ffitype) double, const double ":double"; -%typemap(ffitype) char *, const char *, signed char *, - const signed char *, signed char &, - const signed char & "(* :char)"; -%typemap(ffitype) unsigned char *, const unsigned char *, - unsigned char &, const unsigned char & "(* :unsigned-char)"; -%typemap(ffitype) short *, const short *, short &, - const short & "(* :short)"; -%typemap(ffitype) unsigned short *, const unsigned short *, - unsigned short &, const unsigned short & "(* :unsigned-short)"; -%typemap(ffitype) int *, const int *, int &, const int & "(* :int)"; -%typemap(ffitype) unsigned int *, const unsigned int *, - unsigned int &, const unsigned int & "(* :unsigned-int)"; -%typemap(ffitype) void * "(* :void)"; -%typemap(ffitype) void ":void"; -%typemap(ffitype) enum SWIGTYPE ":int"; -%typemap(ffitype) SWIGTYPE & "(* :void)"; -%typemap(ffitype) SWIGTYPE && "(* :void)"; - -/* const typemaps -idea: marshall all primitive c types to their respective lisp types -to maintain const corretness. For pointers/references, all bets -are off if you try to modify them. - -idea: add a constant-p slot to the base foreign-pointer class. For -constant pointer/references check this value when setting (around method?) -and error if a setf operation is performed on the address of this object. - -*/ - -/* -%exception %{ - try { - $action - } catch (...) { - return $null; - } -%} - -*/ - -// %typemap(throws) SWIGTYPE { -// (void)$1; -// SWIG_fail; -// } - -%typemap(ctype) bool, const bool "int"; -%typemap(ctype) char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, void, - enum SWIGTYPE, SWIGTYPE *, SWIGTYPE[], - SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE &&, const SWIGTYPE "$1_ltype"; -%typemap(ctype) SWIGTYPE "$&1_type"; - -%typemap(in) bool "$1 = (bool)$input;"; -%typemap(in) char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, void, - enum SWIGTYPE, SWIGTYPE *, SWIGTYPE[], - SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$1 = $input;"; -%typemap(in) SWIGTYPE "$1 = *$input;"; - -/* We don't need to do any actual C-side typechecking, but need to - use the precedence values to choose which overloaded function - interfaces to generate when conflicts arise. */ - -/* predefined precedence values - -Symbolic Name Precedence Value ------------------------------- ------------------ -SWIG_TYPECHECK_POINTER 0 -SWIG_TYPECHECK_VOIDPTR 10 -SWIG_TYPECHECK_BOOL 15 -SWIG_TYPECHECK_UINT8 20 -SWIG_TYPECHECK_INT8 25 -SWIG_TYPECHECK_UINT16 30 -SWIG_TYPECHECK_INT16 35 -SWIG_TYPECHECK_UINT32 40 -SWIG_TYPECHECK_INT32 45 -SWIG_TYPECHECK_UINT64 50 -SWIG_TYPECHECK_INT64 55 -SWIG_TYPECHECK_UINT128 60 -SWIG_TYPECHECK_INT128 65 -SWIG_TYPECHECK_INTEGER 70 -SWIG_TYPECHECK_FLOAT 80 -SWIG_TYPECHECK_DOUBLE 90 -SWIG_TYPECHECK_COMPLEX 100 -SWIG_TYPECHECK_UNICHAR 110 -SWIG_TYPECHECK_UNISTRING 120 -SWIG_TYPECHECK_CHAR 130 -SWIG_TYPECHECK_STRING 140 -SWIG_TYPECHECK_BOOL_ARRAY 1015 -SWIG_TYPECHECK_INT8_ARRAY 1025 -SWIG_TYPECHECK_INT16_ARRAY 1035 -SWIG_TYPECHECK_INT32_ARRAY 1045 -SWIG_TYPECHECK_INT64_ARRAY 1055 -SWIG_TYPECHECK_INT128_ARRAY 1065 -SWIG_TYPECHECK_FLOAT_ARRAY 1080 -SWIG_TYPECHECK_DOUBLE_ARRAY 1090 -SWIG_TYPECHECK_CHAR_ARRAY 1130 -SWIG_TYPECHECK_STRING_ARRAY 1140 -*/ - -%typecheck(SWIG_TYPECHECK_BOOL) bool { $1 = 1; }; -%typecheck(SWIG_TYPECHECK_CHAR) char { $1 = 1; }; -%typecheck(SWIG_TYPECHECK_FLOAT) float { $1 = 1; }; -%typecheck(SWIG_TYPECHECK_DOUBLE) double { $1 = 1; }; -%typecheck(SWIG_TYPECHECK_STRING) char * { $1 = 1; }; -%typecheck(SWIG_TYPECHECK_INTEGER) - unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - enum SWIGTYPE { $1 = 1; }; -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, - SWIGTYPE[], SWIGTYPE[ANY], - SWIGTYPE { $1 = 1; }; - -/* This maps C/C++ types to Lisp classes for overload dispatch */ - -%typemap(lispclass) bool "t"; -%typemap(lispclass) char "cl:character"; -%typemap(lispclass) unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - enum SWIGTYPE "cl:integer"; -%typemap(lispclass) float "cl:single-float"; -%typemap(lispclass) double "cl:double-float"; -%typemap(lispclass) char * "cl:string"; - -%typemap(out) void ""; -%typemap(out) bool "$result = (int)$1;"; -%typemap(out) char, unsigned char, signed char, - short, signed short, unsigned short, - int, signed int, unsigned int, - long, signed long, unsigned long, - float, double, long double, char *, void *, - enum SWIGTYPE, SWIGTYPE *, - SWIGTYPE[ANY], SWIGTYPE &, SWIGTYPE && "$result = $1;"; -#ifdef __cplusplus -%typemap(out) SWIGTYPE "$result = new $1_ltype($1);"; -#else -%typemap(out) SWIGTYPE { - $result = ($&1_ltype) malloc(sizeof($1_type)); - memmove($result, &$1, sizeof($1_type)); -} -#endif - -////////////////////////////////////////////////////////////// -// UCS-2 string conversion - -// should this be SWIG_TYPECHECK_CHAR? -%typecheck(SWIG_TYPECHECK_UNICHAR) wchar_t { $1 = 1; }; - -%typemap(in) wchar_t "$1 = $input;"; -%typemap(lin,numinputs=1) wchar_t "(cl::let (($out (cl:char-code $in)))\n $body)"; -%typemap(lin,numinputs=1) wchar_t * "(excl:with-native-string ($out $in -:external-format #+little-endian :fat-le #-little-endian :fat)\n -$body)" - -%typemap(out) wchar_t "$result = $1;"; -%typemap(lout) wchar_t "(cl::setq ACL_ffresult (cl::code-char $body))"; -%typemap(lout) wchar_t * "(cl::setq ACL_ffresult (excl:native-to-string $body -:external-format #+little-endian :fat-le #-little-endian :fat))"; - -%typemap(ffitype) wchar_t ":unsigned-short"; -%typemap(lisptype) wchar_t ""; -%typemap(ctype) wchar_t "wchar_t"; -%typemap(lispclass) wchar_t "cl:character"; -%typemap(lispclass) wchar_t * "cl:string"; -////////////////////////////////////////////////////////////// - -/* Array reference typemaps */ -%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) } -%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) } - -/* const pointers */ -%apply SWIGTYPE * { SWIGTYPE *const } -%apply SWIGTYPE (CLASS::*) { SWIGTYPE (CLASS::*const) } -%apply SWIGTYPE & { SWIGTYPE (CLASS::*const&) } - -/* name conversion for overloaded operators. */ -#ifdef __cplusplus -%rename(__add__) *::operator+; -%rename(__pos__) *::operator+(); -%rename(__pos__) *::operator+() const; - -%rename(__sub__) *::operator-; -%rename(__neg__) *::operator-() const; -%rename(__neg__) *::operator-(); - -%rename(__mul__) *::operator*; -%rename(__deref__) *::operator*(); -%rename(__deref__) *::operator*() const; - -%rename(__div__) *::operator/; -%rename(__mod__) *::operator%; -%rename(__logxor__) *::operator^; -%rename(__logand__) *::operator&; -%rename(__logior__) *::operator|; -%rename(__lognot__) *::operator~(); -%rename(__lognot__) *::operator~() const; - -%rename(__not__) *::operator!(); -%rename(__not__) *::operator!() const; - -%rename(__assign__) *::operator=; - -%rename(__add_assign__) *::operator+=; -%rename(__sub_assign__) *::operator-=; -%rename(__mul_assign__) *::operator*=; -%rename(__div_assign__) *::operator/=; -%rename(__mod_assign__) *::operator%=; -%rename(__logxor_assign__) *::operator^=; -%rename(__logand_assign__) *::operator&=; -%rename(__logior_assign__) *::operator|=; - -%rename(__lshift__) *::operator<<; -%rename(__lshift_assign__) *::operator<<=; -%rename(__rshift__) *::operator>>; -%rename(__rshift_assign__) *::operator>>=; - -%rename(__eq__) *::operator==; -%rename(__ne__) *::operator!=; -%rename(__lt__) *::operator<; -%rename(__gt__) *::operator>; -%rename(__lte__) *::operator<=; -%rename(__gte__) *::operator>=; - -%rename(__and__) *::operator&&; -%rename(__or__) *::operator||; - -%rename(__preincr__) *::operator++(); -%rename(__postincr__) *::operator++(int); -%rename(__predecr__) *::operator--(); -%rename(__postdecr__) *::operator--(int); - -%rename(__comma__) *::operator,(); -%rename(__comma__) *::operator,() const; - -%rename(__member_ref__) *::operator->; -%rename(__member_func_ref__) *::operator->*; - -%rename(__funcall__) *::operator(); -%rename(__aref__) *::operator[]; - -%rename(__bool__) *::operator bool(); -%rename(__bool__) *::operator bool() const; -#endif - -%insert("lisphead") %{ -(eval-when (:compile-toplevel :load-toplevel :execute) - - ;; avoid compiling ef-templates at runtime - (excl:find-external-format :fat) - (excl:find-external-format :fat-le) - -;;; You can define your own identifier converter if you want. -;;; Use the -identifier-converter command line argument to -;;; specify its name. - -(eval-when (:compile-toplevel :load-toplevel :execute) - (cl::defparameter *swig-export-list* nil)) - -(cl::defconstant *void* :..void..) - -;; parsers to aid in finding SWIG definitions in files. -(cl::defun scm-p1 (form) - (let* ((info (cl::second form)) - (id (car info)) - (id-args (if (eq (cl::car form) 'swig-dispatcher) - (cl::cdr info) - (cl::cddr info)))) - (cl::apply *swig-identifier-converter* id - (cl::progn (cl::when (cl::eq (cl::car form) 'swig-dispatcher) - (cl::remf id-args :arities)) - id-args)))) - -(cl::defmacro defswig1 (name (&rest args) &body body) - `(cl::progn (cl::defmacro ,name ,args - ,@body) - (excl::define-simple-parser ,name scm-p1)) ) - -(cl::defmacro defswig2 (name (&rest args) &body body) - `(cl::progn (cl::defmacro ,name ,args - ,@body) - (excl::define-simple-parser ,name second))) - -(defun read-symbol-from-string (string) - (cl::multiple-value-bind (result position) - (cl::read-from-string string nil "eof" :preserve-whitespace t) - (cl::if (cl::and (cl::symbolp result) - (cl::eql position (cl::length string))) - result - (cl::multiple-value-bind (sym) - (cl::intern string) - sym)))) - -(cl::defun full-name (id type arity class) - ; We need some kind of a hack here to handle template classes - ; and other synonym types right. We need the original name. - (let*( (sym (read-symbol-from-string - (if (eq *swig-identifier-converter* 'identifier-convert-lispify) - (string-lispify id) - id))) - (sym-class (find-class sym nil)) - (id (cond ( (not sym-class) - id ) - ( (and sym-class - (not (eq (class-name sym-class) - sym))) - (class-name sym-class) ) - ( t - id ))) ) - (cl::case type - (:getter (cl::format nil "~@[~A_~]~A" class id)) - (:constructor (cl::format nil "new_~A~@[~A~]" id arity)) - (:destructor (cl::format nil "delete_~A" id)) - (:type (cl::format nil "ff_~A" id)) - (:slot id) - (:ff-operator (cl::format nil "ffi_~A" id)) - (otherwise (cl::format nil "~@[~A_~]~A~@[~A~]" - class id arity))))) - -(cl::defun identifier-convert-null (id &key type class arity) - (cl::if (cl::eq type :setter) - `(cl::setf ,(identifier-convert-null - id :type :getter :class class :arity arity)) - (read-symbol-from-string (full-name id type arity class)))) - -(cl::defun string-lispify (str) - (cl::let ( (cname (excl::replace-regexp str "_" "-")) - (lastcase :other) - newcase char res ) - (cl::dotimes (n (cl::length cname)) - (cl::setf char (cl::schar cname n)) - (excl::if* (cl::alpha-char-p char) - then - (cl::setf newcase (cl::if (cl::upper-case-p char) :upper :lower)) - (cl::when (cl::and (cl::eq lastcase :lower) - (cl::eq newcase :upper)) - ;; case change... add a dash - (cl::push #\- res) - (cl::setf newcase :other)) - (cl::push (cl::char-downcase char) res) - (cl::setf lastcase newcase) - else - (cl::push char res) - (cl::setf lastcase :other))) - (cl::coerce (cl::nreverse res) 'string))) - -(cl::defun identifier-convert-lispify (cname &key type class arity) - (cl::assert (cl::stringp cname)) - (cl::when (cl::eq type :setter) - (cl::return-from identifier-convert-lispify - `(cl::setf ,(identifier-convert-lispify - cname :type :getter :class class :arity arity)))) - (cl::setq cname (full-name cname type arity class)) - (cl::if (cl::eq type :constant) - (cl::setf cname (cl::format nil "*~A*" cname))) - (read-symbol-from-string (string-lispify cname))) - -(cl::defun id-convert-and-export (name &rest kwargs) - (cl::multiple-value-bind (symbol package) - (cl::apply *swig-identifier-converter* name kwargs) - (cl::let ((args (cl::list (cl::if (cl::consp symbol) - (cl::cadr symbol) symbol) - (cl::or package cl::*package*)))) - (cl::apply #'cl::export args) - (cl::pushnew args *swig-export-list*)) - symbol)) - -(cl::defmacro swig-insert-id (name namespace &key (type :type) class) - `(cl::let ((cl::*package* (cl::find-package ,(package-name-for-namespace namespace)))) - (id-convert-and-export ,name :type ,type :class ,class))) - -(defswig2 swig-defconstant (string value) - (cl::let ((symbol (id-convert-and-export string :type :constant))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (cl::defconstant ,symbol ,value)))) - -(cl::defun maybe-reorder-args (funcname arglist) - ;; in the foreign setter function the new value will be the last argument - ;; in Lisp it needs to be the first - (cl::if (cl::consp funcname) - (cl::append (cl::last arglist) (cl::butlast arglist)) - arglist)) - -(cl::defun maybe-return-value (funcname arglist) - ;; setf functions should return the new value - (cl::when (cl::consp funcname) - `(,(cl::if (cl::consp (cl::car arglist)) - (cl::caar arglist) - (cl::car arglist))))) - -(cl::defun swig-anyvarargs-p (arglist) - (cl::member :SWIG__varargs_ arglist)) - -(defswig1 swig-defun ((name &optional (mangled-name name) - &key (type :operator) class arity) - arglist kwargs - &body body) - (cl::let* ((symbol (id-convert-and-export name :type type - :arity arity :class class)) - (mangle (excl::if* (cl::string-equal name mangled-name) - then (id-convert-and-export - (cl::cond - ((cl::eq type :setter) (cl::format nil "~A-set" name)) - ((cl::eq type :getter) (cl::format nil "~A-get" name)) - (t name)) - :type :ff-operator :arity arity :class class) - else (cl::intern mangled-name))) - (defun-args (maybe-reorder-args - symbol - (cl::mapcar #'cl::car (cl::and (cl::not (cl::equal arglist '(:void))) - (cl::loop as i in arglist - when (cl::eq (cl::car i) :p+) - collect (cl::cdr i)))))) - (ffargs (cl::if (cl::equal arglist '(:void)) - arglist - (cl::mapcar #'cl::cdr arglist))) - ) - (cl::when (swig-anyvarargs-p ffargs) - (cl::setq ffargs '())) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (excl::compiler-let ((*record-xref-info* nil)) - (ff:def-foreign-call (,mangle ,mangled-name) ,ffargs ,@kwargs)) - (cl::macrolet ((swig-ff-call (&rest args) - (cl::cons ',mangle args))) - (cl::defun ,symbol ,defun-args - ,@body - ,@(maybe-return-value symbol defun-args)))))) - -(defswig1 swig-defmethod ((name &optional (mangled-name name) - &key (type :operator) class arity) - ffargs kwargs - &body body) - (cl::let* ((symbol (id-convert-and-export name :type type - :arity arity :class class)) - (mangle (cl::intern mangled-name)) - (defmethod-args (maybe-reorder-args - symbol - (cl::unless (cl::equal ffargs '(:void)) - (cl::loop for (lisparg name dispatch) in ffargs - when (eq lisparg :p+) - collect `(,name ,dispatch))))) - (ffargs (cl::if (cl::equal ffargs '(:void)) - ffargs - (cl::loop for (nil name nil . ffi) in ffargs - collect `(,name ,@ffi))))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (excl::compiler-let ((*record-xref-info* nil)) - (ff:def-foreign-call (,mangle ,mangled-name) ,ffargs ,@kwargs)) - (cl::macrolet ((swig-ff-call (&rest args) - (cl::cons ',mangle args))) - (cl::defmethod ,symbol ,defmethod-args - ,@body - ,@(maybe-return-value symbol defmethod-args)))))) - -(defswig1 swig-dispatcher ((name &key (type :operator) class arities)) - (cl::let ((symbol (id-convert-and-export name - :type type :class class))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (cl::defun ,symbol (&rest args) - (cl::case (cl::length args) - ,@(cl::loop for arity in arities - for symbol-n = (id-convert-and-export name - :type type :class class :arity arity) - collect `(,arity (cl::apply #',symbol-n args))) - (t (cl::error "No applicable wrapper-methods for foreign call ~a with args ~a of classes ~a" ',symbol args (cl::mapcar #'(cl::lambda (x) (cl::class-name (cl::class-of x))) args))) - ))))) - -(defswig2 swig-def-foreign-stub (name) - (cl::let ((lsymbol (id-convert-and-export name :type :class)) - (symbol (id-convert-and-export name :type :type))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (ff:def-foreign-type ,symbol (:class )) - (cl::defclass ,lsymbol (ff:foreign-pointer) ())))) - -(defswig2 swig-def-foreign-class (name supers &rest rest) - (cl::let ((lsymbol (id-convert-and-export name :type :class)) - (symbol (id-convert-and-export name :type :type))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (ff:def-foreign-type ,symbol ,@rest) - (cl::defclass ,lsymbol ,supers - ((foreign-type :initform ',symbol :initarg :foreign-type - :accessor foreign-pointer-type)))))) - -(defswig2 swig-def-foreign-type (name &rest rest) - (cl::let ((symbol (id-convert-and-export name :type :type))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (ff:def-foreign-type ,symbol ,@rest)))) - -(defswig2 swig-def-synonym-type (synonym of ff-synonym) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (cl::setf (cl::find-class ',synonym) (cl::find-class ',of)) - (ff:def-foreign-type ,ff-synonym (:struct )))) - -(cl::defun package-name-for-namespace (namespace) - (excl::list-to-delimited-string - (cl::cons *swig-module-name* - (cl::mapcar #'(cl::lambda (name) - (cl::string - (cl::funcall *swig-identifier-converter* - name - :type :namespace))) - namespace)) - ".")) - -(cl::defmacro swig-defpackage (namespace) - (cl::let* ((parent-namespaces (cl::maplist #'cl::reverse (cl::cdr (cl::reverse namespace)))) - (parent-strings (cl::mapcar #'package-name-for-namespace - parent-namespaces)) - (string (package-name-for-namespace namespace))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (cl::defpackage ,string - (:use :swig :ff #+ignore '(:common-lisp :ff :excl) - ,@parent-strings ,*swig-module-name*) - (:import-from :cl :* :nil :t))))) - -(cl::defmacro swig-in-package (namespace) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (cl::in-package ,(package-name-for-namespace namespace)))) - -(defswig2 swig-defvar (name mangled-name &key type (ftype :unsigned-natural)) - (cl::let ((symbol (id-convert-and-export name :type type))) - `(cl::eval-when (:compile-toplevel :load-toplevel :execute) - (ff:def-foreign-variable (,symbol ,mangled-name) :type ,ftype)))) - -) ;; eval-when - -(cl::eval-when (:compile-toplevel :execute) - (cl::flet ((starts-with-p (str prefix) - (cl::and (cl::>= (cl::length str) (cl::length prefix)) - (cl::string= str prefix :end1 (cl::length prefix))))) - (cl::export (cl::loop for sym being each present-symbol of cl::*package* - when (cl::or (starts-with-p (cl::symbol-name sym) (cl::symbol-name :swig-)) - (starts-with-p (cl::symbol-name sym) (cl::symbol-name :identifier-convert-))) - collect sym)))) - -%} - -typedef void *__SWIGACL_FwdReference; - -%{ - -#ifdef __cplusplus -# define EXTERN extern "C" -#else -# define EXTERN extern -#endif - -#define EXPORT EXTERN SWIGEXPORT - -typedef void *__SWIGACL_FwdReference; - -#include <string.h> -#include <stdlib.h> -%} diff --git a/Lib/allegrocl/inout_typemaps.i b/Lib/allegrocl/inout_typemaps.i deleted file mode 100644 index d8d61feed..000000000 --- a/Lib/allegrocl/inout_typemaps.i +++ /dev/null @@ -1,111 +0,0 @@ -/* inout_typemaps.i - - Support for INPUT, OUTPUT, and INOUT typemaps. OUTPUT variables are returned - as multiple values. - -*/ - - -/* Note that this macro automatically adds a pointer to the type passed in. - As a result, INOUT typemaps for char are for 'char *'. The definition - of typemaps for 'char' takes advantage of this, believing that it's more - likely to see an INOUT argument for strings, than a single char. */ -%define INOUT_TYPEMAP(type_, OUTresult_, INbind_) -// OUTPUT map. -%typemap(lin,numinputs=0) type_ *OUTPUT, type_ &OUTPUT -%{(cl::let (($out (ff:allocate-fobject '$*in_fftype :c))) - $body - OUTresult_ - (ff:free-fobject $out)) %} - -// INPUT map. -%typemap(in) type_ *INPUT, type_ &INPUT -%{ $1 = &$input; %} - -%typemap(ctype) type_ *INPUT, type_ &INPUT "$*1_ltype"; - - -// INOUT map. -// careful here. the input string is converted to a C string -// with length equal to the input string. This should be large -// enough to contain whatever OUTPUT value will be stored in it. -%typemap(lin,numinputs=1) type_ *INOUT, type_ &INOUT -%{(cl::let (($out (ff:allocate-fobject '$*in_fftype :c))) - INbind_ - $body - OUTresult_ - (ff:free-fobject $out)) %} - -%enddef - -// $in, $out, $lclass, -// $in_fftype, $*in_fftype - -INOUT_TYPEMAP(int, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(short, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(long, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(unsigned int, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(unsigned short, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(unsigned long, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -// char * mapping for passing strings. didn't quite work -// INOUT_TYPEMAP(char, -// (cl::push (excl:native-to-string $out) ACL_result), -// (cl::setf (ff:fslot-value-typed (cl::quote $in_fftype) :c $out) -// (excl:string-to-native $in))) -INOUT_TYPEMAP(float, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(double, - (cl::push (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); -INOUT_TYPEMAP(bool, - (cl::push (not (zerop (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out))) - ACL_result), - (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) (if $in 1 0))); - -%typemap(lisptype) bool *INPUT, bool &INPUT "boolean"; - -// long long support not yet complete -// INOUT_TYPEMAP(long long); -// INOUT_TYPEMAP(unsigned long long); - -// char *OUTPUT map. -// for this to work, swig needs to know how large an array to allocate. -// you can fake this by -// %typemap(ffitype) char *myarg "(:array :char 30)"; -// %apply char *OUTPUT { char *myarg }; -%typemap(lin,numinputs=0) char *OUTPUT, char &OUTPUT -%{(cl::let (($out (ff:allocate-fobject '$*in_fftype :c))) - $body - (cl::push (excl:native-to-string $out) ACL_result) - (ff:free-fobject $out)) %} - -// char *INPUT map. -%typemap(in) char *INPUT, char &INPUT -%{ $1 = &$input; %} -%typemap(ctype) char *INPUT, char &INPUT "$*1_ltype"; - -// char *INOUT map. -%typemap(lin,numinputs=1) char *INOUT, char &INOUT -%{(cl::let (($out (excl:string-to-native $in))) - $body - (cl::push (excl:native-to-string $out) ACL_result) - (ff:free-fobject $out)) %} - -// uncomment this if you want INOUT mappings for chars instead of strings. -// INOUT_TYPEMAP(char, -// (cl::push (code-char (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out)) -// ACL_result), -// (cl::setf (ff:fslot-value-typed (cl::quote $*in_fftype) :c $out) $in)); diff --git a/Lib/allegrocl/longlongs.i b/Lib/allegrocl/longlongs.i deleted file mode 100644 index a15adcdda..000000000 --- a/Lib/allegrocl/longlongs.i +++ /dev/null @@ -1,49 +0,0 @@ -/* ----------------------------------------------------------------------------- - * longlongs.i - * - * Typemap addition for support of 'long long' type and 'unsigned long long - * Makes use of swig-def-foreign-class, so this header should be loaded - * after allegrocl.swg and after any custom user identifier-conversion - * functions have been defined. - * ----------------------------------------------------------------------------- */ - -#ifdef Acl64Bit -%typemap(ctype) long long, unsigned long long "$1_ltype"; -%typemap(out) long long, unsigned long long "$result = $1;"; - -%typemap(ffitype) long long ":nat"; -%typemap(ffitype) unsigned long long ":unsigned-nat"; - -%typemap(lout) long long, unsigned long long " #+64bit (cl::setq ACL_ffresult $body)"; - -#else -%typemap(out) long long, unsigned long long "$result = &$1;"; -%typemap(ffitype) long long "(:struct (l1 :long) (l2 :long))"; - -%typemap(ffitype) unsigned long long "(:struct (l1 :unsigned-long) (l2 :unsigned-long))"; - -%typemap(lout) long long -" (cl::setq ACL_ffresult (make-instance '#.(swig-insert-id \"longlong\" () :type :class) - :foreign-address $body))"; - -%typemap(lout) unsigned long long -" (cl:setq ACL_ffresult (make-instance '#.(swig-insert-id \"ulonglong\" () :type :class) - :foreign-address $body))"; - -#endif - -%typemap(in) long long, unsigned long long "$1 = $input;"; - - -%insert("lisphead") %{ - -#-64bit -(swig-def-foreign-class "longlong" - (ff:foreign-pointer) - (:struct (l1 :long) (l2 :long))) - -#-64bit -(swig-def-foreign-class "ulonglong" - (ff:foreign-pointer) - (:struct (l1 :unsigned-long) (l2 :unsigned-long))) -%} diff --git a/Lib/allegrocl/std_list.i b/Lib/allegrocl/std_list.i deleted file mode 100644 index a3660c9f7..000000000 --- a/Lib/allegrocl/std_list.i +++ /dev/null @@ -1,230 +0,0 @@ -/* ----------------------------------------------------------------------------- - * std_list.i - * - * SWIG typemaps for std::list types - * - * To use, add: - * - * %include "std_list.i" - * - * to your interface file. You will also need to include a template directive - * for each instance of the list container you want to use in your application. - * e.g. - * - * %template (intlist) std::list<int>; - * %template (floatlist) std::list<float>; - * ----------------------------------------------------------------------------- */ - -%module std_list -%warnfilter(468) std::list; - -%{ -#include <list> -#include <stdexcept> -%} - - -namespace std{ - template<class T> class list - { - public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef T value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef T &iterator; - typedef const T& const_iterator; - - list(); - list(unsigned int size, const T& value = T()); - list(const list& other); - - void assign(unsigned int n, const T& value); - void swap(list<T> &x); - - const_reference front(); - const_reference back(); - const_iterator begin(); - const_iterator end(); - - void resize(unsigned int n, T c = T()); - bool empty() const; - - void push_front(const T& INPUT); - void push_back(const T& INPUT); - - void pop_front(); - void pop_back(); - void clear(); - unsigned int size() const; - unsigned int max_size() const; - void resize(unsigned int n, const T& INPUT); - - void remove(const T& INPUT); - void unique(); - void reverse(); - void sort(); - - %extend - { - %typemap(lout) T &__getitem__ "(cl::setq ACL_ffresult (ff:fslot-value-typed '$*out_fftype :c $body))"; - %typemap(lout) T *__getitem__ "(cl::setq ACL_ffresult (make-instance '$lclass :foreign-address $body))"; - - const_reference __getitem__(int i) throw (std::out_of_range) - { - std::list<T>::iterator first = self->begin(); - int size = int(self->size()); - if (i<0) i += size; - if (i>=0 && i<size) - { - for (int k=0;k<i;k++) - { - first++; - } - return *first; - } - else throw std::out_of_range("list index out of range"); - } - void __setitem__(int i, const T& INPUT) throw (std::out_of_range) - { - std::list<T>::iterator first = self->begin(); - int size = int(self->size()); - if (i<0) i += size; - if (i>=0 && i<size) - { - for (int k=0;k<i;k++) - { - first++; - } - *first = INPUT; - } - else throw std::out_of_range("list index out of range"); - } - void __delitem__(int i) throw (std::out_of_range) - { - std::list<T>::iterator first = self->begin(); - int size = int(self->size()); - if (i<0) i += size; - if (i>=0 && i<size) - { - for (int k=0;k<i;k++) - { - first++; - } - self->erase(first); - } - else throw std::out_of_range("list index out of range"); - } - std::list<T> __getslice__(int i,int j) - { - std::list<T>::iterator first = self->begin(); - std::list<T>::iterator end = self->end(); - - int size = int(self->size()); - if (i<0) i += size; - if (j<0) j += size; - if (i<0) i = 0; - if (j>size) j = size; - if (i>=j) i=j; - if (i>=0 && i<size && j>=0) - { - for (int k=0;k<i;k++) - { - first++; - } - for (int m=0;m<j;m++) - { - end++; - } - std::list<T> tmp(j-i); - if (j>i) std::copy(first,end,tmp.begin()); - return tmp; - } - else throw std::out_of_range("list index out of range"); - } - void __delslice__(int i,int j) - { - std::list<T>::iterator first = self->begin(); - std::list<T>::iterator end = self->end(); - - int size = int(self->size()); - if (i<0) i += size; - if (j<0) j += size; - if (i<0) i = 0; - if (j>size) j = size; - - for (int k=0;k<i;k++) - { - first++; - } - for (int m=0;m<=j;m++) - { - end++; - } - self->erase(first,end); - } - void __setslice__(int i,int j, const std::list<T>& v) - { - std::list<T>::iterator first = self->begin(); - std::list<T>::iterator end = self->end(); - - int size = int(self->size()); - if (i<0) i += size; - if (j<0) j += size; - if (i<0) i = 0; - if (j>size) j = size; - - for (int k=0;k<i;k++) - { - first++; - } - for (int m=0;m<=j;m++) - { - end++; - } - if (int(v.size()) == j-i) - { - std::copy(v.begin(),v.end(),first); - } - else { - self->erase(first,end); - if (i+1 <= int(self->size())) - { - first = self->begin(); - for (int k=0;k<i;k++) - { - first++; - } - self->insert(first,v.begin(),v.end()); - } - else self->insert(self->end(),v.begin(),v.end()); - } - } - unsigned int __len__() - { - return self->size(); - } - bool __nonzero__() - { - return !(self->empty()); - } - void append(const T& INPUT) - { - self->push_back(INPUT); - } - void pop() - { - self->pop_back(); - } - } - }; -} - - - - - - diff --git a/Lib/allegrocl/std_string.i b/Lib/allegrocl/std_string.i deleted file mode 100644 index cbcd250a9..000000000 --- a/Lib/allegrocl/std_string.i +++ /dev/null @@ -1,209 +0,0 @@ -/* ----------------------------------------------------------------------------- - * std_string.i - * - * SWIG typemaps for std::string - * ----------------------------------------------------------------------------- */ - -// ------------------------------------------------------------------------ -// std::string is typemapped by value -// This can prevent exporting methods which return a string -// in order for the user to modify it. -// However, I think I'll wait until someone asks for it... -// ------------------------------------------------------------------------ - -// %include <exception.i> -%warnfilter(404) std::string; -%warnfilter(404) std::wstring; - -%{ -#include <string> -%} - -// %include <std_vector.i> - -// %naturalvar std::string; -// %naturalvar std::wstring; - -namespace std { - typedef unsigned long size_t; - typedef signed long ptrdiff_t; - - template <class charT> class basic_string { - public: - typedef charT *pointer; - typedef charT &reference; - typedef const charT &const_reference; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - basic_string(); - basic_string( charT *str ); - size_type size(); - charT operator []( int pos ) const; - charT *c_str() const; - basic_string<charT> &operator = ( const basic_string &ws ); - basic_string<charT> &operator = ( const charT *str ); - basic_string<charT> &append( const basic_string<charT> &other ); - basic_string<charT> &append( const charT *str ); - void push_back( charT c ); - void clear(); - void reserve( size_type t ); - void resize( size_type n, charT c = charT() ); - int compare( const basic_string<charT> &other ) const; - int compare( const charT *str ) const; - basic_string<charT> &insert( size_type pos, - const basic_string<charT> &str ); - size_type find( const basic_string<charT> &other, int pos = 0 ) const; - size_type find( charT c, int pos = 0 ) const; - %extend { - bool operator == ( const basic_string<charT> &other ) const { - return self->compare( other ) == 0; - } - bool operator != ( const basic_string<charT> &other ) const { - return self->compare( other ) != 0; - } - bool operator < ( const basic_string<charT> &other ) const { - return self->compare( other ) == -1; - } - bool operator > ( const basic_string<charT> &other ) const { - return self->compare( other ) == 1; - } - bool operator <= ( const basic_string<charT> &other ) const { - return self->compare( other ) != 1; - } - bool operator >= ( const basic_string<charT> &other ) const { - return self->compare( other ) != -1; - } - - } - }; - - %template(string) basic_string<char>; - %template(wstring) basic_string<wchar_t>; - - %apply char * { string }; - %apply wchar_t * { wstring }; - - typedef basic_string<char> string; - typedef basic_string<wchar_t> wstring; - - // automatically convert constant std::strings to cl:strings - %typemap(ctype) string "char *"; - %typemap(in) string "$1.assign($input);"; - %typemap(out) string "$result = (char *)(&$1)->c_str();"; - %typemap(lisptype) string "cl:string"; - %typemap(lout) string "(cl::setq ACL_ffresult $body)"; - - %typemap(ctype) const string *"char *"; - %typemap(in) const string * "$1.assign($input);"; - %typemap(out) const string * "$result = (char *)($1)->c_str();"; - %typemap(lisptype) const string * "cl:string"; - %typemap(lout) const string * "(cl::setq ACL_ffresult $body)"; - - %typemap(ctype) wstring "wchar_t *"; - %typemap(in) wstring "$1.assign($input);"; - %typemap(out) wstring "$result = (wchar_t *)(&$1)->c_str();"; - %typemap(lisptype) wstring "cl:string"; - %typemap(lout) wstring "(cl::setq ACL_ffresult (excl:native-to-string $body -:external-format #+little-endian :fat-le #-little-endian :fat))"; - - %typemap(ctype) const wstring *"char *"; - %typemap(in) const wstring * "$1.assign($input);"; - %typemap(out) const wstring * "$result = (char *)($1)->c_str();"; - %typemap(lisptype) const wstring * "cl:string"; - %typemap(lout) const wstring * "(cl::setq ACL_ffresult $body)"; - - /* Overloading check */ -// %typemap(in) string { -// if (caml_ptr_check($input)) -// $1.assign((char *)caml_ptr_val($input,0), -// caml_string_len($input)); -// else -// SWIG_exception(SWIG_TypeError, "string expected"); -// } - -// %typemap(in) const string & ($*1_ltype temp) { -// if (caml_ptr_check($input)) { -// temp.assign((char *)caml_ptr_val($input,0), -// caml_string_len($input)); -// $1 = &temp; -// } else { -// SWIG_exception(SWIG_TypeError, "string expected"); -// } -// } - -// %typemap(in) string & ($*1_ltype temp) { -// if (caml_ptr_check($input)) { -// temp.assign((char *)caml_ptr_val($input,0), -// caml_string_len($input)); -// $1 = &temp; -// } else { -// SWIG_exception(SWIG_TypeError, "string expected"); -// } -// } - -// %typemap(in) string * ($*1_ltype *temp) { -// if (caml_ptr_check($input)) { -// temp = new $*1_ltype((char *)caml_ptr_val($input,0), -// caml_string_len($input)); -// $1 = temp; -// } else { -// SWIG_exception(SWIG_TypeError, "string expected"); -// } -// } - -// %typemap(free) string * ($*1_ltype *temp) { -// delete temp; -// } - -// %typemap(argout) string & { -// caml_list_append(swig_result,caml_val_string_len((*$1).c_str(), -// (*$1).size())); -// } - -// %typemap(directorout) string { -// $result.assign((char *)caml_ptr_val($input,0), -// caml_string_len($input)); -// } - -// %typemap(out) string { -// $result = caml_val_string_len($1.c_str(),$1.size()); -// } - -// %typemap(out) string * { -// $result = caml_val_string_len((*$1).c_str(),(*$1).size()); -// } -} - -// #ifdef ENABLE_CHARPTR_ARRAY -// char **c_charptr_array( const std::vector <string > &str_v ); - -// %{ -// SWIGEXT char **c_charptr_array( const std::vector <string > &str_v ) { -// char **out = new char *[str_v.size() + 1]; -// out[str_v.size()] = 0; -// for( int i = 0; i < str_v.size(); i++ ) { -// out[i] = (char *)str_v[i].c_str(); -// } -// return out; -// } -// %} -// #endif - -// #ifdef ENABLE_STRING_VECTOR -// %template (StringVector) std::vector<string >; - -// %insert(ml) %{ -// (* Some STL convenience items *) - -// let string_array_to_vector sa = -// let nv = _new_StringVector C_void in -// array_to_vector nv (fun x -> C_string x) sa ; nv - -// let c_string_array ar = -// _c_charptr_array (string_array_to_vector ar) -// %} - -// %insert(mli) %{ -// val c_string_array: string array -> c_obj -// %} -// #endif diff --git a/Lib/allegrocl/typemaps.i b/Lib/allegrocl/typemaps.i deleted file mode 100644 index 293d1cd34..000000000 --- a/Lib/allegrocl/typemaps.i +++ /dev/null @@ -1,4 +0,0 @@ -/* Unused for Allegro CL module */ - -%include "inout_typemaps.i" -%include "longlongs.i" diff --git a/Lib/cdata.i b/Lib/cdata.i index f18ed4af5..cd1526643 100644 --- a/Lib/cdata.i +++ b/Lib/cdata.i @@ -21,7 +21,7 @@ typedef struct SWIGCDATA { } %typemap(in) (const void *indata, int inlen) = (char *STRING, int LENGTH); -#elif SWIGPHP7 +#elif SWIGPHP %typemap(out) SWIGCDATA { ZVAL_STRINGL($result, $1.data, $1.len); diff --git a/Lib/chicken/chicken.swg b/Lib/chicken/chicken.swg deleted file mode 100644 index 7df676754..000000000 --- a/Lib/chicken/chicken.swg +++ /dev/null @@ -1,809 +0,0 @@ -/* ----------------------------------------------------------------------------- - * chicken.swg - * - * CHICKEN configuration module. - * ----------------------------------------------------------------------------- */ - -/* chicken.h has to appear first. */ - -%insert(runtime) %{ -#include <assert.h> -#include <chicken.h> -%} - -%insert(runtime) "swigrun.swg" // Common C API type-checking code -%insert(runtime) "swigerrors.swg" // SWIG errors -%insert(runtime) "chickenrun.swg" // CHICKEN run-time code - -/* ----------------------------------------------------------------------------- - * standard typemaps - * ----------------------------------------------------------------------------- */ - -/* - CHICKEN: C - ---------- - - fixnum: int, short, unsigned int, unsigned short, unsigned char, - signed char - - char: char - - bool: bool - - flonum: float, double, long, long long, unsigned long, unsigned long - long - */ - -/* --- Primitive types --- */ - -%define SIMPLE_TYPEMAP(type_, from_scheme, to_scheme, checker, convtype, storage_) - -%typemap(in) type_ -%{ if (!checker ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'"); - } - $1 = ($1_ltype) from_scheme ($input); %} - -/* Const primitive references. Passed by value */ - -%typemap(in) const type_ & ($*1_ltype temp) -%{ if (!checker ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'"); - } - temp = ($*1_ltype) from_scheme ($input); - $1 = &temp; %} - -/* --- Variable input --- */ -%typemap(varin) type_ -%{ if (!checker ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Cannot use '$1_ltype' for variable '$name' of type 'type_'"); - } - $1 = ($1_ltype) from_scheme ($input); %} - -#if "storage_" == "0" - -%typemap(out) type_ -%{ - $result = to_scheme (convtype ($1)); -%} - -/* References to primitive types. Return by value */ - -%typemap(out) const type_ & -%{ - $result = to_scheme (convtype (*$1)); -%} - -/* --- Variable output --- */ -%typemap(varout) type_ -%{ - $result = to_scheme (convtype ($varname)); -%} - -%typemap(throws) type_ -%{ - SWIG_Chicken_ThrowException(to_scheme ( convtype ($1))); -%} - -#else - -%typemap(out) type_ -%{ - { - C_word *space = C_alloc(storage_); - $result = to_scheme (&space, convtype ($1)); - } -%} - -/* References to primitive types. Return by value */ - -%typemap(out) const type_ & -%{ - { - C_word *space = C_alloc(storage_); - $result = to_scheme (&space, convtype (*$1)); - } -%} - -/* --- Variable output --- */ -%typemap(varout) type_ -%{ - { - C_word *space = C_alloc(storage_); - $result = to_scheme (&space, convtype ($varname)); - } -%} - -%typemap(throws) type_ -%{ - { - C_word *space = C_alloc(storage_); - SWIG_Chicken_ThrowException(to_scheme (&space, convtype ($1))); - } -%} - -#endif - -/* --- Constants --- */ - -%typemap(constcode) type_ -"static const $1_type $result = $value;" - -%enddef - -SIMPLE_TYPEMAP(int, C_num_to_int, C_fix, C_swig_is_number, (int), 0); -//SIMPLE_TYPEMAP(enum SWIGTYPE, C_unfix, C_fix, C_swig_is_fixnum, (int), 0); -SIMPLE_TYPEMAP(short, C_num_to_int, C_fix, C_swig_is_number, (int), 0); -SIMPLE_TYPEMAP(long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM); -SIMPLE_TYPEMAP(long long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM); -SIMPLE_TYPEMAP(unsigned int, C_num_to_unsigned_int, C_unsigned_int_to_num, C_swig_is_number, (unsigned int), C_SIZEOF_FLONUM); -SIMPLE_TYPEMAP(unsigned short, C_num_to_unsigned_int, C_fix, C_swig_is_number, (unsigned int), 0); -SIMPLE_TYPEMAP(unsigned long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM); -SIMPLE_TYPEMAP(unsigned long long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM); -SIMPLE_TYPEMAP(unsigned char, C_character_code, C_make_character, C_swig_is_char, (unsigned int), 0); -SIMPLE_TYPEMAP(signed char, C_character_code, C_make_character, C_swig_is_char, (int), 0); -SIMPLE_TYPEMAP(char, C_character_code, C_make_character, C_swig_is_char, (char), 0); -SIMPLE_TYPEMAP(bool, C_truep, C_mk_bool, C_swig_is_bool, (bool), 0); -SIMPLE_TYPEMAP(float, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM); -SIMPLE_TYPEMAP(double, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM); - -/* enum SWIGTYPE */ -%apply int { enum SWIGTYPE }; -%apply const int& { const enum SWIGTYPE& }; -%apply const int& { const enum SWIGTYPE&& }; - -%typemap(varin) enum SWIGTYPE -{ - if (!C_swig_is_fixnum($input) && sizeof(int) != sizeof($1)) { - swig_barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, "enum variable '$name' can not be set"); - } - *((int *)(void *)&$1) = C_unfix($input); -} - - -/* --- Input arguments --- */ - -/* Strings */ - -%typemap(in) char * -{ if ($input == C_SCHEME_FALSE) { - $1 = NULL; - } - else { - if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'char *'"); - } - $1 = ($ltype) SWIG_MakeString ($input); - } -} - -%typemap(freearg) char * "if ($1 != NULL) { free ($1); }" - -/* Pointers, references, and arrays */ -%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE *, SWIGTYPE [], SWIGTYPE &, SWIGTYPE && { - $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, $disown); -} - -%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE *DISOWN { - $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, $argnum, SWIG_POINTER_DISOWN); -} - -/* Void pointer. Accepts any kind of pointer */ -%typemap(in) void * { - $1 = ($1_ltype)SWIG_MustGetPtr($input, NULL, $argnum, 0); -} - -%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE * { - $1 = ($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, SWIG_POINTER_DISOWN); -} - -%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE & { - $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0)); -} - -%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE && { - $1 = *(($1_ltype)SWIG_MustGetPtr($input, $descriptor, 1, 0)); -} - -%typemap(varin) SWIGTYPE [] { - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, "Type error"); -} - -%typemap(varin) SWIGTYPE [ANY] { - void *temp; - int ii; - $1_basetype *b = 0; - temp = SWIG_MustGetPtr($input, $1_descriptor, 1, 0); - b = ($1_basetype *) $1; - for (ii = 0; ii < $1_size; ii++) b[ii] = *(($1_basetype *) temp + ii); -} - -%typemap(varin) void * { - $1 = SWIG_MustGetPtr($input, NULL, 1, 0); -} - -%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - $result = SWIG_NewPointerObj($1, $descriptor, $owner); -} - -%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor,(void **) &$1); - $result = SWIG_NewPointerObj($1, ty, $owner); -} - -%typemap(varout) SWIGTYPE *, SWIGTYPE [] { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - $result = SWIG_NewPointerObj($varname, $descriptor, 0); -} - -%typemap(varout) SWIGTYPE & { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - $result = SWIG_NewPointerObj((void *) &$varname, $1_descriptor, 0); -} - -%typemap(varout) SWIGTYPE && { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - $result = SWIG_NewPointerObj((void *) &$varname, $1_descriptor, 0); -} - -/* special typemaps for class pointers */ -%typemap(in) SWIGTYPE (CLASS::*) { - char err_msg[256]; - - if (C_swig_is_pair($input)) { - /* try and convert pointer object */ - void *result; - if (!SWIG_ConvertPtr(C_block_item($input,1), &result, $descriptor, 0)) { - C_word ptr = C_block_item($input,0); - if (C_swig_is_string(ptr)) { - SWIG_UnpackData(C_c_string(ptr), (void *) &$1, sizeof($type)); - } else { - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", $argnum, ($descriptor->str ? $descriptor->str : $descriptor->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } - } else { - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", $argnum, ($descriptor->str ? $descriptor->str : $descriptor->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } - } else { - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", $argnum, ($descriptor->str ? $descriptor->str : $descriptor->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } -} - -%typemap(out) SWIGTYPE (CLASS::*) { - size_t ptr_size = sizeof($type); - C_word *known_space = C_alloc(C_SIZEOF_PAIR + C_SIZEOF_STRING(2*ptr_size) + C_SIZEOF_SWIG_POINTER); - char *temp = (char *)malloc(2*ptr_size); - C_word ptr = SWIG_NewPointerObj((void *) known_space, $descriptor, 0); - - SWIG_PackData(temp, (void *) &$1, ptr_size); - $result = C_pair(&known_space, C_string(&known_space, 2*ptr_size, temp), ptr); - free(temp); -} - -%typemap(varin) SWIGTYPE (CLASS::*) { - char err_msg[256]; - - if (C_swig_is_pair($input)) { - /* try and convert pointer object */ - void *result; - if (!SWIG_ConvertPtr(C_block_item($input,1), &result, $descriptor, 0)) { - C_word ptr = C_block_item($input,0); - if (C_swig_is_string(ptr)) { - SWIG_UnpackData(C_c_string(ptr), (void *) &$1, sizeof($type)); - } else { - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", 1, ($descriptor->str ? $descriptor->str : $descriptor->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } - } else { - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", 1, ($descriptor->str ? $descriptor->str : $descriptor->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } - } else { - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", 1, ($descriptor->str ? $descriptor->str : $descriptor->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } -} - -%typemap(varout) SWIGTYPE (CLASS::*) { - size_t ptr_size = sizeof($type); - C_word *known_space = C_alloc(C_SIZEOF_PAIR + C_SIZEOF_STRING(2*ptr_size) + C_SIZEOF_SWIG_POINTER); - char *temp = (char *)malloc(2*ptr_size); - C_word ptr = SWIG_NewPointerObj((void *) known_space, $descriptor, 0); - - SWIG_PackData(temp, (void *) &$varname, ptr_size); - $result = C_pair(&known_space, C_string(&known_space, 2*ptr_size, temp), ptr); - free(temp); -} - - - -/* Pass-by-value */ - -%typemap(in,closcode="(slot-ref $input 'swig-this)") SWIGTYPE($&1_ltype argp) { - argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, $argnum, 0); - $1 = *argp; -} - -%typemap(varin,closcode="(slot-ref $input 'swig-this)") SWIGTYPE { - $&1_ltype argp; - argp = ($&1_ltype)SWIG_MustGetPtr($input, $&1_descriptor, 1, 0); - $1 = *argp; -} - -%typemap(out) SWIGTYPE -#ifdef __cplusplus -{ - $&1_ltype resultptr; - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - resultptr = new $1_ltype((const $1_ltype &) $1); - $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 1); -} -#else -{ - $&1_ltype resultptr; - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - resultptr = ($&1_ltype) malloc(sizeof($1_type)); - memmove(resultptr, &$1, sizeof($1_type)); - $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 1); -} -#endif - -%typemap(varout) SWIGTYPE -#ifdef __cplusplus -{ - $&1_ltype resultptr; - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - resultptr = new $1_ltype((const $1_ltype&) $1); - $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0); -} -#else -{ - $&1_ltype resultptr; - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - resultptr = ($&1_ltype) malloc(sizeof($1_type)); - memmove(resultptr, &$1, sizeof($1_type)); - $result = SWIG_NewPointerObj(resultptr, $&1_descriptor, 0); -} -#endif - -/* --- Output values --- */ - -/* Strings */ - -%typemap(out) - char * -{ char *s = (char*) $1; - if ($1 == NULL) { - $result = C_SCHEME_FALSE; - } - else { - int string_len = strlen ((char *) ($1)); - C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len)); - $result = C_string (&string_space, string_len, s); - } -} - -%typemap(varout) - char * -{ char *s = (char*) $varname; - if ($varname == NULL) { - $result = C_SCHEME_FALSE; - } - else { - int string_len = strlen ($varname); - C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len)); - $result = C_string (&string_space, string_len, s); - } -} - -%typemap(throws) char * -{ - if ($1 == NULL) { - SWIG_Chicken_ThrowException(C_SCHEME_FALSE); - } else { - int string_len = strlen($1); - C_word *string_space = C_alloc(C_SIZEOF_STRING(string_len)); - SWIG_Chicken_ThrowException(C_string(&string_space, string_len, (char *) $1)); - } -} - -/* Void */ -%typemap(out) void -%{ -$result = C_SCHEME_UNDEFINED; -%} - -/* Special typemap for character array return values */ - -%typemap(out) - char [ANY], const char [ANY] -%{ if ($1 == NULL) { - $result = C_SCHEME_FALSE; - } - else { - const int string_len = strlen ($1); - C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len)); - $result = C_string (&string_space, string_len, $1); - } %} - -/* Primitive types--return by value */ - -/* --- Variable input --- */ - -/* A string */ -#ifdef __cplusplus -%typemap(varin) char * { - if ($input == C_SCHEME_FALSE) { - $1 = NULL; - } - else if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'"); - } - else { - char *temp = C_c_string ($input); - int len = C_header_size ($input); - if ($1) delete [] $1; - $1 = ($type) new char[len+1]; - strncpy((char*)$1, temp, len); - ((char*)$1) [len] = 0; - } -} -%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * { - if ($input == C_SCHEME_FALSE) { - $1 = NULL; - } - else if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'"); - } - else { - char *temp = C_c_string ($input); - int len = C_header_size ($input); - $1 = ($type) new char[len+1]; - strncpy((char*)$1,temp,len); - ((char*)$1) [len] = 0; - } -} -#else -%typemap(varin) char * { - if ($input == C_SCHEME_FALSE) { - $1 = NULL; - } - else if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'"); - } - else { - char *temp = C_c_string ($input); - int len = C_header_size ($input); - if ($1) free((char*) $1); - $1 = ($type) malloc(len+1); - strncpy((char*)$1,temp,len); - ((char*)$1) [len] = 0; - } -} -%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * { - if ($input == C_SCHEME_FALSE) { - $1 = NULL; - } - else if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'"); - } - else { - char *temp = C_c_string ($input); - int len = C_header_size ($input); - $1 = ($type) malloc(len+1); - strncpy((char*)$1,temp,len); - ((char*)$1) [len] = 0; - } -} -#endif - -%typemap(varin) char [] { - swig_barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, "C/C++ variable '$name' is read-only"); -} - -/* Special case for string array variables */ -%typemap(varin) char [ANY] { - if ($input == C_SCHEME_FALSE) { - memset($1,0,$1_dim0*sizeof(char)); - } - else if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "C variable '$name ($1_ltype)'"); - } - else { - char *temp = C_c_string ($input); - strncpy($1,temp,$1_dim0*sizeof(char)); - } -} - -/* --- Variable output --- */ - -/* Void */ -%typemap(varout) void "$result = C_SCHEME_UNDEFINED;"; - -/* Special typemap for character array return values */ -%typemap(varout) char [ANY], const char [ANY] -%{ if ($varname == NULL) { - $result = C_SCHEME_FALSE; - } - else { - const int string_len = strlen ($varname); - C_word *string_space = C_alloc (C_SIZEOF_STRING (string_len)); - $result = C_string (&string_space, string_len, (char *) $varname); - } -%} - - -/* --- Constants --- */ - -%typemap(constcode) char * -"static const char *$result = $value;" - -%typemap(constcode) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] -"static const void *$result = (void*) $value;" - -/* ------------------------------------------------------------ - * String & length - * ------------------------------------------------------------ */ - -%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) { - if ($input == C_SCHEME_FALSE) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Cannot use a null/#f string for a char*, int arguments"); - } - else if (C_swig_is_string ($input)) { - $1 = ($1_ltype) C_c_string ($input); - $2 = ($2_ltype) C_header_size ($input); - } - else { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'string'"); - } -} - -/* ------------------------------------------------------------ - * CHICKEN types - * ------------------------------------------------------------ */ - -%typemap(in) C_word "$1 = $input;"; -%typemap(out) C_word "$result = $1;"; - -/* ------------------------------------------------------------ - * Typechecking rules - * ------------------------------------------------------------ */ - -%typecheck(SWIG_TYPECHECK_INTEGER) - bool, const bool & -{ - $1 = C_swig_is_bool ($input); -} - -%typecheck(SWIG_TYPECHECK_INTEGER) - int, short, - unsigned int, unsigned short, - signed char, unsigned char, - const int &, const short &, - const unsigned int &, const unsigned short &, - enum SWIGTYPE -{ - $1 = C_swig_is_fixnum ($input); -} - -%typecheck(SWIG_TYPECHECK_INTEGER) - long, - unsigned long, - long long, unsigned long long, - const long &, - const unsigned long &, - const long long &, const unsigned long long & -{ - $1 = (C_swig_is_bool ($input) || - C_swig_is_fixnum ($input) || - C_swig_is_flonum ($input)) ? 1 : 0; -} - -%typecheck(SWIG_TYPECHECK_DOUBLE) - float, double, - const float &, const double & -{ - $1 = C_swig_is_flonum ($input); -} - -%typecheck(SWIG_TYPECHECK_CHAR) char { - $1 = C_swig_is_string ($input); -} - -%typecheck(SWIG_TYPECHECK_STRING) char * { - $1 = C_swig_is_string ($input); -} - -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE [] { - void *ptr; - $1 = !SWIG_ConvertPtr($input, &ptr, $1_descriptor, 0); -} - -%typecheck(SWIG_TYPECHECK_VOIDPTR) void * { - void *ptr; - $1 = !SWIG_ConvertPtr($input, &ptr, 0, 0); -} - -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE & -{ - void *ptr = 0; - if (SWIG_ConvertPtr($input, &ptr, $descriptor, SWIG_POINTER_NO_NULL)) { - $1 = 0; - } else { - $1 = 1; - } -} - -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE && -{ - void *ptr = 0; - if (SWIG_ConvertPtr($input, &ptr, $descriptor, SWIG_POINTER_NO_NULL)) { - $1 = 0; - } else { - $1 = 1; - } -} - -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE -{ - void *ptr = 0; - if (SWIG_ConvertPtr($input, &ptr, $&descriptor, SWIG_POINTER_NO_NULL)) { - $1 = 0; - } else { - $1 = 1; - } -} - - -/* ------------------------------------------------------------ - * Exception handling - * ------------------------------------------------------------ */ - -/* ------------------------------------------------------------ - * --- Exception handling --- - * ------------------------------------------------------------ */ - -%typemap(throws) SWIGTYPE { - $<ype temp = new $ltype($1); - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - C_word ptr = SWIG_NewPointerObj(temp, $&descriptor,1); - SWIG_Chicken_ThrowException(ptr); -} - -%typemap(throws) SWIGTYPE * { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - C_word ptr = SWIG_NewPointerObj((void *) $1, $descriptor, 0); - SWIG_Chicken_ThrowException(ptr); -} - -%typemap(throws) SWIGTYPE [ANY] { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - C_word ptr = SWIG_NewPointerObj((void *) $1, $descriptor, 0); - SWIG_Chicken_ThrowException(ptr); -} - -%typemap(throws) SWIGTYPE & { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - C_word ptr = SWIG_NewPointerObj((void *)&($1),$descriptor,0); - SWIG_Chicken_ThrowException(ptr); -} - -%typemap(throws) SWIGTYPE && { - C_word *known_space = C_alloc(C_SIZEOF_SWIG_POINTER); - C_word ptr = SWIG_NewPointerObj((void *)&($1),$descriptor,0); - SWIG_Chicken_ThrowException(ptr); -} - -/* ------------------------------------------------------------ - * ANSI C typemaps - * ------------------------------------------------------------ */ - -%apply unsigned long { size_t }; - -/* ------------------------------------------------------------ - * Various - * ------------------------------------------------------------ */ - -/* Array reference typemaps */ -%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) } -%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) } - -/* const pointers */ -%apply SWIGTYPE * { SWIGTYPE *const } -%apply SWIGTYPE (CLASS::*) { SWIGTYPE (CLASS::*const) } -%apply SWIGTYPE & { SWIGTYPE (CLASS::*const&) } - -/* ------------------------------------------------------------ - * Overloaded operator support - * ------------------------------------------------------------ */ - -#ifdef __cplusplus -%rename(__add__) *::operator+; -%rename(__pos__) *::operator+(); -%rename(__pos__) *::operator+() const; -%rename(__sub__) *::operator-; -%rename(__neg__) *::operator-(); -%rename(__neg__) *::operator-() const; -%rename(__mul__) *::operator*; -%rename(__div__) *::operator/; -%rename(__mod__) *::operator%; -%rename(__lshift__) *::operator<<; -%rename(__rshift__) *::operator>>; -%rename(__and__) *::operator&; -%rename(__or__) *::operator|; -%rename(__xor__) *::operator^; -%rename(__invert__) *::operator~; -%rename(__iadd__) *::operator+=; -%rename(__isub__) *::operator-=; -%rename(__imul__) *::operator*=; -%rename(__idiv__) *::operator/=; -%rename(__imod__) *::operator%=; -%rename(__ilshift__) *::operator<<=; -%rename(__irshift__) *::operator>>=; -%rename(__iand__) *::operator&=; -%rename(__ior__) *::operator|=; -%rename(__ixor__) *::operator^=; -%rename(__lt__) *::operator<; -%rename(__le__) *::operator<=; -%rename(__gt__) *::operator>; -%rename(__ge__) *::operator>=; -%rename(__eq__) *::operator==; -%rename(__ne__) *::operator!=; - -/* Special cases */ -%rename(__call__) *::operator(); - -#endif -/* Warnings for certain CHICKEN keywords */ -%include <chickenkw.swg> - -/* TinyCLOS <--> Low-level CHICKEN */ - -%typemap("clos_in") SIMPLE_CLOS_OBJECT * "(slot-ref $input (quote this))" -%typemap("clos_out") SIMPLE_CLOS_OBJECT * "(make $class (quote this) $1)" - -%insert(header) %{ -#ifdef __cplusplus -extern "C" { -#endif -/* Chicken initialization function */ -SWIGEXPORT void SWIG_init(C_word, C_word, C_word) C_noret; -#ifdef __cplusplus -} -#endif -%} - -%insert(closprefix) "swigclosprefix.scm" - -%insert(init) "swiginit.swg" - -%insert(init) %{ -/* CHICKEN initialization function */ -#ifdef __cplusplus -extern "C" { -#endif -SWIGEXPORT void SWIG_init(C_word argc, C_word closure, C_word continuation) { - int i; - C_word sym; - C_word tmp; - C_word *a; - C_word ret; - C_word *return_vec; - - SWIG_InitializeModule(0); - SWIG_PropagateClientData(); - ret = C_SCHEME_TRUE; - -#if $veclength - return_vec = C_alloc(C_SIZEOF_VECTOR($veclength)); - ret = (C_word) return_vec; - *(return_vec++) = C_VECTOR_TYPE | $veclength; -#endif - - a = C_alloc(2*$nummethods$symsize); - -%} diff --git a/Lib/chicken/chickenkw.swg b/Lib/chicken/chickenkw.swg deleted file mode 100644 index d2c26c74c..000000000 --- a/Lib/chicken/chickenkw.swg +++ /dev/null @@ -1,31 +0,0 @@ -#ifndef CHICKEN_CHICKENKW_SWG_ -#define CHICKEN_CHICKENKW_SWG_ - -/* Warnings for certain CHICKEN keywords. From Section 7.1.1 of - Revised^5 Report on the Algorithmic Language Scheme */ -#define CHICKENKW(x) %namewarn("314: '" #x "' is a R^5RS syntatic keyword") #x - -CHICKENKW(else); -CHICKENKW(=>); -CHICKENKW(define); -CHICKENKW(unquote); -CHICKENKW(unquote-splicing); -CHICKENKW(quote); -CHICKENKW(lambda); -CHICKENKW(if); -CHICKENKW(set!); -CHICKENKW(begin); -CHICKENKW(cond); -CHICKENKW(and); -CHICKENKW(or); -CHICKENKW(case); -CHICKENKW(let); -CHICKENKW(let*); -CHICKENKW(letrec); -CHICKENKW(do); -CHICKENKW(delay); -CHICKENKW(quasiquote); - -#undef CHICKENKW - -#endif //CHICKEN_CHICKENKW_SWG_ diff --git a/Lib/chicken/chickenrun.swg b/Lib/chicken/chickenrun.swg deleted file mode 100644 index bb14b4bc9..000000000 --- a/Lib/chicken/chickenrun.swg +++ /dev/null @@ -1,375 +0,0 @@ -/* ----------------------------------------------------------------------------- - * chickenrun.swg - * ----------------------------------------------------------------------------- */ - -#include <chicken.h> -#include <assert.h> -#include <stdio.h> -#include <string.h> -#include <stdlib.h> -#if (defined(_MSC_VER) && (_MSC_VER < 1900)) || defined(__BORLANDC__) || defined(_WATCOM) -# ifndef snprintf -# define snprintf _snprintf -# endif -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -#define SWIG_malloc(size) \ - malloc(size) -#define SWIG_free(mem) \ - free(mem) -#define SWIG_MakeString(c) \ - SWIG_Chicken_MakeString(c) -#define SWIG_ConvertPtr(s, result, type, flags) \ - SWIG_Chicken_ConvertPtr(s, result, type, flags) -#define SWIG_MustGetPtr(s, type, argnum, flags) \ - SWIG_Chicken_MustGetPtr(s, type, argnum, flags) -#define SWIG_NewPointerObj(ptr, type, owner) \ - SWIG_Chicken_NewPointerObj((void*)ptr, type, owner, &known_space) -#define swig_barf SWIG_Chicken_Barf -#define SWIG_ThrowException(val) SWIG_Chicken_ThrowException(val) - -#define SWIG_contract_assert(expr, message) if (!(expr)) { \ - SWIG_Chicken_Barf(SWIG_BARF1_CONTRACT_ASSERT, C_text(message)); } else - -/* Runtime API */ -#define SWIG_GetModule(clientdata) SWIG_Chicken_GetModule(clientdata) -#define SWIG_SetModule(clientdata, pointer) SWIG_Chicken_SetModule(pointer) - -#define C_swig_is_bool(x) C_truep (C_booleanp (x)) -#define C_swig_is_char(x) C_truep (C_charp (x)) -#define C_swig_is_fixnum(x) C_truep (C_fixnump (x)) -#define C_swig_is_flonum(x) (C_truep (C_blockp (x)) && C_truep (C_flonump (x))) -#define C_swig_is_string(x) (C_truep (C_blockp (x)) && C_truep (C_stringp (x))) -#define C_swig_is_vector(x) (C_truep (C_blockp (x)) && C_truep (C_vectorp (x))) -#define C_swig_is_list(x) (C_truep (C_i_listp (x))) -#define C_swig_is_pair(x) (C_truep (C_blockp(x)) && C_truep (C_pairp(x))) -#define C_swig_is_ptr(x) (C_truep (C_blockp (x)) && C_truep (C_pointerp (x))) -#define C_swig_is_swigpointer(x) (C_truep (C_blockp(x)) && C_truep (C_swigpointerp(x))) -#define C_swig_is_closurep(x) (C_truep (C_blockp(x)) && C_truep(C_closurep(x))) -#define C_swig_is_number(x) (C_swig_is_fixnum(x) || C_swig_is_flonum(x)) -#define C_swig_is_long(x) C_swig_is_number(x) - -#define C_swig_sizeof_closure(num) (num+1) - -#define SWIG_Chicken_SetupArgout { \ - C_word *a = C_alloc(C_swig_sizeof_closure(2)); \ - C_word *closure = a; \ - *(a++)=C_CLOSURE_TYPE|2; \ - *(a++)=(C_word)SWIG_Chicken_ApplyResults; \ - *(a++)=continuation; \ - continuation=(C_word)closure; \ -} - -#define SWIG_APPEND_VALUE(obj) { \ - C_word val = (C_word)(obj); \ - if (val != C_SCHEME_UNDEFINED) { \ - C_word *a = C_alloc(C_swig_sizeof_closure(3)); \ - C_word *closure = a; \ - *(a++)=C_CLOSURE_TYPE|3; \ - *(a++)=(C_word)SWIG_Chicken_MultiResultBuild; \ - *(a++)=(C_word)continuation; \ - *(a++)=val; \ - continuation=(C_word)closure; \ - } } - -#define SWIG_Chicken_FindCreateProxy(func,obj) \ - if (C_swig_is_swigpointer(obj)) { \ - swig_type_info *t = (swig_type_info *) C_block_item(obj, 1); \ - if (t && t->clientdata && ((swig_chicken_clientdata *)t->clientdata)->gc_proxy_create) { \ - func = CHICKEN_gc_root_ref( ((swig_chicken_clientdata *)t->clientdata)->gc_proxy_create); \ - } else { \ - func = C_SCHEME_FALSE; \ - } \ - } else { \ - func = C_SCHEME_FALSE; \ - } - - -enum { - SWIG_BARF1_BAD_ARGUMENT_TYPE /* 1 arg */, - SWIG_BARF1_ARGUMENT_NULL /* 1 arg */, - SWIG_BARF1_CONTRACT_ASSERT /* 1 arg */, -}; - -typedef C_word (*swig_chicken_destructor)(C_word,C_word,C_word,C_word); -typedef struct swig_chicken_clientdata { - void *gc_proxy_create; - swig_chicken_destructor destroy; -} swig_chicken_clientdata; - -static char * -SWIG_Chicken_MakeString(C_word str) { - char *ret; - size_t l; - - l = C_header_size(str); - ret = (char *) SWIG_malloc( (l + 1) * sizeof(char)); - if (!ret) return NULL; - - memcpy(ret, C_c_string(str), l); - ret[l] = '\0'; - return ret; -} - -static C_word SWIG_Chicken_LookupSymbol(char *name, C_SYMBOL_TABLE *stable) { - C_word *a = C_alloc(C_SIZEOF_STRING (strlen (name))); - C_word n = C_string2(&a, name); - C_word sym = C_find_symbol(n, stable); - if (C_truep(sym)) { - return C_symbol_value(sym); - } else { - return C_SCHEME_FALSE; - } -} - -/* Just a helper function. Do not export it */ -static void SWIG_Chicken_Panic (C_char *) C_noret; -static void SWIG_Chicken_Panic (C_char *msg) -{ - C_word *a = C_alloc (C_SIZEOF_STRING (strlen (msg))); - C_word scmmsg = C_string2 (&a, msg); - C_halt (scmmsg); - exit (5); /* should never get here */ -} - -static void -SWIG_Chicken_Barf(int code, C_char *msg, ...) C_noret; -static void -SWIG_Chicken_Barf(int code, C_char *msg, ...) -{ - char *errorhook = C_text("\003syserror-hook"); - C_word *a = C_alloc (C_SIZEOF_STRING (strlen (errorhook))); - C_word err = C_intern2 (&a, errorhook); - int c = -1; - int i, barfval; - va_list v; - - - C_temporary_stack = C_temporary_stack_bottom; - err = C_block_item(err, 0); - - if(C_immediatep (err)) - SWIG_Chicken_Panic (C_text ("`##sys#error-hook' is not defined")); - - switch (code) { - case SWIG_BARF1_BAD_ARGUMENT_TYPE: - barfval = C_BAD_ARGUMENT_TYPE_ERROR; - c = 1; - break; - case SWIG_BARF1_ARGUMENT_NULL: - barfval = C_BAD_ARGUMENT_TYPE_ERROR; - c = 1; - break; - case SWIG_BARF1_CONTRACT_ASSERT: - barfval = C_BAD_ARGUMENT_TYPE_ERROR; - c = 1; - break; - default: - SWIG_Chicken_Panic (C_text (msg)); - }; - - if(c > 0 && !C_immediatep (err)) { - C_save (C_fix (barfval)); - - i = c; - if (i) { - C_word *b = C_alloc (C_SIZEOF_STRING (strlen (msg))); - C_word scmmsg = C_string2 (&b, msg); - C_save (scmmsg); - i--; - } - - va_start (v, msg); - - while(i--) - C_save (va_arg (v, C_word)); - - va_end (v); - C_do_apply (c + 1, err, - C_SCHEME_UNDEFINED); /* <- no continuation is passed: - '##sys#error-hook' may not - return! */ - } - else if (msg) { - SWIG_Chicken_Panic (msg); - } - else { - SWIG_Chicken_Panic (C_text ("unspecified panic")); - } -} - -static void SWIG_Chicken_ThrowException(C_word value) C_noret; -static void SWIG_Chicken_ThrowException(C_word value) -{ - char *aborthook = C_text("\003sysabort"); - C_word *a = C_alloc(C_SIZEOF_STRING(strlen(aborthook))); - C_word abort = C_intern2(&a, aborthook); - - abort = C_block_item(abort, 0); - if (C_immediatep(abort)) - SWIG_Chicken_Panic(C_text("`##sys#abort' is not defined")); - - C_save(value); - C_do_apply(1, abort, C_SCHEME_UNDEFINED); -} - -static void -SWIG_Chicken_Finalizer(C_word argc, C_word closure, C_word continuation, C_word s) -{ - swig_type_info *type; - swig_chicken_clientdata *cdata; - - if (argc == 3 && s != C_SCHEME_FALSE && C_swig_is_swigpointer(s)) { - type = (swig_type_info *) C_block_item(s, 1); - if (type) { - cdata = (swig_chicken_clientdata *) type->clientdata; - if (cdata && cdata->destroy) { - /* this will not return, but will continue correctly */ - cdata->destroy(3,closure,continuation,s); - } - } - } - C_kontinue(continuation, C_SCHEME_UNDEFINED); -} -static C_word finalizer_obj[2] = {(C_word) (C_CLOSURE_TYPE|1), (C_word) SWIG_Chicken_Finalizer}; - -static C_word -SWIG_Chicken_NewPointerObj(void *ptr, swig_type_info *type, int owner, C_word **data) -{ - swig_chicken_clientdata *cdata = (swig_chicken_clientdata *) type->clientdata; - - if (ptr == NULL) - return C_SCHEME_FALSE; - else { - C_word cptr = C_swigmpointer(data, ptr, type); - /* add finalizer to object */ - #ifndef SWIG_CHICKEN_NO_COLLECTION - if (owner) - C_do_register_finalizer(cptr, (C_word) finalizer_obj); - #endif - - return cptr; - } -} - -/* Return 0 if successful. */ -static int -SWIG_Chicken_ConvertPtr(C_word s, void **result, swig_type_info *type, int flags) -{ - swig_cast_info *cast; - swig_type_info *from; - - if (s == C_SCHEME_FALSE) { - *result = NULL; - return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; - } else if (C_swig_is_swigpointer(s)) { - /* try and convert type */ - from = (swig_type_info *) C_block_item(s, 1); - if (!from) return 1; - if (type) { - cast = SWIG_TypeCheckStruct(from, type); - if (cast) { - int newmemory = 0; - *result = SWIG_TypeCast(cast, (void *) C_block_item(s, 0), &newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - } else { - return 1; - } - } else { - *result = (void *) C_block_item(s, 0); - } - - /* check if we are disowning this object */ - if (flags & SWIG_POINTER_DISOWN) { - C_do_unregister_finalizer(s); - } - } else { - return 1; - } - - return 0; -} - -static SWIGINLINE void * -SWIG_Chicken_MustGetPtr (C_word s, swig_type_info *type, int argnum, int flags) -{ - void *result; - char err_msg[256]; - if (SWIG_Chicken_ConvertPtr(s, &result, type, flags)) { - /* type mismatch */ - snprintf(err_msg, sizeof(err_msg), "Type error in argument #%i: expected %s", argnum, (type->str ? type->str : type->name)); - SWIG_Chicken_Barf(SWIG_BARF1_BAD_ARGUMENT_TYPE, err_msg); - } - return result; -} - -static char *chicken_runtimevar_name = "type_pointer" SWIG_TYPE_TABLE_NAME; - -static swig_module_info * -SWIG_Chicken_GetModule(void *SWIGUNUSEDPARM(clientdata)) { - swig_module_info *ret = 0; - C_word sym; - - /* lookup the type pointer... it is stored in its own symbol table */ - C_SYMBOL_TABLE *stable = C_find_symbol_table("swig_runtime_data" SWIG_RUNTIME_VERSION); - if (stable != NULL) { - sym = SWIG_Chicken_LookupSymbol(chicken_runtimevar_name, stable); - if (C_truep(sym) && C_swig_is_ptr(sym)) { - ret = (swig_module_info *) C_block_item(sym, 0); - } - } - - return ret; -} - -static void -SWIG_Chicken_SetModule(swig_module_info *module) { - C_word *a; - C_SYMBOL_TABLE *stable; - C_word sym; - C_word pointer; - static C_word *space = 0; - - /* type pointer is stored in its own symbol table */ - stable = C_find_symbol_table("swig_runtime_data" SWIG_RUNTIME_VERSION); - if (stable == NULL) { - stable = C_new_symbol_table("swig_runtime_data" SWIG_RUNTIME_VERSION, 16); - } - - if (!space) { - space = (C_word *) C_malloc((C_SIZEOF_POINTER + C_SIZEOF_INTERNED_SYMBOL(C_strlen(chicken_runtimevar_name))) * sizeof(C_word)); - } - a = space; - pointer = C_mpointer(&a, (void *) module); - sym = C_intern_in(&a, C_strlen(chicken_runtimevar_name), chicken_runtimevar_name, stable); - C_set_block_item(sym, 0, pointer); -} - -static C_word SWIG_Chicken_MultiResultBuild(C_word num, C_word closure, C_word lst) { - C_word cont = C_block_item(closure,1); - C_word obj = C_block_item(closure,2); - C_word func; - - SWIG_Chicken_FindCreateProxy(func,obj); - - if (C_swig_is_closurep(func)) { - ((C_proc4)(void *)C_block_item(func, 0))(4,func,cont,obj,lst); - } else { - C_word *a = C_alloc(C_SIZEOF_PAIR); - C_kontinue(cont,C_pair(&a,obj,lst)); - } - return C_SCHEME_UNDEFINED; /* never reached */ -} - -static C_word SWIG_Chicken_ApplyResults(C_word num, C_word closure, C_word result) { - C_apply_values(3,C_SCHEME_UNDEFINED,C_block_item(closure,1),result); - return C_SCHEME_UNDEFINED; /* never reached */ -} - -#ifdef __cplusplus -} -#endif diff --git a/Lib/chicken/extra-install.list b/Lib/chicken/extra-install.list deleted file mode 100644 index 48721cee0..000000000 --- a/Lib/chicken/extra-install.list +++ /dev/null @@ -1,3 +0,0 @@ -swigclosprefix.scm -multi-generic.scm -tinyclos-multi-generic.patch diff --git a/Lib/chicken/multi-generic.scm b/Lib/chicken/multi-generic.scm deleted file mode 100644 index 9d2e31d34..000000000 --- a/Lib/chicken/multi-generic.scm +++ /dev/null @@ -1,152 +0,0 @@ -;; This file is no longer necessary with Chicken versions above 1.92 -;; -;; This file overrides two functions inside TinyCLOS to provide support -;; for multi-argument generics. There are many ways of linking this file -;; into your code... all that needs to happen is this file must be -;; executed after loading TinyCLOS but before any SWIG modules are loaded -;; -;; something like the following -;; (require 'tinyclos) -;; (load "multi-generic") -;; (declare (uses swigmod)) -;; -;; An alternative to loading this scheme code directly is to add a -;; (declare (unit multi-generic)) to the top of this file, and then -;; compile this into the final executable or something. Or compile -;; this into an extension. - -;; Lastly, to override TinyCLOS method creation, two functions are -;; overridden: see the end of this file for which two are overridden. -;; You might want to remove those two lines and then exert more control over -;; which functions are used when. - -;; Comments, bugs, suggestions: send either to chicken-users@nongnu.org or to -;; Most code copied from TinyCLOS - -(define <multi-generic> (make <entity-class> - 'name "multi-generic" - 'direct-supers (list <generic>) - 'direct-slots '())) - -(letrec ([applicable? - (lambda (c arg) - (memq c (class-cpl (class-of arg))))] - - [more-specific? - (lambda (c1 c2 arg) - (memq c2 (memq c1 (class-cpl (class-of arg)))))] - - [filter-in - (lambda (f l) - (if (null? l) - '() - (let ([h (##sys#slot l 0)] - [r (##sys#slot l 1)] ) - (if (f h) - (cons h (filter-in f r)) - (filter-in f r) ) ) ) )]) - -(add-method compute-apply-generic - (make-method (list <multi-generic>) - (lambda (call-next-method generic) - (lambda args - (let ([cam (let ([x (compute-apply-methods generic)] - [y ((compute-methods generic) args)] ) - (lambda (args) (x y args)) ) ] ) - (cam args) ) ) ) ) ) - - - -(add-method compute-methods - (make-method (list <multi-generic>) - (lambda (call-next-method generic) - (lambda (args) - (let ([applicable - (filter-in (lambda (method) - (let check-applicable ([list1 (method-specializers method)] - [list2 args]) - (cond ((null? list1) #t) - ((null? list2) #f) - (else - (and (applicable? (##sys#slot list1 0) (##sys#slot list2 0)) - (check-applicable (##sys#slot list1 1) (##sys#slot list2 1))))))) - (generic-methods generic) ) ] ) - (if (or (null? applicable) (null? (##sys#slot applicable 1))) - applicable - (let ([cmms (compute-method-more-specific? generic)]) - (sort applicable (lambda (m1 m2) (cmms m1 m2 args))) ) ) ) ) ) ) ) - -(add-method compute-method-more-specific? - (make-method (list <multi-generic>) - (lambda (call-next-method generic) - (lambda (m1 m2 args) - (let loop ((specls1 (method-specializers m1)) - (specls2 (method-specializers m2)) - (args args)) - (cond-expand - [unsafe - (let ((c1 (##sys#slot specls1 0)) - (c2 (##sys#slot specls2 0)) - (arg (##sys#slot args 0))) - (if (eq? c1 c2) - (loop (##sys#slot specls1 1) - (##sys#slot specls2 1) - (##sys#slot args 1)) - (more-specific? c1 c2 arg))) ] - [else - (cond ((and (null? specls1) (null? specls2)) - (##sys#error "two methods are equally specific" generic)) - ;((or (null? specls1) (null? specls2)) - ; (##sys#error "two methods have different number of specializers" generic)) - ((null? specls1) #f) - ((null? specls2) #t) - ((null? args) - (##sys#error "fewer arguments than specializers" generic)) - (else - (let ((c1 (##sys#slot specls1 0)) - (c2 (##sys#slot specls2 0)) - (arg (##sys#slot args 0))) - (if (eq? c1 c2) - (loop (##sys#slot specls1 1) - (##sys#slot specls2 1) - (##sys#slot args 1)) - (more-specific? c1 c2 arg)))) ) ] ) ) ) ) ) ) - -) ;; end of letrec - -(define multi-add-method - (lambda (generic method) - (slot-set! - generic - 'methods - (let filter-in-method ([methods (slot-ref generic 'methods)]) - (if (null? methods) - (list method) - (let ([l1 (length (method-specializers method))] - [l2 (length (method-specializers (##sys#slot methods 0)))]) - (cond ((> l1 l2) - (cons (##sys#slot methods 0) (filter-in-method (##sys#slot methods 1)))) - ((< l1 l2) - (cons method methods)) - (else - (let check-method ([ms1 (method-specializers method)] - [ms2 (method-specializers (##sys#slot methods 0))]) - (cond ((and (null? ms1) (null? ms2)) - (cons method (##sys#slot methods 1))) ;; skip the method already in the generic - ((eq? (##sys#slot ms1 0) (##sys#slot ms2 0)) - (check-method (##sys#slot ms1 1) (##sys#slot ms2 1))) - (else - (cons (##sys#slot methods 0) (filter-in-method (##sys#slot methods 1)))))))))))) - - (##sys#setslot (##sys#slot generic (- (##sys#size generic) 2)) 1 (compute-apply-generic generic)) )) - -(define (multi-add-global-method val sym specializers proc) - (let ((generic (if (procedure? val) val (make <multi-generic> 'name (##sys#symbol->string sym))))) - (multi-add-method generic (make-method specializers proc)) - generic)) - -;; Might want to remove these, or perhaps do something like -;; (define old-add-method ##tinyclos#add-method) -;; and then you can switch between creating multi-generics and TinyCLOS generics. -(set! ##tinyclos#add-method multi-add-method) -(set! ##tinyclos#add-global-method multi-add-global-method) diff --git a/Lib/chicken/std_string.i b/Lib/chicken/std_string.i deleted file mode 100644 index fa77c1533..000000000 --- a/Lib/chicken/std_string.i +++ /dev/null @@ -1,96 +0,0 @@ -/* ----------------------------------------------------------------------------- - * std_string.i - * - * SWIG typemaps for std::string - * ----------------------------------------------------------------------------- */ - -%{ -#include <string> -%} - -namespace std { - %naturalvar string; - - - %insert(closprefix) %{ (declare (hide <std-string>)) %} - %nodefault string; - %rename("std-string") string; - class string { - public: - ~string() {} - }; - %extend string { - char *str; - } - %{ - #define std_string_str_get(s) ((char *)((s)->c_str())) - #define std_string_str_set(s,v) (s->assign((char *)(v))) - %} - - %typemap(typecheck) string = char *; - %typemap(typecheck) const string & = char *; - - %typemap(in) string (char * tempptr) { - if ($input == C_SCHEME_FALSE) { - $1.resize(0); - } else { - if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, - "Argument #$argnum is not a string"); - } - tempptr = SWIG_MakeString($input); - $1.assign(tempptr); - if (tempptr) SWIG_free(tempptr); - } - } - - %typemap(in) const string& ($*1_ltype temp, char *tempptr) { - - if ($input == C_SCHEME_FALSE) { - temp.resize(0); - $1 = &temp; - } else { - if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, - "Argument #$argnum is not a string"); - } - tempptr = SWIG_MakeString($input); - temp.assign(tempptr); - if (tempptr) SWIG_free(tempptr); - $1 = &temp; - } - } - - %typemap(out) string { - int size = $1.size(); - C_word *space = C_alloc (C_SIZEOF_STRING (size)); - $result = C_string (&space, size, (char *) $1.c_str()); - } - - %typemap(out) const string& { - int size = $1->size(); - C_word *space = C_alloc (C_SIZEOF_STRING (size)); - $result = C_string (&space, size, (char *) $1->c_str()); - } - - %typemap(varin) string { - if ($input == C_SCHEME_FALSE) { - $1.resize(0); - } else { - char *tempptr; - if (!C_swig_is_string ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, - "Argument #$argnum is not a string"); - } - tempptr = SWIG_MakeString($input); - $1.assign(tempptr); - if (tempptr) SWIG_free(tempptr); - } - } - - %typemap(varout) string { - int size = $1.size(); - C_word *space = C_alloc (C_SIZEOF_STRING (size)); - $result = C_string (&space, size, (char *) $1.c_str()); - } -} diff --git a/Lib/chicken/swigclosprefix.scm b/Lib/chicken/swigclosprefix.scm deleted file mode 100644 index e4bd72b71..000000000 --- a/Lib/chicken/swigclosprefix.scm +++ /dev/null @@ -1,31 +0,0 @@ -(declare (hide swig-initialize)) - -(define (swig-initialize obj initargs create) - (slot-set! obj 'swig-this - (if (memq 'swig-this initargs) - (cadr initargs) - (let ((ret (apply create initargs))) - (if (instance? ret) - (slot-ref ret 'swig-this) - ret))))) - -(define-class <swig-metaclass-$module> (<class>) (void)) - -(define-method (compute-getter-and-setter (class <swig-metaclass-$module>) slot allocator) - (if (not (memq ':swig-virtual slot)) - (call-next-method) - (let ((getter (let search-get ((lst slot)) - (if (null? lst) - #f - (if (eq? (car lst) ':swig-get) - (cadr lst) - (search-get (cdr lst)))))) - (setter (let search-set ((lst slot)) - (if (null? lst) - #f - (if (eq? (car lst) ':swig-set) - (cadr lst) - (search-set (cdr lst))))))) - (values - (lambda (o) (getter (slot-ref o 'swig-this))) - (lambda (o new) (setter (slot-ref o 'swig-this) new) new))))) diff --git a/Lib/chicken/tinyclos-multi-generic.patch b/Lib/chicken/tinyclos-multi-generic.patch deleted file mode 100644 index 2e585960e..000000000 --- a/Lib/chicken/tinyclos-multi-generic.patch +++ /dev/null @@ -1,150 +0,0 @@ -# This patch is against chicken 1.92, but it should work just fine -# with older versions of chicken. It adds support for mulit-argument -# generics, that is, generics now correctly handle adding methods -# with different lengths of specializer lists - -# This patch has been committed into the CHICKEN darcs repository, -# so chicken versions above 1.92 work fine. - -# Comments, bugs, suggestions send to chicken-users@nongnu.org - -# Patch written by John Lenz <lenz@cs.wisc.edu> - ---- tinyclos.scm.old 2005-04-05 01:13:56.000000000 -0500 -+++ tinyclos.scm 2005-04-11 16:37:23.746181489 -0500 -@@ -37,8 +37,10 @@ - - (include "parameters") - -+(cond-expand [(not chicken-compile-shared) (declare (unit tinyclos))] -+ [else] ) -+ - (declare -- (unit tinyclos) - (uses extras) - (usual-integrations) - (fixnum) -@@ -234,7 +236,10 @@ - y = C_block_item(y, 1); - } - } -- return(C_block_item(v, i + 1)); -+ if (x == C_SCHEME_END_OF_LIST && y == C_SCHEME_END_OF_LIST) -+ return(C_block_item(v, i + 1)); -+ else -+ goto mismatch; - } - else if(free_index == -1) free_index = i; - mismatch: -@@ -438,7 +443,7 @@ - (define hash-arg-list - (foreign-lambda* unsigned-int ((scheme-object args) (scheme-object svector)) " - C_word tag, h, x; -- int n, i, j; -+ int n, i, j, len = 0; - for(i = 0; args != C_SCHEME_END_OF_LIST; args = C_block_item(args, 1)) { - x = C_block_item(args, 0); - if(C_immediatep(x)) { -@@ -481,8 +486,9 @@ - default: i += 255; - } - } -+ ++len; - } -- return(i & (C_METHOD_CACHE_SIZE - 1));") ) -+ return((i + len) & (C_METHOD_CACHE_SIZE - 1));") ) - - - ; -@@ -868,13 +874,27 @@ - (##tinyclos#slot-set! - generic - 'methods -- (cons method -- (filter-in -- (lambda (m) -- (let ([ms1 (method-specializers m)] -- [ms2 (method-specializers method)] ) -- (not (every2 (lambda (x y) (eq? x y)) ms1 ms2) ) ) ) -- (##tinyclos#slot-ref generic 'methods)))) -+ (let* ([ms1 (method-specializers method)] -+ [l1 (length ms1)] ) -+ (let filter-in-method ([methods (##tinyclos#slot-ref generic 'methods)]) -+ (if (null? methods) -+ (list method) -+ (let* ([mm (##sys#slot methods 0)] -+ [ms2 (method-specializers mm)] -+ [l2 (length ms2)]) -+ (cond ((> l1 l2) -+ (cons mm (filter-in-method (##sys#slot methods 1)))) -+ ((< l1 l2) -+ (cons method methods)) -+ (else -+ (let check-method ([ms1 ms1] -+ [ms2 ms2]) -+ (cond ((and (null? ms1) (null? ms2)) -+ (cons method (##sys#slot methods 1))) ;; skip the method already in the generic -+ ((eq? (##sys#slot ms1 0) (##sys#slot ms2 0)) -+ (check-method (##sys#slot ms1 1) (##sys#slot ms2 1))) -+ (else -+ (cons mm (filter-in-method (##sys#slot methods 1))))))))))))) - (if (memq generic generic-invocation-generics) - (set! method-cache-tag (vector)) - (%entity-cache-set! generic #f) ) -@@ -925,11 +945,13 @@ - (memq (car args) generic-invocation-generics)) - (let ([proc - (method-procedure -+ ; select the first method of one argument - (let lp ([lis (generic-methods generic)]) -- (let ([tail (##sys#slot lis 1)]) -- (if (null? tail) -- (##sys#slot lis 0) -- (lp tail)) ) ) ) ] ) -+ (if (null? lis) -+ (##sys#error "Unable to find original compute-apply-generic") -+ (if (= (length (method-specializers (##sys#slot lis 0))) 1) -+ (##sys#slot lis 0) -+ (lp (##sys#slot lis 1)))))) ] ) - (lambda (args) (apply proc #f args)) ) - (let ([x (compute-apply-methods generic)] - [y ((compute-methods generic) args)] ) -@@ -946,9 +968,13 @@ - (lambda (args) - (let ([applicable - (filter-in (lambda (method) -- (every2 applicable? -- (method-specializers method) -- args)) -+ (let check-applicable ([list1 (method-specializers method)] -+ [list2 args]) -+ (cond ((null? list1) #t) -+ ((null? list2) #f) -+ (else -+ (and (applicable? (##sys#slot list1 0) (##sys#slot list2 0)) -+ (check-applicable (##sys#slot list1 1) (##sys#slot list2 1))))))) - (generic-methods generic) ) ] ) - (if (or (null? applicable) (null? (##sys#slot applicable 1))) - applicable -@@ -975,8 +1001,10 @@ - [else - (cond ((and (null? specls1) (null? specls2)) - (##sys#error "two methods are equally specific" generic)) -- ((or (null? specls1) (null? specls2)) -- (##sys#error "two methods have different number of specializers" generic)) -+ ;((or (null? specls1) (null? specls2)) -+ ; (##sys#error "two methods have different number of specializers" generic)) -+ ((null? specls1) #f) -+ ((null? specls2) #t) - ((null? args) - (##sys#error "fewer arguments than specializers" generic)) - (else -@@ -1210,7 +1238,7 @@ - (define <structure> (make-primitive-class "structure")) - (define <procedure> (make-primitive-class "procedure" <procedure-class>)) - (define <end-of-file> (make-primitive-class "end-of-file")) --(define <environment> (make-primitive-class "environment" <structure>)) ; (Benedikt insisted on this) -+(define <environment> (make-primitive-class "environment" <structure>)) - (define <hash-table> (make-primitive-class "hash-table" <structure>)) - (define <promise> (make-primitive-class "promise" <structure>)) - (define <queue> (make-primitive-class "queue" <structure>)) diff --git a/Lib/chicken/typemaps.i b/Lib/chicken/typemaps.i deleted file mode 100644 index fd587fd68..000000000 --- a/Lib/chicken/typemaps.i +++ /dev/null @@ -1,314 +0,0 @@ -/* ----------------------------------------------------------------------------- - * typemaps.i - * - * Pointer handling - * - * These mappings provide support for input/output arguments and - * common uses for C/C++ pointers. INOUT mappings allow for C/C++ - * pointer variables in addition to input/output arguments. - * ----------------------------------------------------------------------------- */ - -// INPUT typemaps. -// These remap a C pointer to be an "INPUT" value which is passed by value -// instead of reference. - -/* -The following methods can be applied to turn a pointer into a simple -"input" value. That is, instead of passing a pointer to an object, -you would use a real value instead. - - int *INPUT - short *INPUT - long *INPUT - long long *INPUT - unsigned int *INPUT - unsigned short *INPUT - unsigned long *INPUT - unsigned long long *INPUT - unsigned char *INPUT - char *INPUT - bool *INPUT - float *INPUT - double *INPUT - -To use these, suppose you had a C function like this : - - double fadd(double *a, double *b) { - return *a+*b; - } - -You could wrap it with SWIG as follows : - - %include <typemaps.i> - double fadd(double *INPUT, double *INPUT); - -or you can use the %apply directive : - - %include <typemaps.i> - %apply double *INPUT { double *a, double *b }; - double fadd(double *a, double *b); - -*/ - -// OUTPUT typemaps. These typemaps are used for parameters that -// are output only. The output value is appended to the result as -// a list element. - -/* -The following methods can be applied to turn a pointer into an "output" -value. When calling a function, no input value would be given for -a parameter, but an output value would be returned. In the case of -multiple output values, they are returned in the form of a Scheme list. - - int *OUTPUT - short *OUTPUT - long *OUTPUT - long long *OUTPUT - unsigned int *OUTPUT - unsigned short *OUTPUT - unsigned long *OUTPUT - unsigned long long *OUTPUT - unsigned char *OUTPUT - char *OUTPUT - bool *OUTPUT - float *OUTPUT - double *OUTPUT - -For example, suppose you were trying to wrap the modf() function in the -C math library which splits x into integral and fractional parts (and -returns the integer part in one of its parameters).K: - - double modf(double x, double *ip); - -You could wrap it with SWIG as follows : - - %include <typemaps.i> - double modf(double x, double *OUTPUT); - -or you can use the %apply directive : - - %include <typemaps.i> - %apply double *OUTPUT { double *ip }; - double modf(double x, double *ip); - -*/ - -//---------------------------------------------------------------------- -// -// T_OUTPUT typemap (and helper function) to return multiple argouts as -// a tuple instead of a list. -// -//---------------------------------------------------------------------- - -// Simple types - -%define INOUT_TYPEMAP(type_, from_scheme, to_scheme, checker, convtype, storage_) - -%typemap(in) type_ *INPUT($*1_ltype temp), type_ &INPUT($*1_ltype temp) -%{ if (!checker ($input)) { - swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, "Argument #$argnum is not of type 'type_'"); - } - temp = ($*1_ltype) from_scheme ($input); - $1 = &temp; %} - -%typemap(typecheck) type_ *INPUT = type_; -%typemap(typecheck) type_ &INPUT = type_; - -%typemap(in, numinputs=0) type_ *OUTPUT($*1_ltype temp), type_ &OUTPUT($*1_ltype temp) -" $1 = &temp;" - -#if "storage_" == "0" - -%typemap(argout) type_ *OUTPUT, type_ &OUTPUT -%{ - if ($1 == NULL) { - swig_barf (SWIG_BARF1_ARGUMENT_NULL, "Argument #$argnum must be non-null"); - } - SWIG_APPEND_VALUE(to_scheme (convtype (*$1))); -%} - -#else - -%typemap(argout) type_ *OUTPUT, type_ &OUTPUT -%{ - { - C_word *known_space = C_alloc(storage_); - if ($1 == NULL) { - swig_barf (SWIG_BARF1_ARGUMENT_NULL, "Variable '$1' must be non-null"); - } - SWIG_APPEND_VALUE(to_scheme (&known_space, convtype (*$1))); - } -%} - -#endif - -%enddef - -INOUT_TYPEMAP(int, C_num_to_int, C_fix, C_swig_is_number, (int), 0); -INOUT_TYPEMAP(enum SWIGTYPE, C_num_to_int, C_fix, C_swig_is_number, (int), 0); -INOUT_TYPEMAP(short, C_num_to_int, C_fix, C_swig_is_number, (int), 0); -INOUT_TYPEMAP(long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM); -INOUT_TYPEMAP(long long, C_num_to_long, C_long_to_num, C_swig_is_long, (long), C_SIZEOF_FLONUM); -INOUT_TYPEMAP(unsigned int, C_num_to_unsigned_int, C_unsigned_int_to_num, C_swig_is_number, (int), C_SIZEOF_FLONUM); -INOUT_TYPEMAP(unsigned short, C_num_to_unsigned_int, C_fix, C_swig_is_number, (unsigned int), 0); -INOUT_TYPEMAP(unsigned long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM); -INOUT_TYPEMAP(unsigned long long, C_num_to_unsigned_long, C_unsigned_long_to_num, C_swig_is_long, (unsigned long), C_SIZEOF_FLONUM); -INOUT_TYPEMAP(unsigned char, C_character_code, C_make_character, C_swig_is_char, (unsigned int), 0); -INOUT_TYPEMAP(signed char, C_character_code, C_make_character, C_swig_is_char, (int), 0); -INOUT_TYPEMAP(char, C_character_code, C_make_character, C_swig_is_char, (char), 0); -INOUT_TYPEMAP(bool, C_truep, C_mk_bool, C_swig_is_bool, (bool), 0); -INOUT_TYPEMAP(float, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM); -INOUT_TYPEMAP(double, C_c_double, C_flonum, C_swig_is_number, (double), C_SIZEOF_FLONUM); - -// INOUT -// Mappings for an argument that is both an input and output -// parameter - -/* -The following methods can be applied to make a function parameter both -an input and output value. This combines the behavior of both the -"INPUT" and "OUTPUT" methods described earlier. Output values are -returned in the form of a CHICKEN tuple. - - int *INOUT - short *INOUT - long *INOUT - long long *INOUT - unsigned int *INOUT - unsigned short *INOUT - unsigned long *INOUT - unsigned long long *INOUT - unsigned char *INOUT - char *INOUT - bool *INOUT - float *INOUT - double *INOUT - -For example, suppose you were trying to wrap the following function : - - void neg(double *x) { - *x = -(*x); - } - -You could wrap it with SWIG as follows : - - %include <typemaps.i> - void neg(double *INOUT); - -or you can use the %apply directive : - - %include <typemaps.i> - %apply double *INOUT { double *x }; - void neg(double *x); - -As well, you can wrap variables with : - - %include <typemaps.i> - %apply double *INOUT { double *y }; - extern double *y; - -Unlike C, this mapping does not directly modify the input value (since -this makes no sense in CHICKEN). Rather, the modified input value shows -up as the return value of the function. Thus, to apply this function -to a CHICKEN variable you might do this : - - x = neg(x) - -Note : previous versions of SWIG used the symbol 'BOTH' to mark -input/output arguments. This is still supported, but will be slowly -phased out in future releases. - -*/ - -%typemap(in) int *INOUT = int *INPUT; -%typemap(in) enum SWIGTYPE *INOUT = enum SWIGTYPE *INPUT; -%typemap(in) short *INOUT = short *INPUT; -%typemap(in) long *INOUT = long *INPUT; -%typemap(in) long long *INOUT = long long *INPUT; -%typemap(in) unsigned *INOUT = unsigned *INPUT; -%typemap(in) unsigned short *INOUT = unsigned short *INPUT; -%typemap(in) unsigned long *INOUT = unsigned long *INPUT; -%typemap(in) unsigned long long *INOUT = unsigned long long *INPUT; -%typemap(in) unsigned char *INOUT = unsigned char *INPUT; -%typemap(in) char *INOUT = char *INPUT; -%typemap(in) bool *INOUT = bool *INPUT; -%typemap(in) float *INOUT = float *INPUT; -%typemap(in) double *INOUT = double *INPUT; - -%typemap(in) int &INOUT = int &INPUT; -%typemap(in) enum SWIGTYPE &INOUT = enum SWIGTYPE &INPUT; -%typemap(in) short &INOUT = short &INPUT; -%typemap(in) long &INOUT = long &INPUT; -%typemap(in) long long &INOUT = long long &INPUT; -%typemap(in) unsigned &INOUT = unsigned &INPUT; -%typemap(in) unsigned short &INOUT = unsigned short &INPUT; -%typemap(in) unsigned long &INOUT = unsigned long &INPUT; -%typemap(in) unsigned long long &INOUT = unsigned long long &INPUT; -%typemap(in) unsigned char &INOUT = unsigned char &INPUT; -%typemap(in) char &INOUT = char &INPUT; -%typemap(in) bool &INOUT = bool &INPUT; -%typemap(in) float &INOUT = float &INPUT; -%typemap(in) double &INOUT = double &INPUT; - -%typemap(argout) int *INOUT = int *OUTPUT; -%typemap(argout) enum SWIGTYPE *INOUT = enum SWIGTYPE *OUTPUT; -%typemap(argout) short *INOUT = short *OUTPUT; -%typemap(argout) long *INOUT = long *OUTPUT; -%typemap(argout) long long *INOUT = long long *OUTPUT; -%typemap(argout) unsigned *INOUT = unsigned *OUTPUT; -%typemap(argout) unsigned short *INOUT = unsigned short *OUTPUT; -%typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT; -%typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT; -%typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT; -%typemap(argout) bool *INOUT = bool *OUTPUT; -%typemap(argout) float *INOUT = float *OUTPUT; -%typemap(argout) double *INOUT = double *OUTPUT; - -%typemap(argout) int &INOUT = int &OUTPUT; -%typemap(argout) enum SWIGTYPE &INOUT = enum SWIGTYPE &OUTPUT; -%typemap(argout) short &INOUT = short &OUTPUT; -%typemap(argout) long &INOUT = long &OUTPUT; -%typemap(argout) long long &INOUT = long long &OUTPUT; -%typemap(argout) unsigned &INOUT = unsigned &OUTPUT; -%typemap(argout) unsigned short &INOUT = unsigned short &OUTPUT; -%typemap(argout) unsigned long &INOUT = unsigned long &OUTPUT; -%typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT; -%typemap(argout) unsigned char &INOUT = unsigned char &OUTPUT; -%typemap(argout) char &INOUT = char &OUTPUT; -%typemap(argout) bool &INOUT = bool &OUTPUT; -%typemap(argout) float &INOUT = float &OUTPUT; -%typemap(argout) double &INOUT = double &OUTPUT; - -/* Overloading information */ - -%typemap(typecheck) double *INOUT = double; -%typemap(typecheck) bool *INOUT = bool; -%typemap(typecheck) char *INOUT = char; -%typemap(typecheck) signed char *INOUT = signed char; -%typemap(typecheck) unsigned char *INOUT = unsigned char; -%typemap(typecheck) unsigned long *INOUT = unsigned long; -%typemap(typecheck) unsigned long long *INOUT = unsigned long long; -%typemap(typecheck) unsigned short *INOUT = unsigned short; -%typemap(typecheck) unsigned int *INOUT = unsigned int; -%typemap(typecheck) long *INOUT = long; -%typemap(typecheck) long long *INOUT = long long; -%typemap(typecheck) short *INOUT = short; -%typemap(typecheck) int *INOUT = int; -%typemap(typecheck) enum SWIGTYPE *INOUT = enum SWIGTYPE; -%typemap(typecheck) float *INOUT = float; - -%typemap(typecheck) double &INOUT = double; -%typemap(typecheck) bool &INOUT = bool; -%typemap(typecheck) char &INOUT = char; -%typemap(typecheck) signed char &INOUT = signed char; -%typemap(typecheck) unsigned char &INOUT = unsigned char; -%typemap(typecheck) unsigned long &INOUT = unsigned long; -%typemap(typecheck) unsigned long long &INOUT = unsigned long long; -%typemap(typecheck) unsigned short &INOUT = unsigned short; -%typemap(typecheck) unsigned int &INOUT = unsigned int; -%typemap(typecheck) long &INOUT = long; -%typemap(typecheck) long long &INOUT = long long; -%typemap(typecheck) short &INOUT = short; -%typemap(typecheck) int &INOUT = int; -%typemap(typecheck) enum SWIGTYPE &INOUT = enum SWIGTYPE; -%typemap(typecheck) float &INOUT = float; diff --git a/Lib/clisp/clisp.swg b/Lib/clisp/clisp.swg deleted file mode 100644 index e1d330cb3..000000000 --- a/Lib/clisp/clisp.swg +++ /dev/null @@ -1,32 +0,0 @@ -/* ----------------------------------------------------------------------------- - * clisp.swg - * ----------------------------------------------------------------------------- */ - -/* Define a C preprocessor symbol that can be used in interface files - to distinguish between the SWIG language modules. */ - -#define SWIG_CLISP - -/* Typespecs for basic types. */ - -%typemap(in) void "NIL"; - -%typemap(in) char "character"; -%typemap(in) char * "ffi:c-string"; -%typemap(in) unsigned char "ffi:uchar"; -%typemap(in) signed char "ffi:char"; - -%typemap(in) short "ffi:short"; -%typemap(in) signed short "ffi:short"; -%typemap(in) unsigned short "ffi:ushort"; - -%typemap(in) int "ffi:int"; -%typemap(in) signed int "ffi:int"; -%typemap(in) unsigned int "ffi:uint"; - -%typemap(in) long "ffi:long"; -%typemap(in) signed long "ffi:long"; -%typemap(in) unsigned long "ffi:ulong"; - -%typemap(in) float "SINGLE-FLOAT"; -%typemap(in) double "DOUBLE-FLOAT"; diff --git a/Lib/csharp/std_auto_ptr.i b/Lib/csharp/std_auto_ptr.i index d7e5f167e..1d91c9872 100644 --- a/Lib/csharp/std_auto_ptr.i +++ b/Lib/csharp/std_auto_ptr.i @@ -1,5 +1,5 @@ /* - The typemaps here allow to handle functions returning std::auto_ptr<>, + The typemaps here allow handling functions returning std::auto_ptr<>, which is the most common use of this type. If you have functions taking it as parameter, these typemaps can't be used for them and you need to do something else (e.g. use shared_ptr<> which SWIG supports fully). diff --git a/Lib/d/doperators.swg b/Lib/d/doperators.swg index 0cb63533c..0a82a6cb4 100644 --- a/Lib/d/doperators.swg +++ b/Lib/d/doperators.swg @@ -58,7 +58,7 @@ template SwigOperatorDefinitions() { %rename(opCall) *::operator(); -// !a is not overrideable in D1. +// !a is not overridable in D1. %ignoreoperator(LNOT) operator!; // opCmp is used in D. @@ -71,7 +71,7 @@ template SwigOperatorDefinitions() { // a != b is rewritten as !a.opEquals(b) in D. %ignoreoperator(NOTEQUAL) operator!=; -// The logic operators are not overrideable in D. +// The logic operators are not overridable in D. %ignoreoperator(LAND) operator&&; %ignoreoperator(LOR) operator||; @@ -198,7 +198,7 @@ mixin template SwigOperatorDefinitions() { // a != b is rewritten as !a.opEquals(b) in D. %ignoreoperator(NOTEQUAL) operator!=; -// The logic operators are not overrideable in D. +// The logic operators are not overridable in D. %ignoreoperator(LAND) operator&&; %ignoreoperator(LOR) operator||; diff --git a/Lib/exception.i b/Lib/exception.i index ee9ce9bc6..7508b409b 100644 --- a/Lib/exception.i +++ b/Lib/exception.i @@ -12,10 +12,20 @@ %insert("runtime") "swigerrors.swg" -#ifdef SWIGPHP7 +#ifdef SWIGPHP %{ -#include "zend_exceptions.h" -#define SWIG_exception(code, msg) do { zend_throw_exception(NULL, (char*)msg, code); goto thrown; } while (0) +#if PHP_MAJOR >= 8 +# define SWIG_HANDLE_VALUE_ERROR_FOR_PHP8 code == SWIG_ValueError ? zend_ce_value_error : +#else +# define SWIG_HANDLE_VALUE_ERROR_FOR_PHP8 +#endif +#define SWIG_exception(code, msg) do { zend_throw_exception( \ + code == SWIG_TypeError ? zend_ce_type_error : \ + SWIG_HANDLE_VALUE_ERROR_FOR_PHP8 \ + code == SWIG_DivisionByZero ? zend_ce_division_by_zero_error : \ + code == SWIG_SyntaxError ? zend_ce_parse_error : \ + code == SWIG_OverflowError ? zend_ce_arithmetic_error : \ + NULL, msg, code); SWIG_fail; } while (0) %} #endif diff --git a/Lib/go/goruntime.swg b/Lib/go/goruntime.swg index 269a4eefd..c3401b1a8 100644 --- a/Lib/go/goruntime.swg +++ b/Lib/go/goruntime.swg @@ -23,46 +23,38 @@ static void* Swig_malloc(int c) { %} -#if SWIGGO_CGO %insert(cgo_comment_typedefs) %{ #include <stdint.h> %} -#endif #if SWIGGO_INTGO_SIZE == 32 %insert(runtime) %{ typedef int intgo; typedef unsigned int uintgo; %} -#if SWIGGO_CGO %insert(cgo_comment_typedefs) %{ typedef int intgo; typedef unsigned int uintgo; %} -#endif #elif SWIGGO_INTGO_SIZE == 64 %insert(runtime) %{ typedef long long intgo; typedef unsigned long long uintgo; %} -#if SWIGGO_CGO %insert(cgo_comment_typedefs) %{ typedef long long intgo; typedef unsigned long long uintgo; %} -#endif #else %insert(runtime) %{ typedef ptrdiff_t intgo; typedef size_t uintgo; %} -#if SWIGGO_CGO %insert(cgo_comment_typedefs) %{ typedef ptrdiff_t intgo; typedef size_t uintgo; %} #endif -#endif #ifndef SWIGGO_GCCGO // Set the host compiler struct attribute that will be @@ -89,8 +81,6 @@ typedef struct { void* array; intgo len; intgo cap; } _goslice_; %} -#ifdef SWIGGO_CGO - %insert(cgo_comment_typedefs) %{ typedef struct { char *p; intgo n; } _gostring_; @@ -98,91 +88,7 @@ typedef struct { void* array; intgo len; intgo cap; } _goslice_; %} -#endif - -#ifndef SWIGGO_GCCGO -/* Boilerplate for C/C++ code when using 6g/8g. This code is compiled - with gcc. */ -%insert(runtime) %{ - -#define swiggo_size_assert_eq(x, y, name) typedef char name[(x-y)*(x-y)*-2+1]; -#define swiggo_size_assert(t, n) swiggo_size_assert_eq(sizeof(t), n, swiggo_sizeof_##t##_is_not_##n) - -swiggo_size_assert(char, 1) -swiggo_size_assert(short, 2) -swiggo_size_assert(int, 4) -typedef long long swiggo_long_long; -swiggo_size_assert(swiggo_long_long, 8) -swiggo_size_assert(float, 4) -swiggo_size_assert(double, 8) - -#ifdef __cplusplus -extern "C" { -#endif -extern void crosscall2(void (*fn)(void *, int), void *, int); -extern char* _cgo_topofstack(void) __attribute__ ((weak)); -extern void _cgo_allocate(void *, int); -extern void _cgo_panic(void *, int); -#ifdef __cplusplus -} -#endif - -static char *_swig_topofstack() { - if (_cgo_topofstack) { - return _cgo_topofstack(); - } else { - return 0; - } -} - -static void _swig_gopanic(const char *p) { - struct { - const char *p; - } SWIGSTRUCTPACKED a; - a.p = p; - crosscall2(_cgo_panic, &a, (int) sizeof a); -} - -%} - -#if !SWIGGO_CGO - -/* This is here for backward compatibility, but it will not work - with Go 1.5 or later. Do not use it in new code. */ -%insert(runtime) %{ - -static void *_swig_goallocate(size_t len) { - struct { - size_t len; - void *ret; - } SWIGSTRUCTPACKED a; - a.len = len; - crosscall2(_cgo_allocate, &a, (int) sizeof a); - return a.ret; -} - -%} - -#endif - -#if !SWIGGO_CGO - -/* Boilerplate for C code when using 6g/8g. This code is compiled - with 6c/8c. */ -%insert(gc_header) %{ -#include "runtime.h" -#include "cgocall.h" - -#pragma dataflag 16 -static void *cgocall = runtime·cgocall; -#pragma dataflag 16 -void *·_cgo_runtime_cgocall = &cgocall; - -%} - -#endif - -#else +#ifdef SWIGGO_GCCGO /* Boilerplate for C/C++ code when using gccgo. */ %insert(runtime) %{ @@ -201,115 +107,12 @@ extern void _cgo_panic(const char *); #define _swig_gopanic _cgo_panic %} -#if !SWIGGO_CGO - -%insert(runtime) %{ - -/* Implementations of SwigCgocall and friends for different versions - of gccgo. The Go code will call these functions using C names with - a prefix of the module name. The implementations here call the - routine in libgo. The routines to call vary depending on the gccgo - version. We assume that the version of gcc used to compile this - file is the same as the version of gccgo. */ - -#ifdef __cplusplus -extern "C" { -#endif - -#define SWIG_GCC_VERSION \ - (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) - -#if SWIG_GCC_VERSION < 40700 -#define SwigDoCgocall() -#define SwigDoCgocallDone() -#define SwigDoCgocallBack() -#define SwigDoCgocallBackDone() -#elif SWIG_GCC_VERSION == 40700 -void SwigDoCgocall(void) __asm__("libgo_syscall.syscall.Entersyscall"); -void SwigDoCgocallDone(void) __asm__("libgo_syscall.syscall.Exitsyscall"); -void SwigDoCgocallBack(void) __asm__("libgo_syscall.syscall.Exitsyscall"); -void SwigDoCgocallBackDone(void) __asm__("libgo_syscall.syscall.Entersyscall"); -#else -void SwigDoCgocall(void) __asm__("syscall.Cgocall"); -void SwigDoCgocallDone(void) __asm__("syscall.CgocallDone"); -void SwigDoCgocallBack(void) __asm__("syscall.CgocallBack"); -void SwigDoCgocallBackDone(void) __asm__("syscall.CgocallBackDone"); -#endif - -#define SWIGSTRINGIFY2(s) #s -#define SWIGSTRINGIFY(s) SWIGSTRINGIFY2(s) - -void SwigCgocall() - __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocall"); -void SwigCgocall() { - SwigDoCgocall(); -} - -void SwigCgocallDone() - __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocallDone"); -void SwigCgocallDone() { - SwigDoCgocallDone(); -} - -void SwigCgocallBack() - __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocallBack"); -void SwigCgocallBack() { - SwigDoCgocallBack(); -} - -void SwigCgocallBackDone() - __asm__(SWIGSTRINGIFY(SWIGGO_PREFIX) ".SwigCgocallBackDone"); -void SwigCgocallBackDone() { - SwigDoCgocallBackDone(); -} - -#undef SWIGSTRINGIFY -#undef SWIGSTRINGIFY2 - -#ifdef __cplusplus -} -#endif - -%} - -#endif - -#endif - -#if !SWIGGO_CGO - -%insert(runtime) %{ - -/* This is here for backward compatibility, but it will not work - with Go 1.5 or later. Do not use it in new code. */ -static _gostring_ _swig_makegostring(const char *p, size_t l) { - _gostring_ ret; - ret.p = (char*)_swig_goallocate(l + 1); - memcpy(ret.p, p, l); - ret.n = l; - return ret; -} - -%} - #endif -%insert(runtime) %{ - -#define SWIG_contract_assert(expr, msg) \ - if (!(expr)) { _swig_gopanic(msg); } else -%} - #ifndef SWIGGO_GCCGO %go_import("unsafe", _ "runtime/cgo") -#if !SWIGGO_CGO -%insert(go_header) %{ -var _cgo_runtime_cgocall func(unsafe.Pointer, uintptr) -%} -#endif - #else %go_import("syscall", "unsafe") diff --git a/Lib/guile/typemaps.i b/Lib/guile/typemaps.i index cfccced88..84a754d8b 100644 --- a/Lib/guile/typemaps.i +++ b/Lib/guile/typemaps.i @@ -378,26 +378,26 @@ typedef unsigned long SCM; #define %argument_fail(code, type, name, argn) scm_wrong_type_arg((char *) FUNC_NAME, argn, $input); #define %as_voidptr(ptr) (void*)(ptr) -%typemap(in) SWIGTYPE (CLASS::*) { - int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($type),$descriptor); +%typemap(in) SWIGTYPE (CLASS::*) { + int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($1), $descriptor); if (!SWIG_IsOK(res)) { - %argument_fail(res,"$type",$symname, $argnum); + %argument_fail(res,"$type",$symname, $argnum); } } %typemap(out,noblock=1) SWIGTYPE (CLASS::*) { - %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor)); + %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($1), $descriptor)); } %typemap(varin) SWIGTYPE (CLASS::*) { - int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($type), $descriptor); + int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($1), $descriptor); if (!SWIG_IsOK(res)) { scm_wrong_type_arg((char *) FUNC_NAME, 1, $input); } } %typemap(varout,noblock=1) SWIGTYPE (CLASS::*) { - %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor)); + %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($1), $descriptor)); } /* ------------------------------------------------------------ diff --git a/Lib/java/arrays_java.i b/Lib/java/arrays_java.i index dd38438a3..a57da64b4 100644 --- a/Lib/java/arrays_java.i +++ b/Lib/java/arrays_java.i @@ -104,7 +104,7 @@ JAVA_ARRAYS_DECL(int, jint, Int, Int) /* int[] */ JAVA_ARRAYS_DECL(unsigned int, jlong, Long, Uint) /* unsigned int[] */ JAVA_ARRAYS_DECL(long, jint, Int, Long) /* long[] */ JAVA_ARRAYS_DECL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */ -JAVA_ARRAYS_DECL(jlong, jlong, Long, Longlong) /* long long[] */ +JAVA_ARRAYS_DECL(long long, jlong, Long, Longlong) /* long long[] */ JAVA_ARRAYS_DECL(float, jfloat, Float, Float) /* float[] */ JAVA_ARRAYS_DECL(double, jdouble, Double, Double) /* double[] */ @@ -128,7 +128,7 @@ JAVA_ARRAYS_IMPL(int, jint, Int, Int) /* int[] */ JAVA_ARRAYS_IMPL(unsigned int, jlong, Long, Uint) /* unsigned int[] */ JAVA_ARRAYS_IMPL(long, jint, Int, Long) /* long[] */ JAVA_ARRAYS_IMPL(unsigned long, jlong, Long, Ulong) /* unsigned long[] */ -JAVA_ARRAYS_IMPL(jlong, jlong, Long, Longlong) /* long long[] */ +JAVA_ARRAYS_IMPL(long long, jlong, Long, Longlong) /* long long[] */ JAVA_ARRAYS_IMPL(float, jfloat, Float, Float) /* float[] */ JAVA_ARRAYS_IMPL(double, jdouble, Double, Double) /* double[] */ diff --git a/Lib/java/javahead.swg b/Lib/java/javahead.swg index 2e10254f3..1fc327909 100644 --- a/Lib/java/javahead.swg +++ b/Lib/java/javahead.swg @@ -30,18 +30,6 @@ #endif %insert(runtime) %{ -/* Fix for jlong on some versions of gcc on Windows */ -#if defined(__GNUC__) && !defined(__INTEL_COMPILER) - typedef long long __int64; -#endif - -/* Fix for jlong on 64-bit x86 Solaris */ -#if defined(__x86_64) -# ifdef _LP64 -# undef _LP64 -# endif -#endif - #include <jni.h> #include <stdlib.h> #include <string.h> diff --git a/Lib/java/std_auto_ptr.i b/Lib/java/std_auto_ptr.i index 9b3cd7315..69ac2841f 100644 --- a/Lib/java/std_auto_ptr.i +++ b/Lib/java/std_auto_ptr.i @@ -1,5 +1,5 @@ /* - The typemaps here allow to handle functions returning std::auto_ptr<>, + The typemaps here allow handling functions returning std::auto_ptr<>, which is the most common use of this type. If you have functions taking it as parameter, these typemaps can't be used for them and you need to do something else (e.g. use shared_ptr<> which SWIG supports fully). diff --git a/Lib/java/swiginterface.i b/Lib/java/swiginterface.i index 334464157..0a0f7806a 100644 --- a/Lib/java/swiginterface.i +++ b/Lib/java/swiginterface.i @@ -28,7 +28,7 @@ } %typemap(javaout) CTYPE *const& { long cPtr = $jnicall; - return (cPtr == 0) ? null : ($javainterfacename)new $javaclassname(cPtr, $owner); + return (cPtr == 0) ? null : ($*javainterfacename)new $*javaclassname(cPtr, $owner); } %typemap(javadirectorin) CTYPE "($&javainterfacename)new $&javaclassname($jniinput, true)" diff --git a/Lib/javascript/jsc/arrays_javascript.i b/Lib/javascript/jsc/arrays_javascript.i index b9199d86b..713b7ef23 100644 --- a/Lib/javascript/jsc/arrays_javascript.i +++ b/Lib/javascript/jsc/arrays_javascript.i @@ -21,34 +21,39 @@ * fs = example.FiddleSticks; * ----------------------------------------------------------------------------- */ -%fragment("SWIG_JSCGetIntProperty", "header", fragment=SWIG_AsVal_frag(int)) {} + +%fragment("SWIG_JSCGetIntProperty", "header", fragment=SWIG_AsVal_frag(int)) {} %fragment("SWIG_JSCGetNumberProperty", "header", fragment=SWIG_AsVal_frag(double)) {} +%fragment("SWIG_JSCOutInt", "header", fragment=SWIG_From_frag(int)) {} +%fragment("SWIG_JSCOutNumber", "header", fragment=SWIG_From_frag(double)) {} + +%define JAVASCRIPT_ARRAYS_IN_DECL(NAME, CTYPE, ANY, ANYLENGTH) -%typemap(in, fragment="SWIG_JSCGetIntProperty") int[], int[ANY] - (int length = 0, JSObjectRef array, JSValueRef jsvalue, int i = 0, int res = 0, $*1_ltype temp) { +%typemap(in, fragment=NAME) CTYPE[ANY] { if (JSValueIsObject(context, $input)) { + int i; // Convert into Array - array = JSValueToObject(context, $input, NULL); + JSObjectRef array = JSValueToObject(context, $input, NULL); - length = $1_dim0; + int length = ANYLENGTH; $1 = ($*1_ltype *)malloc(sizeof($*1_ltype) * length); // Get each element from array for (i = 0; i < length; i++) { - jsvalue = JSObjectGetPropertyAtIndex(context, array, i, NULL); + JSValueRef jsvalue = JSObjectGetPropertyAtIndex(context, array, i, NULL); + $*1_ltype temp; // Get primitive value from JSObject - res = SWIG_AsVal(int)(jsvalue, &temp); + int res = SWIG_AsVal(CTYPE)(jsvalue, &temp); if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double"); } arg$argnum[i] = temp; } - } else { @@ -56,68 +61,34 @@ } } -%typemap(freearg) int[], int[ANY] { +%typemap(freearg) CTYPE[ANY] { free($1); } -%typemap(out, fragment=SWIG_From_frag(int)) int[], int[ANY] (int length = 0, int i = 0) -{ - length = $1_dim0; +%enddef + +%define JAVASCRIPT_ARRAYS_OUT_DECL(NAME, CTYPE) + +%typemap(out, fragment=NAME) CTYPE[ANY] { + int length = $1_dim0; JSValueRef values[length]; + int i; for (i = 0; i < length; i++) { - values[i] = SWIG_From(int)($1[i]); + values[i] = SWIG_From(CTYPE)($1[i]); } $result = JSObjectMakeArray(context, length, values, NULL); } -%typemap(in, fragment="SWIG_JSCGetNumberProperty") double[], double[ANY] - (int length = 0, JSObjectRef array, JSValueRef jsvalue, int i = 0, int res = 0, $*1_ltype temp) { - if (JSValueIsObject(context, $input)) - { - // Convert into Array - array = JSValueToObject(context, $input, NULL); +%enddef - length = $1_dim0; - - $1 = ($*1_ltype *)malloc(sizeof($*1_ltype) * length); +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetIntProperty", int, , SWIGJSC_ArrayLength(context, array)) +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetIntProperty", int, ANY, $1_dim0) +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetNumberProperty", double, , SWIGJSC_ArrayLength(context, array)) +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetNumberProperty", double, ANY, $1_dim0) - // Get each element from array - for (i = 0; i < length; i++) - { - jsvalue = JSObjectGetPropertyAtIndex(context, array, i, NULL); +JAVASCRIPT_ARRAYS_OUT_DECL("SWIG_JSCOutInt", int) +JAVASCRIPT_ARRAYS_OUT_DECL("SWIG_JSCOutNumber", double) - // Get primitive value from JSObject - res = SWIG_AsVal(double)(jsvalue, &temp); - if (!SWIG_IsOK(res)) - { - SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double"); - } - arg$argnum[i] = temp; - } - - } - else - { - SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef"); - } -} - -%typemap(freearg) double[], double[ANY] { - free($1); -} - -%typemap(out, fragment=SWIG_From_frag(double)) double[], double[ANY] (int length = 0, int i = 0) -{ - length = $1_dim0; - JSValueRef values[length]; - - for (i = 0; i < length; i++) - { - values[i] = SWIG_From(double)($1[i]); - } - - $result = JSObjectMakeArray(context, length, values, NULL); -} diff --git a/Lib/javascript/jsc/javascriptinit.swg b/Lib/javascript/jsc/javascriptinit.swg index 8df5488b0..b0138b39a 100644 --- a/Lib/javascript/jsc/javascriptinit.swg +++ b/Lib/javascript/jsc/javascriptinit.swg @@ -1,19 +1,16 @@ %insert(init) %{ SWIGRUNTIME void -SWIG_JSC_SetModule(void *clientdata, swig_module_info *swig_module) { - JSGlobalContextRef context; +SWIG_JSC_SetModule(JSGlobalContextRef context, swig_module_info *swig_module) { JSObjectRef globalObject; JSStringRef moduleName; JSClassDefinition classDef; JSClassRef classRef; JSObjectRef object; - if(clientdata == 0){ + if(context == 0){ return; } - context = (JSGlobalContextRef)clientdata; - globalObject = JSContextGetGlobalObject(context); moduleName = JSStringCreateWithUTF8CString("swig_module_info_data"); @@ -29,19 +26,16 @@ SWIG_JSC_SetModule(void *clientdata, swig_module_info *swig_module) { JSStringRelease(moduleName); } SWIGRUNTIME swig_module_info * -SWIG_JSC_GetModule(void *clientdata) { - JSGlobalContextRef context; +SWIG_JSC_GetModule(JSGlobalContextRef context) { JSObjectRef globalObject; JSStringRef moduleName; JSValueRef value; JSObjectRef object; - if(clientdata == 0){ + if(context == 0){ return 0; } - context = (JSGlobalContextRef)clientdata; - globalObject = JSContextGetGlobalObject(context); moduleName = JSStringCreateWithUTF8CString("swig_module_info_data"); @@ -59,6 +53,7 @@ SWIG_JSC_GetModule(void *clientdata) { #define SWIG_GetModule(clientdata) SWIG_JSC_GetModule(clientdata) #define SWIG_SetModule(clientdata, pointer) SWIG_JSC_SetModule(clientdata, pointer) +#define SWIG_INIT_CLIENT_DATA_TYPE JSGlobalContextRef %} %insert(init) "swiginit.swg" @@ -76,7 +71,7 @@ extern "C" { #endif bool SWIGJSC_INIT (JSGlobalContextRef context, JSObjectRef *exports) { - SWIG_InitializeModule((void*)context); + SWIG_InitializeModule(context); %} /* ----------------------------------------------------------------------------- diff --git a/Lib/javascript/jsc/javascriptrun.swg b/Lib/javascript/jsc/javascriptrun.swg index 26c440244..d092ea4ab 100644 --- a/Lib/javascript/jsc/javascriptrun.swg +++ b/Lib/javascript/jsc/javascriptrun.swg @@ -117,27 +117,25 @@ SWIGRUNTIME int SWIG_JSC_ConvertInstancePtr(JSContextRef context, JSObjectRef ob SwigPrivData *cdata; cdata = (SwigPrivData *) JSObjectGetPrivate(objRef); - if(cdata == NULL) { + if (cdata == NULL) { return SWIG_ERROR; } - if(cdata->info != info) { - bool type_valid = false; - swig_cast_info *t = info->cast; - while(t != NULL) { - if(t->type == cdata->info) { - type_valid = true; - break; - } - t = t->next; - } - if(!type_valid) { - return SWIG_TypeError; + assert(ptr); + *ptr = NULL; + if (cdata->info == info) { + *ptr = cdata->swigCObject; + } else { + swig_cast_info *tc = SWIG_TypeCheckStruct(cdata->info, info); + if (tc) { + int newmemory = 0; + *ptr = SWIG_TypeCast(tc, cdata->swigCObject, &newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + } else { + return SWIG_ERROR; } } - *ptr = cdata->swigCObject; - - if(flags & SWIG_POINTER_DISOWN) { + if (flags & SWIG_POINTER_DISOWN) { cdata->swigCMemOwn = false; } diff --git a/Lib/javascript/jsc/javascriptruntime.swg b/Lib/javascript/jsc/javascriptruntime.swg index 8f8390890..a626390cc 100644 --- a/Lib/javascript/jsc/javascriptruntime.swg +++ b/Lib/javascript/jsc/javascriptruntime.swg @@ -11,6 +11,7 @@ #include <string.h> #include <errno.h> #include <limits.h> +#include <assert.h> %} %insert(runtime) "swigrun.swg"; /* SWIG API */ diff --git a/Lib/javascript/v8/arrays_javascript.i b/Lib/javascript/v8/arrays_javascript.i index 22b50be8f..6dc7e4b9b 100644 --- a/Lib/javascript/v8/arrays_javascript.i +++ b/Lib/javascript/v8/arrays_javascript.i @@ -21,105 +21,66 @@ * fs = example.FiddleSticks; * ----------------------------------------------------------------------------- */ -%fragment("SWIG_JSCGetIntProperty", "header", fragment=SWIG_AsVal_frag(int)) {} + +%fragment("SWIG_JSCGetIntProperty", "header", fragment=SWIG_AsVal_frag(int)) {} %fragment("SWIG_JSCGetNumberProperty", "header", fragment=SWIG_AsVal_frag(double)) {} +%fragment("SWIG_JSCOutInt", "header", fragment=SWIG_From_frag(int)) {} +%fragment("SWIG_JSCOutNumber", "header", fragment=SWIG_From_frag(double)) {} + +%define JAVASCRIPT_ARRAYS_IN_DECL(NAME, CTYPE, ANY, ANYLENGTH) -%typemap(in, fragment="SWIG_JSCGetIntProperty") int[], int[ANY] - (int length = 0, v8::Local<v8::Array> array, v8::Local<v8::Value> jsvalue, int i = 0, int res = 0, $*1_ltype temp) { - if ($input->IsArray()) - { +%typemap(in, fragment=NAME) CTYPE[ANY] { + if ($input->IsArray()) { // Convert into Array - array = v8::Local<v8::Array>::Cast($input); + v8::Local<v8::Array> array = v8::Local<v8::Array>::Cast($input); - length = $1_dim0; + int length = ANYLENGTH; - $1 = ($*1_ltype *)malloc(sizeof($*1_ltype) * length); + $1 = ($*1_ltype *)malloc(sizeof($*1_ltype) * length); // Get each element from array - for (i = 0; i < length; i++) - { - jsvalue = array->Get(i); + for (int i = 0; i < length; i++) { + v8::Local<v8::Value> jsvalue = SWIGV8_ARRAY_GET(array, i); + $*1_ltype temp; // Get primitive value from JSObject - res = SWIG_AsVal(int)(jsvalue, &temp); - if (!SWIG_IsOK(res)) - { + int res = SWIG_AsVal(CTYPE)(jsvalue, &temp); + if (!SWIG_IsOK(res)) { SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double"); } arg$argnum[i] = temp; } - - } - else - { - SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef"); + } else { + SWIG_exception_fail(SWIG_ERROR, "$input is not an array"); } } -%typemap(freearg) int[], int[ANY] { - free($1); +%typemap(freearg) CTYPE[ANY] { + free($1); } -%typemap(out, fragment=SWIG_From_frag(int)) int[], int[ANY] (int length = 0, int i = 0) -{ - length = $1_dim0; - v8::Local<v8::Array> array = v8::Array::New(length); - - for (i = 0; i < length; i++) - { - array->Set(i, SWIG_From(int)($1[i])); - } - - - $result = array; -} - -%typemap(in, fragment="SWIG_JSCGetNumberProperty") double[], double[ANY] - (int length = 0, v8::Local<v8::Array> array, v8::Local<v8::Value> jsvalue, int i = 0, int res = 0, $*1_ltype temp) { - if ($input->IsArray()) - { - // Convert into Array - array = v8::Local<v8::Array>::Cast($input); - - length = $1_dim0; +%enddef - $1 = ($*1_ltype *)malloc(sizeof($*1_ltype) * length); +%define JAVASCRIPT_ARRAYS_OUT_DECL(NAME, CTYPE) - // Get each element from array - for (i = 0; i < length; i++) - { - jsvalue = array->Get(i); - - // Get primitive value from JSObject - res = SWIG_AsVal(double)(jsvalue, &temp); - if (!SWIG_IsOK(res)) - { - SWIG_exception_fail(SWIG_ERROR, "Failed to convert $input to double"); - } - arg$argnum[i] = temp; - } +%typemap(out, fragment=NAME) CTYPE[ANY] { + int length = $1_dim0; + v8::Local<v8::Array> array = SWIGV8_ARRAY_NEW(length); + for (int i = 0; i < length; i++) { + SWIGV8_ARRAY_SET(array, i, SWIG_From(CTYPE)($1[i])); } - else - { - SWIG_exception_fail(SWIG_ERROR, "$input is not JSObjectRef"); - } -} -%typemap(freearg) double[], double[ANY] { - free($1); + $result = array; } -%typemap(out, fragment=SWIG_From_frag(double)) double[], double[ANY] (int length = 0, int i = 0) -{ - length = $1_dim0; - v8::Local<v8::Array> array = v8::Array::New(length); +%enddef - for (i = 0; i < length; i++) - { - array->Set(i, SWIG_From(double)($1[i])); - } +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetIntProperty", int, , array->Length()) +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetIntProperty", int, ANY, $1_dim0) +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetNumberProperty", double, , array->Length()) +JAVASCRIPT_ARRAYS_IN_DECL("SWIG_JSCGetNumberProperty", double, ANY, $1_dim0) +JAVASCRIPT_ARRAYS_OUT_DECL("SWIG_JSCOutInt", int) +JAVASCRIPT_ARRAYS_OUT_DECL("SWIG_JSCOutNumber", double) - $result = array; -} diff --git a/Lib/javascript/v8/javascriptcode.swg b/Lib/javascript/v8/javascriptcode.swg index 0b0f1304e..2abed9488 100644 --- a/Lib/javascript/v8/javascriptcode.swg +++ b/Lib/javascript/v8/javascriptcode.swg @@ -432,7 +432,7 @@ fail: $jsmangledname_class_0->SetHiddenPrototype(true); v8::Local<v8::Object> $jsmangledname_obj = $jsmangledname_class_0->GetFunction(); #else - v8::Local<v8::Object> $jsmangledname_obj = $jsmangledname_class_0->GetFunction(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked(); + v8::Local<v8::Object> $jsmangledname_obj = $jsmangledname_class_0->GetFunction(context).ToLocalChecked(); #endif %} @@ -444,10 +444,10 @@ fail: * ----------------------------------------------------------------------------- */ %fragment("jsv8_register_class", "templates") %{ -#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903) +#if (V8_MAJOR_VERSION-0) < 5 $jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj); #else - SWIGV8_MAYBE_CHECK($jsparent_obj->Set(SWIGV8_CURRENT_CONTEXT(), SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj)); + SWIGV8_MAYBE_CHECK($jsparent_obj->Set(context, SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj)); #endif %} @@ -469,10 +469,10 @@ fail: * ----------------------------------------------------------------------------- */ %fragment("jsv8_register_namespace", "templates") %{ -#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903) +#if (V8_MAJOR_VERSION-0) < 5 $jsparent_obj->Set(SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj); #else - SWIGV8_MAYBE_CHECK($jsparent_obj->Set(SWIGV8_CURRENT_CONTEXT(), SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj)); + SWIGV8_MAYBE_CHECK($jsparent_obj->Set(context, SWIGV8_SYMBOL_NEW("$jsname"), $jsmangledname_obj)); #endif %} @@ -509,7 +509,7 @@ fail: * ----------------------------------------------------------------------------- */ %fragment("jsv8_register_static_function", "templates") %{ - SWIGV8_AddStaticFunction($jsparent_obj, "$jsname", $jswrapper); + SWIGV8_AddStaticFunction($jsparent_obj, "$jsname", $jswrapper, context); %} /* ----------------------------------------------------------------------------- @@ -523,5 +523,5 @@ fail: * ----------------------------------------------------------------------------- */ %fragment("jsv8_register_static_variable", "templates") %{ - SWIGV8_AddStaticVariable($jsparent_obj, "$jsname", $jsgetter, $jssetter); + SWIGV8_AddStaticVariable($jsparent_obj, "$jsname", $jsgetter, $jssetter, context); %} diff --git a/Lib/javascript/v8/javascriptcomplex.swg b/Lib/javascript/v8/javascriptcomplex.swg index b73d5e2dd..7b3c5547e 100644 --- a/Lib/javascript/v8/javascriptcomplex.swg +++ b/Lib/javascript/v8/javascriptcomplex.swg @@ -17,7 +17,7 @@ SWIG_From_dec(Type)(%ifcplusplus(const Type&, Type) c) { SWIGV8_HANDLESCOPE_ESC(); - v8::Local<v8::Array> vals = SWIGV8_ARRAY_NEW(); + v8::Local<v8::Array> vals = SWIGV8_ARRAY_NEW(0); SWIGV8_ARRAY_SET(vals, 0, SWIG_From(double)(Real(c))); SWIGV8_ARRAY_SET(vals, 1, SWIG_From(double)(Imag(c))); @@ -39,23 +39,23 @@ SWIG_AsVal_dec(Type) (SWIGV8_VALUE o, Type* val) if (o->IsArray()) { SWIGV8_ARRAY array = SWIGV8_ARRAY::Cast(o); - if(array->Length() != 2) SWIG_Error(SWIG_TypeError, "Illegal argument for complex: must be array[2]."); + if (array->Length() != 2) SWIG_Error(SWIG_TypeError, "Illegal argument for complex: must be array[2]."); double re, im; int res; res = SWIG_AsVal(double)(SWIGV8_ARRAY_GET(array, 0), &re); - if(!SWIG_IsOK(res)) { + if (!SWIG_IsOK(res)) { return SWIG_TypeError; } res = SWIG_AsVal(double)(SWIGV8_ARRAY_GET(array, 1), &im); - if(!SWIG_IsOK(res)) { + if (!SWIG_IsOK(res)) { return SWIG_TypeError; } if (val) *val = Constructor(re, im); return SWIG_OK; - } else if(o->IsNumber()){ + } else if (o->IsNumber()) { double d; int res = SWIG_AddCast(SWIG_AsVal(double)(o, &d)); if (SWIG_IsOK(res)) { @@ -81,17 +81,17 @@ SWIG_AsVal_dec(Type) (SWIGV8_VALUE o, Type* val) if (o->IsArray()) { SWIGV8_ARRAY array = SWIGV8_ARRAY::Cast(o); - if(array->Length() != 2) SWIG_Error(SWIG_TypeError, "Illegal argument for complex: must be array[2]."); + if (array->Length() != 2) SWIG_Error(SWIG_TypeError, "Illegal argument for complex: must be array[2]."); double re, im; int res; res = SWIG_AsVal(double)(SWIGV8_ARRAY_GET(array, 0), &re); - if(!SWIG_IsOK(res)) { + if (!SWIG_IsOK(res)) { return SWIG_TypeError; } res = SWIG_AsVal(double)(SWIGV8_ARRAY_GET(array, 1), &im); - if(!SWIG_IsOK(res)) { + if (!SWIG_IsOK(res)) { return SWIG_TypeError; } @@ -102,7 +102,7 @@ SWIG_AsVal_dec(Type) (SWIGV8_VALUE o, Type* val) } else { return SWIG_OverflowError; } - } else if(o->IsNumber()){ + } else if (o->IsNumber()) { float re; int res = SWIG_AddCast(SWIG_AsVal(float)(o, &re)); if (SWIG_IsOK(res)) { diff --git a/Lib/javascript/v8/javascripthelpers.swg b/Lib/javascript/v8/javascripthelpers.swg index 9da3ad639..fdbff000e 100644 --- a/Lib/javascript/v8/javascripthelpers.swg +++ b/Lib/javascript/v8/javascripthelpers.swg @@ -61,11 +61,11 @@ SWIGRUNTIME void SWIGV8_AddMemberVariable(SWIGV8_FUNCTION_TEMPLATE class_templ, * Registers a class method with given name for a given object. */ SWIGRUNTIME void SWIGV8_AddStaticFunction(SWIGV8_OBJECT obj, const char* symbol, - const SwigV8FunctionCallback& _func) { -#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903) || (SWIG_V8_VERSION < 0x0704) + const SwigV8FunctionCallback& _func, v8::Local<v8::Context> context) { +#if (V8_MAJOR_VERSION-0) < 5 obj->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction()); #else - SWIGV8_MAYBE_CHECK(obj->Set(SWIGV8_CURRENT_CONTEXT(), SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked())); + SWIGV8_MAYBE_CHECK(obj->Set(context, SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction(context).ToLocalChecked())); #endif } @@ -73,11 +73,12 @@ SWIGRUNTIME void SWIGV8_AddStaticFunction(SWIGV8_OBJECT obj, const char* symbol, * Registers a class method with given name for a given object. */ SWIGRUNTIME void SWIGV8_AddStaticVariable(SWIGV8_OBJECT obj, const char* symbol, - SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) { + SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter, + v8::Local<v8::Context> context) { #if (V8_MAJOR_VERSION-0) < 5 obj->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter); #else - SWIGV8_MAYBE_CHECK(obj->SetAccessor(SWIGV8_CURRENT_CONTEXT(), SWIGV8_SYMBOL_NEW(symbol), getter, setter)); + SWIGV8_MAYBE_CHECK(obj->SetAccessor(context, SWIGV8_SYMBOL_NEW(symbol), getter, setter)); #endif } diff --git a/Lib/javascript/v8/javascriptinit.swg b/Lib/javascript/v8/javascriptinit.swg index 401f9ae1f..772189787 100644 --- a/Lib/javascript/v8/javascriptinit.swg +++ b/Lib/javascript/v8/javascriptinit.swg @@ -5,27 +5,27 @@ %insert(init) %{ SWIGRUNTIME void -SWIG_V8_SetModule(void *, swig_module_info *swig_module) { - v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global(); +SWIG_V8_SetModule(v8::Local<v8::Context> context, swig_module_info *swig_module) { + v8::Local<v8::Object> global_obj = context->Global(); v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module); assert(!mod.IsEmpty()); #if (V8_MAJOR_VERSION-0) < 5 global_obj->SetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"), mod); #else v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("swig_module_info_data")); - global_obj->SetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey, mod); + global_obj->SetPrivate(context, privateKey, mod); #endif } SWIGRUNTIME swig_module_info * -SWIG_V8_GetModule(void *) { - v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global(); +SWIG_V8_GetModule(v8::Local<v8::Context> context) { + v8::Local<v8::Object> global_obj = context->Global(); #if (V8_MAJOR_VERSION-0) < 5 v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data")); #else v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("swig_module_info_data")); v8::Local<v8::Value> moduleinfo; - if (!global_obj->GetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey).ToLocal(&moduleinfo)) + if (!global_obj->GetPrivate(context, privateKey).ToLocal(&moduleinfo)) return 0; #endif @@ -52,6 +52,7 @@ SWIG_V8_GetModule(void *) { #define SWIG_GetModule(clientdata) SWIG_V8_GetModule(clientdata) #define SWIG_SetModule(clientdata, pointer) SWIG_V8_SetModule(clientdata, pointer) +#define SWIG_INIT_CLIENT_DATA_TYPE v8::Local<v8::Context> %} @@ -64,20 +65,20 @@ SWIG_V8_GetModule(void *) { %} %insert(init) %{ +#if !defined(NODE_MODULE_VERSION) || (NODE_MODULE_VERSION < 12) // Note: 'extern "C"'' disables name mangling which makes it easier to load the symbol manually -// TODO: is it ok to do that? -extern "C" -#if (NODE_MODULE_VERSION < 0x000C) -void SWIGV8_INIT (SWIGV8_OBJECT exports) +extern "C" void SWIGV8_INIT (SWIGV8_OBJECT exports_obj) +#elif (NODE_MODULE_VERSION < 64) +void SWIGV8_INIT (SWIGV8_OBJECT exports_obj, SWIGV8_VALUE /*module*/, void*) #else -void SWIGV8_INIT (SWIGV8_OBJECT exports, SWIGV8_OBJECT /*module*/) +void SWIGV8_INIT (SWIGV8_OBJECT exports_obj, SWIGV8_VALUE /*module*/, v8::Local<v8::Context> context, void*) #endif { - SWIG_InitializeModule(static_cast<void *>(&exports)); +#if !defined(NODE_MODULE_VERSION) || NODE_MODULE_VERSION < 64 + v8::Local<v8::Context> context = SWIGV8_CURRENT_CONTEXT(); +#endif - SWIGV8_HANDLESCOPE(); - - SWIGV8_OBJECT exports_obj = exports; + SWIG_InitializeModule(context); %} @@ -124,6 +125,10 @@ void SWIGV8_INIT (SWIGV8_OBJECT exports, SWIGV8_OBJECT /*module*/) } #if defined(BUILDING_NODE_EXTENSION) +#if (NODE_MODULE_VERSION < 64) NODE_MODULE($jsname, $jsname_initialize) +#else +NODE_MODULE_CONTEXT_AWARE($jsname, $jsname_initialize) +#endif #endif %} diff --git a/Lib/javascript/v8/javascriptrun.swg b/Lib/javascript/v8/javascriptrun.swg index 45dd8fe28..2df342416 100644 --- a/Lib/javascript/v8/javascriptrun.swg +++ b/Lib/javascript/v8/javascriptrun.swg @@ -50,28 +50,29 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo; #define SWIGV8_THROW_EXCEPTION(err) v8::ThrowException(err) #define SWIGV8_STRING_NEW(str) v8::String::New(str) #define SWIGV8_SYMBOL_NEW(sym) v8::String::NewSymbol(sym) -#elif (SWIG_V8_VERSION < 0x0704) +#else #define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size) #define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext() #define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err) +#if (SWIG_V8_VERSION < 0x0704) #define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str, v8::String::kNormalString) #define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym, v8::String::kNormalString) #else -#define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size) -#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext() -#define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err) #define SWIGV8_STRING_NEW(str) (v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str, v8::NewStringType::kNormal)).ToLocalChecked() #define SWIGV8_SYMBOL_NEW(sym) (v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym, v8::NewStringType::kNormal)).ToLocalChecked() #endif +#endif -#if (SWIG_V8_VERSION < 0x0704) +#if (V8_MAJOR_VERSION-0) < 5 +#define SWIGV8_MAYBE_CHECK(maybe) maybe +#elif (SWIG_V8_VERSION < 0x0704) #define SWIGV8_MAYBE_CHECK(maybe) maybe.FromJust() #else #define SWIGV8_MAYBE_CHECK(maybe) maybe.Check() #endif #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032318) -#define SWIGV8_ARRAY_NEW() v8::Array::New() +#define SWIGV8_ARRAY_NEW(size) v8::Array::New(size) #define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool) #define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val) #define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func) @@ -91,7 +92,7 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo; #define SWIGV8_ARRAY_GET(array, index) (array)->Get(index) #define SWIGV8_ARRAY_SET(array, index, value) (array)->Set(index, value) #else -#define SWIGV8_ARRAY_NEW() v8::Array::New(v8::Isolate::GetCurrent()) +#define SWIGV8_ARRAY_NEW(size) v8::Array::New(v8::Isolate::GetCurrent(), size) #define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool) #define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val) #define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func) @@ -120,15 +121,7 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo; #define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class); #endif -#ifdef NODE_VERSION -#if NODE_VERSION_AT_LEAST(10, 12, 0) -#define SWIG_NODE_AT_LEAST_1012 -#endif -#endif - -//Necessary to check Node.js version because V8 API changes are backported in Node.js -#if (defined(NODE_VERSION) && !defined(SWIG_NODE_AT_LEAST_1012)) || \ - (!defined(NODE_VERSION) && (V8_MAJOR_VERSION-0) < 7) +#if (V8_MAJOR_VERSION-0) < 6 || (SWIG_V8_VERSION < 0x0608) #define SWIGV8_TO_OBJECT(handle) (handle)->ToObject() #define SWIGV8_TO_STRING(handle) (handle)->ToString() #define SWIGV8_NUMBER_VALUE(handle) (handle)->NumberValue() @@ -136,22 +129,18 @@ typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo; #define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue() #define SWIGV8_WRITE_UTF8(handle, buffer, len) (handle)->WriteUtf8(buffer, len) #define SWIGV8_UTF8_LENGTH(handle) (handle)->Utf8Length() -#elif (SWIG_V8_VERSION < 0x0704) +#else #define SWIGV8_TO_OBJECT(handle) (handle)->ToObject(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked() #define SWIGV8_TO_STRING(handle) (handle)->ToString(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked() #define SWIGV8_NUMBER_VALUE(handle) (handle)->NumberValue(SWIGV8_CURRENT_CONTEXT()).ToChecked() #define SWIGV8_INTEGER_VALUE(handle) (handle)->IntegerValue(SWIGV8_CURRENT_CONTEXT()).ToChecked() -#define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue(SWIGV8_CURRENT_CONTEXT()).ToChecked() #define SWIGV8_WRITE_UTF8(handle, buffer, len) (handle)->WriteUtf8(v8::Isolate::GetCurrent(), buffer, len) #define SWIGV8_UTF8_LENGTH(handle) (handle)->Utf8Length(v8::Isolate::GetCurrent()) +#if (SWIG_V8_VERSION < 0x0704) +#define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue(SWIGV8_CURRENT_CONTEXT()).ToChecked() #else -#define SWIGV8_TO_OBJECT(handle) (handle)->ToObject(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked() -#define SWIGV8_TO_STRING(handle) (handle)->ToString(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked() -#define SWIGV8_NUMBER_VALUE(handle) (handle)->NumberValue(SWIGV8_CURRENT_CONTEXT()).ToChecked() -#define SWIGV8_INTEGER_VALUE(handle) (handle)->IntegerValue(SWIGV8_CURRENT_CONTEXT()).ToChecked() #define SWIGV8_BOOLEAN_VALUE(handle) (handle)->BooleanValue(v8::Isolate::GetCurrent()) -#define SWIGV8_WRITE_UTF8(handle, buffer, len) (handle)->WriteUtf8(v8::Isolate::GetCurrent(), buffer, len) -#define SWIGV8_UTF8_LENGTH(handle) (handle)->Utf8Length(v8::Isolate::GetCurrent()) +#endif #endif /* --------------------------------------------------------------------------- @@ -291,6 +280,7 @@ SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(SWIGV8_OBJECT objRef, void **ptr, swi } int newmemory = 0; *ptr = SWIG_TypeCast(tc, cdata->swigCObject, &newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ } else { *ptr = cdata->swigCObject; } @@ -325,7 +315,7 @@ SWIGRUNTIME int SWIG_V8_GetInstancePtr(SWIGV8_VALUE valRef, void **ptr) { if(!valRef->IsObject()) { return SWIG_TypeError; } - SWIGV8_OBJECT objRef = SWIGV8_TO_OBJECT(valRef); + SWIGV8_OBJECT objRef = SWIGV8_OBJECT::Cast(valRef); if(objRef->InternalFieldCount() < 1) return SWIG_ERROR; @@ -420,7 +410,7 @@ SWIGRUNTIME int SWIG_V8_ConvertPtr(SWIGV8_VALUE valRef, void **ptr, swig_type_in if(!valRef->IsObject()) { return SWIG_TypeError; } - SWIGV8_OBJECT objRef = SWIGV8_TO_OBJECT(valRef); + SWIGV8_OBJECT objRef = SWIGV8_OBJECT::Cast(valRef); return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags); } @@ -454,7 +444,7 @@ SWIGRUNTIME SWIGV8_VALUE SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, } #endif -#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903) || (SWIG_V8_VERSION < 0x0704) +#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903) v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance(); #else v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance(SWIGV8_CURRENT_CONTEXT()).ToLocalChecked(); @@ -707,9 +697,9 @@ SWIGV8_VALUE SWIGV8_AppendOutput(SWIGV8_VALUE result, SWIGV8_VALUE obj) { SWIGV8_HANDLESCOPE_ESC(); if (result->IsUndefined()) { - result = SWIGV8_ARRAY_NEW(); + result = SWIGV8_ARRAY_NEW(0); } else if (!result->IsArray()) { - SWIGV8_ARRAY tmparr = SWIGV8_ARRAY_NEW(); + SWIGV8_ARRAY tmparr = SWIGV8_ARRAY_NEW(0); SWIGV8_ARRAY_SET(tmparr, 0, result); result = tmparr; } diff --git a/Lib/javascript/v8/javascriptruntime.swg b/Lib/javascript/v8/javascriptruntime.swg index 773014f2a..115554a5a 100644 --- a/Lib/javascript/v8/javascriptruntime.swg +++ b/Lib/javascript/v8/javascriptruntime.swg @@ -64,6 +64,7 @@ #include <errno.h> #include <limits.h> #include <stdlib.h> +#include <assert.h> %} %insert(runtime) "swigrun.swg"; /* SWIG API */ diff --git a/Lib/javascript/v8/javascriptstrings.swg b/Lib/javascript/v8/javascriptstrings.swg index 9c0919172..aaf1b9302 100644 --- a/Lib/javascript/v8/javascriptstrings.swg +++ b/Lib/javascript/v8/javascriptstrings.swg @@ -8,13 +8,13 @@ SWIG_AsCharPtrAndSize(SWIGV8_VALUE valRef, char** cptr, size_t* psize, int *allo { if(valRef->IsString()) { %#if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903) - v8::Handle<v8::String> js_str = SWIGV8_TO_STRING(valRef); + v8::Handle<v8::String> js_str = v8::Handle<v8::String>::Cast(valRef); %#else - v8::Local<v8::String> js_str = SWIGV8_TO_STRING(valRef); + v8::Local<v8::String> js_str = v8::Local<v8::String>::Cast(valRef); %#endif size_t len = SWIGV8_UTF8_LENGTH(js_str) + 1; - char* cstr = new char[len]; + char* cstr = (char*) %new_array(len, char); SWIGV8_WRITE_UTF8(js_str, cstr, len); if(alloc) *alloc = SWIG_NEWOBJ; @@ -24,7 +24,7 @@ SWIG_AsCharPtrAndSize(SWIGV8_VALUE valRef, char** cptr, size_t* psize, int *allo return SWIG_OK; } else { if(valRef->IsObject()) { - SWIGV8_OBJECT obj = SWIGV8_TO_OBJECT(valRef); + SWIGV8_OBJECT obj = SWIGV8_OBJECT::Cast(valRef); // try if the object is a wrapped char[] swig_type_info* pchar_descriptor = SWIG_pchar_descriptor(); if (pchar_descriptor) { diff --git a/Lib/lua/luarun.swg b/Lib/lua/luarun.swg index b8ddf000a..6ef2c6f15 100644 --- a/Lib/lua/luarun.swg +++ b/Lib/lua/luarun.swg @@ -1344,14 +1344,14 @@ SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration /* The real function that resolves a metamethod. * Function searches given class and all it's bases(recursively) for first instance of something that is - * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation + * not equal to SWIG_Lua_resolve_metamethod. (Almost always this 'something' is actual metamethod implementation * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the * answer. * Returns 1 if found, 0 otherwise. * clss is class which metatable we will search for method * metamethod_name_idx is index in L where metamethod name (as string) lies - * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check - * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from + * skip_check allows skipping searching metamethod in the given class and immediately going to searching in bases. skip_check + * is not carried to subsequent recursive calls - false is always passed. It is set to true only at first call from * SWIG_Lua_resolve_metamethod * */ SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, @@ -1497,7 +1497,7 @@ SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class } } - lua_pop(L,1); /* remove inheritable metatmethods table */ + lua_pop(L,1); /* remove inheritable metamethods table */ /* Special handling for __tostring method */ lua_pushstring(L, "__tostring"); diff --git a/Lib/lua/luatypemaps.swg b/Lib/lua/luatypemaps.swg index 8959f201e..3f531bd05 100644 --- a/Lib/lua/luatypemaps.swg +++ b/Lib/lua/luatypemaps.swg @@ -39,12 +39,12 @@ $1 = ($type)lua_tonumber(L, $input);%} // SWIG assumes that this code will need a pointer to int to be passed in // (this might be ok for objects by const ref, but not for numeric primitives) // therefore we add a set of typemaps to fix this (for both in & out) -%typemap(in,checkfn="lua_isnumber") const int&($basetype temp) -%{ temp=($basetype)lua_tonumber(L,$input); $1=&temp;%} +%typemap(in,checkfn="lua_isnumber") const int&($*1_ltype temp) +%{ temp=($*1_ltype)lua_tonumber(L,$input); $1=&temp;%} -%typemap(in,checkfn="lua_isnumber") const unsigned int&($basetype temp) +%typemap(in,checkfn="lua_isnumber") const unsigned int&($*1_ltype temp) %{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative") -temp=($basetype)lua_tonumber(L,$input); $1=&temp;%} +temp=($*1_ltype)lua_tonumber(L,$input); $1=&temp;%} %typemap(out) const int&, const unsigned int& %{ lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%} @@ -237,13 +237,13 @@ $1=($1_ltype)&temp;%} // therefore a special wrapping functions SWIG_ConvertMember() & SWIG_NewMemberObj() were written %typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*) %{ - if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($type),$descriptor))) + if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($1),$descriptor))) SWIG_fail_ptr("$symname",$argnum,$descriptor); %} %typemap(out) SWIGTYPE (CLASS::*) -%{ - SWIG_NewMemberObj(L,(void*)(&$1),sizeof($type),$descriptor); SWIG_arg++; +%{ + SWIG_NewMemberObj(L,(void*)(&$1),sizeof($1),$descriptor); SWIG_arg++; %} diff --git a/Lib/math.i b/Lib/math.i index a37c92d19..ac8d9a6eb 100644 --- a/Lib/math.i +++ b/Lib/math.i @@ -9,6 +9,8 @@ #include <math.h> %} +#ifndef SWIGPHP /* PHP already provides all these functions except fabs() */ + extern double cos(double x); /* Cosine of x */ @@ -54,9 +56,6 @@ extern double pow(double x, double y); extern double sqrt(double x); /* Square root. x >= 0 */ -extern double fabs(double x); -/* Absolute value of x */ - extern double ceil(double x); /* Smallest integer not less than x, as a double */ @@ -66,6 +65,13 @@ extern double floor(double x); extern double fmod(double x, double y); /* Floating-point remainder of x/y, with the same sign as x. */ +#endif + +extern double fabs(double x); +/* Absolute value of x */ + +#ifndef SWIGPHP /* PHP already provides these constants and it's an error to redefine them */ + #define M_E 2.7182818284590452354 #define M_LOG2E 1.4426950408889634074 #define M_LOG10E 0.43429448190325182765 @@ -80,3 +86,4 @@ extern double fmod(double x, double y); #define M_SQRT2 1.41421356237309504880 #define M_SQRT1_2 0.70710678118654752440 +#endif diff --git a/Lib/modula3/modula3.swg b/Lib/modula3/modula3.swg deleted file mode 100644 index 13d06e9c6..000000000 --- a/Lib/modula3/modula3.swg +++ /dev/null @@ -1,787 +0,0 @@ -/* ----------------------------------------------------------------------------- - * modula3.swg - * - * Modula3 typemaps - * ----------------------------------------------------------------------------- */ - -%include <modula3head.swg> - -/* The ctype, m3rawtype and m3wraptype typemaps work together and so there should be one of each. - * The ctype typemap contains the C type used in the signature of C wrappers for C++ functions. - * The m3rawtype typemap contains the M3 type used in the raw interface. - * The m3rawintype typemap contains the M3 type used as function argument. - * The m3rawrettype typemap contains the M3 type used as return value. - * The m3wraptype typemap contains the M3 type used in the M3 type wrapper classes and module class. */ - -/* Primitive types */ -%typemap(ctype) bool, const bool & "bool" -%typemap(ctype) char, const char & "char" -%typemap(ctype) signed char, const signed char & "signed char" -%typemap(ctype) unsigned char, const unsigned char & "unsigned short" -%typemap(ctype) short, const short & "short" -%typemap(ctype) unsigned short, const unsigned short & "unsigned short" -%typemap(ctype) int, const int & "int" -%typemap(ctype) unsigned int, const unsigned int & "unsigned int" -%typemap(ctype) long, const long & "long" -%typemap(ctype) unsigned long, const unsigned long & "unsigned long" -%typemap(ctype) long long, const long long & "long long" -%typemap(ctype) unsigned long long, const unsigned long long & "unsigned long long" -%typemap(ctype) float, const float & "float" -%typemap(ctype) double, const double & "double" -%typemap(ctype) char * "char *" -%typemap(ctype) void "void" - -%typemap(m3rawtype) bool, const bool & "BOOLEAN" -%typemap(m3rawtype) char, const char & "C.char" -%typemap(m3rawtype) signed char, const signed char & "C.signed_char" -%typemap(m3rawtype) unsigned char, const unsigned char & "C.unsigned_char" -%typemap(m3rawtype) short, const short & "C.short" -%typemap(m3rawtype) unsigned short, const unsigned short & "C.unsigned_short" -%typemap(m3rawtype) int, const int & "C.int" -%typemap(m3rawtype) unsigned int, const unsigned int & "C.unsigned_int" -%typemap(m3rawtype) long, const long & "C.long" -%typemap(m3rawtype) unsigned long, const unsigned long & "C.unsigned_long" -%typemap(m3rawtype) long long, const long long & "C.long_long" -%typemap(m3rawtype) unsigned long long, const unsigned long long & "C.unsigned_long_long" -%typemap(m3rawtype) float, const float & "C.float" -%typemap(m3rawtype) double, const double & "C.double" -%typemap(m3rawtype) long double, const long double & "C.long_double" -%typemap(m3rawtype) char * "C.char_star" -%typemap(m3rawtype) void "" -%typemap(m3rawtype) FILE "Cstdio.FILE"; -%typemap(m3rawtype) FILE * "Cstdio.FILE_star"; - - -%typemap(m3rawintype) bool *, bool &, bool "BOOLEAN" -%typemap(m3rawintype) char *, char &, char "C.char" -%typemap(m3rawintype) signed char *, signed char &, signed char "C.signed_char" -%typemap(m3rawintype) unsigned char *, unsigned char &, unsigned char "C.unsigned_char" -%typemap(m3rawintype) short *, short &, short "C.short" -%typemap(m3rawintype) unsigned short *, unsigned short &, unsigned short "C.unsigned_short" -%typemap(m3rawintype) int *, int &, int "C.int" -%typemap(m3rawintype) unsigned int *, unsigned int &, unsigned int "C.unsigned_int" -%typemap(m3rawintype) long *, long &, long "C.long" -%typemap(m3rawintype) unsigned long *, unsigned long &, unsigned long "C.unsigned_long" -%typemap(m3rawintype) long long *, long long &, long long "C.long_long" -%typemap(m3rawintype) unsigned long long *, unsigned long long &, unsigned long long "C.unsigned_long_long" -%typemap(m3rawintype) float *, float &, float "C.float" -%typemap(m3rawintype) double *, double &, double "C.double" -%typemap(m3rawintype) long double *, long double &, long double "C.long_double" -%typemap(m3rawintype) char * "C.char_star" -%typemap(m3rawintype) void "" -%typemap(m3rawintype) void * "ADDRESS" -%typemap(m3rawintype) FILE "Cstdio.FILE"; -%typemap(m3rawintype) FILE * "Cstdio.FILE_star"; - -%typemap(m3rawinmode) char *, void *, FILE * "" - - -%typemap(m3rawrettype) bool, const bool & "BOOLEAN" -%typemap(m3rawrettype) char, const char & "C.char" -%typemap(m3rawrettype) signed char, const signed char & "C.signed_char" -%typemap(m3rawrettype) unsigned char, const unsigned char & "C.unsigned_char" -%typemap(m3rawrettype) short, const short & "C.short" -%typemap(m3rawrettype) unsigned short, const unsigned short & "C.unsigned_short" -%typemap(m3rawrettype) int, const int & "C.int" -%typemap(m3rawrettype) unsigned int, const unsigned int & "C.unsigned_int" -%typemap(m3rawrettype) long, const long & "C.long" -%typemap(m3rawrettype) unsigned long, const unsigned long & "C.unsigned_long" -%typemap(m3rawrettype) long long, const long long & "C.long_long" -%typemap(m3rawrettype) unsigned long long, const unsigned long long & "C.unsigned_long_long" -%typemap(m3rawrettype) float, const float & "C.float" -%typemap(m3rawrettype) double, const double & "C.double" -%typemap(m3rawrettype) long double, const long double & "C.long_double" -%typemap(m3rawrettype) char * "C.char_star" -%typemap(m3rawrettype) void "" -%typemap(m3rawrettype) void * "ADDRESS" -%typemap(m3rawrettype) FILE "Cstdio.FILE"; -%typemap(m3rawrettype) FILE * "Cstdio.FILE_star"; - - -%typemap("m3rawtype:import") - char, const char &, - signed char, const signed char &, - unsigned char, const unsigned char &, - short, const short &, - unsigned short, const unsigned short &, - int, const int &, - unsigned int, const unsigned int &, - long, const long &, - unsigned long, const unsigned long &, - long long, const long long &, - unsigned long long, const unsigned long long &, - float, const float &, - double, const double &, - long double, const long double &, - char * - "Ctypes AS C" - -%typemap("m3rawintype:import") - char, const char &, - signed char, const signed char &, - unsigned char, const unsigned char &, - short, const short &, - unsigned short, const unsigned short &, - int, const int &, - unsigned int, const unsigned int &, - long, const long &, - unsigned long, const unsigned long &, - long long, const long long &, - unsigned long long, const unsigned long long &, - float, const float &, - double, const double &, - long double, const long double &, - char * - "Ctypes AS C" - -%typemap("m3rawrettype:import") - char, const char &, - signed char, const signed char &, - unsigned char, const unsigned char &, - short, const short &, - unsigned short, const unsigned short &, - int, const int &, - unsigned int, const unsigned int &, - long, const long &, - unsigned long, const unsigned long &, - long long, const long long &, - unsigned long long, const unsigned long long &, - float, const float &, - double, const double &, - long double, const long double &, - char * - "Ctypes AS C" - -%typemap("m3rawtype:import") - FILE, FILE * - "Cstdio"; - -%typemap("m3rawintype:import") - FILE, FILE * - "Cstdio"; - -%typemap("m3rawrettype:import") - FILE, FILE * - "Cstdio"; - -%typemap(m3wraptype) bool, const bool & "BOOLEAN" -%typemap(m3wraptype) char, const char & "CHAR" -%typemap(m3wraptype) signed char, const signed char & "CHAR" -%typemap(m3wraptype) unsigned char, const unsigned char & "CHAR" -%typemap(m3wraptype) short, const short & "Integer16.T" -%typemap(m3wraptype) unsigned short, const unsigned short & "Cardinal16.T" -%typemap(m3wraptype) int, const int & "INTEGER" -%typemap(m3wraptype) unsigned int, const unsigned int & "CARDINAL" -%typemap(m3wraptype) long, const long & "Integer32.T" -%typemap(m3wraptype) unsigned long, const unsigned long & "Cardinal32.T" -%typemap(m3wraptype) long long, const long long & "Integer64.T" -%typemap(m3wraptype) unsigned long long, const unsigned long long & "Cardinal64.T" -%typemap(m3wraptype) float, const float & "REAL" -%typemap(m3wraptype) double, const double & "LONGREAL" -%typemap(m3wraptype) long double, const long double & "EXTENDED" -%typemap(m3wraptype) char * "TEXT" -%typemap(m3wraptype) void "" -%typemap(m3wraptype) FILE "Cstdio.FILE"; -%typemap(m3wraptype) FILE * "Cstdio.FILE_star"; - -%typemap(m3wrapintype) bool, const bool *, const bool & "BOOLEAN" -%typemap(m3wrapintype) char, const char *, const char & "CHAR" -%typemap(m3wrapintype) signed char, const signed char *, const signed char & "CHAR" -%typemap(m3wrapintype) unsigned char, const unsigned char *, const unsigned char & "CHAR" -%typemap(m3wrapintype) short, const short *, const short & "INTEGER" -%typemap(m3wrapintype) unsigned short, const unsigned short *, const unsigned short & "CARDINAL" -%typemap(m3wrapintype) int, const int *, const int & "INTEGER" -%typemap(m3wrapintype) unsigned int, const unsigned int *, const unsigned int & "CARDINAL" -%typemap(m3wrapintype) long, const long *, const long & "INTEGER" -%typemap(m3wrapintype) unsigned long, const unsigned long *, const unsigned long & "CARDINAL" -%typemap(m3wrapintype) long long, const long long *, const long long & "INTEGER" -%typemap(m3wrapintype) unsigned long long, const unsigned long long *, const unsigned long long & "CARDINAL" -%typemap(m3wrapintype) float, const float *, const float & "REAL" -%typemap(m3wrapintype) double, const double *, const double & "LONGREAL" -%typemap(m3wrapintype) long double, const long double *, const long double & "EXTENDED" -%typemap(m3wrapintype) const char *, const char [] "TEXT" -%typemap(m3wrapintype,numinputs=0) void "" -%typemap(m3wrapintype) FILE "Cstdio.FILE"; -%typemap(m3wrapintype) FILE * "Cstdio.FILE_star"; - - -%typemap(m3wrapouttype) bool, bool *, bool & "BOOLEAN" -%typemap(m3wrapouttype) char, char *, char & "CHAR" -%typemap(m3wrapouttype) signed char, signed char *, signed char & "CHAR" -%typemap(m3wrapouttype) unsigned char, unsigned char *, unsigned char & "CHAR" -%typemap(m3wrapouttype) short, short *, short & "INTEGER" -%typemap(m3wrapouttype) unsigned short, unsigned short *, unsigned short & "CARDINAL" -%typemap(m3wrapouttype) int, int *, int & "INTEGER" -%typemap(m3wrapouttype) unsigned int, unsigned int *, unsigned int & "CARDINAL" -%typemap(m3wrapouttype) long, long *, long & "INTEGER" -%typemap(m3wrapouttype) unsigned long, unsigned long *, unsigned long & "CARDINAL" -%typemap(m3wrapouttype) long long, long long *, long long & "INTEGER" -%typemap(m3wrapouttype) unsigned long long, unsigned long long *, unsigned long long & "CARDINAL" -%typemap(m3wrapouttype) float, float *, float & "REAL" -%typemap(m3wrapouttype) double, double *, double & "LONGREAL" -%typemap(m3wrapouttype) long double, long double *, long double & "EXTENDED" -%typemap(m3wrapouttype) char *, char [] "TEXT" -%typemap(m3wrapouttype,numinputs=0) void "" - -%typemap(m3wraprettype) bool, const bool & "BOOLEAN" -%typemap(m3wraprettype) char, const char & "CHAR" -%typemap(m3wraprettype) signed char, const signed char & "CHAR" -%typemap(m3wraprettype) unsigned char, const unsigned char & "CHAR" -%typemap(m3wraprettype) short, const short & "INTEGER" -%typemap(m3wraprettype) unsigned short, const unsigned short & "CARDINAL" -%typemap(m3wraprettype) int, const int & "INTEGER" -%typemap(m3wraprettype) unsigned int, const unsigned int & "CARDINAL" -%typemap(m3wraprettype) long, const long & "INTEGER" -%typemap(m3wraprettype) unsigned long, const unsigned long & "CARDINAL" -%typemap(m3wraprettype) long long, const long long & "INTEGER" -%typemap(m3wraprettype) unsigned long long, const unsigned long long & "CARDINAL" -%typemap(m3wraprettype) float, const float & "REAL" -%typemap(m3wraprettype) double, const double & "LONGREAL" -%typemap(m3wraprettype) long double, const long double & "EXTENDED" -%typemap(m3wraprettype) char * "TEXT" -%typemap(m3wraprettype) void "" -%typemap(m3wraprettype) FILE "Cstdio.FILE"; -%typemap(m3wraprettype) FILE * "Cstdio.FILE_star"; - - -%typemap(ctype) char[ANY] "char *" -%typemap(m3rawtype) char[ANY] "C.char_star" -%typemap(m3rawintype) char[ANY] "C.char_star" -%typemap(m3rawrettype) char[ANY] "C.char_star" -%typemap(m3wraptype) char[ANY] "TEXT" -%typemap(m3wrapintype) char[ANY] "TEXT" -%typemap(m3wrapouttype) char[ANY] "TEXT" -%typemap(m3wraprettype) char[ANY] "TEXT" - -%typemap(m3wrapinmode) const char * %{%} -%typemap(m3wrapargvar) const char * %{$1 : C.char_star;%} -%typemap(m3wrapinconv) const char * %{$1 := M3toC.SharedTtoS($1_name);%} -%typemap(m3wrapfreearg) const char * %{M3toC.FreeSharedS($1_name,$1);%} -%typemap(m3wrapargraw) const char * %{$1%} -%typemap("m3wrapargvar:import") const char * "Ctypes AS C" -%typemap("m3wrapinconv:import") const char * "M3toC" -%typemap("m3wrapfreearg:import") const char * "M3toC" - -%typemap(m3wrapretvar) char * %{result : C.char_star;%} -%typemap(m3wrapretraw) char * %{result%} -%typemap(m3wrapretconv) char * %{M3toC.CopyStoT(result)%} -%typemap("m3wrapretvar:import") char * "Ctypes AS C" -%typemap("m3wrapretconv:import") char * "M3toC" - -%typemap(m3wrapinmode) FILE * %{%} - - -%typemap("m3wraptype:import") - FILE, FILE * - "Cstdio"; - -%typemap("m3wrapintype:import") - FILE, FILE * - "Cstdio"; - -%typemap("m3wraprettype:import") - FILE, FILE * - "Cstdio"; - - -/* Composed types */ -%typemap(ctype) SWIGTYPE "$1_type" -%typemap(m3rawtype) SWIGTYPE "$1_basetype" -%typemap(m3rawrettype) SWIGTYPE "UNTRACED REF $1_basetype" -%typemap(m3wraptype) SWIGTYPE "$1_basetype" -%typemap(m3wrapintype) SWIGTYPE "$1_basetype" -%typemap(m3wrapouttype) SWIGTYPE "$1_basetype" -%typemap(m3wraprettype) SWIGTYPE "$1_basetype" - -%typemap(ctype) SWIGTYPE [] "$1_type" -%typemap(m3rawtype) const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype" -%typemap(m3rawtype) SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype" -%typemap(m3rawintype) const SWIGTYPE [] "(*ARRAY OF*) $1_basetype" -%typemap(m3rawinmode) const SWIGTYPE [] "READONLY" -%typemap(m3rawintype) SWIGTYPE [] "(*ARRAY OF*) $1_basetype" -%typemap(m3rawinmode) SWIGTYPE [] "VAR" -%typemap(m3rawrettype) const SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype" -%typemap(m3rawrettype) SWIGTYPE [] "UNTRACED REF ARRAY INTEGER OF $1_basetype" -%typemap(m3wraptype) SWIGTYPE [] "$1_basetype" -%typemap(m3wrapintype) const SWIGTYPE [] "ARRAY OF $1_basetype" -%typemap(m3wrapinmode) const SWIGTYPE [] "READONLY" -%typemap(m3wrapintype) SWIGTYPE [] "ARRAY OF $1_basetype" -%typemap(m3wrapinmode) SWIGTYPE [] "VAR" -%typemap(m3wrapouttype) SWIGTYPE [] "ARRAY OF $1_basetype" -%typemap(m3wraprettype) SWIGTYPE [] "REF ARRAY OF $1_basetype" - -%typemap(ctype) SWIGTYPE * "$1_type" -%typemap(m3rawtype) const SWIGTYPE * "UNTRACED REF $1_basetype" -%typemap(m3rawtype) SWIGTYPE * "UNTRACED REF $1_basetype" -%typemap(m3rawintype) const SWIGTYPE * "$1_basetype" -%typemap(m3rawinmode) const SWIGTYPE * "READONLY" -%typemap(m3rawintype) SWIGTYPE * "$1_basetype" -%typemap(m3rawinmode) SWIGTYPE * "VAR" -%typemap(m3rawrettype) const SWIGTYPE * "UNTRACED REF $1_basetype" -%typemap(m3rawrettype) SWIGTYPE * "UNTRACED REF $1_basetype" -%typemap(m3wraptype) SWIGTYPE * "$1_basetype" -%typemap(m3wrapintype) const SWIGTYPE * "$1_basetype" -%typemap(m3wrapinmode) const SWIGTYPE * "READONLY" -%typemap(m3wrapintype) SWIGTYPE * "$1_basetype" -%typemap(m3wrapinmode) SWIGTYPE * "VAR" -%typemap(m3wrapouttype) SWIGTYPE * "$1_basetype" -%typemap(m3wraprettype) SWIGTYPE * "UNTRACED REF $1_basetype" - -%typemap(ctype) SWIGTYPE & "$1_type" -%typemap(m3rawtype) const SWIGTYPE & "UNTRACED REF $1_basetype" -%typemap(m3rawtype) SWIGTYPE & "UNTRACED REF $1_basetype" -%typemap(m3rawintype) const SWIGTYPE & "$1_basetype" -%typemap(m3rawinmode) const SWIGTYPE & "READONLY" -%typemap(m3rawintype) SWIGTYPE & "$1_basetype" -%typemap(m3rawinmode) SWIGTYPE & "VAR" -%typemap(m3rawrettype) const SWIGTYPE & "UNTRACED REF $1_basetype" -%typemap(m3rawrettype) SWIGTYPE & "UNTRACED REF $1_basetype" -%typemap(m3wraptype) SWIGTYPE & "$1_basetype" -%typemap(m3wrapintype) const SWIGTYPE & "$1_basetype" -%typemap(m3wrapinmode) const SWIGTYPE & "READONLY" -%typemap(m3wrapintype) SWIGTYPE & "$1_basetype" -%typemap(m3wrapinmode) SWIGTYPE & "VAR" -%typemap(m3wrapouttype) SWIGTYPE & "$1_basetype" -%typemap(m3wraprettype) SWIGTYPE & "UNTRACED REF $1_basetype" - -%typemap(ctype) SWIGTYPE && "$1_type" -%typemap(m3rawtype) const SWIGTYPE && "UNTRACED REF $1_basetype" -%typemap(m3rawtype) SWIGTYPE && "UNTRACED REF $1_basetype" -%typemap(m3rawintype) const SWIGTYPE && "$1_basetype" -%typemap(m3rawinmode) const SWIGTYPE && "READONLY" -%typemap(m3rawintype) SWIGTYPE && "$1_basetype" -%typemap(m3rawinmode) SWIGTYPE && "VAR" -%typemap(m3rawrettype) const SWIGTYPE && "UNTRACED REF $1_basetype" -%typemap(m3rawrettype) SWIGTYPE && "UNTRACED REF $1_basetype" -%typemap(m3wraptype) SWIGTYPE && "$1_basetype" -%typemap(m3wrapintype) const SWIGTYPE && "$1_basetype" -%typemap(m3wrapinmode) const SWIGTYPE && "READONLY" -%typemap(m3wrapintype) SWIGTYPE && "$1_basetype" -%typemap(m3wrapinmode) SWIGTYPE && "VAR" -%typemap(m3wrapouttype) SWIGTYPE && "$1_basetype" -%typemap(m3wraprettype) SWIGTYPE && "UNTRACED REF $1_basetype" - -%typemap(ctype) enum SWIGTYPE "$1_type" -%typemap(m3rawtype) enum SWIGTYPE "C.int" -%typemap(m3rawintype) enum SWIGTYPE "C.int (* $1_type *)" -%typemap(m3rawrettype) enum SWIGTYPE "C.int" -%typemap(m3wraptype) enum SWIGTYPE "$*1_type" -%typemap(m3wrapintype) enum SWIGTYPE "$1_type" -%typemap(m3wrapouttype) enum SWIGTYPE "$1_type" -%typemap(m3wraprettype) enum SWIGTYPE "$*1_type" - -/* pointer to a class member */ -%typemap(ctype) SWIGTYPE (CLASS::*) "$1_type" -%typemap(m3rawtype) SWIGTYPE (CLASS::*) "REFANY" -%typemap(m3wraptype) SWIGTYPE (CLASS::*) "$1_basetype" - -/* The following are the in, out, freearg, argout typemaps. - These are the PInvoke code generating typemaps for converting from C# to C and visa versa. */ - -/* primitive types */ -%typemap(in) bool -%{ $1 = $input ? true : false; %} - -%typemap(in) char, - signed char, - unsigned char, - short, - unsigned short, - int, - unsigned int, - long, - unsigned long, - long long, - unsigned long long, - float, - double, - enum SWIGTYPE -%{ $1 = ($1_ltype)$input; %} - -%typemap(out) bool %{ $result = $1; %} -%typemap(out) char %{ $result = $1; %} -%typemap(out) signed char %{ $result = $1; %} -%typemap(out) unsigned char %{ $result = $1; %} -%typemap(out) short %{ $result = $1; %} -%typemap(out) unsigned short %{ $result = $1; %} -%typemap(out) int %{ $result = $1; %} -%typemap(out) unsigned int %{ $result = $1; %} -%typemap(out) long %{ $result = $1; %} -%typemap(out) unsigned long %{ $result = $1; %} -%typemap(out) long long %{ $result = $1; %} -%typemap(out) unsigned long long %{ $result = $1; %} -%typemap(out) float %{ $result = $1; %} -%typemap(out) double %{ $result = $1; %} -%typemap(out) enum SWIGTYPE %{ $result = $1; %} - -/* char * - treat as String */ -%typemap(in) char * { - $1 = $input; -} -//%typemap(freearg) char * { if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); } -//%typemap(out) char * { if($1) $result = JCALL1(NewStringUTF, jenv, $1); } - -%typemap(out) void "" - -/* primitive types by const reference */ -%typemap(in) const bool & (bool temp) -%{ temp = $input ? true : false; - $1 = &temp; %} - -%typemap(in) const char & (char temp), - const signed char & (signed char temp), - const unsigned char & (unsigned char temp), - const short & (short temp), - const unsigned short & (unsigned short temp), - const int & (int temp), - const unsigned int & (unsigned int temp), - const long & (long temp), - const unsigned long & (unsigned long temp), - const long long & ($*1_ltype temp), - const unsigned long long & ($*1_ltype temp), - const float & (float temp), - const double & (double temp) -%{ temp = ($*1_ltype)$input; -$1 = &temp; %} - -%typemap(out) const bool & %{ $result = *$1; %} -%typemap(out) const char & %{ $result = *$1; %} -%typemap(out) const signed char & %{ $result = *$1; %} -%typemap(out) const unsigned char & %{ $result = *$1; %} -%typemap(out) const short & %{ $result = *$1; %} -%typemap(out) const unsigned short & %{ $result = *$1; %} -%typemap(out) const int & %{ $result = *$1; %} -%typemap(out) const unsigned int & %{ $result = *$1; %} -%typemap(out) const long & %{ $result = *$1; %} -%typemap(out) const unsigned long & %{ $result = *$1; %} -%typemap(out) const long long & %{ $result = *$1; %} -%typemap(out) const unsigned long long & %{ $result = *$1; %} -%typemap(out) const float & %{ $result = *$1; %} -%typemap(out) const double & %{ $result = *$1; %} - -/* Default handling. Object passed by value. Convert to a pointer */ -%typemap(in) SWIGTYPE ($&1_type argp) -%{ argp = *($&1_ltype*)&$input; - if (!argp) { -// SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null $1_type"); - RETURN $null; - } - $1 = *argp; %} -%typemap(out) SWIGTYPE -#ifdef __cplusplus -%{*($&1_ltype*)&$result = new $1_ltype((const $1_ltype &)$1); %} -#else -{ - $&1_ltype $1ptr = ($&1_ltype) malloc(sizeof($1_ltype)); - memmove($1ptr, &$1, sizeof($1_type)); - *($&1_ltype*)&$result = $1ptr; -} -#endif - -/* Generic pointers and references */ -%typemap(in) SWIGTYPE *, SWIGTYPE (CLASS::*) %{ $1 = *($&1_ltype)&$input; %} -%typemap(in) SWIGTYPE & %{ $1 = *($&1_ltype)&$input; - if(!$1) { - //SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null"); - RETURN $null; - } %} -%typemap(in) SWIGTYPE && %{ $1 = *($&1_ltype)&$input; - if(!$1) { - //SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "$1_type reference is null"); - RETURN $null; - } %} -%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE (CLASS::*) %{ *($&1_ltype)&$result = $1; %} - - -/* Default array handling */ -%typemap(in) SWIGTYPE [] %{ $1 = *($&1_ltype)&$input; %} -%typemap(out) SWIGTYPE [] %{ *($&1_ltype)&$result = $1; %} - -/* char[ANY] - treat as String */ -%typemap(in) char[ANY] { - $1 = $input; -} - -%typemap(argout) char[ANY] "" -%typemap(freearg) char[ANY] ""//{ if ($1) JCALL2(ReleaseStringUTFChars, jenv, $input, $1); } -%typemap(out) char[ANY] { if($1) $result = $1; } - - -/* Typecheck typemaps - The purpose of these is merely to issue a warning for overloaded C++ functions - * that cannot be overloaded in C# as more than one C++ type maps to a single C# type */ - -%typecheck(SWIG_TYPECHECK_BOOL) /* Java boolean */ - bool, - const bool & - "" - -%typecheck(SWIG_TYPECHECK_CHAR) /* Java char */ - char, - const char & - "" - -%typecheck(SWIG_TYPECHECK_INT8) /* Java byte */ - signed char, - const signed char & - "" - -%typecheck(SWIG_TYPECHECK_INT16) /* Java short */ - unsigned char, - short, - const unsigned char &, - const short & - "" - -%typecheck(SWIG_TYPECHECK_INT32) /* Java int */ - unsigned short, - int, - long, - const unsigned short &, - const int &, - const long &, - enum SWIGTYPE - "" - -%typecheck(SWIG_TYPECHECK_INT64) /* Java long */ - unsigned int, - unsigned long, - long long, - const unsigned int &, - const unsigned long &, - const long long & - "" - -%typecheck(SWIG_TYPECHECK_INT128) /* Java BigInteger */ - unsigned long long - "" - -%typecheck(SWIG_TYPECHECK_FLOAT) /* Java float */ - float, - const float & - "" - -%typecheck(SWIG_TYPECHECK_DOUBLE) /* Java double */ - double, - const double & - "" - -%typecheck(SWIG_TYPECHECK_STRING) /* Java String */ - char *, - char[ANY] - "" - -%typecheck(SWIG_TYPECHECK_POINTER) /* Default */ - SWIGTYPE, - SWIGTYPE *, - SWIGTYPE &, - SWIGTYPE &&, - SWIGTYPE [], - SWIGTYPE (CLASS::*) - "" - -/* Exception handling */ - -%typemap(throws) int, - long, - short, - unsigned int, - unsigned long, - unsigned short { - char error_msg[256]; - sprintf(error_msg, "C++ $1_type exception thrown, value: %d", $1); - SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, error_msg); - RETURN $null; -} - -%typemap(throws) SWIGTYPE { - (void)$1; - SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "C++ $1_type exception thrown"); - RETURN $null; -} - -%typemap(throws) char * { - SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, $1); - RETURN $null; -} - - -/* Typemaps for code generation in proxy classes and C# type wrapper classes */ - -/* The in typemap is used for converting function parameter types from the type - * used in the proxy, module or type wrapper class to the type used in the PInvoke class. */ -%typemap(m3in) bool, const bool &, - char, const char &, - signed char, const signed char &, - unsigned char, const unsigned char &, - short, const short &, - unsigned short, const unsigned short &, - int, const int &, - unsigned int, const unsigned int &, - long, const long &, - unsigned long, const unsigned long &, - long long, const long long &, - unsigned long long, const unsigned long long &, - float, const float &, - double, const double &, - char *, - char[ANY], - enum SWIGTYPE - "$input" -%typemap(m3in) SWIGTYPE "$&*1_type.getCPtr($input)" -%typemap(m3in) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "$1_basetype.getCPtr($input)" - -/* The m3out typemap is used for converting function return types from the return type - * used in the PInvoke class to the type returned by the proxy, module or type wrapper class. */ -%typemap(m3out) bool, const bool &, - char, const char &, - signed char, const signed char &, - unsigned char, const unsigned char &, - short, const short &, - unsigned short, const unsigned short &, - int, const int &, - unsigned int, const unsigned int &, - long, const long &, - unsigned long, const unsigned long &, - long long, const long long &, - unsigned long long, const unsigned long long &, - float, const float &, - double, const double &, - char *, - char[ANY], - enum SWIGTYPE -%{$imcall%} - -%typemap(m3out) void %{$imcall%} - -%typemap(m3out) SWIGTYPE %{ - RETURN NEW(REF $1_basetype, $imcall); -%} -%typemap(m3out) SWIGTYPE & %{ - RETURN NEW($1_basetype, $imcall, $owner); -%} -%typemap(m3out) SWIGTYPE && %{ - RETURN NEW($1_basetype, $imcall, $owner); -%} -%typemap(m3out) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{ - cPtr := $imcall; - RETURN (cPtr = IntPtr.Zero) ? null : NEW($1_basetype, cPtr, $owner); -%} - -/* Properties */ -%typemap(m3varin) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{ -PROCEDURE Set$var (value: $vartype) = - BEGIN - $imcall; - END Set$var; -%} - -%typemap(m3varout) bool, const bool &, - char, const char &, - signed char, const signed char &, - unsigned char, const unsigned char &, - short, const short &, - unsigned short, const unsigned short &, - int, const int &, - unsigned int, const unsigned int &, - long, const long &, - unsigned long, const unsigned long &, - long long, const long long &, - unsigned long long, const unsigned long long &, - float, const float &, - double, const double &, - char *, - char[ANY], - enum SWIGTYPE %{ -PROCEDURE Get$var (): $vartype = - BEGIN - RETURN $imcall; - END Get$var; -%} - -%typemap(m3varout) void %{ - get { - $imcall; - } %} -%typemap(m3varout) SWIGTYPE %{ - get { - RETURN new $&*1_mangle($imcall, true); - } %} -%typemap(m3varout) SWIGTYPE & %{ - get { - RETURN new $1_basetype($imcall, $owner); - } %} -%typemap(m3varout) SWIGTYPE && %{ - get { - RETURN new $1_basetype($imcall, $owner); - } %} -%typemap(m3varout) SWIGTYPE *, SWIGTYPE [], SWIGTYPE (CLASS::*) %{ - get { - IntPtr cPtr = $imcall; - RETURN (cPtr == IntPtr.Zero) ? null : new $1_basetype(cPtr, $owner); - } %} - -/* Typemaps used for the generation of proxy and type wrapper class code */ -%typemap(m3base) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "" -%typemap(m3classmodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "public" -%typemap(m3code) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "" -%typemap(m3imports) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "using System;" -%typemap(m3interfaces) SWIGTYPE "IDisposable" -%typemap(m3interfaces_derived) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "" -%typemap(m3ptrconstructormodifiers) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) "internal" - -%typemap(m3finalize) SWIGTYPE %{ - ~$1_basetype() { - Dispose(); - } -%} - -%typemap(m3destruct, methodname="Dispose") SWIGTYPE { - if(swigCPtr != IntPtr.Zero && swigCMemOwn) { - $imcall; - swigCMemOwn = false; - } - swigCPtr = IntPtr.Zero; - GC.SuppressFinalize(this); - } - -%typemap(m3destruct_derived, methodname="Dispose") SWIGTYPE { - if(swigCPtr != IntPtr.Zero && swigCMemOwn) { - $imcall; - swigCMemOwn = false; - } - swigCPtr = IntPtr.Zero; - GC.SuppressFinalize(this); - base.Dispose(); - } - -%typemap(m3getcptr) SWIGTYPE, SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [], SWIGTYPE (CLASS::*) %{ - internal static IntPtr getCPtr($1_basetype obj) { - RETURN (obj == null) ? IntPtr.Zero : obj.swigCPtr; - } -%} - -/* M3 specific directives */ -#define %m3multiretval %feature("modula3:multiretval") -#define %constnumeric(num) %feature("constnumeric","num") - -%pragma(modula3) moduleimports=%{ -IMPORT BlaBla; -%} - -%pragma(modula3) imclassimports=%{ -FROM BlaBla IMPORT Bla; -%} - -/* Some ANSI C typemaps */ - -%apply unsigned long { size_t }; - -/* Array reference typemaps */ -%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) } -%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) } - -/* const pointers */ -%apply SWIGTYPE * { SWIGTYPE *const } -%apply SWIGTYPE (CLASS::*) { SWIGTYPE (CLASS::*const) } -%apply SWIGTYPE & { SWIGTYPE (CLASS::*const&) } - diff --git a/Lib/modula3/modula3head.swg b/Lib/modula3/modula3head.swg deleted file mode 100644 index af96a78d1..000000000 --- a/Lib/modula3/modula3head.swg +++ /dev/null @@ -1,64 +0,0 @@ -/* ----------------------------------------------------------------------------- - * modula3head.swg - * - * Modula3 support code - * ----------------------------------------------------------------------------- */ - -%insert(runtime) %{ - -#include <stdlib.h> -#include <string.h> -#include <stdio.h> -%} - -#if 0 -%insert(runtime) %{ -/* Support for throwing Modula3 exceptions */ -typedef enum { - SWIG_JavaOutOfMemoryError = 1, - SWIG_JavaIOException, - SWIG_JavaRuntimeException, - SWIG_JavaIndexOutOfBoundsException, - SWIG_JavaArithmeticException, - SWIG_JavaIllegalArgumentException, - SWIG_JavaNullPointerException, - SWIG_JavaUnknownError -} SWIG_JavaExceptionCodes; - -typedef struct { - SWIG_JavaExceptionCodes code; - const char *java_exception; -} SWIG_JavaExceptions_t; - -#if defined(SWIG_NOINCLUDE) -void SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg); -#else -%} -%insert(runtime) { -void SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) { - jclass excep; - static const SWIG_JavaExceptions_t java_exceptions[] = { - { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" }, - { SWIG_JavaIOException, "java/io/IOException" }, - { SWIG_JavaRuntimeException, "java/lang/RuntimeException" }, - { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" }, - { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" }, - { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" }, - { SWIG_JavaNullPointerException, "java/lang/NullPointerException" }, - { SWIG_JavaUnknownError, "java/lang/UnknownError" }, - { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" } }; - const SWIG_JavaExceptions_t *except_ptr = java_exceptions; - - while (except_ptr->code != code && except_ptr->code) - except_ptr++; - - JCALL0(ExceptionClear, jenv); - excep = JCALL1(FindClass, jenv, except_ptr->java_exception); - if (excep) - JCALL2(ThrowNew, jenv, excep, msg); -} -} -%insert(runtime) %{ -#endif -%} -#endif diff --git a/Lib/modula3/typemaps.i b/Lib/modula3/typemaps.i deleted file mode 100644 index 1d76ab5e0..000000000 --- a/Lib/modula3/typemaps.i +++ /dev/null @@ -1,74 +0,0 @@ -/* ----------------------------------------------------------------------------- - * typemaps.i - * - * Pointer and reference handling typemap library - * - * These mappings provide support for input/output arguments and common - * uses for C/C++ pointers and C++ references. - * ----------------------------------------------------------------------------- */ - -/* These typemaps will eventually probably maybe make their way into named typemaps - * OUTPUT * and OUTPUT & as they currently break functions that return a pointer or - * reference. */ - -%typemap(ctype) bool *, bool & "bool *" -%typemap(ctype) char & "char *" -%typemap(ctype) signed char *, signed char & "signed char *" -%typemap(ctype) unsigned char *, unsigned char & "unsigned short *" -%typemap(ctype) short *, short & "short *" -%typemap(ctype) unsigned short *, unsigned short & "unsigned short *" -%typemap(ctype) int *, int & "int *" -%typemap(ctype) unsigned int *, unsigned int & "unsigned int *" -%typemap(ctype) long *, long & "long *" -%typemap(ctype) unsigned long *, unsigned long & "unsigned long *" -%typemap(ctype) long long *, long long & "long long *" -%typemap(ctype) unsigned long long *, unsigned long long & "unsigned long long *" -%typemap(ctype) float *, float & "float *" -%typemap(ctype) double *, double & "double *" - -%typemap(imtype) bool *, bool & "ref bool" -%typemap(imtype) char & "ref char" -%typemap(imtype) signed char *, signed char & "ref sbyte" -%typemap(imtype) unsigned char *, unsigned char & "ref byte" -%typemap(imtype) short *, short & "ref short" -%typemap(imtype) unsigned short *, unsigned short & "ref ushort" -%typemap(imtype) int *, int & "ref int" -%typemap(imtype) unsigned int *, unsigned int & "ref uint" -%typemap(imtype) long *, long & "ref int" -%typemap(imtype) unsigned long *, unsigned long & "ref uint" -%typemap(imtype) long long *, long long & "ref long" -%typemap(imtype) unsigned long long *, unsigned long long & "ref ulong" -%typemap(imtype) float *, float & "ref float" -%typemap(imtype) double *, double & "ref double" - -%typemap(cstype) bool *, bool & "ref bool" -%typemap(cstype) char & "ref char" -%typemap(cstype) signed char *, signed char & "ref sbyte" -%typemap(cstype) unsigned char *, unsigned char & "ref byte" -%typemap(cstype) short *, short & "ref short" -%typemap(cstype) unsigned short *, unsigned short & "ref ushort" -%typemap(cstype) int *, int & "ref int" -%typemap(cstype) unsigned int *, unsigned int & "ref uint" -%typemap(cstype) long *, long & "ref int" -%typemap(cstype) unsigned long *, unsigned long & "ref uint" -%typemap(cstype) long long *, long long & "ref long" -%typemap(cstype) unsigned long long *, unsigned long long & "ref ulong" -%typemap(cstype) float *, float & "ref float" -%typemap(cstype) double *, double & "ref double" - -%typemap(csin) bool *, bool &, - char &, - signed char *, signed char &, - unsigned char *, unsigned char &, - short *, short &, - unsigned short *, unsigned short &, - int *, int &, - unsigned int *, unsigned int &, - long *, long &, - unsigned long *, unsigned long &, - long long *, long long &, - unsigned long long *, unsigned long long &, - float *, float &, - double *, double & - "ref $csinput" - diff --git a/Lib/octave/octcomplex.swg b/Lib/octave/octcomplex.swg index 87e77a62e..553c25a3d 100644 --- a/Lib/octave/octcomplex.swg +++ b/Lib/octave/octcomplex.swg @@ -2,7 +2,7 @@ Defines the As/From conversors for double/float complex, you need to provide complex Type, the Name you want to use in the conversors, the complex Constructor method, and the Real and Imag complex - accesor methods. + accessor methods. See the std_complex.i and ccomplex.i for concrete examples. */ diff --git a/Lib/perl5/perltypemaps.swg b/Lib/perl5/perltypemaps.swg index bf1596e9f..42f8887be 100644 --- a/Lib/perl5/perltypemaps.swg +++ b/Lib/perl5/perltypemaps.swg @@ -56,7 +56,9 @@ %define %set_output(obj) $result = obj; argvi++ %enddef /* append output */ -%define %append_output(obj) if (argvi >= items) EXTEND(sp, argvi+1); %set_output(obj) %enddef +%define %append_output(obj) +if (argvi >= items) EXTEND(sp, argvi+1); +%set_output(obj) %enddef /* variable output */ %define %set_varoutput(obj) sv_setsv($result,obj) %enddef @@ -95,7 +97,7 @@ "sv_setiv(SvRV($result), PTR2IV(&$1));"; %typemap(varout,type="$1_descriptor") SWIGTYPE (CLASS::*) { - SWIG_MakePackedObj($result, (void *) &$1, sizeof($1_type), $1_descriptor); + SWIG_MakePackedObj($result, (void *) &$1, sizeof($1), $1_descriptor); } %typemap(varout) SWIGTYPE *const = SWIGTYPE *; diff --git a/Lib/php/const.i b/Lib/php/const.i index 32b4b9b0b..3b40c2c7f 100644 --- a/Lib/php/const.i +++ b/Lib/php/const.i @@ -3,6 +3,58 @@ * * Typemaps for constants * ----------------------------------------------------------------------------- */ +%typemap(classconsttab) int, + unsigned int, + short, + unsigned short, + long, + unsigned long, + unsigned char, + signed char, + enum SWIGTYPE %{ + zend_declare_class_constant_long(SWIGTYPE_$class_ce, "$const_name", sizeof("$const_name") - 1, ($1_type)$value); +%} + +%typemap(classconsttab) bool %{ + zend_declare_class_constant_bool(SWIGTYPE_$class_ce, "$const_name", sizeof("$const_name") - 1, ($1_type)$value); +%} + +%typemap(classconsttab) float, + double %{ + zend_declare_class_constant_double(SWIGTYPE_$class_ce, "$const_name", sizeof("$const_name") - 1, $value); +%} + +%typemap(classconsttab) char %{ +{ + char swig_char = $value; + zend_declare_class_constant_stringl(SWIGTYPE_$class_ce, "$const_name", sizeof("$const_name") - 1, &swig_char, 1); +} +%} + +%typemap(classconsttab) char *, + const char *, + char [], + const char [] %{ + zend_declare_class_constant_string(SWIGTYPE_$class_ce, "$const_name", sizeof("$const_name") - 1, $value); +%} + +// This creates a zend_object to wrap the pointer, and we can't do that +// before the Zend runtime has been initialised so we delay it until +// RINIT. The downside is it then happens for every request. +%typemap(classconsttab,rinit=1) SWIGTYPE *, + SWIGTYPE &, + SWIGTYPE &&, + SWIGTYPE [] %{ +{ + zval z; + ZVAL_UNDEF(&z); + SWIG_SetPointerZval(&z, (void*)$value, $1_descriptor, 0); + zval_copy_ctor(&z); + zend_declare_class_constant(SWIGTYPE_$class_ce, "$const_name", sizeof("$const_name") - 1, &z); +} +%} + +%typemap(classconsttab) SWIGTYPE (CLASS::*) ""; %typemap(consttab) int, unsigned int, @@ -31,11 +83,15 @@ const char [] "SWIG_STRING_CONSTANT($symname, $value);"; -%typemap(consttab) SWIGTYPE *, +// This creates a zend_object to wrap the pointer, and we can't do that +// before the Zend runtime has been initialised so we delay it until +// RINIT. The downside is it then happens for every request. +%typemap(consttab,rinit=1) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] { zend_constant c; + ZVAL_UNDEF(&c.value); SWIG_SetPointerZval(&c.value, (void*)$value, $1_descriptor, 0); zval_copy_ctor(&c.value); c.name = zend_string_init("$symname", sizeof("$symname") - 1, 0); diff --git a/Lib/php/director.swg b/Lib/php/director.swg index ea0eba8ac..68be6a3ba 100644 --- a/Lib/php/director.swg +++ b/Lib/php/director.swg @@ -8,6 +8,8 @@ #ifndef SWIG_DIRECTOR_PHP_HEADER_ #define SWIG_DIRECTOR_PHP_HEADER_ +#define SWIG_DIRECTOR_CAST(ARG) dynamic_cast<Swig::Director *>(ARG) + #include <string> #include <exception> #include <map> @@ -76,31 +78,39 @@ namespace Swig { }; class Director { + private: + /* flag indicating whether the object is owned by PHP or C++ */ + mutable bool swig_disown_flag; + protected: // "mutable" so we can get a non-const pointer to it in const methods. mutable zval swig_self; typedef std::map<void *, GCItem_var> swig_ownership_map; mutable swig_ownership_map swig_owner; + public: - Director(zval *self) { + Director(zval *self) : swig_disown_flag(false) { ZVAL_COPY_VALUE(&swig_self, self); } - static bool swig_is_overridden_method(const char *cname, const char *lc_fname) { - bool result = false; + ~Director() { + if (swig_disown_flag) { + Z_DELREF(swig_self); + } + } + + void swig_disown() const { + if (!swig_disown_flag) { + swig_disown_flag = true; + Z_ADDREF(swig_self); + } + } + + static bool swig_is_overridden_method(const char *cname, zval *z) { zend_string * cname_str = zend_string_init(cname, strlen(cname), 0); zend_class_entry *ce = zend_lookup_class(cname_str); - if (ce) { - zval * mptr = zend_hash_str_find(&ce->function_table, lc_fname, strlen(lc_fname)); - if (mptr) { - // common.scope points to zend_class_entry for the declaring class, - // and there's only one of those per class, so we can just use a - // pointer compare here. - result = Z_FUNC_P(mptr)->common.scope != ce; - } - } zend_string_release(cname_str); - return result; + return ce == Z_OBJCE_P(z); } template <typename Type> @@ -109,6 +119,12 @@ namespace Swig { swig_owner[vptr] = new GCItem_T<Type>(vptr); } } + + void swig_acquire_ownership_obj(void *vptr, int own) const { + if (vptr && own) { + swig_owner[vptr] = new GCItem_Object(own); + } + } }; /* base class for director exceptions */ @@ -121,8 +137,8 @@ namespace Swig { swig_msg += " "; swig_msg += msg; } - SWIG_ErrorCode() = code; - SWIG_ErrorMsg() = swig_msg.c_str(); + // Don't replace an already active PHP exception. + if (!EG(exception)) zend_throw_exception(NULL, swig_msg.c_str(), code); } virtual ~DirectorException() throw() { @@ -150,8 +166,7 @@ namespace Swig { }; /* any php exception that occurs during a director method call */ - class DirectorMethodException : public DirectorException - { + class DirectorMethodException : public DirectorException { public: DirectorMethodException() : DirectorException(E_ERROR, "SWIG director method error", NULL) { diff --git a/Lib/php/factory.i b/Lib/php/factory.i index c4e082dd2..5a1f9dc06 100644 --- a/Lib/php/factory.i +++ b/Lib/php/factory.i @@ -3,41 +3,41 @@ you have: ---- geometry.h -------- - struct Geometry { - enum GeomType{ - POINT, - CIRCLE - }; - - virtual ~Geometry() {} + struct Geometry { + enum GeomType{ + POINT, + CIRCLE + }; + + virtual ~Geometry() {} virtual int draw() = 0; - + // // Factory method for all the Geometry objects // - static Geometry *create(GeomType i); - }; - - struct Point : Geometry { - int draw() { return 1; } - double width() { return 1.0; } - }; - - struct Circle : Geometry { - int draw() { return 2; } - double radius() { return 1.5; } - }; - + static Geometry *create(GeomType i); + }; + + struct Point : Geometry { + int draw() { return 1; } + double width() { return 1.0; } + }; + + struct Circle : Geometry { + int draw() { return 2; } + double radius() { return 1.5; } + }; + // // Factory method for all the Geometry objects // Geometry *Geometry::create(GeomType type) { - switch (type) { - case POINT: return new Point(); - case CIRCLE: return new Circle(); - default: return 0; - } - } + switch (type) { + case POINT: return new Point(); + case CIRCLE: return new Circle(); + default: return 0; + } + } ---- geometry.h -------- @@ -57,16 +57,16 @@ NOTES: remember to fully qualify all the type names and don't use %factory inside a namespace declaration, ie, instead of - + namespace Foo { %factory(Geometry *Geometry::create, Point, Circle); } use - %factory(Foo::Geometry *Foo::Geometry::create, Foo::Point, Foo::Circle); + %factory(Foo::Geometry *Foo::Geometry::create, Foo::Point, Foo::Circle); + - */ /* for loop for macro with one argument */ @@ -90,13 +90,13 @@ /* for loop for macro with two arguments */ %define %formacro_2(macro,...)%_formacro_2(macro, __VA_ARGS__, __fordone__)%enddef -%define %_factory_dispatch(Type) +%define %_factory_dispatch(Type) if (!dcast) { Type *dobj = dynamic_cast<Type *>($1); if (dobj) { dcast = 1; - SWIG_SetPointerZval(return_value, SWIG_as_voidptr(dobj),$descriptor(Type *), $owner); - } + SWIG_SetPointerZval(return_value, SWIG_as_voidptr(dobj), $descriptor(Type *), $owner); + } }%enddef %define %factory(Method,Types...) @@ -104,6 +104,6 @@ if (!dcast) { int dcast = 0; %formacro(%_factory_dispatch, Types) if (!dcast) { - SWIG_SetPointerZval(return_value, SWIG_as_voidptr($1),$descriptor, $owner); + SWIG_SetPointerZval(return_value, SWIG_as_voidptr($1), $descriptor, $owner); } }%enddef diff --git a/Lib/php/globalvar.i b/Lib/php/globalvar.i deleted file mode 100644 index 6b31207a6..000000000 --- a/Lib/php/globalvar.i +++ /dev/null @@ -1,293 +0,0 @@ -/* ----------------------------------------------------------------------------- - * globalvar.i - * - * Global variables - add the variable to PHP - * ----------------------------------------------------------------------------- */ - -%typemap(varinit) char * -{ - zval z_var; - if ($1) { - ZVAL_STRING(&z_var, $1); - } else { - ZVAL_STR(&z_var, ZSTR_EMPTY_ALLOC()); - } - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) char [] -{ - zval z_var; - ZVAL_STRING(&z_var, $1); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) int, - unsigned int, - unsigned short, - short, - unsigned short, - long, - unsigned long, - signed char, - unsigned char, - enum SWIGTYPE -{ - zval z_var; - ZVAL_LONG(&z_var, (long)$1); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) bool -{ - zval z_var; - ZVAL_BOOL(&z_var, ($1)?1:0); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) float, double -{ - zval z_var; - ZVAL_DOUBLE(&z_var, (double)$1); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) char -{ - zval z_var; - char c = $1; - ZVAL_STRINGL(&z_var, &c, 1); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) SWIGTYPE *, SWIGTYPE [] -{ - zval z_var; - SWIG_SetPointerZval(&z_var, (void*)$1, $1_descriptor, 0); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) SWIGTYPE, SWIGTYPE &, SWIGTYPE && -{ - zval z_var; - SWIG_SetPointerZval(&z_var, (void*)&$1, $&1_descriptor, 0); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit) char [ANY] -{ - zval z_var; - /* varinit char [ANY] */ - ZVAL_STRINGL(&z_var, $1, $1_dim0); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &z_var); -} - -%typemap(varinit, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*) -{ - zval resource; - void * p = emalloc(sizeof($1)); - memcpy(p, &$1, sizeof($1)); - ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr)); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource); -} - -%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - $1 = zval_get_long(z_var); -} - -%typemap(varin) bool -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - convert_to_boolean(z_var); - $1 = (Z_TYPE_P(z_var) == IS_TRUE); -} - -%typemap(varin) double,float -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - $1 = zval_get_double(z_var); -} - -%typemap(varin) char -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - convert_to_string(z_var); - if ($1 != Z_STRVAL_P(z_var)[0]) { - $1 = Z_STRVAL_P(z_var)[0]; - } -} - -%typemap(varin) char * -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - char *s1; - convert_to_string(z_var); - s1 = Z_STRVAL_P(z_var); - if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) { - if (s1) - $1 = estrdup(s1); - else - $1 = NULL; - } -} - - -%typemap(varin) SWIGTYPE [] -{ - if ($1) { - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, $owner); - } -} - -%typemap(varin) char [ANY] -{ - zval **z_var; - char *s1; - - zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1, (void**)&z_var); - s1 = Z_STRVAL_P(z_var); - if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) { - if (s1) - strncpy($1, s1, $1_dim0); - } -} - -%typemap(varin) SWIGTYPE -{ - zval *z_var; - $&1_ltype _temp; - - z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - if (SWIG_ConvertPtr(z_var, (void**)&_temp, $&1_descriptor, 0) < 0) { - SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor"); - } - - $1 = *($&1_ltype)_temp; -} - -%typemap(varin) SWIGTYPE *, SWIGTYPE &, SWIGTYPE && -{ - zval *z_var; - $1_ltype _temp; - - z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - if (SWIG_ConvertPtr(z_var, (void **)&_temp, $1_descriptor, 0) < 0) { - SWIG_PHP_Error(E_ERROR,"Type error in value of $symname. Expected $&1_descriptor"); - } - - $1 = ($1_ltype)_temp; -} - -%typemap(varin, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*) -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - void * p = (void*)zend_fetch_resource_ex(z_var, SWIG_MEMBER_PTR, swig_member_ptr); - memcpy(&$1, p, sizeof($1)); -} - -%typemap(varout) int, - unsigned int, - unsigned short, - short, - long, - unsigned long, - signed char, - unsigned char, - enum SWIGTYPE -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - if ($1 != ($1_ltype)Z_LVAL_P(z_var)) { - z_var->value.lval = (long)$1; - } -} - -//SAMFIX need to cast zval->type, what if zend-hash_find fails? etc? -%typemap(varout) bool -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - if ($1 != ($1_ltype)Z_LVAL_P(z_var)) { - z_var->value.lval = (long)$1; - } -} - -%typemap(varout) double, float -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - if ($1 != ($1_ltype)Z_DVAL_P(z_var)) { - z_var->value.dval = (double)$1; - } -} - -%typemap(varout) char -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - char c = $1; - if ($1 != Z_STRVAL_P(z_val)[0]) { - ZVAL_STRING(z_var, &c); - } -} - -%typemap(varout) char * -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - const char *s1 = Z_STRVAL_P(z_var); - if ((s1 == NULL) || ($1 == NULL) || strcmp(s1, $1)) { - if (s1) - efree(s1); - if ($1) { - (z_var)->value.str.val = estrdup($1); - (z_var)->value.str.len = strlen($1) + 1; - } else { - (z_var)->value.str.val = 0; - (z_var)->value.str.len = 0; - } - } -} - -%typemap(varout) SWIGTYPE -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - SWIG_SetPointerZval(z_var, (void*)&$1, $&1_descriptor, 0); -} - -%typemap(varout) SWIGTYPE [] -{ - if($1) { - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0); - } -} - -%typemap(varout) char [ANY] -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - const char *s1 = Z_STRVAL_P(z_var); -deliberate error cos this code looks bogus to me - if ((s1 == NULL) || strcmp(s1, $1)) { - if ($1) { - (z_var)->value.str.val = estrdup($1); - (z_var)->value.str.len = strlen($1) + 1; - } else { - (z_var)->value.str.val = 0; - (z_var)->value.str.len = 0; - } - } -} - -%typemap(varout) SWIGTYPE *, SWIGTYPE &, SWIGTYPE && -{ - zval *z_var = zend_hash_str_find(&EG(symbol_table), "$1", sizeof("$1") - 1); - SWIG_SetPointerZval(z_var, (void*)$1, $1_descriptor, 0); -} - -%typemap(varout, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*) -{ - zval resource; - void * p = emalloc(sizeof($1)); - memcpy(p, &$1, sizeof($1)); - ZVAL_RES(&resource, zend_register_resource(p, swig_member_ptr)); - zend_hash_str_add(&EG(symbol_table), "$1", sizeof("$1") - 1, &resource); -} diff --git a/Lib/php/php.swg b/Lib/php/php.swg index 4eba6be2a..6e4ee2d2f 100644 --- a/Lib/php/php.swg +++ b/Lib/php/php.swg @@ -10,7 +10,6 @@ %include <phpinit.swg> // PHP initialization routine. -%include <globalvar.i> // Global variables. %include <const.i> // use %init %{ "/*code goes here*/ " %} @@ -86,56 +85,74 @@ /* Object passed by value. Convert to a pointer */ %typemap(in) SWIGTYPE ($&1_ltype tmp) %{ - if (SWIG_ConvertPtr(&$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) { - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor"); - } - $1 = *tmp; + if (SWIG_ConvertPtr(&$input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) { + zend_type_error("Expected $&1_descriptor for argument $argnum of $symname"); + return; + } + $1 = *tmp; %} %typemap(directorout) SWIGTYPE ($&1_ltype tmp) %{ - /* If exit was via exception, PHP NULL is returned so skip the conversion. */ - if (!EG(exception)) { - if (SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $&1_descriptor"); - $result = *tmp; - } + if (SWIG_ConvertPtr($input, (void **) &tmp, $&1_descriptor, 0) < 0 || tmp == NULL) { + zend_type_error("Expected $&1_descriptor for argument $argnum of $symname"); + SWIG_fail; + } + $result = *tmp; %} %typemap(in) SWIGTYPE *, SWIGTYPE [] %{ - if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) { - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor"); - } + if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0) { + zend_type_error("Expected $1_descriptor for argument $argnum of $symname"); + return; + } +%} + +%typemap(directorout) SWIGTYPE * (swig_owntype own), + SWIGTYPE [] (swig_owntype own) +%{ + if (SWIG_ConvertPtrAndOwn($input, (void **)&$result, $1_descriptor, SWIG_POINTER_DISOWN, &own) < 0) { + zend_type_error("Expected $1_descriptor for argument $argnum of $symname"); + SWIG_fail; + } + swig_acquire_ownership_obj((void*)$result, own); %} -%typemap(in) SWIGTYPE & +%typemap(in) SWIGTYPE &, + SWIGTYPE && %{ - if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) { - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor"); - } + if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) { + zend_type_error("Expected $1_descriptor for argument $argnum of $symname"); + return; + } %} -%typemap(in) SWIGTYPE && +%typemap(directorout) SWIGTYPE & ($1_ltype tmp), + SWIGTYPE && ($1_ltype tmp) %{ - if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, 0) < 0 || $1 == NULL) { - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor"); - } + if (SWIG_ConvertPtr($input, (void **) &tmp, $1_descriptor, 0) < 0 || tmp == NULL) { + zend_type_error("Expected $1_descriptor for argument $argnum of $symname"); + SWIG_fail; + } + $result = tmp; %} %typemap(in) SWIGTYPE *const& ($*ltype temp) %{ - if (SWIG_ConvertPtr(&$input, (void **) &temp, $*1_descriptor, 0) < 0) { - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $*1_descriptor"); - } - $1 = ($1_ltype)&temp; + if (SWIG_ConvertPtr(&$input, (void **) &temp, $*1_descriptor, 0) < 0) { + zend_type_error("Expected $*1_descriptor for argument $argnum of $symname"); + return; + } + $1 = ($1_ltype)&temp; %} %typemap(in) SWIGTYPE *DISOWN %{ - if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN ) < 0) { - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor"); + if (SWIG_ConvertPtr(&$input, (void **) &$1, $1_descriptor, SWIG_POINTER_DISOWN) < 0) { + zend_type_error("Expected $1_descriptor for argument $argnum of $symname"); + return; } %} @@ -146,17 +163,20 @@ %typemap(in) void * %{ - if (SWIG_ConvertPtr(&$input, (void **) &$1, 0, 0) < 0) { - /* Allow NULL from php for void* */ - if (Z_ISNULL($input)) $1=0; - else - SWIG_PHP_Error(E_ERROR, "Type error in argument $argnum of $symname. Expected $1_descriptor"); - } + if (SWIG_ConvertPtr(&$input, (void **) &$1, 0, 0) < 0) { + /* Allow NULL from php for void* */ + if (Z_ISNULL($input)) { + $1=0; + } else { + zend_type_error("Expected $1_descriptor for argument $argnum of $symname"); + return; + } + } %} /* Special case when void* is passed by reference so it can be made to point to opaque api structs */ -%typemap(in) void ** ($*1_ltype ptr, int force), +%typemap(in, byref=1) void ** ($*1_ltype ptr, int force), void *& ($*1_ltype ptr, int force) { /* If they pass NULL by reference, make it into a void* @@ -165,7 +185,8 @@ /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */ if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) { /* wasn't a pre/ref/thing, OR anything like an int thing */ - SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname."); + zend_throw_exception(zend_ce_type_error, "Type error in argument $arg of $symname", 0); + return; } } force=0; @@ -183,8 +204,8 @@ %typemap(argout) void **, void *& %{ - if (force$argnum) { - SWIG_SetPointerZval(&$input, (void*) ptr$argnum, $*1_descriptor, 1); + if (force$argnum && Z_ISREF($input)) { + SWIG_SetPointerZval(Z_REFVAL($input), (void*) ptr$argnum, $*1_descriptor, 1); } %} @@ -370,12 +391,12 @@ SWIGTYPE &, SWIGTYPE && %{ - SWIG_SetPointerZval(return_value, (void *)$1, $1_descriptor, $owner); + SWIG_SetPointerZval($result, (void *)$1, $1_descriptor, $owner); %} %typemap(out) SWIGTYPE *const& %{ - SWIG_SetPointerZval(return_value, (void *)*$1, $*1_descriptor, $owner); + SWIG_SetPointerZval($result, (void *)*$1, $*1_descriptor, $owner); %} %typemap(directorin) SWIGTYPE *, @@ -383,19 +404,19 @@ SWIGTYPE &, SWIGTYPE && %{ - SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, ($owner)|2); + SWIG_SetPointerZval($input, (void *)&$1, $1_descriptor, $owner); %} -%typemap(out, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*) +%typemap(out) SWIGTYPE (CLASS::*) { void * p = emalloc(sizeof($1)); memcpy(p, &$1, sizeof($1)); - RETVAL_RES(zend_register_resource(p, swig_member_ptr)); + SWIG_SetPointerZval($result, (void *)p, $&1_descriptor, 1); } -%typemap(in, fragment="swig_php_init_member_ptr") SWIGTYPE (CLASS::*) +%typemap(in) SWIGTYPE (CLASS::*) { - void * p = (void*)zend_fetch_resource_ex(&$input, SWIG_MEMBER_PTR, swig_member_ptr); + void * p = SWIG_Z_FETCH_OBJ_P(&$input)->ptr; memcpy(&$1, p, sizeof($1)); } @@ -403,33 +424,30 @@ SWIGTYPE &DYNAMIC { swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1); - SWIG_SetPointerZval(return_value, (void *)$1, ty, $owner); + SWIG_SetPointerZval($result, (void *)$1, ty, $owner); } %typemap(out) SWIGTYPE -#ifdef __cplusplus { +#ifdef __cplusplus $&1_ltype resultobj = new $1_ltype((const $1_ltype &) $1); - SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1); -} #else -{ - $&1_ltype resultobj = ($&1_ltype) emalloc(sizeof($1_type)); + $&1_ltype resultobj = ($&1_ltype) malloc(sizeof($1_type)); memcpy(resultobj, &$1, sizeof($1_type)); - SWIG_SetPointerZval(return_value, (void *)resultobj, $&1_descriptor, 1); -} #endif + SWIG_SetPointerZval($result, (void *)resultobj, $&1_descriptor, 1); +} %typemap(directorin) SWIGTYPE %{ - SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1|2); + SWIG_SetPointerZval($input, SWIG_as_voidptr(new $1_ltype((const $1_ltype &)$1)), $&1_descriptor, 1); %} %typemap(out) void ""; %typemap(out) char [ANY] { - int len = 0; + size_t len = 0; while (len < $1_dim0 && $1[len]) ++len; RETVAL_STRINGL($1, len); } @@ -465,7 +483,10 @@ %php_typecheck(double,SWIG_TYPECHECK_DOUBLE,IS_DOUBLE) %php_typecheck(char,SWIG_TYPECHECK_CHAR,IS_STRING) -%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *&, char [] +%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char *, char *& + " $1 = (Z_TYPE($input) == IS_STRING || Z_TYPE($input) == IS_NULL); " + +%typemap(typecheck,precedence=SWIG_TYPECHECK_STRING) char [] " $1 = (Z_TYPE($input) == IS_STRING); " %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE @@ -537,3 +558,6 @@ /* php keywords */ %include <phpkw.swg> + +/* PHP known interfaces */ +%include <phpinterfaces.i> diff --git a/Lib/php/phpinit.swg b/Lib/php/phpinit.swg index 1665f5dc4..40f7b0766 100644 --- a/Lib/php/phpinit.swg +++ b/Lib/php/phpinit.swg @@ -7,19 +7,6 @@ %init %{ SWIG_php_minit { + zend_class_entry SWIGUNUSED internal_ce; SWIG_InitializeModule((void*)&module_number); %} - -%fragment("swig_php_init_member_ptr2", "header") %{ -#define SWIG_MEMBER_PTR "CLASS::*" - -static void swig_member_ptr_dtor(zend_resource *res) { - efree(res->ptr); -} - -static int swig_member_ptr = 0; -%} - -%fragment("swig_php_init_member_ptr", "init", fragment="swig_php_init_member_ptr2") %{ - swig_member_ptr = zend_register_list_destructors_ex(swig_member_ptr_dtor, NULL, SWIG_MEMBER_PTR, module_number); -%} diff --git a/Lib/php/phpinterfaces.i b/Lib/php/phpinterfaces.i new file mode 100644 index 000000000..dda219d91 --- /dev/null +++ b/Lib/php/phpinterfaces.i @@ -0,0 +1,62 @@ +/* ----------------------------------------------------------------------------- + * phpinterfaces.i + * + * Define "known" PHP interfaces. + * + * These can be added at MINIT time (which is when PHP loads the extension + * module). + * + * Any interface can be added via phpinterfaces, but looking up the + * zend_class_entry by name has to wait until RINIT time, which means it + * happens for every request. + * ----------------------------------------------------------------------------- */ + +// Note: Abstract interfaces such as "Traversable" can't be used in +// "implements" so are not relevant here. + +%insert(header) %{ + +#define SWIG_PHP_INTERFACE_Iterator_CE zend_ce_iterator +#define SWIG_PHP_INTERFACE_Iterator_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_IteratorAggregate_CE zend_ce_aggregate +#define SWIG_PHP_INTERFACE_IteratorAggregate_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_ArrayAccess_CE zend_ce_arrayaccess +#define SWIG_PHP_INTERFACE_ArrayAccess_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_Serializable_CE zend_ce_serializable +#define SWIG_PHP_INTERFACE_Serializable_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_Countable_CE zend_ce_countable +#define SWIG_PHP_INTERFACE_Countable_HEADER "zend_interfaces.h" + +#define SWIG_PHP_INTERFACE_OuterIterator_CE spl_ce_OuterIterator +#define SWIG_PHP_INTERFACE_OuterIterator_HEADER "ext/spl/spl_iterators.h" + +#define SWIG_PHP_INTERFACE_RecursiveIterator_CE spl_ce_RecursiveIterator +#define SWIG_PHP_INTERFACE_RecursiveIterator_HEADER "ext/spl/spl_iterators.h" + +#define SWIG_PHP_INTERFACE_SeekableIterator_CE spl_ce_SeekableIterator +#define SWIG_PHP_INTERFACE_SeekableIterator_HEADER "ext/spl/spl_iterators.h" + +#define SWIG_PHP_INTERFACE_SplObserver_CE spl_ce_SplObserver +#define SWIG_PHP_INTERFACE_SplObserver_HEADER "ext/spl/spl_observer.h" + +#define SWIG_PHP_INTERFACE_SplSubject_CE spl_ce_SplSubject +#define SWIG_PHP_INTERFACE_SplSubject_HEADER "ext/spl/spl_observer.h" + +#define SWIG_PHP_INTERFACE_DateTimeInterface_CE php_date_get_interface_ce() +#define SWIG_PHP_INTERFACE_DateTimeInterface_HEADER "ext/date/php_date.h" + +// The "json" extension needs to be loaded earlier that us for this to work. +#define SWIG_PHP_INTERFACE_JsonSerializable_CE php_json_serializable_ce +#define SWIG_PHP_INTERFACE_JsonSerializable_HEADER "ext/json/php_json.h" + +// New in PHP 8.0. +#if PHP_MAJOR >= 8 +# define SWIG_PHP_INTERFACE_Stringable_CE zend_ce_stringable +# define SWIG_PHP_INTERFACE_Stringable_HEADER "zend_interfaces.h" +#endif + +%} diff --git a/Lib/php/phpkw.swg b/Lib/php/phpkw.swg index 5c5296a1f..e431fc2e4 100644 --- a/Lib/php/phpkw.swg +++ b/Lib/php/phpkw.swg @@ -55,6 +55,7 @@ PHPKW(endwhile); PHPKW(extends); PHPKW(final); PHPKW(finally); +PHPKW(fn); // as of PHP 7.4 PHPKW(for); PHPKW(foreach); PHPKW(function); @@ -65,6 +66,7 @@ PHPKW(implements); PHPKW(instanceof); PHPKW(insteadof); PHPKW(interface); +PHPKW(match); // as of PHP 8.0 PHPKW(namespace); PHPKW(new); PHPKW(or); @@ -119,6 +121,10 @@ PHPBN2(PHP_SAPI); PHPBN2(PHP_EOL); PHPBN2(PHP_INT_MAX); PHPBN2(PHP_INT_SIZE); +PHPBN2(PHP_FLOAT_DIG); // Since 7.2.0 +PHPBN2(PHP_FLOAT_EPSILON); // Since 7.2.0 +PHPBN2(PHP_FLOAT_MIN); // Since 7.2.0 +PHPBN2(PHP_FLOAT_MAX); // Since 7.2.0 PHPBN2(DEFAULT_INCLUDE_PATH); PHPBN2(PEAR_INSTALL_DIR); PHPBN2(PEAR_EXTENSION_DIR); @@ -134,6 +140,7 @@ PHPBN2(PHP_LOCALSTATEDIR); PHPBN2(PHP_CONFIG_FILE_PATH); PHPBN2(PHP_CONFIG_FILE_SCAN_DIR); PHPBN2(PHP_SHLIB_SUFFIX); +PHPBN2(PHP_FD_SETSIZE); // Since 7.1.0 PHPBN2(E_ERROR); PHPBN2(E_WARNING); PHPBN2(E_PARSE); @@ -145,6 +152,7 @@ PHPBN2(E_COMPILE_WARNING); PHPBN2(E_USER_ERROR); PHPBN2(E_USER_WARNING); PHPBN2(E_USER_NOTICE); +PHPBN2(E_RECOVERABLE_ERROR); PHPBN2(E_DEPRECATED); PHPBN2(E_USER_DEPRECATED); PHPBN2(E_ALL); @@ -156,6 +164,9 @@ PHPBN2(__COMPILER_HALT_OFFSET__); PHPBN2(PHP_OUTPUT_HANDLER_START); PHPBN2(PHP_OUTPUT_HANDLER_CONT); PHPBN2(PHP_OUTPUT_HANDLER_END); +/* Since 7.4.0 (Microsoft Windows only) */ +PHPBN2(PHP_WINDOWS_EVENT_CTRL_C); +PHPBN2(PHP_WINDOWS_EVENT_CTRL_BREAK); /* These don't actually seem to be set (tested on Linux, I guess they're * Windows only?) */ PHPBN2(PHP_WINDOWS_NT_DOMAIN_CONTROLLER); @@ -402,21 +413,6 @@ PHPBN2(CURLOPT_TCP_NODELAY); PHPBN2(CURLOPT_TIMEOUT_MS); PHPBN2(CURLOPT_CONNECTTIMEOUT_MS); PHPBN2(GMP_VERSION); -PHPBN2(SWFTEXTFIELD_USEFONT); -PHPBN2(SWFTEXTFIELD_AUTOSIZE); -PHPBN2(SWF_SOUND_NOT_COMPRESSED); -PHPBN2(SWF_SOUND_ADPCM_COMPRESSED); -PHPBN2(SWF_SOUND_MP3_COMPRESSED); -PHPBN2(SWF_SOUND_NOT_COMPRESSED_LE); -PHPBN2(SWF_SOUND_NELLY_COMPRESSED); -PHPBN2(SWF_SOUND_5KHZ); -PHPBN2(SWF_SOUND_11KHZ); -PHPBN2(SWF_SOUND_22KHZ); -PHPBN2(SWF_SOUND_44KHZ); -PHPBN2(SWF_SOUND_8BITS); -PHPBN2(SWF_SOUND_16BITS); -PHPBN2(SWF_SOUND_MONO); -PHPBN2(SWF_SOUND_STEREO); PHPBN2(OPENSSL_VERSION_NUMBER); PHPBN2(SNMP_OID_OUTPUT_FULL); PHPBN2(SNMP_OID_OUTPUT_NUMERIC); @@ -627,27 +623,26 @@ PHPBN2(PGSQL_POLLING_OK); PHPBN2(PGSQL_POLLING_READING); PHPBN2(PGSQL_POLLING_WRITING); -/* Class names reserved by PHP (case insensitive) */ +/* Class names reserved by PHP. */ +/* Check is case insensitive - these *MUST* be listed in lower case here. */ PHPCN(directory); PHPCN(stdclass); PHPCN(__php_incomplete_class); -/* Added in PHP5. */ PHPCN(exception); PHPCN(errorexception); PHPCN(php_user_filter); PHPCN(closure); PHPCN(generator); PHPCN(self); -PHPCN(static); PHPCN(parent); /* http://php.net/manual/en/migration70.incompatible.php#migration70.incompatible.other.classes */ PHPCN(bool); // As of PHP 7.0 PHPCN(int); // As of PHP 7.0 PHPCN(float); // As of PHP 7.0 PHPCN(string); // As of PHP 7.0 -PHPCN(NULL); // As of PHP 7.0 -PHPCN(TRUE); // As of PHP 7.0 -PHPCN(FALSE); // As of PHP 7.0 +PHPCN(null); // As of PHP 7.0 +PHPCN(true); // As of PHP 7.0 +PHPCN(false); // As of PHP 7.0 PHPCN(resource); // As of PHP 7.0 (currently works but reserved) PHPCN(object); // As of PHP 7.0 (currently works but reserved) PHPCN(mixed); // As of PHP 7.0 (currently works but reserved) @@ -655,6 +650,14 @@ PHPCN(numeric); // As of PHP 7.0 (currently works but reserved) /* http://php.net/manual/en/migration71.incompatible.php#migration71.incompatible.invalid-class-names */ PHPCN(iterable); // As of PHP 7.1 PHPCN(void); // As of PHP 7.1 +/* Predefined interfaces and classes, introduced in PHP 7.0.0 */ +PHPCN(arithmeticerror); +PHPCN(assertionerror); +PHPCN(divisionbyzeroerror); +PHPCN(error); +PHPCN(throwable); +PHPCN(parseerror); +PHPCN(typeerror); /* From extensions (which of these are actually predefined depends which * extensions are loaded by default). */ PHPCN(xmlwriter); diff --git a/Lib/php/phppointers.i b/Lib/php/phppointers.i index d79697b5e..8b4e75e60 100644 --- a/Lib/php/phppointers.i +++ b/Lib/php/phppointers.i @@ -2,15 +2,11 @@ %typemap(in, byref=1) TYPE *REF ($*1_ltype tmp), TYPE &REF ($*1_ltype tmp) %{ - /* First Check for SWIG wrapped type */ - if (Z_ISNULL($input)) { - $1 = 0; - } else if (Z_ISREF($input)) { - /* Not swig wrapped type, so we check if it's a PHP reference type */ - CONVERT_IN(tmp, $*1_ltype, $input); - $1 = &tmp; + if (Z_ISREF($input)) { + CONVERT_IN(tmp, $*1_ltype, $input); + $1 = &tmp; } else { - SWIG_PHP_Error(E_ERROR, SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference)); + zend_type_error(SWIG_PHP_Arg_Error_Msg($argnum, Expected a reference)); } %} %typemap(argout) TYPE *REF, diff --git a/Lib/php/phprun.swg b/Lib/php/phprun.swg index a07a1b9f8..a3569a783 100644 --- a/Lib/php/phprun.swg +++ b/Lib/php/phprun.swg @@ -4,24 +4,23 @@ * PHP runtime library * ----------------------------------------------------------------------------- */ +#define swig_owntype int + #ifdef __cplusplus extern "C" { #endif -#include "zend.h" -#include "zend_API.h" -#include "zend_exceptions.h" + #include "php.h" -#if PHP_MAJOR_VERSION != 7 -# error These bindings need PHP7 - to generate PHP5 bindings use: SWIG < 4.0.0 and swig -php5 +#if PHP_MAJOR_VERSION < 7 +# error These bindings need PHP 7 or later - to generate PHP5 bindings use: SWIG < 4.0.0 and swig -php5 #endif -#include "ext/standard/php_string.h" -#include <stdlib.h> /* for abort(), used in generated code. */ +#include "zend_inheritance.h" +#include "zend_exceptions.h" +#include "zend_inheritance.h" -/* This indirection is to work around const correctness issues in older PHP. - * FIXME: Remove for PHP7? Or might user code be using it? */ -#define SWIG_ZEND_NAMED_FE(ZN, N, A) ZEND_NAMED_FE(ZN, N, A) +#include <stdlib.h> /* for abort(), used in generated code. */ #define SWIG_BOOL_CONSTANT(N, V) REGISTER_BOOL_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT) #define SWIG_LONG_CONSTANT(N, V) REGISTER_LONG_CONSTANT(#N, V, CONST_CS | CONST_PERSISTENT) @@ -32,13 +31,27 @@ extern "C" { REGISTER_STRINGL_CONSTANT(#N, &swig_char, 1, CONST_CS | CONST_PERSISTENT);\ } while (0) -/* ZEND_CONSTANT_SET_FLAGS is new in PHP 7.3. */ +/* ZEND_CONSTANT_SET_FLAGS was new in PHP 7.3. */ #ifdef ZEND_CONSTANT_SET_FLAGS # define SWIG_ZEND_CONSTANT_SET_FLAGS ZEND_CONSTANT_SET_FLAGS #else # define SWIG_ZEND_CONSTANT_SET_FLAGS(C, F, N) do { (C)->flags = (F); (C)->module_number = (N); } while (0) #endif +/* zend_object_alloc was new in PHP 7.3. */ +#if PHP_MAJOR_VERSION == 7 && PHP_MINOR_VERSION < 3 +static zend_always_inline void *zend_object_alloc(size_t obj_size, zend_class_entry *ce) { + void *obj = emalloc(obj_size + zend_object_properties_size(ce)); + memset(obj, 0, obj_size - sizeof(zval)); + return obj; +} +#endif + +/* ZEND_THIS was new in PHP 7.4. */ +#ifndef ZEND_THIS +# define ZEND_THIS &EX(This) +#endif + #ifdef __cplusplus } #endif @@ -50,10 +63,10 @@ static int default_error_code = E_ERROR; #define SWIG_PHP_Arg_Error_Msg(argnum,extramsg) "Error in argument " #argnum " "#extramsg -#define SWIG_PHP_Error(code,msg) do { SWIG_ErrorCode() = code; SWIG_ErrorMsg() = msg; SWIG_fail; } while (0) +#define SWIG_PHP_Error(code,msg) do { zend_throw_exception(NULL, msg, code); SWIG_fail; } while (0) #define SWIG_contract_assert(expr,msg) \ - if (!(expr) ) { zend_printf("Contract Assert Failed %s\n",msg ); } else + do { if (!(expr)) zend_printf("Contract Assert Failed %s\n", msg); } while (0) /* Standard SWIG API */ #define SWIG_GetModule(clientdata) SWIG_Php_GetModule() @@ -64,74 +77,49 @@ static int default_error_code = E_ERROR; typedef struct { void * ptr; int newobject; + const swig_type_info * type; + zend_object std; } swig_object_wrapper; +#define SWIG_Z_FETCH_OBJ_P(zv) php_fetch_object(Z_OBJ_P(zv)) + +static inline +swig_object_wrapper * php_fetch_object(zend_object *obj) { + return (swig_object_wrapper *)((char *)obj - XtOffsetOf(swig_object_wrapper, std)); +} + #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) static void SWIG_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject) { - /* - * First test for Null pointers. Return those as PHP native NULL - */ - if (!ptr ) { + // Return PHP NULL for a C/C++ NULL pointer. + if (!ptr) { ZVAL_NULL(z); return; } - if (type->clientdata) { + + if (!type->clientdata) { + zend_type_error("Type: %s not registered with zend", type->name); + return; + } + + { + zend_object *obj; swig_object_wrapper *value; - if (! (*(int *)(type->clientdata))) - zend_error(E_ERROR, "Type: %s failed to register with zend",type->name); - value=(swig_object_wrapper *)emalloc(sizeof(swig_object_wrapper)); - value->ptr=ptr; - value->newobject=(newobject & 1); - if ((newobject & 2) == 0) { - /* Just register the pointer as a resource. */ - ZVAL_RES(z, zend_register_resource(value, *(int *)(type->clientdata))); + if (Z_TYPE_P(z) == IS_OBJECT) { + /* The PHP object is already initialised - this is the case when wrapping + * the return value from a PHP constructor. */ + obj = Z_OBJ_P(z); } else { - /* - * Wrap the resource in an object, the resource will be accessible - * via the "_cPtr" member. This is currently only used by - * directorin typemaps. - */ - zval resource; - zend_class_entry *ce = NULL; - const char *type_name = type->name+3; /* +3 so: _p_Foo -> Foo */ - size_t type_name_len; - const char * p; - HashTable * ht; - - /* Namespace__Foo -> Foo */ - /* FIXME: ugly and goes wrong for classes with __ in their names. */ - while ((p = strstr(type_name, "__")) != NULL) { - type_name = p + 2; - } - type_name_len = strlen(type_name); - - ZVAL_RES(&resource, zend_register_resource(value, *(int *)(type->clientdata))); - if (SWIG_PREFIX_LEN > 0) { - zend_string * classname = zend_string_alloc(SWIG_PREFIX_LEN + type_name_len, 0); - memcpy(classname->val, SWIG_PREFIX, SWIG_PREFIX_LEN); - memcpy(classname->val + SWIG_PREFIX_LEN, type_name, type_name_len); - ce = zend_lookup_class(classname); - zend_string_release(classname); - } else { - zend_string * classname = zend_string_init(type_name, type_name_len, 0); - ce = zend_lookup_class(classname); - zend_string_release(classname); - } - if (ce == NULL) { - /* class does not exist */ - ce = zend_standard_class_def; - } - - ALLOC_HASHTABLE(ht); - zend_hash_init(ht, 1, NULL, NULL, 0); - zend_hash_str_update(ht, "_cPtr", sizeof("_cPtr") - 1, &resource); - object_and_properties_init(z, ce, ht); + zend_class_entry *ce = (zend_class_entry*)(type->clientdata); + obj = ce->create_object(ce); + ZVAL_OBJ(z, obj); } - return; + value = php_fetch_object(obj); + value->ptr = ptr; + value->newobject = (newobject & 1); + value->type = type; } - zend_error(E_ERROR, "Type: %s not registered with zend",type->name); } /* This pointer conversion routine takes the native pointer p (along with @@ -139,15 +127,10 @@ SWIG_SetPointerZval(zval *z, void *ptr, swig_type_info *type, int newobject) { according to ty. The resultant pointer is returned, or NULL is returned if the pointer can't be cast. - Sadly PHP has no API to find a type name from a type id, only from an - instance of a resource of the type id, so we have to pass type_name as well. - - The two functions which might call this are: - SWIG_ConvertResourcePtr which gets the type name from the resource - and the registered zend destructors for which we have one per type each - with the type name hard wired in. */ + This is called by SWIG_ConvertPtr which gets the type name from the + swig_object_wrapper. */ static void * -SWIG_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty) { +SWIG_ConvertPtrData(void * p, const char *type_name, swig_type_info *ty, int *own) { swig_cast_info *tc; void *result = 0; @@ -156,7 +139,7 @@ SWIG_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty) { return p; } - if (! type_name) { + if (! type_name) { /* can't convert p to ptr type ty if we don't know what type p is */ return NULL; } @@ -166,62 +149,36 @@ SWIG_ConvertResourceData(void * p, const char *type_name, swig_type_info *ty) { if (tc) { int newmemory = 0; result = SWIG_TypeCast(tc, p, &newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ + if (newmemory == SWIG_CAST_NEW_MEMORY) { + assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */ + if (own) + *own |= SWIG_CAST_NEW_MEMORY; + } } return result; } -/* This function returns a pointer of type ty by extracting the pointer - and type info from the resource in z. z must be a resource. - If it fails, NULL is returned. - It uses SWIG_ConvertResourceData to do the real work. */ -static void * -SWIG_ConvertResourcePtr(zval *z, swig_type_info *ty, int flags) { - swig_object_wrapper *value; - void *p; - const char *type_name; - - if (Z_RES_TYPE_P(z) == -1) return NULL; - value = (swig_object_wrapper *) Z_RES_VAL_P(z); - if (flags & SWIG_POINTER_DISOWN) { - value->newobject = 0; - } - p = value->ptr; - - type_name=zend_rsrc_list_get_rsrc_type(Z_RES_P(z)); - - return SWIG_ConvertResourceData(p, type_name, ty); -} - -/* We allow passing of a RESOURCE pointing to the object or an OBJECT whose - _cPtr is a resource pointing to the object */ +/* We wrap C/C++ pointers as PHP objects. */ static int -SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) { +SWIG_ConvertPtrAndOwn(zval *z, void **ptr, swig_type_info *ty, int flags, swig_owntype *own) { + if (own) + *own = 0; + if (z == NULL) { *ptr = 0; - return 0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; } switch (Z_TYPE_P(z)) { case IS_OBJECT: { - HashTable * ht = Z_OBJ_HT_P(z)->get_properties(z); - if (ht) { - zval * _cPtr = zend_hash_str_find(ht, "_cPtr", sizeof("_cPtr") - 1); - if (_cPtr) { - if (Z_TYPE_P(_cPtr) == IS_INDIRECT) { - _cPtr = Z_INDIRECT_P(_cPtr); - } - if (Z_TYPE_P(_cPtr) == IS_RESOURCE) { - *ptr = SWIG_ConvertResourcePtr(_cPtr, ty, flags); - return (*ptr == NULL ? -1 : 0); - } - } + swig_object_wrapper *value = SWIG_Z_FETCH_OBJ_P(z); + *ptr = SWIG_ConvertPtrData(value->ptr, value->type->name, ty, own); + if (*ptr == NULL) return SWIG_ERROR; + if (flags & SWIG_POINTER_DISOWN) { + value->newobject = 0; } - break; + return SWIG_OK; } - case IS_RESOURCE: - *ptr = SWIG_ConvertResourcePtr(z, ty, flags); - return (*ptr == NULL ? -1 : 0); case IS_NULL: *ptr = 0; return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; @@ -230,6 +187,11 @@ SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) { return -1; } +static int +SWIG_ConvertPtr(zval *z, void **ptr, swig_type_info *ty, int flags) { + return SWIG_ConvertPtrAndOwn(z, ptr, ty, flags, 0); +} + static const char const_name[] = "swig_runtime_data_type_pointer"; static swig_module_info *SWIG_Php_GetModule() { zval *pointer = zend_get_constant_str(const_name, sizeof(const_name) - 1); @@ -237,7 +199,7 @@ static swig_module_info *SWIG_Php_GetModule() { if (Z_TYPE_P(pointer) == IS_LONG) { return (swig_module_info *) pointer->value.lval; } - } + } return NULL; } diff --git a/Lib/php/std_common.i b/Lib/php/std_common.i index 092bf012b..1b69fc779 100644 --- a/Lib/php/std_common.i +++ b/Lib/php/std_common.i @@ -7,4 +7,3 @@ %include <std/std_except.i> %apply size_t { std::size_t }; - diff --git a/Lib/php/std_map.i b/Lib/php/std_map.i index 7c0157353..fed3cf0b3 100644 --- a/Lib/php/std_map.i +++ b/Lib/php/std_map.i @@ -35,7 +35,7 @@ namespace std { map(); map(const map& other); - + unsigned int size() const; void clear(); %extend { diff --git a/Lib/php/std_string.i b/Lib/php/std_string.i index b55751f07..082a32ce1 100644 --- a/Lib/php/std_string.i +++ b/Lib/php/std_string.i @@ -33,10 +33,8 @@ namespace std { %} %typemap(directorout) string %{ - if (!EG(exception)) { convert_to_string($input); $result.assign(Z_STRVAL_P($input), Z_STRLEN_P($input)); - } %} %typemap(out) string %{ @@ -74,12 +72,10 @@ namespace std { %} %typemap(directorout) string & ($*1_ltype *temp) %{ - if (!EG(exception)) { convert_to_string($input); temp = new $*1_ltype(Z_STRVAL_P($input), Z_STRLEN_P($input)); swig_acquire_ownership(temp); $result = temp; - } %} %typemap(argout) string & %{ diff --git a/Lib/php/std_vector.i b/Lib/php/std_vector.i index e633bc3ad..382b37ca0 100644 --- a/Lib/php/std_vector.i +++ b/Lib/php/std_vector.i @@ -112,5 +112,3 @@ namespace std { %define specialize_std_vector(T) #warning "specialize_std_vector - specialization for type T no longer needed" %enddef - - diff --git a/Lib/php/stl.i b/Lib/php/stl.i index 04f86014f..38aba67b8 100644 --- a/Lib/php/stl.i +++ b/Lib/php/stl.i @@ -7,4 +7,3 @@ %include <std_vector.i> %include <std_map.i> %include <std_pair.i> - diff --git a/Lib/php/typemaps.i b/Lib/php/typemaps.i index c248a588e..94b351113 100644 --- a/Lib/php/typemaps.i +++ b/Lib/php/typemaps.i @@ -276,7 +276,8 @@ INT_TYPEMAP(unsigned long long); /* So... we didn't get a ref or ptr, but we'll accept NULL by reference */ if (!(Z_ISREF($input) && Z_ISNULL_P(Z_REFVAL($input)))) { /* wasn't a pre/ref/thing, OR anything like an int thing */ - SWIG_PHP_Error(E_ERROR, "Type error in argument $arg of $symname."); + zend_type_error("Expected reference or NULL for argument $arg of $symname"); + return; } } force=0; diff --git a/Lib/php/utils.i b/Lib/php/utils.i index ed6e08ff4..b8fd9091d 100644 --- a/Lib/php/utils.i +++ b/Lib/php/utils.i @@ -17,8 +17,8 @@ errno = 0; lvar = (t) strtoll(Z_STRVAL(invar), &endptr, 10); if (*endptr && !errno) break; - /* FALL THRU */ } + /* FALL THRU */ default: lvar = (t) zval_get_long(&invar); } @@ -34,8 +34,8 @@ errno = 0; lvar = (t) strtoull(Z_STRVAL(invar), &endptr, 10); if (*endptr && !errno) break; - /* FALL THRU */ } + /* FALL THRU */ default: lvar = (t) zval_get_long(&invar); } @@ -75,16 +75,21 @@ %} %typemap(directorout) TYPE %{ - if (!EG(exception)) { - CONVERT_IN($result, $1_ltype, *$input); - } + CONVERT_IN($result, $1_ltype, *$input); +%} +%typemap(directorout) const TYPE & +%{ + $*1_ltype swig_val; + CONVERT_IN(swig_val, $*1_ltype, *$input); + $1_ltype temp = new $*1_ltype(($*1_ltype)swig_val); + swig_acquire_ownership(temp); + $result = temp; %} -%typemap(directorout) const TYPE & ($*1_ltype temp) +%typemap(directorfree) const TYPE & %{ - if (!EG(exception)) { - CONVERT_IN(temp, $*1_ltype, *$input); + if (director) { + director->swig_release_ownership(%as_voidptr($input)); } - $result = &temp; %} %enddef diff --git a/Lib/pike/pike.swg b/Lib/pike/pike.swg deleted file mode 100644 index a36bf3ad2..000000000 --- a/Lib/pike/pike.swg +++ /dev/null @@ -1,326 +0,0 @@ -/* ----------------------------------------------------------------------------- - * pike.swg - * - * Pike configuration module. - * ----------------------------------------------------------------------------- */ - -%insert(runtime) "swigrun.swg"; // Common C API type-checking code -%insert(runtime) "pikerun.swg"; // Pike run-time code - -%insert(runtime) %{ -#ifdef __cplusplus -extern "C" { -#endif -#include <pike/global.h> -#include <pike/module.h> -#include <pike/interpret.h> -#ifdef __cplusplus -} -#endif -%} - -/* ----------------------------------------------------------------------------- - * standard typemaps - * ----------------------------------------------------------------------------- */ - -/* --- Input arguments --- */ - -/* Primitive datatypes. */ - -%typemap(in, pikedesc="tInt") - int, unsigned int, short, unsigned short, - long, unsigned long, char, signed char, unsigned char, - bool, enum SWIGTYPE, long long, unsigned long long -{ - if ($input.type != T_INT) - Pike_error("Bad argument: Expected an integer.\n"); - $1 = ($1_ltype) $input.u.integer; -} - -%typemap(in, pikedesc="tFloat") float, double { - if ($input.type != T_FLOAT) - Pike_error("Bad argument: Expected a float.\n"); - $1 = ($1_ltype) $input.u.float_number; -} - -%typemap(in, pikedesc="tStr") char *, char [ANY] { - if ($input.type != T_STRING) - Pike_error("Bad argument: Expected a string.\n"); - $1 = ($1_ltype) STR0($input.u.string); -} - -/* Pointers, references and arrays */ - -%typemap(in) SWIGTYPE *, - SWIGTYPE &, - SWIGTYPE &&, - SWIGTYPE [] - "SWIG_ConvertPtr($input.u.object, (void **) &$1, $1_descriptor, 1);" - -/* Void pointer. Accepts any kind of pointer */ -%typemap(in) void * "/* FIXME */"; - -/* Object passed by value. Convert to a pointer */ -%typemap(in) SWIGTYPE ($&1_ltype argp) "/* FIXME */"; - -/* Pointer to a class member */ -%typemap(in) SWIGTYPE (CLASS::*) "/* FIXME */"; - -/* Const primitive references. Passed by value */ - -%typemap(in, pikedesc="tInt") const int & (int temp), - const short & (short temp), - const long & (long temp), - const unsigned int & (unsigned int temp), - const unsigned short & (unsigned short temp), - const unsigned long & (unsigned long temp), - const char & (char temp), - const signed char & (signed char temp), - const unsigned char & (unsigned char temp), - const bool & (bool temp), - const long long & ($*1_ltype temp), - const unsigned long long & ($*1_ltype temp), - const enum SWIGTYPE & ($*1_ltype temp), - const enum SWIGTYPE && ($*1_ltype temp) -{ - if ($input.type != T_INT) - Pike_error("Bad argument: Expected an integer.\n"); - temp = ($*1_ltype) $input.u.integer; - $1 = &temp; -} - -%typemap(in, pikedesc="tFloat") const float & (float temp), - const double & (double temp) -{ - if ($input.type != T_FLOAT) - Pike_error("Bad argument: Expected a float.\n"); - temp = ($*1_ltype) $input.u.float_number; - $1 = &temp; -} - -/* ----------------------------------------------------------------------------- - * Output Typemaps - * ----------------------------------------------------------------------------- */ -%typemap(out, pikedesc="tInt") - int, unsigned int, - short, unsigned short, - long, unsigned long, - char, signed char, unsigned char, - bool, enum SWIGTYPE - "push_int($1);"; - -%typemap(out, pikedesc="tInt") long long "push_int64($1);"; -%typemap(out, pikedesc="tInt") unsigned long long "push_int64($1);"; -%typemap(out, pikedesc="tFloat") float, double "push_float($1);"; -%typemap(out, pikedesc="tStr") char * "push_text($1);"; - -/* Pointers, references, and arrays */ -%typemap(out, pikedesc="tObj") SWIGTYPE*, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] "push_object(SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner));"; - -/* Void return value; don't push anything */ -%typemap(out, pikedesc="tVoid") void ""; - -/* Dynamic casts */ - -%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC "/* FIXME */"; - -/* Member pointer */ -%typemap(out) SWIGTYPE (CLASS::*) "/* FIXME */"; - -/* Special typemap for character array return values */ -%typemap(out, pikedesc="tStr") char [ANY], const char [ANY] "push_text($1);"; - -/* Primitive types--return by value */ -%typemap(out, pikedesc="tObj") SWIGTYPE -#ifdef __cplusplus -{ - $&1_ltype resultptr; - resultptr = new $1_ltype((const $1_ltype &) $1); - push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1)); -} -#else -{ - $&1_ltype resultptr; - resultptr = ($&1_ltype) malloc(sizeof($1_type)); - memmove(resultptr, &$1, sizeof($1_type)); - push_object(SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1)); -} -#endif - -/* References to primitive types. Return by value */ - -%typemap(out, pikedesc="tInt") const int &, const unsigned int &, - const short &, const unsigned short &, - const long &, const unsigned long &, - const char &, const signed char &, const unsigned char &, - const bool &, - const long long &, const unsigned long long &, - const enum SWIGTYPE & ($*1_ltype temp), - const enum SWIGTYPE && ($*1_ltype temp) - "push_int(*($1));"; - -%typemap(out, pikedesc="tFloat") const float &, const double & "push_float(*($1));"; - -/************************ Constant Typemaps *****************************/ - -%typemap(constant) - int, unsigned int, - short, unsigned short, - long, unsigned long, - signed char, unsigned char, - bool, enum SWIGTYPE, - long long, unsigned long long - "add_integer_constant(\"$symname\", $1, 0);"; - -%typemap(constant) char - "add_integer_constant(\"$symname\", '$1', 0);"; - -%typemap(constant) long long, unsigned long long - "add_integer_constant(\"$symname\", $1, 0);"; - -%typemap(constant) float, double - "add_float_constant(\"$symname\", $1, 0);"; - -%typemap(constant) char * - "add_string_constant(\"$symname\", \"$1\", 0);"; - -/* ------------------------------------------------------------ - * String & length - * ------------------------------------------------------------ */ - -%typemap(in) (char *STRING, int LENGTH), (char *STRING, size_t LENGTH) { - if ($input.type != T_STRING) - Pike_error("Bad argument: Expected a string.\n"); - $1 = ($1_ltype) STR0($input.u.string); - $2 = ($2_ltype) $input.u.string->length; -} - -/* ------------------------------------------------------------ - * ANSI C typemaps - * ------------------------------------------------------------ */ - -%typemap(in, pikedesc="tInt") size_t { - if ($input.type != T_INT) - Pike_error("Bad argument: Expected an integer.\n"); - $1 = ($1_ltype) $input.u.integer; -} - -%typemap(out) size_t = long; - -/* ------------------------------------------------------------ - * Typechecking rules - * ------------------------------------------------------------ */ - -%typecheck(SWIG_TYPECHECK_INTEGER) - int, short, long, - unsigned int, unsigned short, unsigned long, - signed char, unsigned char, - long long, unsigned long long, - const int &, const short &, const long &, - const unsigned int &, const unsigned short &, const unsigned long &, - const long long &, const unsigned long long &, - enum SWIGTYPE, enum SWIGTYPE &, SWIGTYPE &&, - bool, const bool & -{ - $1 = ($input.type == T_INT) ? 1 : 0; -} - -%typecheck(SWIG_TYPECHECK_DOUBLE) - float, double, - const float &, const double & -{ - $1 = (($input.type == T_FLOAT) || ($input.type == T_INT)) ? 1 : 0; -} - -%typecheck(SWIG_TYPECHECK_CHAR) char { - $1 = ($input.type == T_INT) ? 1 : 0; -} - -%typecheck(SWIG_TYPECHECK_STRING) char * { - $1 = ($input.type == T_STRING) ? 1 : 0; -} - -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE &&, SWIGTYPE [] { - void *ptr; - if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $1_descriptor, 0) == -1) { - $1 = 0; - } else { - $1 = 1; - } -} - -%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE { - void *ptr; - if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, $&1_descriptor, 0) == -1) { - $1 = 0; - } else { - $1 = 1; - } -} - -%typecheck(SWIG_TYPECHECK_VOIDPTR) void * { - void *ptr; - if (SWIG_ConvertPtr($input.u.object, (void **) &ptr, 0, 0) == -1) { - $1 = 0; - } else { - $1 = 1; - } -} - -/* Array reference typemaps */ -%apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) } -%apply SWIGTYPE && { SWIGTYPE ((&&)[ANY]) } - -/* const pointers */ -%apply SWIGTYPE * { SWIGTYPE *const } -%apply SWIGTYPE (CLASS::*) { SWIGTYPE (CLASS::*const) } -%apply SWIGTYPE & { SWIGTYPE (CLASS::*const&) } - -/* ------------------------------------------------------------ - * Overloaded operator support - * ------------------------------------------------------------ */ - -#ifdef __cplusplus -%rename("`+") *::operator+; -%rename("`-") *::operator-; -%rename("`*") *::operator*; -%rename("`/") *::operator/; -%rename("`%") *::operator%; -%rename("`<<") *::operator<<; -%rename("`>>") *::operator>>; -%rename("`&") *::operator&; -%rename("`|") *::operator|; -%rename("`^") *::operator^; -%rename("`~") *::operator~; -%rename("`<") *::operator<; -%rename("`>") *::operator>; -%rename("`==") *::operator==; - -/* Special cases */ -%rename("`()") *::operator(); - -#endif - -/* ------------------------------------------------------------ - * The start of the Pike initialization function - * ------------------------------------------------------------ */ - -%init "swiginit.swg" - -%init %{ -#ifdef __cplusplus -extern "C" -#endif -PIKE_MODULE_EXIT {} - -#ifdef __cplusplus -extern "C" -#endif -PIKE_MODULE_INIT -{ - struct program *pr; - SWIG_InitializeModule(0); -%} - -/* pike keywords */ -%include <pikekw.swg> diff --git a/Lib/pike/pikekw.swg b/Lib/pike/pikekw.swg deleted file mode 100644 index 844b1f189..000000000 --- a/Lib/pike/pikekw.swg +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef PIKE_PIKEKW_SWG_ -#define PIKE_PIKEKW_SWG_ - -/* Warnings for Pike keywords */ -#define PIKEKW(x) %namewarn("314: '" #x "' is a pike keyword") #x - -/* - from - http://www.http://docs.linux.cz/pike/tutorial_C.html - -*/ - - -PIKEKW(array); -PIKEKW(break); -PIKEKW(case); -PIKEKW(catch); -PIKEKW(continue); -PIKEKW(default); -PIKEKW(do); -PIKEKW(else); -PIKEKW(float); -PIKEKW(for); -PIKEKW(foreach); -PIKEKW(function); -PIKEKW(gauge); -PIKEKW(if); -PIKEKW(inherit); -PIKEKW(inline); -PIKEKW(int); -PIKEKW(lambda); -PIKEKW(mapping); -PIKEKW(mixed); -PIKEKW(multiset); -PIKEKW(nomask); -PIKEKW(object); -PIKEKW(predef); -PIKEKW(private); -PIKEKW(program); -PIKEKW(protected); -PIKEKW(public); -PIKEKW(return); -PIKEKW(sscanf); -PIKEKW(static); -PIKEKW(string); -PIKEKW(switch); -PIKEKW(typeof); -PIKEKW(varargs); -PIKEKW(void); -PIKEKW(while); - - -#undef PIKEKW - -#endif //PIKE_PIKEKW_SWG_ diff --git a/Lib/pike/pikerun.swg b/Lib/pike/pikerun.swg deleted file mode 100644 index 6ec1143cf..000000000 --- a/Lib/pike/pikerun.swg +++ /dev/null @@ -1,71 +0,0 @@ -/* ----------------------------------------------------------------------------- - * pikerun.swg - * - * This file contains the runtime support for Pike modules - * and includes code for managing global variables and pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#endif -#include "pike/object.h" -#include "pike/program.h" -#ifdef __cplusplus -} -#endif -#include <assert.h> - -/* Stores information about a wrapped object */ -typedef struct swig_object_wrapper { - void *self; - swig_type_info *type; -} swig_object_wrapper; - -#ifdef THIS -#undef THIS -#endif -#define THIS (((swig_object_wrapper *) Pike_fp->current_storage)->self) - -#define SWIG_ConvertPtr SWIG_Pike_ConvertPtr -#define SWIG_NewPointerObj SWIG_Pike_NewPointerObj -#define SWIG_GetModule(clientdata) SWIG_Pike_GetModule(clientdata) -#define SWIG_SetModule(clientdata, pointer) SWIG_Pike_SetModule(pointer) - -/* These need to be filled in before type sharing between modules will work */ -static swig_module_info *SWIG_Pike_GetModule(void *SWIGUNUSEDPARM(clientdata)) { - return 0; -} - -static void SWIG_Pike_SetModule(swig_module_info *pointer) { - -} - -/* Convert a pointer value */ -static int -SWIG_Pike_ConvertPtr(struct object *obj, void **ptr, swig_type_info *ty, int flags) { - struct program *pr; - swig_cast_info *tc; - swig_object_wrapper *obj_wrapper; - - if (ty) { - pr = (struct program *) ty->clientdata; - obj_wrapper = (swig_object_wrapper *) get_storage(obj, pr); - if (obj_wrapper && obj_wrapper->type) { - tc = SWIG_TypeCheckStruct(obj_wrapper->type, ty); - if (tc) { - int newmemory = 0; - *ptr = SWIG_TypeCast(tc, obj_wrapper->self, &newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - return 0; - } - } - } - return -1; -} - -/* Create a new pointer object */ -static struct object * -SWIG_Pike_NewPointerObj(void *ptr, swig_type_info *type, int own) { - return 0; -} diff --git a/Lib/pike/std_string.i b/Lib/pike/std_string.i deleted file mode 100644 index b32b3c112..000000000 --- a/Lib/pike/std_string.i +++ /dev/null @@ -1,60 +0,0 @@ -/* ----------------------------------------------------------------------------- - * std_string.i - * - * SWIG typemaps for std::string - * ----------------------------------------------------------------------------- */ - -%{ -#include <string> -%} - -namespace std { - - %naturalvar string; - - class string; - - /* Overloading check */ - - %typemap(typecheck) string = char *; - %typemap(typecheck) const string & = char *; - - %typemap(in, pikedesc="tStr") string { - if ($input.type != T_STRING) - Pike_error("Bad argument: Expected a string.\n"); - $1.assign(STR0($input.u.string)); - } - - %typemap(in, pikedesc="tStr") const string & ($*1_ltype temp) { - if ($input.type != T_STRING) - Pike_error("Bad argument: Expected a string.\n"); - temp.assign(STR0($input.u.string)); - $1 = &temp; - } - - %typemap(out, pikedesc="tStr") string "push_text($1.c_str());"; - - %typemap(out, pikedesc="tStr") const string & "push_text($1->c_str());"; - - %typemap(directorin) string, const string &, string & "$1.c_str()"; - - %typemap(directorin) string *, const string * "$1->c_str()"; - - %typemap(directorout) string { - if ($input.type == T_STRING) - $result.assign(STR0($input.u.string)); - else - throw Swig::DirectorTypeMismatchException("string expected"); - } - - %typemap(directorout) const string & ($*1_ltype temp) { - if ($input.type == T_STRING) { - temp.assign(STR0($input.u.string)); - $result = &temp; - } else { - throw Swig::DirectorTypeMismatchException("string expected"); - } - } - -} - diff --git a/Lib/python/pyerrors.swg b/Lib/python/pyerrors.swg index dcd99c939..2628de8e6 100644 --- a/Lib/python/pyerrors.swg +++ b/Lib/python/pyerrors.swg @@ -95,8 +95,12 @@ SWIG_Python_RaiseOrModifyTypeError(const char *message) #else newvalue = PyString_FromFormat("%s\nAdditional information:\n%s", PyString_AsString(value), message); #endif - Py_XDECREF(value); - PyErr_Restore(type, newvalue, traceback); + if (newvalue) { + Py_XDECREF(value); + PyErr_Restore(type, newvalue, traceback); + } else { + PyErr_Restore(type, value, traceback); + } } else { /* Raise TypeError using given message */ PyErr_SetString(PyExc_TypeError, message); diff --git a/Lib/python/pyrun.swg b/Lib/python/pyrun.swg index 63ff82ff8..0025184d1 100644 --- a/Lib/python/pyrun.swg +++ b/Lib/python/pyrun.swg @@ -127,7 +127,12 @@ SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) { if (!PyList_Check(result)) { PyObject *o2 = result; result = PyList_New(1); - PyList_SetItem(result, 0, o2); + if (result) { + PyList_SET_ITEM(result, 0, o2); + } else { + Py_DECREF(obj); + return o2; + } } PyList_Append(result,obj); Py_DECREF(obj); @@ -279,18 +284,25 @@ SwigPyClientData_New(PyObject* obj) /* the newraw method and newargs arguments used to create a new raw instance */ if (PyClass_Check(obj)) { data->newraw = 0; - data->newargs = obj; Py_INCREF(obj); + data->newargs = obj; } else { data->newraw = PyObject_GetAttrString(data->klass, "__new__"); if (data->newraw) { - Py_INCREF(data->newraw); - data->newargs = PyTuple_New(1); - PyTuple_SetItem(data->newargs, 0, obj); + data->newargs = PyTuple_New(1); + if (data->newargs) { + Py_INCREF(obj); + PyTuple_SET_ITEM(data->newargs, 0, obj); + } else { + Py_DECREF(data->newraw); + Py_DECREF(data->klass); + free(data); + return 0; + } } else { - data->newargs = obj; + Py_INCREF(obj); + data->newargs = obj; } - Py_INCREF(data->newargs); } /* the destroy method, aka as the C++ delete method */ data->destroy = PyObject_GetAttrString(data->klass, "__swig_destroy__"); @@ -299,10 +311,7 @@ SwigPyClientData_New(PyObject* obj) data->destroy = 0; } if (data->destroy) { - int flags; - Py_INCREF(data->destroy); - flags = PyCFunction_GET_FLAGS(data->destroy); - data->delargs = !(flags & (METH_O)); + data->delargs = !(PyCFunction_GET_FLAGS(data->destroy) & METH_O); } else { data->delargs = 0; } @@ -313,10 +322,13 @@ SwigPyClientData_New(PyObject* obj) } SWIGRUNTIME void -SwigPyClientData_Del(SwigPyClientData *data) { +SwigPyClientData_Del(SwigPyClientData *data) +{ + Py_XDECREF(data->klass); Py_XDECREF(data->newraw); Py_XDECREF(data->newargs); Py_XDECREF(data->destroy); + free(data); } /* =============== SwigPyObject =====================*/ @@ -343,7 +355,7 @@ SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args)) if (!sobj->dict) sobj->dict = PyDict_New(); - Py_INCREF(sobj->dict); + Py_XINCREF(sobj->dict); return sobj->dict; } @@ -361,18 +373,21 @@ SwigPyObject_format(const char* fmt, SwigPyObject *v) PyObject *res = NULL; PyObject *args = PyTuple_New(1); if (args) { - if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) { - PyObject *ofmt = SWIG_Python_str_FromChar(fmt); + PyObject *val = SwigPyObject_long(v); + if (val) { + PyObject *ofmt; + PyTuple_SET_ITEM(args, 0, val); + ofmt = SWIG_Python_str_FromChar(fmt); if (ofmt) { #if PY_VERSION_HEX >= 0x03000000 - res = PyUnicode_Format(ofmt,args); + res = PyUnicode_Format(ofmt,args); #else - res = PyString_Format(ofmt,args); + res = PyString_Format(ofmt,args); #endif - Py_DECREF(ofmt); + Py_DECREF(ofmt); } - Py_DECREF(args); } + Py_DECREF(args); } return res; } @@ -394,18 +409,23 @@ SwigPyObject_repr(SwigPyObject *v) { const char *name = SWIG_TypePrettyName(v->ty); PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v); - if (v->next) { + if (repr && v->next) { PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next); + if (nrep) { # if PY_VERSION_HEX >= 0x03000000 - PyObject *joined = PyUnicode_Concat(repr, nrep); - Py_DecRef(repr); - Py_DecRef(nrep); - repr = joined; + PyObject *joined = PyUnicode_Concat(repr, nrep); + Py_DecRef(repr); + Py_DecRef(nrep); + repr = joined; # else - PyString_ConcatAndDel(&repr,nrep); + PyString_ConcatAndDel(&repr,nrep); # endif + } else { + Py_DecRef(repr); + repr = NULL; + } } - return repr; + return repr; } /* We need a version taking two PyObject* parameters so it's a valid @@ -501,8 +521,12 @@ SwigPyObject_dealloc(PyObject *v) if (data->delargs) { /* we need to create a temporary object to carry the destroy operation */ PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0); - res = SWIG_Python_CallFunctor(destroy, tmp); - Py_DECREF(tmp); + if (tmp) { + res = SWIG_Python_CallFunctor(destroy, tmp); + } else { + res = 0; + } + Py_XDECREF(tmp); } else { PyCFunction meth = PyCFunction_GET_FUNCTION(destroy); PyObject *mself = PyCFunction_GET_SELF(destroy); @@ -523,6 +547,9 @@ SwigPyObject_dealloc(PyObject *v) #endif } Py_XDECREF(next); +#ifdef SWIGPYTHON_BUILTIN + Py_XDECREF(sobj->dict); +#endif PyObject_DEL(v); } @@ -578,9 +605,9 @@ SwigPyObject_own(PyObject *v, PyObject *args) PyObject *obj = PyBool_FromLong(sobj->own); if (val) { if (PyObject_IsTrue(val)) { - SwigPyObject_acquire(v,args); + Py_DECREF(SwigPyObject_acquire(v,args)); } else { - SwigPyObject_disown(v,args); + Py_DECREF(SwigPyObject_disown(v,args)); } } return obj; @@ -725,7 +752,7 @@ SwigPyObject_TypeOnce(void) { }; swigpyobject_type = tmp; type_init = 1; - if (PyType_Ready(&swigpyobject_type) < 0) + if (PyType_Ready(&swigpyobject_type) != 0) return NULL; } return &swigpyobject_type; @@ -740,6 +767,9 @@ SwigPyObject_New(void *ptr, swig_type_info *ty, int own) sobj->ty = ty; sobj->own = own; sobj->next = 0; +#ifdef SWIGPYTHON_BUILTIN + sobj->dict = 0; +#endif } return (PyObject *)sobj; } @@ -892,7 +922,7 @@ SwigPyPacked_TypeOnce(void) { }; swigpypacked_type = tmp; type_init = 1; - if (PyType_Ready(&swigpypacked_type) < 0) + if (PyType_Ready(&swigpypacked_type) != 0) return NULL; } return &swigpypacked_type; @@ -1200,12 +1230,17 @@ SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this) #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS) PyObject **dictptr = _PyObject_GetDictPtr(inst); if (dictptr != NULL) { - PyObject *dict = *dictptr; - if (dict == NULL) { - dict = PyDict_New(); - *dictptr = dict; - PyDict_SetItem(dict, SWIG_This(), swig_this); - } + PyObject *dict = *dictptr; + if (dict == NULL) { + dict = PyDict_New(); + *dictptr = dict; + } + if (dict) { + PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + Py_DECREF(inst); + inst = 0; + } } #else if (PyObject_SetAttr(inst, SWIG_This(), swig_this) == -1) { @@ -1256,7 +1291,11 @@ SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this) dict = PyDict_New(); *dictptr = dict; } - return PyDict_SetItem(dict, SWIG_This(), swig_this); + if (dict) { + return PyDict_SetItem(dict, SWIG_This(), swig_this); + } else{ + return -1; + } } #endif return PyObject_SetAttr(inst, SWIG_This(), swig_this); @@ -1271,7 +1310,7 @@ SWIG_Python_InitShadowInstance(PyObject *args) { } else { SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]); if (sthis) { - SwigPyObject_append((PyObject*) sthis, obj[1]); + Py_DECREF(SwigPyObject_append((PyObject*) sthis, obj[1])); } else { if (SWIG_Python_SetSwigThis(obj[0], obj[1]) != 0) return NULL; @@ -1310,7 +1349,9 @@ SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int f } else { newobj = PyObject_New(SwigPyObject, clientdata->pytype); #ifdef SWIGPYTHON_BUILTIN - newobj->dict = 0; + if (newobj) { + newobj->dict = 0; + } #endif } if (newobj) { @@ -1349,6 +1390,13 @@ SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) { void *SWIG_ReturnGlobalTypeList(void *); #endif +/* The python cached type query */ +SWIGRUNTIME PyObject * +SWIG_Python_TypeCache(void) { + static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); + return cache; +} + SWIGRUNTIME swig_module_info * SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) { static void *type_pointer = (void *)0; @@ -1377,11 +1425,13 @@ SWIG_Python_DestroyModule(PyObject *obj) swig_type_info *ty = types[i]; if (ty->owndata) { SwigPyClientData *data = (SwigPyClientData *) ty->clientdata; + ty->clientdata = 0; if (data) SwigPyClientData_Del(data); } } Py_DECREF(SWIG_This()); Swig_This_global = NULL; + Py_DECREF(SWIG_Python_TypeCache()); } SWIGRUNTIME void @@ -1395,19 +1445,14 @@ SWIG_Python_SetModule(swig_module_info *swig_module) { #endif PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule); if (pointer && module) { - PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer); + if (PyModule_AddObject(module, "type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer) != 0) { + Py_DECREF(pointer); + } } else { Py_XDECREF(pointer); } } -/* The python cached type query */ -SWIGRUNTIME PyObject * -SWIG_Python_TypeCache(void) { - static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New(); - return cache; -} - SWIGRUNTIME swig_type_info * SWIG_Python_TypeQuery(const char *type) { @@ -1422,8 +1467,10 @@ SWIG_Python_TypeQuery(const char *type) descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type); if (descriptor) { obj = PyCapsule_New((void*) descriptor, NULL, NULL); - PyDict_SetItem(cache, key, obj); - Py_DECREF(obj); + if (obj) { + PyDict_SetItem(cache, key, obj); + Py_DECREF(obj); + } } } Py_DECREF(key); @@ -1566,7 +1613,7 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { } if (!tp->tp_dict) { - if (PyType_Ready(tp) < 0) + if (PyType_Ready(tp) != 0) goto done; } @@ -1581,7 +1628,7 @@ SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) { } else { encoded_name = PyUnicode_AsUTF8String(name); if (!encoded_name) - return -1; + goto done; } PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name)); Py_DECREF(encoded_name); diff --git a/Lib/python/std_auto_ptr.i b/Lib/python/std_auto_ptr.i index e310e00c8..c94006a68 100644 --- a/Lib/python/std_auto_ptr.i +++ b/Lib/python/std_auto_ptr.i @@ -1,5 +1,5 @@ /* - The typemaps here allow to handle functions returning std::auto_ptr<>, + The typemaps here allow handling functions returning std::auto_ptr<>, which is the most common use of this type. If you have functions taking it as parameter, these typemaps can't be used for them and you need to do something else (e.g. use shared_ptr<> which SWIG supports fully). diff --git a/Lib/ruby/rubyautodoc.swg b/Lib/ruby/rubyautodoc.swg index 1e6b0d9dc..6b0472ce8 100644 --- a/Lib/ruby/rubyautodoc.swg +++ b/Lib/ruby/rubyautodoc.swg @@ -77,7 +77,7 @@ AUTODOC(operator>, "Higher than comparison operator"); AUTODOC(operator<<, "Left shifting or appending operator"); AUTODOC(operator>>, "Right shifting operator or extracting operator"); AUTODOC(operator+, "Add operator"); -AUTODOC(operator-, "Substraction operator"); +AUTODOC(operator-, "Subtraction operator"); AUTODOC(operator+(), "Positive operator"); AUTODOC(operator-(), "Negation operator"); AUTODOC(operator&, "AND operator"); @@ -93,7 +93,7 @@ AUTODOC(__gt__, "Higher than comparison operator"); AUTODOC(__lshift__, "Left shifting or appending operator"); AUTODOC(__rshift__, "Right shifting operator or extracting operator"); AUTODOC(__add___, "Add operator"); -AUTODOC(__sub__, "Substraction operator"); +AUTODOC(__sub__, "Subtraction operator"); AUTODOC(__pos__, "Positive operator"); AUTODOC(__neg__, "Negation operator"); AUTODOC(__and__, "AND operator"); diff --git a/Lib/ruby/std_auto_ptr.i b/Lib/ruby/std_auto_ptr.i index 3a415b942..eab8ec53d 100644 --- a/Lib/ruby/std_auto_ptr.i +++ b/Lib/ruby/std_auto_ptr.i @@ -1,5 +1,5 @@ /* - The typemaps here allow to handle functions returning std::auto_ptr<>, + The typemaps here allow handling functions returning std::auto_ptr<>, which is the most common use of this type. If you have functions taking it as parameter, these typemaps can't be used for them and you need to do something else (e.g. use shared_ptr<> which SWIG supports fully). diff --git a/Lib/scilab/scienum.swg b/Lib/scilab/scienum.swg index 54ec1f85c..cc1f7c977 100644 --- a/Lib/scilab/scienum.swg +++ b/Lib/scilab/scienum.swg @@ -18,7 +18,7 @@ SWIG_Int_AsEnum(void *pvApiCtx, int iVar, int *enumValue, char *fname) { } %fragment(SWIG_From_frag(Enum), "header", fragment="SWIG_Int_FromEnum") { -%#define SWIG_From_Enum(scilabValue) SWIG_Int_FromEnum(pvApiCtx, SWIG_Scilab_GetOutputPosition(), scilabValue, SWIG_Scilab_GetFuncName()) +%#define SWIG_From_Enum(scilabValue) SWIG_Int_FromEnum(pvApiCtx, SWIG_Scilab_GetOutputPosition(), (int)scilabValue, SWIG_Scilab_GetFuncName()) } %fragment("SWIG_Int_FromEnum", "header", fragment="SWIG_SciDouble_FromInt") { SWIGINTERN int diff --git a/Lib/swiginit.swg b/Lib/swiginit.swg index 33926b10f..e50b1b46d 100644 --- a/Lib/swiginit.swg +++ b/Lib/swiginit.swg @@ -50,9 +50,12 @@ extern "C" { #define SWIGRUNTIME_DEBUG #endif +#ifndef SWIG_INIT_CLIENT_DATA_TYPE +#define SWIG_INIT_CLIENT_DATA_TYPE void * +#endif SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { +SWIG_InitializeModule(SWIG_INIT_CLIENT_DATA_TYPE clientdata) { size_t i; swig_module_info *module_head, *iter; int init; diff --git a/Lib/swigrun.swg b/Lib/swigrun.swg index 59118ecad..5f3159916 100644 --- a/Lib/swigrun.swg +++ b/Lib/swigrun.swg @@ -115,7 +115,7 @@ SWIG errors code. Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this + allows returning the 'cast rank', for example, if you have this int food(double) int fooi(int); diff --git a/Lib/tcl/mactkinit.c b/Lib/tcl/mactkinit.c index 8d1420088..18f1f0203 100644 --- a/Lib/tcl/mactkinit.c +++ b/Lib/tcl/mactkinit.c @@ -126,7 +126,7 @@ MacintoshInit() * * This procedure calls initialization routines require a Tcl * interp as an argument. This call effectively makes the passed - * iterpreter the "main" interpreter for the application. + * interpreter the "main" interpreter for the application. * * Results: * Returns TCL_OK if everything went fine. If it didn't the diff --git a/Lib/typemaps/swigtype.swg b/Lib/typemaps/swigtype.swg index 581de1a90..402313ebf 100644 --- a/Lib/typemaps/swigtype.swg +++ b/Lib/typemaps/swigtype.swg @@ -562,29 +562,29 @@ * ------------------------------------------------------------ */ %typemap(in) SWIGTYPE (CLASS::*) { - int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($type),$descriptor); + int res = SWIG_ConvertMember($input, %as_voidptr(&$1), sizeof($1),$descriptor); if (!SWIG_IsOK(res)) { %argument_fail(res,"$type",$symname, $argnum); } } %typemap(out,noblock=1) SWIGTYPE (CLASS::*) { - %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor)); + %set_output(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($1), $descriptor)); } %typemap(varin) SWIGTYPE (CLASS::*) { - int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($type), $descriptor); + int res = SWIG_ConvertMember($input,%as_voidptr(&$1), sizeof($1), $descriptor); if (!SWIG_IsOK(res)) { %variable_fail(res, "$type", "$name"); } } %typemap(varout,noblock=1) SWIGTYPE (CLASS::*) { - %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor)); + %set_varoutput(SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($1), $descriptor)); } %typemap(constcode,noblock=1) SWIGTYPE (CLASS::*) { - %set_constant("$symname", SWIG_NewMemberObj(%as_voidptr(&$value), sizeof($type), $descriptor)); + %set_constant("$symname", SWIG_NewMemberObj(%as_voidptr(&$value), sizeof($value), $descriptor)); } #if defined(SWIG_DIRECTOR_TYPEMAPS) @@ -592,13 +592,13 @@ /* directorin */ %typemap(directorin,noblock=1) SWIGTYPE (CLASS::*) { - $input = SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($type), $descriptor); + $input = SWIG_NewMemberObj(%as_voidptr(&$1), sizeof($1), $descriptor); } /* directorout */ %typemap(directorout) SWIGTYPE (CLASS::*) { - int swig_res = SWIG_ConvertMember($input,%as_voidptr(&$result), sizeof($type), $descriptor); + int swig_res = SWIG_ConvertMember($input,%as_voidptr(&$result), sizeof($result), $descriptor); if (!SWIG_IsOK(swig_res)) { %dirout_fail(swig_res,"$type"); } diff --git a/Lib/uffi/uffi.swg b/Lib/uffi/uffi.swg deleted file mode 100644 index 41b085998..000000000 --- a/Lib/uffi/uffi.swg +++ /dev/null @@ -1,101 +0,0 @@ -/* Define a C preprocessor symbol that can be used in interface files - to distinguish between the SWIG language modules. */ - -#define SWIG_UFFI - -/* Typespecs for basic types. */ - -%typemap(ffitype) char ":char"; -%typemap(ffitype) unsigned char ":unsigned-char"; -%typemap(ffitype) signed char ":char"; -%typemap(ffitype) short ":short"; -%typemap(ffitype) signed short ":short"; -%typemap(ffitype) unsigned short ":unsigned-short"; -%typemap(ffitype) int ":int"; -%typemap(ffitype) signed int ":int"; -%typemap(ffitype) unsigned int ":unsigned-int"; -%typemap(ffitype) long ":long"; -%typemap(ffitype) signed long ":long"; -%typemap(ffitype) unsigned long ":unsigned-long"; -%typemap(ffitype) float ":float"; -%typemap(ffitype) double ":double"; -%typemap(ffitype) char * ":cstring"; -%typemap(ffitype) void * ":pointer-void"; -%typemap(ffitype) void ":void"; - -// FIXME: This is guesswork -typedef long size_t; - -%wrapper %{ -(eval-when (compile eval) - -;;; You can define your own identifier converter if you want. -;;; Use the -identifier-converter command line argument to -;;; specify its name. - -(defun identifier-convert-null (id &key type) - (declare (ignore type)) - (read-from-string id)) - -(defun identifier-convert-lispify (cname &key type) - (assert (stringp cname)) - (if (eq type :constant) - (setf cname (format nil "*~A*" cname))) - (setf cname (replace-regexp cname "_" "-")) - (let ((lastcase :other) - newcase char res) - (dotimes (n (length cname)) - (setf char (schar cname n)) - (if* (alpha-char-p char) - then - (setf newcase (if (upper-case-p char) :upper :lower)) - - (when (or (and (eq lastcase :upper) (eq newcase :lower)) - (and (eq lastcase :lower) (eq newcase :upper))) - ;; case change... add a dash - (push #\- res) - (setf newcase :other)) - - (push (char-downcase char) res) - - (setf lastcase newcase) - - else - (push char res) - (setf lastcase :other))) - (read-from-string (coerce (nreverse res) 'string)))) - -(defun identifier-convert-low-level (cname &key type) - (assert (stringp cname)) - (if (eq type :constant) - (setf cname (format nil "+~A+" cname))) - (setf cname (substitute #\- #\_ cname)) - (if (eq type :operator) - (setf cname (format nil "%~A" cname))) - (if (eq type :constant-function) - nil) - (read-from-string cname)) - - - -(defmacro swig-defconstant (string value &key (export T)) - (let ((symbol (funcall *swig-identifier-converter* string :type :constant))) - `(eval-when (compile load eval) - (uffi:def-constant ,symbol ,value ,export)))) - -(defmacro swig-defun (name &rest rest) - (let ((symbol (funcall *swig-identifier-converter* name :type :operator))) - `(eval-when (compile load eval) - (uffi:def-function (,name ,symbol) ,@rest) - (export (quote ,symbol))))) - -(defmacro swig-def-struct (name &rest fields) - "Declare a struct object" - (let ((symbol (funcall *swig-identifier-converter* name :type :type))) - `(eval-when (compile load eval) - (uffi:def-struct ,symbol ,@fields) - (export (quote ,symbol))))) - - -) ;; eval-when -%} diff --git a/Makefile.in b/Makefile.in index 39816bed5..6edfc240a 100644 --- a/Makefile.in +++ b/Makefile.in @@ -29,7 +29,7 @@ TARGET = $(TARGET_NOEXE)@EXEEXT@ SOURCE = Source CCACHE = CCache DOCS = Doc/Manual -HAVE_CXX11_COMPILER = @HAVE_CXX11_COMPILER@ +HAVE_CXX11 = @HAVE_CXX11@ swig: libfiles source ccache @@ -249,7 +249,7 @@ check-%-test-suite: echo warning: cannot $(ACTION) $* test-suite "(no dir $$dir)";\ else \ echo $(ACTION)ing $* test-suite; \ - (cd $$dir && $(MAKE) $(FLAGS) $(ACTION) HAVE_CXX11_COMPILER=$(HAVE_CXX11_COMPILER)) \ + (cd $$dir && $(MAKE) $(FLAGS) $(ACTION) HAVE_CXX11=$(HAVE_CXX11)) \ || passed=false; \ fi; \ test $$passed = true diff --git a/RELEASENOTES b/RELEASENOTES index cc3ba0712..da60d543f 100644 --- a/RELEASENOTES +++ b/RELEASENOTES @@ -7,6 +7,10 @@ Release Notes Detailed release notes are available with the release and are also published on the SWIG web site at http://swig.org/release.html. +SWIG-4.1.0 summary: +- Add PHP 8 support. +- PHP wrapping is now done entirely via PHP's C API - no more .php wrapper. + SWIG-4.0.2 summary: - A few fixes around doxygen comment handling. - Ruby 2.7 support added. diff --git a/Source/CParse/cscanner.c b/Source/CParse/cscanner.c index a3702704e..2113b9cc6 100644 --- a/Source/CParse/cscanner.c +++ b/Source/CParse/cscanner.c @@ -93,7 +93,7 @@ int isStructuralDoxygen(String *s) { const size_t len = strlen(structuralTags[n]); if (strncmp(slashPointer, structuralTags[n], len) == 0) { /* Take care to avoid false positives with prefixes of other tags. */ - if (slashPointer[len] == '\0' || isspace(slashPointer[len])) + if (slashPointer[len] == '\0' || isspace((int)slashPointer[len])) return 1; } } diff --git a/Source/CParse/templ.c b/Source/CParse/templ.c index 22d49fac5..2f38cc2c2 100644 --- a/Source/CParse/templ.c +++ b/Source/CParse/templ.c @@ -839,6 +839,7 @@ Node *Swig_cparse_template_locate(String *name, Parm *tparms, Symtab *tscope) { String *nodeType = nodeType(n); int isclass = 0; assert(Equal(nodeType, "template")); + (void)nodeType; isclass = (Equal(Getattr(n, "templatetype"), "class")); if (!isclass) { /* If not a templated class we must have a templated function. diff --git a/Source/DOH/file.c b/Source/DOH/file.c index 570f84ed5..96f700223 100644 --- a/Source/DOH/file.c +++ b/Source/DOH/file.c @@ -64,6 +64,7 @@ static void open_files_list_remove(DohFile *f) { } Delete(sf); assert(removed); + (void)removed; } /* ----------------------------------------------------------------------------- @@ -80,6 +81,7 @@ void DohCloseAllOpenFiles() { DOHString *sf = Getitem(all_open_files, i); int check = sscanf(Char(sf), "%p", (void **)&f); assert(check == 1); + (void)check; if (f->closeondel) { if (f->filep) { check = fclose(f->filep); diff --git a/Source/Doxygen/doxytranslator.h b/Source/Doxygen/doxytranslator.h index f07b632a2..a72a31df6 100644 --- a/Source/Doxygen/doxytranslator.h +++ b/Source/Doxygen/doxytranslator.h @@ -53,13 +53,13 @@ public: virtual ~DoxygenTranslator(); /* - * Return the documentation for a given node formated for the correct + * Return the documentation for a given node formatted for the correct * documentation system. */ String *getDocumentation(Node *node, const_String_or_char_ptr indentationString); /* - * Returns truem is the specified node has comment attached. + * Returns true if the specified node has comment attached. */ bool hasDocumentation(Node *node); diff --git a/Source/Doxygen/pydoc.h b/Source/Doxygen/pydoc.h index 07c5ce51e..19885276f 100644 --- a/Source/Doxygen/pydoc.h +++ b/Source/Doxygen/pydoc.h @@ -195,7 +195,7 @@ private: typedef std::map<std::string, std::pair<tagHandler, std::string> >TagHandlersMap; static TagHandlersMap tagHandlers; - // this contains the sections tittles, like 'Arguments:' or 'Notes:', that are printed only once + // this contains the sections titles, like 'Arguments:' or 'Notes:', that are printed only once static std::map<std::string, std::string> sectionTitles; // Helper functions for fillStaticTables(): make a new tag handler object. diff --git a/Source/Include/swigwarn.h b/Source/Include/swigwarn.h index 8362cc08e..955a8773a 100644 --- a/Source/Include/swigwarn.h +++ b/Source/Include/swigwarn.h @@ -157,9 +157,9 @@ #define WARN_TYPE_REDEFINED 404 #define WARN_TYPE_RVALUE_REF_QUALIFIER_IGNORED 405 -#define WARN_TYPEMAP_SOURCETARGET 450 +#define WARN_TYPEMAP_SOURCETARGET 450 /* No longer issued */ #define WARN_TYPEMAP_CHARLEAK 451 -#define WARN_TYPEMAP_SWIGTYPE 452 +#define WARN_TYPEMAP_SWIGTYPE 452 /* No longer issued */ #define WARN_TYPEMAP_APPLY_UNDEF 453 #define WARN_TYPEMAP_SWIGTYPELEAK 454 @@ -302,19 +302,7 @@ /* please leave 830-849 free for C# */ -#define WARN_MODULA3_TYPEMAP_TYPE_UNDEF 850 -#define WARN_MODULA3_TYPEMAP_GETCPTR_UNDEF 851 -#define WARN_MODULA3_TYPEMAP_CLASSMOD_UNDEF 852 -#define WARN_MODULA3_TYPEMAP_PTRCONSTMOD_UNDEF 853 -#define WARN_MODULA3_TYPEMAP_MULTIPLE_RETURN 854 -#define WARN_MODULA3_MULTIPLE_INHERITANCE 855 -#define WARN_MODULA3_TYPECONSTRUCTOR_UNKNOWN 856 -#define WARN_MODULA3_UNKNOWN_PRAGMA 857 -#define WARN_MODULA3_BAD_ENUMERATION 858 -#define WARN_MODULA3_DOUBLE_ID 859 -#define WARN_MODULA3_BAD_IMPORT 860 - -/* please leave 850-869 free for Modula 3 */ +/* 850-860 were used by Modula 3 (removed in SWIG 4.1.0) - avoid reusing for now */ #define WARN_PHP_MULTIPLE_INHERITANCE 870 #define WARN_PHP_UNKNOWN_PRAGMA 871 diff --git a/Source/Modules/allegrocl.cxx b/Source/Modules/allegrocl.cxx deleted file mode 100644 index 97af186fe..000000000 --- a/Source/Modules/allegrocl.cxx +++ /dev/null @@ -1,2963 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * allegrocl.cxx - * - * ALLEGROCL language module for SWIG. - * ----------------------------------------------------------------------------- */ - -#include "swigmod.h" -#include "cparse.h" -#include <ctype.h> - -// #define ALLEGROCL_DEBUG -// #define ALLEGROCL_WRAP_DEBUG -// #define ALLEGROCL_TYPE_DEBUG -// #define ALLEGROCL_CLASS_DEBUG - -static const char *usage = "\ -Allegro CL Options (available with -allegrocl)\n\ - -identifier-converter <type or funcname> - \n\ - Specifies the type of conversion to do on C identifiers to convert\n\ - them to symbols. There are two built-in converters: 'null' and\n\ - 'lispify'. The default is 'null'. If you supply a name other\n\ - than one of the built-ins, then a function by that name will be\n\ - called to convert identifiers to symbols.\n\ - -[no]cwrap - Turn on or turn off generation of an intermediate C file when\n\ - creating a C interface. By default this is only done for C++ code.\n\ - -isolate - Define all SWIG helper functions in a package unique to this\n\ - module. Avoids redefinition warnings when loading multiple\n\ - SWIGged modules into the same running Allegro CL image.\n\ -"; - -static File *f_cl = 0; -String *f_clhead = NewString(""); -String *f_clwrap = NewString("(swig-in-package ())\n\n"); -static File *f_begin; -static File *f_runtime; -static File *f_cxx_header = 0; -static File *f_cxx_wrapper = 0; - -static String *module_name = 0; -static String *swig_package = 0; - -static String *identifier_converter = NewString("identifier-convert-null"); - -static bool CWrap = true; // generate wrapper file for C code by default. most correct. -static bool Generate_Wrapper = false; -static bool unique_swig_package = false; - -static SwigType *fwdref_ffi_type = NewString("__SWIGACL_FwdReference"); - -static String *current_namespace = NewString(""); -static String *current_package = NewString(""); -static Hash *defined_namespace_packages = NewHash(); -static Node *in_class = 0; - -static Node *first_linked_type = 0; -static Hash *defined_foreign_types = NewHash(); -static Hash *defined_foreign_ltypes = NewHash(); - -static String *anon_type_name = NewString("anontype"); -static int anon_type_count = 0; - -// stub -String *convert_literal(String *num_param, String *type, bool try_to_split = true); - -class ALLEGROCL:public Language { -public: - virtual void main(int argc, char *argv[]); - virtual int top(Node *n); - virtual int functionWrapper(Node *n); - virtual int namespaceDeclaration(Node *n); - virtual int constructorHandler(Node *n); - virtual int destructorHandler(Node *n); - virtual int globalvariableHandler(Node *n); - virtual int variableWrapper(Node *n); - virtual int constantWrapper(Node *n); - virtual int memberfunctionHandler(Node *n); - virtual int membervariableHandler(Node *n); - virtual int classHandler(Node *n); - virtual int emit_one(Node *n); - virtual int enumDeclaration(Node *n); - virtual int enumvalueDeclaration(Node *n); - virtual int typedefHandler(Node *n); - virtual int classforwardDeclaration(Node *n); - virtual int templateDeclaration(Node *n); - virtual int validIdentifier(String *s); -private: - int emit_defun(Node *n, File *f_cl); - int emit_dispatch_defun(Node *n); - int emit_buffered_defuns(Node *n); - int cClassHandler(Node *n); - int cppClassHandler(Node *n); -}; -static ALLEGROCL *allegrocl = 0; - -static String *trim(String *str) { - char *c = Char(str); - while (*c != '\0' && isspace((int) *c)) - ++c; - String *result = NewString(c); - Chop(result); - return result; -} - -int is_integer(String *s) { - char *c = Char(s); - if (c[0] == '#' && (c[1] == 'x' || c[1] == 'o')) - c += 2; - - while (*c) { - if (!isdigit(*c)) - return 0; - c++; - } - return 1; -} - -String *class_from_class_or_class_ref(String *type) { - SwigType *stripped = SwigType_strip_qualifiers(type); - if (SwigType_isclass(stripped)) - return stripped; - - if (SwigType_ispointer(stripped) || SwigType_isreference(stripped)) { - // Printf(stderr,"It is a pointer/reference. Is it a class?\n"); - SwigType_pop(stripped); - if (SwigType_isclass(stripped)) { - return stripped; - } - } - return 0; -} - -String *lookup_defined_foreign_type(String *k) { - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "Looking up defined type '%s'.\n Found: '%s'\n", k, Getattr(defined_foreign_types, k)); -#endif - - return Getattr(defined_foreign_types, k); -} - -String *listify_namespace(String *namespaze) { - if (Len(namespaze) == 0) - return NewString("()"); - String *result = NewStringf("(\"%s\")", namespaze); - Replaceall(result, "::", "\" \""); - return result; -} - -String *namespaced_name(Node *n, String *ns = current_namespace) { - - return NewStringf("%s%s%s", ns, (Len(ns) != 0) ? "::" : "", Getattr(n, "sym:name")); -} - -// "Namespace::Nested::Class2::Baz" -> "Baz" -static String *strip_namespaces(String *str) { - return Swig_scopename_last(str); -} - -void add_linked_type(Node *n) { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Adding linked node of type: %s(%s) %s(%p)\n\n", nodeType(n), Getattr(n, "storage"), Getattr(n, "name"), n); - // Swig_print_node(n); -#endif - if (!first_linked_type) { - first_linked_type = n; - Setattr(n, "allegrocl:last_linked_type", n); - } else { - Node *t = Getattr(first_linked_type, "allegrocl:last_linked_type"); - Setattr(t, "allegrocl:next_linked_type", n); - Setattr(first_linked_type, "allegrocl:last_linked_type", n); - } -} - -void replace_linked_type(Node *old, Node *new_node) { - Node *prev = Getattr(old, "allegrocl:prev_linked_type"); - - Setattr(new_node, "allegrocl:next_linked_type", Getattr(old, "allegrocl:next_linked_type")); - if (prev) - Setattr(prev, "allegrocl:next_linked_type", new_node); - Delattr(old, "allegrocl:next_linked_type"); - Delattr(old, "allegrocl:prev_linked_type"); - - // check if we're replacing the first link. - if (first_linked_type == old) { - first_linked_type = new_node; - Setattr(first_linked_type, "allegrocl:last_linked_type", Getattr(old, "allegrocl:last_linked_type")); - } - // check if we're replacing the last link. - if (Getattr(first_linked_type, "allegrocl:last_linked_type") == old) - Setattr(first_linked_type, "allegrocl:last_linked_type", new_node); -} - -void insert_linked_type_at(Node *old, Node *new_node, int before = 1) { - Node *p = 0; - - if (!first_linked_type) { - add_linked_type(new_node); - return; - } - - if (!before) { - Setattr(new_node, "allegrocl:next_linked_type", Getattr(old, "allegrocl:next_linked_type")); - Setattr(old, "allegrocl:next_linked_type", new_node); - if (Getattr(first_linked_type, "allegrocl:last_linked_type") == old) - Setattr(first_linked_type, "allegrocl:last_linked_type", new_node); - } else { - Node *c = first_linked_type; - while (c) { - if (c == old) { - break; - } else { - p = c; - c = Getattr(c, "allegrocl:next_linked_type"); - } - } - if (c == old) { - Setattr(new_node, "allegrocl:next_linked_type", c); - if (first_linked_type == c) { - first_linked_type = new_node; - Setattr(first_linked_type, "allegrocl:last_linked_type", Getattr(c, "allegrocl:last_linked_type")); - Delattr(c, "allegrocl:last_linked_type"); - } - if (p) - Setattr(p, "allegrocl:next_linked_type", new_node); - } - } -} - -Node *find_linked_type_by_name(String *name) { - Node *p = 0; - Node *c = first_linked_type; - - // Printf(stderr,"in find_linked_type_by_name '%s'...", name); - while (c) { - String *key = Getattr(c, "name"); - if (!Strcmp(key, name)) { - break; - } else { - p = c; - c = Getattr(c, "allegrocl:next_linked_type"); - } - } - // Printf(stderr,"exit find_linked_type_by_name.\n"); - - if (p && c) - Setattr(c, "allegrocl:prev_linked_type", p); - // Printf(stderr,"find_linked_type_by_name: DONE\n"); - return c; -} - -Node *get_primary_synonym_of(Node *n) { - Node *p = Getattr(n, "allegrocl:synonym-of"); - Node *prim = n; - - // Printf(stderr, "getting primary synonym of %p\n", n); - while (p) { - // Printf(stderr, " found one! %p\n", p); - prim = p; - p = Getattr(p, "allegrocl:synonym-of"); - } - // Printf(stderr,"get_primary_syn: DONE. returning %s(%p)\n", Getattr(prim,"name"),prim); - return prim; -} - -void add_forward_referenced_type(Node *n, int overwrite = 0) { - String *k = Getattr(n, "name"); - String *name = Getattr(n, "sym:name"); - String *ns = listify_namespace(current_namespace); - - String *val = Getattr(defined_foreign_types, k); - - if (!val || overwrite) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "Adding forward reference for %s (overwrite=%d)\n", k, overwrite); -#endif - Setattr(defined_foreign_types, Copy(k), NewString("forward-reference")); - - String *mangled_lname_gen = NewStringf("#.(swig-insert-id \"%s\" %s :type :class)", name, ns); - - Setattr(defined_foreign_ltypes, Copy(k), mangled_lname_gen); - // Printf(f_cl, ";; forward reference stub\n" - // "(swig-def-foreign-class \"%s\" (ff:foreign-pointer) (:class ))\n\n" - // , name); - -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Linking forward reference type = %s(%p)\n", k, n); -#endif - add_linked_type(n); - } -} - -void add_defined_foreign_type(Node *n, int overwrite = 0, String *k = 0, - String *name = 0, String *ns = current_namespace) { - - String *val; - String *ns_list = listify_namespace(ns); - String *templated = n ? Getattr(n, "template") : 0; - String *cDeclName = n ? Getattr(n, "name") : 0; - -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "IN A-D-F-T. (n=%p, ow=%d, k=%s, name=%s, ns=%s\n", n, overwrite, k, name, ns); - Printf(stderr, " templated = '%p', classDecl = '%p'\n", templated, cDeclName); -#endif - if (n) { - if (!name) - name = Getattr(n, "sym:name"); - if (!name) - name = strip_namespaces(Getattr(n, "name")); - if (templated) { - k = namespaced_name(n); - } else { - String *kind_of_type = Getattr(n, "kind"); - - /* - For typedefs of the form: - - typedef struct __xxx { ... } xxx; - - behavior differs between C mode and C++ mode. - - C Mode: - add_defined_foreign_type will be called once via classHandler - to define the type for 'struct __xxx' and add the mapping from - 'struct __xxx' -> 'xxx' - - It will also be called once via typedefHandler to add the - mapping 'xxx' -> 'xxx' - - C++ Mode: - add_defined_foreign_type will be called once via classHandler - to define the type for 'xxx'. it also adds the mapping from - 'xxx' -> 'xxx' and also for 'struct xxx' -> 'xxx' - - In typedefHandler, we again try to add the mapping from - 'xxx' -> 'xxx', which already exists. This second mapping - is ignored. - - Both modes: - - All references to this typedef'd struct will appear in - generated lisp code as an objectd of type 'xxx'. For - non-typedef'd structs, the classHand mapping will be - - struct __xxx -> (swig-insert-id "__xxx") - */ - // Swig_print_node(n); - String *unnamed = Getattr(n, "unnamed"); - if (kind_of_type && (!Strcmp(kind_of_type, "struct") - || !Strcmp(kind_of_type, "union")) && cDeclName && !unnamed) { - k = NewStringf("%s %s", kind_of_type, cDeclName); - } else { - if (!Strcmp(nodeType(n), "enum") && unnamed) { - name = NewStringf("%s%d", anon_type_name, anon_type_count++); - k = NewStringf("enum %s", name); - Setattr(n, "allegrocl:name", name); - - } else { - k = k ? k : Getattr(n, "name"); - } - } - } - // Swig_print_node(n); - } - - String *tname = SwigType_istemplate_templateprefix(name); - if (tname) { - String *temp = strip_namespaces(tname); - name = NewStringf("%s%s%s", temp, SwigType_templateargs(name), SwigType_templatesuffix(name)); - Delete(temp); - Delete(tname); - } - - val = lookup_defined_foreign_type(k); - - int is_fwd_ref = 0; - if (val) - is_fwd_ref = !Strcmp(val, "forward-reference"); - - if (!val || overwrite || is_fwd_ref) { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Adding defined type '%s' = '%s' '%s' (overwrite=%d, in-class=%d)\n", k, ns, name, overwrite, in_class); -#endif - String *mangled_name_gen = NewStringf("#.(swig-insert-id \"%s\" %s :type :type)", name, ns_list); - String *mangled_lname_gen = NewStringf("#.(swig-insert-id \"%s\" %s :type :class)", name, ns_list); - - Setattr(defined_foreign_types, Copy(k), Copy(mangled_name_gen)); - Setattr(defined_foreign_ltypes, Copy(k), Copy(mangled_lname_gen)); - - if (CPlusPlus) { - bool cpp_struct = Strstr(k, "struct ") ? true : false; - bool cpp_union = Strstr(k, "union ") ? true : false; - - String *cpp_type = 0; - if (cpp_struct) { - cpp_type = Copy(k); - Replaceall(cpp_type, "struct ", ""); - } else if (cpp_union) { - cpp_type = Copy(k); - Replaceall(cpp_type, "union ", ""); - } - - if (cpp_struct || cpp_union) { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, " Also adding defined type '%s' = '%s' '%s' (overwrite=%d)\n", cpp_type, ns, name, overwrite); -#endif - Setattr(defined_foreign_types, Copy(cpp_type), Copy(mangled_name_gen)); - Setattr(defined_foreign_ltypes, Copy(cpp_type), Copy(mangled_lname_gen)); - } - } -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "looking to add %s/%s(%p) to linked_type_list...\n", k, name, n); -#endif - if (is_fwd_ref) { - // Printf(stderr,"*** 1\n"); - if (n) - add_linked_type(n); - } else { - // Printf(stderr,"*** 1-a\n"); - if (SwigType_istemplate(k)) { - SwigType *resolved = SwigType_typedef_resolve_all(k); - // Printf(stderr,"*** 1-b\n"); - Node *match = find_linked_type_by_name(resolved); - Node *new_node = 0; - // Printf(stderr, "*** temp-1\n"); - if (n) { - new_node = n; - } else { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Creating a new templateInst:\n"); - Printf(stderr, " name = %s\n", resolved); - Printf(stderr, " sym:name = %s\n", name); - Printf(stderr, " real-name = %s\n", k); - Printf(stderr, " type = %s\n", resolved); - Printf(stderr, " ns = %s\n\n", ns); -#endif - new_node = NewHash(); - Setattr(new_node, "nodeType", "templateInst"); - Setattr(new_node, "name", Copy(resolved)); - Setattr(new_node, "sym:name", Copy(name)); - Setattr(new_node, "real-name", Copy(k)); - Setattr(new_node, "type", Copy(resolved)); - Setattr(new_node, "allegrocl:namespace", ns); - Setattr(new_node, "allegrocl:package", ns); - } - - if (!match) { - if (!Strcmp(nodeType(new_node), "templateInst") && in_class) { - /* this is an implicit template instantiation found while - walking a class. need to insert this into the - linked_type list before the current class definition */ -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "trying to insert a templateInst before a class\n"); -#endif - insert_linked_type_at(in_class, new_node); -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "DID IT!\n"); -#endif - } else { - // Printf(stderr,"*** 3\n"); - add_linked_type(new_node); - } - Setattr(new_node, "allegrocl:synonym:is-primary", "1"); - } else { - // a synonym type was found (held in variable 'match') - // Printf(stderr, "setting primary synonym of %p to %p\n", new_node, match); - if (new_node == match) - Printf(stderr, "Hey-4 * - '%s' is a synonym of itself!\n", Getattr(new_node, "name")); - Setattr(new_node, "allegrocl:synonym-of", match); - // Printf(stderr,"*** 4\n"); - add_linked_type(new_node); - } - } else { - Node *match; - - if (!Strcmp(nodeType(n), "cdecl") && !Strcmp(Getattr(n, "storage"), "typedef")) { - SwigType *type = SwigType_strip_qualifiers(Getattr(n, "type")); -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Examining typedef '%s' for class references. (%d)\n", type, SwigType_isclass(type)); -#endif - if (SwigType_isclass(type)) { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Found typedef of a class '%s'\n", type); -#endif - /* - For the following parsed expression: - - typedef struct __xxx { ... } xxx; - - if n is of kind "class" (defining the class 'struct __xxx' - then we add n to the linked type list. - - if n is "cdecl" node of storage "typedef" (to note - that xxx is equivalent to 'struct __xxx' then we don't - want to add this node to the linked type list. - */ - String *defined_type = lookup_defined_foreign_type(type); - String *defined_key_type = lookup_defined_foreign_type(k); - - if ((Strstr(type, "struct ") || Strstr(type, "union ")) - && defined_type && !Strcmp(defined_type, defined_key_type)) { - // mark as a synonym but don't add to linked_type list - // Printf(stderr,"*** 4.8\n"); - Setattr(n, "allegrocl:synonym", "1"); - } else { - SwigType *lookup_type = SwigType_istemplate(type) ? SwigType_typedef_resolve_all(type) : Copy(type); - match = find_linked_type_by_name(lookup_type); - if (match) { - Setattr(n, "allegrocl:synonym", "1"); - Setattr(n, "allegrocl:synonym-of", match); - Setattr(n, "real-name", Copy(lookup_type)); - - // Printf(stderr, "*** pre-5: found match of '%s'(%p)\n", Getattr(match,"name"),match); - // if(n == match) Printf(stderr, "Hey-5 *** setting synonym of %p to %p\n", n, match); - // Printf(stderr,"*** 5\n"); - add_linked_type(n); - } else { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Creating classfoward node for struct stub in typedef.\n"); -#endif - Node *new_node = NewHash(); - String *symname = Copy(type); - Replaceall(symname, "struct ", ""); - Setattr(new_node, "nodeType", "classforward"); - Setattr(new_node, "name", Copy(type)); - Setattr(new_node, "sym:name", symname); - Setattr(new_node, "allegrocl:namespace", ns); - Setattr(new_node, "allegrocl:package", ns); - - String *mangled_new_name = NewStringf("#.(swig-insert-id \"%s\" %s)", symname, ns_list); - String *mangled_new_lname = NewStringf("#.(swig-insert-id \"%s\" %s :type :class)", symname, ns_list); - Setattr(defined_foreign_types, Copy(symname), Copy(mangled_new_name)); - Setattr(defined_foreign_ltypes, Copy(symname), Copy(mangled_new_lname)); - - // Printf(stderr,"Weird! Can't find the type!\n"); - add_forward_referenced_type(new_node); - add_linked_type(new_node); - - Setattr(n, "allegrocl:synonym", "1"); - Setattr(n, "allegrocl:synonym-of", new_node); - - add_linked_type(n); - } - Delete(lookup_type); - } - } else { - // check if it's a pointer or reference to a class. - // Printf(stderr,"Checking if '%s' is a p. or r. to a class\n", type); - String *class_ref = class_from_class_or_class_ref(type); - if (class_ref) { - match = find_linked_type_by_name(class_ref); - Setattr(n, "allegrocl:synonym", "1"); - Setattr(n, "allegrocl:synonym-of", match); - add_linked_type(n); - } - } - Delete(type); - // synonym types have already been added. - // Printf(stderr,"*** 10\n"); - if (!Getattr(n, "allegrocl:synonym")) - add_linked_type(n); - } else if (Getattr(n, "template")) { - // Printf(stderr, "this is a class template node(%s)\n", nodeType(n)); - String *resolved = SwigType_typedef_resolve_all(Getattr(n, "name")); - -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, " looking up %s for linked type match with %s...\n", Getattr(n, "sym:name"), resolved); -#endif - match = find_linked_type_by_name(resolved); - if (!match) { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "found no implicit instantiation of %%template node %s(%p)\n", Getattr(n, "name"), n); -#endif - add_linked_type(n); - } else { - Node *primary = get_primary_synonym_of(match); - - Setattr(n, "allegrocl:synonym:is-primary", "1"); - Delattr(primary, "allegrocl:synonym:is-primary"); - if (n == match) - Printf(stderr, "Hey-7 * setting synonym of %p to %p\n (match = %p)", primary, n, match); - Setattr(primary, "allegrocl:synonym-of", n); - // Printf(stderr,"*** 7\n"); - add_linked_type(n); - } - } else { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "linking type '%s'(%p)\n", k, n); -#endif - // Printf(stderr,"*** 8\n"); - add_linked_type(n); - } - } - } - Delete(mangled_name_gen); - Delete(mangled_lname_gen); - } else { - if (!CPlusPlus || Strcmp(Getattr(n,"kind"),"typedef")) { - Swig_warning(WARN_TYPE_REDEFINED, Getfile(n), Getline(n), - "Attempting to store a foreign type that exists: %s (%s)\n", - k, val); - } - } - - Delete(ns_list); - -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "OUT A-D-F-T\n"); -#endif -} - -void note_implicit_template_instantiation(SwigType *t) { - // the namespace of the implicit instantiation is not necessarily - // current_namespace. Attempt to cull this from the type. -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "culling namespace of '%s' from '%s'\n", t, SwigType_templateprefix(t)); -#endif - SwigType *type = Copy(t); - SwigType *tok = SwigType_pop(type); - String *implicit_ns = SwigType_istemplate(tok) ? Swig_scopename_prefix(SwigType_templateprefix(tok)) : 0; - add_defined_foreign_type(0, 0, t, t, implicit_ns ? implicit_ns : current_namespace); - - Delete(type); -} - -String *get_ffi_type(Node *n, SwigType *ty, const_String_or_char_ptr name) { - /* lookup defined foreign type. - if it exists, it will return a form suitable for placing - into lisp code to generate the def-foreign-type name */ - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "inside g_f_t: looking up '%s' '%s'\n", ty, name); -#endif - - String *found_type = lookup_defined_foreign_type(ty); - - if (found_type) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "found_type '%s'\n", found_type); -#endif - return (Strcmp(found_type, "forward-reference") ? Copy(found_type) : get_ffi_type(n, fwdref_ffi_type, "")); - } else { - Node *node = NewHash(); - Setattr(node, "type", ty); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup("ffitype", node, name, 0); - Delete(node); - - if (tm) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "g-f-t: found ffitype typemap '%s'\n", tm); -#endif - return NewString(tm); - } - - if (SwigType_istemplate(ty)) { - note_implicit_template_instantiation(ty); - return Copy(lookup_defined_foreign_type(ty)); - } - } - return 0; -} - -String *lookup_defined_foreign_ltype(String *l) { - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "Looking up defined ltype '%s'.\n Found: '%s'\n", l, Getattr(defined_foreign_ltypes, l)); -#endif - return Getattr(defined_foreign_ltypes, l); -} - -/* walk type and return string containing lisp version. - recursive. */ -String *internal_compose_foreign_type(Node *n, SwigType *ty) { - - SwigType *tok; - String *ffiType = NewString(""); - - // for a function type, need to walk the parm list. - while (Len(ty) != 0) { - tok = SwigType_pop(ty); - - if (SwigType_isfunction(tok)) { - // Generate Function wrapper - Printf(ffiType, "(:function "); - // walk parm list - List *pl = SwigType_parmlist(tok); - - Printf(ffiType, "("); // start parm list - for (Iterator i = First(pl); i.item; i = Next(i)) { - SwigType *f_arg = SwigType_strip_qualifiers(i.item); - Printf(ffiType, "%s ", internal_compose_foreign_type(n, f_arg)); - Delete(f_arg); - } - Printf(ffiType, ")"); // end parm list. - - // do function return type. - Printf(ffiType, " %s)", internal_compose_foreign_type(n, ty)); - break; - } else if (SwigType_ispointer(tok) || SwigType_isreference(tok)) { - Printf(ffiType, "(* %s)", internal_compose_foreign_type(n, ty)); - } else if (SwigType_isarray(tok)) { - Printf(ffiType, "(:array %s", internal_compose_foreign_type(n, ty)); - String *atype = NewString("int"); - String *dim = convert_literal(SwigType_array_getdim(tok, 0), atype); - Delete(atype); - if (is_integer(dim)) { - Printf(ffiType, " %s)", dim); - } else { - Printf(ffiType, " #| %s |#)", SwigType_array_getdim(tok, 0)); - } - } else if (SwigType_ismemberpointer(tok)) { - // temp - Printf(ffiType, "(* %s)", internal_compose_foreign_type(n, ty)); - } else { - String *res = get_ffi_type(n, tok, ""); - if (res) { - Printf(ffiType, "%s", res); - } else { - SwigType *resolved_type = SwigType_typedef_resolve_all(tok); - if (Cmp(resolved_type, tok) != 0) { - res = get_ffi_type(n, resolved_type, ""); - if (res) { - } else { - res = internal_compose_foreign_type(n, resolved_type); - } - if (res) - Printf(ffiType, "%s", res); - } - - if (!res) { - String *is_struct = 0; - String *tok_remove_text = 0; - String *tok_name = Copy(tok); - String *tok_key = SwigType_str(tok,0); - if ((is_struct = Strstr(tok_key, "struct ")) || Strstr(tok_key, "union ")) { - tok_remove_text = NewString(is_struct ? "struct " : "union "); - } - - /* be more permissive of opaque types. This is the swig way. - compiles will notice if these types are ultimately not - present. */ - - if(tok_remove_text) { - Replaceall(tok_name,tok_remove_text,""); - } - tok_name = strip_namespaces(tok_name); - Delete(tok_remove_text); - // Swig_warning(WARN_TYPE_UNDEFINED_CLASS, Getfile(tok), Getline(tok), "Unable to find definition of '%s', assuming forward reference.\n", tok); - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "i-c-f-t: adding forward reference for unknown type '%s'. mapping: %s -> %s\n", tok, tok_key, tok_name); -#endif - Node *nn = NewHash(); - Setattr(nn,"nodeType","classforward"); - Setattr(nn,"kind","class"); - Setattr(nn,"sym:name",tok_name); - Setattr(nn,"name",tok_key); - Setattr(nn,"allegrocl:package",current_namespace); - - add_forward_referenced_type(nn, 0); - // tok_name is dangling here, unused. ouch. why? - Printf(ffiType, "%s", get_ffi_type(n, tok, ""), tok_name); - } - } - } - } - return ffiType; -} - -String *compose_foreign_type(Node *n, SwigType *ty, String * /*id*/ = 0) { - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "compose_foreign_type: ENTER (%s)...\n ", ty); - // Printf(stderr, "compose_foreign_type: ENTER (%s)(%s)...\n ", ty, (id ? id : 0)); - /* String *id_ref = SwigType_str(ty, id); - Printf(stderr, "looking up typemap for %s, found '%s'(%p)\n", - id_ref, lookup_res ? Getattr(lookup_res, "code") : 0, lookup_res); - if (lookup_res) Swig_print_node(lookup_res); - */ -#endif - - /* should we allow named lookups in the typemap here? YES! */ - /* unnamed lookups should be found in get_ffi_type, called - by internal_compose_foreign_type(), below. */ - - /* I'm reverting to 'no' for the question above. I can no longer - remember why I needed it. If a user needed it, I'll find out - as soon as they upgrade. Sigh. -mutandiz 9/16/2008. */ - -/* - if(id && lookup_res) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "compose_foreign_type: EXIT-1 (%s)\n ", Getattr(lookup_res, "code")); -#endif - return NewString(Getattr(lookup_res, "code")); - } -*/ - - SwigType *temp = SwigType_strip_qualifiers(ty); - String *res = internal_compose_foreign_type(n, temp); - Delete(temp); - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "compose_foreign_type: EXIT (%s)\n ", res); -#endif - - return res; -} - -void update_package_if_needed(Node *n, File *f = f_clwrap) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "update_package: ENTER... \n"); - Printf(stderr, " current_package = '%s'\n", current_package); - Printf(stderr, " node_package = '%s'\n", Getattr(n, "allegrocl:package")); - Printf(stderr, " node(%p) = '%s'\n", n, Getattr(n, "name")); -#endif - String *node_package = Getattr(n, "allegrocl:package"); - if (Strcmp(current_package, node_package)) { - String *lispy_package = listify_namespace(node_package); - - Delete(current_package); - current_package = Copy(node_package); - Printf(f, "\n(swig-in-package %s)\n", lispy_package); - Delete(lispy_package); - } -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "update_package: EXIT.\n"); -#endif -} - -static String *mangle_name(Node *n, char const *prefix = "ACL", String *ns = current_namespace) { - String *suffix = Getattr(n, "sym:overname"); - String *pre_mangled_name = NewStringf("%s_%s__%s%s", prefix, ns, Getattr(n, "sym:name"), suffix); - String *mangled_name = Swig_name_mangle(pre_mangled_name); - Delete(pre_mangled_name); - return mangled_name; -} - -/* utilities */ - -/* remove a pointer from ffitype. non-destructive. - (* :char) ==> :char - (* (:array :int 30)) ==> (:array :int 30) */ -String *dereference_ffitype(String *ffitype) { - char *start; - char *temp = Char(ffitype); - String *reduced_type = 0; - - if(temp && temp[0] == '(' && temp[1] == '*') { - temp += 2; - - // walk past start of pointer references - while(*temp == ' ') temp++; - start = temp; - // temp = Char(reduced_type); - reduced_type = NewString(start); - temp = Char(reduced_type); - // walk to end of string. remove closing paren - while(*temp != '\0') temp++; - *(--temp) = '\0'; - } - - return reduced_type ? reduced_type : Copy(ffitype); -} - -/* returns new string w/ parens stripped */ -String *strip_parens(String *string) { - string = Copy(string); - Replaceall(string, "(", ""); - Replaceall(string, ")", ""); - return string; -} - -int ALLEGROCL::validIdentifier(String *s) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "validIdentifier %s\n", s); -#endif - - char *c = Char(s); - - bool got_dot = false; - bool only_dots = true; - - /* Check that s is a valid common lisp symbol. There's a lot of leeway here. - A common lisp symbol is essentially any token that's not a number and - does not consist of only dots. - - We are expressly not allowing spaces in identifiers here, but spaces - could be added via the identifier converter. */ - while (*c) { - if (*c == '.') { - got_dot = true; - } else { - only_dots = false; - } - if (!isgraph(*c)) - return 0; - c++; - } - - return (got_dot && only_dots) ? 0 : 1; -} - -String *infix_to_prefix(String *val, char split_op, const String *op, String *type) { - List *ored = Split(val, split_op, -1); - - // some float hackery - if (((split_op == '+') || (split_op == '-')) && Len(ored) == 2 && - (SwigType_type(type) == T_FLOAT || SwigType_type(type) == T_DOUBLE || SwigType_type(type) == T_LONGDOUBLE)) { - // check that we're not splitting a float - String *possible_result = convert_literal(val, type, false); - if (possible_result) - return possible_result; - - } - // try parsing the split results. if any part fails, kick out. - bool part_failed = false; - if (Len(ored) > 1) { - String *result = NewStringf("(%s", op); - for (Iterator i = First(ored); i.item; i = Next(i)) { - String *converted = convert_literal(i.item, type); - if (converted) { - Printf(result, " %s", converted); - Delete(converted); - } else { - part_failed = true; - break; - } - } - Printf(result, ")"); - Delete(ored); - return part_failed ? 0 : result; - } - Delete(ored); - return 0; -} - -/* To be called by code generating the lisp interface - Will return a containing the literal based on type. - Will return null if there are problems. - - try_to_split defaults to true (see stub above). - */ -String *convert_literal(String *literal, String *type, bool try_to_split) { - String *num_param = Copy(literal); - String *trimmed = trim(num_param); - String *num = strip_parens(trimmed), *res = 0; - char *s = Char(num); - - String *ns = listify_namespace(current_namespace); - - // very basic parsing of infix expressions. - if (try_to_split && SwigType_type(type) != T_STRING) { - if ((res = infix_to_prefix(num, '|', "logior", type))) - return res; - if ((res = infix_to_prefix(num, '&', "logand", type))) - return res; - if ((res = infix_to_prefix(num, '^', "logxor", type))) - return res; - if ((res = infix_to_prefix(num, '*', "*", type))) - return res; - if ((res = infix_to_prefix(num, '/', "/", type))) - return res; - if ((res = infix_to_prefix(num, '+', "+", type))) - return res; - if ((res = infix_to_prefix(num, '-', "-", type))) - return res; - // if ((res = infix_to_prefix(num, '~', "lognot", type))) return res; - // if( (res = infix_to_prefix(num, '<<', "ash", type)) ) return res; - } - - // unary complement... - if (s[0] == '~' && Len(num) >= 2) { - String *id = NewString(++s); - String *id_conv = convert_literal(id, type, false); - Delete(id); - if (id_conv) - return NewStringf("(lognot %s)", id_conv); - s--; - } - - if (SwigType_type(type) == T_FLOAT || SwigType_type(type) == T_DOUBLE || SwigType_type(type) == T_LONGDOUBLE) { - // Use CL syntax for float literals - String *oldnum = Copy(num); - - // careful. may be a float identifier or float constant. - char *num_start = Char(num); - char *num_end = num_start + strlen(num_start) - 1; - - bool is_literal = isdigit(*num_start) || (*num_start == '.'); - - String *lisp_exp = 0; - if (is_literal) { - if (*num_end == 'f' || *num_end == 'F') { - lisp_exp = NewString("f"); - } else { - lisp_exp = NewString("d"); - } - - if (*num_end == 'l' || *num_end == 'L' || *num_end == 'f' || *num_end == 'F') { - *num_end = '\0'; - num_end--; - } - - int exponents = Replaceall(num, "e", lisp_exp) + Replaceall(num, "E", lisp_exp); - - if (!exponents) - Printf(num, "%s0", lisp_exp); - - if (exponents > 1 || (exponents + Replaceall(num, ".", ".") == 0)) { - // Printf(stderr, "Can't parse '%s' as type '%s'.\n", oldnum, type); - Delete(num); - num = 0; - } - Delete(lisp_exp); - } else { - String *id = NewStringf("#.(swig-insert-id \"%s\" %s :type :constant)", - num, ns); - Delete(num); - num = id; - } - - Delete(oldnum); - Delete(trimmed); - Delete(ns); - return num; - } else if (SwigType_type(type) == T_CHAR) { - /* Use CL syntax for character literals */ - Delete(num); - Delete(trimmed); - return NewStringf("#\\%s", num_param); - } else if (SwigType_type(type) == T_STRING) { - /* Use CL syntax for string literals */ - Delete(num); - Delete(trimmed); - return NewStringf("\"%s\"", num_param); - } else if (Len(num) >= 1 && (isdigit(s[0]) || s[0] == '+' || s[0] == '-')) { - /* use CL syntax for numbers */ - String *oldnum = Copy(num); - int usuffixes = Replaceall(num, "u", "") + Replaceall(num, "U", ""); - int lsuffixes = Replaceall(num, "l", "") + Replaceall(num, "L", ""); - if (usuffixes > 1 || lsuffixes > 1) { - Printf(stderr, "Weird!! number %s looks invalid.\n", oldnum); - SWIG_exit(EXIT_FAILURE); - } - s = Char(num); - if (s[0] == '0' && Len(num) >= 2) { - /*octal or hex */ - res = NewStringf("#%c%s", tolower(s[1]) == 'x' ? 'x' : 'o', s + 2); - Delete(num); - } else { - res = num; - } - Delete(oldnum); - Delete(trimmed); - return res; - } else if (allegrocl->validIdentifier(num)) { - /* convert C/C++ identifiers to CL symbols */ - res = NewStringf("#.(swig-insert-id \"%s\" %s :type :constant)", num, ns); - Delete(num); - Delete(trimmed); - Delete(ns); - return res; - } else { - Delete(trimmed); - return num; - } -} - - -void emit_stub_class(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_stub_class: ENTER... '%s'(%p)\n", Getattr(n, "sym:name"), n); - Swig_print_node(n); -#endif - - - String *name = Getattr(n, "sym:name"); - - if (Getattr(n, "allegrocl:synonym:already-been-stubbed")) - return; - - String *tname = SwigType_istemplate_templateprefix(name); - if (tname) { - String *temp = strip_namespaces(tname); - name = NewStringf("%s%s%s", temp, SwigType_templateargs(name), SwigType_templatesuffix(name)); - Delete(temp); - Delete(tname); - } else { - name = strip_namespaces(name); - } - - // Printf(f_clhead, ";; from emit-stub-class\n"); - update_package_if_needed(n, f_clhead); - Printf(f_clhead, ";; class template stub.\n"); - Printf(f_clhead, "(swig-def-foreign-stub \"%s\")\n", name); - - Setattr(n, "allegrocl:synonym:already-been-stubbed", "1"); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_stub_class: EXIT\n"); -#endif -} - -void emit_synonym(Node *synonym) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_synonym: ENTER... \n"); -#endif - - // Printf(stderr,"in emit_synonym for %s(%p)\n", Getattr(synonym,"name"),synonym); - int is_tempInst = !Strcmp(nodeType(synonym), "templateInst"); - String *synonym_type; - - Node *of = get_primary_synonym_of(synonym); - - if (is_tempInst) { - // Printf(stderr, "*** using real-name '%s'\n", Getattr(synonym,"real-name")); - synonym_type = Getattr(synonym, "real-name"); - } else { - // Printf(stderr, "*** using name '%s'\n", Getattr(synonym,"name")); - synonym_type = Getattr(synonym, "name"); - } - - String *synonym_ns = listify_namespace(Getattr(synonym, "allegrocl:namespace")); - String *syn_ltype, *syn_type, *of_ltype; - // String *of_cdeclname = Getattr(of,"allegrocl:classDeclarationName"); - String *of_ns = Getattr(of, "allegrocl:namespace"); - String *of_ns_list = listify_namespace(of_ns); - // String *of_name = of_cdeclname ? NewStringf("struct %s", Getattr(of,"name")) : NewStringf("%s::%s", of_ns, Getattr(of,"sym:name")); - // String *of_name = NewStringf("%s::%s", of_ns, Getattr(of,"sym:name")); - String *of_name = namespaced_name(of, of_ns); - - if (CPlusPlus && !Strcmp(nodeType(synonym), "cdecl")) { - String *real_name = Getattr(synonym, "real-name"); - if (!real_name) - real_name = NewString("Unknown"); // TODO: fix - syn_ltype = NewStringf("#.(swig-insert-id \"%s\" %s :type :class)", strip_namespaces(real_name), synonym_ns); - syn_type = NewStringf("#.(swig-insert-id \"%s\" %s :type :type)", strip_namespaces(real_name), synonym_ns); - } else { - syn_ltype = lookup_defined_foreign_ltype(synonym_type); - syn_type = lookup_defined_foreign_type(synonym_type); - } - - of_ltype = lookup_defined_foreign_ltype(of_name); - - // Printf(stderr,";; from emit-synonym syn='%s' of_ltype='%s'\n", syn_ltype, of_ltype); - if( of_ltype ) - Printf(f_clhead, "(swig-def-synonym-type %s\n %s\n %s)\n", syn_ltype, of_ltype, syn_type); - - Delete(synonym_ns); - Delete(of_ns_list); - Delete(of_name); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_synonym: EXIT\n"); -#endif -} - -void emit_full_class(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_full_class: ENTER... \n"); -#endif - - String *name = Getattr(n, "sym:name"); - String *kind = Getattr(n, "kind"); - - // Printf(stderr,"in emit_full_class: '%s'(%p).", Getattr(n,"name"),n); - if (Getattr(n, "allegrocl:synonym-of")) { - // Printf(stderr,"but it's a synonym of something.\n"); - update_package_if_needed(n, f_clhead); - emit_synonym(n); - return; - } - // collect superclasses - String *bases = Getattr(n, "bases"); - String *supers = NewString("("); - if (bases) { - int first = 1; - for (Iterator i = First(bases); i.item; i = Next(i)) { - if (!first) - Printf(supers, " "); - String *s = lookup_defined_foreign_ltype(Getattr(i.item, "name")); - // String *name = Getattr(i.item,"name"); - if (s) { - Printf(supers, "%s", s); - } else { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "emit_templ_inst: did not find ltype for base class %s (%s)", Getattr(i.item, "name"), Getattr(n, "allegrocl:namespace")); -#endif - } - } - } else { - Printf(supers, "ff:foreign-pointer"); - } - - // check for "feature:aclmixins" and add those as well. - Printf(supers, " %s)", Getattr(n,"feature:aclmixins")); - - // Walk children to generate type definition. - String *slotdefs = NewString(" "); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, " walking children...\n"); -#endif - - Node *c; - for (c = firstChild(n); c; c = nextSibling(c)) { - String *storage_type = Getattr(c, "storage"); - if ((!Strcmp(nodeType(c), "cdecl") && (!storage_type || Strcmp(storage_type, "typedef")))) { - String *access = Getattr(c, "access"); - - // hack. why would decl have a value of "variableHandler" and now "0"? - String *childDecl = Getattr(c, "decl"); - // Printf(stderr,"childDecl = '%s' (%s)\n", childDecl, Getattr(c,"view")); - if (!childDecl || !Strcmp(childDecl, "0")) - childDecl = NewString(""); - - SwigType *childType; - String *cname; - - // don't include types for private slots (yet). spr33959. - if(access && Strcmp(access,"public")) { - childType = NewStringf("int"); - cname = NewString("nil"); - } else { - childType = NewStringf("%s%s", childDecl, Getattr(c, "type")); - cname = Copy(Getattr(c, "name")); - } - - if (!SwigType_isfunction(childType)) { - // Printf(slotdefs, ";;; member functions don't appear as slots.\n "); - // Printf(slotdefs, ";; "); - String *ns = listify_namespace(Getattr(n, "allegrocl:package")); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "slot name = '%s' ns = '%s' class-of '%s' and type = '%s'\n", cname, ns, name, childType); -#endif - Printf(slotdefs, "(#.(swig-insert-id \"%s\" %s :type :slot :class \"%s\") %s)", cname, ns, name, compose_foreign_type(n, childType)); - Delete(ns); - if (access && Strcmp(access, "public")) - Printf(slotdefs, " ;; %s member", access); - - Printf(slotdefs, "\n "); - } - Delete(childType); - Delete(cname); - } - } - - String *ns_list = listify_namespace(Getattr(n, "allegrocl:namespace")); - update_package_if_needed(n, f_clhead); - Printf(f_clhead, "(swig-def-foreign-class \"%s\"\n %s\n (:%s\n%s))\n\n", name, supers, kind, slotdefs); - - Delete(supers); - Delete(ns_list); - - Setattr(n, "allegrocl:synonym:already-been-stubbed", "1"); -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_full_class: EXIT\n"); -#endif - -} - -void emit_class(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_class: ENTER... '%s'(%p)\n", Getattr(n, "sym:name"), n); -#endif - - int is_tempInst = !Strcmp(nodeType(n), "templateInst"); - - String *ns_list = listify_namespace(Getattr(n, "allegrocl:namespace")); - String *name = Getattr(n, is_tempInst ? "real-name" : "name"); - - String *tname = SwigType_istemplate_templateprefix(name); - if (tname) { - String *temp = strip_namespaces(tname); - name = NewStringf("%s%s%s", temp, SwigType_templateargs(name), SwigType_templatesuffix(name)); - Delete(temp); - Delete(tname); - } else { - name = strip_namespaces(name); - } - - if (Getattr(n, "allegrocl:synonym:is-primary")) { - // Printf(stderr," is primary... "); - if (is_tempInst) { - emit_stub_class(n); - } else { - emit_full_class(n); - } - } else { - // Node *primary = Getattr(n,"allegrocl:synonym-of"); - Node *primary = get_primary_synonym_of(n); - if (primary && (primary != n)) { - // Printf(stderr," emitting synonym... "); - emit_stub_class(primary); - update_package_if_needed(n, f_clhead); - emit_synonym(n); - } else { - emit_full_class(n); - } - } - // Printf(stderr,"DONE\n"); - Delete(name); - Delete(ns_list); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_class: EXIT\n"); -#endif -} - -void emit_typedef(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_typedef: ENTER... \n"); -#endif - - String *name; - String *sym_name = Getattr(n, "sym:name"); - String *type = NewStringf("%s%s", Getattr(n, "decl"), Getattr(n, "type")); - String *lisp_type = compose_foreign_type(n, type); - Delete(type); - Node *in_class = Getattr(n, "allegrocl:typedef:in-class"); - - // Printf(stderr,"in emit_typedef: '%s'(%p).",Getattr(n,"name"),n); - if (Getattr(n, "allegrocl:synonym-of")) { - // Printf(stderr," but it's a synonym of something.\n"); - emit_synonym(n); - return; - } - - if (in_class) { - String *class_name = Getattr(in_class, "name"); - String *tname = SwigType_istemplate_templateprefix(class_name); - if (tname) { - String *temp = strip_namespaces(tname); - class_name = NewStringf("%s%s%s", temp, SwigType_templateargs(class_name), SwigType_templatesuffix(class_name)); - Delete(temp); - Delete(tname); - } - - name = NewStringf("%s__%s", class_name, sym_name); - Setattr(n, "allegrocl:in-class", in_class); - } else { - name = sym_name ? Copy(sym_name) : Copy(Getattr(n, "name")); - } - - // leave these in for now. might want to change these to def-foreign-class at some point. -// Printf(f_clhead, ";; %s\n", SwigType_typedef_resolve_all(lisp_type)); - Printf(f_clhead, "(swig-def-foreign-type \"%s\"\n %s)\n", name, lisp_type); - - Delete(name); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_typedef: EXIT\n"); -#endif -} - -void emit_enum_type_no_wrap(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_enum_type_no_wrap: ENTER... \n"); -#endif - - String *unnamed = Getattr(n, "unnamed"); - String *name; - // SwigType *enumtype; - - name = unnamed ? Getattr(n, "allegrocl:name") : Getattr(n, "sym:name"); - SwigType *tmp = NewStringf("enum %s", unnamed ? unnamed : name); - - Node *node = NewHash(); - Setattr(node, "type", tmp); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *enumtype = Swig_typemap_lookup("ffitype", node, "", 0); - Delete(node); - - Delete(tmp); - - if (name) { - String *ns = listify_namespace(current_namespace); - - Printf(f_clhead, "(swig-def-foreign-type \"%s\" %s)\n", name, enumtype); - Delete(ns); - - // walk children. - Node *c; - for (c = firstChild(n); c; c = nextSibling(c)) { - if (!Getattr(c, "error")) { - String *val = Getattr(c, "enumvalue"); - if (!val) - val = Getattr(c, "enumvalueex"); - String *converted_val = convert_literal(val, Getattr(c, "type")); - String *valname = Getattr(c, "sym:name"); - - if (converted_val) { - Printf(f_clhead, "(swig-defconstant \"%s\" %s)\n", valname, converted_val); - Delete(converted_val); - } else { - Swig_warning(WARN_LANG_DISCARD_CONST, Getfile(n), Getline(n), "Unable to parse enum value '%s'. Setting to NIL\n", val); - Printf(f_clhead, "(swig-defconstant \"%s\" nil #| %s |#)\n", valname, val); - } - } - } - } - Printf(f_clhead, "\n"); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_enum_type_no_wrap: EXIT\n"); -#endif - -} - -void emit_enum_type(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_enum_type: ENTER... \n"); -#endif - - if (!Generate_Wrapper) { - emit_enum_type_no_wrap(n); - return; - } - - String *unnamed = Getattr(n, "unnamed"); - String *name; - // SwigType *enumtype; - - name = unnamed ? Getattr(n, "allegrocl:name") : Getattr(n, "sym:name"); - SwigType *tmp = NewStringf("enum %s", unnamed ? unnamed : name); - - Node *node = NewHash(); - Setattr(node, "type", tmp); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *enumtype = Swig_typemap_lookup("ffitype", node, "", 0); - Delete(node); - - Delete(tmp); - - if (name) { - String *ns = listify_namespace(current_namespace); - - Printf(f_clhead, "(swig-def-foreign-type \"%s\" %s)\n", name, enumtype); - Delete(ns); - - // walk children. - Node *c; - for(c = firstChild(n); c; c=nextSibling(c)) { - String *mangled_name = mangle_name(c, "ACL_ENUM", Getattr(c,"allegrocl:package")); - Printf(f_clhead, "(swig-defvar \"%s\" \"%s\" :type :constant :ftype :signed-long)\n", Getattr(c, "sym:name"), mangled_name); - Delete(mangled_name); - } - } -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_enum_type: EXIT\n"); -#endif - -} - -void emit_default_linked_type(Node *n) { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_default_linked_type: ENTER... \n"); -#endif - - // catchall for non class types. - if (!Strcmp(nodeType(n), "classforward")) { - Printf(f_clhead, ";; forward referenced stub.\n"); - Printf(f_clhead, "(swig-def-foreign-class \"%s\" (ff:foreign-pointer) (:class ))\n\n", Getattr(n, "sym:name")); - } else if (!Strcmp(nodeType(n), "enum")) { - emit_enum_type(n); - } else { - Printf(stderr, "Don't know how to emit node type '%s' named '%s'\n", nodeType(n), Getattr(n, "name")); - } - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_default_linked_type: EXIT\n"); -#endif - -} - -void dump_linked_types(File *f) { - Node *n = first_linked_type; - int i = 0; - while (n) { - Printf(f, "%d: (%p) node '%s' name '%s'\n", i++, n, nodeType(n), Getattr(n, "sym:name")); - - Node *t = Getattr(n, "allegrocl:synonym-of"); - if (t) - Printf(f, " synonym-of %s(%p)\n", Getattr(t, "name"), t); - n = Getattr(n, "allegrocl:next_linked_type"); - } -} - -void emit_linked_types() { - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_linked_types: ENTER... "); -#endif - - Node *n = first_linked_type; - - while (n) { - String *node_type = nodeType(n); - - // Printf(stderr,"emitting node %s(%p) of type %s.", Getattr(n,"name"),n, nodeType(n)); - if (!Strcmp(node_type, "class") || !Strcmp(node_type, "templateInst")) { - // may need to emit a stub, so it will update the package itself. - // Printf(stderr," Passing to emit_class."); - emit_class(n); - } else if (!Strcmp(nodeType(n), "cdecl")) { - // Printf(stderr," Passing to emit_typedef."); - update_package_if_needed(n, f_clhead); - emit_typedef(n); - } else { - // Printf(stderr," Passing to default_emitter."); - update_package_if_needed(n, f_clhead); - emit_default_linked_type(n); - } - - n = Getattr(n, "allegrocl:next_linked_type"); - // Printf(stderr,"returned.\n"); - } - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_linked_types: EXIT\n"); -#endif -} - -extern "C" Language *swig_allegrocl(void) { - return (allegrocl = new ALLEGROCL()); -} - -void ALLEGROCL::main(int argc, char *argv[]) { - int i; - - Preprocessor_define("SWIGALLEGROCL 1", 0); - SWIG_library_directory("allegrocl"); - SWIG_config_file("allegrocl.swg"); - - for (i = 1; i < argc; i++) { - if (!strcmp(argv[i], "-identifier-converter")) { - char *conv = argv[i + 1]; - - if (!conv) - Swig_arg_error(); - - Swig_mark_arg(i); - Swig_mark_arg(i + 1); - i++; - - /* check for built-ins */ - if (!strcmp(conv, "lispify")) { - Delete(identifier_converter); - identifier_converter = NewString("identifier-convert-lispify"); - } else if (!strcmp(conv, "null")) { - Delete(identifier_converter); - identifier_converter = NewString("identifier-convert-null"); - } else { - /* Must be user defined */ - Delete(identifier_converter); - identifier_converter = NewString(conv); - } - } else if (!strcmp(argv[i], "-cwrap")) { - CWrap = true; - Swig_mark_arg(i); - } else if (!strcmp(argv[i], "-nocwrap")) { - CWrap = false; - Swig_mark_arg(i); - } else if (!strcmp(argv[i], "-isolate")) { - unique_swig_package = true; - Swig_mark_arg(i); - } - - if (!strcmp(argv[i], "-help")) { - Printf(stdout, "%s\n", usage); - } - - } - - allow_overloading(); -} - -int ALLEGROCL::top(Node *n) { - module_name = Getattr(n, "name"); - String *cxx_filename = Getattr(n, "outfile"); - String *cl_filename = NewString(""); - - swig_package = unique_swig_package ? NewStringf("swig.%s", module_name) : NewString("swig"); - - Printf(cl_filename, "%s%s.cl", SWIG_output_directory(), module_name); - - f_cl = NewFile(cl_filename, "w", SWIG_output_files()); - if (!f_cl) { - Printf(stderr, "Unable to open %s for writing\n", cl_filename); - SWIG_exit(EXIT_FAILURE); - } - - Generate_Wrapper = CPlusPlus || CWrap; - - if (Generate_Wrapper) { - f_begin = NewFile(cxx_filename, "w", SWIG_output_files()); - if (!f_begin) { - Delete(f_cl); - Printf(stderr, "Unable to open %s for writing\n", cxx_filename); - SWIG_exit(EXIT_FAILURE); - } - } else - f_begin = NewString(""); - - f_runtime = NewString(""); - f_cxx_header = f_runtime; - f_cxx_wrapper = NewString(""); - - Swig_register_filebyname("header", f_cxx_header); - Swig_register_filebyname("wrapper", f_cxx_wrapper); - Swig_register_filebyname("begin", f_begin); - Swig_register_filebyname("runtime", f_runtime); - Swig_register_filebyname("lisp", f_clwrap); - Swig_register_filebyname("lisphead", f_cl); - - Swig_banner(f_begin); - - Printf(f_runtime, "\n\n#ifndef SWIGALLEGROCL\n#define SWIGALLEGROCL\n#endif\n\n"); - - Swig_banner_target_lang(f_cl, ";;"); - - Printf(f_cl, "\n" - "(defpackage :%s\n" - " (:use :common-lisp :ff :excl)\n" - " (:export #:*swig-identifier-converter* #:*swig-module-name*\n" - " #:*void* #:*swig-export-list*))\n" - "(in-package :%s)\n\n" - "(eval-when (:compile-toplevel :load-toplevel :execute)\n" - " (defparameter *swig-identifier-converter* '%s)\n" - " (defparameter *swig-module-name* :%s))\n\n", swig_package, swig_package, identifier_converter, module_name); - Printf(f_cl, "(defpackage :%s\n" " (:use :common-lisp :%s :ff :excl))\n\n", module_name, swig_package); - - Printf(f_clhead, "(in-package :%s)\n", module_name); - - Language::top(n); - -#ifdef ALLEGROCL_TYPE_DEBUG - dump_linked_types(stderr); -#endif - emit_linked_types(); - - Printf(f_clwrap, "\n(cl::in-package :%s)\n", swig_package); - Printf(f_clwrap, "\n(macrolet ((swig-do-export ()\n"); - Printf(f_clwrap, " `(dolist (s ',*swig-export-list*)\n"); - Printf(f_clwrap, " (apply #'export s))))\n"); - Printf(f_clwrap, " (swig-do-export))\n"); - Printf(f_clwrap, "\n(setq *swig-export-list* nil)\n"); - - Printf(f_cl, "%s\n", f_clhead); - Printf(f_cl, "%s\n", f_clwrap); - - Delete(f_cl); - Delete(f_clhead); - Delete(f_clwrap); - - Dump(f_runtime, f_begin); - Printf(f_begin, "%s\n", f_cxx_wrapper); - - Delete(f_runtime); - Delete(f_begin); - Delete(f_cxx_wrapper); - - // Swig_print_tree(n); - - return SWIG_OK; -} - -int any_varargs(ParmList *pl) { - Parm *p; - - for (p = pl; p; p = nextSibling(p)) { - if (SwigType_isvarargs(Getattr(p, "type"))) - return 1; - } - - return 0; -} - -String *get_lisp_type(Node *n, SwigType *ty, const_String_or_char_ptr name) { - Node *node = NewHash(); - Setattr(node, "type", ty); - Setattr(node, "name", name); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup("lisptype", node, "", 0); - Delete(node); - - return tm ? NewString(tm) : NewString(""); -} - -Node *parent_node_skipping_extends(Node *n) { - Node *result = n; - do { - result = parentNode(result); - } - while (Cmp("extend", nodeType(result)) == 0); - return result; -} - -/* ----------------------------------------------------------------------------- - * emit_num_lin_arguments() - * - * Calculate the total number of arguments. This function is safe for use - * with multi-argument typemaps which may change the number of arguments in - * strange ways. - * ----------------------------------------------------------------------------- */ - -int emit_num_lin_arguments(ParmList *parms) { - Parm *p = parms; - int nargs = 0; - - while (p) { - // Printf(stderr,"enla: '%s' lin='%p' numinputs='%s'\n", Getattr(p,"name"), Getattr(p,"tmap:lin"), Getattr(p,"tmap:lin:numinputs")); - if (Getattr(p, "tmap:lin")) { - nargs += GetInt(p, "tmap:lin:numinputs"); - p = Getattr(p, "tmap:lin:next"); - } else { - p = nextSibling(p); - } - } - - /* DB 04/02/2003: Not sure this is necessary with tmap:in:numinputs */ - /* - if (parms && (p = Getattr(parms,"emit:varargs"))) { - if (!nextSibling(p)) { - nargs--; - } - } - */ - return nargs; -} - -String *id_converter_type(SwigType const *type) { - SwigType *t = Copy(type); - String *result = 0; - - if (SwigType_ispointer(t)) { - SwigType_pop(t); - String *pointee = id_converter_type(t); - result = NewStringf("(:* %s)", pointee); - Delete(pointee); - } else if (SwigType_ismemberpointer(t)) { - String *klass = SwigType_parm(t); - SwigType_pop(t); - String *member = id_converter_type(t); - result = NewStringf("(:member \"%s\" %s)", klass, member); - Delete(klass); - Delete(member); - } else if (SwigType_isreference(t)) { - SwigType_pop(t); - String *referencee = id_converter_type(t); - result = NewStringf("(:& %s)", referencee); - Delete(referencee); - } else if (SwigType_isarray(t)) { - String *size = SwigType_parm(t); - SwigType_pop(t); - String *element_type = id_converter_type(t); - result = NewStringf("(:array %s \"%s\")", element_type, size); - Delete(size); - Delete(element_type); - } else if (SwigType_isfunction(t)) { - result = NewString("(:function ("); - String *parmlist_str = SwigType_parm(t); - List *parms = SwigType_parmlist(parmlist_str); - - for (Iterator i = First(parms); i.item;) { - String *parm = id_converter_type((SwigType *) i.item); - Printf(result, "%s", parm); - i = Next(i); - if (i.item) - Printf(result, " "); - Delete(parm); - } - SwigType_pop(t); - String *ret = id_converter_type(t); - Printf(result, ") %s)", ret); - - Delete(parmlist_str); - Delete(parms); - Delete(ret); - } else if (SwigType_isqualifier(t)) { - result = NewString("(:qualified ("); - String *qualifiers_str = Copy(SwigType_parm(t)); // ?! - // Replaceall below SEGVs if we don't put the Copy here... - SwigType_pop(t); - String *qualifiee = id_converter_type(t); - - Replaceall(qualifiers_str, " ", " :"); - if (Len(qualifiers_str) > 0) - Printf(result, ":"); - Printf(result, "%s) %s)", qualifiers_str, qualifiee); - - Delete(qualifiers_str); - Delete(qualifiee); - } else if (SwigType_istemplate(t)) { - result = NewStringf("(:template \"%s\")", t); - } else { /* if (SwigType_issimple(t)) */ - - if (Strstr(Char(t), "::")) { - result = listify_namespace(t); - } else { - result = NewStringf("\"%s\"", t); - } - } - - Delete(t); - return result; -} - -static ParmList *parmlist_with_names(ParmList *pl) { - ParmList *pl2 = CopyParmList(pl); - for (Parm *p = pl, *p2 = pl2; p2; p = nextSibling(p), p2 = nextSibling(p2)) { - if (!Getattr(p2, "name")) - Setattr(p2, "name", Getattr(p2, "lname")); - Setattr(p2, "name", strip_namespaces(Getattr(p2, "name"))); - Setattr(p2, "tmap:ctype", Getattr(p, "tmap:ctype")); - - String *temp = Getattr(p, "tmap:lin"); - if (temp) { - Setattr(p2, "tmap:lin", temp); - Setattr(p2, "tmap:lin:next", Getattr(p, "tmap:lin:next")); - } - } - return pl2; -} - -static String *parmlist_str_id_converter(ParmList *pl) { - String *result = NewString(""); - for (Parm *p = pl; p;) { - String *lispy_type = id_converter_type(Getattr(p, "type")); - Printf(result, "(\"%s\" %s)", Getattr(p, "name"), lispy_type); - Delete(lispy_type); - if ((p = nextSibling(p))) - Printf(result, " "); - } - return result; -} - -String *collect_others_args(Node *overload) { - String *overloaded_from = Getattr(overload, "sym:overloaded"); - String *others_args = NewString(""); - int first_overload = 1; - - for (Node *overload2 = overloaded_from; overload2; overload2 = Getattr(overload2, "sym:nextSibling")) { - if (overload2 == overload || GetInt(overload2, "overload:ignore")) - continue; - - ParmList *opl = parmlist_with_names(Getattr(overload2, "wrap:parms")); - String *args = parmlist_str_id_converter(opl); - if (!first_overload) - Printf(others_args, "\n "); - Printf(others_args, "(%s)", args); - Delete(args); - Delete(opl); - first_overload = 0; - } - return others_args; -} - -struct IDargs { - String *name; - String *type; - String *klass; - String *arity; - - IDargs():name(0), type(0), klass(0), arity(0) { - } - - String *full_quoted_str() { - String *result = no_others_quoted_str(); - if (arity) - Printf(result, " :arity %s", arity); - return result; - } - - String *no_others_quoted_str() { - String *result = NewString(""); - Printf(result, "\"%s\" :type :%s", name, type); - if (klass) - Printf(result, " :class \"%s\"", klass); - return result; - } - - String *noname_str(bool include_class = true) { - String *result = NewString(""); - Printf(result, " :type :%s", type); - if (klass && include_class) - Printf(result, " :class \"%s\"", klass); - if (arity) - Printf(result, " :arity %s", arity); - return result; - } - - String *noname_no_others_str(bool include_class = true) { - String *result = NewString(""); - Printf(result, " :type :%s", type); - if (klass && include_class) - Printf(result, " :class \"%s\"", klass); - return result; - } -}; -IDargs *id_converter_arguments(Node *n) { - IDargs *result = (IDargs *) GetVoid(n, "allegrocl:id-converter-args"); - if (!result) - result = new IDargs; - - // Base name - if (!result->name) { - result->name = Getattr(n, "allegrocl:old-sym:name"); - if (!result->name) - result->name = Getattr(n, "sym:name"); - result->name = Copy(result->name); - } - // :type - if (result->type) - Delete(result->type); - if (!Getattr(n, "allegrocl:kind")) - Setattr(n, "allegrocl:kind", "function"); - if (Strstr(Getattr(n, "name"), "operator ")) - Replaceall(Getattr(n, "allegrocl:kind"), "function", "operator"); - if (Strstr(Getattr(n, "allegrocl:kind"), "variable")) { - int name_end = Len(Getattr(n, "sym:name")) - 4; - char *str = Char(Getattr(n, "sym:name")); - String *get_set = NewString(str + name_end + 1); - result->type = Copy(Getattr(n, "allegrocl:kind")); - Replaceall(result->type, "variable", ""); - Printf(result->type, "%ster", get_set); - Delete(get_set); - } else { - result->type = Copy(Getattr(n, "allegrocl:kind")); - } - - // :class - if (Strstr(result->type, "member ")) { - Replaceall(result->type, "member ", ""); - if (!result->klass) { - result->klass = Copy(Getattr(parent_node_skipping_extends(n), "sym:name")); - } - } - // :arity - if (Getattr(n, "sym:overloaded")) { - if (result->arity) - Delete(result->arity); - result->arity = NewStringf("%d", - // emit_num_arguments(Getattr(n, "wrap:parms"))); - emit_num_lin_arguments(Getattr(n, "wrap:parms"))); - // Printf(stderr, "got arity of '%s' node '%s' '%p'\n", result->arity, Getattr(n,"name"), Getattr(n,"wrap:parms")); - } - - SetVoid(n, "allegrocl:id-converter-args", result); - return result; -} - -int ALLEGROCL::emit_buffered_defuns(Node *n) { - - Node *overloaded_from = Getattr(n, "sym:overloaded"); - - String *wrap; - - if (!overloaded_from) { - wrap = Getattr(n, "allegrocl:lisp-wrap"); - - Printf(f_clwrap, "%s\n", wrap); - Delattr(n, "allegrocl:lisp-wrap"); - Delete(wrap); - } else { - for (Node *overload = overloaded_from; overload; overload = Getattr(overload, "sym:nextSibling")) { - String *others_args = collect_others_args(overload); - wrap = Getattr(overload, "allegrocl:lisp-wrap"); - - Replaceall(wrap, "@@OTHERS-ARGS-GO-HERE@@", others_args); -// IDargs* id_args = id_converter_arguments(overload); -// Replaceall(id_args->others_args, "@@OTHERS-ARGS-GO-HERE@@", others_args); - - if (!GetInt(overload, "overload:ignore")) - Printf(f_clwrap, "%s", wrap); - - Delattr(overload, "allegrocl:lisp-wrap"); - Delete(wrap); - } - } - return SWIG_OK; -} - -String *dispatching_type(Node *n, Parm *p) { - String *result = 0; - - String *parsed = Getattr(p, "type"); //Swig_cparse_type(Getattr(p,"tmap:ctype")); - String *cl_t = SwigType_typedef_resolve_all(parsed); - - Node *node = NewHash(); - Setattr(node, "type", parsed); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup("lispclass", node, Getattr(p, "name"), 0); - Delete(node); - - if (tm) { - result = Copy(tm); - } else { - String *lookup_type = class_from_class_or_class_ref(parsed); - if (lookup_type) - result = lookup_defined_foreign_ltype(lookup_type); - } - - // if (!result && SwigType_ispointer(cl_t)) { - // SwigType_pop(cl_t); - // result = lookup_defined_foreign_ltype(cl_t); - // } - - if (!result) - result = NewStringf("ff:foreign-pointer"); - - // Delete(parsed); - Delete(cl_t); - return result; -} - -int ALLEGROCL::emit_dispatch_defun(Node *n) { -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_dispatch_defun: ENTER... "); -#endif - List *overloads = Swig_overload_rank(n, true); - - // Printf(stderr,"\ndispatch node=%p\n\n", n); - // Swig_print_node(n); - - Node *overloaded_from = Getattr(n,"sym:overloaded"); - bool include_class = Getattr(overloaded_from, "allegrocl:dispatcher:include-class") ? true : false; - String *id_args = id_converter_arguments(n)->noname_no_others_str(include_class); - Printf(f_clwrap, "(swig-dispatcher (\"%s\" %s :arities (", Getattr(overloaded_from, "allegrocl:dispatcher:name"), id_args); - - Delattr(overloaded_from, "allegrocl:dispatcher:include-class"); - Delattr(overloaded_from, "allegrocl:dispatcher:name"); - - int last_arity = -1; - for (Iterator i = First(overloads); i.item; i = Next(i)) { - int arity = emit_num_lin_arguments(Getattr(i.item, "wrap:parms")); - if (arity == last_arity) - continue; - - Printf(f_clwrap, "%s%d", last_arity == -1 ? "" : " ", arity); - - last_arity = arity; - } - Printf(f_clwrap, ")))\n"); - - Delete(id_args); - Delete(overloads); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_dispatch_defun: EXIT\n"); -#endif - - return SWIG_OK; -} - -int ALLEGROCL::emit_defun(Node *n, File *fcl) { -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_defun: ENTER... "); -#endif - - // avoid name conflicts between smart pointer wrappers and the wrappers for the - // actual class. - bool smartmemberwrapper = (!Cmp(Getattr(n, "view"), "memberfunctionHandler") && - Getattr(n,"allocate:smartpointeraccess")); - -#ifdef ALLEGROCL_DEBUG - int auto_generated = Cmp(Getattr(n, "view"), "globalfunctionHandler"); - Printf(stderr, "%s%sfunction %s%s%s\n", auto_generated ? "> " : "", Getattr(n, "sym:overloaded") - ? "overloaded " : "", current_namespace, (current_namespace) > 0 ? "::" : "", Getattr(n, "sym:name")); - Printf(stderr, " (view: %s)\n", Getattr(n, "view")); - Swig_print_node(n); -#endif - - - String *funcname = Getattr(n, "allegrocl:old-sym:name"); - if (smartmemberwrapper || !funcname) - funcname = Getattr(n, "sym:name"); - - String *mangled_name = Getattr(n, "wrap:name"); - ParmList *pl = parmlist_with_names(Getattr(n, "wrap:parms")); - - // attach typemap info. - Wrapper *wrap = NewWrapper(); - Swig_typemap_attach_parms("lin", pl, wrap); - // Swig_typemap_attach_parms("ffitype", pl, wrap); - Swig_typemap_lookup("lout", n, Swig_cresult_name(), 0); - - SwigType *result_type = Swig_cparse_type(Getattr(n, "tmap:ctype")); - // prime the pump, with support for OUTPUT, INOUT typemaps. - Printf(wrap->code, - "(cl::let ((ACL_ffresult %s:*void*)\n ACL_result)\n $body\n (cl::if (cl::eq ACL_ffresult %s:*void*)\n (cl::values-list ACL_result)\n (cl::values-list (cl::cons ACL_ffresult ACL_result))))", - swig_package, swig_package); - - Parm *p; - int largnum = 0, argnum = 0, first = 1; - // int varargs=0; - if (Generate_Wrapper) { - String *extra_parms = id_converter_arguments(n)->noname_str(smartmemberwrapper ? false : true); - Node *overloaded_from = Getattr(n,"sym:overloaded"); - if (overloaded_from) { - if(!GetFlag(overloaded_from,"allegrocl:dispatcher:name")) { - Setattr(overloaded_from,"allegrocl:dispatcher:name",funcname); - Setattr(overloaded_from,"allegrocl:dispatcher:include-class", smartmemberwrapper ? 0 : "1"); - // Printf(stderr, " set a:d:name='%s', a:d:i-c='%s'\n", Getattr(n,"allegrocl:dispatcher:name"), Getattr(n,"allegrocl:dispatcher:include-class")); - } - Printf(fcl, "(swig-defmethod (\"%s\" \"%s\"%s)\n", funcname, mangled_name, extra_parms); - } else - Printf(fcl, "(swig-defun (\"%s\" \"%s\"%s)\n", funcname, mangled_name, extra_parms); - Delete(extra_parms); - } - // Just C - else { - Printf(fcl, "(swig-defun (\"%s\" \"%s\")\n", funcname, Generate_Wrapper ? mangled_name : funcname); - } - - ////////////////////////////////////// - // Lisp foreign call parameter list // - ////////////////////////////////////// - Printf(fcl, " ("); - - /* Special cases */ - - if (ParmList_len(pl) == 0) { - Printf(fcl, ":void"); -/* } else if (any_varargs(pl)) { - Printf(fcl, "#| varargs |#"); - varargs=1; */ - } else { - String *largs = NewString(""); - - for (p = pl; p; p = nextSibling(p), argnum++, largnum++) { - // SwigType *argtype=Getattr(p, "type"); - SwigType *argtype = Swig_cparse_type(Getattr(p, "tmap:ctype")); - SwigType *parmtype = Getattr(p,"type"); - - if (!first) { - Printf(fcl, "\n "); - } - - /* by default, skip varargs */ - if (!SwigType_isvarargs(parmtype)) { - String *argname = NewStringf("PARM%d_%s", largnum, Getattr(p, "name")); - - // Printf(stderr,"%s\n", Getattr(p,"tmap:lin")); - String *ffitype = compose_foreign_type(n, argtype, Getattr(p,"name")); - String *deref_ffitype = dereference_ffitype(ffitype); - String *lisptype = get_lisp_type(n, parmtype, Getattr(p, "name")); - -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "lisptype of '%s' '%s' = '%s'\n", parmtype, - Getattr(p, "name"), lisptype); -#endif - - // while we're walking the parameters, generating LIN - // wrapper code... - Setattr(p, "lname", NewStringf("SWIG_arg%d", largnum)); - - String *parm_code = Getattr(p, "tmap:lin"); - if (parm_code) { - String *lname = Getattr(p, "lname"); - - Printf(largs, " %s", lname); - Replaceall(parm_code, "$in_fftype", ffitype); // must come before $in - Replaceall(parm_code, "$in", argname); - Replaceall(parm_code, "$out", lname); - Replaceall(parm_code, "$*in_fftype", deref_ffitype); - Replaceall(wrap->code, "$body", parm_code); - } - - String *dispatchtype = Getattr(n, "sym:overloaded") ? dispatching_type(n, p) : NewString(""); - - // if this parameter has been removed from the C/++ wrapper - // it shouldn't be in the lisp wrapper either. - if (!checkAttribute(p, "tmap:in:numinputs", "0")) { - Printf(fcl, "(%s %s %s %s %s)", - // parms in the ff wrapper, but not in the lisp wrapper. - (checkAttribute(p, "tmap:lin:numinputs", "0") ? ":p-" : ":p+"), argname, dispatchtype, ffitype, lisptype); - - first = 0; - } - - Delete(argname); - Delete(ffitype); - Delete(deref_ffitype); - Delete(lisptype); - } - } - - Printf(wrap->locals, "%s", largs); - } - - String *lout = Getattr(n, "tmap:lout"); - Replaceall(lout, "$owner", GetFlag(n, "feature:new") ? "t" : "nil"); - - Replaceall(wrap->code, "$body", lout); - // $lclass handling. - String *lclass = (String *) 0; - SwigType *parsed = Swig_cparse_type(Getattr(n, "tmap:ctype")); - // SwigType *cl_t = SwigType_typedef_resolve_all(parsed); - SwigType *cl_t = class_from_class_or_class_ref(parsed); - String *out_ffitype = compose_foreign_type(n, parsed); - String *deref_out_ffitype; - String *out_temp = Copy(parsed); - - if (SwigType_ispointer(out_temp)) { - SwigType_pop(out_temp); - deref_out_ffitype = compose_foreign_type(n, out_temp); - } else { - deref_out_ffitype = Copy(out_ffitype); - } - - Delete(out_temp); - - Delete(parsed); - - if (cl_t) { - lclass = lookup_defined_foreign_ltype(cl_t); - } - - int ff_foreign_ptr = 0; - if (!lclass) { - ff_foreign_ptr = 1; - lclass = NewStringf("ff:foreign-pointer"); - } -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "for output wrapping %s: type=%s, ctype=%s\n", Getattr(n, "name"), - Getattr(n, "type"), Swig_cparse_type(Getattr(n, "tmap:ctype"))); -#endif - - if (lclass) - Replaceall(wrap->code, "$lclass", lclass); - if (out_ffitype) - Replaceall(wrap->code, "$out_fftype", out_ffitype); - if (deref_out_ffitype) - Replaceall(wrap->code, "$*out_fftype", deref_out_ffitype); - - Replaceall(wrap->code, "$body", NewStringf("(swig-ff-call%s)", wrap->locals)); - String *ldestructor = Copy(lclass); - if (ff_foreign_ptr) - Replaceall(ldestructor, ldestructor, "cl::identity"); - else - Replaceall(ldestructor, ":type :class", ":type :destructor"); - Replaceall(wrap->code, "$ldestructor", ldestructor); - Delete(ldestructor); - - Printf(fcl, ")\n"); /* finish arg list */ - - ///////////////////////////////////////////////////// - // Lisp foreign call return type and optimizations // - ///////////////////////////////////////////////////// - Printf(fcl, " (:returning (%s %s)", compose_foreign_type(n, result_type), get_lisp_type(n, Getattr(n, "type"), Swig_cresult_name())); - - for (Iterator option = First(n); option.item; option = Next(option)) { - if (Strncmp("feature:ffargs:", option.key, 15)) - continue; - String *option_val = option.item; - String *option_name = NewString(Char(option.key) + 14); - Replaceall(option_name, "_", "-"); - - // TODO: varargs vs call-direct ? - Printf(fcl, "\n %s %s", option_name, option_val); - - Delete(option_name); - } - - Printf(fcl, ")\n %s)\n\n", wrap->code); - // Wrapper_print(wrap, stderr); - - Delete(result_type); - Delete(mangled_name); - Delete(pl); - DelWrapper(wrap); - -#ifdef ALLEGROCL_WRAP_DEBUG - Printf(stderr, "emit_defun: EXIT\n"); -#endif - - return SWIG_OK; -} - -int ALLEGROCL::functionWrapper(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "functionWrapper %s\n", Getattr(n,"name")); -#endif - - - ParmList *parms = CopyParmList(Getattr(n, "parms")); - Wrapper *f = NewWrapper(); - SwigType *t = Getattr(n, "type"); - String *name = Getattr(n, "name"); - - String *raw_return_type = Swig_typemap_lookup("ctype", n, "", 0); - SwigType *return_type = Swig_cparse_type(raw_return_type); - SwigType *resolved = SwigType_typedef_resolve_all(return_type); - int is_void_return = (Cmp(resolved, "void") == 0); - - Delete(resolved); - - if (!is_void_return) { - String *lresult_init = - NewStringf("= (%s)0", - SwigType_str(SwigType_strip_qualifiers(return_type),0)); - Wrapper_add_localv(f, "lresult", - SwigType_lstr(SwigType_ltype(return_type), "lresult"), - lresult_init, NIL); - Delete(lresult_init); - } - // Emit all of the local variables for holding arguments. - emit_parameter_variables(parms, f); - - // Attach the standard typemaps - Swig_typemap_attach_parms("ctype", parms, f); - Swig_typemap_attach_parms("lin", parms, f); - emit_attach_parmmaps(parms, f); - - String *mangled = mangle_name(n); - Node *overloaded = Getattr(n, "sym:overloaded"); - - // Parameter overloading - Setattr(n, "wrap:parms", parms); - Setattr(n, "wrap:name", mangled); - - if (overloaded) { - // emit warnings when overloading is impossible on the lisp side. - // basically Swig_overload_check(n), but with script_lang_wrapping - // set to true. - Delete(Swig_overload_rank(n, true)); - if (Getattr(n, "overload:ignore")) { - // if we're the last overload, make sure to force the emit - // of the rest of the overloads before we leave. - // Printf(stderr, "ignored overload %s(%p)\n", name, Getattr(n, "sym:nextSibling")); - if (!Getattr(n, "sym:nextSibling")) { - update_package_if_needed(n); - emit_buffered_defuns(n); - emit_dispatch_defun(n); - } - DelWrapper(f); - return SWIG_OK; - } - } - // Get number of required and total arguments - int num_arguments = emit_num_arguments(parms); - int gencomma = 0; - -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "Walking parameters for %s '%s'\n", Getattr(n, "allegrocl:kind"), name); -#endif - // Now walk the function parameter list and generate code to get arguments - String *name_and_parms = NewStringf("%s (", mangled); - int i; - Parm *p; - for (i = 0, p = parms; i < num_arguments; i++) { - -#ifdef ALLEGROCL_DEBUG - String *temp1 = Getattr(p,"tmap:in"); - String *temp2 = Getattr(p,"tmap:in:numinputs"); - Printf(stderr," parm %d: %s, tmap:in='%s', tmap:in:numinputs='%s'\n", i, Getattr(p,"name"), temp1 ? temp1 : "", temp2 ? temp2 : ""); -#endif - - while (p && checkAttribute(p, "tmap:in:numinputs", "0")) { - p = Getattr(p, "tmap:in:next"); - } - - if (!p) - break; - - SwigType *c_parm_type = Swig_cparse_type(Getattr(p, "tmap:ctype")); - String *arg = NewStringf("l%s", Getattr(p, "lname")); - - // Emit parameter declaration - if (gencomma) - Printf(name_and_parms, ", "); - String *parm_decl = SwigType_str(c_parm_type, arg); - Printf(name_and_parms, "%s", parm_decl); -#ifdef ALLEGROCL_DEBUG - Printf(stderr, " param: %s\n", parm_decl); -#endif - Delete(parm_decl); - gencomma = 1; - - // Emit parameter conversion code - String *parm_code = Getattr(p, "tmap:in"); - //if (!parm_code) { - // Swig_warning(...); - // p = nextSibling(p); - /*} else */ { - // canThrow(n, "in", p); - Replaceall(parm_code, "$input", arg); - Setattr(p, "emit:input", arg); - Printf(f->code, "%s\n", parm_code); - p = Getattr(p, "tmap:in:next"); - } - - Delete(arg); - } - Printf(name_and_parms, ")"); - -#ifdef ALLEGROCL_DEBUG - Printf(stderr, " arity = %d(%d)\n", emit_num_lin_arguments(parms), emit_num_lin_arguments(Getattr(n,"wrap:parms"))); -#endif - - // Emit the function definition - String *signature = SwigType_str(return_type, name_and_parms); - Printf(f->def, "EXPORT %s {", signature); - if (CPlusPlus) - Printf(f->code, " try {\n"); - - String *actioncode = emit_action(n); - - String *tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode); - if (!is_void_return) { - if (tm) { - Replaceall(tm, "$result", "lresult"); - Printf(f->code, "%s\n", tm); - Printf(f->code, " return lresult;\n"); - Delete(tm); - } else { - Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, - "Unable to use return type %s in function %s.\n", - SwigType_str(t, 0), name); - } - } - - /* See if there is any return cleanup code */ - if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Printf(f->code, "%s\n", tm); - Delete(tm); - } - - emit_return_variable(n, t, f); - - if (CPlusPlus) { - Printf(f->code, " } catch (...) {\n"); - if (!is_void_return) - Printf(f->code, " return (%s)0;\n", - SwigType_str(SwigType_strip_qualifiers(return_type),0)); - Printf(f->code, " }\n"); - } - Printf(f->code, "}\n"); - - /* print this when in C mode? make this a command-line arg? */ - if (Generate_Wrapper) - Wrapper_print(f, f_cxx_wrapper); - - String *f_buffer = NewString(""); - - emit_defun(n, f_buffer); - Setattr(n, "allegrocl:lisp-wrap", f_buffer); - - if (!overloaded || !Getattr(n, "sym:nextSibling")) { - update_package_if_needed(n); - emit_buffered_defuns(n); - // this is the last overload. - if (overloaded) { - emit_dispatch_defun(n); - } - } - - DelWrapper(f); - - return SWIG_OK; -} - -int ALLEGROCL::namespaceDeclaration(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "namespaceDecl: '%s'(%p) (fc=%p)\n", Getattr(n, "sym:name"), n, firstChild(n)); -#endif - - /* don't wrap a namespace with no contents. package bloat. - also, test-suite/namespace_class.i claims an unnamed namespace - is 'private' and should not be wrapped. Complying... - */ - if (Getattr(n,"unnamed") || !firstChild(n)) - return SWIG_OK; - - String *name = Getattr(n, "sym:name"); - - String *old_namespace = current_namespace; - if (Cmp(current_namespace, "") == 0) - current_namespace = NewStringf("%s", name); - else - current_namespace = NewStringf("%s::%s", current_namespace, name); - - if (!GetInt(defined_namespace_packages, current_namespace)) { - SetInt(defined_namespace_packages, current_namespace, 1); - String *lispy_namespace = listify_namespace(current_namespace); - Printf(f_clhead, "(swig-defpackage %s)\n", lispy_namespace); - Delete(lispy_namespace); - } - - emit_children(n); - - Delete(current_namespace); - current_namespace = old_namespace; - return SWIG_OK; -} - -int ALLEGROCL::constructorHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "constructorHandler %s\n", Getattr(n, "name")); -#endif - // Swig_print_node(n); - Setattr(n, "allegrocl:kind", "constructor"); - Setattr(n, "allegrocl:old-sym:name", Getattr(n, "sym:name")); - - // Let SWIG generate a global forwarding function. - return Language::constructorHandler(n); -} - -int ALLEGROCL::destructorHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "destructorHandler %s\n", Getattr(n, "name")); -#endif - - Setattr(n, "allegrocl:kind", "destructor"); - Setattr(n, "allegrocl:old-sym:name", Getattr(n, "sym:name")); - - // Let SWIG generate a global forwarding function. - return Language::destructorHandler(n); -} - -int ALLEGROCL::constantWrapper(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "constantWrapper %s\n", Getattr(n, "name")); -#endif - - if (Generate_Wrapper) { - // Setattr(n,"wrap:name",mangle_name(n, "ACLPP")); - String *const_type = Getattr(n, "type"); - - String *const_val = 0; - String *raw_const = Getattr(n, "value"); - - if (SwigType_type(const_type) == T_STRING) { - const_val = NewStringf("\"%s\"", raw_const); - } else if (SwigType_type(const_type) == T_CHAR) { - const_val = NewStringf("'%s'", raw_const); - } else { - const_val = Copy(raw_const); - } - - SwigType_add_qualifier(const_type, "const"); - - String *ppcname = NewStringf("ACLppc_%s", Getattr(n, "sym:name")); - // Printf(f_runtime, "static const %s = %s;\n", SwigType_lstr(const_type, ppcname), const_val); - Printf(f_runtime, "static %s = %s;\n", SwigType_lstr(const_type, ppcname), const_val); - - Setattr(n, "name", ppcname); - SetFlag(n, "feature:immutable"); - - Delete(const_val); - return variableWrapper(n); - } - - String *type = Getattr(n, "type"); - String *value = Getattr(n, "value"); - String *converted_value = convert_literal(value, type); - String *name = Getattr(n, "sym:name"); - - Setattr(n, "allegrocl:kind", "constant"); - Setattr(n, "allegrocl:old-sym:name", Getattr(n, "sym:name")); - -#if 0 - Printf(stdout, "constant %s is of type %s. value: %s\n", name, type, converted_value); -#endif - - if (converted_value) { - Printf(f_clwrap, "(swig-defconstant \"%s\" %s)\n", name, converted_value); - } else { - Swig_warning(WARN_LANG_DISCARD_CONST, Getfile(n), Getline(n), "Unable to parse constant value '%s'. Setting to NIL\n", value); - Printf(f_clwrap, "(swig-defconstant \"%s\" nil #| %s |#)\n", name, value); - } - - Delete(converted_value); - - return SWIG_OK; -} - -int ALLEGROCL::globalvariableHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "globalvariableHandler %s\n", Getattr(n, "name")); -#endif - - if (Generate_Wrapper) - return Language::globalvariableHandler(n); - - // String *name = Getattr(n, "name"); - SwigType *type = Getattr(n, "type"); - SwigType *rtype = SwigType_typedef_resolve_all(type); - - if (SwigType_isclass(rtype)) { - SwigType_add_pointer(type); - SwigType_add_pointer(rtype); - } - - Printf(f_clwrap, "(swig-defvar \"%s\" \"%s\" :type %s)\n", - Getattr(n, "sym:name"), Getattr(n, "sym:name"), ((SwigType_isconst(type)) ? ":constant" : ":variable")); - - return SWIG_OK; -} - -int ALLEGROCL::variableWrapper(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "variableWrapper %s\n", Getattr(n, "name")); -#endif - Setattr(n, "allegrocl:kind", "variable"); - Setattr(n, "allegrocl:old-sym:name", Getattr(n, "sym:name")); - - // Let SWIG generate a get/set function pair. - if (Generate_Wrapper) - return Language::variableWrapper(n); - - String *name = Getattr(n, "name"); - SwigType *type = Getattr(n, "type"); - SwigType *ctype; - SwigType *rtype = SwigType_typedef_resolve_all(type); - - String *mangled_name = mangle_name(n); - - int pointer_added = 0; - - if (SwigType_isclass(rtype)) { - SwigType_add_pointer(type); - SwigType_add_pointer(rtype); - pointer_added = 1; - } - - ctype = SwigType_str(type, 0); - - // EXPORT <SwigType_str> <mangled_name>; - // <SwigType_str> <mangled_name> = <name>; - Printf(f_runtime, "EXPORT %s %s;\n%s %s = %s%s;\n", ctype, mangled_name, ctype, mangled_name, (pointer_added ? "&" : ""), name); - - Printf(f_cl, "(swig-defvar \"%s\" :type %s)\n", mangled_name, ((SwigType_isconst(type)) ? ":constant" : ":variable")); - - Printf(stderr,"***\n"); - Delete(mangled_name); - -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "DONE variable %s\n", Getattr(n, "name")); -#endif - - return SWIG_OK; -} - -int ALLEGROCL::memberfunctionHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "memberfunctionHandler %s::%s\n", Getattr(parent_node_skipping_extends(n), "name"), Getattr(n, "name")); - Swig_print_node(n); -#endif - Setattr(n, "allegrocl:kind", "member function"); - Setattr(n, "allegrocl:old-sym:name", Getattr(n, "sym:name")); - - // Let SWIG generate a global forwarding function. - return Language::memberfunctionHandler(n); -} - -int ALLEGROCL::membervariableHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "membervariableHandler %s::%s\n", Getattr(parent_node_skipping_extends(n), "name"), Getattr(n, "name")); -#endif - Setattr(n, "allegrocl:kind", "member variable"); - Setattr(n, "allegrocl:old-sym:name", Getattr(n, "sym:name")); - - // Let SWIG generate a get/set function pair. - return Language::membervariableHandler(n); -} - -int ALLEGROCL::typedefHandler(Node *n) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "In typedefHandler\n"); -#endif - - SwigType *typedef_type = Getattr(n,"type"); - // has the side-effect of noting any implicit - // template instantiations in type. - String *ff_type = compose_foreign_type(n, typedef_type); - - String *sym_name = Getattr(n, "sym:name"); - - String *name; - String *type_ref; - - if (in_class) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, " typedef in class '%s'(%p)\n", Getattr(in_class, "sym:name"), in_class); -#endif - Setattr(n, "allegrocl:typedef:in-class", in_class); - - String *class_name = Getattr(in_class, "name"); - name = NewStringf("%s__%s", class_name, sym_name); - type_ref = NewStringf("%s::%s", class_name, sym_name); - Setattr(n, "allegrocl:in-class", in_class); - } else { - name = Copy(sym_name); - type_ref = Copy(Getattr(n, "name")); - } - - Setattr(n, "allegrocl:namespace", current_namespace); - - String *lookup = lookup_defined_foreign_type(typedef_type); - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "** lookup='%s'(%p), typedef_type='%s', strcmp = '%d' strstr = '%d'\n", lookup, lookup, typedef_type, Strcmp(typedef_type,"void"), Strstr(ff_type,"__SWIGACL_FwdReference")); -#endif - - if(lookup || (!lookup && Strcmp(typedef_type,"void")) || - (!lookup && Strstr(ff_type,"__SWIGACL_FwdReference"))) { - add_defined_foreign_type(n, 0, type_ref, name); - } else { - add_forward_referenced_type(n); - } - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "Out typedefHandler\n"); -#endif - - Delete(ff_type); - - return SWIG_OK; -} - -// forward referenced classes are added specially to defined_foreign_types -int ALLEGROCL::classforwardDeclaration(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "classforwardDeclaration %s\n", Getattr(n, "name")); -#endif - - add_forward_referenced_type(n); - return SWIG_OK; -} - -int ALLEGROCL::classHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "classHandler %s::%s\n", current_namespace, Getattr(n, "sym:name")); -#endif - - int result; - - if (Generate_Wrapper) - result = cppClassHandler(n); - else - result = cClassHandler(n); - - return result; -} - -int ALLEGROCL::cClassHandler(Node *n) { -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "In cClassHandler\n"); -#endif - /* Add this structure to the known lisp types */ - // Printf(stderr, "Adding %s foreign type\n", name); - String *ns = listify_namespace(current_namespace); - - add_defined_foreign_type(n); - - Delete(ns); - -#ifdef ALLEGROCL_TYPE_DEBUG - Printf(stderr, "Out cClassHandler\n"); -#endif - - return SWIG_OK; -} - -int ALLEGROCL::cppClassHandler(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "cppClassHandler %s\n", Getattr(n, "name")); -#endif - - // String *name=Getattr(n, "sym:name"); - // String *kind = Getattr(n,"kind"); - - /* Template instantiation. - Careful. - SWIG does not create instantiations of templated classes whenever - it sees a templated class reference (say, as a return type, or - in a parameter list). - - The %template directive results in a templated class instantiation - that will actually be seen by <LANG> :: classHandler(). - - In this case, we don't want to error if the type already exists; - the point is to force the creation of wrappers for the templated - class. - */ - String *templated = Getattr(n, "template"); - String *t_name; - // String *ns = listify_namespace(current_namespace); - - if (templated) { - t_name = namespaced_name(n); - } else { - t_name = Getattr(n, "name"); - } - - Setattr(n, "allegrocl:namespace", current_namespace); - - /* Add this structure to the known lisp types. - Class may contain references to the type currently being - defined */ - if (!templated || !lookup_defined_foreign_type(t_name)) { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "Adding %s foreign type\n", Getattr(n, "sym:name")); -#endif - add_defined_foreign_type(n); - } else { -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "cppClassHand: type %s already exists. Assuming %%template instantiation for wrapping purposes.\n", Getattr(n, "sym:name")); -#endif - add_defined_foreign_type(n, 1); - } - - // Generate slot accessors, constructor, and destructor. - Node *prev_class = in_class; - in_class = n; - - Node *c; - // walk all member variables. -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, " MANUALLY walking class members... \n"); -#endif - for (c = firstChild(n); c; c = nextSibling(c)) { - // ping the types of all children--even protected and private - // so their types can be added to the linked_type_list. - SwigType *childType = NewStringf("%s%s", Getattr(c, "decl"), - Getattr(c, "type")); -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, "looking at child '%p' of type '%s' '%d'\n", c, childType, SwigType_isfunction(childType)); - // Swig_print_node(c); -#endif - if (!SwigType_isfunction(childType)) - Delete(compose_foreign_type(n, childType)); - - Delete(childType); - } -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, " MANUAL walk DONE.\n"); -#endif - - // this will walk all necessary methods. -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, " LANGUAGE walk of children...\n"); -#endif - Language::classHandler(n); -#ifdef ALLEGROCL_CLASS_DEBUG - Printf(stderr, " LANGUAGE walk DONE\n"); -#endif - in_class = prev_class; - - return SWIG_OK; -} - -int ALLEGROCL::emit_one(Node *n) { - // When the current package does not correspond with the current - // namespace we need to generate an IN-PACKAGE form, unless the - // current node is another namespace node. - if (Cmp(nodeType(n), "namespace") != 0 && Cmp(current_package, current_namespace) != 0) { - String *lispy_namespace = listify_namespace(current_namespace); - Printf(f_clwrap, "(swig-in-package %s)\n", lispy_namespace); - Delete(lispy_namespace); - Delete(current_package); - current_package = NewStringf("%s", current_namespace); - } - - Setattr(n, "allegrocl:package", current_package); - - return Language::emit_one(n); -} - -int ALLEGROCL::enumDeclaration(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "enumDeclaration %s\n", Getattr(n, "name")); -#endif - - if (getCurrentClass() && (cplus_mode != PUBLIC)) - return SWIG_NOWRAP; - - if (Getattr(n, "sym:name")) { - add_defined_foreign_type(n); - } - Node *c; - for (c = firstChild(n); c; c = nextSibling(c)) { - ALLEGROCL::enumvalueDeclaration(c); - // since we walk our own children, we need to add - // the current package ourselves. - Setattr(c, "allegrocl:package", current_package); - } - return SWIG_OK; -} - - -int ALLEGROCL::enumvalueDeclaration(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "enumvalueDeclaration %s\n", Getattr(n, "name")); -#endif - /* print this when in C mode? make this a command-line arg? */ - if (Generate_Wrapper) { - SwigType *enum_type = Copy(Getattr(n,"type")); - String *mangled_name = - mangle_name(n, "ACL_ENUM", - in_class ? Getattr(in_class,"name") : - current_namespace); - - SwigType_add_qualifier(enum_type,"const"); - - String *enum_decl = SwigType_str(enum_type, mangled_name); - Printf(f_cxx_wrapper, "EXPORT %s;\n", enum_decl); - Printf(f_cxx_wrapper, "%s = %s;\n", enum_decl, Getattr(n, "value")); - - Delete(mangled_name); - Delete(enum_type); - Delete(enum_decl); - } - return SWIG_OK; -} - -int ALLEGROCL::templateDeclaration(Node *n) { -#ifdef ALLEGROCL_DEBUG - Printf(stderr, "templateDeclaration %s\n", Getattr(n, "name")); -#endif - - String *type = Getattr(n, "templatetype"); - - // Printf(stderr, "tempDecl: %s %s\n", Getattr(n,"name"), - // type); - // Swig_print_node(n); - - if (!Strcmp(type, "cdecl")) { - SwigType *ty = NewStringf("%s%s", Getattr(n, "decl"), - Getattr(n, "type")); - Delete(ty); - } - - Delete(type); - - return SWIG_OK; -} - diff --git a/Source/Modules/cffi.cxx b/Source/Modules/cffi.cxx index bf3338813..6333fa153 100644 --- a/Source/Modules/cffi.cxx +++ b/Source/Modules/cffi.cxx @@ -227,7 +227,7 @@ int CFFI::classHandler(Node *n) { int CFFI::constructorHandler(Node *n) { #ifdef CFFI_DEBUG Printf(stderr, "constructor %s\n", Getattr(n, "name")); - Printf(stderr, "constructor %s\n and %s and %s", Getattr(n, "kind"), Getattr(n, "sym:name"), Getattr(n, "allegrocl:old-sym:name")); + Printf(stderr, "constructor %s\n and %s", Getattr(n, "kind"), Getattr(n, "sym:name")); #endif Setattr(n, "cffi:constructorfunction", "1"); // Let SWIG generate a global forwarding function. @@ -426,7 +426,6 @@ void CFFI::cleanupFunction(Node *n, Wrapper *f, ParmList *parms) { if (GetFlag(n, "feature:new")) { String *tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0); if (tm) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NULL); Delete(tm); } @@ -546,7 +545,6 @@ int CFFI::functionWrapper(Node *n) { /* See if there is any return cleanup code */ String *tm = 0; if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); Delete(tm); } diff --git a/Source/Modules/chicken.cxx b/Source/Modules/chicken.cxx deleted file mode 100644 index 76b6455e2..000000000 --- a/Source/Modules/chicken.cxx +++ /dev/null @@ -1,1535 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * chicken.cxx - * - * CHICKEN language module for SWIG. - * ----------------------------------------------------------------------------- */ - -#include "swigmod.h" - -#include <ctype.h> - -static const char *usage = "\ -\ -CHICKEN Options (available with -chicken)\n\ - -closprefix <prefix> - Prepend <prefix> to all clos identifiers\n\ - -noclosuses - Do not (declare (uses ...)) in scheme file\n\ - -nocollection - Do not register pointers with chicken garbage\n\ - collector and export destructors\n\ - -nounit - Do not (declare (unit ...)) in scheme file\n\ - -proxy - Export TinyCLOS class definitions\n\ - -unhideprimitive - Unhide the primitive: symbols\n\ - -useclassprefix - Prepend the class name to all clos identifiers\n\ -\n"; - -static char *module = 0; -static const char *chicken_path = "chicken"; -static int num_methods = 0; - -static File *f_begin = 0; -static File *f_runtime = 0; -static File *f_header = 0; -static File *f_wrappers = 0; -static File *f_init = 0; -static String *chickentext = 0; -static String *closprefix = 0; -static String *swigtype_ptr = 0; - - -static String *f_sym_size = 0; - -/* some options */ -static int declare_unit = 1; -static int no_collection = 0; -static int clos_uses = 1; - -/* C++ Support + Clos Classes */ -static int clos = 0; -static String *c_class_name = 0; -static String *class_name = 0; -static String *short_class_name = 0; - -static int in_class = 0; -static int have_constructor = 0; -static bool exporting_destructor = false; -static bool exporting_constructor = false; -static String *constructor_name = 0; -static String *member_name = 0; - -/* sections of the .scm code */ -static String *scm_const_defs = 0; -static String *clos_class_defines = 0; -static String *clos_methods = 0; - -/* Some clos options */ -static int useclassprefix = 0; -static String *clossymnameprefix = 0; -static int hide_primitive = 1; -static Hash *primitive_names = 0; - -/* Used for overloading constructors */ -static int has_constructor_args = 0; -static List *constructor_arg_types = 0; -static String *constructor_dispatch = 0; - -static Hash *overload_parameter_lists = 0; - -class CHICKEN:public Language { -public: - - virtual void main(int argc, char *argv[]); - virtual int top(Node *n); - virtual int functionWrapper(Node *n); - virtual int variableWrapper(Node *n); - virtual int constantWrapper(Node *n); - virtual int classHandler(Node *n); - virtual int memberfunctionHandler(Node *n); - virtual int membervariableHandler(Node *n); - virtual int constructorHandler(Node *n); - virtual int destructorHandler(Node *n); - virtual int validIdentifier(String *s); - virtual int staticmembervariableHandler(Node *n); - virtual int staticmemberfunctionHandler(Node *n); - virtual int importDirective(Node *n); - -protected: - void addMethod(String *scheme_name, String *function); - /* Return true iff T is a pointer type */ - int isPointer(SwigType *t); - void dispatchFunction(Node *n); - - String *chickenNameMapping(String *, const_String_or_char_ptr ); - String *chickenPrimitiveName(String *); - - String *runtimeCode(); - String *defaultExternalRuntimeFilename(); - String *buildClosFunctionCall(List *types, const_String_or_char_ptr closname, const_String_or_char_ptr funcname); -}; - -/* ----------------------------------------------------------------------- - * swig_chicken() - Instantiate module - * ----------------------------------------------------------------------- */ - -static Language *new_swig_chicken() { - return new CHICKEN(); -} - -extern "C" { - Language *swig_chicken(void) { - return new_swig_chicken(); - } -} - -void CHICKEN::main(int argc, char *argv[]) { - int i; - - SWIG_library_directory(chicken_path); - - // Look for certain command line options - for (i = 1; i < argc; i++) { - if (argv[i]) { - if (strcmp(argv[i], "-help") == 0) { - fputs(usage, stdout); - SWIG_exit(0); - } else if (strcmp(argv[i], "-proxy") == 0) { - clos = 1; - Swig_mark_arg(i); - } else if (strcmp(argv[i], "-closprefix") == 0) { - if (argv[i + 1]) { - clossymnameprefix = NewString(argv[i + 1]); - Swig_mark_arg(i); - Swig_mark_arg(i + 1); - i++; - } else { - Swig_arg_error(); - } - } else if (strcmp(argv[i], "-useclassprefix") == 0) { - useclassprefix = 1; - Swig_mark_arg(i); - } else if (strcmp(argv[i], "-unhideprimitive") == 0) { - hide_primitive = 0; - Swig_mark_arg(i); - } else if (strcmp(argv[i], "-nounit") == 0) { - declare_unit = 0; - Swig_mark_arg(i); - } else if (strcmp(argv[i], "-noclosuses") == 0) { - clos_uses = 0; - Swig_mark_arg(i); - } else if (strcmp(argv[i], "-nocollection") == 0) { - no_collection = 1; - Swig_mark_arg(i); - } - } - } - - if (!clos) - hide_primitive = 0; - - // Add a symbol for this module - Preprocessor_define("SWIGCHICKEN 1", 0); - - // Set name of typemaps - - SWIG_typemap_lang("chicken"); - - // Read in default typemaps */ - SWIG_config_file("chicken.swg"); - allow_overloading(); -} - -int CHICKEN::top(Node *n) { - String *chicken_filename = NewString(""); - File *f_scm; - String *scmmodule; - - /* Initialize all of the output files */ - String *outfile = Getattr(n, "outfile"); - - f_begin = NewFile(outfile, "w", SWIG_output_files()); - if (!f_begin) { - FileErrorDisplay(outfile); - SWIG_exit(EXIT_FAILURE); - } - f_runtime = NewString(""); - f_init = NewString(""); - f_header = NewString(""); - f_wrappers = NewString(""); - chickentext = NewString(""); - closprefix = NewString(""); - f_sym_size = NewString(""); - primitive_names = NewHash(); - overload_parameter_lists = NewHash(); - - /* Register file targets with the SWIG file handler */ - Swig_register_filebyname("header", f_header); - Swig_register_filebyname("wrapper", f_wrappers); - Swig_register_filebyname("begin", f_begin); - Swig_register_filebyname("runtime", f_runtime); - Swig_register_filebyname("init", f_init); - - Swig_register_filebyname("chicken", chickentext); - Swig_register_filebyname("closprefix", closprefix); - - clos_class_defines = NewString(""); - clos_methods = NewString(""); - scm_const_defs = NewString(""); - - Swig_banner(f_begin); - - Printf(f_runtime, "\n\n#ifndef SWIGCHICKEN\n#define SWIGCHICKEN\n#endif\n\n"); - - if (no_collection) - Printf(f_runtime, "#define SWIG_CHICKEN_NO_COLLECTION 1\n"); - - Printf(f_runtime, "\n"); - - /* Set module name */ - module = Swig_copy_string(Char(Getattr(n, "name"))); - scmmodule = NewString(module); - Replaceall(scmmodule, "_", "-"); - - Printf(f_header, "#define SWIG_init swig_%s_init\n", module); - Printf(f_header, "#define SWIG_name \"%s\"\n", scmmodule); - - Printf(f_wrappers, "#ifdef __cplusplus\n"); - Printf(f_wrappers, "extern \"C\" {\n"); - Printf(f_wrappers, "#endif\n\n"); - - Language::top(n); - - SwigType_emit_type_table(f_runtime, f_wrappers); - - Printf(f_wrappers, "#ifdef __cplusplus\n"); - Printf(f_wrappers, "}\n"); - Printf(f_wrappers, "#endif\n"); - - Printf(f_init, "C_kontinue (continuation, ret);\n"); - Printf(f_init, "}\n\n"); - - Printf(f_init, "#ifdef __cplusplus\n"); - Printf(f_init, "}\n"); - Printf(f_init, "#endif\n"); - - Printf(chicken_filename, "%s%s.scm", SWIG_output_directory(), module); - if ((f_scm = NewFile(chicken_filename, "w", SWIG_output_files())) == 0) { - FileErrorDisplay(chicken_filename); - SWIG_exit(EXIT_FAILURE); - } - - Swig_banner_target_lang(f_scm, ";;"); - Printf(f_scm, "\n"); - - if (declare_unit) - Printv(f_scm, "(declare (unit ", scmmodule, "))\n\n", NIL); - Printv(f_scm, "(declare \n", - tab4, "(hide swig-init swig-init-return)\n", - tab4, "(foreign-declare \"C_extern void swig_", module, "_init(C_word,C_word,C_word) C_noret;\"))\n", NIL); - Printv(f_scm, "(define swig-init (##core#primitive \"swig_", module, "_init\"))\n", NIL); - Printv(f_scm, "(define swig-init-return (swig-init))\n\n", NIL); - - if (clos) { - //Printf (f_scm, "(declare (uses tinyclos))\n"); - //New chicken versions have tinyclos as an egg - Printf(f_scm, "(require-extension tinyclos)\n"); - Replaceall(closprefix, "$module", scmmodule); - Printf(f_scm, "%s\n", closprefix); - Printf(f_scm, "%s\n", clos_class_defines); - Printf(f_scm, "%s\n", clos_methods); - } else { - Printf(f_scm, "%s\n", scm_const_defs); - } - - Printf(f_scm, "%s\n", chickentext); - - Delete(f_scm); - - char buftmp[20]; - sprintf(buftmp, "%d", num_methods); - Replaceall(f_init, "$nummethods", buftmp); - Replaceall(f_init, "$symsize", f_sym_size); - - if (hide_primitive) - Replaceall(f_init, "$veclength", buftmp); - else - Replaceall(f_init, "$veclength", "0"); - - Delete(chicken_filename); - Delete(chickentext); - Delete(closprefix); - Delete(overload_parameter_lists); - - Delete(clos_class_defines); - Delete(clos_methods); - Delete(scm_const_defs); - - /* Close all of the files */ - Delete(primitive_names); - Delete(scmmodule); - Dump(f_runtime, f_begin); - Dump(f_header, f_begin); - Dump(f_wrappers, f_begin); - Wrapper_pretty_print(f_init, f_begin); - Delete(f_header); - Delete(f_wrappers); - Delete(f_sym_size); - Delete(f_init); - Delete(f_runtime); - Delete(f_begin); - return SWIG_OK; -} - -int CHICKEN::functionWrapper(Node *n) { - - String *name = Getattr(n, "name"); - String *iname = Getattr(n, "sym:name"); - SwigType *d = Getattr(n, "type"); - ParmList *l = Getattr(n, "parms"); - - Parm *p; - int i; - String *wname; - Wrapper *f; - String *mangle = NewString(""); - String *get_pointers; - String *cleanup; - String *argout; - String *tm; - String *overname = 0; - String *declfunc = 0; - String *scmname; - bool any_specialized_arg = false; - List *function_arg_types = NewList(); - - int num_required; - int num_arguments; - int have_argout; - - Printf(mangle, "\"%s\"", SwigType_manglestr(d)); - - if (Getattr(n, "sym:overloaded")) { - overname = Getattr(n, "sym:overname"); - } else { - if (!addSymbol(iname, n)) - return SWIG_ERROR; - } - - f = NewWrapper(); - wname = NewString(""); - get_pointers = NewString(""); - cleanup = NewString(""); - argout = NewString(""); - declfunc = NewString(""); - scmname = NewString(iname); - Replaceall(scmname, "_", "-"); - - /* Local vars */ - Wrapper_add_local(f, "resultobj", "C_word resultobj"); - - /* Write code to extract function parameters. */ - emit_parameter_variables(l, f); - - /* Attach the standard typemaps */ - emit_attach_parmmaps(l, f); - Setattr(n, "wrap:parms", l); - - /* Get number of required and total arguments */ - num_arguments = emit_num_arguments(l); - num_required = emit_num_required(l); - - Append(wname, Swig_name_wrapper(iname)); - if (overname) { - Append(wname, overname); - } - // Check for interrupts - Printv(f->code, "C_trace(\"", scmname, "\");\n", NIL); - - Printv(f->def, "static ", "void ", wname, " (C_word argc, C_word closure, C_word continuation", NIL); - Printv(declfunc, "void ", wname, "(C_word,C_word,C_word", NIL); - - /* Generate code for argument marshalling */ - for (i = 0, p = l; i < num_arguments; i++) { - - while (checkAttribute(p, "tmap:in:numinputs", "0")) { - p = Getattr(p, "tmap:in:next"); - } - - SwigType *pt = Getattr(p, "type"); - String *ln = Getattr(p, "lname"); - - Printf(f->def, ", C_word scm%d", i + 1); - Printf(declfunc, ",C_word"); - - /* Look for an input typemap */ - if ((tm = Getattr(p, "tmap:in"))) { - String *parse = Getattr(p, "tmap:in:parse"); - if (!parse) { - String *source = NewStringf("scm%d", i + 1); - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", ln); - Replaceall(tm, "$input", source); - Setattr(p, "emit:input", source); /* Save the location of - the object */ - - if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) { - Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN"); - } else { - Replaceall(tm, "$disown", "0"); - } - - if (i >= num_required) - Printf(get_pointers, "if (argc-2>%i && (%s)) {\n", i, source); - Printv(get_pointers, tm, "\n", NIL); - if (i >= num_required) - Printv(get_pointers, "}\n", NIL); - - if (clos) { - if (i < num_required) { - if (strcmp("void", Char(pt)) != 0) { - Node *class_node = 0; - String *clos_code = Getattr(p, "tmap:in:closcode"); - class_node = classLookup(pt); - if (clos_code && class_node) { - String *class_name = NewStringf("<%s>", Getattr(class_node, "sym:name")); - Replaceall(class_name, "_", "-"); - Append(function_arg_types, class_name); - Append(function_arg_types, Copy(clos_code)); - any_specialized_arg = true; - Delete(class_name); - } else { - Append(function_arg_types, "<top>"); - Append(function_arg_types, "$input"); - } - } - } - } - Delete(source); - } - - p = Getattr(p, "tmap:in:next"); - continue; - } else { - Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0)); - break; - } - } - - /* finish argument marshalling */ - - Printf(f->def, ") {"); - Printf(declfunc, ")"); - - if (num_required != num_arguments) { - Append(function_arg_types, "^^##optional$$"); - } - - /* First check the number of arguments is correct */ - if (num_arguments != num_required) - Printf(f->code, "if (argc-2<%i || argc-2>%i) C_bad_argc(argc,%i);\n", num_required, num_arguments, num_required + 2); - else - Printf(f->code, "if (argc!=%i) C_bad_argc(argc,%i);\n", num_arguments + 2, num_arguments + 2); - - /* Now piece together the first part of the wrapper function */ - Printv(f->code, get_pointers, NIL); - - /* Insert constraint checking code */ - for (p = l; p;) { - if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); - Printv(f->code, tm, "\n", NIL); - p = Getattr(p, "tmap:check:next"); - } else { - p = nextSibling(p); - } - } - - /* Insert cleanup code */ - for (p = l; p;) { - if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Printv(cleanup, tm, "\n", NIL); - p = Getattr(p, "tmap:freearg:next"); - } else { - p = nextSibling(p); - } - } - - /* Insert argument output code */ - have_argout = 0; - for (p = l; p;) { - if ((tm = Getattr(p, "tmap:argout"))) { - - if (!have_argout) { - have_argout = 1; - // Print initial argument output code - Printf(argout, "SWIG_Chicken_SetupArgout\n"); - } - - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", "resultobj"); - Replaceall(tm, "$arg", Getattr(p, "emit:input")); - Replaceall(tm, "$input", Getattr(p, "emit:input")); - Printf(argout, "%s", tm); - p = Getattr(p, "tmap:argout:next"); - } else { - p = nextSibling(p); - } - } - - Setattr(n, "wrap:name", wname); - - /* Emit the function call */ - String *actioncode = emit_action(n); - - /* Return the function value */ - if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "resultobj"); - Replaceall(tm, "$result", "resultobj"); - if (GetFlag(n, "feature:new")) { - Replaceall(tm, "$owner", "1"); - } else { - Replaceall(tm, "$owner", "0"); - } - - Printf(f->code, "%s", tm); - - if (have_argout) - Printf(f->code, "\nSWIG_APPEND_VALUE(resultobj);\n"); - - } else { - Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(d, 0), name); - } - emit_return_variable(n, d, f); - - /* Insert the argument output code */ - Printv(f->code, argout, NIL); - - /* Output cleanup code */ - Printv(f->code, cleanup, NIL); - - /* Look to see if there is any newfree cleanup code */ - if (GetFlag(n, "feature:new")) { - if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Printf(f->code, "%s\n", tm); - } - } - - /* See if there is any return cleanup code */ - if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Printf(f->code, "%s\n", tm); - } - - - if (have_argout) { - Printf(f->code, "C_kontinue(continuation,C_SCHEME_END_OF_LIST);\n"); - } else { - if (exporting_constructor && clos && hide_primitive) { - /* Don't return a proxy, the wrapped CLOS class is the proxy */ - Printf(f->code, "C_kontinue(continuation,resultobj);\n"); - } else { - // make the continuation the proxy creation function, if one exists - Printv(f->code, "{\n", - "C_word func;\n", - "SWIG_Chicken_FindCreateProxy(func, resultobj)\n", - "if (C_swig_is_closurep(func))\n", - " ((C_proc4)(void *)C_block_item(func, 0))(4,func,continuation,resultobj,C_SCHEME_FALSE);\n", - "else\n", " C_kontinue(continuation, resultobj);\n", "}\n", NIL); - } - } - - /* Error handling code */ -#ifdef USE_FAIL - Printf(f->code, "fail:\n"); - Printv(f->code, cleanup, NIL); - Printf(f->code, "swig_panic (\"failure in " "'$symname' SWIG function wrapper\");\n"); -#endif - Printf(f->code, "}\n"); - - /* Substitute the cleanup code */ - Replaceall(f->code, "$cleanup", cleanup); - - /* Substitute the function name */ - Replaceall(f->code, "$symname", iname); - Replaceall(f->code, "$result", "resultobj"); - - /* Dump the function out */ - Printv(f_wrappers, "static ", declfunc, " C_noret;\n", NIL); - Wrapper_print(f, f_wrappers); - - /* Now register the function with the interpreter. */ - if (!Getattr(n, "sym:overloaded")) { - if (exporting_destructor && !no_collection) { - Printf(f_init, "((swig_chicken_clientdata *)(SWIGTYPE%s->clientdata))->destroy = (swig_chicken_destructor) %s;\n", swigtype_ptr, wname); - } else { - addMethod(scmname, wname); - } - - /* Only export if we are not in a class, or if in a class memberfunction */ - if (!in_class || member_name) { - String *method_def; - String *clos_name; - if (in_class) - clos_name = NewString(member_name); - else - clos_name = chickenNameMapping(scmname, ""); - - if (!any_specialized_arg) { - method_def = NewString(""); - Printv(method_def, "(define ", clos_name, " ", chickenPrimitiveName(scmname), ")", NIL); - } else { - method_def = buildClosFunctionCall(function_arg_types, clos_name, chickenPrimitiveName(scmname)); - } - Printv(clos_methods, method_def, "\n", NIL); - Delete(clos_name); - Delete(method_def); - } - - if (have_constructor && !has_constructor_args && any_specialized_arg) { - has_constructor_args = 1; - constructor_arg_types = Copy(function_arg_types); - } - } else { - /* add function_arg_types to overload hash */ - List *flist = Getattr(overload_parameter_lists, scmname); - if (!flist) { - flist = NewList(); - Setattr(overload_parameter_lists, scmname, flist); - } - - Append(flist, Copy(function_arg_types)); - - if (!Getattr(n, "sym:nextSibling")) { - dispatchFunction(n); - } - } - - - Delete(wname); - Delete(get_pointers); - Delete(cleanup); - Delete(declfunc); - Delete(mangle); - Delete(function_arg_types); - DelWrapper(f); - return SWIG_OK; -} - -int CHICKEN::variableWrapper(Node *n) { - char *name = GetChar(n, "name"); - char *iname = GetChar(n, "sym:name"); - SwigType *t = Getattr(n, "type"); - ParmList *l = Getattr(n, "parms"); - - String *wname = NewString(""); - String *mangle = NewString(""); - String *tm; - String *tm2 = NewString(""); - String *argnum = NewString("0"); - String *arg = NewString("argv[0]"); - Wrapper *f; - String *overname = 0; - String *scmname; - - scmname = NewString(iname); - Replaceall(scmname, "_", "-"); - - Printf(mangle, "\"%s\"", SwigType_manglestr(t)); - - if (Getattr(n, "sym:overloaded")) { - overname = Getattr(n, "sym:overname"); - } else { - if (!addSymbol(iname, n)) - return SWIG_ERROR; - } - - f = NewWrapper(); - - /* Attach the standard typemaps */ - emit_attach_parmmaps(l, f); - Setattr(n, "wrap:parms", l); - - // evaluation function names - Append(wname, Swig_name_wrapper(iname)); - if (overname) { - Append(wname, overname); - } - Setattr(n, "wrap:name", wname); - - // Check for interrupts - Printv(f->code, "C_trace(\"", scmname, "\");\n", NIL); - - if (1 || (SwigType_type(t) != T_USER) || (isPointer(t))) { - - Printv(f->def, "static ", "void ", wname, "(C_word, C_word, C_word, C_word) C_noret;\n", NIL); - Printv(f->def, "static " "void ", wname, "(C_word argc, C_word closure, " "C_word continuation, C_word value) {\n", NIL); - - Wrapper_add_local(f, "resultobj", "C_word resultobj"); - - Printf(f->code, "if (argc!=2 && argc!=3) C_bad_argc(argc,2);\n"); - - /* Check for a setting of the variable value */ - if (!GetFlag(n, "feature:immutable")) { - Printf(f->code, "if (argc > 2) {\n"); - if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "value"); - Replaceall(tm, "$target", name); - Replaceall(tm, "$input", "value"); - /* Printv(f->code, tm, "\n",NIL); */ - emit_action_code(n, f->code, tm); - } else { - Swig_warning(WARN_TYPEMAP_VARIN_UNDEF, input_file, line_number, "Unable to set variable of type %s.\n", SwigType_str(t, 0)); - } - Printf(f->code, "}\n"); - } - - String *varname; - if (SwigType_istemplate((char *) name)) { - varname = SwigType_namestr((char *) name); - } else { - varname = name; - } - - // Now return the value of the variable - regardless - // of evaluating or setting. - if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", varname); - Replaceall(tm, "$varname", varname); - Replaceall(tm, "$target", "resultobj"); - Replaceall(tm, "$result", "resultobj"); - /* Printf(f->code, "%s\n", tm); */ - emit_action_code(n, f->code, tm); - } else { - Swig_warning(WARN_TYPEMAP_VAROUT_UNDEF, input_file, line_number, "Unable to read variable of type %s\n", SwigType_str(t, 0)); - } - - Printv(f->code, "{\n", - "C_word func;\n", - "SWIG_Chicken_FindCreateProxy(func, resultobj)\n", - "if (C_swig_is_closurep(func))\n", - " ((C_proc4)(void *)C_block_item(func, 0))(4,func,continuation,resultobj,C_SCHEME_FALSE);\n", - "else\n", " C_kontinue(continuation, resultobj);\n", "}\n", NIL); - - /* Error handling code */ -#ifdef USE_FAIL - Printf(f->code, "fail:\n"); - Printf(f->code, "swig_panic (\"failure in " "'%s' SWIG wrapper\");\n", proc_name); -#endif - Printf(f->code, "}\n"); - - Wrapper_print(f, f_wrappers); - - /* Now register the variable with the interpreter. */ - addMethod(scmname, wname); - - if (!in_class || member_name) { - String *clos_name; - if (in_class) - clos_name = NewString(member_name); - else - clos_name = chickenNameMapping(scmname, ""); - - Node *class_node = classLookup(t); - String *clos_code = Getattr(n, "tmap:varin:closcode"); - if (class_node && clos_code && !GetFlag(n, "feature:immutable")) { - Replaceall(clos_code, "$input", "(car lst)"); - Printv(clos_methods, "(define (", clos_name, " . lst) (if (null? lst) (", chickenPrimitiveName(scmname), ") (", - chickenPrimitiveName(scmname), " ", clos_code, ")))\n", NIL); - } else { - /* Simply re-export the procedure */ - if (GetFlag(n, "feature:immutable") && GetFlag(n, "feature:constasvar")) { - Printv(clos_methods, "(define ", clos_name, " (", chickenPrimitiveName(scmname), "))\n", NIL); - Printv(scm_const_defs, "(set! ", scmname, " (", scmname, "))\n", NIL); - } else { - Printv(clos_methods, "(define ", clos_name, " ", chickenPrimitiveName(scmname), ")\n", NIL); - } - } - Delete(clos_name); - } - } else { - Swig_warning(WARN_TYPEMAP_VAR_UNDEF, input_file, line_number, "Unsupported variable type %s (ignored).\n", SwigType_str(t, 0)); - } - - Delete(wname); - Delete(argnum); - Delete(arg); - Delete(tm2); - Delete(mangle); - DelWrapper(f); - return SWIG_OK; -} - -/* ------------------------------------------------------------ - * constantWrapper() - * ------------------------------------------------------------ */ - -int CHICKEN::constantWrapper(Node *n) { - - char *name = GetChar(n, "name"); - char *iname = GetChar(n, "sym:name"); - SwigType *t = Getattr(n, "type"); - ParmList *l = Getattr(n, "parms"); - String *value = Getattr(n, "value"); - - String *proc_name = NewString(""); - String *wname = NewString(""); - String *mangle = NewString(""); - String *tm; - String *tm2 = NewString(""); - String *source = NewString(""); - String *argnum = NewString("0"); - String *arg = NewString("argv[0]"); - Wrapper *f; - String *overname = 0; - String *scmname; - String *rvalue; - SwigType *nctype; - - scmname = NewString(iname); - Replaceall(scmname, "_", "-"); - - Printf(source, "swig_const_%s", iname); - Replaceall(source, "::", "__"); - - Printf(mangle, "\"%s\"", SwigType_manglestr(t)); - - if (Getattr(n, "sym:overloaded")) { - overname = Getattr(n, "sym:overname"); - } else { - if (!addSymbol(iname, n)) - return SWIG_ERROR; - } - - Append(wname, Swig_name_wrapper(iname)); - if (overname) { - Append(wname, overname); - } - - nctype = NewString(t); - if (SwigType_isconst(nctype)) { - Delete(SwigType_pop(nctype)); - } - - bool is_enum_item = (Cmp(nodeType(n), "enumitem") == 0); - if (SwigType_type(nctype) == T_STRING) { - rvalue = NewStringf("\"%s\"", value); - } else if (SwigType_type(nctype) == T_CHAR && !is_enum_item) { - rvalue = NewStringf("\'%s\'", value); - } else { - rvalue = NewString(value); - } - - /* Special hook for member pointer */ - if (SwigType_type(t) == T_MPOINTER) { - Printf(f_header, "static %s = %s;\n", SwigType_str(t, source), rvalue); - } else { - if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) { - Replaceall(tm, "$source", rvalue); - Replaceall(tm, "$target", source); - Replaceall(tm, "$result", source); - Replaceall(tm, "$value", rvalue); - Printf(f_header, "%s\n", tm); - } else { - Swig_warning(WARN_TYPEMAP_CONST_UNDEF, input_file, line_number, "Unsupported constant value.\n"); - return SWIG_NOWRAP; - } - } - - f = NewWrapper(); - - /* Attach the standard typemaps */ - emit_attach_parmmaps(l, f); - Setattr(n, "wrap:parms", l); - - // evaluation function names - - // Check for interrupts - Printv(f->code, "C_trace(\"", scmname, "\");\n", NIL); - - if (1 || (SwigType_type(t) != T_USER) || (isPointer(t))) { - - Setattr(n, "wrap:name", wname); - Printv(f->def, "static ", "void ", wname, "(C_word, C_word, C_word) C_noret;\n", NIL); - - Printv(f->def, "static ", "void ", wname, "(C_word argc, C_word closure, " "C_word continuation) {\n", NIL); - - Wrapper_add_local(f, "resultobj", "C_word resultobj"); - - Printf(f->code, "if (argc!=2) C_bad_argc(argc,2);\n"); - - // Return the value of the variable - if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - - Replaceall(tm, "$source", source); - Replaceall(tm, "$varname", source); - Replaceall(tm, "$target", "resultobj"); - Replaceall(tm, "$result", "resultobj"); - /* Printf(f->code, "%s\n", tm); */ - emit_action_code(n, f->code, tm); - } else { - Swig_warning(WARN_TYPEMAP_VAROUT_UNDEF, input_file, line_number, "Unable to read variable of type %s\n", SwigType_str(t, 0)); - } - - Printv(f->code, "{\n", - "C_word func;\n", - "SWIG_Chicken_FindCreateProxy(func, resultobj)\n", - "if (C_swig_is_closurep(func))\n", - " ((C_proc4)(void *)C_block_item(func, 0))(4,func,continuation,resultobj,C_SCHEME_FALSE);\n", - "else\n", " C_kontinue(continuation, resultobj);\n", "}\n", NIL); - - /* Error handling code */ -#ifdef USE_FAIL - Printf(f->code, "fail:\n"); - Printf(f->code, "swig_panic (\"failure in " "'%s' SWIG wrapper\");\n", proc_name); -#endif - Printf(f->code, "}\n"); - - Wrapper_print(f, f_wrappers); - - /* Now register the variable with the interpreter. */ - addMethod(scmname, wname); - - if (!in_class || member_name) { - String *clos_name; - if (in_class) - clos_name = NewString(member_name); - else - clos_name = chickenNameMapping(scmname, ""); - if (GetFlag(n, "feature:constasvar")) { - Printv(clos_methods, "(define ", clos_name, " (", chickenPrimitiveName(scmname), "))\n", NIL); - Printv(scm_const_defs, "(set! ", scmname, " (", scmname, "))\n", NIL); - } else { - Printv(clos_methods, "(define ", clos_name, " ", chickenPrimitiveName(scmname), ")\n", NIL); - } - Delete(clos_name); - } - - } else { - Swig_warning(WARN_TYPEMAP_VAR_UNDEF, input_file, line_number, "Unsupported variable type %s (ignored).\n", SwigType_str(t, 0)); - } - - Delete(wname); - Delete(nctype); - Delete(proc_name); - Delete(argnum); - Delete(arg); - Delete(tm2); - Delete(mangle); - Delete(source); - Delete(rvalue); - DelWrapper(f); - return SWIG_OK; -} - -int CHICKEN::classHandler(Node *n) { - /* Create new strings for building up a wrapper function */ - have_constructor = 0; - constructor_dispatch = 0; - constructor_name = 0; - - c_class_name = NewString(Getattr(n, "sym:name")); - class_name = NewString(""); - short_class_name = NewString(""); - Printv(class_name, "<", c_class_name, ">", NIL); - Printv(short_class_name, c_class_name, NIL); - Replaceall(class_name, "_", "-"); - Replaceall(short_class_name, "_", "-"); - - if (!addSymbol(class_name, n)) - return SWIG_ERROR; - - /* Handle inheritance */ - String *base_class = NewString(""); - List *baselist = Getattr(n, "bases"); - if (baselist && Len(baselist)) { - Iterator base = First(baselist); - while (base.item) { - if (!Getattr(base.item, "feature:ignore")) - Printv(base_class, "<", Getattr(base.item, "sym:name"), "> ", NIL); - base = Next(base); - } - } - - Replaceall(base_class, "_", "-"); - - String *scmmod = NewString(module); - Replaceall(scmmod, "_", "-"); - - Printv(clos_class_defines, "(define ", class_name, "\n", " (make <swig-metaclass-", scmmod, "> 'name \"", short_class_name, "\"\n", NIL); - Delete(scmmod); - - if (Len(base_class)) { - Printv(clos_class_defines, " 'direct-supers (list ", base_class, ")\n", NIL); - } else { - Printv(clos_class_defines, " 'direct-supers (list <object>)\n", NIL); - } - - Printf(clos_class_defines, " 'direct-slots (list 'swig-this\n"); - - String *mangled_classname = Swig_name_mangle(Getattr(n, "sym:name")); - - SwigType *ct = NewStringf("p.%s", Getattr(n, "name")); - swigtype_ptr = SwigType_manglestr(ct); - - Printf(f_runtime, "static swig_chicken_clientdata _swig_chicken_clientdata%s = { 0 };\n", mangled_classname); - Printv(f_init, "SWIG_TypeClientData(SWIGTYPE", swigtype_ptr, ", (void *) &_swig_chicken_clientdata", mangled_classname, ");\n", NIL); - SwigType_remember(ct); - - /* Emit all of the members */ - - in_class = 1; - Language::classHandler(n); - in_class = 0; - - Printf(clos_class_defines, ")))\n\n"); - - if (have_constructor) { - Printv(clos_methods, "(define-method (initialize (obj ", class_name, ") initargs)\n", " (swig-initialize obj initargs ", NIL); - if (constructor_arg_types) { - String *initfunc_name = NewStringf("%s@@SWIG@initmethod", class_name); - String *func_call = buildClosFunctionCall(constructor_arg_types, initfunc_name, chickenPrimitiveName(constructor_name)); - Printf(clos_methods, "%s)\n)\n", initfunc_name); - Printf(clos_methods, "(declare (hide %s))\n", initfunc_name); - Printf(clos_methods, "%s\n", func_call); - Delete(func_call); - Delete(initfunc_name); - Delete(constructor_arg_types); - constructor_arg_types = 0; - } else if (constructor_dispatch) { - Printf(clos_methods, "%s)\n)\n", constructor_dispatch); - Delete(constructor_dispatch); - constructor_dispatch = 0; - } else { - Printf(clos_methods, "%s)\n)\n", chickenPrimitiveName(constructor_name)); - } - Delete(constructor_name); - constructor_name = 0; - } else { - Printv(clos_methods, "(define-method (initialize (obj ", class_name, ") initargs)\n", " (swig-initialize obj initargs (lambda x #f)))\n", NIL); - } - - /* export class initialization function */ - if (clos) { - String *funcname = NewString(mangled_classname); - Printf(funcname, "_swig_chicken_setclosclass"); - String *closfuncname = NewString(funcname); - Replaceall(closfuncname, "_", "-"); - - Printv(f_wrappers, "static void ", funcname, "(C_word,C_word,C_word,C_word) C_noret;\n", - "static void ", funcname, "(C_word argc, C_word closure, C_word continuation, C_word cl) {\n", - " C_trace(\"", funcname, "\");\n", - " if (argc!=3) C_bad_argc(argc,3);\n", - " swig_chicken_clientdata *cdata = (swig_chicken_clientdata *) SWIGTYPE", swigtype_ptr, "->clientdata;\n", - " cdata->gc_proxy_create = CHICKEN_new_gc_root();\n", - " CHICKEN_gc_root_set(cdata->gc_proxy_create, cl);\n", " C_kontinue(continuation, C_SCHEME_UNDEFINED);\n", "}\n", NIL); - addMethod(closfuncname, funcname); - - Printv(clos_methods, "(", chickenPrimitiveName(closfuncname), " (lambda (x lst) (if lst ", - "(cons (make ", class_name, " 'swig-this x) lst) ", "(make ", class_name, " 'swig-this x))))\n\n", NIL); - Delete(closfuncname); - Delete(funcname); - } - - Delete(mangled_classname); - Delete(swigtype_ptr); - swigtype_ptr = 0; - - Delete(class_name); - Delete(short_class_name); - Delete(c_class_name); - class_name = 0; - short_class_name = 0; - c_class_name = 0; - - return SWIG_OK; -} - -int CHICKEN::memberfunctionHandler(Node *n) { - String *iname = Getattr(n, "sym:name"); - String *proc = NewString(iname); - Replaceall(proc, "_", "-"); - - member_name = chickenNameMapping(proc, short_class_name); - Language::memberfunctionHandler(n); - Delete(member_name); - member_name = NULL; - Delete(proc); - - return SWIG_OK; -} - -int CHICKEN::staticmemberfunctionHandler(Node *n) { - String *iname = Getattr(n, "sym:name"); - String *proc = NewString(iname); - Replaceall(proc, "_", "-"); - - member_name = NewStringf("%s-%s", short_class_name, proc); - Language::staticmemberfunctionHandler(n); - Delete(member_name); - member_name = NULL; - Delete(proc); - - return SWIG_OK; -} - -int CHICKEN::membervariableHandler(Node *n) { - String *iname = Getattr(n, "sym:name"); - //String *pb = SwigType_typedef_resolve_all(SwigType_base(Getattr(n, "type"))); - - Language::membervariableHandler(n); - - String *proc = NewString(iname); - Replaceall(proc, "_", "-"); - - //Node *class_node = Swig_symbol_clookup(pb, Getattr(n, "sym:symtab")); - Node *class_node = classLookup(Getattr(n, "type")); - - //String *getfunc = NewStringf("%s-%s-get", short_class_name, proc); - //String *setfunc = NewStringf("%s-%s-set", short_class_name, proc); - String *getfunc = Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, c_class_name, iname)); - Replaceall(getfunc, "_", "-"); - String *setfunc = Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, c_class_name, iname)); - Replaceall(setfunc, "_", "-"); - - Printv(clos_class_defines, " (list '", proc, " ':swig-virtual ':swig-get ", chickenPrimitiveName(getfunc), NIL); - - if (!GetFlag(n, "feature:immutable")) { - if (class_node) { - Printv(clos_class_defines, " ':swig-set (lambda (x y) (", chickenPrimitiveName(setfunc), " x (slot-ref y 'swig-this))))\n", NIL); - } else { - Printv(clos_class_defines, " ':swig-set ", chickenPrimitiveName(setfunc), ")\n", NIL); - } - } else { - Printf(clos_class_defines, ")\n"); - } - - Delete(proc); - Delete(setfunc); - Delete(getfunc); - return SWIG_OK; -} - -int CHICKEN::staticmembervariableHandler(Node *n) { - String *iname = Getattr(n, "sym:name"); - String *proc = NewString(iname); - Replaceall(proc, "_", "-"); - - member_name = NewStringf("%s-%s", short_class_name, proc); - Language::staticmembervariableHandler(n); - Delete(member_name); - member_name = NULL; - Delete(proc); - - return SWIG_OK; -} - -int CHICKEN::constructorHandler(Node *n) { - have_constructor = 1; - has_constructor_args = 0; - - - exporting_constructor = true; - Language::constructorHandler(n); - exporting_constructor = false; - - has_constructor_args = 1; - - String *iname = Getattr(n, "sym:name"); - constructor_name = Swig_name_construct(NSPACE_TODO, iname); - Replaceall(constructor_name, "_", "-"); - return SWIG_OK; -} - -int CHICKEN::destructorHandler(Node *n) { - - if (no_collection) - member_name = NewStringf("delete-%s", short_class_name); - - exporting_destructor = true; - Language::destructorHandler(n); - exporting_destructor = false; - - if (no_collection) { - Delete(member_name); - member_name = NULL; - } - - return SWIG_OK; -} - -int CHICKEN::importDirective(Node *n) { - String *modname = Getattr(n, "module"); - if (modname && clos_uses) { - - // Find the module node for this imported module. It should be the - // first child but search just in case. - Node *mod = firstChild(n); - while (mod && Strcmp(nodeType(mod), "module") != 0) - mod = nextSibling(mod); - - if (mod) { - String *name = Getattr(mod, "name"); - if (name) { - Printf(closprefix, "(declare (uses %s))\n", name); - } - } - } - - return Language::importDirective(n); -} - -String *CHICKEN::buildClosFunctionCall(List *types, const_String_or_char_ptr closname, const_String_or_char_ptr funcname) { - String *method_signature = NewString(""); - String *func_args = NewString(""); - String *func_call = NewString(""); - - Iterator arg_type; - int arg_count = 0; - int optional_arguments = 0; - - for (arg_type = First(types); arg_type.item; arg_type = Next(arg_type)) { - if (Strcmp(arg_type.item, "^^##optional$$") == 0) { - optional_arguments = 1; - } else { - Printf(method_signature, " (arg%i %s)", arg_count, arg_type.item); - arg_type = Next(arg_type); - if (!arg_type.item) - break; - - String *arg = NewStringf("arg%i", arg_count); - String *access_arg = Copy(arg_type.item); - - Replaceall(access_arg, "$input", arg); - Printf(func_args, " %s", access_arg); - - Delete(arg); - Delete(access_arg); - } - arg_count++; - } - - if (optional_arguments) { - Printf(func_call, "(define-method (%s %s . args) (apply %s %s args))", closname, method_signature, funcname, func_args); - } else { - Printf(func_call, "(define-method (%s %s) (%s %s))", closname, method_signature, funcname, func_args); - } - - Delete(method_signature); - Delete(func_args); - - return func_call; -} - -extern "C" { - - /* compares based on non-primitive names */ - static int compareTypeListsHelper(const DOH *a, const DOH *b, int opt_equal) { - List *la = (List *) a; - List *lb = (List *) b; - - Iterator ia = First(la); - Iterator ib = First(lb); - - while (ia.item && ib.item) { - int ret = Strcmp(ia.item, ib.item); - if (ret) - return ret; - ia = Next(Next(ia)); - ib = Next(Next(ib)); - } if (opt_equal && ia.item && Strcmp(ia.item, "^^##optional$$") == 0) - return 0; - if (ia.item) - return -1; - if (opt_equal && ib.item && Strcmp(ib.item, "^^##optional$$") == 0) - return 0; - if (ib.item) - return 1; - - return 0; - } - - static int compareTypeLists(const DOH *a, const DOH *b) { - return compareTypeListsHelper(a, b, 0); - } -} - -void CHICKEN::dispatchFunction(Node *n) { - /* Last node in overloaded chain */ - - int maxargs; - String *tmp = NewString(""); - String *dispatch = Swig_overload_dispatch(n, "%s (2+$numargs,closure," "continuation$commaargs);", &maxargs); - - /* Generate a dispatch wrapper for all overloaded functions */ - - Wrapper *f = NewWrapper(); - String *iname = Getattr(n, "sym:name"); - String *wname = NewString(""); - String *scmname = NewString(iname); - Replaceall(scmname, "_", "-"); - - Append(wname, Swig_name_wrapper(iname)); - - Printv(f->def, "static void real_", wname, "(C_word, C_word, C_word, C_word) C_noret;\n", NIL); - - Printv(f->def, "static void real_", wname, "(C_word oldargc, C_word closure, C_word continuation, C_word args) {", NIL); - - Wrapper_add_local(f, "argc", "int argc"); - Printf(tmp, "C_word argv[%d]", maxargs + 1); - Wrapper_add_local(f, "argv", tmp); - Wrapper_add_local(f, "ii", "int ii"); - Wrapper_add_local(f, "t", "C_word t = args"); - Printf(f->code, "if (!C_swig_is_list (args)) {\n"); - Printf(f->code, " swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE, " "\"Argument #1 must be a list of overloaded arguments\");\n"); - Printf(f->code, "}\n"); - Printf(f->code, "argc = C_unfix (C_i_length (args));\n"); - Printf(f->code, "for (ii = 0; (ii < argc) && (ii < %d); ii++, t = C_block_item (t, 1)) {\n", maxargs); - Printf(f->code, "argv[ii] = C_block_item (t, 0);\n"); - Printf(f->code, "}\n"); - - Printv(f->code, dispatch, "\n", NIL); - Printf(f->code, "swig_barf (SWIG_BARF1_BAD_ARGUMENT_TYPE," "\"No matching function for overloaded '%s'\");\n", iname); - Printv(f->code, "}\n", NIL); - Wrapper_print(f, f_wrappers); - addMethod(scmname, wname); - - DelWrapper(f); - f = NewWrapper(); - - /* varargs */ - Printv(f->def, "void ", wname, "(C_word, C_word, C_word, ...) C_noret;\n", NIL); - Printv(f->def, "void ", wname, "(C_word c, C_word t0, C_word t1, ...) {", NIL); - Printv(f->code, - "C_word t2;\n", - "va_list v;\n", - "C_word *a, c2 = c;\n", - "C_save_rest (t1, c2, 2);\n", "a = C_alloc((c-2)*3);\n", "t2 = C_restore_rest (a, C_rest_count (0));\n", "real_", wname, " (3, t0, t1, t2);\n", NIL); - Printv(f->code, "}\n", NIL); - Wrapper_print(f, f_wrappers); - - /* Now deal with overloaded function when exporting clos */ - if (clos) { - List *flist = Getattr(overload_parameter_lists, scmname); - if (flist) { - Delattr(overload_parameter_lists, scmname); - - SortList(flist, compareTypeLists); - - String *clos_name; - if (have_constructor && !has_constructor_args) { - has_constructor_args = 1; - constructor_dispatch = NewStringf("%s@SWIG@new@dispatch", short_class_name); - clos_name = Copy(constructor_dispatch); - Printf(clos_methods, "(declare (hide %s))\n", clos_name); - } else if (in_class) - clos_name = NewString(member_name); - else - clos_name = chickenNameMapping(scmname, ""); - - Iterator f; - List *prev = 0; - int all_primitive = 1; - - /* first check for duplicates and an empty call */ - String *newlist = NewList(); - for (f = First(flist); f.item; f = Next(f)) { - /* check if cur is a duplicate of prev */ - if (prev && compareTypeListsHelper(f.item, prev, 1) == 0) { - Delete(f.item); - } else { - Append(newlist, f.item); - prev = f.item; - Iterator j; - for (j = First(f.item); j.item; j = Next(j)) { - if (Strcmp(j.item, "^^##optional$$") != 0 && Strcmp(j.item, "<top>") != 0) - all_primitive = 0; - } - } - } - Delete(flist); - flist = newlist; - - if (all_primitive) { - Printf(clos_methods, "(define %s %s)\n", clos_name, chickenPrimitiveName(scmname)); - } else { - for (f = First(flist); f.item; f = Next(f)) { - /* now export clos code for argument */ - String *func_call = buildClosFunctionCall(f.item, clos_name, chickenPrimitiveName(scmname)); - Printf(clos_methods, "%s\n", func_call); - Delete(f.item); - Delete(func_call); - } - } - - Delete(clos_name); - Delete(flist); - } - } - - DelWrapper(f); - Delete(dispatch); - Delete(tmp); - Delete(wname); -} - -int CHICKEN::isPointer(SwigType *t) { - return SwigType_ispointer(SwigType_typedef_resolve_all(t)); -} - -void CHICKEN::addMethod(String *scheme_name, String *function) { - String *sym = NewString(""); - if (clos) { - Append(sym, "primitive:"); - } - Append(sym, scheme_name); - - /* add symbol to Chicken internal symbol table */ - if (hide_primitive) { - Printv(f_init, "{\n", - " C_word *p0 = a;\n", " *(a++)=C_CLOSURE_TYPE|1;\n", " *(a++)=(C_word)", function, ";\n", " C_mutate(return_vec++, (C_word)p0);\n", "}\n", NIL); - } else { - Printf(f_sym_size, "+C_SIZEOF_INTERNED_SYMBOL(%d)", Len(sym)); - Printf(f_init, "sym = C_intern (&a, %d, \"%s\");\n", Len(sym), sym); - Printv(f_init, "C_mutate ((C_word*)sym+1, (*a=C_CLOSURE_TYPE|1, a[1]=(C_word)", function, ", tmp=(C_word)a, a+=2, tmp));\n", NIL); - } - - if (hide_primitive) { - Setattr(primitive_names, scheme_name, NewStringf("(vector-ref swig-init-return %i)", num_methods)); - } else { - Setattr(primitive_names, scheme_name, Copy(sym)); - } - - num_methods++; - - Delete(sym); -} - -String *CHICKEN::chickenPrimitiveName(String *name) { - String *value = Getattr(primitive_names, name); - if (value) - return value; - else { - Swig_error(input_file, line_number, "Internal Error: attempting to reference non-existent primitive name %s\n", name); - return NewString("#f"); - } -} - -int CHICKEN::validIdentifier(String *s) { - char *c = Char(s); - /* Check whether we have an R5RS identifier. */ - /* <identifier> --> <initial> <subsequent>* | <peculiar identifier> */ - /* <initial> --> <letter> | <special initial> */ - if (!(isalpha(*c) || (*c == '!') || (*c == '$') || (*c == '%') - || (*c == '&') || (*c == '*') || (*c == '/') || (*c == ':') - || (*c == '<') || (*c == '=') || (*c == '>') || (*c == '?') - || (*c == '^') || (*c == '_') || (*c == '~'))) { - /* <peculiar identifier> --> + | - | ... */ - if ((strcmp(c, "+") == 0) - || strcmp(c, "-") == 0 || strcmp(c, "...") == 0) - return 1; - else - return 0; - } - /* <subsequent> --> <initial> | <digit> | <special subsequent> */ - while (*c) { - if (!(isalnum(*c) || (*c == '!') || (*c == '$') || (*c == '%') - || (*c == '&') || (*c == '*') || (*c == '/') || (*c == ':') - || (*c == '<') || (*c == '=') || (*c == '>') || (*c == '?') - || (*c == '^') || (*c == '_') || (*c == '~') || (*c == '+') - || (*c == '-') || (*c == '.') || (*c == '@'))) - return 0; - c++; - } - return 1; -} - - /* ------------------------------------------------------------ - * closNameMapping() - * Maps the identifier from C++ to the CLOS based on command - * line parameters and such. - * If class_name = "" that means the mapping is for a function or - * variable not attached to any class. - * ------------------------------------------------------------ */ -String *CHICKEN::chickenNameMapping(String *name, const_String_or_char_ptr class_name) { - String *n = NewString(""); - - if (Strcmp(class_name, "") == 0) { - // not part of a class, so no class name to prefix - if (clossymnameprefix) { - Printf(n, "%s%s", clossymnameprefix, name); - } else { - Printf(n, "%s", name); - } - } else { - if (useclassprefix) { - Printf(n, "%s-%s", class_name, name); - } else { - if (clossymnameprefix) { - Printf(n, "%s%s", clossymnameprefix, name); - } else { - Printf(n, "%s", name); - } - } - } - return n; -} - -String *CHICKEN::runtimeCode() { - String *s = Swig_include_sys("chickenrun.swg"); - if (!s) { - Printf(stderr, "*** Unable to open 'chickenrun.swg'\n"); - s = NewString(""); - } - return s; -} - -String *CHICKEN::defaultExternalRuntimeFilename() { - return NewString("swigchickenrun.h"); -} diff --git a/Source/Modules/clisp.cxx b/Source/Modules/clisp.cxx deleted file mode 100644 index d7f197197..000000000 --- a/Source/Modules/clisp.cxx +++ /dev/null @@ -1,515 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * clisp.cxx - * - * clisp language module for SWIG. - * ----------------------------------------------------------------------------- */ - -#include "swigmod.h" - -static const char *usage = "\ -CLISP Options (available with -clisp)\n\ - -extern-all - Create clisp definitions for all the functions and\n\ - global variables otherwise only definitions for\n\ - externed functions and variables are created.\n\ - -generate-typedef - Use def-c-type to generate shortcuts according to the\n\ - typedefs in the input.\n\ -"; - -class CLISP:public Language { -public: - File *f_cl; - String *module; - virtual void main(int argc, char *argv[]); - virtual int top(Node *n); - virtual int functionWrapper(Node *n); - virtual int variableWrapper(Node *n); - virtual int constantWrapper(Node *n); - virtual int classDeclaration(Node *n); - virtual int enumDeclaration(Node *n); - virtual int typedefHandler(Node *n); - List *entries; -private: - String *get_ffi_type(Node *n, SwigType *ty); - String *convert_literal(String *num_param, String *type); - String *strip_parens(String *string); - int extern_all_flag; - int generate_typedef_flag; - int is_function; -}; - -void CLISP::main(int argc, char *argv[]) { - int i; - - Preprocessor_define("SWIGCLISP 1", 0); - SWIG_library_directory("clisp"); - SWIG_config_file("clisp.swg"); - generate_typedef_flag = 0; - extern_all_flag = 0; - - for (i = 1; i < argc; i++) { - if (!strcmp(argv[i], "-help")) { - Printf(stdout, "%s\n", usage); - } else if ((Strcmp(argv[i], "-extern-all") == 0)) { - extern_all_flag = 1; - Swig_mark_arg(i); - } else if ((Strcmp(argv[i], "-generate-typedef") == 0)) { - generate_typedef_flag = 1; - Swig_mark_arg(i); - } - } -} - -int CLISP::top(Node *n) { - - File *f_null = NewString(""); - module = Getattr(n, "name"); - String *output_filename; - entries = NewList(); - - /* Get the output file name */ - String *outfile = Getattr(n, "outfile"); - - if (!outfile) { - Printf(stderr, "Unable to determine outfile\n"); - SWIG_exit(EXIT_FAILURE); - } - - output_filename = NewStringf("%s%s.lisp", SWIG_output_directory(), module); - - f_cl = NewFile(output_filename, "w+", SWIG_output_files()); - if (!f_cl) { - FileErrorDisplay(output_filename); - SWIG_exit(EXIT_FAILURE); - } - - Swig_register_filebyname("header", f_null); - Swig_register_filebyname("begin", f_null); - Swig_register_filebyname("runtime", f_null); - Swig_register_filebyname("wrapper", f_null); - - String *header = NewString(""); - - Swig_banner_target_lang(header, ";;"); - - Printf(header, "\n(defpackage :%s\n (:use :common-lisp :ffi)", module); - - Language::top(n); - - Iterator i; - - long len = Len(entries); - if (len > 0) { - Printf(header, "\n (:export"); - } - //else nothing to export - - for (i = First(entries); i.item; i = Next(i)) { - Printf(header, "\n\t:%s", i.item); - } - - if (len > 0) { - Printf(header, ")"); - } - - Printf(header, ")\n"); - Printf(header, "\n(in-package :%s)\n", module); - Printf(header, "\n(default-foreign-language :stdc)\n"); - - len = Tell(f_cl); - - Printf(f_cl, "%s", header); - - long end = Tell(f_cl); - - for (len--; len >= 0; len--) { - end--; - (void)Seek(f_cl, len, SEEK_SET); - int ch = Getc(f_cl); - (void)Seek(f_cl, end, SEEK_SET); - Putc(ch, f_cl); - } - - Seek(f_cl, 0, SEEK_SET); - Write(f_cl, Char(header), Len(header)); - - Delete(f_cl); - - return SWIG_OK; -} - - -int CLISP::functionWrapper(Node *n) { - is_function = 1; - String *storage = Getattr(n, "storage"); - if (!extern_all_flag && (!storage || (!Swig_storage_isextern(n) && !Swig_storage_isexternc(n)))) - return SWIG_OK; - - String *func_name = Getattr(n, "sym:name"); - - ParmList *pl = Getattr(n, "parms"); - - int argnum = 0, first = 1; - - Printf(f_cl, "\n(ffi:def-call-out %s\n\t(:name \"%s\")\n", func_name, func_name); - - Append(entries, func_name); - - if (ParmList_len(pl) != 0) { - Printf(f_cl, "\t(:arguments "); - } - for (Parm *p = pl; p; p = nextSibling(p), argnum++) { - - String *argname = Getattr(p, "name"); - // SwigType *argtype; - - String *ffitype = get_ffi_type(n, Getattr(p, "type")); - - int tempargname = 0; - - if (!argname) { - argname = NewStringf("arg%d", argnum); - tempargname = 1; - } - - if (!first) { - Printf(f_cl, "\n\t\t"); - } - Printf(f_cl, "(%s %s)", argname, ffitype); - first = 0; - - Delete(ffitype); - - if (tempargname) - Delete(argname); - } - if (ParmList_len(pl) != 0) { - Printf(f_cl, ")\n"); /* finish arg list */ - } - String *ffitype = get_ffi_type(n, Getattr(n, "type")); - if (Strcmp(ffitype, "NIL")) { //when return type is not nil - Printf(f_cl, "\t(:return-type %s)\n", ffitype); - } - Printf(f_cl, "\t(:library +library-name+))\n"); - - return SWIG_OK; -} - - -int CLISP::constantWrapper(Node *n) { - is_function = 0; - String *type = Getattr(n, "type"); - String *converted_value = convert_literal(Getattr(n, "value"), type); - String *name = Getattr(n, "sym:name"); - - Printf(f_cl, "\n(defconstant %s %s)\n", name, converted_value); - Append(entries, name); - Delete(converted_value); - - return SWIG_OK; -} - -int CLISP::variableWrapper(Node *n) { - is_function = 0; - String *storage = Getattr(n, "storage"); - - if (!extern_all_flag && (!storage || (!Swig_storage_isextern(n) && !Swig_storage_isexternc(n)))) - return SWIG_OK; - - String *var_name = Getattr(n, "sym:name"); - String *lisp_type = get_ffi_type(n, Getattr(n, "type")); - Printf(f_cl, "\n(ffi:def-c-var %s\n (:name \"%s\")\n (:type %s)\n", var_name, var_name, lisp_type); - Printf(f_cl, "\t(:library +library-name+))\n"); - Append(entries, var_name); - - Delete(lisp_type); - return SWIG_OK; -} - -int CLISP::typedefHandler(Node *n) { - if (generate_typedef_flag) { - is_function = 0; - Printf(f_cl, "\n(ffi:def-c-type %s %s)\n", Getattr(n, "name"), get_ffi_type(n, Getattr(n, "type"))); - } - - return Language::typedefHandler(n); -} - -int CLISP::enumDeclaration(Node *n) { - if (getCurrentClass() && (cplus_mode != PUBLIC)) - return SWIG_NOWRAP; - - is_function = 0; - String *name = Getattr(n, "sym:name"); - - Printf(f_cl, "\n(ffi:def-c-enum %s ", name); - - for (Node *c = firstChild(n); c; c = nextSibling(c)) { - - String *slot_name = Getattr(c, "name"); - String *value = Getattr(c, "enumvalue"); - - Printf(f_cl, "(%s %s)", slot_name, value); - - Append(entries, slot_name); - - Delete(value); - } - - Printf(f_cl, ")\n"); - return SWIG_OK; -} - - -// Includes structs -int CLISP::classDeclaration(Node *n) { - is_function = 0; - String *name = Getattr(n, "sym:name"); - String *kind = Getattr(n, "kind"); - - if (Strcmp(kind, "struct")) { - Printf(stderr, "Don't know how to deal with %s kind of class yet.\n", kind); - Printf(stderr, " (name: %s)\n", name); - SWIG_exit(EXIT_FAILURE); - } - - - Printf(f_cl, "\n(ffi:def-c-struct %s", name); - - Append(entries, NewStringf("make-%s", name)); - - for (Node *c = firstChild(n); c; c = nextSibling(c)) { - - if (Strcmp(nodeType(c), "cdecl")) { - Printf(stderr, "Structure %s has a slot that we can't deal with.\n", name); - Printf(stderr, "nodeType: %s, name: %s, type: %s\n", nodeType(c), Getattr(c, "name"), Getattr(c, "type")); - SWIG_exit(EXIT_FAILURE); - } - - String *temp = Copy(Getattr(c, "decl")); - if (temp) { - Append(temp, Getattr(c, "type")); //appending type to the end, otherwise wrong type - String *lisp_type = get_ffi_type(n, temp); - Delete(temp); - - String *slot_name = Getattr(c, "sym:name"); - Printf(f_cl, "\n\t(%s %s)", slot_name, lisp_type); - - Append(entries, NewStringf("%s-%s", name, slot_name)); - - Delete(lisp_type); - } - } - - Printf(f_cl, ")\n"); - - /* Add this structure to the known lisp types */ - //Printf(stdout, "Adding %s foreign type\n", name); - // add_defined_foreign_type(name); - - return SWIG_OK; -} - -/* utilities */ -/* returns new string w/ parens stripped */ -String *CLISP::strip_parens(String *string) { - char *s = Char(string), *p; - int len = Len(string); - String *res; - - if (len == 0 || s[0] != '(' || s[len - 1] != ')') { - return NewString(string); - } - - p = (char *) malloc(len - 2 + 1); - if (!p) { - Printf(stderr, "Malloc failed\n"); - SWIG_exit(EXIT_FAILURE); - } - - strncpy(p, s + 1, len - 1); - p[len - 2] = 0; /* null terminate */ - - res = NewString(p); - free(p); - - return res; -} - -String *CLISP::convert_literal(String *num_param, String *type) { - String *num = strip_parens(num_param), *res; - char *s = Char(num); - - /* Make sure doubles use 'd' instead of 'e' */ - if (!Strcmp(type, "double")) { - String *updated = Copy(num); - if (Replace(updated, "e", "d", DOH_REPLACE_ANY) > 1) { - Printf(stderr, "Weird!! number %s looks invalid.\n", num); - SWIG_exit(EXIT_FAILURE); - } - Delete(num); - return updated; - } - - if (SwigType_type(type) == T_CHAR) { - /* Use CL syntax for character literals */ - return NewStringf("#\\%s", num_param); - } else if (SwigType_type(type) == T_STRING) { - /* Use CL syntax for string literals */ - return NewStringf("\"%s\"", num_param); - } - - if (Len(num) < 2 || s[0] != '0') { - return num; - } - - /* octal or hex */ - - res = NewStringf("#%c%s", s[1] == 'x' ? 'x' : 'o', s + 2); - Delete(num); - - return res; -} - -String *CLISP::get_ffi_type(Node *n, SwigType *ty) { - Node *node = NewHash(); - Setattr(node, "type", ty); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup("in", node, "", 0); - Delete(node); - - if (tm) { - return NewString(tm); - } else if (SwigType_ispointer(ty)) { - SwigType *cp = Copy(ty); - SwigType_del_pointer(cp); - String *inner_type = get_ffi_type(n, cp); - - if (SwigType_isfunction(cp)) { - return inner_type; - } - - SwigType *base = SwigType_base(ty); - String *base_name = SwigType_str(base, 0); - - String *str; - if (!Strcmp(base_name, "int") || !Strcmp(base_name, "float") || !Strcmp(base_name, "short") - || !Strcmp(base_name, "double") || !Strcmp(base_name, "long") || !Strcmp(base_name, "char")) { - - str = NewStringf("(ffi:c-ptr %s)", inner_type); - } else { - str = NewStringf("(ffi:c-pointer %s)", inner_type); - } - Delete(base_name); - Delete(base); - Delete(cp); - Delete(inner_type); - return str; - } else if (SwigType_isarray(ty)) { - SwigType *cp = Copy(ty); - String *array_dim = SwigType_array_getdim(ty, 0); - - if (!Strcmp(array_dim, "")) { //dimension less array convert to pointer - Delete(array_dim); - SwigType_del_array(cp); - SwigType_add_pointer(cp); - String *str = get_ffi_type(n, cp); - Delete(cp); - return str; - } else { - SwigType_pop_arrays(cp); - String *inner_type = get_ffi_type(n, cp); - Delete(cp); - - int ndim = SwigType_array_ndim(ty); - String *dimension; - if (ndim == 1) { - dimension = array_dim; - } else { - dimension = array_dim; - for (int i = 1; i < ndim; i++) { - array_dim = SwigType_array_getdim(ty, i); - Append(dimension, " "); - Append(dimension, array_dim); - Delete(array_dim); - } - String *temp = dimension; - dimension = NewStringf("(%s)", dimension); - Delete(temp); - } - String *str; - if (is_function) - str = NewStringf("(ffi:c-ptr (ffi:c-array %s %s))", inner_type, dimension); - else - str = NewStringf("(ffi:c-array %s %s)", inner_type, dimension); - - Delete(inner_type); - Delete(dimension); - return str; - } - } else if (SwigType_isfunction(ty)) { - SwigType *cp = Copy(ty); - SwigType *fn = SwigType_pop_function(cp); - String *args = NewString(""); - ParmList *pl = SwigType_function_parms(fn, n); - if (ParmList_len(pl) != 0) { - Printf(args, "(:arguments "); - } - int argnum = 0, first = 1; - for (Parm *p = pl; p; p = nextSibling(p), argnum++) { - String *argname = Getattr(p, "name"); - SwigType *argtype = Getattr(p, "type"); - String *ffitype = get_ffi_type(n, argtype); - - int tempargname = 0; - - if (!argname) { - argname = NewStringf("arg%d", argnum); - tempargname = 1; - } - if (!first) { - Printf(args, "\n\t\t"); - } - Printf(args, "(%s %s)", argname, ffitype); - first = 0; - Delete(ffitype); - if (tempargname) - Delete(argname); - } - if (ParmList_len(pl) != 0) { - Printf(args, ")\n"); /* finish arg list */ - } - String *ffitype = get_ffi_type(n, cp); - String *str = NewStringf("(ffi:c-function %s \t\t\t\t(:return-type %s))", args, ffitype); - Delete(fn); - Delete(args); - Delete(cp); - Delete(ffitype); - return str; - } - String *str = SwigType_str(ty, 0); - if (str) { - char *st = Strstr(str, "struct"); - if (st) { - st += 7; - return NewString(st); - } - char *cl = Strstr(str, "class"); - if (cl) { - cl += 6; - return NewString(cl); - } - } - return str; -} - -extern "C" Language *swig_clisp(void) { - return new CLISP(); -} diff --git a/Source/Modules/csharp.cxx b/Source/Modules/csharp.cxx index 5fef4caef..edb79e13e 100644 --- a/Source/Modules/csharp.cxx +++ b/Source/Modules/csharp.cxx @@ -901,8 +901,6 @@ public: // Get typemap for this argument if ((tm = Getattr(p, "tmap:in"))) { canThrow(n, "in", p); - Replaceall(tm, "$source", arg); /* deprecated */ - Replaceall(tm, "$target", ln); /* deprecated */ Replaceall(tm, "$arg", arg); /* deprecated? */ Replaceall(tm, "$input", arg); Setattr(p, "emit:input", arg); @@ -921,7 +919,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { canThrow(n, "check", p); - Replaceall(tm, "$target", Getattr(p, "lname")); /* deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(f->code, tm, "\n", NIL); @@ -935,7 +932,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { canThrow(n, "freearg", p); - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(cleanup, tm, "\n", NIL); @@ -949,8 +945,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { canThrow(n, "argout", p); - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* deprecated */ - Replaceall(tm, "$target", Getattr(p, "lname")); /* deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ Replaceall(tm, "$result", "jresult"); Replaceall(tm, "$input", Getattr(p, "emit:input")); @@ -982,8 +976,6 @@ public: /* Return value if necessary */ if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { canThrow(n, "out", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ - Replaceall(tm, "$target", "jresult"); /* deprecated */ Replaceall(tm, "$result", "jresult"); if (GetFlag(n, "feature:new")) @@ -1011,7 +1003,6 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { canThrow(n, "newfree", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ Printf(f->code, "%s\n", tm); } } @@ -1020,7 +1011,6 @@ public: if (!native_function_flag) { if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { canThrow(n, "ret", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ Printf(f->code, "%s\n", tm); } } diff --git a/Source/Modules/emit.cxx b/Source/Modules/emit.cxx index 7a4c2dcfb..edfa57ccd 100644 --- a/Source/Modules/emit.cxx +++ b/Source/Modules/emit.cxx @@ -74,7 +74,6 @@ void emit_parameter_variables(ParmList *l, Wrapper *f) { while (p) { tm = Getattr(p, "tmap:arginit"); if (tm) { - Replace(tm, "$target", Getattr(p, "lname"), DOH_REPLACE_ANY); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:arginit:next"); } else { @@ -87,7 +86,6 @@ void emit_parameter_variables(ParmList *l, Wrapper *f) { while (p) { tm = Getattr(p, "tmap:default"); if (tm) { - Replace(tm, "$target", Getattr(p, "lname"), DOH_REPLACE_ANY); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:default:next"); } else { @@ -116,7 +114,6 @@ void emit_attach_parmmaps(ParmList *l, Wrapper *f) { while (p) { String *tm = Getattr(p, "tmap:in"); if (tm && checkAttribute(p, "tmap:in:numinputs", "0")) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); np = Getattr(p, "tmap:in:next"); while (p && (p != np)) { diff --git a/Source/Modules/go.cxx b/Source/Modules/go.cxx index 0163f71df..c4d61e583 100644 --- a/Source/Modules/go.cxx +++ b/Source/Modules/go.cxx @@ -115,8 +115,6 @@ class GO:public Language { String *package; // SWIG module name. String *module; - // Flag for generating cgo input files. - bool cgo_flag; // Flag for generating gccgo output. bool gccgo_flag; // Prefix to use with gccgo. @@ -137,7 +135,6 @@ class GO:public Language { /* Output files */ File *f_c_begin; File *f_go_begin; - File *f_gc_begin; /* Output fragments */ File *f_c_runtime; @@ -151,9 +148,6 @@ class GO:public Language { File *f_go_header; File *f_go_wrappers; File *f_go_directors; - File *f_gc_runtime; - File *f_gc_header; - File *f_gc_wrappers; File *f_cgo_comment; File *f_cgo_comment_typedefs; @@ -201,7 +195,6 @@ class GO:public Language { public: GO():package(NULL), module(NULL), - cgo_flag(true), gccgo_flag(false), go_prefix(NULL), prefix_option(NULL), @@ -212,7 +205,6 @@ public: intgo_type_size(0), f_c_begin(NULL), f_go_begin(NULL), - f_gc_begin(NULL), f_c_runtime(NULL), f_c_header(NULL), f_c_wrappers(NULL), @@ -224,9 +216,6 @@ public: f_go_header(NULL), f_go_wrappers(NULL), f_go_directors(NULL), - f_gc_runtime(NULL), - f_gc_header(NULL), - f_gc_wrappers(NULL), f_cgo_comment(NULL), f_cgo_comment_typedefs(NULL), saw_import(false), @@ -256,6 +245,7 @@ private: SWIG_library_directory("go"); bool display_help = false; + bool saw_nocgo_flag = false; // Process command line options. for (int i = 1; i < argc; i++) { @@ -271,10 +261,9 @@ private: } } else if (strcmp(argv[i], "-cgo") == 0) { Swig_mark_arg(i); - cgo_flag = true; } else if (strcmp(argv[i], "-no-cgo") == 0) { Swig_mark_arg(i); - cgo_flag = false; + saw_nocgo_flag = true; } else if (strcmp(argv[i], "-gccgo") == 0) { Swig_mark_arg(i); gccgo_flag = true; @@ -346,6 +335,11 @@ private: } } + if (saw_nocgo_flag) { + Printf(stderr, "SWIG -go: -no-cgo option is no longer supported\n"); + SWIG_exit(EXIT_FAILURE); + } + if (gccgo_flag && !pkgpath_option && !prefix_option) { prefix_option = NewString("go"); } @@ -353,10 +347,6 @@ private: // Add preprocessor symbol to parser. Preprocessor_define("SWIGGO 1", 0); - if (cgo_flag) { - Preprocessor_define("SWIGGO_CGO 1", 0); - } - if (gccgo_flag) { Preprocessor_define("SWIGGO_GCCGO 1", 0); } @@ -458,12 +448,6 @@ private: String *go_filename = NewString(""); Printf(go_filename, "%s%s.go", SWIG_output_directory(), module); - String *gc_filename = NULL; - if (!gccgo_flag) { - gc_filename = NewString(""); - Printf(gc_filename, "%s%s_gc.c", SWIG_output_directory(), module); - } - // Generate a unique ID based on a hash of the SWIG input. swig_uint64 hash = {0, 0}; FILE *swig_input = Swig_open(swig_filename); @@ -504,14 +488,6 @@ private: SWIG_exit(EXIT_FAILURE); } - if (!gccgo_flag && !cgo_flag) { - f_gc_begin = NewFile(gc_filename, "w", SWIG_output_files()); - if (!f_gc_begin) { - FileErrorDisplay(gc_filename); - SWIG_exit(EXIT_FAILURE); - } - } - f_c_runtime = NewString(""); f_c_header = NewString(""); f_c_wrappers = NewString(""); @@ -522,15 +498,8 @@ private: f_go_header = NewString(""); f_go_wrappers = NewString(""); f_go_directors = NewString(""); - if (!gccgo_flag && !cgo_flag) { - f_gc_runtime = NewString(""); - f_gc_header = NewString(""); - f_gc_wrappers = NewString(""); - } - if (cgo_flag) { - f_cgo_comment = NewString(""); - f_cgo_comment_typedefs = NewString(""); - } + f_cgo_comment = NewString(""); + f_cgo_comment_typedefs = NewString(""); Swig_register_filebyname("begin", f_c_begin); Swig_register_filebyname("runtime", f_c_runtime); @@ -545,16 +514,8 @@ private: Swig_register_filebyname("go_header", f_go_header); Swig_register_filebyname("go_wrapper", f_go_wrappers); Swig_register_filebyname("go_director", f_go_directors); - if (!gccgo_flag && !cgo_flag) { - Swig_register_filebyname("gc_begin", f_gc_begin); - Swig_register_filebyname("gc_runtime", f_gc_runtime); - Swig_register_filebyname("gc_header", f_gc_header); - Swig_register_filebyname("gc_wrapper", f_gc_wrappers); - } - if (cgo_flag) { - Swig_register_filebyname("cgo_comment", f_cgo_comment); - Swig_register_filebyname("cgo_comment_typedefs", f_cgo_comment_typedefs); - } + Swig_register_filebyname("cgo_comment", f_cgo_comment); + Swig_register_filebyname("cgo_comment_typedefs", f_cgo_comment_typedefs); Swig_banner(f_c_begin); if (CPlusPlus) { @@ -587,34 +548,18 @@ private: Swig_banner(f_go_begin); Printf(f_go_begin, "\n// source: %s\n", swig_filename); - if (!gccgo_flag && !cgo_flag && soname) { - Swig_banner(f_gc_begin); - Printf(f_gc_begin, "\n/* source: %s */\n\n", swig_filename); - Printf(f_gc_begin, "\n/* This file should be compiled with 6c/8c. */\n"); - Printf(f_gc_begin, "#pragma dynimport _ _ \"%s\"\n", soname); - } - - if (cgo_flag) { - Printv(f_cgo_comment_typedefs, "/*\n", NULL); + Printv(f_cgo_comment_typedefs, "/*\n", NULL); - // The cgo program defines the intgo type after our function - // definitions, but we want those definitions to be able to use - // intgo also. - Printv(f_cgo_comment_typedefs, "#define intgo swig_intgo\n", NULL); - Printv(f_cgo_comment_typedefs, "typedef void *swig_voidp;\n", NULL); - } + // The cgo program defines the intgo type after our function + // definitions, but we want those definitions to be able to use + // intgo also. + Printv(f_cgo_comment_typedefs, "#define intgo swig_intgo\n", NULL); + Printv(f_cgo_comment_typedefs, "typedef void *swig_voidp;\n", NULL); // Output module initialization code. Printf(f_go_begin, "\npackage %s\n\n", getModuleName(package)); - if (gccgo_flag && !cgo_flag) { - Printf(f_go_runtime, "func SwigCgocall()\n"); - Printf(f_go_runtime, "func SwigCgocallDone()\n"); - Printf(f_go_runtime, "func SwigCgocallBack()\n"); - Printf(f_go_runtime, "func SwigCgocallBackDone()\n\n"); - } - // All the C++ wrappers should be extern "C". Printv(f_c_wrappers, "#ifdef __cplusplus\n", "extern \"C\" {\n", "#endif\n\n", NULL); @@ -686,21 +631,45 @@ private: // End the extern "C". Printv(f_c_wrappers, "#ifdef __cplusplus\n", "}\n", "#endif\n\n", NULL); - if (cgo_flag) { - // End the cgo comment. - Printv(f_cgo_comment, "#undef intgo\n", NULL); - Printv(f_cgo_comment, "*/\n", NULL); - Printv(f_cgo_comment, "import \"C\"\n", NULL); - Printv(f_cgo_comment, "\n", NULL); + // End the cgo comment. + Printv(f_cgo_comment, "#undef intgo\n", NULL); + Printv(f_cgo_comment, "*/\n", NULL); + Printv(f_cgo_comment, "import \"C\"\n", NULL); + Printv(f_cgo_comment, "\n", NULL); + + bool need_panic = false; + if (Strstr(f_c_runtime, "SWIG_contract_assert(") != 0 || Strstr(f_c_wrappers, "SWIG_contract_assert(") != 0) { + Printv(f_c_begin, "\n#define SWIG_contract_assert(expr, msg) if (!(expr)) { _swig_gopanic(msg); } else\n\n", NULL); + need_panic = true; + } + + if (!gccgo_flag && (need_panic || Strstr(f_c_runtime, "_swig_gopanic") != 0 || Strstr(f_c_wrappers, "_swig_gopanic") != 0)) { + Printv(f_go_header, "//export cgo_panic_", unique_id, "\n", NULL); + Printv(f_go_header, "func cgo_panic_", unique_id, "(p *byte) {\n", NULL); + Printv(f_go_header, "\ts := (*[1024]byte)(unsafe.Pointer(p))[:]\n", NULL); + Printv(f_go_header, "\tfor i, b := range s {\n", NULL); + Printv(f_go_header, "\t\tif b == 0 {\n", NULL); + Printv(f_go_header, "\t\t\tpanic(string(s[:i]))\n", NULL); + Printv(f_go_header, "\t\t}\n", NULL); + Printv(f_go_header, "\t}\n", NULL); + Printv(f_go_header, "\tpanic(string(s))\n", NULL); + Printv(f_go_header, "}\n\n", NULL); + + Printv(f_c_begin, "\nextern\n", NULL); + Printv(f_c_begin, "#ifdef __cplusplus\n", NULL); + Printv(f_c_begin, " \"C\"\n", NULL); + Printv(f_c_begin, "#endif\n", NULL); + Printv(f_c_begin, " void cgo_panic_", unique_id, "(const char*);\n", NULL); + Printv(f_c_begin, "static void _swig_gopanic(const char *p) {\n", NULL); + Printv(f_c_begin, " cgo_panic_", unique_id, "(p);\n", NULL); + Printv(f_c_begin, "}\n\n", NULL); } Dump(f_c_runtime, f_c_begin); Dump(f_c_wrappers, f_c_begin); Dump(f_c_init, f_c_begin); - if (cgo_flag) { - Dump(f_cgo_comment_typedefs, f_go_begin); - Dump(f_cgo_comment, f_go_begin); - } + Dump(f_cgo_comment_typedefs, f_go_begin); + Dump(f_cgo_comment, f_go_begin); Dump(f_go_imports, f_go_begin); Dump(f_go_header, f_go_begin); Dump(f_go_runtime, f_go_begin); @@ -708,12 +677,6 @@ private: if (directorsEnabled()) { Dump(f_go_directors, f_go_begin); } - if (!gccgo_flag && !cgo_flag) { - Dump(f_gc_header, f_gc_begin); - Dump(f_gc_runtime, f_gc_begin); - Dump(f_gc_wrappers, f_gc_begin); - } - Delete(f_c_runtime); Delete(f_c_header); Delete(f_c_wrappers); @@ -723,21 +686,10 @@ private: Delete(f_go_header); Delete(f_go_wrappers); Delete(f_go_directors); - if (!gccgo_flag && !cgo_flag) { - Delete(f_gc_runtime); - Delete(f_gc_header); - Delete(f_gc_wrappers); - } - if (cgo_flag) { - Delete(f_cgo_comment); - Delete(f_cgo_comment_typedefs); - } - + Delete(f_cgo_comment); + Delete(f_cgo_comment_typedefs); Delete(f_c_begin); Delete(f_go_begin); - if (!gccgo_flag && !cgo_flag) { - Delete(f_gc_begin); - } return SWIG_OK; } @@ -952,7 +904,7 @@ private: ParmList *parms = Getattr(n, "parms"); Setattr(n, "wrap:parms", parms); - int r = makeWrappers(n, name, go_name, overname, wname, NULL, parms, result, is_static); + int r = makeWrappers(n, go_name, overname, wname, NULL, parms, result, is_static); if (r != SWIG_OK) { return r; } @@ -1010,7 +962,6 @@ private: * * Write out the various function wrappers. * n: The function we are emitting. - * name: The function name. * go_name: The name of the function in Go. * overname: The overload string for overloaded function. * wname: The SWIG wrapped name--the name of the C function. @@ -1021,38 +972,15 @@ private: * is_static: Whether this is a static method or member. * ---------------------------------------------------------------------- */ - int makeWrappers(Node *n, String *name, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) { + int makeWrappers(Node *n, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) { assert(result); int ret = SWIG_OK; - if (cgo_flag) { - int r = makeCgoWrappers(n, go_name, overname, wname, base, parms, result, is_static); - if (r != SWIG_OK) { - ret = r; - } - } else { - int r = goFunctionWrapper(n, name, go_name, overname, wname, base, parms, result, is_static); - if (r != SWIG_OK) { - ret = r; - } - - if (!gccgo_flag) { - r = gcFunctionWrapper(wname); - if (r != SWIG_OK) { - ret = r; - } - r = gccFunctionWrapper(n, base, wname, parms, result); - if (r != SWIG_OK) { - ret = r; - } - } else { - r = gccgoFunctionWrapper(n, base, wname, parms, result); - if (r != SWIG_OK) { - ret = r; - } - } + int r = makeCgoWrappers(n, go_name, overname, wname, base, parms, result, is_static); + if (r != SWIG_OK) { + ret = r; } if (class_methods) { @@ -1619,415 +1547,6 @@ private: } /* ---------------------------------------------------------------------- - * goFunctionWrapper() - * - * Write out a function wrapper in Go. When not implementing a - * method, the actual code is all in C; here we just declare the C - * function. When implementing a method, we have to call the C - * function, because it will have a different name. If base is not - * NULL, then we are being called to forward a virtual method to a - * base class. - * ---------------------------------------------------------------------- */ - - int goFunctionWrapper(Node *n, String *name, String *go_name, String *overname, String *wname, List *base, ParmList *parms, SwigType *result, bool is_static) { - Wrapper *dummy = initGoTypemaps(parms); - - int parm_count = emit_num_arguments(parms); - int required_count = emit_num_required(parms); - - String *receiver = class_receiver; - if (receiver && is_static) { - receiver = NULL; - } - - String *nodetype = Getattr(n, "nodeType"); - bool is_constructor = Cmp(nodetype, "constructor") == 0; - bool is_destructor = Cmp(nodetype, "destructor") == 0; - if (is_constructor || is_destructor) { - assert(class_receiver); - assert(!base); - receiver = NULL; - } - - Swig_save("cgoGoWrapper", n, "type", "tmap:goout", NULL); - Setattr(n, "type", result); - - String *goout = goTypemapLookup("goout", n, "swig_r"); - - Swig_restore(n); - - bool add_to_interface = (interfaces && !is_constructor && !is_destructor && !is_static && !overname && checkFunctionVisibility(n, NULL)); - - bool needs_wrapper = (gccgo_flag || receiver || is_constructor || is_destructor || parm_count > required_count); - - bool has_goout = false; - if (goout) { - has_goout = true; - } - - // See whether any of the function parameters are represented by - // interface values. When calling the C++ code, we need to convert - // back to a uintptr. - Parm *p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - String *ty = Getattr(p, "type"); - if (goGetattr(p, "tmap:goargout")) { - has_goout = true; - needs_wrapper = true; - } else if (goTypeIsInterface(p, ty) || goGetattr(p, "tmap:goin")) { - needs_wrapper = true; - } - - if (paramNeedsEscape(p)) { - needs_wrapper = true; - } - - p = nextParm(p); - } - if (goTypeIsInterface(n, result) || goout != NULL) { - needs_wrapper = true; - } - - if (!gccgo_flag) { - Printv(f_go_wrappers, "var ", wname, " unsafe.Pointer\n\n", NULL); - } - - // If this is a method, first declare the C function we will call. - // If we do not need a wrapper, then we will only be writing a - // declaration. - String *wrapper_name = NULL; - if (needs_wrapper) { - wrapper_name = buildGoWrapperName(name, overname); - - if (gccgo_flag) { - Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL); - } - - bool arg = false; - Printv(f_go_wrappers, "func ", wrapper_name, "(", NULL); - if (parm_count > required_count) { - Printv(f_go_wrappers, argName(&arg), " int", NULL); - } - Parm *p = getParm(parms); - int i = 0; - if (is_destructor) { - if (parm_count > required_count) { - Printv(f_go_wrappers, ", ", NULL); - } - Printv(f_go_wrappers, argName(&arg), " uintptr", NULL); - ++i; - p = nextParm(p); - } else if (receiver && (base || !is_constructor)) { - if (parm_count > required_count) { - Printv(f_go_wrappers, ", ", NULL); - } - Printv(f_go_wrappers, argName(&arg), " ", receiver, NULL); - if (!base) { - ++i; - p = nextParm(p); - } - } - for (; i < parm_count; ++i) { - p = getParm(p); - if (i > 0 || (base && receiver) || parm_count > required_count) { - Printv(f_go_wrappers, ", ", NULL); - } - String *tm = goWrapperType(p, Getattr(p, "type"), false); - Printv(f_go_wrappers, argName(&arg), " ", tm, NULL); - Delete(tm); - p = nextParm(p); - } - Printv(f_go_wrappers, ")", NULL); - if (is_constructor) { - Printv(f_go_wrappers, " (", argName(&arg), " ", class_receiver, ")", NULL); - } else { - if (SwigType_type(result) != T_VOID) { - String *tm = goWrapperType(n, result, true); - Printv(f_go_wrappers, " (", argName(&arg), " ", tm, ")", NULL); - Delete(tm); - } - } - - if (!gccgo_flag) { - Printv(f_go_wrappers, " {\n", NULL); - if (arg) { - Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&base))\n", NULL); - } else { - Printv(f_go_wrappers, "\tvar _swig_p uintptr\n", NULL); - } - Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", wname, ", _swig_p)\n", NULL); - Printv(f_go_wrappers, "\treturn\n", NULL); - Printv(f_go_wrappers, "}", NULL); - } - - Printv(f_go_wrappers, "\n\n", NULL); - } - - // Start defining the Go function. - - if (!needs_wrapper && gccgo_flag) { - Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL); - } - - Printv(f_go_wrappers, "func ", NULL); - - p = parms; - int pi = 0; - - // Add the receiver if this is a method. - String *first = NULL; - if (receiver) { - Printv(f_go_wrappers, "(", NULL); - if (base && receiver) { - Printv(f_go_wrappers, "_swig_base", NULL); - if (first == NULL) { - first = NewString("_swig_base"); - } - } else { - Printv(f_go_wrappers, Getattr(p, "lname"), NULL); - if (first == NULL) { - first = Copy(Getattr(p, "lname")); - } - p = nextParm(p); - ++pi; - } - Printv(f_go_wrappers, " ", receiver, ") ", NULL); - } - - Printv(f_go_wrappers, go_name, NULL); - if (overname) { - Printv(f_go_wrappers, overname, NULL); - } - Printv(f_go_wrappers, "(", NULL); - - // If we are doing methods, add this function to the interface. - if (add_to_interface) { - Printv(interfaces, "\t", go_name, "(", NULL); - } - - // Write out the parameters to both the function definition and - // the interface. - - String *parm_print = NewString(""); - - for (; pi < parm_count; ++pi) { - p = getParm(p); - if (pi == 0 && is_destructor) { - String *cl = exportedName(class_name); - Printv(parm_print, Getattr(p, "lname"), " ", cl, NULL); - if (first == NULL) { - first = Copy(Getattr(p, "lname")); - } - Delete(cl); - } else { - if (pi > (receiver && !base ? 1 : 0)) { - Printv(parm_print, ", ", NULL); - } - if (pi >= required_count) { - Printv(parm_print, "_swig_args ...interface{}", NULL); - if (first == NULL) { - first = NewString("_swig_args"); - } - break; - } - Printv(parm_print, Getattr(p, "lname"), " ", NULL); - if (first == NULL) { - first = Copy(Getattr(p, "lname")); - } - String *tm = goType(p, Getattr(p, "type")); - Printv(parm_print, tm, NULL); - Delete(tm); - } - p = nextParm(p); - } - - Printv(parm_print, ")", NULL); - - // Write out the result type. - if (is_constructor) { - String *cl = exportedName(class_name); - Printv(parm_print, " (_swig_ret ", cl, ")", NULL); - if (first == NULL) { - first = NewString("_swig_ret"); - } - Delete(cl); - } else { - if (SwigType_type(result) != T_VOID) { - String *tm = goType(n, result); - Printv(parm_print, " (_swig_ret ", tm, ")", NULL); - if (first == NULL) { - first = NewString("_swig_ret"); - } - Delete(tm); - } - } - - Printv(f_go_wrappers, parm_print, NULL); - if (add_to_interface) { - Printv(interfaces, parm_print, "\n", NULL); - } - - // If this is a wrapper, we need to actually call the C function. - if (needs_wrapper) { - Printv(f_go_wrappers, " {\n", NULL); - - if (parm_count > required_count) { - Parm *p = parms; - int i; - for (i = 0; i < required_count; ++i) { - p = getParm(p); - p = nextParm(p); - } - for (; i < parm_count; ++i) { - p = getParm(p); - String *tm = goType(p, Getattr(p, "type")); - Printv(f_go_wrappers, "\tvar ", Getattr(p, "lname"), " ", tm, "\n", NULL); - Printf(f_go_wrappers, "\tif len(_swig_args) > %d {\n", i - required_count); - Printf(f_go_wrappers, "\t\t%s = _swig_args[%d].(%s)\n", Getattr(p, "lname"), i - required_count, tm); - Printv(f_go_wrappers, "\t}\n", NULL); - Delete(tm); - p = nextParm(p); - } - } - - String *call = NewString(""); - - bool need_return_var = SwigType_type(result) != T_VOID && ((gccgo_flag && is_constructor) || has_goout); - if (need_return_var) { - Printv(f_go_wrappers, "\tvar swig_r ", NULL); - if (is_constructor) { - String *cl = exportedName(class_name); - Printv(f_go_wrappers, cl, NULL); - Delete(cl); - } else { - Printv(f_go_wrappers, goImType(n, result), NULL); - } - Printv(f_go_wrappers, "\n", NULL); - } - - if (gccgo_flag) { - if (has_goout || is_constructor) { - Printv(call, "\tfunc() {\n", NULL); - } - Printv(call, "\tdefer SwigCgocallDone()\n", NULL); - Printv(call, "\tSwigCgocall()\n", NULL); - } - - Printv(call, "\t", NULL); - if (SwigType_type(result) != T_VOID) { - if (need_return_var) { - Printv(call, "swig_r = ", NULL); - } else { - Printv(call, "return ", NULL); - } - } - - Printv(call, wrapper_name, "(", NULL); - - if (parm_count > required_count) { - Printv(call, "len(_swig_args)", NULL); - } - - if (base && receiver) { - if (parm_count > required_count) { - Printv(call, ", ", NULL); - } - Printv(call, "_swig_base", NULL); - } - - Parm *p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - if (i > 0 || (base && receiver) - || parm_count > required_count) { - Printv(call, ", ", NULL); - } - - SwigType *pt = Getattr(p, "type"); - String *ln = Getattr(p, "lname"); - - String *goin = goGetattr(p, "tmap:goin"); - if (goin == NULL) { - Printv(call, ln, NULL); - if ((i == 0 && is_destructor) || ((i > 0 || !receiver || base || is_constructor) && goTypeIsInterface(p, pt))) { - Printv(call, ".Swigcptr()", NULL); - } - Setattr(p, "emit:goinput", ln); - } else { - String *ivar = NewString(""); - Printf(ivar, "_swig_i_%d", i); - String *itm = goImType(p, pt); - Printv(f_go_wrappers, "\tvar ", ivar, " ", itm, "\n", NULL); - goin = Copy(goin); - Replaceall(goin, "$input", ln); - Replaceall(goin, "$result", ivar); - Printv(f_go_wrappers, goin, "\n", NULL); - Delete(goin); - Printv(call, ivar, NULL); - Setattr(p, "emit:goinput", ivar); - } - - // If the parameter has an argout or freearg typemap, make - // sure that it escapes. - if (paramNeedsEscape(p)) { - Printv(f_go_wrappers, "\tif Swig_escape_always_false {\n", NULL); - Printv(f_go_wrappers, "\t\tSwig_escape_val = ", Getattr(p, "emit:goinput"), "\n", NULL); - Printv(f_go_wrappers, "\t}\n", NULL); - } - - p = nextParm(p); - } - Printv(call, ")\n", NULL); - - if (gccgo_flag && (has_goout || is_constructor)) { - Printv(call, "\t}()\n", NULL); - } - - Printv(f_go_wrappers, call, NULL); - Delete(call); - - goargout(parms); - - if (need_return_var) { - if (goout == NULL) { - Printv(f_go_wrappers, "\treturn swig_r\n", NULL); - } else { - String *tm = goType(n, result); - Printv(f_go_wrappers, "\tvar swig_r_1 ", tm, "\n", NULL); - Replaceall(goout, "$input", "swig_r"); - Replaceall(goout, "$result", "swig_r_1"); - Printv(f_go_wrappers, goout, "\n", NULL); - Printv(f_go_wrappers, "\treturn swig_r_1\n", NULL); - } - } - - Printv(f_go_wrappers, "}\n", NULL); - } else if (!gccgo_flag) { - // We don't need a wrapper. If we're using gccgo, the function - // declaration is all we need--it has a //extern comment to - // GCC-compiled wrapper. If we're not using gccgo, we need to - // call the GCC-compiled wrapper here. - Printv(f_go_wrappers, " {\n", NULL); - if (first == NULL) { - Printv(f_go_wrappers, "\tvar _swig_p uintptr\n", NULL); - } else { - Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&", first, "))\n", NULL); - } - Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", wname, ", _swig_p)\n", NULL); - Printv(f_go_wrappers, "\treturn\n", NULL); - Printv(f_go_wrappers, "}", NULL); - } - - Printv(f_go_wrappers, "\n", NULL); - - Delete(wrapper_name); - DelWrapper(dummy); - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- * initGoTypemaps() * * Initialize the typenames for a Go wrapper, returning a dummy @@ -2055,362 +1574,6 @@ private: return dummy; } - /* ---------------------------------------------------------------------- - * argName() - * - * A helper for goFunctionWrapper to output the first argument name - * as "base" and all others as "_". - * ---------------------------------------------------------------------- */ - - const char *argName(bool *arg) { - if (*arg) { - return "_"; - } - *arg = true; - return "base"; - } - - /* ---------------------------------------------------------------------- - * paramNeedsEscape() - * - * A helper for goFunctionWrapper that returns whether a parameter - * needs to explicitly escape. This is true if the parameter has a - * non-empty argout or freearg typemap, because in those cases the - * Go argument might be or contain a pointer. We need to ensure - * that that pointer does not point into the stack, which means that - * it needs to escape. - * ---------------------------------------------------------------------- */ - bool paramNeedsEscape(Parm *p) { - String *argout = Getattr(p, "tmap:argout"); - String *freearg = Getattr(p, "tmap:freearg"); - if ((!argout || Len(argout) == 0) && (!freearg || Len(freearg) == 0)) { - return false; - } - // If a C++ type is represented as an interface type in Go, then - // we don't care whether it escapes, because we know that the - // pointer is a C++ pointer. - if (goTypeIsInterface(p, Getattr(p, "type"))) { - return false; - } - return true; - } - - /* ---------------------------------------------------------------------- - * gcFunctionWrapper() - * - * This is used for 6g/8g, not for gccgo. Write out the function - * redirector that will be compiled with 6c/8c. This used to write - * out a real function wrapper, but that has moved into Go code. - * ---------------------------------------------------------------------- */ - - int gcFunctionWrapper(String *wname) { - Wrapper *f = NewWrapper(); - - Printv(f->def, "#pragma dynimport ", wname, " ", wname, " \"\"\n", NULL); - Printv(f->def, "#pragma cgo_import_static ", wname, "\n", NULL); - Printv(f->def, "extern void ", wname, "(void*);\n", NULL); - // Declare this as a uintptr, since it is not a pointer into the - // Go heap. - // \xc2\xb7 is UTF-8 for U+00B7 which is Unicode 'Middle Dot' - Printv(f->def, "uintptr \xc2\xb7", wname, " = (uintptr)", wname, ";\n", NULL); - - Wrapper_print(f, f_gc_wrappers); - - DelWrapper(f); - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * gccFunctionWrapper() - * - * This is used for 6g/8g, not for gccgo. Write out the function - * wrapper which will be compiled with gcc. If the base parameter - * is not NULL, this is calls the base class method rather than - * executing the SWIG wrapper code. - * ---------------------------------------------------------------------- */ - - int gccFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) { - Wrapper *f = NewWrapper(); - - Swig_save("gccFunctionWrapper", n, "parms", NULL); - - Parm *base_parm = NULL; - if (base && !isStatic(n)) { - SwigType *base_type = Copy(getClassType()); - SwigType_add_pointer(base_type); - base_parm = NewParm(base_type, NewString("arg1"), n); - set_nextSibling(base_parm, parms); - parms = base_parm; - } - - emit_parameter_variables(parms, f); - emit_attach_parmmaps(parms, f); - int parm_count = emit_num_arguments(parms); - int required_count = emit_num_required(parms); - bool needs_swigargs = false; - - emit_return_variable(n, result, f); - - // Start the function definition. - - Printv(f->def, "void\n", wname, "(void *swig_v)\n", "{\n", NULL); - - // The single function parameter is a pointer to the real argument - // values. Define the structure that it points to. - - String *swigargs = NewString("\tstruct swigargs {\n"); - - if (parm_count > required_count) { - needs_swigargs = true; - Printv(swigargs, "\t\tintgo _swig_optargc;\n", NULL); - } - - Parm *p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - - String *ln = Getattr(p, "lname"); - SwigType *pt = Getattr(p, "type"); - String *ct = gcCTypeForGoValue(p, pt, ln); - Printv(swigargs, "\t\t\t", ct, ";\n", NULL); - needs_swigargs = true; - Delete(ct); - - String *gn = NewStringf("_swig_go_%d", i); - ct = gcCTypeForGoValue(p, pt, gn); - Setattr(p, "emit:input", gn); - Wrapper_add_local(f, gn, ct); - Delete(ct); - - p = nextParm(p); - } - if (SwigType_type(result) != T_VOID) { - Printv(swigargs, "\t\tlong : 0;\n", NULL); - String *ln = NewString(Swig_cresult_name()); - String *ct = gcCTypeForGoValue(n, result, ln); - Delete(ln); - Printv(swigargs, "\t\t", ct, ";\n", NULL); - needs_swigargs = true; - Delete(ct); - - ln = NewString("_swig_go_result"); - ct = gcCTypeForGoValue(n, result, ln); - Wrapper_add_local(f, "_swig_go_result", ct); - Delete(ct); - Delete(ln); - } - Printv(swigargs, "\t} SWIGSTRUCTPACKED *swig_a = (struct swigargs *) swig_v;\n", NULL); - - // Copy the input arguments out of the structure into the Go local - // variables. - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - String *ln = Getattr(p, "lname"); - String *gn = Getattr(p, "emit:input"); - Printv(f->code, "\t", gn, " = swig_a->", ln, ";\n", NULL); - p = nextParm(p); - } - - // Apply the in typemaps. - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - String *tm = Getattr(p, "tmap:in"); - if (!tm) { - Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0)); - } else { - tm = Copy(tm); - String *gn = Getattr(p, "emit:input"); - Replaceall(tm, "$input", gn); - if (i < required_count) { - Printv(f->code, "\t", tm, "\n", NULL); - } else { - Printf(f->code, "\tif (swig_a->_swig_optargc > %d) {\n", i - required_count); - Printv(f->code, "\t\t", tm, "\n", NULL); - Printv(f->code, "\t}\n", NULL); - } - Delete(tm); - } - p = nextParm(p); - } - - Printv(f->code, "\n", NULL); - - // Do the real work of the function. - - checkConstraints(parms, f); - - emitGoAction(n, base, parms, result, f); - - argout(parms, f); - - cleanupFunction(n, f, parms); - - if (needs_swigargs) - { - Printv(f->locals, swigargs, NULL); - } - - Printv(f->code, "}\n", NULL); - - Wrapper_print(f, f_c_wrappers); - - Swig_restore(n); - - Delete(swigargs); - DelWrapper(f); - Delete(base_parm); - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * gccgoFunctionWrapper() - * - * This is used for gccgo, not 6g/8g. Write out the function - * wrapper which will be compiled with gcc. If the base parameter - * is not NULL, this is calls the base class method rather than - * executing the SWIG wrapper code. - * ---------------------------------------------------------------------- */ - - int gccgoFunctionWrapper(Node *n, List *base, String *wname, ParmList *parms, SwigType *result) { - Wrapper *f = NewWrapper(); - - Swig_save("gccgoFunctionWrapper", n, "parms", NULL); - - Parm *base_parm = NULL; - if (base && !isStatic(n)) { - SwigType *base_type = Copy(getClassType()); - SwigType_add_pointer(base_type); - base_parm = NewParm(base_type, NewString("arg1"), n); - set_nextSibling(base_parm, parms); - parms = base_parm; - } - - emit_parameter_variables(parms, f); - emit_attach_parmmaps(parms, f); - int parm_count = emit_num_arguments(parms); - int required_count = emit_num_required(parms); - - emit_return_variable(n, result, f); - - // Start the function definition. - - String *fnname = NewString(""); - Printv(fnname, "go_", wname, "(", NULL); - - if (parm_count > required_count) { - Printv(fnname, "intgo _swig_optargc", NULL); - } - - Parm *p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - SwigType *pt = Copy(Getattr(p, "type")); - if (SwigType_isarray(pt)) { - SwigType_del_array(pt); - SwigType_add_pointer(pt); - } - String *pn = NewString("g"); - Append(pn, Getattr(p, "lname")); - String *ct = gccgoCTypeForGoValue(p, pt, pn); - if (i > 0 || parm_count > required_count) { - Printv(fnname, ", ", NULL); - } - Printv(fnname, ct, NULL); - Delete(ct); - Delete(pn); - Delete(pt); - p = nextParm(p); - } - - Printv(fnname, ")", NULL); - - String *fndef = NewString(""); - if (SwigType_type(result) == T_VOID) { - Printv(fndef, "void ", fnname, NULL); - } else { - String *ct = gccgoCTypeForGoValue(n, result, fnname); - Printv(fndef, ct, NULL); - Delete(ct); - } - - Printv(f->def, fndef, " __asm__(\"", go_prefix, "_", wname, "\");\n", NULL); - - Printv(f->def, fndef, " {\n", NULL); - - Delete(fnname); - Delete(fndef); - - if (SwigType_type(result) != T_VOID) { - String *ln = NewString("_swig_go_result"); - String *ct = gccgoCTypeForGoValue(n, result, ln); - Wrapper_add_local(f, "_swig_go_result", ct); - Delete(ct); - Delete(ln); - } - - // Copy the parameters into the variables which hold their values, - // applying appropriate transformations. - - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - - String *tm = Getattr(p, "tmap:in"); - if (!tm) { - Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, - "Unable to use type %s as a function argument\n", SwigType_str(Getattr(p, "type"), 0)); - } else { - String *ln = Getattr(p, "lname"); - String *pn = NewString("g"); - Append(pn, ln); - tm = Copy(tm); - Replaceall(tm, "$input", pn); - Setattr(p, "emit:input", pn); - if (i < required_count) { - Printv(f->code, " ", tm, "\n", NULL); - } else { - Printf(f->code, " if (_swig_optargc > %d) {\n", i - required_count); - Printv(f->code, " ", tm, "\n", NULL); - Printv(f->code, " }\n", NULL); - } - Delete(tm); - } - - p = nextParm(p); - } - - Printv(f->code, "\n", NULL); - - // Do the real work of the function. - - checkConstraints(parms, f); - - emitGoAction(n, base, parms, result, f); - - argout(parms, f); - - cleanupFunction(n, f, parms); - - if (SwigType_type(result) != T_VOID) { - Printv(f->code, " return _swig_go_result;\n", NULL); - } - - Printv(f->code, "}\n", NULL); - - Wrapper_print(f, f_c_wrappers); - - Swig_restore(n); - - DelWrapper(f); - Delete(base_parm); - - return SWIG_OK; - } - /* ----------------------------------------------------------------------- * checkConstraints() * @@ -2442,10 +1605,6 @@ private: * ----------------------------------------------------------------------- */ void emitGoAction(Node *n, List *base, ParmList *parms, SwigType *result, Wrapper *f) { - if (!gccgo_flag && !cgo_flag && SwigType_type(result) != T_VOID) { - Wrapper_add_local(f, "swig_stktop", "char *swig_stktop"); - Printv(f->code, "\tswig_stktop = _swig_topofstack();\n", NULL); - } String *actioncode; if (!base || isStatic(n)) { Swig_director_emit_dynamic_cast(n, f); @@ -2455,9 +1614,6 @@ private: actioncode = NewString(""); String *current = NewString(""); - if (!gccgo_flag && !cgo_flag) { - Printv(current, "swig_a->", NULL); - } Printv(current, Getattr(parms, "lname"), NULL); int vc = 0; @@ -2493,14 +1649,6 @@ private: Delete(tm); } - if (!gccgo_flag && !cgo_flag && SwigType_type(result) != T_VOID) { - // If the function called back into the Go code, the stack might - // have been copied. We need to adjust swig_a accordingly here. - // This is what cgo does. - Printv(f->code, "\tswig_a = (struct swigargs*)((char*)swig_a + (_swig_topofstack() - swig_stktop));\n", NULL); - Printv(f->code, "\tswig_a->", Swig_cresult_name(), " = ", "_swig_go_result;\n", NULL); - } - Swig_restore(n); } @@ -2553,26 +1701,23 @@ private: } } - // When using cgo, if we need to memcpy a parameter to pass it to - // the C code, the compiler may think that the parameter is not - // live during the function call. If the garbage collector runs - // while the C/C++ function is running, the parameter may be - // freed. Force the compiler to see the parameter as live across - // the C/C++ function. - if (cgo_flag) { - int parm_count = emit_num_arguments(parms); - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - bool c_struct_type; - Delete(cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type)); - if (c_struct_type) { - Printv(f_go_wrappers, "\tif Swig_escape_always_false {\n", NULL); - Printv(f_go_wrappers, "\t\tSwig_escape_val = ", Getattr(p, "emit:goinput"), "\n", NULL); - Printv(f_go_wrappers, "\t}\n", NULL); - } - p = nextParm(p); + // If we need to memcpy a parameter to pass it to the C code, the + // compiler may think that the parameter is not live during the + // function call. If the garbage collector runs while the C/C++ + // function is running, the parameter may be freed. Force the + // compiler to see the parameter as live across the C/C++ function. + int parm_count = emit_num_arguments(parms); + p = parms; + for (int i = 0; i < parm_count; ++i) { + p = getParm(p); + bool c_struct_type; + Delete(cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type)); + if (c_struct_type) { + Printv(f_go_wrappers, "\tif Swig_escape_always_false {\n", NULL); + Printv(f_go_wrappers, "\t\tSwig_escape_val = ", Getattr(p, "emit:goinput"), "\n", NULL); + Printv(f_go_wrappers, "\t}\n", NULL); } + p = nextParm(p); } } @@ -2615,7 +1760,6 @@ private: if (GetFlag(n, "feature:new")) { String *tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0); if (tm) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NULL); Delete(tm); } @@ -2627,7 +1771,6 @@ private: /* See if there is any return cleanup code */ String *tm; if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); Delete(tm); } @@ -2895,7 +2038,7 @@ private: Append(wname, unique_id); Setattr(n, "wrap:name", wname); - int r = makeWrappers(n, sname, go_name, NULL, wname, NULL, NULL, type, true); + int r = makeWrappers(n, go_name, NULL, wname, NULL, NULL, type, true); if (r != SWIG_OK) { return r; @@ -3208,7 +2351,7 @@ private: } } - int r = makeWrappers(method, name, go_name, overname, wname, bases, Getattr(method, "parms"), result, is_static); + int r = makeWrappers(method, go_name, overname, wname, bases, Getattr(method, "parms"), result, is_static); Swig_restore(method); @@ -3283,7 +2426,7 @@ private: Append(wname, unique_id); ParmList *parms = NewParm(vt, var_name, var); String *result = NewString("void"); - int r = makeWrappers(var, mname_set, go_name, NULL, wname, bases, parms, result, false); + int r = makeWrappers(var, go_name, NULL, wname, bases, parms, result, false); if (r != SWIG_OK) { return r; } @@ -3312,7 +2455,7 @@ private: String *wname = Swig_name_wrapper(mname_get); Append(wname, unique_id); - int r = makeWrappers(var, mname_get, go_name, NULL, wname, bases, NULL, vt, false); + int r = makeWrappers(var, go_name, NULL, wname, bases, NULL, vt, false); if (r != SWIG_OK) { return r; } @@ -3428,8 +2571,7 @@ private: SwigType *result = Copy(Getattr(b.item, "classtypeobj")); SwigType_add_pointer(result); - int r = makeWrappers(n, name, go_name, NULL, wname, NULL, parm, result, - false); + int r = makeWrappers(n, go_name, NULL, wname, NULL, parm, result, false); if (r != SWIG_OK) { return r; } @@ -3677,50 +2819,17 @@ private: } if (!is_ignored) { - if (cgo_flag) { - Printv(f_cgo_comment, "extern uintptr_t ", wname, "(int", NULL); - - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - bool c_struct_type; - String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type); - Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL); - p = nextParm(p); - } - Printv(f_cgo_comment, ");\n", NULL); - } else { - // Declare the C++ wrapper. - - if (!gccgo_flag) { - Printv(f_go_wrappers, "var ", wname, " unsafe.Pointer\n\n", NULL); - } else { - Printv(f_go_wrappers, "//extern ", go_prefix, "_", wname, "\n", NULL); - } - - Printv(f_go_wrappers, "func ", fn_with_over_name, "(_swig_director int", NULL); - - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - String *tm = goWrapperType(p, Getattr(p, "type"), false); - Printv(f_go_wrappers, ", _ ", tm, NULL); - Delete(tm); - p = nextParm(p); - } - - Printv(f_go_wrappers, ") (_swig_ret ", go_type_name, ")", NULL); - - if (!gccgo_flag) { - Printv(f_go_wrappers, " {\n", NULL); - Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&_swig_director))\n", NULL); - Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", wname, ", _swig_p)\n", NULL); - Printv(f_go_wrappers, "\treturn\n", NULL); - Printv(f_go_wrappers, "}", NULL); - } + Printv(f_cgo_comment, "extern uintptr_t ", wname, "(int", NULL); - Printv(f_go_wrappers, "\n\n", NULL); + p = parms; + for (int i = 0; i < parm_count; ++i) { + p = getParm(p); + bool c_struct_type; + String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type); + Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL); + p = nextParm(p); } + Printv(f_cgo_comment, ");\n", NULL); // Write out the Go function that calls the wrapper. @@ -3740,19 +2849,10 @@ private: Printv(f_go_wrappers, "\tp := &", director_struct_name, "{0, v}\n", NULL); - if (gccgo_flag && !cgo_flag) { - Printv(f_go_wrappers, "\tdefer SwigCgocallDone()\n", NULL); - Printv(f_go_wrappers, "\tSwigCgocall()\n", NULL); - } - String *call = NewString(""); Printv(call, "\tp.", class_receiver, " = ", NULL); - if (cgo_flag) { - Printv(call, go_type_name, "(C.", wname, "(C.int(swigDirectorAdd(p))", NULL); - } else { - Printv(call, fn_with_over_name, "(swigDirectorAdd(p)", NULL); - } + Printv(call, go_type_name, "(C.", wname, "(C.int(swigDirectorAdd(p))", NULL); p = parms; for (int i = 0; i < parm_count; ++i) { @@ -3783,25 +2883,19 @@ private: Setattr(p, "emit:goinput", ivar); - if (cgo_flag) { - bool c_struct_type; - String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); - if (c_struct_type) { - Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); - } else { - Printv(call, "C.", ct, "(", ivar, ")", NULL); - } - Delete(ct); + bool c_struct_type; + String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); + if (c_struct_type) { + Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); } else { - Printv(call, ivar, NULL); + Printv(call, "C.", ct, "(", ivar, ")", NULL); } + Delete(ct); + p = nextParm(p); } - Printv(call, ")", NULL); - if (cgo_flag) { - Printv(call, ")", NULL); - } + Printv(call, "))", NULL); Printv(f_go_wrappers, call, "\n", NULL); @@ -3839,39 +2933,23 @@ private: Printv(action, ");", NULL); Setattr(n, "wrap:action", action); - if (cgo_flag) { - cgoWrapperInfo info; + cgoWrapperInfo info; - info.n = n; - info.go_name = func_name; - info.overname = overname; - info.wname = wname; - info.base = NULL; - info.parms = first_parm; - info.result = result; - info.is_static = false; - info.receiver = NULL; - info.is_constructor = true; - info.is_destructor = false; + info.n = n; + info.go_name = func_name; + info.overname = overname; + info.wname = wname; + info.base = NULL; + info.parms = first_parm; + info.result = result; + info.is_static = false; + info.receiver = NULL; + info.is_constructor = true; + info.is_destructor = false; - int r = cgoGccWrapper(&info); - if (r != SWIG_OK) { - return r; - } - } else if (!gccgo_flag) { - int r = gcFunctionWrapper(wname); - if (r != SWIG_OK) { - return r; - } - r = gccFunctionWrapper(n, NULL, wname, first_parm, result); - if (r != SWIG_OK) { - return r; - } - } else { - int r = gccgoFunctionWrapper(n, NULL, wname, first_parm, result); - if (r != SWIG_OK) { - return r; - } + int r = cgoGccWrapper(&info); + if (r != SWIG_OK) { + return r; } Swig_restore(n); @@ -3960,7 +3038,7 @@ private: Setattr(n, "wrap:parms", parms); String *result = NewString("void"); - int r = makeWrappers(n, fnname, fnname, NULL, wname, NULL, parms, result, isStatic(n)); + int r = makeWrappers(n, fnname, NULL, wname, NULL, parms, result, isStatic(n)); if (r != SWIG_OK) { return r; } @@ -4025,65 +3103,9 @@ private: * makeDirectorDestructorWrapper * * Emit the function wrapper for the destructor of a director class. - * This writes director_sig to f_c_directors and leaves the function - * unfinished. * ------------------------------------------------------------ */ void makeDirectorDestructorWrapper(String *go_name, String *director_struct_name, String *director_sig) { - if (cgo_flag) { - makeCgoDirectorDestructorWrapper(go_name, director_struct_name, director_sig); - return; - } - - Printv(f_go_wrappers, "func ", go_name, "(c int) {\n", NULL); - if (gccgo_flag) { - Printv(f_go_wrappers, "\tSwigCgocallBack()\n", NULL); - Printv(f_go_wrappers, "\tdefer SwigCgocallBackDone()\n", NULL); - } - Printv(f_go_wrappers, "\tswigDirectorLookup(c).(*", director_struct_name, ").", class_receiver, " = 0\n", NULL); - Printv(f_go_wrappers, "\tswigDirectorDelete(c)\n", NULL); - Printv(f_go_wrappers, "}\n\n", NULL); - - String *wname = NewString("_swiggo_wrap_DeleteDirector_"); - Append(wname, class_name); - - if (!gccgo_flag) { - Printv(f_c_directors, "extern \"C\" void ", wname, "(void*, int);\n", NULL); - } else { - Printv(f_c_directors, "extern \"C\" void ", wname, "(intgo) __asm__(\"", go_prefix, ".", go_name, "\");\n", NULL); - } - - Printv(f_c_directors, director_sig, NULL); - - if (!gccgo_flag) { - Printv(f_c_directors, " struct { intgo p; } SWIGSTRUCTPACKED a;\n", NULL); - Printv(f_c_directors, " a.p = go_val;\n", NULL); - Printv(f_c_directors, " crosscall2(", wname, ", &a, (int) sizeof a);\n", NULL); - - Printv(f_gc_wrappers, "#pragma dynexport ", wname, " ", wname, "\n", NULL); - Printv(f_gc_wrappers, "#pragma cgo_export_static ", wname, " ", wname, "\n", NULL); - Printv(f_gc_wrappers, "#pragma textflag 7\n", NULL); - Printv(f_gc_wrappers, "extern void \xc2\xb7", go_name, "();\n", NULL); - Printv(f_gc_wrappers, "void\n", NULL); - Printv(f_gc_wrappers, wname, "(void *a, int32 n)\n", NULL); - Printv(f_gc_wrappers, "{\n", NULL); - Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", go_name, ", a, n);\n", NULL); - Printv(f_gc_wrappers, "}\n\n", NULL); - } else { - Printv(f_c_directors, " ", wname, "(go_val);\n", NULL); - } - - Delete(wname); - } - - /* ------------------------------------------------------------ - * makeCgoDirectorDestructorWrapper - * - * When using cgo, emit the function wrapper for the destructor of a - * director class. - * ------------------------------------------------------------ */ - - void makeCgoDirectorDestructorWrapper(String *go_name, String *director_struct_name, String *director_sig) { String *wname = Copy(go_name); Append(wname, unique_id); @@ -4115,6 +3137,7 @@ private: String *name = Getattr(n, "sym:name"); if (!name) { assert(is_ignored); + (void)is_ignored; name = Getattr(n, "name"); } @@ -4252,9 +3275,7 @@ private: if (overname) { Append(callback_name, overname); } - if (cgo_flag) { - Append(callback_name, unique_id); - } + Append(callback_name, unique_id); String *upcall_name = Copy(director_struct_name); Append(upcall_name, "_upcall_"); @@ -4315,68 +3336,28 @@ private: Printv(f_go_wrappers, "}\n\n", NULL); if (!GetFlag(n, "abstract")) { - if (cgo_flag) { - Printv(f_cgo_comment, "extern ", NULL); + Printv(f_cgo_comment, "extern ", NULL); - if (SwigType_type(result) == T_VOID) { - Printv(f_cgo_comment, "void", NULL); - } else { - bool c_struct_type; - String *ret_type = cgoTypeForGoValue(n, result, &c_struct_type); - Printv(f_cgo_comment, ret_type, NULL); - Delete(ret_type); - } - - Printv(f_cgo_comment, " ", upcall_wname, "(uintptr_t", NULL); - - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - bool c_struct_type; - String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type); - Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL); - p = nextParm(p); - } - Printv(f_cgo_comment, ");\n", NULL); + if (SwigType_type(result) == T_VOID) { + Printv(f_cgo_comment, "void", NULL); } else { - // Declare the upcall function, which calls the method on - // the parent class. - - if (!gccgo_flag) { - Printv(f_go_wrappers, "var ", upcall_wname, " unsafe.Pointer\n\n", NULL); - } else { - Printv(f_go_wrappers, "//extern ", go_prefix, "_", upcall_wname, "\n", NULL); - } - - Printv(f_go_wrappers, "func ", upcall_gc_name, "(_swig_ptr ", go_type_name, NULL); - - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - String *tm = goWrapperType(p, Getattr(p, "type"), false); - Printv(f_go_wrappers, ", _ ", tm, NULL); - Delete(tm); - p = nextParm(p); - } - - Printv(f_go_wrappers, ")", NULL); - - if (SwigType_type(result) != T_VOID) { - String *tm = goWrapperType(n, result, true); - Printv(f_go_wrappers, " (_swig_ret ", tm, ")", NULL); - Delete(tm); - } + bool c_struct_type; + String *ret_type = cgoTypeForGoValue(n, result, &c_struct_type); + Printv(f_cgo_comment, ret_type, NULL); + Delete(ret_type); + } - if (!gccgo_flag) { - Printv(f_go_wrappers, " {\n", NULL); - Printv(f_go_wrappers, "\t_swig_p := uintptr(unsafe.Pointer(&_swig_ptr))\n", NULL); - Printv(f_go_wrappers, "\t_cgo_runtime_cgocall(", upcall_wname, ", _swig_p)\n", NULL); - Printv(f_go_wrappers, "\treturn\n", NULL); - Printv(f_go_wrappers, "}", NULL); - } + Printv(f_cgo_comment, " ", upcall_wname, "(uintptr_t", NULL); - Printv(f_go_wrappers, "\n\n", NULL); + p = parms; + for (int i = 0; i < parm_count; ++i) { + p = getParm(p); + bool c_struct_type; + String *ct = cgoTypeForGoValue(p, Getattr(p, "type"), &c_struct_type); + Printv(f_cgo_comment, ", ", ct, " ", Getattr(p, "lname"), NULL); + p = nextParm(p); } + Printv(f_cgo_comment, ");\n", NULL); } // Define the method on the director class in Go. @@ -4435,73 +3416,36 @@ private: String *ret_type = NULL; bool memcpy_ret = false; String *wt = NULL; - bool has_goout = false; String *goout = NULL; if (SwigType_type(result) != T_VOID) { ret_type = goImType(n, result); Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL); goout = goTypemapLookup("goout", n, "swig_r"); - if (goout) { - has_goout = true; - } - - if (cgo_flag) { - bool c_struct_type; - Delete(cgoTypeForGoValue(n, result, &c_struct_type)); - if (c_struct_type) { - memcpy_ret = true; - } - } - } - p = parms; - for (int i = 0; i < parm_count; ++i) { - p = getParm(p); - if (goGetattr(p, "tmap:goargout")) { - has_goout = true; + bool c_struct_type; + Delete(cgoTypeForGoValue(n, result, &c_struct_type)); + if (c_struct_type) { + memcpy_ret = true; } - p = nextParm(p); } String *call = NewString(""); - if (gccgo_flag && !cgo_flag) { - if (has_goout) { - Printv(call, "\tfunc() {\n", NULL); - } - Printv(call, "\tdefer SwigCgocallDone()\n", NULL); - Printv(call, "\tSwigCgocall()\n", NULL); - } - Printv(call, "\t", NULL); if (SwigType_type(result) != T_VOID) { if (memcpy_ret) { Printv(call, "swig_r_p := ", NULL); } else { - Printv(call, "swig_r = ", NULL); - if (cgo_flag) { - Printv(call, "(", ret_type, ")(", NULL); - } + Printv(call, "swig_r = (", ret_type, ")(", NULL); } - if (cgo_flag && goTypeIsInterface(n, result)) { + if (goTypeIsInterface(n, result)) { wt = goWrapperType(n, result, true); Printv(call, "(", wt, ")(", NULL); } } - if (cgo_flag) { - Printv(call, "C.", upcall_wname, NULL); - } else { - Printv(call, upcall_gc_name, NULL); - } - Printv(call, "(", NULL); - if (cgo_flag) { - Printv(call, "C.uintptr_t(", NULL); - } - Printv(call, "swig_p.", go_type_name, NULL); - if (cgo_flag) { - Printv(call, ")", NULL); - } + Printv(call, "C.", upcall_wname, "(C.uintptr_t(swig_p.", + go_type_name, ")", NULL); p = parms; for (int i = 0; i < parm_count; ++i) { @@ -4534,16 +3478,12 @@ private: Setattr(p, "emit:goinput", ivar); - if (cgo_flag) { - bool c_struct_type; - String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); - if (c_struct_type) { - Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); - } else { - Printv(call, "C.", ct, "(", ivar, ")", NULL); - } + bool c_struct_type; + String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); + if (c_struct_type) { + Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); } else { - Printv(call, ivar, NULL); + Printv(call, "C.", ct, "(", ivar, ")", NULL); } p = nextParm(p); @@ -4551,19 +3491,13 @@ private: Printv(call, ")", NULL); - if (gccgo_flag && !cgo_flag && has_goout) { - Printv(call, "\n\t}()", NULL); + if (wt) { + // Close the type conversion to the wrapper type. + Printv(call, ")", NULL); } - - if (cgo_flag) { - if (wt) { - // Close the type conversion to the wrapper type. - Printv(call, ")", NULL); - } - if (SwigType_type(result) != T_VOID && !memcpy_ret) { - // Close the type conversion of the return value. - Printv(call, ")", NULL); - } + if (SwigType_type(result) != T_VOID && !memcpy_ret) { + // Close the type conversion of the return value. + Printv(call, ")", NULL); } Printv(call, "\n", NULL); @@ -4677,41 +3611,23 @@ private: Printv(action, ");", NULL); Setattr(n, "wrap:action", action); - if (cgo_flag) { - cgoWrapperInfo info; - - info.n = n; - info.go_name = go_name; - info.overname = overname; - info.wname = upcall_wname; - info.base = NULL; - info.parms = first_parm; - info.result = result; - info.is_static = is_static; - info.receiver = NULL; - info.is_constructor = false; - info.is_destructor = false; - - int r = cgoGccWrapper(&info); - if (r != SWIG_OK) { - return r; - } - } else if (!gccgo_flag) { - // Write the upcall wrapper function. This is compiled by gc - // and calls the C++ function. - int r = gcFunctionWrapper(upcall_wname); - if (r != SWIG_OK) { - return r; - } - r = gccFunctionWrapper(n, NULL, upcall_wname, first_parm, result); - if (r != SWIG_OK) { - return r; - } - } else { - int r = gccgoFunctionWrapper(n, NULL, upcall_wname, first_parm, result); - if (r != SWIG_OK) { - return r; - } + cgoWrapperInfo info; + + info.n = n; + info.go_name = go_name; + info.overname = overname; + info.wname = upcall_wname; + info.base = NULL; + info.parms = first_parm; + info.result = result; + info.is_static = is_static; + info.receiver = NULL; + info.is_constructor = false; + info.is_destructor = false; + + int r = cgoGccWrapper(&info); + if (r != SWIG_OK) { + return r; } Delete(first_type); @@ -4756,54 +3672,30 @@ private: Printv(f_go_wrappers, "\tvar swig_r ", ret_type, "\n", NULL); goout = goTypemapLookup("goout", n, "swig_r"); - if (cgo_flag) { - bool c_struct_type; - Delete(cgoTypeForGoValue(n, result, &c_struct_type)); - if (c_struct_type) { - memcpy_ret = true; - } + bool c_struct_type; + Delete(cgoTypeForGoValue(n, result, &c_struct_type)); + if (c_struct_type) { + memcpy_ret = true; } } String *call = NewString(""); - if (gccgo_flag && !cgo_flag) { - if (goout != NULL) { - Printv(call, "\tfunc() {\n", NULL); - } - Printv(call, "\tdefer SwigCgocallDone()\n", NULL); - Printv(call, "\tSwigCgocall()\n", NULL); - } - Printv(call, "\t", NULL); if (SwigType_type(result) != T_VOID) { if (memcpy_ret) { Printv(call, "swig_r_p := ", NULL); } else { - Printv(call, "swig_r = ", NULL); - if (cgo_flag) { - Printv(call, "(", ret_type, ")(", NULL); - } + Printv(call, "swig_r = (", ret_type, ")(", NULL); } - if (cgo_flag && goTypeIsInterface(n, result)) { + if (goTypeIsInterface(n, result)) { wt = goWrapperType(n, result, true); Printv(call, "(", wt, ")(", NULL); } } - if (cgo_flag) { - Printv(call, "C.", upcall_wname, NULL); - } else { - Printv(call, upcall_gc_name, NULL); - } - Printv(call, "(", NULL); - if (cgo_flag) { - Printv(call, "C.uintptr_t(", NULL); - } - Printv(call, "p.(*", director_struct_name, ").", go_type_name, NULL); - if (cgo_flag) { - Printv(call, ")", NULL); - } + Printv(call, "C.", upcall_wname, "(C.uintptr_t(p.(*", + director_struct_name, ").", go_type_name, ")", NULL); p = parms; for (int i = 0; i < parm_count; ++i) { @@ -4834,16 +3726,12 @@ private: Setattr(p, "emit:goinput", ivar); - if (cgo_flag) { - bool c_struct_type; - String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); - if (c_struct_type) { - Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); - } else { - Printv(call, "C.", ct, "(", ivar, ")", NULL); - } + bool c_struct_type; + String *ct = cgoTypeForGoValue(p, pt, &c_struct_type); + if (c_struct_type) { + Printv(call, "*(*C.", ct, ")(unsafe.Pointer(&", ivar, "))", NULL); } else { - Printv(call, ivar, NULL); + Printv(call, "C.", ct, "(", ivar, ")", NULL); } Delete(ln); @@ -4853,19 +3741,13 @@ private: Printv(call, ")", NULL); - if (gccgo_flag && !cgo_flag && goout != NULL) { - Printv(call, "\n\t}()", NULL); + if (wt) { + // Close the type conversion to the wrapper type. + Printv(call, ")", NULL); } - - if (cgo_flag) { - if (wt) { - // Close the type conversion to the wrapper type. - Printv(call, ")", NULL); - } - if (SwigType_type(result) != T_VOID && !memcpy_ret) { - // Close the type conversion of the return value. - Printv(call, ")", NULL); - } + if (SwigType_type(result) != T_VOID && !memcpy_ret) { + // Close the type conversion of the return value. + Printv(call, ")", NULL); } Printv(call, "\n", NULL); @@ -4905,11 +3787,8 @@ private: // The Go function which invokes the method. This is called by // the C++ method on the director class. - if (cgo_flag) { - Printv(f_go_wrappers, "//export ", callback_name, "\n", NULL); - } - - Printv(f_go_wrappers, "func ", callback_name, "(swig_c int", NULL); + Printv(f_go_wrappers, "//export ", callback_name, "\n", + "func ", callback_name, "(swig_c int", NULL); p = parms; for (int i = 0; i < parm_count; ++i) { @@ -5015,23 +3894,11 @@ private: } Printv(call, "\n", NULL); - if (gccgo_flag && !cgo_flag) { - if (goout != NULL) { - Printv(f_go_wrappers, "\tfunc() {\n", NULL); - } - Printv(f_go_wrappers, "\tSwigCgocallBack()\n", NULL); - Printv(f_go_wrappers, "\tdefer SwigCgocallBackDone()\n", NULL); - } - Printv(f_go_wrappers, "\tswig_p := swigDirectorLookup(swig_c).(*", director_struct_name, ")\n", NULL); Printv(f_go_wrappers, goincode, NULL); Printv(f_go_wrappers, call, NULL); Delete(call); - if (gccgo_flag && !cgo_flag && goout != NULL) { - Printv(f_go_wrappers, "\t}()\n", NULL); - } - if (SwigType_type(result) != T_VOID) { if (goout == NULL) { Printv(f_go_wrappers, "\treturn swig_r\n", NULL); @@ -5133,241 +4000,6 @@ private: * Emit the function wrapper for a director method. * ------------------------------------------------------------ */ void makeDirectorMethodWrapper(Node *n, Wrapper *w, String *callback_name) { - if (cgo_flag) { - makeCgoDirectorMethodWrapper(n, w, callback_name); - return; - } - - ParmList *parms = Getattr(n, "wrap:parms"); - SwigType *result = Getattr(n, "type"); - - String *callback_wname = Swig_name_wrapper(callback_name); - Append(callback_wname, unique_id); - - if (!gccgo_flag) { - Printv(f_c_directors, "extern \"C\" void ", callback_wname, "(void*, int);\n", NULL); - } else { - Printv(f_c_directors, "extern \"C\" ", NULL); - - String *fnname = NewString(""); - Printv(fnname, callback_wname, "(int", NULL); - - Parm *p = parms; - while (p) { - while (checkAttribute(p, "tmap:directorin:numinputs", "0")) { - p = Getattr(p, "tmap:directorin:next"); - } - String *cg = gccgoCTypeForGoValue(p, Getattr(p, "type"), - Getattr(p, "lname")); - Printv(fnname, ", ", cg, NULL); - Delete(cg); - p = Getattr(p, "tmap:directorin:next"); - } - - Printv(fnname, ")", NULL); - - if (SwigType_type(result) == T_VOID) { - Printv(f_c_directors, "void ", fnname, NULL); - } else { - String *tm = gccgoCTypeForGoValue(n, result, fnname); - Printv(f_c_directors, tm, NULL); - Delete(tm); - } - - Delete(fnname); - - Printv(f_c_directors, " __asm__(\"", go_prefix, ".", callback_name, "\");\n", NULL); - } - - if (!gccgo_flag) { - Printv(w->code, " struct {\n", NULL); - Printv(w->code, " intgo go_val;\n", NULL); - - Parm *p = parms; - while (p) { - while (checkAttribute(p, "tmap:directorin:numinputs", "0")) { - p = Getattr(p, "tmap:directorin:next"); - } - String *ln = Getattr(p, "lname"); - String *cg = gcCTypeForGoValue(p, Getattr(p, "type"), ln); - Printv(w->code, " ", cg, ";\n", NULL); - Delete(cg); - p = Getattr(p, "tmap:directorin:next"); - } - if (SwigType_type(result) != T_VOID) { - Printv(w->code, " long : 0;\n", NULL); - String *rname = NewString(Swig_cresult_name()); - String *cg = gcCTypeForGoValue(n, result, rname); - Printv(w->code, " ", cg, ";\n", NULL); - Delete(cg); - Delete(rname); - } - - Printv(w->code, " } SWIGSTRUCTPACKED swig_a;\n", NULL); - Printv(w->code, " swig_a.go_val = go_val;\n", NULL); - - p = parms; - while (p) { - while (checkAttribute(p, "tmap:directorin:numinputs", "0")) { - p = Getattr(p, "tmap:directorin:next"); - } - String *tm = Getattr(p, "tmap:directorin"); - if (!tm) { - Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file, - line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0)); - } else { - tm = Copy(tm); - String *ln = Getattr(p, "lname"); - String *input = NewString(""); - Printv(input, "swig_a.", ln, NULL); - Setattr(p, "emit:directorinput", input); - Replaceall(tm, "$input", input); - Replaceall(tm, "$owner", "0"); - Delete(input); - Printv(w->code, "\t", tm, "\n", NULL); - Delete(tm); - } - p = Getattr(p, "tmap:directorin:next"); - } - - Printv(w->code, " crosscall2(", callback_wname, ", &swig_a, (int) sizeof swig_a);\n", NULL); - - /* Marshal outputs */ - for (p = parms; p;) { - String *tm; - if ((tm = Getattr(p, "tmap:directorargout"))) { - tm = Copy(tm); - Replaceall(tm, "$result", "jresult"); - Replaceall(tm, "$input", Getattr(p, "emit:directorinput")); - Printv(w->code, tm, "\n", NIL); - Delete(tm); - p = Getattr(p, "tmap:directorargout:next"); - } else { - p = nextSibling(p); - } - } - - if (SwigType_type(result) != T_VOID) { - String *result_str = NewString("c_result"); - String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL); - if (!tm) { - Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number, - "Unable to use type %s as director method result\n", SwigType_str(result, 0)); - } else { - static const String *swig_a_result = NewStringf("swig_a.%s", Swig_cresult_name()); - Replaceall(tm, "$input", swig_a_result); - Replaceall(tm, "$result", "c_result"); - Printv(w->code, " ", tm, "\n", NULL); - String *retstr = SwigType_rcaststr(result, "c_result"); - Printv(w->code, " return ", retstr, ";\n", NULL); - Delete(retstr); - Delete(tm); - } - Delete(result_str); - } - - // The C wrapper code which calls the Go function. - Printv(f_gc_wrappers, "#pragma dynexport ", callback_wname, " ", callback_wname, "\n", NULL); - Printv(f_gc_wrappers, "#pragma cgo_export_static ", callback_wname, " ", callback_wname, "\n", NULL); - Printv(f_gc_wrappers, "#pragma textflag 7\n", NULL); - Printv(f_gc_wrappers, "extern void \xc2\xb7", callback_name, "();\n", NULL); - Printv(f_gc_wrappers, "void\n", NULL); - Printv(f_gc_wrappers, callback_wname, "(void *a, int32 n)\n", NULL); - Printv(f_gc_wrappers, "{\n", NULL); - Printv(f_gc_wrappers, "\truntime\xc2\xb7" "cgocallback(\xc2\xb7", callback_name, ", a, n);\n", NULL); - Printv(f_gc_wrappers, "}\n\n", NULL); - } else { - if (SwigType_type(result) != T_VOID) { - String *r = NewString(Swig_cresult_name()); - String *tm = gccgoCTypeForGoValue(n, result, r); - Wrapper_add_local(w, r, tm); - Delete(tm); - Delete(r); - } - - String *args = NewString(""); - - Parm *p = parms; - while (p) { - while (checkAttribute(p, "tmap:directorin:numinputs", "0")) { - p = Getattr(p, "tmap:directorin:next"); - } - - String *pn = NewString("g"); - Append(pn, Getattr(p, "lname")); - Setattr(p, "emit:directorinput", pn); - - String *tm = gccgoCTypeForGoValue(n, Getattr(p, "type"), pn); - Wrapper_add_local(w, pn, tm); - Delete(tm); - - tm = Getattr(p, "tmap:directorin"); - if (!tm) { - Swig_warning(WARN_TYPEMAP_DIRECTORIN_UNDEF, input_file, - line_number, "Unable to use type %s as director method argument\n", SwigType_str(Getattr(p, "type"), 0)); - } else { - tm = Copy(tm); - Replaceall(tm, "$input", pn); - Replaceall(tm, "$owner", 0); - Printv(w->code, " ", tm, "\n", NULL); - Delete(tm); - - Printv(args, ", ", pn, NULL); - } - - p = Getattr(p, "tmap:directorin:next"); - } - - Printv(w->code, " ", NULL); - if (SwigType_type(result) != T_VOID) { - Printv(w->code, Swig_cresult_name(), " = ", NULL); - } - Printv(w->code, callback_wname, "(go_val", args, ");\n", NULL); - - /* Marshal outputs */ - for (p = parms; p;) { - String *tm; - if ((tm = Getattr(p, "tmap:directorargout"))) { - tm = Copy(tm); - Replaceall(tm, "$result", "jresult"); - Replaceall(tm, "$input", Getattr(p, "emit:directorinput")); - Printv(w->code, tm, "\n", NIL); - Delete(tm); - p = Getattr(p, "tmap:directorargout:next"); - } else { - p = nextSibling(p); - } - } - - if (SwigType_type(result) != T_VOID) { - String *result_str = NewString("c_result"); - String *tm = Swig_typemap_lookup("directorout", n, result_str, NULL); - if (!tm) { - Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number, - "Unable to use type %s as director method result\n", SwigType_str(result, 0)); - } else { - Replaceall(tm, "$input", Swig_cresult_name()); - Replaceall(tm, "$result", "c_result"); - Printv(w->code, " ", tm, "\n", NULL); - String *retstr = SwigType_rcaststr(result, "c_result"); - Printv(w->code, " return ", retstr, ";\n", NULL); - Delete(retstr); - Delete(tm); - } - Delete(result_str); - } - } - - Delete(callback_wname); - } - - /* ------------------------------------------------------------ - * makeDirectorMethodWrapper - * - * Emit the function wrapper for a director method for cgo. - * ------------------------------------------------------------ */ - - void makeCgoDirectorMethodWrapper(Node *n, Wrapper *w, String *callback_name) { ParmList *parms = Getattr(n, "wrap:parms"); SwigType *result = Getattr(n, "type"); @@ -6085,6 +4717,7 @@ private: } bool r = addSymbol(name, n, scope) ? true : false; assert(r); + (void)r; return true; } diff --git a/Source/Modules/guile.cxx b/Source/Modules/guile.cxx index 461c69e50..d7d3da8fc 100644 --- a/Source/Modules/guile.cxx +++ b/Source/Modules/guile.cxx @@ -719,7 +719,6 @@ public: sprintf(source, "argv[%d]", i); else sprintf(source, "s_%d", i); - String *target = Getattr(p, "lname"); if (!args_passed_as_array) { if (i != 0) @@ -730,8 +729,6 @@ public: Printf(f->code, " if (%s != SCM_UNDEFINED) {\n", source); } if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", target); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); Printv(f->code, tm, "\n", NIL); @@ -794,7 +791,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -807,8 +803,6 @@ public: String *returns_argout = NewString(""); for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", Getattr(p, "lname")); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(outarg, tm, "\n", NIL); @@ -828,7 +822,6 @@ public: /* Insert cleanup code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(cleanup, tm, "\n", NIL); p = Getattr(p, "tmap:freearg:next"); @@ -859,8 +852,6 @@ public: // Now have return value, figure out what to do with it. if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { Replaceall(tm, "$result", "gswig_result"); - Replaceall(tm, "$target", "gswig_result"); - Replaceall(tm, "$source", Swig_cresult_name()); if (GetFlag(n, "feature:new")) Replaceall(tm, "$owner", "1"); else @@ -898,13 +889,11 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NIL); } } // Free any memory allocated by the function being wrapped.. if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NIL); } // Wrap things up (in a manner of speaking) @@ -1141,9 +1130,7 @@ public: /* Check for a setting of the variable value */ Printf(f->code, "if (s_0 != SCM_UNDEFINED) {\n"); if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "s_0"); Replaceall(tm, "$input", "s_0"); - Replaceall(tm, "$target", name); /* Printv(f->code,tm,"\n",NIL); */ emit_action_code(n, f->code, tm); } else { @@ -1155,8 +1142,6 @@ public: // of evaluating or setting) if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "gswig_result"); Replaceall(tm, "$result", "gswig_result"); /* Printv(f->code,tm,"\n",NIL); */ emit_action_code(n, f->code, tm); @@ -1334,9 +1319,7 @@ public: // See if there's a typemap if ((tm = Swig_typemap_lookup("constant", n, name, 0))) { - Replaceall(tm, "$source", value); Replaceall(tm, "$value", value); - Replaceall(tm, "$target", name); Printv(f_header, tm, "\n", NIL); } else { // Create variable and assign it a value diff --git a/Source/Modules/java.cxx b/Source/Modules/java.cxx index 7c8bed480..444fe02d1 100644 --- a/Source/Modules/java.cxx +++ b/Source/Modules/java.cxx @@ -196,7 +196,7 @@ public: String *name = Getattr(n, "name") ? Getattr(n, "name") : NewString("<unnamed>"); Swig_warning(WARN_JAVA_NSPACE_WITHOUT_PACKAGE, Getfile(n), Getline(n), "The nspace feature is used on '%s' without -package. " - "The generated code may not compile as Java does not support types declared in a named package accessing types declared in an unnamed package.\n", name); + "The generated code may not compile as Java does not support types declared in a named package accessing types declared in an unnamed package.\n", SwigType_namestr(name)); } } @@ -1001,8 +1001,6 @@ public: // Get typemap for this argument if ((tm = Getattr(p, "tmap:in"))) { addThrows(n, "tmap:in", p); - Replaceall(tm, "$source", arg); /* deprecated */ - Replaceall(tm, "$target", ln); /* deprecated */ Replaceall(tm, "$arg", arg); /* deprecated? */ Replaceall(tm, "$input", arg); Setattr(p, "emit:input", arg); @@ -1027,7 +1025,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { addThrows(n, "tmap:check", p); - Replaceall(tm, "$target", Getattr(p, "lname")); /* deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(f->code, tm, "\n", NIL); @@ -1041,7 +1038,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { addThrows(n, "tmap:freearg", p); - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(cleanup, tm, "\n", NIL); @@ -1055,8 +1051,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { addThrows(n, "tmap:argout", p); - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* deprecated */ - Replaceall(tm, "$target", Getattr(p, "lname")); /* deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ Replaceall(tm, "$result", "jresult"); Replaceall(tm, "$input", Getattr(p, "emit:input")); @@ -1090,8 +1084,6 @@ public: /* Return value if necessary */ if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { addThrows(n, "tmap:out", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ - Replaceall(tm, "$target", "jresult"); /* deprecated */ Replaceall(tm, "$result", "jresult"); if (GetFlag(n, "feature:new")) @@ -1118,7 +1110,6 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { addThrows(n, "tmap:newfree", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ Printf(f->code, "%s\n", tm); } } @@ -1127,7 +1118,6 @@ public: if (!native_function_flag) { if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { addThrows(n, "tmap:ret", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ Printf(f->code, "%s\n", tm); } } diff --git a/Source/Modules/javascript.cxx b/Source/Modules/javascript.cxx index 98f6d801f..431dd4744 100644 --- a/Source/Modules/javascript.cxx +++ b/Source/Modules/javascript.cxx @@ -727,7 +727,7 @@ Node *JSEmitter::getBaseClass(Node *n) { /* ----------------------------------------------------------------------------- * JSEmitter::emitWrapperFunction() : dispatches emitter functions. * - * This allows to have small sized, dedicated emitting functions. + * This allows having small sized, dedicated emitting functions. * All state dependent branching is done here. * ----------------------------------------------------------------------------- */ @@ -1255,7 +1255,7 @@ int JSEmitter::emitFunctionDispatcher(Node *n, bool /*is_member */ ) { // Note: this dispatcher function gets called after the last overloaded function has been created. // At this time, n.wrap:name contains the name of the last wrapper function. // To get a valid function name for the dispatcher function we take the last wrapper name and - // substract the extension "sym:overname", + // subtract the extension "sym:overname", String *wrap_name = NewString(Getattr(n, "wrap:name")); String *overname = Getattr(n, "sym:overname"); diff --git a/Source/Modules/lang.cxx b/Source/Modules/lang.cxx index f7979b611..66aebdea1 100644 --- a/Source/Modules/lang.cxx +++ b/Source/Modules/lang.cxx @@ -722,18 +722,18 @@ int Language::typemapDirective(Node *n) { String *code = Getattr(n, "code"); Parm *kwargs = Getattr(n, "kwargs"); Node *items = firstChild(n); - static int namewarn = 0; + static int nameerror = 0; if (code && (Strstr(code, "$source") || (Strstr(code, "$target")))) { - Swig_warning(WARN_TYPEMAP_SOURCETARGET, Getfile(n), Getline(n), "Deprecated typemap feature ($source/$target).\n"); - if (!namewarn) { - Swig_warning(WARN_TYPEMAP_SOURCETARGET, Getfile(n), Getline(n), "The use of $source and $target in a typemap declaration is deprecated.\n\ + Swig_error(Getfile(n), Getline(n), "Obsolete typemap feature ($source/$target).\n"); + if (!nameerror) { + Swig_error(Getfile(n), Getline(n), "The use of $source and $target in a typemap declaration is no longer supported.\n\ For typemaps related to argument input (in,ignore,default,arginit,check), replace\n\ $source by $input and $target by $1. For typemaps related to return values (out,\n\ argout,ret,except), replace $source by $1 and $target by $result. See the file\n\ Doc/Manual/Typemaps.html for complete details.\n"); - namewarn = 1; + nameerror = 1; } } @@ -1481,8 +1481,6 @@ int Language::membervariableHandler(Node *n) { } else { String *pname0 = Swig_cparm_name(0, 0); String *pname1 = Swig_cparm_name(0, 1); - Replace(tm, "$source", pname1, DOH_REPLACE_ANY); - Replace(tm, "$target", target, DOH_REPLACE_ANY); Replace(tm, "$input", pname1, DOH_REPLACE_ANY); Replace(tm, "$self", pname0, DOH_REPLACE_ANY); Setattr(n, "wrap:action", tm); @@ -3049,8 +3047,6 @@ int Language::variableWrapper(Node *n) { } } else { String *pname0 = Swig_cparm_name(0, 0); - Replace(tm, "$source", pname0, DOH_REPLACE_ANY); - Replace(tm, "$target", name, DOH_REPLACE_ANY); Replace(tm, "$input", pname0, DOH_REPLACE_ANY); Setattr(n, "wrap:action", tm); Delete(tm); diff --git a/Source/Modules/lua.cxx b/Source/Modules/lua.cxx index 188b11c2b..4ba9cb8c3 100644 --- a/Source/Modules/lua.cxx +++ b/Source/Modules/lua.cxx @@ -613,13 +613,9 @@ public: } SwigType *pt = Getattr(p, "type"); - String *ln = Getattr(p, "lname"); - /* Look for an input typemap */ sprintf(source, "%d", i + 1); if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", ln); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) { @@ -678,7 +674,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -690,7 +685,6 @@ public: String *cleanup = NewString(""); for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); p = Getattr(p, "tmap:freearg:next"); } else { @@ -709,8 +703,6 @@ public: // returnval+=GetInt(p,"tmap:argout:numoutputs"); // } // else returnval++; - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", Swig_cresult_name()); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(outarg, tm, "\n", NIL); @@ -740,7 +732,6 @@ public: // returnval+=GetInt(tm,"numoutputs"); // } // else returnval++; - Replaceall(tm, "$source", Swig_cresult_name()); if (GetFlag(n, "feature:new")) { Replaceall(tm, "$owner", "1"); } else { @@ -762,14 +753,12 @@ public: /* Look to see if there is any newfree cleanup code */ if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } } /* See if there is any return cleanup code */ if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } @@ -1002,6 +991,7 @@ public: // REPORT("variableWrapper", n); String *lua_name = Getattr(n, "lua:name"); assert(lua_name); + (void)lua_name; current[VARIABLE] = true; // let SWIG generate the wrappers int result = Language::variableWrapper(n); @@ -1073,14 +1063,10 @@ public: } if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", lua_name); Replaceall(tm, "$value", value); Replaceall(tm, "$nsname", nsname); registerConstant(luaCurrentSymbolNSpace(), tm); } else if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", lua_name); Replaceall(tm, "$value", value); Replaceall(tm, "$nsname", nsname); Printf(f_init, "%s\n", tm); @@ -1109,8 +1095,6 @@ public: Setattr(n_v2, "sym:name", lua_name_v2); tm_v2 = Swig_typemap_lookup("consttab", n_v2, name, 0); if (tm_v2) { - Replaceall(tm_v2, "$source", value); - Replaceall(tm_v2, "$target", lua_name_v2); Replaceall(tm_v2, "$value", value); Replaceall(tm_v2, "$nsname", nsname); registerConstant(getNSpace(), tm_v2); @@ -1122,8 +1106,6 @@ public: Swig_restore(n); return SWIG_ERROR; } - Replaceall(tm_v2, "$source", value); - Replaceall(tm_v2, "$target", lua_name_v2); Replaceall(tm_v2, "$value", value); Replaceall(tm_v2, "$nsname", nsname); Printf(f_init, "%s\n", tm_v2); diff --git a/Source/Modules/modula3.cxx b/Source/Modules/modula3.cxx deleted file mode 100644 index c606845ea..000000000 --- a/Source/Modules/modula3.cxx +++ /dev/null @@ -1,3931 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * modula3.cxx - * - * Modula3 language module for SWIG. - * ----------------------------------------------------------------------------- */ - -/* - Text formatted with - indent -sob -br -ce -nut -npsl -*/ - -/* - Report: - - It's not a good concept to use member variables or global variables - for passing parameters to functions. - It's not a good concept to use functions of superclasses for specific services. - E.g. For SWIG this means: Generating accessor functions for member variables - is the most common but no general task to be processed in membervariableHandler. - Better provide a service function which generates accessor function code - and equip this service function with all parameters needed for input (parse node) - and output (generated code). - - How can I make globalvariableHandler not to generate - interface functions to two accessor functions - (that don't exist) ? - - How can I generate a typemap that turns every C reference argument into - its Modula 3 counterpart, that is - void test(Complex &z); - PROCEDURE test(VAR z:Complex); - - neither $*n_mangle nor $*n_type nor $*n_ltype return the type without - pointer converted to Modula3 equivalent, - $*n_mangle is the variant closest to what I expect - - using a typemap like - typemap(m3wrapintype) int * %{VAR $1_name: INTEGER%} - has the advantages: - - one C parameter can be turned into multiple M3 parameters - - the argument can be renamed - - using typemaps like - typemap(m3wrapinmode) int * "VAR" - typemap(m3wrapintype) int * "INTEGER" - has the advantages: - - multiple parameters with same type and default value can be bundled - - more conform to the other language modules - - Where takes the reduction of multi-typemaps place? - How can I preserve all parameters for functions of the intermediary class? - The answer is Getattrs(n,"tmap:m3rawintype:next") - - Char() can be used to transform a String to (char *) - which can be used for output with printf - - What is the while (checkAttribute()) loop in functionWrapper good for? - Appearently for skipping (numinputs=0) typemaps. - - SWIGTYPE const * - typemap is ignored, whereas - SWIGTYPE * - typemap is invoked, why? - Had it been (const SWIGTYPE *) instead? - - enumeration items should definitely be equipped - with its plain numerical value - One could add tag 'numvalue' in CParse/parser.y, - but it is still possible that someone declares an - enumeration using a symbolic constant. - I have quickly hacked - that the successive number is assigned - if "enumvalue" has suffix "+1". - The ultimate solution would be to generate a C program - which includes the header and outputs all constants. - This program might be compiled and run - by 'make' or by SWIG and the resulting output is fed back to SWIG. - - It's a bad idea to interpret feature value "" - 'disable feature' because the value "" - might be sensible in case of feature:modula3:oldprefix. - - What's the difference between "sym:name" and "name" ? - "name" is the original name and - "sym:name" is probably modified by the user using %rename - - Is it possible for 'configure' to find out if m3pp is installed - and to invoke it for generated Modula3 files? - - It would be better to separate an arguments purpose and its name, - because an output variable with name "OUTPUT" is not very descriptive. - In case of PLPlot this could be solved by typedefs - that assign special purposes to the array types. - - Can one interpret $n_basetype as the identifier matched with SWIGTYPE ? - - SWIG's odds: - - arguments of type (Node *) for SWIG functions - should be most often better (const Node *): - Swig_symbol_qualified, Getattr, nodeType, parentNode - - unique identifier style instead of - NewString, Getattr, firstChild - - 'class'.name is qualified, - 'enum'.name and 'enumitem'.name is not - - Swig_symbol_qualified() returns NIL for enumeration nodes - - - Is there a function that creates a C representation of a SWIG type string? - - ToDo: - - create WeakRefs only for resources returned by function marked with %newobject - -> part of output conversion - - clean typemap conception - - should a multi-typemap for m3wrapouttype skip the corresponding input parameters? - when yes - How to handle inout-arguments? In this case like in-argument. - - C++ classes - - C++ exceptions - - allow for moving RECORD and OBJECT definitions - to separate files, with the main type called T - - call-back functions - - special option: fast access to class members by pointer arithmetic, - member offsets can be determined by a C++ program that print them. - - emit enumeration definitions when its first item is declared, - currently enumerations are emitted at the beginning of the file - - Done: - - addThrow should convert the typemap by itself - - not possible because routine for attaching mapped types to parameter nodes - won't work for the function node - - turning error codes into exceptions - -> part of output value checking - - create WeakRefs for resources allocated by the library - -> part of output conversion - - TRY..FINALLY..END; can be omitted - - if there is no m3wrapfreearg - - no exception can be raised in the body (empty RAISES) list -*/ - -#include "swigmod.h" - -#include <limits.h> // for INT_MAX -#include <ctype.h> - -#define USAGE_ARG_DIR "m3wrapargdir typemap expect values: in, out, inout\n" - -class MODULA3:public Language { -public: - enum block_type { no_block, constant, variable, blocktype, revelation }; - -private: - struct M3File { - String *f; - Hash *import; - block_type bt; - /* VC++ 6 doesn't allow the access to 'no_block' - if it is a private member of MODULA3 class */ - M3File():f(NewString("")), import(NewHash()), bt(no_block) { - } - ~M3File() { - Delete(f); - Delete(import); - } - - /* ----------------------------------------------------------------------------- - * enterBlock() - * - * Make sure that a given declaration is written to the right declaration block, - * that is constants are written after "CONST" and so on ... - * ----------------------------------------------------------------------------- */ - void enterBlock(block_type newbt) { - static const char *ident[] = { "", "\nCONST\n", "\nVAR\n", "\nTYPE\n", "\nREVEAL\n" }; -#ifdef DEBUG - if ((bt < 0) || (4 < bt)) { - printf("bt %d out of range\n", bt); - } -#endif - if (newbt != bt) { - Append(f, ident[newbt]); - bt = newbt; - } - } - - }; - - static const char *usage; - const String *empty_string; - - Hash *swig_types_hash; - File *f_begin; - File *f_runtime; - File *f_header; - File *f_wrappers; - File *f_init; - - bool proxy_flag; // Flag for generating proxy classes - bool have_default_constructor_flag; - bool native_function_flag; // Flag for when wrapping a native function - bool enum_constant_flag; // Flag for when wrapping an enum or constant - bool static_flag; // Flag for when wrapping a static functions or member variables - bool variable_wrapper_flag; // Flag for when wrapping a nonstatic member variable - bool wrapping_member_flag; // Flag for when wrapping a member variable/enum/const - bool global_variable_flag; // Flag for when wrapping a global variable - bool old_variable_names; // Flag for old style variable names in the intermediary class - bool unsafe_module; - - String *m3raw_name; // raw interface name - M3File m3raw_intf; // raw interface - M3File m3raw_impl; // raw implementation (usually empty) - String *m3wrap_name; // wrapper module - M3File m3wrap_intf; - M3File m3wrap_impl; - String *m3makefile; - String *targetlibrary; - String *proxy_class_def; - String *proxy_class_code; - String *proxy_class_name; - String *variable_name; //Name of a variable being wrapped - String *variable_type; //Type of this variable - Hash *enumeration_coll; //Collection of all enumerations. - /* The items are nodes with members: - "items" - hash of with key 'itemname' and content 'itemvalue' - "max" - maximum value in item list - */ - String *constant_values; - String *constantfilename; - String *renamefilename; - String *typemapfilename; - String *m3raw_imports; //intermediary class imports from %pragma - String *module_imports; //module imports from %pragma - String *m3raw_baseclass; //inheritance for intermediary class class from %pragma - String *module_baseclass; //inheritance for module class from %pragma - String *m3raw_interfaces; //interfaces for intermediary class class from %pragma - String *module_interfaces; //interfaces for module class from %pragma - String *m3raw_class_modifiers; //class modifiers for intermediary class overridden by %pragma - String *m3wrap_modifiers; //class modifiers for module class overridden by %pragma - String *upcasts_code; //C++ casts for inheritance hierarchies C++ code - String *m3raw_cppcasts_code; //C++ casts up inheritance hierarchies intermediary class code - String *destructor_call; //C++ destructor call if any - String *outfile; - - enum type_additions { none, pointer, reference }; - -public: - - /* ----------------------------------------------------------------------------- - * MODULA3() - * ----------------------------------------------------------------------------- */ - -MODULA3(): - empty_string(NewString("")), - swig_types_hash(NULL), - f_begin(NULL), - f_runtime(NULL), - f_header(NULL), - f_wrappers(NULL), - f_init(NULL), - proxy_flag(true), - have_default_constructor_flag(false), - native_function_flag(false), - enum_constant_flag(false), - static_flag(false), - variable_wrapper_flag(false), - wrapping_member_flag(false), - global_variable_flag(false), - old_variable_names(false), - unsafe_module(false), - m3raw_name(NULL), - m3raw_intf(), - m3raw_impl(), - m3wrap_name(NULL), - m3wrap_intf(), - m3wrap_impl(), - m3makefile(NULL), - targetlibrary(NULL), - proxy_class_def(NULL), - proxy_class_code(NULL), - proxy_class_name(NULL), - variable_name(NULL), - variable_type(NULL), - enumeration_coll(NULL), - constant_values(NULL), - constantfilename(NULL), - renamefilename(NULL), - typemapfilename(NULL), - m3raw_imports(NULL), - module_imports(NULL), - m3raw_baseclass(NULL), - module_baseclass(NULL), - m3raw_interfaces(NULL), - module_interfaces(NULL), - m3raw_class_modifiers(NULL), - m3wrap_modifiers(NULL), - upcasts_code(NULL), - m3raw_cppcasts_code(NULL), - destructor_call(NULL), - outfile(NULL) { - } - - /************** some utility functions ***************/ - - /* ----------------------------------------------------------------------------- - * getMappedType() - * - * Return the type of 'p' mapped by 'map'. - * Print a standard warning if 'p' can't be mapped. - * ----------------------------------------------------------------------------- */ - - String *getMappedType(Node *p, const char *map) { - String *mapattr = NewString("tmap:"); - Append(mapattr, map); - - String *tm = Getattr(p, mapattr); - if (tm == NIL) { - Swig_warning(WARN_MODULA3_TYPEMAP_TYPE_UNDEF, input_file, line_number, - "No '%s' typemap defined for type '%s'\n", map, SwigType_str(Getattr(p, "type"), 0)); - } - Delete(mapattr); - return tm; - } - - /* ----------------------------------------------------------------------------- - * getMappedTypeNew() - * - * Similar to getMappedType but uses Swig_type_lookup_new. - * ----------------------------------------------------------------------------- */ - - String *getMappedTypeNew(Node *n, const char *map, const char *lname = "", bool warn = true) { - String *tm = Swig_typemap_lookup(map, n, lname, 0); - if ((tm == NIL) && warn) { - Swig_warning(WARN_MODULA3_TYPEMAP_TYPE_UNDEF, input_file, line_number, - "No '%s' typemap defined for type '%s'\n", map, SwigType_str(Getattr(n, "type"), 0)); - } - return tm; - } - - /* ----------------------------------------------------------------------------- - * attachMappedType() - * - * Obtain the type mapped by 'map' and attach it to the node - * ----------------------------------------------------------------------------- */ - - void attachMappedType(Node *n, const char *map, const char *lname = "") { - String *tm = Swig_typemap_lookup(map, n, lname, 0); - if (tm != NIL) { - String *attr = NewStringf("tmap:%s", map); - Setattr(n, attr, tm); - Delete(attr); - } - } - - /* ----------------------------------------------------------------------------- - * skipIgnored() - * - * Skip all parameters that have 'numinputs=0' - * with respect to a given typemap. - * ----------------------------------------------------------------------------- */ - - Node *skipIgnored(Node *p, const char *map) { - String *niattr = NewStringf("tmap:%s:numinputs", map); - String *nextattr = NewStringf("tmap:%s:next", map); - - while ((p != NIL) && checkAttribute(p, niattr, "0")) { - p = Getattr(p, nextattr); - } - - Delete(nextattr); - Delete(niattr); - return p; - } - - /* ----------------------------------------------------------------------------- - * isInParam() - * isOutParam() - * - * Check if the parameter is intended for input or for output. - * ----------------------------------------------------------------------------- */ - - bool isInParam(Node *p) { - String *dir = Getattr(p, "tmap:m3wrapargdir"); -//printf("dir for %s: %s\n", Char(Getattr(p,"name")), Char(dir)); - if ((dir == NIL) || (Strcmp(dir, "in") == 0) - || (Strcmp(dir, "inout") == 0)) { - return true; - } else if (Strcmp(dir, "out") == 0) { - return false; - } else { - printf("%s", USAGE_ARG_DIR); - return false; - } - } - - bool isOutParam(Node *p) { - String *dir = Getattr(p, "tmap:m3wrapargdir"); - if ((dir == NIL) || (Strcmp(dir, "in") == 0)) { - return false; - } else if ((Strcmp(dir, "out") == 0) || (Strcmp(dir, "inout") == 0)) { - return true; - } else { - printf("%s", USAGE_ARG_DIR); - return false; - } - } - - /* ----------------------------------------------------------------------------- - * printAttrs() - * - * For debugging: Show all attributes of a node and their values. - * ----------------------------------------------------------------------------- */ - void printAttrs(Node *n) { - Iterator it; - for (it = First(n); it.key != NIL; it = Next(it)) { - printf("%s = %s\n", Char(it.key), Char(Getattr(n, it.key))); - } - } - - /* ----------------------------------------------------------------------------- - * hasPrefix() - * - * Check if a string have a given prefix. - * ----------------------------------------------------------------------------- */ - bool hasPrefix(const String *str, const String *prefix) { - int len_prefix = Len(prefix); - return (Len(str) > len_prefix) - && (Strncmp(str, prefix, len_prefix) == 0); - } - - /* ----------------------------------------------------------------------------- - * getQualifiedName() - * - * Return fully qualified identifier of n. - * ----------------------------------------------------------------------------- */ -#if 0 - // Swig_symbol_qualified returns NIL for enumeration nodes - String *getQualifiedName(Node *n) { - String *qual = Swig_symbol_qualified(n); - String *name = Getattr(n, "name"); - if (hasContent(qual)) { - return NewStringf("%s::%s", qual, name); - } else { - return name; - } - } -#else - String *getQualifiedName(Node *n) { - String *name = Copy(Getattr(n, "name")); - n = parentNode(n); - while (n != NIL) { - const String *type = nodeType(n); - if ((Strcmp(type, "class") == 0) || (Strcmp(type, "struct") == 0) || (Strcmp(type, "namespace") == 0)) { - String *newname = NewStringf("%s::%s", Getattr(n, "name"), name); - Delete(name); - //name = newname; - // Hmpf, the class name is already qualified. - return newname; - } - n = parentNode(n); - } - //printf("qualified name: %s\n", Char(name)); - return name; - } -#endif - - /* ----------------------------------------------------------------------------- - * nameToModula3() - * - * Turn usual C identifiers like "this_is_an_identifier" - * into usual Modula 3 identifier like "thisIsAnIdentifier" - * ----------------------------------------------------------------------------- */ - String *nameToModula3(const String *sym, bool leadingCap) { - int len_sym = Len(sym); - char *csym = Char(sym); - char *m3sym = new char[len_sym + 1]; - int i, j; - bool cap = leadingCap; - for (i = 0, j = 0; j < len_sym; j++) { - char c = csym[j]; - if ((c == '_') || (c == ':')) { - cap = true; - } else { - if (isdigit(c)) { - m3sym[i] = c; - cap = true; - } else { - if (cap) { - m3sym[i] = (char)toupper(c); - } else { - m3sym[i] = (char)tolower(c); - } - cap = false; - } - i++; - } - } - m3sym[i] = 0; - String *result = NewString(m3sym); - delete[]m3sym; - return result; - } - - /* ----------------------------------------------------------------------------- - * capitalizeFirst() - * - * Make the first character upper case. - * ----------------------------------------------------------------------------- */ - String *capitalizeFirst(const String *str) { - return NewStringf("%c%s", toupper(*Char(str)), Char(str) + 1); - } - - /* ----------------------------------------------------------------------------- - * prefixedNameToModula3() - * - * If feature modula3:oldprefix and modula3:newprefix is present - * and the C identifier has leading 'oldprefix' - * then it is replaced by the 'newprefix'. - * The rest is converted to Modula style. - * ----------------------------------------------------------------------------- */ - String *prefixedNameToModula3(Node *n, const String *sym, bool leadingCap) { - String *oldPrefix = Getattr(n, "feature:modula3:oldprefix"); - String *newPrefix = Getattr(n, "feature:modula3:newprefix"); - String *result = NewString(""); - char *short_sym = Char(sym); - // if at least one prefix feature is present - // the replacement takes place - if ((oldPrefix != NIL) || (newPrefix != NIL)) { - if ((oldPrefix == NIL) || hasPrefix(sym, oldPrefix)) { - short_sym += Len(oldPrefix); - if (newPrefix != NIL) { - Append(result, newPrefix); - } - } - } - String *suffix = nameToModula3(short_sym, leadingCap || hasContent(newPrefix)); - Append(result, suffix); - Delete(suffix); - return result; - } - - /* ----------------------------------------------------------------------------- - * hasContent() - * - * Check if the string exists and contains something. - * ----------------------------------------------------------------------------- */ - bool hasContent(const String *str) { - return (str != NIL) && (Strcmp(str, "") != 0); - } - - /* ----------------------------------------------------------------------------- - * openWriteFile() - * - * Caution: The file must be freshly allocated and will be destroyed - * by this routine. - * ----------------------------------------------------------------------------- */ - - File *openWriteFile(String *name) { - File *file = NewFile(name, "w", SWIG_output_files()); - if (!file) { - FileErrorDisplay(name); - SWIG_exit(EXIT_FAILURE); - } - Delete(name); - return file; - } - - /* ----------------------------------------------------------------------------- - * aToL() - * - * like atol but with additional user warning - * ----------------------------------------------------------------------------- */ - - long aToL(const String *value) { - char *endptr; - long numvalue = strtol(Char(value), &endptr, 0); - if (*endptr != 0) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "The string <%s> does not denote a numeric value.\n", value); - } - return numvalue; - } - - /* ----------------------------------------------------------------------------- - * strToL() - * - * like strtol but returns if the conversion was successful - * ----------------------------------------------------------------------------- */ - - bool strToL(const String *value, long &numvalue) { - char *endptr; - numvalue = strtol(Char(value), &endptr, 0); - return (*endptr == 0); - } - - /* ----------------------------------------------------------------------------- - * evalExpr() - * - * Evaluate simple expression as they may occur in "enumvalue" attributes. - * ----------------------------------------------------------------------------- */ - - bool evalExpr(String *value, long &numvalue) { - // Split changes file status of String and thus cannot receive 'const' strings -//printf("evaluate <%s>\n", Char(value)); - List *summands = Split(value, '+', INT_MAX); - Iterator sm = First(summands); - numvalue = 0; - for (; sm.item != NIL; sm = Next(sm)) { - String *smvalue = Getattr(constant_values, sm.item); - long smnumvalue; - if (smvalue != NIL) { - if (!strToL(smvalue, smnumvalue)) { -//printf("evaluation: abort 0 <%s>\n", Char(smvalue)); - return false; - } - } else { - if (!strToL(sm.item, smnumvalue)) { -//printf("evaluation: abort 1 <%s>\n", Char(sm)); - return false; - } - } - numvalue += smnumvalue; - } -//printf("evaluation: return %ld\n", numvalue); - return true; - } - - /* ----------------------------------------------------------------------------- - * log2() - * - * Determine the position of the single bit of a power of two. - * Returns true if the given number is a power of two. - * ----------------------------------------------------------------------------- */ - - bool log2(long n, long &exp) { - exp = 0; - while (n > 0) { - if ((n & 1) != 0) { - return n == 1; - } - exp++; - n >>= 1; - } - return false; - } - - /* ----------------------------------------------------------------------------- - * writeArg - * - * Write a function argument or RECORD entry definition. - * Bundles arguments of same type and default value. - * 'name.next==NIL' denotes the end of the entry or argument list. - * ----------------------------------------------------------------------------- */ - - bool equalNilStr(const String *str0, const String *str1) { - if (str0 == NIL) { - return (str1 == NIL); - //return (str0==NIL) == (str1==NIL); - } else { - return (str1 != NIL) && (Cmp(str0, str1) == 0); - //return Cmp(str0,str1)==0; - } - } - - struct writeArgState { - String *mode, *name, *type, *value; - bool hold; - writeArgState():mode(NIL), name(NIL), type(NIL), value(NIL), hold(false) { - } - }; - - void writeArg(File *f, writeArgState & state, String *mode, String *name, String *type, String *value) { - /* skip the first argument, - only store the information for the next call in this case */ - if (state.name != NIL) { - if ((!state.hold) && (state.mode != NIL)) { - Printf(f, "%s ", state.mode); - } - if ((name != NIL) && equalNilStr(state.mode, mode) && equalNilStr(state.type, type) && (state.value == NIL) && (value == NIL) - /* the same expression may have different values - due to side effects of the called function */ - /*equalNilStr(state.value,value) */ - ) { - Printf(f, "%s, ", state.name); - state.hold = true; - } else { - Append(f, state.name); - if (state.type != NIL) { - Printf(f, ": %s", state.type); - } - if (state.value != NIL) { - Printf(f, ":= %s", state.value); - } - Append(f, ";\n"); - state.hold = false; - } - } - /* at the next call the current argument will be the previous one */ - state.mode = mode; - state.name = name; - state.type = type; - state.value = value; - } - - /* ----------------------------------------------------------------------------- - * getProxyName() - * - * Test to see if a type corresponds to something wrapped with a proxy class - * Return NULL if not otherwise the proxy class name - * ----------------------------------------------------------------------------- */ - - String *getProxyName(SwigType *t) { - if (proxy_flag) { - Node *n = classLookup(t); - if (n) { - return Getattr(n, "sym:name"); - } - } - return NULL; - } - - /*************** language processing ********************/ - - /* ------------------------------------------------------------ - * main() - * ------------------------------------------------------------ */ - - virtual void main(int argc, char *argv[]) { - - SWIG_library_directory("modula3"); - - // Look for certain command line options - for (int i = 1; i < argc; i++) { - if (argv[i]) { - if (strcmp(argv[i], "-generateconst") == 0) { - if (argv[i + 1]) { - constantfilename = NewString(argv[i + 1]); - Swig_mark_arg(i); - Swig_mark_arg(i + 1); - i++; - } else { - Swig_arg_error(); - } - } else if (strcmp(argv[i], "-generaterename") == 0) { - if (argv[i + 1]) { - renamefilename = NewString(argv[i + 1]); - Swig_mark_arg(i); - Swig_mark_arg(i + 1); - i++; - } else { - Swig_arg_error(); - } - } else if (strcmp(argv[i], "-generatetypemap") == 0) { - if (argv[i + 1]) { - typemapfilename = NewString(argv[i + 1]); - Swig_mark_arg(i); - Swig_mark_arg(i + 1); - i++; - } else { - Swig_arg_error(); - } - } else if (strcmp(argv[i], "-noproxy") == 0) { - Swig_mark_arg(i); - proxy_flag = false; - } else if (strcmp(argv[i], "-oldvarnames") == 0) { - Swig_mark_arg(i); - old_variable_names = true; - } else if (strcmp(argv[i], "-help") == 0) { - Printf(stdout, "%s\n", usage); - } - } - } - - // Add a symbol to the parser for conditional compilation - Preprocessor_define("SWIGMODULA3 1", 0); - - // Add typemap definitions - SWIG_typemap_lang("modula3"); - SWIG_config_file("modula3.swg"); - - allow_overloading(); - } - - /* --------------------------------------------------------------------- - * top() - * --------------------------------------------------------------------- */ - - virtual int top(Node *n) { - if (hasContent(constantfilename) || hasContent(renamefilename) || hasContent(typemapfilename)) { - int result = SWIG_OK; - if (hasContent(constantfilename)) { - result = generateConstantTop(n) && result; - } - if (hasContent(renamefilename)) { - result = generateRenameTop(n) && result; - } - if (hasContent(typemapfilename)) { - result = generateTypemapTop(n) && result; - } - return result; - } else { - return generateM3Top(n); - } - } - - void scanConstant(File *file, Node *n) { - Node *child = firstChild(n); - while (child != NIL) { - String *constname = NIL; - String *type = nodeType(child); - if ((Strcmp(type, "enumitem") == 0) - || (Strcmp(type, "constant") == 0)) { -#if 1 - constname = getQualifiedName(child); -#else - constname = Getattr(child, "value"); - if ((!hasContent(constname)) - || (('0' <= *Char(constname)) && (*Char(constname) <= '9'))) { - constname = Getattr(child, "name"); - } -#endif - } - if (constname != NIL) { - Printf(file, " printf(\"%%%%constnumeric(%%Lg) %s;\\n\", (long double)%s);\n", constname, constname); - } - scanConstant(file, child); - child = nextSibling(child); - } - } - - int generateConstantTop(Node *n) { - File *file = openWriteFile(NewStringf("%s.c", constantfilename)); - if (CPlusPlus) { - Printf(file, "#include <cstdio>\n"); - } else { - Printf(file, "#include <stdio.h>\n"); - } - Printf(file, "#include \"%s\"\n", input_file); - Printf(file, "\n"); - Printf(file, "int main (int argc, char *argv[]) {\n"); - Printf(file, "\ -/*This program must work for floating point numbers and integers.\n\ - Thus all numbers are converted to double precision floating point format.*/\n"); - scanConstant(file, n); - Printf(file, " return 0;\n"); - Printf(file, "}\n"); - Delete(file); - return SWIG_OK; - } - - void scanRename(File *file, Node *n) { - Node *child = firstChild(n); - while (child != NIL) { - String *type = nodeType(child); - if (Strcmp(type, "cdecl") == 0) { - ParmList *p = Getattr(child, "parms"); - if (p != NIL) { - String *name = getQualifiedName(child); - String *m3name = nameToModula3(name, true); - /*don't know how to get the original C type identifiers */ - //String *arguments = createCSignature (child); - Printf(file, "%%rename(\"%s\") %s;\n", m3name, name); - /*Printf(file, "%%rename(\"%s\") %s %s(%s);\n", - m3name, Getattr(n,"type"), name, arguments); */ - Delete(name); - Delete(m3name); - //Delete (arguments); - } - } - scanRename(file, child); - child = nextSibling(child); - } - } - - int generateRenameTop(Node *n) { - File *file = openWriteFile(NewStringf("%s.i", renamefilename)); - Printf(file, "\ -/* This file was generated from %s\n\ - by SWIG with option -generaterename. */\n\ -\n", input_file); - scanRename(file, n); - Delete(file); - return SWIG_OK; - } - - void scanTypemap(File *file, Node *n) { - Node *child = firstChild(n); - while (child != NIL) { - String *type = nodeType(child); - //printf("nodetype %s\n", Char(type)); - String *storage = Getattr(child, "storage"); - if ((Strcmp(type, "class") == 0) || ((Strcmp(type, "cdecl") == 0) && (storage != NIL) - && (Strcmp(storage, "typedef") == 0))) { - String *name = getQualifiedName(child); - String *m3name = nameToModula3(name, true); - Printf(file, "%%typemap(\"m3wrapintype\") %s %%{%s%%}\n", name, m3name); - Printf(file, "%%typemap(\"m3rawintype\") %s %%{%s%%}\n", name, m3name); - Printf(file, "\n"); - } - scanTypemap(file, child); - child = nextSibling(child); - } - } - - int generateTypemapTop(Node *n) { - File *file = openWriteFile(NewStringf("%s.i", typemapfilename)); - Printf(file, "\ -/* This file was generated from %s\n\ - by SWIG with option -generatetypemap. */\n\ -\n", input_file); - scanTypemap(file, n); - Delete(file); - return SWIG_OK; - } - - int generateM3Top(Node *n) { - /* Initialize all of the output files */ - outfile = Getattr(n, "outfile"); - - f_begin = NewFile(outfile, "w", SWIG_output_files()); - if (!f_begin) { - FileErrorDisplay(outfile); - SWIG_exit(EXIT_FAILURE); - } - f_runtime = NewString(""); - f_init = NewString(""); - f_header = NewString(""); - f_wrappers = NewString(""); - - m3makefile = NewString(""); - - /* Register file targets with the SWIG file handler */ - Swig_register_filebyname("header", f_header); - Swig_register_filebyname("wrapper", f_wrappers); - Swig_register_filebyname("begin", f_begin); - Swig_register_filebyname("runtime", f_runtime); - Swig_register_filebyname("init", f_init); - - Swig_register_filebyname("m3rawintf", m3raw_intf.f); - Swig_register_filebyname("m3rawimpl", m3raw_impl.f); - Swig_register_filebyname("m3wrapintf", m3wrap_intf.f); - Swig_register_filebyname("m3wrapimpl", m3wrap_impl.f); - Swig_register_filebyname("m3makefile", m3makefile); - - swig_types_hash = NewHash(); - - String *name = Getattr(n, "name"); - // Make the intermediary class and module class names. The intermediary class name can be set in the module directive. - Node *optionsnode = Getattr(Getattr(n, "module"), "options"); - if (optionsnode != NIL) { - String *m3raw_name_tmp = Getattr(optionsnode, "m3rawname"); - if (m3raw_name_tmp != NIL) { - m3raw_name = Copy(m3raw_name_tmp); - } - } - if (m3raw_name == NIL) { - m3raw_name = NewStringf("%sRaw", name); - } - Setattr(m3wrap_impl.import, m3raw_name, ""); - - m3wrap_name = Copy(name); - - proxy_class_def = NewString(""); - proxy_class_code = NewString(""); - m3raw_baseclass = NewString(""); - m3raw_interfaces = NewString(""); - m3raw_class_modifiers = NewString(""); // package access only to the intermediary class by default - m3raw_imports = NewString(""); - m3raw_cppcasts_code = NewString(""); - m3wrap_modifiers = NewString("public"); - module_baseclass = NewString(""); - module_interfaces = NewString(""); - module_imports = NewString(""); - upcasts_code = NewString(""); - - Swig_banner(f_begin); - - Printf(f_runtime, "\n\n#ifndef SWIGMODULA3\n#define SWIGMODULA3\n#endif\n\n"); - - Swig_name_register("wrapper", "Modula3_%f"); - if (old_variable_names) { - Swig_name_register("set", "set_%n%v"); - Swig_name_register("get", "get_%n%v"); - } - - Printf(f_wrappers, "\n#ifdef __cplusplus\n"); - Printf(f_wrappers, "extern \"C\" {\n"); - Printf(f_wrappers, "#endif\n\n"); - - constant_values = NewHash(); - scanForConstPragmas(n); - enumeration_coll = NewHash(); - collectEnumerations(enumeration_coll, n); - - /* Emit code */ - Language::top(n); - - // Generate m3makefile - // This will be unnecessary if SWIG is invoked from Quake. - { - File *file = openWriteFile(NewStringf("%sm3makefile", SWIG_output_directory())); - - Printf(file, "%% automatically generated quake file for %s\n\n", name); - - /* Write the fragments written by '%insert' - collected while 'top' processed the parse tree */ - Printv(file, m3makefile, NIL); - - Printf(file, "import(\"libm3\")\n"); - //Printf(file, "import_lib(\"%s\",\"/usr/lib\")\n", name); - Printf(file, "module(\"%s\")\n", m3raw_name); - Printf(file, "module(\"%s\")\n\n", m3wrap_name); - - if (targetlibrary != NIL) { - Printf(file, "library(\"%s\")\n", targetlibrary); - } else { - Printf(file, "library(\"m3%s\")\n", name); - } - Delete(file); - } - - // Generate the raw interface - { - File *file = openWriteFile(NewStringf("%s%s.i3", SWIG_output_directory(), m3raw_name)); - - emitBanner(file); - - Printf(file, "INTERFACE %s;\n\n", m3raw_name); - - emitImportStatements(m3raw_intf.import, file); - Printf(file, "\n"); - - // Write the interface generated within 'top' - Printv(file, m3raw_intf.f, NIL); - - Printf(file, "\nEND %s.\n", m3raw_name); - Delete(file); - } - - // Generate the raw module - { - File *file = openWriteFile(NewStringf("%s%s.m3", SWIG_output_directory(), m3raw_name)); - - emitBanner(file); - - Printf(file, "MODULE %s;\n\n", m3raw_name); - - emitImportStatements(m3raw_impl.import, file); - Printf(file, "\n"); - - // will be empty usually - Printv(file, m3raw_impl.f, NIL); - - Printf(file, "BEGIN\nEND %s.\n", m3raw_name); - Delete(file); - } - - // Generate the interface for the comfort wrappers - { - File *file = openWriteFile(NewStringf("%s%s.i3", SWIG_output_directory(), m3wrap_name)); - - emitBanner(file); - - Printf(file, "INTERFACE %s;\n", m3wrap_name); - - emitImportStatements(m3wrap_intf.import, file); - Printf(file, "\n"); - - { - Iterator it = First(enumeration_coll); - if (it.key != NIL) { - Printf(file, "TYPE\n"); - } - for (; it.key != NIL; it = Next(it)) { - Printf(file, "\n"); - emitEnumeration(file, it.key, it.item); - } - } - - // Add the wrapper methods - Printv(file, m3wrap_intf.f, NIL); - - // Finish off the class - Printf(file, "\nEND %s.\n", m3wrap_name); - Delete(file); - } - - // Generate the wrapper routines implemented in Modula 3 - { - File *file = openWriteFile(NewStringf("%s%s.m3", SWIG_output_directory(), m3wrap_name)); - - emitBanner(file); - - if (unsafe_module) { - Printf(file, "UNSAFE "); - } - Printf(file, "MODULE %s;\n\n", m3wrap_name); - - emitImportStatements(m3wrap_impl.import, file); - Printf(file, "\n"); - - // Add the wrapper methods - Printv(file, m3wrap_impl.f, NIL); - - Printf(file, "\nBEGIN\nEND %s.\n", m3wrap_name); - Delete(file); - } - - if (upcasts_code) - Printv(f_wrappers, upcasts_code, NIL); - - Printf(f_wrappers, "#ifdef __cplusplus\n"); - Printf(f_wrappers, "}\n"); - Printf(f_wrappers, "#endif\n"); - - // Output a Modula 3 type wrapper class for each SWIG type - for (Iterator swig_type = First(swig_types_hash); swig_type.item != NIL; swig_type = Next(swig_type)) { - emitTypeWrapperClass(swig_type.key, swig_type.item); - } - - Delete(swig_types_hash); - swig_types_hash = NULL; - Delete(constant_values); - constant_values = NULL; - Delete(enumeration_coll); - enumeration_coll = NULL; - Delete(m3raw_name); - m3raw_name = NULL; - Delete(m3raw_baseclass); - m3raw_baseclass = NULL; - Delete(m3raw_interfaces); - m3raw_interfaces = NULL; - Delete(m3raw_class_modifiers); - m3raw_class_modifiers = NULL; - Delete(m3raw_imports); - m3raw_imports = NULL; - Delete(m3raw_cppcasts_code); - m3raw_cppcasts_code = NULL; - Delete(proxy_class_def); - proxy_class_def = NULL; - Delete(proxy_class_code); - proxy_class_code = NULL; - Delete(m3wrap_name); - m3wrap_name = NULL; - Delete(m3wrap_modifiers); - m3wrap_modifiers = NULL; - Delete(targetlibrary); - targetlibrary = NULL; - Delete(module_baseclass); - module_baseclass = NULL; - Delete(module_interfaces); - module_interfaces = NULL; - Delete(module_imports); - module_imports = NULL; - Delete(upcasts_code); - upcasts_code = NULL; - Delete(constantfilename); - constantfilename = NULL; - Delete(renamefilename); - renamefilename = NULL; - Delete(typemapfilename); - typemapfilename = NULL; - - /* Close all of the files */ - Dump(f_runtime, f_begin); - Dump(f_header, f_begin); - Dump(f_wrappers, f_begin); - Wrapper_pretty_print(f_init, f_begin); - Delete(f_header); - Delete(f_wrappers); - Delete(f_init); - Delete(f_runtime); - Delete(f_begin); - return SWIG_OK; - } - - /* ----------------------------------------------------------------------------- - * emitBanner() - * ----------------------------------------------------------------------------- */ - - void emitBanner(File *f) { - Printf(f, "(*******************************************************************************\n"); - Swig_banner_target_lang(f, " *"); - Printf(f, "*******************************************************************************)\n\n"); - } - - /* ---------------------------------------------------------------------- - * nativeWrapper() - * ---------------------------------------------------------------------- */ - - virtual int nativeWrapper(Node *n) { - String *wrapname = Getattr(n, "wrap:name"); - - if (!addSymbol(wrapname, n)) - return SWIG_ERROR; - - if (Getattr(n, "type")) { - Swig_save("nativeWrapper", n, "name", NIL); - Setattr(n, "name", wrapname); - native_function_flag = true; - functionWrapper(n); - Swig_restore(n); - native_function_flag = false; - } else { - Swig_error(input_file, line_number, "No return type for %%native method %s.\n", Getattr(n, "wrap:name")); - } - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * functionWrapper() - * ---------------------------------------------------------------------- */ - - virtual int functionWrapper(Node *n) { - String *type = nodeType(n); - String *funcType = Getattr(n, "modula3:functype"); - String *rawname = Getattr(n, "name"); - String *symname = Getattr(n, "sym:name"); - String *capname = capitalizeFirst(symname); - //String *wname = Swig_name_wrapper(symname); - - //printf("function: %s\n", Char(symname)); - //printf(" purpose: %s\n", Char(funcType)); - - if (Strcmp(type, "cdecl") == 0) { - if (funcType == NIL) { - // no wrapper needed for plain functions - emitM3RawPrototype(n, rawname, symname); - emitM3Wrapper(n, symname); - } else if (Strcmp(funcType, "method") == 0) { - Setattr(n, "modula3:funcname", capname); - emitCWrapper(n, capname); - emitM3RawPrototype(n, capname, capname); - emitM3Wrapper(n, capname); - } else if (Strcmp(funcType, "accessor") == 0) { - /* - * Generate the proxy class properties for public member variables. - * Not for enums and constants. - */ - if (proxy_flag && wrapping_member_flag && !enum_constant_flag) { - // Capitalize the first letter in the function name - Setattr(n, "proxyfuncname", capname); - Setattr(n, "imfuncname", symname); - if (hasPrefix(capname, "Set")) { - Setattr(n, "modula3:setname", capname); - } else { - Setattr(n, "modula3:getname", capname); - } - - emitCWrapper(n, capname); - emitM3RawPrototype(n, capname, capname); - emitM3Wrapper(n, capname); - //proxyClassFunctionHandler(n); - } -#ifdef DEBUG - } else { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Function type <%s> unknown.\n", Char(funcType)); -#endif - } - } else if ((Strcmp(type, "constructor") == 0) || (Strcmp(type, "destructor") == 0)) { - emitCWrapper(n, capname); - emitM3RawPrototype(n, capname, capname); - emitM3Wrapper(n, capname); - } -// a Java relict -#if 0 - if (!(proxy_flag && is_wrapping_class()) && !enum_constant_flag) { - emitM3Wrapper(n, capname); - } -#endif - - Delete(capname); - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * emitCWrapper() - * - * Generate the wrapper in C which calls C++ methods. - * ---------------------------------------------------------------------- */ - - virtual int emitCWrapper(Node *n, const String *wname) { - String *rawname = Getattr(n, "name"); - String *c_return_type = NewString(""); - String *cleanup = NewString(""); - String *outarg = NewString(""); - String *body = NewString(""); - Hash *throws_hash = NewHash(); - ParmList *l = Getattr(n, "parms"); - SwigType *t = Getattr(n, "type"); - String *symname = Getattr(n, "sym:name"); - - if (!Getattr(n, "sym:overloaded")) { - if (!addSymbol(wname, n)) { - return SWIG_ERROR; - } - } - // A new wrapper function object - Wrapper *f = NewWrapper(); - - /* Attach the non-standard typemaps to the parameter list. */ - Swig_typemap_attach_parms("ctype", l, f); - - /* Get return types */ - { - String *tm = getMappedTypeNew(n, "ctype", ""); - if (tm != NIL) { - Printf(c_return_type, "%s", tm); - } - } - - bool is_void_return = (Cmp(c_return_type, "void") == 0); - if (!is_void_return) { - Wrapper_add_localv(f, "cresult", c_return_type, "cresult = 0", NIL); - } - - Printv(f->def, " SWIGEXPORT ", c_return_type, " ", wname, "(", NIL); - - // Emit all of the local variables for holding arguments. - emit_parameter_variables(l, f); - - /* Attach the standard typemaps */ - emit_attach_parmmaps(l, f); - Setattr(n, "wrap:parms", l); - - // Generate signature and argument conversion for C wrapper - { - Parm *p; - attachParameterNames(n, "tmap:name", "c:wrapname", "m3arg%d"); - bool gencomma = false; - for (p = skipIgnored(l, "in"); p; p = skipIgnored(p, "in")) { - - String *arg = Getattr(p, "c:wrapname"); - { - /* Get the ctype types of the parameter */ - String *c_param_type = getMappedType(p, "ctype"); - // Add parameter to C function - Printv(f->def, gencomma ? ", " : "", c_param_type, " ", arg, NIL); - Delete(c_param_type); - gencomma = true; - } - - // Get typemap for this argument - String *tm = getMappedType(p, "in"); - if (tm != NIL) { - addThrows(throws_hash, "in", p); - Replaceall(tm, "$input", arg); - Setattr(p, "emit:input", arg); /*??? */ - Printf(f->code, "%s\n", tm); - p = Getattr(p, "tmap:in:next"); - } else { - p = nextSibling(p); - } - } - } - - /* Insert constraint checking code */ - { - Parm *p; - for (p = l; p;) { - String *tm = Getattr(p, "tmap:check"); - if (tm != NIL) { - addThrows(throws_hash, "check", p); - Replaceall(tm, "$target", Getattr(p, "lname")); /* deprecated */ - Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ - Replaceall(tm, "$input", Getattr(p, "emit:input")); - Printv(f->code, tm, "\n", NIL); - p = Getattr(p, "tmap:check:next"); - } else { - p = nextSibling(p); - } - } - } - - /* Insert cleanup code */ - { - Parm *p; - for (p = l; p;) { - String *tm = Getattr(p, "tmap:freearg"); - if (tm != NIL) { - addThrows(throws_hash, "freearg", p); - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* deprecated */ - Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ - Replaceall(tm, "$input", Getattr(p, "emit:input")); - Printv(cleanup, tm, "\n", NIL); - p = Getattr(p, "tmap:freearg:next"); - } else { - p = nextSibling(p); - } - } - } - - /* Insert argument output code */ - { - Parm *p; - for (p = l; p;) { - String *tm = Getattr(p, "tmap:argout"); - if (tm != NIL) { - addThrows(throws_hash, "argout", p); - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* deprecated */ - Replaceall(tm, "$target", Getattr(p, "lname")); /* deprecated */ - Replaceall(tm, "$arg", Getattr(p, "emit:input")); /* deprecated? */ - Replaceall(tm, "$result", "cresult"); - Replaceall(tm, "$input", Getattr(p, "emit:input")); - Printv(outarg, tm, "\n", NIL); - p = Getattr(p, "tmap:argout:next"); - } else { - p = nextSibling(p); - } - } - } - - // Get any Modula 3 exception classes in the throws typemap - ParmList *throw_parm_list = NULL; - if ((throw_parm_list = Getattr(n, "catchlist"))) { - Swig_typemap_attach_parms("throws", throw_parm_list, f); - Parm *p; - for (p = throw_parm_list; p; p = nextSibling(p)) { - addThrows(throws_hash, "throws", p); - } - } - - Setattr(n, "wrap:name", wname); - - // Now write code to make the function call - if (!native_function_flag) { - String *actioncode = emit_action(n); - - /* Return value if necessary */ - String *tm; - if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - addThrows(throws_hash, "out", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ - Replaceall(tm, "$target", "cresult"); /* deprecated */ - Replaceall(tm, "$result", "cresult"); - Printf(f->code, "%s", tm); - if (hasContent(tm)) - Printf(f->code, "\n"); - } else { - Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(t, 0), rawname); - } - emit_return_variable(n, t, f); - } - - /* Output argument output code */ - Printv(f->code, outarg, NIL); - - /* Output cleanup code */ - Printv(f->code, cleanup, NIL); - - /* Look to see if there is any newfree cleanup code */ - if (GetFlag(n, "feature:new")) { - String *tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0); - if (tm != NIL) { - addThrows(throws_hash, "newfree", n); - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ - Printf(f->code, "%s\n", tm); - } - } - - /* See if there is any return cleanup code */ - if (!native_function_flag) { - String *tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0); - if (tm != NIL) { - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ - Printf(f->code, "%s\n", tm); - } - } - - /* Finish C wrapper */ - Printf(f->def, ") {"); - - if (!is_void_return) - Printv(f->code, " return cresult;\n", NIL); - Printf(f->code, "}\n"); - - /* Substitute the cleanup code */ - Replaceall(f->code, "$cleanup", cleanup); - - /* Substitute the function name */ - Replaceall(f->code, "$symname", symname); - - if (!is_void_return) { - Replaceall(f->code, "$null", "0"); - } else { - Replaceall(f->code, "$null", ""); - } - - /* Dump the function out */ - if (!native_function_flag) { - Wrapper_print(f, f_wrappers); - } - - Delete(c_return_type); - Delete(cleanup); - Delete(outarg); - Delete(body); - Delete(throws_hash); - DelWrapper(f); - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * emitM3RawPrototype() - * - * Generate an EXTERNAL procedure declaration in Modula 3 - * which is the interface to an existing C routine or a C wrapper. - * ---------------------------------------------------------------------- */ - - virtual int emitM3RawPrototype(Node *n, const String *cname, const String *m3name) { - String *im_return_type = NewString(""); - //String *symname = Getattr(n,"sym:name"); - ParmList *l = Getattr(n, "parms"); - - /* Attach the non-standard typemaps to the parameter list. */ - Swig_typemap_attach_parms("m3rawinmode", l, NULL); - Swig_typemap_attach_parms("m3rawintype", l, NULL); - - /* Get return types */ - bool has_return; - { - String *tm = getMappedTypeNew(n, "m3rawrettype", ""); - if (tm != NIL) { - Printf(im_return_type, "%s", tm); - } - has_return = hasContent(tm); - } - - /* cname is the original name if 'n' denotes a C function - and it is the relabeled name (sym:name) if 'n' denotes a C++ method or similar */ - m3raw_intf.enterBlock(no_block); - Printf(m3raw_intf.f, "\n<* EXTERNAL %s *>\nPROCEDURE %s (", cname, m3name); - - // Generate signature for raw interface - { - Parm *p; - writeArgState state; - attachParameterNames(n, "tmap:rawinname", "modula3:rawname", "arg%d"); - for (p = skipIgnored(l, "m3rawintype"); p; p = skipIgnored(p, "m3rawintype")) { - - /* Get argument passing mode, should be one of VALUE, VAR, READONLY */ - String *mode = Getattr(p, "tmap:m3rawinmode"); - String *argname = Getattr(p, "modula3:rawname"); - String *im_param_type = getMappedType(p, "m3rawintype"); - addImports(m3raw_intf.import, "m3rawintype", p); - - writeArg(m3raw_intf.f, state, mode, argname, im_param_type, NIL); - if (im_param_type != NIL) { - p = Getattr(p, "tmap:m3rawintype:next"); - } else { - p = nextSibling(p); - } - } - writeArg(m3raw_intf.f, state, NIL, NIL, NIL, NIL); - } - - /* Finish M3 raw prototype */ - Printf(m3raw_intf.f, ")"); - // neither a C wrapper nor a plain C function may throw an exception - //generateThrowsClause(throws_hash, m3raw_intf.f); - if (has_return) { - Printf(m3raw_intf.f, ": %s", im_return_type); - } - Printf(m3raw_intf.f, ";\n"); - - Delete(im_return_type); - return SWIG_OK; - } - - /* ----------------------------------------------------------------------- - * variableWrapper() - * ----------------------------------------------------------------------- */ - - virtual int variableWrapper(Node *n) { - Language::variableWrapper(n); - return SWIG_OK; - } - - /* ----------------------------------------------------------------------- - * globalvariableHandler() - * ----------------------------------------------------------------------- */ - - virtual int globalvariableHandler(Node *n) { - SwigType *t = Getattr(n, "type"); - String *tm; - - // Get the variable type - if ((tm = getMappedTypeNew(n, "m3wraptype", ""))) { - substituteClassname(t, tm); - } - - variable_name = Getattr(n, "sym:name"); - variable_type = Copy(tm); - - // Get the variable type expressed in terms of Modula 3 equivalents of C types - if ((tm = getMappedTypeNew(n, "m3rawtype", ""))) { - m3raw_intf.enterBlock(no_block); - Printf(m3raw_intf.f, "\n<* EXTERNAL *> VAR %s: %s;\n", variable_name, tm); - } - // Output the property's accessor methods - /* - global_variable_flag = true; - int ret = Language::globalvariableHandler(n); - global_variable_flag = false; - */ - - Printf(m3wrap_impl.f, "\n\n"); - - //return ret; - return 1; - } - - long getConstNumeric(Node *n) { - String *constnumeric = Getfeature(n, "constnumeric"); - String *name = Getattr(n, "name"); - long numvalue; - if (constnumeric == NIL) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Feature 'constnumeric' is necessary to obtain value of %s.\n", name); - return 0; - } else if (!strToL(constnumeric, numvalue)) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, - "The feature 'constnumeric' of %s specifies value <%s> which is not an integer constant.\n", name, constnumeric); - return 0; - } else { - return numvalue; - } - } - - /* ------------------------------------------------------------------------ - * generateIntConstant() - * - * Considers node as an integer constant definition - * and generate a Modula 3 constant definition. - * ------------------------------------------------------------------------ */ - void generateIntConstant(Node *n, String *name) { - String *value = Getattr(n, "value"); - String *type = Getfeature(n, "modula3:constint:type"); - String *conv = Getfeature(n, "modula3:constint:conv"); - - if (name == NIL) { - name = Getattr(n, "sym:name"); - } - - long numvalue; - bool isSimpleNum = strToL(value, numvalue); - if (!isSimpleNum) { - numvalue = getConstNumeric(n); - } - - String *m3value; - if ((conv == NIL) || ((Strcmp(conv, "set:int") != 0) && (Strcmp(conv, "int:set") != 0))) { - /* The original value of the constant has precedence over - 'constnumeric' feature since we like to keep - the style (that is the base) of simple numeric constants */ - if (isSimpleNum) { - if (hasPrefix(value, "0x")) { - m3value = NewStringf("16_%s", Char(value) + 2); - } else if ((Len(value) > 1) && (*Char(value) == '0')) { - m3value = NewStringf("8_%s", Char(value) + 1); - } else { - m3value = Copy(value); - } - /* If we cannot easily obtain the value of a numeric constant, - we use the results given by a C compiler. */ - } else { - m3value = Copy(Getfeature(n, "constnumeric")); - } - } else { - // if the value can't be converted, it is ignored - if (convertInt(numvalue, numvalue, conv)) { - m3value = NewStringf("%d", numvalue); - } else { - m3value = NIL; - } - } - - if (m3value != NIL) { - m3wrap_intf.enterBlock(constant); - Printf(m3wrap_intf.f, "%s", name); - if (hasContent(type)) { - Printf(m3wrap_intf.f, ": %s", type); - } - Printf(m3wrap_intf.f, " = %s;\n", m3value); - Delete(m3value); - } - } - - /* ----------------------------------------------------------------------- - * generateSetConstant() - * - * Considers node as a set constant definition - * and generate a Modula 3 constant definition. - * ------------------------------------------------------------------------ */ - void generateSetConstant(Node *n, String *name) { - String *value = Getattr(n, "value"); - String *type = Getfeature(n, "modula3:constset:type"); - String *setname = Getfeature(n, "modula3:constset:set"); - String *basename = Getfeature(n, "modula3:constset:base"); - String *conv = Getfeature(n, "modula3:constset:conv"); - - m3wrap_intf.enterBlock(constant); - - Printf(m3wrap_intf.f, "%s", name); - if (type != NIL) { - Printf(m3wrap_intf.f, ":%s ", type); - } - Printf(m3wrap_intf.f, " = %s{", setname); - - long numvalue = 0; - if (!strToL(value, numvalue)) { - numvalue = getConstNumeric(n); - } - convertInt(numvalue, numvalue, conv); - - bool isIntType = Strcmp(basename, "CARDINAL") == 0; - Hash *items = NIL; - if (!isIntType) { - Hash *enumeration = Getattr(enumeration_coll, basename); - if (enumeration == NIL) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "There is no enumeration <%s> as needed for the set.\n", setname); - isIntType = true; - } else { - items = Getattr(enumeration, "items"); - } - } - - bool gencomma = false; - int bitpos = 0; - while (numvalue > 0) { - if ((numvalue & 1) != 0) { - if (isIntType) { - if (gencomma) { - Printv(m3wrap_intf.f, ",", NIL); - } - gencomma = true; - Printf(m3wrap_intf.f, "%d", bitpos); - } else { - char bitval[15]; - sprintf(bitval, "%d", bitpos); - String *bitname = Getattr(items, bitval); - if (bitname == NIL) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Enumeration <%s> has no value <%s>.\n", setname, bitval); - } else { - if (gencomma) { - Printv(m3wrap_intf.f, ",", NIL); - } - gencomma = true; - Printf(m3wrap_intf.f, "%s.%s", basename, bitname); - } - } - } - numvalue >>= 1; - bitpos++; - } - Printf(m3wrap_intf.f, "};\n"); - } - - void generateConstant(Node *n) { - // any of the special interpretation disables the default behaviour - String *enumitem = Getfeature(n, "modula3:enumitem:name"); - String *constset = Getfeature(n, "modula3:constset:name"); - String *constint = Getfeature(n, "modula3:constint:name"); - if (hasContent(enumitem) || hasContent(constset) || hasContent(constint)) { - if (hasContent(constset)) { - generateSetConstant(n, constset); - } - if (hasContent(constint)) { - generateIntConstant(n, constint); - } - } else { - String *value = Getattr(n, "value"); - String *name = Getattr(n, "sym:name"); - if (name == NIL) { - name = Getattr(n, "name"); - } - m3wrap_intf.enterBlock(constant); - Printf(m3wrap_intf.f, "%s = %s;\n", name, value); - } - } - - void emitEnumeration(File *file, String *name, Node *n) { - Printf(file, "%s = {", name); - int i; - bool gencomma = false; - int max = aToL(Getattr(n, "max")); - Hash *items = Getattr(n, "items"); - for (i = 0; i <= max; i++) { - if (gencomma) { - Printf(file, ","); - } - Printf(file, "\n"); - gencomma = true; - char numstr[15]; - sprintf(numstr, "%d", i); - String *name = Getattr(items, numstr); - if (name != NIL) { - Printv(file, name, NIL); - } else { - Printf(file, "Dummy%d", i); - } - } - Printf(file, "\n};\n"); - } - - /* ----------------------------------------------------------------------- - * constantWrapper() - * - * Handles constants and enumeration items. - * ------------------------------------------------------------------------ */ - - virtual int constantWrapper(Node *n) { - generateConstant(n); - return SWIG_OK; - } - -#if 0 -// enumerations are handled like constant definitions - /* ----------------------------------------------------------------------------- - * enumDeclaration() - * ----------------------------------------------------------------------------- */ - - virtual int enumDeclaration(Node *n) { - String *symname = nameToModula3(Getattr(n, "sym:name"), true); - enumerationStart(symname); - int result = Language::enumDeclaration(n); - enumerationStop(); - Delete(symname); - return result; - } -#endif - - /* ----------------------------------------------------------------------------- - * enumvalueDeclaration() - * ----------------------------------------------------------------------------- */ - - virtual int enumvalueDeclaration(Node *n) { - generateConstant(n); - /* - This call would continue processing in the constantWrapper - which cannot handle values like "RED+1". - return Language::enumvalueDeclaration(n); - */ - return SWIG_OK; - } - - /* ----------------------------------------------------------------------------- - * pragmaDirective() - * - * Valid Pragmas: - * imclassbase - base (extends) for the intermediary class - * imclassclassmodifiers - class modifiers for the intermediary class - * imclasscode - text (Modula 3 code) is copied verbatim to the intermediary class - * imclassimports - import statements for the intermediary class - * imclassinterfaces - interface (implements) for the intermediary class - * - * modulebase - base (extends) for the module class - * moduleclassmodifiers - class modifiers for the module class - * modulecode - text (Modula 3 code) is copied verbatim to the module class - * moduleimports - import statements for the module class - * moduleinterfaces - interface (implements) for the module class - * - * ----------------------------------------------------------------------------- */ - - virtual int pragmaDirective(Node *n) { - if (!ImportMode) { - String *lang = Getattr(n, "lang"); - String *code = Getattr(n, "name"); - String *value = Getattr(n, "value"); - - if (Strcmp(lang, "modula3") == 0) { - - String *strvalue = NewString(value); - Replaceall(strvalue, "\\\"", "\""); -/* - bool isEnumItem = Strcmp(code, "enumitem") == 0; - bool isSetItem = Strcmp(code, "setitem") == 0; -*/ - if (Strcmp(code, "imclassbase") == 0) { - Delete(m3raw_baseclass); - m3raw_baseclass = Copy(strvalue); - } else if (Strcmp(code, "imclassclassmodifiers") == 0) { - Delete(m3raw_class_modifiers); - m3raw_class_modifiers = Copy(strvalue); - } else if (Strcmp(code, "imclasscode") == 0) { - Printf(m3raw_intf.f, "%s\n", strvalue); - } else if (Strcmp(code, "imclassimports") == 0) { - Delete(m3raw_imports); - m3raw_imports = Copy(strvalue); - } else if (Strcmp(code, "imclassinterfaces") == 0) { - Delete(m3raw_interfaces); - m3raw_interfaces = Copy(strvalue); - } else if (Strcmp(code, "modulebase") == 0) { - Delete(module_baseclass); - module_baseclass = Copy(strvalue); - } else if (Strcmp(code, "moduleclassmodifiers") == 0) { - Delete(m3wrap_modifiers); - m3wrap_modifiers = Copy(strvalue); - } else if (Strcmp(code, "modulecode") == 0) { - Printf(m3wrap_impl.f, "%s\n", strvalue); - } else if (Strcmp(code, "moduleimports") == 0) { - Delete(module_imports); - module_imports = Copy(strvalue); - } else if (Strcmp(code, "moduleinterfaces") == 0) { - Delete(module_interfaces); - module_interfaces = Copy(strvalue); - } else if (Strcmp(code, "unsafe") == 0) { - unsafe_module = true; - } else if (Strcmp(code, "library") == 0) { - if (targetlibrary) { - Delete(targetlibrary); - } - targetlibrary = Copy(strvalue); - } else if (Strcmp(code, "enumitem") == 0) { - } else if (Strcmp(code, "constset") == 0) { - } else if (Strcmp(code, "constint") == 0) { - } else if (Strcmp(code, "makesetofenum") == 0) { - m3wrap_intf.enterBlock(blocktype); - Printf(m3wrap_intf.f, "%sSet = SET OF %s;\n", value, value); - } else { - Swig_warning(WARN_MODULA3_UNKNOWN_PRAGMA, input_file, line_number, "Unrecognized pragma <%s>.\n", code); - } - Delete(strvalue); - } - } - return Language::pragmaDirective(n); - } - - void Setfeature(Node *n, const char *feature, const String *value, bool warn = false) { - //printf("tag feature <%s> with value <%s>\n", feature, Char(value)); - String *attr = NewStringf("feature:%s", feature); - if ((Setattr(n, attr, value) != 0) && warn) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Feature <%s> of %s did already exist.\n", feature, Getattr(n, "name")); - } - Delete(attr); - } - - String *Getfeature(Node *n, const char *feature) { - //printf("retrieve feature <%s> with value <%s>\n", feature, Char(value)); - String *attr = NewStringf("feature:%s", feature); - String *result = Getattr(n, attr); - Delete(attr); - return result; - } - - bool convertInt(long in, long &out, const String *mode) { - if ((mode == NIL) || (Strcmp(mode, "int:int") == 0) || (Strcmp(mode, "set:set") == 0)) { - out = in; - return true; - } else if (Strcmp(mode, "set:int") == 0) { - return log2(in, out); - } else if (Strcmp(mode, "int:set") == 0) { - out = 1L << in; - return unsigned (in) < (sizeof(out) * 8); - } else { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Unknown integer conversion method <%s>.\n", mode); - return false; - } - } - - void collectEnumerations(Hash *enums, Node *n) { - Node *child = firstChild(n); - while (child != NIL) { - String *name = Getattr(child, "name"); - const bool isConstant = Strcmp(nodeType(child), "constant") == 0; - const bool isEnumItem = Strcmp(nodeType(child), "enumitem") == 0; - if (isConstant || isEnumItem) { -//printf("%s%s name %s\n", isConstant?"constant":"", isEnumItem?"enumitem":"", Char(name)); - { - String *m3name = Getfeature(child, "modula3:enumitem:name"); - String *m3enum = Getfeature(child, "modula3:enumitem:enum"); - String *conv = Getfeature(child, "modula3:enumitem:conv"); - - if (m3enum != NIL) { -//printf("m3enum %s\n", Char(m3enum)); - if (m3name == NIL) { - m3name = name; - } - - long max = -1; - Hash *items; - Hash *enumnode = Getattr(enums, m3enum); - if (enumnode == NIL) { - enumnode = NewHash(); - items = NewHash(); - Setattr(enumnode, "items", items); - Setattr(enums, m3enum, enumnode); - } else { - String *maxstr = Getattr(enumnode, "max"); - if (maxstr != NIL) { - max = aToL(maxstr); - } - items = Getattr(enumnode, "items"); - } - long numvalue; - String *value = Getattr(child, "value"); -//printf("value: %s\n", Char(value)); - if ((value == NIL) || (!strToL(value, numvalue))) { - value = Getattr(child, "enumvalue"); - if ((value == NIL) || (!evalExpr(value, numvalue))) { - numvalue = getConstNumeric(child); - } -//printf("constnumeric: %s\n", Char(value)); - } - Setattr(constant_values, name, NewStringf("%d", numvalue)); - if (convertInt(numvalue, numvalue, conv)) { - String *newvalue = NewStringf("%d", numvalue); - String *oldname = Getattr(items, newvalue); - if (oldname != NIL) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "The value <%s> is already assigned to <%s>.\n", value, oldname); - } -//printf("items %p, set %s = %s\n", items, Char(newvalue), Char(m3name)); - Setattr(items, newvalue, m3name); - if (max < numvalue) { - max = numvalue; - } - Setattr(enumnode, "max", NewStringf("%d", max)); - } - } - } - } - - collectEnumerations(enums, child); - child = nextSibling(child); - } - } - - enum const_pragma_type { cpt_none, cpt_constint, cpt_constset, cpt_enumitem }; - - struct const_id_pattern { - String *prefix, *parentEnum; - }; - - void tagConstants(Node *first, String *parentEnum, const const_id_pattern & pat, const String *pragma, List *convdesc) { - Node *n = first; - while (n != NIL) { - String *name = getQualifiedName(n); - bool isConstant = Strcmp(nodeType(n), "constant") == 0; - bool isEnumItem = Strcmp(nodeType(n), "enumitem") == 0; - if ((isConstant || isEnumItem) && ((pat.prefix == NIL) || (hasPrefix(name, pat.prefix))) && ((pat.parentEnum == NIL) || ((parentEnum != NIL) - && - (Strcmp - (pat.parentEnum, parentEnum) - == 0)))) { - //printf("tag %s\n", Char(name)); - String *srctype = Getitem(convdesc, 1); - String *relationstr = Getitem(convdesc, 3); - List *relationdesc = Split(relationstr, ',', 2); - - // transform name from C to Modula3 style - String *srcstyle = NIL; - String *newprefix = NIL; - { - //printf("name conversion <%s>\n", Char(Getitem(convdesc,2))); - List *namedesc = Split(Getitem(convdesc, 2), ',', INT_MAX); - Iterator nameit = First(namedesc); - for (; nameit.item != NIL; nameit = Next(nameit)) { - List *nameassign = Split(nameit.item, '=', 2); - String *tag = Getitem(nameassign, 0); - String *data = Getitem(nameassign, 1); - //printf("name conv <%s> = <%s>\n", Char(tag), Char(data)); - if (Strcmp(tag, "srcstyle") == 0) { - srcstyle = Copy(data); - } else if (Strcmp(tag, "prefix") == 0) { - newprefix = Copy(data); - } else { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Unknown name conversion tag <%s> with value <%s>.\n", tag, data); - } - Delete(nameassign); - } - Delete(namedesc); - } - const char *stem = Char(name); - if (pat.prefix != NIL) { - //printf("pat.prefix %s for %s\n", Char(pat.prefix), Char(name)); - stem += Len(pat.prefix); - } - String *newname; - if (srcstyle && Strcmp(srcstyle, "underscore") == 0) { - if (newprefix != NIL) { - String *newstem = nameToModula3(stem, true); - newname = NewStringf("%s%s", newprefix, newstem); - Delete(newstem); - } else { - newname = nameToModula3(stem, true); - } - } else { - if (srcstyle != NIL) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Unknown C identifier style <%s>.\n", srcstyle); - } - newname = Copy(name); - } - - if (Strcmp(pragma, "enumitem") == 0) { - if (Len(relationdesc) != 1) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Expected <enumeration>, got <%s>.\n", relationstr); - } - Setfeature(n, "modula3:enumitem:name", newname, true); - Setfeature(n, "modula3:enumitem:enum", relationstr, true); - Setfeature(n, "modula3:enumitem:conv", NewStringf("%s:int", srctype), true); - } else if (Strcmp(pragma, "constint") == 0) { - if (Len(relationdesc) != 1) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Expected <ordinal type>, got <%s>.\n", relationstr); - } - Setfeature(n, "modula3:constint:name", newname, true); - Setfeature(n, "modula3:constint:type", Getitem(relationdesc, 0), true); - Setfeature(n, "modula3:constint:conv", NewStringf("%s:int", srctype), true); - } else if (Strcmp(pragma, "constset") == 0) { - if (Len(relationdesc) != 2) { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Expected <set type,base type>, got <%s>.\n", relationstr); - } - String *settype = Getitem(relationdesc, 0); - Setfeature(n, "modula3:constset:name", newname, true); - //Setfeature(n,"modula3:constset:type",settype,true); - Setfeature(n, "modula3:constset:set", settype, true); - Setfeature(n, "modula3:constset:base", Getitem(relationdesc, 1), true); - Setfeature(n, "modula3:constset:conv", NewStringf("%s:set", srctype), true); - } - - Delete(newname); - Delete(relationdesc); - } - - if (Strcmp(nodeType(n), "enum") == 0) { - //printf("explore enum %s, qualification %s\n", Char(name), Char(Swig_symbol_qualified(n))); - tagConstants(firstChild(n), name, pat, pragma, convdesc); - } else { - tagConstants(firstChild(n), NIL, pat, pragma, convdesc); - } - n = nextSibling(n); - } - } - - void scanForConstPragmas(Node *n) { - Node *child = firstChild(n); - while (child != NIL) { - const String *type = nodeType(child); - if (Strcmp(type, "pragma") == 0) { - const String *lang = Getattr(child, "lang"); - const String *code = Getattr(child, "name"); - String *value = Getattr(child, "value"); - - if (Strcmp(lang, "modula3") == 0) { - const_pragma_type cpt = cpt_none; - if (Strcmp(code, "constint") == 0) { - cpt = cpt_constint; - } else if (Strcmp(code, "constset") == 0) { - cpt = cpt_constset; - } else if (Strcmp(code, "enumitem") == 0) { - cpt = cpt_enumitem; - } - if (cpt != cpt_none) { - const_id_pattern pat = { NIL, NIL }; - - List *convdesc = Split(value, ';', 4); - List *patterndesc = Split(Getitem(convdesc, 0), ',', INT_MAX); - Iterator patternit; - for (patternit = First(patterndesc); patternit.item != NIL; patternit = Next(patternit)) { - List *patternassign = Split(patternit.item, '=', 2); - String *tag = Getitem(patternassign, 0); - String *data = Getitem(patternassign, 1); - if (Strcmp(tag, "prefix") == 0) { - pat.prefix = Copy(data); - } else if (Strcmp(tag, "enum") == 0) { - pat.parentEnum = Copy(data); - } else { - Swig_warning(WARN_MODULA3_BAD_ENUMERATION, input_file, line_number, "Unknown identification tag <%s> with value <%s>.\n", tag, data); - } - Delete(patternassign); - } - tagConstants(child, NIL, pat, code, convdesc); - - Delete(patterndesc); - } - } - } - scanForConstPragmas(child); - child = nextSibling(child); - } - } - - /* ----------------------------------------------------------------------------- - * emitProxyClassDefAndCPPCasts() - * ----------------------------------------------------------------------------- */ - - void emitProxyClassDefAndCPPCasts(Node *n) { - String *c_classname = SwigType_namestr(Getattr(n, "name")); - String *c_baseclass = NULL; - String *baseclass = NULL; - String *c_baseclassname = NULL; - String *name = Getattr(n, "name"); - - /* Deal with inheritance */ - List *baselist = Getattr(n, "bases"); - if (baselist) { - Iterator base = First(baselist); - while (base.item) { - if (!GetFlag(base.item, "feature:ignore")) { - String *baseclassname = Getattr(base.item, "name"); - if (!c_baseclassname) { - c_baseclassname = baseclassname; - baseclass = Copy(getProxyName(baseclassname)); - if (baseclass) - c_baseclass = SwigType_namestr(baseclassname); - } else { - /* Warn about multiple inheritance for additional base class(es) */ - String *proxyclassname = Getattr(n, "classtypeobj"); - Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n), - "Warning for %s, base %s ignored. Multiple inheritance is not supported in Modula 3.\n", SwigType_namestr(proxyclassname), SwigType_namestr(baseclassname)); - } - } - base = Next(base); - } - } - - bool derived = baseclass && getProxyName(c_baseclassname); - if (!baseclass) - baseclass = NewString(""); - - // Inheritance from pure Modula 3 classes - const String *pure_baseclass = typemapLookup(n, "m3base", name, WARN_NONE); - if (hasContent(pure_baseclass) && hasContent(baseclass)) { - Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n), - "Warning for %s, base %s ignored. Multiple inheritance is not supported in Modula 3.\n", name, pure_baseclass); - } - // Pure Modula 3 interfaces - const String *pure_interfaces = typemapLookup(n, derived ? "m3interfaces_derived" : "m3interfaces", - name, WARN_NONE); - - // Start writing the proxy class - Printv(proxy_class_def, typemapLookup(n, "m3imports", name, WARN_NONE), // Import statements - "\n", typemapLookup(n, "m3classmodifiers", name, WARN_MODULA3_TYPEMAP_CLASSMOD_UNDEF), // Class modifiers - " class $m3classname", // Class name and bases - (derived || *Char(pure_baseclass) || *Char(pure_interfaces)) ? " : " : "", baseclass, pure_baseclass, ((derived || *Char(pure_baseclass)) && *Char(pure_interfaces)) ? // Interfaces - ", " : "", pure_interfaces, " {\n", " private IntPtr swigCPtr;\n", // Member variables for memory handling - derived ? "" : " protected bool swigCMemOwn;\n", "\n", " ", typemapLookup(n, "m3ptrconstructormodifiers", name, WARN_MODULA3_TYPEMAP_PTRCONSTMOD_UNDEF), // pointer constructor modifiers - " $m3classname(IntPtr cPtr, bool cMemoryOwn) ", // Constructor used for wrapping pointers - derived ? - ": base($imclassname.$m3classnameTo$baseclass(cPtr), cMemoryOwn) {\n" - : "{\n swigCMemOwn = cMemoryOwn;\n", " swigCPtr = cPtr;\n", " }\n", NIL); - - if (!have_default_constructor_flag) { // All proxy classes need a constructor - Printv(proxy_class_def, "\n", " protected $m3classname() : this(IntPtr.Zero, false) {\n", " }\n", NIL); - } - // C++ destructor is wrapped by the Dispose method - // Note that the method name is specified in a typemap attribute called methodname - String *destruct = NewString(""); - const String *tm = NULL; - Node *attributes = NewHash(); - String *destruct_methodname = NULL; - if (derived) { - tm = typemapLookup(n, "m3destruct_derived", name, WARN_NONE, attributes); - destruct_methodname = Getattr(attributes, "tmap:m3destruct_derived:methodname"); - } else { - tm = typemapLookup(n, "m3destruct", name, WARN_NONE, attributes); - destruct_methodname = Getattr(attributes, "tmap:m3destruct:methodname"); - } - if (!destruct_methodname) { - Swig_error(Getfile(n), Getline(n), "No methodname attribute defined in m3destruct%s typemap for %s\n", (derived ? "_derived" : ""), proxy_class_name); - } - // Emit the Finalize and Dispose methods - if (tm) { - // Finalize method - if (*Char(destructor_call)) { - Printv(proxy_class_def, typemapLookup(n, "m3finalize", name, WARN_NONE), NIL); - } - // Dispose method - Printv(destruct, tm, NIL); - if (*Char(destructor_call)) - Replaceall(destruct, "$imcall", destructor_call); - else - Replaceall(destruct, "$imcall", "throw new MethodAccessException(\"C++ destructor does not have public access\")"); - if (*Char(destruct)) - Printv(proxy_class_def, "\n public ", derived ? "override" : "virtual", " void ", destruct_methodname, "() ", destruct, "\n", NIL); - } - Delete(attributes); - Delete(destruct); - - // Emit various other methods - Printv(proxy_class_def, typemapLookup(n, "m3getcptr", name, WARN_MODULA3_TYPEMAP_GETCPTR_UNDEF), // getCPtr method - typemapLookup(n, "m3code", name, WARN_NONE), // extra Modula 3 code - "\n", NIL); - - // Substitute various strings into the above template - Replaceall(proxy_class_def, "$m3classname", proxy_class_name); - Replaceall(proxy_class_code, "$m3classname", proxy_class_name); - - Replaceall(proxy_class_def, "$baseclass", baseclass); - Replaceall(proxy_class_code, "$baseclass", baseclass); - - Replaceall(proxy_class_def, "$imclassname", m3raw_name); - Replaceall(proxy_class_code, "$imclassname", m3raw_name); - - // Add code to do C++ casting to base class (only for classes in an inheritance hierarchy) - if (derived) { - Printv(m3raw_cppcasts_code, "\n [DllImport(\"", m3wrap_name, "\", EntryPoint=\"Modula3_", proxy_class_name, "To", baseclass, "\")]\n", NIL); - Printv(m3raw_cppcasts_code, " public static extern IntPtr ", "$m3classnameTo$baseclass(IntPtr objectRef);\n", NIL); - - Replaceall(m3raw_cppcasts_code, "$m3classname", proxy_class_name); - Replaceall(m3raw_cppcasts_code, "$baseclass", baseclass); - - Printv(upcasts_code, - "SWIGEXPORT long Modula3_$imclazznameTo$imbaseclass", - "(long objectRef) {\n", - " long baseptr = 0;\n" " *($cbaseclass **)&baseptr = *($cclass **)&objectRef;\n" " return baseptr;\n" "}\n", "\n", NIL); - - Replaceall(upcasts_code, "$imbaseclass", baseclass); - Replaceall(upcasts_code, "$cbaseclass", c_baseclass); - Replaceall(upcasts_code, "$imclazzname", proxy_class_name); - Replaceall(upcasts_code, "$cclass", c_classname); - } - Delete(baseclass); - } - - /* ---------------------------------------------------------------------- - * getAttrString() - * - * If necessary create and return the string - * associated with a certain attribute of 'n'. - * ---------------------------------------------------------------------- */ - - String *getAttrString(Node *n, const char *attr) { - String *str = Getattr(n, attr); - if (str == NIL) { - str = NewString(""); - Setattr(n, attr, str); - } - return str; - } - - /* ---------------------------------------------------------------------- - * getMethodDeclarations() - * - * If necessary create and return the handle - * where the methods of the current access can be written to. - * 'n' must be a member of a struct or a class. - * ---------------------------------------------------------------------- */ - - String *getMethodDeclarations(Node *n) { - String *acc_str = Getattr(n, "access"); - String *methodattr; - if (acc_str == NIL) { - methodattr = NewString("modula3:method:public"); - } else { - methodattr = NewStringf("modula3:method:%s", acc_str); - } - String *methods = getAttrString(parentNode(n), Char(methodattr)); - Delete(methodattr); - return methods; - } - - /* ---------------------------------------------------------------------- - * classHandler() - * ---------------------------------------------------------------------- */ - - virtual int classHandler(Node *n) { - - File *f_proxy = NULL; - proxy_class_name = Copy(Getattr(n, "sym:name")); - //String *rawname = Getattr(n,"name"); - - if (proxy_flag) { - if (!addSymbol(proxy_class_name, n)) - return SWIG_ERROR; - - if (Cmp(proxy_class_name, m3raw_name) == 0) { - Printf(stderr, "Class name cannot be equal to intermediary class name: %s\n", proxy_class_name); - SWIG_exit(EXIT_FAILURE); - } - - if (Cmp(proxy_class_name, m3wrap_name) == 0) { - Printf(stderr, "Class name cannot be equal to module class name: %s\n", proxy_class_name); - SWIG_exit(EXIT_FAILURE); - } - - String *filen = NewStringf("%s%s.m3", SWIG_output_directory(), proxy_class_name); - f_proxy = NewFile(filen, "w", SWIG_output_files()); - if (!f_proxy) { - FileErrorDisplay(filen); - SWIG_exit(EXIT_FAILURE); - } - Delete(filen); - filen = NULL; - - emitBanner(f_proxy); - - Clear(proxy_class_def); - Clear(proxy_class_code); - - have_default_constructor_flag = false; - destructor_call = NewString(""); - } - - /* This will invoke memberfunctionHandler, membervariableHandler ... - and finally it may invoke functionWrapper - for wrappers and member variable accessors. - It will invoke Language:constructorDeclaration - which decides whether to call MODULA3::constructorHandler */ - Language::classHandler(n); - - { - String *kind = Getattr(n, "kind"); - if (Cmp(kind, "struct") == 0) { - String *entries = NewString(""); - Node *child; - writeArgState state; - for (child = firstChild(n); child != NIL; child = nextSibling(child)) { - String *childType = nodeType(child); - if (Strcmp(childType, "cdecl") == 0) { - String *member = Getattr(child, "sym:name"); - ParmList *pl = Getattr(child, "parms"); - if (pl == NIL) { - // Get the variable type in Modula 3 type equivalents - String *m3ct = getMappedTypeNew(child, "m3rawtype", ""); - - writeArg(entries, state, NIL, member, m3ct, NIL); - } - } - } - writeArg(entries, state, NIL, NIL, NIL, NIL); - - m3raw_intf.enterBlock(blocktype); - Printf(m3raw_intf.f, "%s =\nRECORD\n%sEND;\n", proxy_class_name, entries); - - Delete(entries); - - } else if (Cmp(kind, "class") == 0) { - enum access_privilege { acc_public, acc_protected, acc_private }; - int max_acc = acc_public; - - const char *acc_name[3] = { "public", "protected", "private" }; - String *methods[3]; - int acc; - for (acc = acc_public; acc <= acc_private; acc++) { - String *methodattr = NewStringf("modula3:method:%s", acc_name[acc]); - methods[acc] = Getattr(n, methodattr); - Delete(methodattr); - max_acc = max_acc > acc ? max_acc : acc; - } - - /* Determine the name of the base class */ - String *baseclassname = NewString(""); - { - List *baselist = Getattr(n, "bases"); - if (baselist) { - /* Look for the first (principal?) base class - - Modula 3 does not support multiple inheritance */ - Iterator base = First(baselist); - if (base.item) { - Append(baseclassname, Getattr(base.item, "sym:name")); - base = Next(base); - if (base.item) { - Swig_warning(WARN_MODULA3_MULTIPLE_INHERITANCE, Getfile(n), Getline(n), - "Warning for %s, base %s ignored. Multiple inheritance is not supported in Modula 3.\n", - proxy_class_name, Getattr(base.item, "name")); - } - } - } - } - - /* the private class of the base class and only this - need a pointer to the C++ object */ - bool need_private = !hasContent(baseclassname); - max_acc = need_private ? acc_private : max_acc; - - /* Declare C++ object as abstract pointer in Modula 3 */ - /* The revelation system does not allow us - to imitate the whole class hierarchy of the C++ library, - but at least we can distinguish between classes of different roots. */ - if (hasContent(baseclassname)) { - m3raw_intf.enterBlock(blocktype); - Printf(m3raw_intf.f, "%s = %s;\n", proxy_class_name, baseclassname); - } else { - m3raw_intf.enterBlock(blocktype); - Printf(m3raw_intf.f, "%s <: ADDRESS;\n", proxy_class_name); - m3raw_impl.enterBlock(revelation); - Printf(m3raw_impl.f, "%s = UNTRACED BRANDED REF RECORD (*Dummy*) END;\n", proxy_class_name); - } - - String *superclass; - m3wrap_intf.enterBlock(blocktype); - if (hasContent(methods[acc_public])) { - superclass = NewStringf("%sPublic", proxy_class_name); - } else if (hasContent(baseclassname)) { - superclass = Copy(baseclassname); - } else { - superclass = NewString("ROOT"); - } - Printf(m3wrap_intf.f, "%s <: %s;\n", proxy_class_name, superclass); - Delete(superclass); - - { - static const char *acc_m3suffix[] = { "Public", "Protected", "Private" }; - int acc; - for (acc = acc_public; acc <= acc_private; acc++) { - bool process_private = (acc == acc_private) && need_private; - if (hasContent(methods[acc]) || process_private) { - String *subclass = NewStringf("%s%s", proxy_class_name, acc_m3suffix[acc]); - /* - m3wrap_intf.enterBlock(revelation); - Printf(m3wrap_intf.f, "%s <: %s;\n", proxy_class_name, subclass); - */ - if (acc == max_acc) { - m3wrap_intf.enterBlock(revelation); - Printf(m3wrap_intf.f, "%s =\n", proxy_class_name); - } else { - m3wrap_intf.enterBlock(blocktype); - Printf(m3wrap_intf.f, "%s =\n", subclass); - } - Printf(m3wrap_intf.f, "%s BRANDED OBJECT\n", baseclassname); - if (process_private) { - Setattr(m3wrap_intf.import, m3raw_name, ""); - Printf(m3wrap_intf.f, "cxxObj:%s.%s;\n", m3raw_name, proxy_class_name); - } - if (hasContent(methods[acc])) { - Printf(m3wrap_intf.f, "METHODS\n%s", methods[acc]); - } - if (acc == max_acc) { - String *overrides = Getattr(n, "modula3:override"); - Printf(m3wrap_intf.f, "OVERRIDES\n%s", overrides); - } - Printf(m3wrap_intf.f, "END;\n"); - Delete(baseclassname); - baseclassname = subclass; - } - } - } - - Delete(methods[acc_public]); - Delete(methods[acc_protected]); - Delete(methods[acc_private]); - - } else { - Swig_warning(WARN_MODULA3_TYPECONSTRUCTOR_UNKNOWN, input_file, line_number, "Unknown type constructor %s\n", kind); - } - } - - if (proxy_flag) { - - emitProxyClassDefAndCPPCasts(n); - - Printv(f_proxy, proxy_class_def, proxy_class_code, NIL); - - Printf(f_proxy, "}\n"); - Delete(f_proxy); - f_proxy = NULL; - - Delete(proxy_class_name); - proxy_class_name = NULL; - Delete(destructor_call); - destructor_call = NULL; - } - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * memberfunctionHandler() - * ---------------------------------------------------------------------- */ - - virtual int memberfunctionHandler(Node *n) { - //printf("begin memberfunctionHandler(%s)\n", Char(Getattr(n,"name"))); - Setattr(n, "modula3:functype", "method"); - Language::memberfunctionHandler(n); - - { - /* Language::memberfunctionHandler will remove the mapped types - that emitM3Wrapper may attach */ - ParmList *pl = Getattr(n, "parms"); - Swig_typemap_attach_parms("m3wrapinmode", pl, NULL); - Swig_typemap_attach_parms("m3wrapinname", pl, NULL); - Swig_typemap_attach_parms("m3wrapintype", pl, NULL); - Swig_typemap_attach_parms("m3wrapindefault", pl, NULL); - attachParameterNames(n, "tmap:m3wrapinname", "autoname", "arg%d"); - String *rettype = getMappedTypeNew(n, "m3wrapouttype", ""); - - String *methodname = Getattr(n, "sym:name"); -/* - if (methodname==NIL) { - methodname = Getattr(n,"name"); - } -*/ - String *arguments = createM3Signature(n); - String *storage = Getattr(n, "storage"); - String *overridden = Getattr(n, "override"); - bool isVirtual = (storage != NIL) && (Strcmp(storage, "virtual") == 0); - bool isOverridden = (overridden != NIL) - && (Strcmp(overridden, "1") == 0); - if ((!isVirtual) || (!isOverridden)) { - { - String *methods = getMethodDeclarations(n); - Printf(methods, "%s(%s)%s%s;%s\n", - methodname, arguments, - hasContent(rettype) ? ": " : "", hasContent(rettype) ? (const String *) rettype : "", isVirtual ? " (* base method *)" : ""); - } - { - /* this was attached by functionWrapper - invoked by Language::memberfunctionHandler */ - String *fname = Getattr(n, "modula3:funcname"); - String *overrides = getAttrString(parentNode(n), "modula3:override"); - Printf(overrides, "%s := %s;\n", methodname, fname); - } - } - } - - if (proxy_flag) { - String *overloaded_name = getOverloadedName(n); - String *intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, overloaded_name); - Setattr(n, "proxyfuncname", Getattr(n, "sym:name")); - Setattr(n, "imfuncname", intermediary_function_name); - proxyClassFunctionHandler(n); - Delete(overloaded_name); - } - //printf("end memberfunctionHandler(%s)\n", Char(Getattr(n,"name"))); - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * staticmemberfunctionHandler() - * ---------------------------------------------------------------------- */ - - virtual int staticmemberfunctionHandler(Node *n) { - - static_flag = true; - Language::staticmemberfunctionHandler(n); - - if (proxy_flag) { - String *overloaded_name = getOverloadedName(n); - String *intermediary_function_name = Swig_name_member(NSPACE_TODO, proxy_class_name, overloaded_name); - Setattr(n, "proxyfuncname", Getattr(n, "sym:name")); - Setattr(n, "imfuncname", intermediary_function_name); - proxyClassFunctionHandler(n); - Delete(overloaded_name); - } - static_flag = false; - - return SWIG_OK; - } - - /* ----------------------------------------------------------------------------- - * proxyClassFunctionHandler() - * - * Function called for creating a Modula 3 wrapper function around a c++ function in the - * proxy class. Used for both static and non-static C++ class functions. - * C++ class static functions map to Modula 3 static functions. - * Two extra attributes in the Node must be available. These are "proxyfuncname" - - * the name of the Modula 3 class proxy function, which in turn will call "imfuncname" - - * the intermediary (PInvoke) function name in the intermediary class. - * ----------------------------------------------------------------------------- */ - - void proxyClassFunctionHandler(Node *n) { - SwigType *t = Getattr(n, "type"); - ParmList *l = Getattr(n, "parms"); - Hash *throws_hash = NewHash(); - String *intermediary_function_name = Getattr(n, "imfuncname"); - String *proxy_function_name = Getattr(n, "proxyfuncname"); - String *tm; - Parm *p; - int i; - String *imcall = NewString(""); - String *return_type = NewString(""); - String *function_code = NewString(""); - bool setter_flag = false; - - if (!proxy_flag) - return; - - if (l) { - if (SwigType_type(Getattr(l, "type")) == T_VOID) { - l = nextSibling(l); - } - } - - /* Attach the non-standard typemaps to the parameter list */ - Swig_typemap_attach_parms("in", l, NULL); - Swig_typemap_attach_parms("m3wraptype", l, NULL); - Swig_typemap_attach_parms("m3in", l, NULL); - - /* Get return types */ - if ((tm = getMappedTypeNew(n, "m3wraptype", ""))) { - substituteClassname(t, tm); - Printf(return_type, "%s", tm); - } - - if (proxy_flag && wrapping_member_flag && !enum_constant_flag) { - // Properties - setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, proxy_class_name, variable_name))) - == 0); - } - - /* Start generating the proxy function */ - Printf(function_code, " %s ", Getattr(n, "feature:modula3:methodmodifiers")); - if (static_flag) - Printf(function_code, "static "); - if (Getattr(n, "override")) - Printf(function_code, "override "); - else if (checkAttribute(n, "storage", "virtual")) - Printf(function_code, "virtual "); - - Printf(function_code, "%s %s(", return_type, proxy_function_name); - - Printv(imcall, m3raw_name, ".", intermediary_function_name, "(", NIL); - if (!static_flag) - Printv(imcall, "swigCPtr", NIL); - - emit_mark_varargs(l); - - int gencomma = !static_flag; - - /* Output each parameter */ - for (i = 0, p = l; p; i++) { - - /* Ignored varargs */ - if (checkAttribute(p, "varargs:ignore", "1")) { - p = nextSibling(p); - continue; - } - - /* Ignored parameters */ - if (checkAttribute(p, "tmap:in:numinputs", "0")) { - p = Getattr(p, "tmap:in:next"); - continue; - } - - /* Ignore the 'this' argument for variable wrappers */ - if (!(variable_wrapper_flag && i == 0)) { - SwigType *pt = Getattr(p, "type"); - String *param_type = NewString(""); - - /* Get the Modula 3 parameter type */ - if ((tm = getMappedType(p, "m3wraptype"))) { - substituteClassname(pt, tm); - Printf(param_type, "%s", tm); - } - - if (gencomma) - Printf(imcall, ", "); - - String *arg = variable_wrapper_flag ? NewString("value") : makeParameterName(n, - p, - i); - - // Use typemaps to transform type used in Modula 3 wrapper function (in proxy class) to type used in PInvoke function (in intermediary class) - if ((tm = getMappedType(p, "in"))) { - addThrows(throws_hash, "in", p); - substituteClassname(pt, tm); - Replaceall(tm, "$input", arg); - Printv(imcall, tm, NIL); - } - - /* Add parameter to proxy function */ - if (gencomma >= 2) - Printf(function_code, ", "); - gencomma = 2; - Printf(function_code, "%s %s", param_type, arg); - - Delete(arg); - Delete(param_type); - } - p = Getattr(p, "tmap:in:next"); - } - - Printf(imcall, ")"); - Printf(function_code, ")"); - - // Transform return type used in PInvoke function (in intermediary class) to type used in Modula 3 wrapper function (in proxy class) - if ((tm = getMappedTypeNew(n, "m3out", ""))) { - addThrows(throws_hash, "m3out", n); - if (GetFlag(n, "feature:new")) - Replaceall(tm, "$owner", "true"); - else - Replaceall(tm, "$owner", "false"); - substituteClassname(t, tm); - Replaceall(tm, "$imcall", imcall); - } - - generateThrowsClause(throws_hash, function_code); - Printf(function_code, " %s\n\n", tm ? (const String *) tm : empty_string); - - if (proxy_flag && wrapping_member_flag && !enum_constant_flag) { - // Properties - if (setter_flag) { - // Setter method - if ((tm = getMappedTypeNew(n, "m3varin", ""))) { - if (GetFlag(n, "feature:new")) - Replaceall(tm, "$owner", "true"); - else - Replaceall(tm, "$owner", "false"); - substituteClassname(t, tm); - Replaceall(tm, "$imcall", imcall); - Printf(proxy_class_code, "%s", tm); - } - } else { - // Getter method - if ((tm = getMappedTypeNew(n, "m3varout", ""))) { - if (GetFlag(n, "feature:new")) - Replaceall(tm, "$owner", "true"); - else - Replaceall(tm, "$owner", "false"); - substituteClassname(t, tm); - Replaceall(tm, "$imcall", imcall); - Printf(proxy_class_code, "%s", tm); - } - } - } else { - // Normal function call - Printv(proxy_class_code, function_code, NIL); - } - - Delete(function_code); - Delete(return_type); - Delete(imcall); - Delete(throws_hash); - } - - /* ---------------------------------------------------------------------- - * constructorHandler() - * ---------------------------------------------------------------------- */ - - virtual int constructorHandler(Node *n) { - // this invokes functionWrapper - Language::constructorHandler(n); - - if (proxy_flag) { - ParmList *l = Getattr(n, "parms"); - - Hash *throws_hash = NewHash(); - String *overloaded_name = getOverloadedName(n); - String *imcall = NewString(""); - - Printf(proxy_class_code, " %s %s(", Getattr(n, "feature:modula3:methodmodifiers"), proxy_class_name); - Printv(imcall, " : this(", m3raw_name, ".", Swig_name_construct(NSPACE_TODO, overloaded_name), "(", NIL); - - /* Attach the non-standard typemaps to the parameter list */ - Swig_typemap_attach_parms("in", l, NULL); - Swig_typemap_attach_parms("m3wraptype", l, NULL); - Swig_typemap_attach_parms("m3in", l, NULL); - - emit_mark_varargs(l); - - int gencomma = 0; - - String *tm; - Parm *p = l; - int i; - - /* Output each parameter */ - for (i = 0; p; i++) { - - /* Ignored varargs */ - if (checkAttribute(p, "varargs:ignore", "1")) { - p = nextSibling(p); - continue; - } - - /* Ignored parameters */ - if (checkAttribute(p, "tmap:in:numinputs", "0")) { - p = Getattr(p, "tmap:in:next"); - continue; - } - - SwigType *pt = Getattr(p, "type"); - String *param_type = NewString(""); - - /* Get the Modula 3 parameter type */ - if ((tm = getMappedType(p, "m3wraptype"))) { - substituteClassname(pt, tm); - Printf(param_type, "%s", tm); - } - - if (gencomma) - Printf(imcall, ", "); - - String *arg = makeParameterName(n, p, i); - - // Use typemaps to transform type used in Modula 3 wrapper function (in proxy class) to type used in PInvoke function (in intermediary class) - if ((tm = getMappedType(p, "in"))) { - addThrows(throws_hash, "in", p); - substituteClassname(pt, tm); - Replaceall(tm, "$input", arg); - Printv(imcall, tm, NIL); - } - - /* Add parameter to proxy function */ - if (gencomma) - Printf(proxy_class_code, ", "); - Printf(proxy_class_code, "%s %s", param_type, arg); - gencomma = 1; - - Delete(arg); - Delete(param_type); - p = Getattr(p, "tmap:in:next"); - } - - Printf(imcall, "), true)"); - - Printf(proxy_class_code, ")"); - Printf(proxy_class_code, "%s", imcall); - generateThrowsClause(throws_hash, proxy_class_code); - Printf(proxy_class_code, " {\n"); - Printf(proxy_class_code, " }\n\n"); - - if (!gencomma) // We must have a default constructor - have_default_constructor_flag = true; - - Delete(overloaded_name); - Delete(imcall); - Delete(throws_hash); - } - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * destructorHandler() - * ---------------------------------------------------------------------- */ - - virtual int destructorHandler(Node *n) { - Language::destructorHandler(n); - String *symname = Getattr(n, "sym:name"); - - if (proxy_flag) { - Printv(destructor_call, m3raw_name, ".", Swig_name_destroy(NSPACE_TODO, symname), "(swigCPtr)", NIL); - } - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * membervariableHandler() - * ---------------------------------------------------------------------- */ - - virtual int membervariableHandler(Node *n) { - //printf("begin membervariableHandler(%s)\n", Char(Getattr(n,"name"))); - SwigType *t = Getattr(n, "type"); - String *tm; - - // Get the variable type - if ((tm = getMappedTypeNew(n, "m3wraptype", ""))) { - substituteClassname(t, tm); - } - - variable_name = Getattr(n, "sym:name"); - //printf("member variable: %s\n", Char(variable_name)); - - // Output the property's field declaration and accessor methods - Printf(proxy_class_code, " public %s %s {", tm, variable_name); - - Setattr(n, "modula3:functype", "accessor"); - wrapping_member_flag = true; - variable_wrapper_flag = true; - Language::membervariableHandler(n); - wrapping_member_flag = false; - variable_wrapper_flag = false; - - Printf(proxy_class_code, "\n }\n\n"); - - { - String *methods = getMethodDeclarations(n); - String *overrides = getAttrString(parentNode(n), "modula3:override"); - SwigType *type = Getattr(n, "type"); - String *m3name = capitalizeFirst(variable_name); - //String *m3name = nameToModula3(variable_name,true); - if (!SwigType_isconst(type)) { - { - String *inmode = getMappedTypeNew(n, "m3wrapinmode", "", false); - String *intype = getMappedTypeNew(n, "m3wrapintype", ""); - Printf(methods, "set%s(%s val:%s);\n", m3name, (inmode != NIL) ? (const String *) inmode : "", intype); - } - { - /* this was attached by functionWrapper - invoked by Language::memberfunctionHandler */ - String *fname = Getattr(n, "modula3:setname"); - Printf(overrides, "set%s := %s;\n", m3name, fname); - } - } - { - { - String *outtype = getMappedTypeNew(n, "m3wrapouttype", ""); - Printf(methods, "get%s():%s;\n", m3name, outtype); - } - { - /* this was attached by functionWrapper - invoked by Language::memberfunctionHandler */ - String *fname = Getattr(n, "modula3:getname"); - Printf(overrides, "get%s := %s;\n", m3name, fname); - } - } - Delete(m3name); - } - //printf("end membervariableHandler(%s)\n", Char(Getattr(n,"name"))); - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * staticmembervariableHandler() - * ---------------------------------------------------------------------- */ - - virtual int staticmembervariableHandler(Node *n) { - - bool static_const_member_flag = (Getattr(n, "value") == 0); - if (static_const_member_flag) { - SwigType *t = Getattr(n, "type"); - String *tm; - - // Get the variable type - if ((tm = getMappedTypeNew(n, "m3wraptype", ""))) { - substituteClassname(t, tm); - } - // Output the property's field declaration and accessor methods - Printf(proxy_class_code, " public static %s %s {", tm, Getattr(n, "sym:name")); - } - - variable_name = Getattr(n, "sym:name"); - wrapping_member_flag = true; - static_flag = true; - Language::staticmembervariableHandler(n); - wrapping_member_flag = false; - static_flag = false; - - if (static_const_member_flag) - Printf(proxy_class_code, "\n }\n\n"); - - return SWIG_OK; - } - - /* ---------------------------------------------------------------------- - * memberconstantHandler() - * ---------------------------------------------------------------------- */ - - virtual int memberconstantHandler(Node *n) { - variable_name = Getattr(n, "sym:name"); - wrapping_member_flag = true; - Language::memberconstantHandler(n); - wrapping_member_flag = false; - return SWIG_OK; - } - - /* ----------------------------------------------------------------------------- - * getOverloadedName() - * ----------------------------------------------------------------------------- */ - - String *getOverloadedName(Node *n) { - String *overloaded_name = Copy(Getattr(n, "sym:name")); - - if (Getattr(n, "sym:overloaded")) { - Printv(overloaded_name, Getattr(n, "sym:overname"), NIL); - } - - return overloaded_name; - } - - /* ----------------------------------------------------------------------------- - * emitM3Wrapper() - * It is also used for set and get methods of global variables. - * ----------------------------------------------------------------------------- */ - - void emitM3Wrapper(Node *n, const String *func_name) { - SwigType *t = Getattr(n, "type"); - ParmList *l = Getattr(n, "parms"); - Hash *throws_hash = NewHash(); - int num_exceptions = 0; - int num_returns = 0; - String *rawcall = NewString(""); - String *reccall = NewString(""); - String *local_variables = NewString(""); - String *local_constants = NewString(""); - String *incheck = NewString(""); - String *outcheck = NewString(""); - String *setup = NewString(""); - String *cleanup = NewString(""); - String *outarg = NewString(""); /* don't mix up with 'autark' :-] */ - String *storeout = NewString(""); - String *result_name = NewString(""); - String *return_variables = NewString(""); - const char *result_return = "ret"; - String *function_code = NewString(""); - /*several names for the same function */ - String *raw_name = Getattr(n, "name"); /*original C function name */ - //String *func_name = Getattr(n,"sym:name"); /*final Modula3 name chosen by the user*/ - bool setter_flag = false; - int multiretval = GetFlag(n, "feature:modula3:multiretval"); - - if (l) { - if (SwigType_type(Getattr(l, "type")) == T_VOID) { - l = nextSibling(l); - } - } - - /* Attach the non-standard typemaps to the parameter list */ - Swig_typemap_attach_parms("m3wrapargvar", l, NULL); - Swig_typemap_attach_parms("m3wrapargconst", l, NULL); - Swig_typemap_attach_parms("m3wrapargraw", l, NULL); - Swig_typemap_attach_parms("m3wrapargdir", l, NULL); - Swig_typemap_attach_parms("m3wrapinmode", l, NULL); - Swig_typemap_attach_parms("m3wrapinname", l, NULL); - Swig_typemap_attach_parms("m3wrapintype", l, NULL); - Swig_typemap_attach_parms("m3wrapindefault", l, NULL); - Swig_typemap_attach_parms("m3wrapinconv", l, NULL); - Swig_typemap_attach_parms("m3wrapincheck", l, NULL); - Swig_typemap_attach_parms("m3wrapoutname", l, NULL); - Swig_typemap_attach_parms("m3wrapouttype", l, NULL); - Swig_typemap_attach_parms("m3wrapoutconv", l, NULL); - Swig_typemap_attach_parms("m3wrapoutcheck", l, NULL); - - attachMappedType(n, "m3wrapretraw"); - attachMappedType(n, "m3wrapretname"); - attachMappedType(n, "m3wraprettype"); - attachMappedType(n, "m3wrapretvar"); - attachMappedType(n, "m3wrapretconv"); - attachMappedType(n, "m3wrapretcheck"); - - Swig_typemap_attach_parms("m3wrapfreearg", l, NULL); - -/* - Swig_typemap_attach_parms("m3wrapargvar:throws", l, NULL); - Swig_typemap_attach_parms("m3wrapargraw:throws", l, NULL); - Swig_typemap_attach_parms("m3wrapinconv:throws", l, NULL); - Swig_typemap_attach_parms("m3wrapincheck:throws", l, NULL); - Swig_typemap_attach_parms("m3wrapoutconv:throws", l, NULL); - Swig_typemap_attach_parms("m3wrapoutcheck:throws", l, NULL); - - attachMappedType(n, "m3wrapretvar:throws"); - attachMappedType(n, "m3wrapretconv:throws"); - attachMappedType(n, "m3wrapretcheck:throws"); - - Swig_typemap_attach_parms("m3wrapfreearg:throws", l, NULL); -*/ - - /* Attach argument names to the parameter list */ - /* should be a separate procedure making use of hashes */ - attachParameterNames(n, "tmap:m3wrapinname", "autoname", "arg%d"); - - /* Get return types */ - String *result_m3rawtype = Copy(getMappedTypeNew(n, "m3rawrettype", "")); - String *result_m3wraptype = Copy(getMappedTypeNew(n, "m3wraprettype", "")); - bool has_return_raw = hasContent(result_m3rawtype); - bool has_return_m3 = hasContent(result_m3wraptype); - if (has_return_m3) { - num_returns++; - //printf("%s: %s\n", Char(func_name),Char(result_m3wraptype)); - } - - String *arguments = createM3Signature(n); - - /* Create local variables or RECORD fields for return values - and determine return type that might result from a converted VAR argument. */ - { - writeArgState state; - if (multiretval && has_return_m3) { - writeArg(return_variables, state, NIL, NewString(result_return), result_m3wraptype, NIL); - } - - Parm *p = skipIgnored(l, "m3wrapouttype"); - while (p != NIL) { - - String *arg = Getattr(p, "tmap:m3wrapoutname"); - if (arg == NIL) { - arg = Getattr(p, "name"); - } - - String *tm = Getattr(p, "tmap:m3wrapouttype"); - if (tm != NIL) { - if (isOutParam(p)) { - if (!multiretval) { - if (num_returns == 0) { - Printv(result_name, arg, NIL); - Clear(result_m3wraptype); - Printv(result_m3wraptype, tm, NIL); - } else { - Swig_warning(WARN_MODULA3_TYPEMAP_MULTIPLE_RETURN, input_file, line_number, - "Typemap m3wrapargdir set to 'out' for %s implies a RETURN value, but the routine %s has already one.\nUse %%multiretval feature.\n", - SwigType_str(Getattr(p, "type"), 0), raw_name); - } - } - num_returns++; - addImports(m3wrap_intf.import, "m3wrapouttype", p); - writeArg(return_variables, state, NIL, arg, tm, NIL); - } - p = skipIgnored(Getattr(p, "tmap:m3wrapouttype:next"), "m3wrapouttype"); - } else { - p = nextSibling(p); - } - } - writeArg(return_variables, state, NIL, NIL, NIL, NIL); - - if (multiretval) { - Printv(result_name, Swig_cresult_name(), NIL); - Printf(result_m3wraptype, "%sResult", func_name); - m3wrap_intf.enterBlock(blocktype); - Printf(m3wrap_intf.f, "%s =\nRECORD\n%sEND;\n", result_m3wraptype, return_variables); - Printf(local_variables, "%s: %s;\n", result_name, result_m3wraptype); - } else { - Append(local_variables, return_variables); - } - } - - /* Declare local constants e.g. for storing argument names. */ - { - Parm *p = l; - while (p != NIL) { - - String *arg = Getattr(p, "autoname"); - - String *tm = Getattr(p, "tmap:m3wrapargconst"); - if (tm != NIL) { - addImports(m3wrap_impl.import, "m3wrapargconst", p); - Replaceall(tm, "$input", arg); - Printv(local_constants, tm, "\n", NIL); - p = Getattr(p, "tmap:m3wrapargconst:next"); - } else { - p = nextSibling(p); - } - - } - } - - /* Declare local variables e.g. for converted input values. */ - { - String *tm = getMappedTypeNew(n, "m3wrapretvar", "", false); - if (tm != NIL) { - addImports(m3wrap_impl.import, "m3wrapretvar", n); - addThrows(throws_hash, "m3wrapretvar", n); - Printv(local_variables, tm, "\n", NIL); - } - - Parm *p = l; - while (p != NIL) { - - String *arg = Getattr(p, "autoname"); - - tm = Getattr(p, "tmap:m3wrapargvar"); - if (tm != NIL) { - /* exceptions that may be raised but can't be caught, - thus we won't count them in num_exceptions */ - addImports(m3wrap_impl.import, "m3wrapargvar", p); - addThrows(throws_hash, "m3wrapargvar", p); - Replaceall(tm, "$input", arg); - Printv(local_variables, tm, "\n", NIL); - p = Getattr(p, "tmap:m3wrapargvar:next"); - } else { - p = nextSibling(p); - } - - } - } - - /* Convert input values from Modula 3 to C. */ - { - Parm *p = l; - while (p != NIL) { - - String *arg = Getattr(p, "autoname"); - - String *tm = Getattr(p, "tmap:m3wrapinconv"); - if (tm != NIL) { - addImports(m3wrap_impl.import, "m3wrapinconv", p); - num_exceptions += addThrows(throws_hash, "m3wrapinconv", p); - Replaceall(tm, "$input", arg); - Printv(setup, tm, "\n", NIL); - p = Getattr(p, "tmap:m3wrapinconv:next"); - } else { - p = nextSibling(p); - } - - } - } - - /* Generate checks for input value integrity. */ - { - Parm *p = l; - while (p != NIL) { - - String *arg = Getattr(p, "autoname"); - - String *tm = Getattr(p, "tmap:m3wrapincheck"); - if (tm != NIL) { - addImports(m3wrap_impl.import, "m3wrapincheck", p); - num_exceptions += addThrows(throws_hash, "m3wrapincheck", p); - Replaceall(tm, "$input", arg); - Printv(incheck, tm, "\n", NIL); - p = Getattr(p, "tmap:m3wrapincheck:next"); - } else { - p = nextSibling(p); - } - - } - } - - Printv(rawcall, m3raw_name, ".", func_name, "(", NIL); - /* Arguments to the raw C function */ - { - bool gencomma = false; - Parm *p = l; - while (p != NIL) { - if (gencomma) { - Printf(rawcall, ", "); - } - gencomma = true; - addImports(m3wrap_impl.import, "m3wrapargraw", p); - num_exceptions += addThrows(throws_hash, "m3wrapargraw", p); - - String *arg = Getattr(p, "autoname"); - String *qualarg = NewString(""); - if (!isInParam(p)) { - String *tmparg = Getattr(p, "tmap:m3wrapoutname"); - if (tmparg != NIL) { - arg = tmparg; - } - if (multiretval /*&& isOutParam(p) - automatically fulfilled */ ) { - Printf(qualarg, "%s.", result_name); - } - } - Append(qualarg, arg); - Setattr(p, "m3outarg", qualarg); - - String *tm = Getattr(p, "tmap:m3wrapargraw"); - if (tm != NIL) { - Replaceall(tm, "$input", arg); - Replaceall(tm, "$output", qualarg); - Printv(rawcall, tm, NIL); - p = Getattr(p, "tmap:m3wrapargraw:next"); - } else { - //Printv(rawcall, Getattr(p,"lname"), NIL); - Printv(rawcall, qualarg, NIL); - p = nextSibling(p); - } - Delete(qualarg); - } - } - Printf(rawcall, ")"); - - /* Check for error codes and integrity of results */ - { - String *tm = getMappedTypeNew(n, "m3wrapretcheck", "", false); - if (tm != NIL) { - addImports(m3wrap_impl.import, "m3wrapretcheck", n); - num_exceptions += addThrows(throws_hash, "m3wrapretcheck", n); - Printv(outcheck, tm, "\n", NIL); - } - - Parm *p = l; - while (p != NIL) { - tm = Getattr(p, "tmap:m3wrapoutcheck"); - if (tm != NIL) { - String *arg = Getattr(p, "autoname"); - String *outarg = Getattr(p, "m3outarg"); - addImports(m3wrap_impl.import, "m3wrapoutcheck", p); - num_exceptions += addThrows(throws_hash, "m3wrapoutcheck", p); - //substituteClassname(Getattr(p,"type"), tm); - Replaceall(tm, "$input", arg); - Replaceall(tm, "$output", outarg); - Printv(outcheck, tm, "\n", NIL); - p = Getattr(p, "tmap:m3wrapoutcheck:next"); - } else { - p = nextSibling(p); - } - } - } - - /* Convert the results to Modula 3 data structures and - put them in the record prepared for returning */ - { - /* m3wrapretconv is processed - when it is clear if there is some output conversion and checking code */ - Parm *p = l; - while (p != NIL) { - String *tm = Getattr(p, "tmap:m3wrapoutconv"); - if (tm != NIL) { - String *arg = Getattr(p, "autoname"); - String *outarg = Getattr(p, "m3outarg"); - addImports(m3wrap_impl.import, "m3wrapoutconv", n); - num_exceptions += addThrows(throws_hash, "m3wrapoutconv", p); - //substituteClassname(Getattr(p,"type"), tm); - Replaceall(tm, "$input", arg); - Replaceall(tm, "$output", outarg); - Printf(storeout, "%s := %s;\n", outarg, tm); - p = Getattr(p, "tmap:m3wrapoutconv:next"); - } else { - p = nextSibling(p); - } - } - } - - /* Generate cleanup code */ - { - Parm *p = l; - while (p != NIL) { - String *tm = Getattr(p, "tmap:m3wrapfreearg"); - if (tm != NIL) { - String *arg = Getattr(p, "autoname"); - String *outarg = Getattr(p, "m3outarg"); - addImports(m3wrap_impl.import, "m3wrapfreearg", p); - num_exceptions += addThrows(throws_hash, "m3wrapfreearg", p); - //substituteClassname(Getattr(p,"type"), tm); - Replaceall(tm, "$input", arg); - Replaceall(tm, "$output", outarg); - Printv(cleanup, tm, "\n", NIL); - p = Getattr(p, "tmap:m3wrapfreearg:next"); - } else { - p = nextSibling(p); - } - } - } - - { - /* Currently I don't know how a typemap similar to the original 'out' typemap - could help returning the return value. */ - /* Receive result from call to raw library function */ - if (!has_return_raw) { - /* - rawcall(arg1); - result.val := arg1; - RETURN result; - */ - /* - rawcall(arg1); - RETURN arg1; - */ - Printf(reccall, "%s;\n", rawcall); - - if (hasContent(result_name)) { - Printf(outarg, "RETURN %s;\n", result_name); - } - } else { - /* - arg0 := rawcall(arg1); - result.ret := Convert(arg0); - result.val := arg1; - RETURN result; - */ - /* - arg0 := rawcall(); - RETURN Convert(arg0); - */ - /* - RETURN rawcall(); - */ - String *return_raw = getMappedTypeNew(n, "m3wrapretraw", "", false); - String *return_conv = getMappedTypeNew(n, "m3wrapretconv", "", false); - - /* immediate RETURN would skip result checking */ - if ((hasContent(outcheck) || hasContent(storeout) - || hasContent(cleanup)) && (!hasContent(result_name)) - && (return_raw == NIL)) { - Printv(result_name, Swig_cresult_name(), NIL); - Printf(local_variables, "%s: %s;\n", result_name, result_m3wraptype); - } - - String *result_lvalue = Copy(result_name); - if (multiretval) { - Printf(result_lvalue, ".%s", result_return); - } - if (return_raw != NIL) { - Printf(reccall, "%s := %s;\n", return_raw, rawcall); - } else if (hasContent(result_name)) { - Printf(reccall, "%s := %s;\n", result_lvalue, rawcall); - } else { - Printf(outarg, "RETURN %s;\n", rawcall); - } - if (return_conv != NIL) { - addImports(m3wrap_impl.import, "m3wrapretconv", n); - num_exceptions += addThrows(throws_hash, "m3wrapretconv", n); - if (hasContent(result_name)) { - Printf(reccall, "%s := %s;\n", result_lvalue, return_conv); - Printf(outarg, "RETURN %s;\n", result_name); - } else { - Printf(outarg, "RETURN %s;\n", return_conv); - } - } else { - if (hasContent(result_name)) { - Printf(outarg, "RETURN %s;\n", result_name); - } - } - } - } - - /* Create procedure header */ - { - String *header = NewStringf("PROCEDURE %s (%s)", - func_name, arguments); - - if ((num_returns > 0) || multiretval) { - Printf(header, ": %s", result_m3wraptype); - } - generateThrowsClause(throws_hash, header); - - Append(function_code, header); - - m3wrap_intf.enterBlock(no_block); - Printf(m3wrap_intf.f, "%s;\n\n", header); - } - - { - String *body = NewStringf("%s%s%s%s%s", - incheck, - setup, - reccall, - outcheck, - storeout); - - String *exc_handler; - if (hasContent(cleanup) && (num_exceptions > 0)) { - exc_handler = NewStringf("TRY\n%sFINALLY\n%sEND;\n", body, cleanup); - } else { - exc_handler = NewStringf("%s%s", body, cleanup); - } - - Printf(function_code, " =\n%s%s%s%sBEGIN\n%s%sEND %s;\n\n", - hasContent(local_constants) ? "CONST\n" : "", local_constants, - hasContent(local_variables) ? "VAR\n" : "", local_variables, exc_handler, outarg, func_name); - - Delete(exc_handler); - Delete(body); - } - - m3wrap_impl.enterBlock(no_block); - if (proxy_flag && global_variable_flag) { - setter_flag = (Cmp(Getattr(n, "sym:name"), Swig_name_set(NSPACE_TODO, variable_name)) == 0); - // Properties - if (setter_flag) { - // Setter method - String *tm = getMappedTypeNew(n, "m3varin", ""); - if (tm != NIL) { - if (GetFlag(n, "feature:new")) { - Replaceall(tm, "$owner", "true"); - } else { - Replaceall(tm, "$owner", "false"); - } - substituteClassname(t, tm); - Replaceall(tm, "$rawcall", rawcall); - Replaceall(tm, "$vartype", variable_type); /* $type is already replaced by some super class */ - Replaceall(tm, "$var", variable_name); - Printf(m3wrap_impl.f, "%s", tm); - } - } else { - // Getter method - String *tm = getMappedTypeNew(n, "m3varout", ""); - if (tm != NIL) { - if (GetFlag(n, "feature:new")) - Replaceall(tm, "$owner", "true"); - else - Replaceall(tm, "$owner", "false"); - substituteClassname(t, tm); - Replaceall(tm, "$rawcall", rawcall); - Replaceall(tm, "$vartype", variable_type); - Replaceall(tm, "$var", variable_name); - Printf(m3wrap_impl.f, "%s", tm); - } - } - } else { - // Normal function call - Printv(m3wrap_impl.f, function_code, NIL); - } - - Delete(arguments); - Delete(return_variables); - Delete(local_variables); - Delete(local_constants); - Delete(outarg); - Delete(incheck); - Delete(outcheck); - Delete(setup); - Delete(cleanup); - Delete(storeout); - Delete(function_code); - Delete(result_name); - Delete(result_m3wraptype); - Delete(reccall); - Delete(rawcall); - Delete(throws_hash); - } - - /*---------------------------------------------------------------------- - * replaceSpecialVariables() - *--------------------------------------------------------------------*/ - - virtual void replaceSpecialVariables(String *method, String *tm, Parm *parm) { - (void)method; - SwigType *type = Getattr(parm, "type"); - substituteClassname(type, tm); - } - - /* ----------------------------------------------------------------------------- - * substituteClassname() - * - * Substitute the special variable $m3classname with the proxy class name for classes/structs/unions - * that SWIG knows about. - * Otherwise use the $descriptor name for the Modula 3 class name. Note that the $&m3classname substitution - * is the same as a $&descriptor substitution, ie one pointer added to descriptor name. - * Inputs: - * pt - parameter type - * tm - typemap contents that might contain the special variable to be replaced - * Outputs: - * tm - typemap contents complete with the special variable substitution - * Return: - * substitution_performed - flag indicating if a substitution was performed - * ----------------------------------------------------------------------------- */ - - bool substituteClassname(SwigType *pt, String *tm) { - bool substitution_performed = false; - if (Strstr(tm, "$m3classname") || Strstr(tm, "$&m3classname")) { - String *classname = getProxyName(pt); - if (classname) { - Replaceall(tm, "$&m3classname", classname); // getProxyName() works for pointers to classes too - Replaceall(tm, "$m3classname", classname); - } else { // use $descriptor if SWIG does not know anything about this type. Note that any typedefs are resolved. - String *descriptor = NULL; - SwigType *type = Copy(SwigType_typedef_resolve_all(pt)); - - if (Strstr(tm, "$&m3classname")) { - SwigType_add_pointer(type); - descriptor = NewStringf("SWIGTYPE%s", SwigType_manglestr(type)); - Replaceall(tm, "$&m3classname", descriptor); - } else { // $m3classname - descriptor = NewStringf("SWIGTYPE%s", SwigType_manglestr(type)); - Replaceall(tm, "$m3classname", descriptor); - } - - // Add to hash table so that the type wrapper classes can be created later - Setattr(swig_types_hash, descriptor, type); - Delete(descriptor); - Delete(type); - } - substitution_performed = true; - } - return substitution_performed; - } - - /* ----------------------------------------------------------------------------- - * attachParameterNames() - * - * Inputs: - * n - Node of a function declaration - * tmid - attribute name for overriding C argument names, - * e.g. "tmap:m3wrapinname", - * don't forget to attach the mapped types before - * nameid - attribute for attaching the names, - * e.g. "modula3:inname" - * fmt - format for the argument name containing %d - * e.g. "arg%d" - * ----------------------------------------------------------------------------- */ - - void attachParameterNames(Node *n, const char *tmid, const char *nameid, const char *fmt) { - /* Use C parameter name if present and unique, - otherwise create an 'arg%d' name */ - Hash *hash = NewHash(); - Parm *p = Getattr(n, "parms"); - int count = 0; - while (p != NIL) { - String *name = Getattr(p, tmid); - if (name == NIL) { - name = Getattr(p, "name"); - } - String *newname; - if ((!hasContent(name)) || (Getattr(hash, name) != NIL)) { - newname = NewStringf(fmt, count); - } else { - newname = Copy(name); - } - if (1 == Setattr(hash, newname, "1")) { - Swig_warning(WARN_MODULA3_DOUBLE_ID, input_file, line_number, "Argument '%s' twice.\n", newname); - } - Setattr(p, nameid, newname); -// Delete(newname); - p = nextSibling(p); - count++; - } - Delete(hash); - } - - /* ----------------------------------------------------------------------------- - * createM3Signature() - * - * Create signature of M3 wrapper procedure - * Call attachParameterNames and attach mapped types before! - * m3wrapintype, m3wrapinmode, m3wrapindefault - * ----------------------------------------------------------------------------- */ - - String *createM3Signature(Node *n) { - String *arguments = NewString(""); - Parm *p = skipIgnored(Getattr(n, "parms"), "m3wrapintype"); - writeArgState state; - while (p != NIL) { - - /* Get the M3 parameter type */ - String *tm = getMappedType(p, "m3wrapintype"); - if (tm != NIL) { - if (isInParam(p)) { - addImports(m3wrap_intf.import, "m3wrapintype", p); - addImports(m3wrap_impl.import, "m3wrapintype", p); - String *mode = Getattr(p, "tmap:m3wrapinmode"); - String *deflt = Getattr(p, "tmap:m3wrapindefault"); - String *arg = Getattr(p, "autoname"); - SwigType *pt = Getattr(p, "type"); - substituteClassname(pt, tm); /* do we need this ? */ - - writeArg(arguments, state, mode, arg, tm, deflt); - } - p = skipIgnored(Getattr(p, "tmap:m3wrapintype:next"), "m3wrapintype"); - } else { - p = nextSibling(p); - } - } - writeArg(arguments, state, NIL, NIL, NIL, NIL); - return (arguments); - } - -/* not used any longer - - try SwigType_str if required again */ -#if 0 - /* ----------------------------------------------------------------------------- - * createCSignature() - * - * Create signature of C function - * ----------------------------------------------------------------------------- */ - - String *createCSignature(Node *n) { - String *arguments = NewString(""); - bool gencomma = false; - Node *p; - for (p = Getattr(n, "parms"); p != NIL; p = nextSibling(p)) { - if (gencomma) { - Append(arguments, ","); - } - gencomma = true; - String *type = Getattr(p, "type"); - String *ctype = getMappedTypeNew(type, "ctype"); - Append(arguments, ctype); - } - return arguments; - } -#endif - - /* ----------------------------------------------------------------------------- - * emitTypeWrapperClass() - * ----------------------------------------------------------------------------- */ - - void emitTypeWrapperClass(String *classname, SwigType *type) { - Node *n = NewHash(); - Setfile(n, input_file); - Setline(n, line_number); - - String *filen = NewStringf("%s%s.m3", SWIG_output_directory(), classname); - File *f_swigtype = NewFile(filen, "w", SWIG_output_files()); - if (!f_swigtype) { - FileErrorDisplay(filen); - SWIG_exit(EXIT_FAILURE); - } - String *swigtype = NewString(""); - - // Emit banner name - emitBanner(f_swigtype); - - // Pure Modula 3 baseclass and interfaces - const String *pure_baseclass = typemapLookup(n, "m3base", type, WARN_NONE); - const String *pure_interfaces = typemapLookup(n, "m3interfaces", type, WARN_NONE); - - // Emit the class - Printv(swigtype, typemapLookup(n, "m3imports", type, WARN_NONE), // Import statements - "\n", typemapLookup(n, "m3classmodifiers", type, WARN_MODULA3_TYPEMAP_CLASSMOD_UNDEF), // Class modifiers - " class $m3classname", // Class name and bases - *Char(pure_baseclass) ? " : " : "", pure_baseclass, *Char(pure_interfaces) ? // Interfaces - " : " : "", pure_interfaces, " {\n", " private IntPtr swigCPtr;\n", "\n", " ", typemapLookup(n, "m3ptrconstructormodifiers", type, WARN_MODULA3_TYPEMAP_PTRCONSTMOD_UNDEF), // pointer constructor modifiers - " $m3classname(IntPtr cPtr, bool bFutureUse) {\n", // Constructor used for wrapping pointers - " swigCPtr = cPtr;\n", " }\n", "\n", " protected $m3classname() {\n", // Default constructor - " swigCPtr = IntPtr.Zero;\n", " }\n", typemapLookup(n, "m3getcptr", type, WARN_MODULA3_TYPEMAP_GETCPTR_UNDEF), // getCPtr method - typemapLookup(n, "m3code", type, WARN_NONE), // extra Modula 3 code - "}\n", "\n", NIL); - - Replaceall(swigtype, "$m3classname", classname); - Printv(f_swigtype, swigtype, NIL); - - Delete(f_swigtype); - Delete(filen); - Delete(swigtype); - } - - /* ----------------------------------------------------------------------------- - * typemapLookup() - * n - for input only and must contain info for Getfile(n) and Getline(n) to work - * tmap_method - typemap method name - * type - typemap type to lookup - * warning - warning number to issue if no typemaps found - * typemap_attributes - the typemap attributes are attached to this node and will - * also be used for temporary storage if non null - * return is never NULL, unlike Swig_typemap_lookup() - * ----------------------------------------------------------------------------- */ - - const String *typemapLookup(Node *n, const_String_or_char_ptr tmap_method, SwigType *type, int warning, Node *typemap_attributes = 0) { - Node *node = !typemap_attributes ? NewHash() : typemap_attributes; - Setattr(node, "type", type); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup(tmap_method, node, "", 0); - if (!tm) { - tm = empty_string; - if (warning != WARN_NONE) - Swig_warning(warning, Getfile(n), Getline(n), "No %s typemap defined for %s\n", tmap_method, SwigType_str(type, 0)); - } - if (!typemap_attributes) - Delete(node); - return tm; - } - - /* ----------------------------------------------------------------------------- - * addThrows() - * - * Add all exceptions to a hash that are associated with the 'typemap'. - * Return number the number of these exceptions. - * ----------------------------------------------------------------------------- */ - - int addThrows(Hash *throws_hash, const String *typemap, Node *parameter) { - // Get the comma separated throws clause - held in "throws" attribute in the typemap passed in - int len = 0; - String *throws_attribute = NewStringf("%s:throws", typemap); - - addImports(m3wrap_intf.import, throws_attribute, parameter); - addImports(m3wrap_impl.import, throws_attribute, parameter); - - String *throws = getMappedTypeNew(parameter, Char(throws_attribute), "", false); - //printf("got exceptions %s for %s\n", Char(throws), Char(throws_attribute)); - - if (throws) { - // Put the exception classes in the throws clause into a temporary List - List *temp_classes_list = Split(throws, ',', INT_MAX); - len = Len(temp_classes_list); - - // Add the exception classes to the node throws list, but don't duplicate if already in list - if (temp_classes_list /*&& hasContent(temp_classes_list) */ ) { - for (Iterator cls = First(temp_classes_list); cls.item != NIL; cls = Next(cls)) { - String *exception_class = NewString(cls.item); - Replaceall(exception_class, " ", ""); // remove spaces - Replaceall(exception_class, "\t", ""); // remove tabs - if (hasContent(exception_class)) { - // $m3classname substitution - SwigType *pt = Getattr(parameter, "type"); - substituteClassname(pt, exception_class); - // Don't duplicate the exception class in the throws clause - //printf("add exception %s\n", Char(exception_class)); - Setattr(throws_hash, exception_class, "1"); - } - Delete(exception_class); - } - } - Delete(temp_classes_list); - } - Delete(throws_attribute); - return len; - } - - /* ----------------------------------------------------------------------------- - * generateThrowsClause() - * ----------------------------------------------------------------------------- */ - - void generateThrowsClause(Hash *throws_hash, String *code) { - // Add the throws clause into code - if (Len(throws_hash) > 0) { - Iterator cls = First(throws_hash); - Printf(code, " RAISES {%s", cls.key); - for (cls = Next(cls); cls.key != NIL; cls = Next(cls)) { - Printf(code, ", %s", cls.key); - } - Printf(code, "}"); - } - } - - /* ----------------------------------------------------------------------------- - * addImports() - * - * Add all imports that are needed for contents of 'typemap'. - * ----------------------------------------------------------------------------- */ - - void addImports(Hash *imports_hash, const String *typemap, Node *node) { - // Get the comma separated throws clause - held in "throws" attribute in the typemap passed in - String *imports_attribute = NewStringf("%s:import", typemap); - String *imports = getMappedTypeNew(node, Char(imports_attribute), "", false); - //printf("got imports %s for %s\n", Char(imports), Char(imports_attribute)); - - if (imports != NIL) { - List *import_list = Split(imports, ',', INT_MAX); - - // Add the exception classes to the node imports list, but don't duplicate if already in list - if (import_list != NIL) { - for (Iterator imp = First(import_list); imp.item != NIL; imp = Next(imp)) { - List *import_pair = Split(imp.item, ' ', 3); - if (Len(import_pair) == 1) { - Setattr(imports_hash, Getitem(import_pair, 0), ""); - } else if ((Len(import_pair) == 3) - && Strcmp(Getitem(import_pair, 1), "AS") == 0) { - Setattr(imports_hash, Getitem(import_pair, 0), Getitem(import_pair, 2)); - } else { - Swig_warning(WARN_MODULA3_BAD_IMPORT, input_file, line_number, - "Malformed import '%s' for typemap '%s' defined for type '%s'\n", imp, typemap, SwigType_str(Getattr(node, "type"), 0)); - } - Delete(import_pair); - } - } - Delete(import_list); - } - Delete(imports_attribute); - } - - /* ----------------------------------------------------------------------------- - * emitImportStatements() - * ----------------------------------------------------------------------------- */ - - void emitImportStatements(Hash *imports_hash, String *code) { - // Add the imports statements into code - Iterator imp = First(imports_hash); - while (imp.key != NIL) { - Printf(code, "IMPORT %s", imp.key); - String *imp_as = imp.item; - if (hasContent(imp_as)) { - Printf(code, " AS %s", imp_as); - } - Printf(code, ";\n"); - imp = Next(imp); - } - } - -}; /* class MODULA3 */ - -/* ----------------------------------------------------------------------------- - * swig_modula3() - Instantiate module - * ----------------------------------------------------------------------------- */ - -extern "C" Language *swig_modula3(void) { - return new MODULA3(); -} - -/* ----------------------------------------------------------------------------- - * Static member variables - * ----------------------------------------------------------------------------- */ - -const char *MODULA3::usage = "\ -Modula 3 Options (available with -modula3)\n\ - -generateconst <file> - Generate code for computing numeric values of constants\n\ - -generaterename <file> - Generate suggestions for %rename\n\ - -generatetypemap <file> - Generate templates for some basic typemaps\n\ - -oldvarnames - Old intermediary method names for variable wrappers\n\ -\n"; - -/* - -generateconst <file> - stem of the .c source file for computing the numeric values of constants\n\ - -generaterename <file> - stem of the .i source file containing %rename suggestions\n\ - -generatetypemap <file> - stem of the .i source file containing typemap patterns\n\ -*/ diff --git a/Source/Modules/mzscheme.cxx b/Source/Modules/mzscheme.cxx index 788681330..3ff691662 100644 --- a/Source/Modules/mzscheme.cxx +++ b/Source/Modules/mzscheme.cxx @@ -322,8 +322,6 @@ public: } // Handle parameter types. if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", target); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); Printv(f->code, tm, "\n", NIL); @@ -343,7 +341,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -355,8 +352,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* Deprecated */ - Replaceall(tm, "$target", Getattr(p, "lname")); /* Deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(outarg, tm, "\n", NIL); @@ -371,7 +366,6 @@ public: /* Insert cleanup code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); p = Getattr(p, "tmap:freearg:next"); } else { @@ -385,8 +379,6 @@ public: // Now have return value, figure out what to do with it. if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "values[0]"); Replaceall(tm, "$result", "values[0]"); if (GetFlag(n, "feature:new")) Replaceall(tm, "$owner", "1"); @@ -408,14 +400,12 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NIL); } } // Free any memory allocated by the function being wrapped.. if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NIL); } // Wrap things up (in a manner of speaking) @@ -453,7 +443,7 @@ public: Printv(df->def, "static Scheme_Object *\n", dname, "(int argc, Scheme_Object **argv) {", NIL); Printv(df->code, dispatch, "\n", NIL); Printf(df->code, "scheme_signal_error(\"No matching function for overloaded '%s'\");\n", iname); - Printf(df->code, "return NULL;\n", iname); + Printf(df->code, "return NULL;\n"); Printv(df->code, "}\n", NIL); Wrapper_print(df, f_wrappers); Printf(init_func_def, "scheme_add_global(\"%s\", scheme_make_prim_w_arity(%s,\"%s\",%d,%d),menv);\n", proc_name, dname, proc_name, 0, maxargs); @@ -521,8 +511,6 @@ public: /* Check for a setting of the variable value */ Printf(f->code, "if (argc) {\n"); if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "argv[0]"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "argv[0]"); Replaceall(tm, "$argnum", "1"); emit_action_code(n, f->code, tm); @@ -535,8 +523,6 @@ public: // of evaluating or setting) if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "swig_result"); Replaceall(tm, "$result", "swig_result"); /* Printf (f->code, "%s\n", tm); */ emit_action_code(n, f->code, tm); @@ -609,9 +595,7 @@ public: Printv(rvalue, "'", temp, "'", NIL); } if ((tm = Swig_typemap_lookup("constant", n, name, 0))) { - Replaceall(tm, "$source", rvalue); Replaceall(tm, "$value", rvalue); - Replaceall(tm, "$target", name); Printf(f_init, "%s\n", tm); } else { // Create variable and assign it a value diff --git a/Source/Modules/ocaml.cxx b/Source/Modules/ocaml.cxx index 9f7504b87..caa9725c0 100644 --- a/Source/Modules/ocaml.cxx +++ b/Source/Modules/ocaml.cxx @@ -590,8 +590,6 @@ public: } // Handle parameter types. if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", target); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); Printv(f->code, tm, "\n", NIL); @@ -611,7 +609,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -623,8 +620,6 @@ public: for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "emit:input")); /* Deprecated */ - Replaceall(tm, "$target", Getattr(p, "lname")); /* Deprecated */ Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Replaceall(tm, "$ntype", normalizeTemplatedClassName(Getattr(p, "type"))); @@ -640,7 +635,6 @@ public: /* Insert cleanup code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); p = Getattr(p, "tmap:freearg:next"); } else { @@ -681,8 +675,6 @@ public: String *actioncode = emit_action(n); if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - Replaceall(tm, "$source", "swig_result"); - Replaceall(tm, "$target", "rv"); Replaceall(tm, "$result", "rv"); Replaceall(tm, "$ntype", return_type_normalized); Printv(f->code, tm, "\n", NIL); @@ -701,14 +693,12 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", "swig_result"); Printv(f->code, tm, "\n", NIL); } } /* See if there is any return cleanup code */ if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); Delete(tm); } @@ -716,7 +706,6 @@ public: // Free any memory allocated by the function being wrapped.. if ((tm = Swig_typemap_lookup("swig_result", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NIL); } // Wrap things up (in a manner of speaking) @@ -853,13 +842,9 @@ public: /* Check for a setting of the variable value */ Printf(f->code, "if (args != Val_int(0)) {\n"); if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "args"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "args"); emit_action_code(n, f->code, tm); } else if ((tm = Swig_typemap_lookup("in", n, name, 0))) { - Replaceall(tm, "$source", "args"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "args"); emit_action_code(n, f->code, tm); } else { @@ -871,13 +856,9 @@ public: // of evaluating or setting) if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "swig_result"); Replaceall(tm, "$result", "swig_result"); emit_action_code(n, f->code, tm); } else if ((tm = Swig_typemap_lookup("out", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "swig_result"); Replaceall(tm, "$result", "swig_result"); emit_action_code(n, f->code, tm); } else { diff --git a/Source/Modules/octave.cxx b/Source/Modules/octave.cxx index b1769e42a..04b315eaf 100644 --- a/Source/Modules/octave.cxx +++ b/Source/Modules/octave.cxx @@ -611,9 +611,7 @@ public: sprintf(source, "args(%d)", j); Setattr(p, "emit:input", source); - Replaceall(tm, "$source", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); - Replaceall(tm, "$target", Getattr(p, "lname")); if (Getattr(p, "wrap:disown") || (Getattr(p, "tmap:in:disown"))) { Replaceall(tm, "$disown", "SWIG_POINTER_DISOWN"); @@ -658,7 +656,6 @@ public: // Insert constraint checking code for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -681,7 +678,6 @@ public: } } if (tm && (Len(tm) != 0)) { - Replaceall(tm, "$source", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); } p = Getattr(p, "tmap:freearg:next"); @@ -694,8 +690,6 @@ public: String *outarg = NewString(""); for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", "_outp"); Replaceall(tm, "$result", "_outp"); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); @@ -723,8 +717,6 @@ public: // Return the function value if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "_outv"); Replaceall(tm, "$result", "_outv"); if (GetFlag(n, "feature:new")) @@ -745,13 +737,11 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } } if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Replaceall(tm, "$result", "_outv"); Printf(f->code, "%s\n", tm); Delete(tm); @@ -815,7 +805,7 @@ public: Printf(tmp, "}"); Wrapper_add_local(f, "argv", tmp); Printv(f->code, dispatch, "\n", NIL); - Printf(f->code, "error(\"No matching function for overload\");\n", iname); + Printf(f->code, "error(\"No matching function for overload\");\n"); Printf(f->code, "return octave_value_list();\n"); Printv(f->code, "}\n", NIL); @@ -849,8 +839,6 @@ public: if (is_assignable(n)) { Setattr(n, "wrap:name", setname); if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "args(0)"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "args(0)"); if (Getattr(n, "tmap:varin:implicitconv")) { Replaceall(tm, "$implicitconv", get_implicitconv_flag(n)); @@ -874,8 +862,6 @@ public: Octave_begin_function(n, getf->def, getname, getwname, true); Wrapper_add_local(getf, "obj", "octave_value obj"); if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "obj"); Replaceall(tm, "$result", "obj"); addfail = emit_action_code(n, getf->code, tm); Delete(tm); @@ -920,8 +906,6 @@ public: value = wname; } if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", cppvalue ? cppvalue : value); Replaceall(tm, "$nsname", iname); Printf(f_init, "%s\n", tm); diff --git a/Source/Modules/overload.cxx b/Source/Modules/overload.cxx index 5d278107c..8a4ce48f7 100644 --- a/Source/Modules/overload.cxx +++ b/Source/Modules/overload.cxx @@ -21,6 +21,7 @@ String *argv_template_string; String *argc_template_string; +namespace { struct Overloaded { Node *n; /* Node */ int argc; /* Argument count */ @@ -28,6 +29,7 @@ struct Overloaded { int error; /* Ambiguity error */ bool implicitconv_function; /* For ordering implicitconv functions*/ }; +} static int fast_dispatch_mode = 0; static int cast_dispatch_mode = 0; @@ -809,7 +811,7 @@ String *Swig_overload_dispatch(Node *n, const_String_or_char_ptr fmt, int *maxar } if (num_arguments) { - Printf(f, "int _v;\n"); + Printf(f, "int _v = 0;\n"); } int num_braces = 0; diff --git a/Source/Modules/perl5.cxx b/Source/Modules/perl5.cxx index dfa85f3c8..e87f9f310 100644 --- a/Source/Modules/perl5.cxx +++ b/Source/Modules/perl5.cxx @@ -725,14 +725,11 @@ public: /* Produce string representation of source and target arguments */ sprintf(source, "ST(%d)", i); - String *target = Getattr(p, "lname"); if (i >= num_required) { Printf(f->code, " if (items > %d) {\n", i); } if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$target", target); - Replaceall(tm, "$source", source); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); /* Save input location */ @@ -767,7 +764,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -778,7 +774,6 @@ public: /* Insert cleanup code */ for (i = 0, p = l; p; i++) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(cleanup, tm, "\n", NIL); @@ -793,8 +788,6 @@ public: for (i = 0, p = l; p; i++) { if ((tm = Getattr(p, "tmap:argout"))) { SwigType *t = Getattr(p, "type"); - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", "ST(argvi)"); Replaceall(tm, "$result", "ST(argvi)"); if (is_shadow(t)) { Replaceall(tm, "$shadow", "SWIG_SHADOW"); @@ -855,8 +848,6 @@ public: if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { SwigType *t = Getattr(n, "type"); - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "ST(argvi)"); Replaceall(tm, "$result", "ST(argvi)"); if (is_shadow(t)) { Replaceall(tm, "$shadow", "SWIG_SHADOW"); @@ -884,13 +875,11 @@ public: if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } } if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } @@ -995,8 +984,6 @@ public: /* Check for a few typemaps */ tm = Swig_typemap_lookup("varin", n, name, 0); if (tm) { - Replaceall(tm, "$source", "sv"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "sv"); /* Printf(setf->code,"%s\n", tm); */ emit_action_code(n, setf->code, tm); @@ -1019,9 +1006,7 @@ public: Printv(getf->code, tab4, "MAGIC_PPERL\n", NIL); if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$target", "sv"); Replaceall(tm, "$result", "sv"); - Replaceall(tm, "$source", name); if (is_shadow(t)) { Replaceall(tm, "$shadow", "SWIG_SHADOW"); } else { @@ -1111,8 +1096,6 @@ public: } if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", value); if (is_shadow(type)) { Replaceall(tm, "$shadow", "SWIG_SHADOW"); @@ -1121,8 +1104,6 @@ public: } Printf(constant_tab, "%s,\n", tm); } else if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", value); if (is_shadow(type)) { Replaceall(tm, "$shadow", "SWIG_SHADOW"); @@ -2341,7 +2322,7 @@ public: Replaceall(tm, "$error", "ERRSV"); Printv(w->code, Str(tm), "\n", NIL); } else { - Printf(w->code, " Swig::DirectorMethodException::raise(ERRSV);\n", classname, pyname); + Printf(w->code, " Swig::DirectorMethodException::raise(ERRSV);\n"); } Append(w->code, "}\n"); Delete(tm); diff --git a/Source/Modules/php.cxx b/Source/Modules/php.cxx index 1edbd874c..d1ef52b48 100644 --- a/Source/Modules/php.cxx +++ b/Source/Modules/php.cxx @@ -12,72 +12,36 @@ * ----------------------------------------------------------------------------- */ -/* FIXME: PHP OO wrapping TODO list: - * - * Medium term: - * - * Handle default parameters on overloaded methods in PHP where possible. - * (Mostly done - just need to handle cases of overloaded methods with - * default parameters...) - * This is an optimisation - we could handle this case using a PHP - * default value, but currently we treat it as we would for a default - * value which is a compound C++ expression (i.e. as if we had a - * method with two overloaded forms instead of a single method with - * a default parameter value). - * - * Long term: - * - * Sort out locale-dependent behaviour of strtod() - it's harmless unless - * SWIG ever sets the locale and DOH/base.c calls atof, so we're probably - * OK currently at least. - */ - -/* - * TODO: Replace remaining stderr messages with Swig_error or Swig_warning - * (may need to add more WARN_PHP_xxx codes...) - */ - #include "swigmod.h" #include <ctype.h> #include <errno.h> static const char *usage = "\ -PHP 7 Options (available with -php7)\n\ - -noproxy - Don't generate proxy classes.\n\ +PHP Options (available with -php7)\n\ -prefix <prefix> - Prepend <prefix> to all class names in PHP wrappers\n\ \n"; -/* The original class wrappers for PHP stored the pointer to the C++ class in - * the object property _cPtr. If we use the same name for the member variable - * which we put the pointer to the C++ class in, then the flat function - * wrappers will automatically pull it out without any changes being required. - * FIXME: Isn't using a leading underscore a bit suspect here? - */ -#define SWIG_PTR "_cPtr" +// How to wrap non-class functions, variables and constants: +// FIXME: Make this specifiable and also allow a real namespace. -/* This is the name of the hash where the variables existing only in PHP - * classes are stored. - */ -#define SWIG_DATA "_pData" +// Wrap as global PHP names. +static bool wrap_nonclass_global = true; + +// Wrap in a class to fake a namespace (for compatibility with SWIG's behaviour +// before PHP added namespaces. +static bool wrap_nonclass_fake_class = true; -static int constructors = 0; -static String *NOTCLASS = NewString("Not a class"); -static Node *classnode = 0; static String *module = 0; static String *cap_module = 0; static String *prefix = 0; -static String *shadow_classname = 0; - static File *f_begin = 0; static File *f_runtime = 0; static File *f_runtime_h = 0; static File *f_h = 0; -static File *f_phpcode = 0; static File *f_directors = 0; static File *f_directors_h = 0; -static String *phpfilename = 0; static String *s_header; static String *s_wrappers; @@ -85,7 +49,6 @@ static String *s_init; static String *r_init; // RINIT user code static String *s_shutdown; // MSHUTDOWN user code static String *r_shutdown; // RSHUTDOWN user code -static String *s_vinit; // varinit initialization code. static String *s_vdecl; static String *s_cinit; // consttab initialization code. static String *s_oinit; @@ -93,29 +56,48 @@ static String *s_arginfo; static String *s_entry; static String *cs_entry; static String *all_cs_entry; +static String *fake_cs_entry; +static String *s_creation; static String *pragma_incl; static String *pragma_code; static String *pragma_phpinfo; static String *pragma_version; -static String *s_oowrappers; -static String *s_fakeoowrappers; -static String *s_phpclasses; + +static String *class_name = NULL; +static String *magic_set = NULL; +static String *magic_get = NULL; +static String *magic_isset = NULL; + +// Class used as pseudo-namespace for compatibility. +static String *fake_class_name() { + static String *result = NULL; + if (!result) { + result = Len(prefix) ? prefix : module; + if (!s_creation) { + s_creation = NewStringEmpty(); + } + if (!fake_cs_entry) { + fake_cs_entry = NewStringf("static zend_function_entry class_%s_functions[] = {\n", result); + } + Printf(s_creation, "/* class entry for %s */\n",result); + Printf(s_creation, "zend_class_entry *SWIGTYPE_%s_ce;\n\n",result); + Printf(s_oinit, " INIT_CLASS_ENTRY(internal_ce, \"%s\", class_%s_functions);\n", result, result); + Printf(s_oinit, " SWIGTYPE_%s_ce = zend_register_internal_class(&internal_ce);\n", result); + Printf(s_oinit, "\n"); + } + return result; +} /* To reduce code size (generated and compiled) we only want to emit each * different arginfo once, so we need to track which have been used. */ static Hash *arginfo_used; -/* Variables for using PHP classes */ -static Node *current_class = 0; - -static Hash *shadow_get_vars; -static Hash *shadow_set_vars; +/* Track non-class pointer types we need to to wrap */ static Hash *zend_types = 0; static int shadow = 1; -static bool class_has_ctor = false; static String *wrapping_member_constant = NULL; // These static variables are used to pass some state from Handlers into functionWrapper @@ -126,67 +108,115 @@ static enum { membervar, staticmembervar, constructor, - directorconstructor + directorconstructor, + directordisown } wrapperType = standard; extern "C" { static void (*r_prevtracefunc) (const SwigType *t, String *mangled, String *clientdata) = 0; } -static void SwigPHP_emit_resource_registrations() { - Iterator ki; - bool emitted_default_dtor = false; +static void print_creation_free_wrapper(Node *n) { + if (!s_creation) { + s_creation = NewStringEmpty(); + } + + String *s = s_creation; + + Printf(s, "/* class entry for %s */\n",class_name); + Printf(s, "zend_class_entry *SWIGTYPE_%s_ce;\n\n",class_name); + Printf(s, "/* class object handlers for %s */\n",class_name); + Printf(s, "zend_object_handlers %s_object_handlers;\n\n",class_name); + + if (Getattr(n, "has_destructor")) { + Printf(s, "/* Garbage Collection Method for class %s */\n",class_name); + Printf(s, "void %s_free_storage(zend_object *object) {\n",class_name); + Printf(s, " swig_object_wrapper *obj = 0;\n"); + Printf(s, " if (!object)\n"); + Printf(s, " return;\n"); + Printf(s, " obj = php_fetch_object(object);\n"); + + Printf(s, " zend_object_std_dtor(&obj->std);\n"); + + // expand %delete typemap instead of SWIG_remove? + Printf(s, " if (obj->newobject)\n"); + Printf(s, " SWIG_remove((%s *)obj->ptr);\n", Getattr(n, "classtype")); + Printf(s, "}\n\n"); + } + + Printf(s, "/* Object Creation Method for class %s */\n",class_name); + Printf(s, "zend_object * %s_object_new(zend_class_entry *ce) {\n",class_name); + Printf(s, " swig_object_wrapper *obj = (swig_object_wrapper*)zend_object_alloc(sizeof(swig_object_wrapper), ce);\n"); + Printf(s, " zend_object_std_init(&obj->std, ce);\n"); + Printf(s, " object_properties_init(&obj->std, ce);\n"); + Printf(s, " %s_object_handlers.offset = XtOffsetOf(swig_object_wrapper, std);\n", class_name); + if (Getattr(n, "has_destructor")) { + Printf(s, " %s_object_handlers.free_obj = %s_free_storage;\n", class_name, class_name); + } + Printf(s, " obj->std.handlers = &%s_object_handlers;\n obj->newobject = 1;\n return &obj->std;\n}\n\n\n",class_name); +} +static void SwigPHP_emit_pointer_type_registrations() { if (!zend_types) return; - ki = First(zend_types); - if (ki.key) - Printf(s_oinit, "\n /* Register resource destructors for pointer types */\n"); - while (ki.key) { - DOH *key = ki.key; - Node *class_node = ki.item; - String *human_name = key; - String *rsrc_dtor_name = NULL; - - // write out body - if (class_node != NOTCLASS) { - String *destructor = Getattr(class_node, "destructor"); - human_name = Getattr(class_node, "sym:name"); - if (!human_name) - human_name = Getattr(class_node, "name"); - // Do we have a known destructor for this type? - if (destructor) { - rsrc_dtor_name = NewStringf("_wrap_destroy%s", key); - // Write out custom destructor function - Printf(s_wrappers, "static ZEND_RSRC_DTOR_FUNC(%s) {\n", rsrc_dtor_name); - Printf(s_wrappers, " %s(res, SWIGTYPE%s->name);\n", destructor, key); - Printf(s_wrappers, "}\n"); - } - } + Iterator ki = First(zend_types); + if (!ki.key) + return; - if (!rsrc_dtor_name) { - rsrc_dtor_name = NewString("_swig_default_rsrc_destroy"); - if (!emitted_default_dtor) { - // Write out custom destructor function - Printf(s_wrappers, "static ZEND_RSRC_DTOR_FUNC(%s) {\n", rsrc_dtor_name); - Printf(s_wrappers, " efree(res->ptr);\n"); - Printf(s_wrappers, "}\n"); - emitted_default_dtor = true; - } - } + Printf(s_wrappers, "/* class object handlers for pointer wrappers */\n"); + Printf(s_wrappers, "static zend_object_handlers swig_ptr_object_handlers;\n\n"); + + Printf(s_wrappers, "/* Object Creation Method for pointer wrapping class */\n"); + Printf(s_wrappers, "static zend_object * swig_ptr_object_new(zend_class_entry *ce) {\n"); + Printf(s_wrappers, " swig_object_wrapper *obj = (swig_object_wrapper*)zend_object_alloc(sizeof(swig_object_wrapper), ce);\n"); + Printf(s_wrappers, " zend_object_std_init(&obj->std, ce);\n"); + Printf(s_wrappers, " object_properties_init(&obj->std, ce);\n"); + Printf(s_wrappers, " obj->std.handlers = &swig_ptr_object_handlers;\n"); + Printf(s_wrappers, " obj->newobject = 0;\n"); + Printf(s_wrappers, " return &obj->std;\n"); + Printf(s_wrappers, "}\n\n"); + + Printf(s_wrappers, "/* Implement __toString equivalent, since that worked for the old-style resource wrapped pointers. */\n"); + Append(s_wrappers, "#if PHP_MAJOR_VERSION < 8\n"); + Printf(s_wrappers, "static int swig_ptr_cast_object(zval *z, zval *retval, int type) {\n"); + Append(s_wrappers, "#else\n"); + Printf(s_wrappers, "static int swig_ptr_cast_object(zend_object *zobj, zval *retval, int type) {\n"); + Append(s_wrappers, "#endif\n"); + Printf(s_wrappers, " if (type == IS_STRING) {\n"); + Printf(s_wrappers, " char buf[80];\n"); + Append(s_wrappers, "#if PHP_MAJOR_VERSION < 8\n"); + Printf(s_wrappers, " swig_object_wrapper *obj = SWIG_Z_FETCH_OBJ_P(z);\n"); + Append(s_wrappers, "#else\n"); + Printf(s_wrappers, " swig_object_wrapper *obj = php_fetch_object(zobj);\n"); + Append(s_wrappers, "#endif\n"); + Printv(s_wrappers, " sprintf(buf, \"SWIGPointer(%p,owned=%d)\", obj->ptr, obj->newobject);\n", NIL); + Printf(s_wrappers, " ZVAL_STRING(retval, buf);\n"); + Printf(s_wrappers, " return SUCCESS;\n"); + Printf(s_wrappers, " }\n"); + Printf(s_wrappers, " return FAILURE;\n"); + Printf(s_wrappers, "}\n\n"); + + Printf(s_oinit, "\n /* Register classes to represent non-class pointer types */\n"); + Printf(s_oinit, " memcpy(&swig_ptr_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));\n"); + Printf(s_oinit, " swig_ptr_object_handlers.offset = XtOffsetOf(swig_object_wrapper, std);\n"); + Printf(s_oinit, " swig_ptr_object_handlers.cast_object = swig_ptr_cast_object;\n"); - // declare le_swig_<mangled> to store php registration - Printf(s_vdecl, "static int le_swig_%s=0; /* handle for %s */\n", key, human_name); + while (ki.key) { + String *type = ki.key; - // register with php - Printf(s_oinit, " le_swig_%s=zend_register_list_destructors_ex" - "(%s, NULL, SWIGTYPE%s->name, module_number);\n", key, rsrc_dtor_name, key); + if (!s_creation) { + s_creation = NewStringEmpty(); + } - // store php type in class struct - Printf(s_oinit, " SWIG_TypeClientData(SWIGTYPE%s,&le_swig_%s);\n", key, key); + Printf(s_creation, "/* class entry for pointer to %s */\n", type); + Printf(s_creation, "zend_class_entry *SWIGTYPE_%s_ce;\n\n", type); - Delete(rsrc_dtor_name); + Printf(s_oinit, " INIT_CLASS_ENTRY(internal_ce, \"%s\\\\%s\", NULL);\n", "SWIG", type); + Printf(s_oinit, " SWIGTYPE_%s_ce = zend_register_internal_class(&internal_ce);\n", type); + Printf(s_oinit, " SWIGTYPE_%s_ce->create_object = swig_ptr_object_new;\n", type); + Printf(s_oinit, " SWIG_TypeClientData(SWIGTYPE%s,SWIGTYPE_%s_ce);\n", type, type); + Printf(s_oinit, "\n"); ki = Next(ki); } @@ -215,7 +245,7 @@ public: } else { Swig_arg_error(); } - } else if ((strcmp(argv[i], "-noshadow") == 0) || (strcmp(argv[i], "-noproxy") == 0)) { + } else if ((strcmp(argv[i], "-noshadow") == 0)) { shadow = 0; Swig_mark_arg(i); } else if (strcmp(argv[i], "-help") == 0) { @@ -270,12 +300,10 @@ public: s_header = NewString("/* header section */\n"); s_wrappers = NewString("/* wrapper section */\n"); /* subsections of the init section */ - s_vinit = NewStringEmpty(); s_vdecl = NewString("/* vdecl subsection */\n"); s_cinit = NewString(" /* cinit subsection */\n"); s_oinit = NewString(" /* oinit subsection */\n"); pragma_phpinfo = NewStringEmpty(); - s_phpclasses = NewString("/* PHP Proxy Classes */\n"); f_directors_h = NewStringEmpty(); f_directors = NewStringEmpty(); @@ -313,9 +341,6 @@ public: if (!prefix) prefix = NewStringEmpty(); - Printf(f_runtime, "#define SWIG_PREFIX \"%s\"\n", prefix); - Printf(f_runtime, "#define SWIG_PREFIX_LEN %lu\n", (unsigned long)Len(prefix)); - if (directorsEnabled()) { Swig_banner(f_directors_h); Printf(f_directors_h, "\n"); @@ -327,36 +352,6 @@ public: Delete(filename); } - /* PHP module file */ - filen = NewStringEmpty(); - Printv(filen, SWIG_output_directory(), module, ".php", NIL); - phpfilename = NewString(filen); - - f_phpcode = NewFile(filen, "w", SWIG_output_files()); - if (!f_phpcode) { - FileErrorDisplay(filen); - SWIG_exit(EXIT_FAILURE); - } - - Printf(f_phpcode, "<?php\n\n"); - - Swig_banner(f_phpcode); - - Printf(f_phpcode, "\n"); - Printf(f_phpcode, "// Try to load our extension if it's not already loaded.\n"); - Printf(f_phpcode, "if (!extension_loaded('%s')) {\n", module); - Printf(f_phpcode, " if (strtolower(substr(PHP_OS, 0, 3)) === 'win') {\n"); - Printf(f_phpcode, " if (!dl('php_%s.dll')) return;\n", module); - Printf(f_phpcode, " } else {\n"); - Printf(f_phpcode, " // PHP_SHLIB_SUFFIX gives 'dylib' on MacOS X but modules are 'so'.\n"); - Printf(f_phpcode, " if (PHP_SHLIB_SUFFIX === 'dylib') {\n"); - Printf(f_phpcode, " if (!dl('%s.so')) return;\n", module); - Printf(f_phpcode, " } else {\n"); - Printf(f_phpcode, " if (!dl('%s.'.PHP_SHLIB_SUFFIX)) return;\n", module); - Printf(f_phpcode, " }\n"); - Printf(f_phpcode, " }\n"); - Printf(f_phpcode, "}\n\n"); - /* sub-sections of the php file */ pragma_code = NewStringEmpty(); pragma_incl = NewStringEmpty(); @@ -364,76 +359,11 @@ public: /* Initialize the rest of the module */ - Printf(s_oinit, " ZEND_INIT_MODULE_GLOBALS(%s, %s_init_globals, NULL);\n", module, module); - /* start the header section */ - Printf(s_header, "ZEND_BEGIN_MODULE_GLOBALS(%s)\n", module); - Printf(s_header, "const char *error_msg;\n"); - Printf(s_header, "int error_code;\n"); - Printf(s_header, "ZEND_END_MODULE_GLOBALS(%s)\n", module); - Printf(s_header, "ZEND_DECLARE_MODULE_GLOBALS(%s)\n", module); - Printf(s_header, "#define SWIG_ErrorMsg() ZEND_MODULE_GLOBALS_ACCESSOR(%s, error_msg)\n", module); - Printf(s_header, "#define SWIG_ErrorCode() ZEND_MODULE_GLOBALS_ACCESSOR(%s, error_code)\n", module); - - /* The following can't go in Lib/php/phprun.swg as it uses SWIG_ErrorMsg(), etc - * which has to be dynamically generated as it depends on the module name. - */ - Append(s_header, "#ifdef __GNUC__\n"); - Append(s_header, "static void SWIG_FAIL(void) __attribute__ ((__noreturn__));\n"); - Append(s_header, "#endif\n\n"); - Append(s_header, "static void SWIG_FAIL(void) {\n"); - Append(s_header, " zend_error(SWIG_ErrorCode(), \"%s\", SWIG_ErrorMsg());\n"); - // zend_error() should never return with the parameters we pass, but if it - // does, we really don't want to let SWIG_FAIL() return. This also avoids - // a warning about returning from a function marked as "__noreturn__". - Append(s_header, " abort();\n"); - Append(s_header, "}\n\n"); - - Printf(s_header, "static void %s_init_globals(zend_%s_globals *globals ) {\n", module, module); - Printf(s_header, " globals->error_msg = default_error_msg;\n"); - Printf(s_header, " globals->error_code = default_error_code;\n"); - Printf(s_header, "}\n"); - - Printf(s_header, "static void SWIG_ResetError(void) {\n"); - Printf(s_header, " SWIG_ErrorMsg() = default_error_msg;\n"); - Printf(s_header, " SWIG_ErrorCode() = default_error_code;\n"); - Printf(s_header, "}\n"); - - Append(s_header, "\n"); - Printf(s_header, "ZEND_NAMED_FUNCTION(_wrap_swig_%s_alter_newobject) {\n", module); - Append(s_header, " zval args[2];\n"); - Append(s_header, " swig_object_wrapper *value;\n"); - Append(s_header, "\n"); - Append(s_header, " SWIG_ResetError();\n"); - Append(s_header, " if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {\n"); - Append(s_header, " WRONG_PARAM_COUNT;\n"); - Append(s_header, " }\n"); - Append(s_header, "\n"); - Append(s_header, " value = (swig_object_wrapper *) Z_RES_VAL(args[0]);\n"); - Append(s_header, " value->newobject = zval_is_true(&args[1]);\n"); - Append(s_header, "\n"); - Append(s_header, " return;\n"); - Append(s_header, "}\n"); - Printf(s_header, "ZEND_NAMED_FUNCTION(_wrap_swig_%s_get_newobject) {\n", module); - Append(s_header, " zval args[1];\n"); - Append(s_header, " swig_object_wrapper *value;\n"); - Append(s_header, "\n"); - Append(s_header, " SWIG_ResetError();\n"); - Append(s_header, " if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {\n"); - Append(s_header, " WRONG_PARAM_COUNT;\n"); - Append(s_header, " }\n"); - Append(s_header, "\n"); - Append(s_header, " value = (swig_object_wrapper *) Z_RES_VAL(args[0]);\n"); - Append(s_header, " RETVAL_LONG(value->newobject);\n"); - Append(s_header, "\n"); - Append(s_header, " return;\n"); - Append(s_header, "}\n"); - Printf(s_header, "#define SWIG_name \"%s\"\n", module); Printf(s_header, "#ifdef __cplusplus\n"); Printf(s_header, "extern \"C\" {\n"); Printf(s_header, "#endif\n"); - Printf(s_header, "#include \"php.h\"\n"); Printf(s_header, "#include \"php_ini.h\"\n"); Printf(s_header, "#include \"ext/standard/info.h\"\n"); Printf(s_header, "#include \"php_%s.h\"\n", module); @@ -441,6 +371,9 @@ public: Printf(s_header, "}\n"); Printf(s_header, "#endif\n\n"); + Printf(s_header, "#ifdef __cplusplus\n#define SWIG_remove(PTR) delete PTR\n"); + Printf(s_header, "#else\n#define SWIG_remove(PTR) free(PTR)\n#endif\n\n"); + if (directorsEnabled()) { // Insert director runtime Swig_insert_file("director_common.swg", s_header); @@ -479,14 +412,20 @@ public: /* holds all the per-class function entry sections */ all_cs_entry = NewString("/* class entry subsection */\n"); cs_entry = NULL; + fake_cs_entry = NULL; Printf(s_entry, "/* Every non-class user visible function must have an entry here */\n"); - Printf(s_entry, "static zend_function_entry %s_functions[] = {\n", module); + Printf(s_entry, "static zend_function_entry module_%s_functions[] = {\n", module); /* Emit all of the code */ Language::top(n); - SwigPHP_emit_resource_registrations(); + SwigPHP_emit_pointer_type_registrations(); + if (s_creation) { + Dump(s_creation, s_header); + Delete(s_creation); + s_creation = NULL; + } /* start the init section */ { @@ -495,14 +434,14 @@ public: Printv(s_init, "zend_module_entry ", module, "_module_entry = {\n", NIL); Printf(s_init, " STANDARD_MODULE_HEADER,\n"); Printf(s_init, " \"%s\",\n", module); - Printf(s_init, " %s_functions,\n", module); + Printf(s_init, " module_%s_functions,\n", module); Printf(s_init, " PHP_MINIT(%s),\n", module); if (Len(s_shutdown) > 0) { Printf(s_init, " PHP_MSHUTDOWN(%s),\n", module); } else { Printf(s_init, " NULL, /* No MSHUTDOWN code */\n"); } - if (Len(r_init) > 0 || Len(s_vinit) > 0) { + if (Len(r_init) > 0) { Printf(s_init, " PHP_RINIT(%s),\n", module); } else { Printf(s_init, " NULL, /* No RINIT code */\n"); @@ -548,8 +487,6 @@ public: */ // Printv(s_init,s_resourcetypes,NIL); - /* We need this after all classes written out by ::top */ - Printf(s_oinit, " CG(active_class_entry) = NULL;\n"); Printf(s_oinit, " /* end oinit subsection */\n"); Printf(s_init, "%s\n", s_oinit); @@ -563,27 +500,14 @@ public: Printf(s_init, "}\n\n"); // Now do REQUEST init which holds any user specified %rinit, and also vinit - if (Len(r_init) > 0 || Len(s_vinit) > 0) { + if (Len(r_init) > 0) { Printf(f_h, "PHP_RINIT_FUNCTION(%s);\n", module); Printf(s_init, "PHP_RINIT_FUNCTION(%s)\n{\n", module); - if (Len(r_init) > 0) { - Printv(s_init, - "/* rinit section */\n", - r_init, "\n", - NIL); - } - - if (Len(s_vinit) > 0) { - /* finish our init section which will have been used by class wrappers */ - Printv(s_init, - " /* vinit subsection */\n", - s_vinit, "\n" - " /* end vinit subsection */\n", - NIL); - Clear(s_vinit); - } - Delete(s_vinit); + Printv(s_init, + "/* rinit section */\n", + r_init, "\n", + NIL); Printf(s_init, " return SUCCESS;\n"); Printf(s_init, "}\n\n"); @@ -652,10 +576,13 @@ public: Dump(f_directors, f_begin); } Printv(f_begin, s_vdecl, s_wrappers, NIL); - Printv(f_begin, all_cs_entry, "\n\n", s_arginfo, "\n\n", s_entry, - " SWIG_ZEND_NAMED_FE(swig_", module, "_alter_newobject,_wrap_swig_", module, "_alter_newobject,NULL)\n" - " SWIG_ZEND_NAMED_FE(swig_", module, "_get_newobject,_wrap_swig_", module, "_get_newobject,NULL)\n" + Printv(f_begin, s_arginfo, "\n\n", all_cs_entry, "\n\n", s_entry, " ZEND_FE_END\n};\n\n", NIL); + if (fake_cs_entry) { + Printv(f_begin, fake_cs_entry, " ZEND_FE_END\n};\n\n", NIL); + Delete(fake_cs_entry); + fake_cs_entry = NULL; + } Printv(f_begin, s_init, NIL); Delete(s_header); Delete(s_wrappers); @@ -668,78 +595,205 @@ public: Delete(f_begin); Delete(arginfo_used); - Printf(f_phpcode, "%s\n%s\n", pragma_incl, pragma_code); - if (s_fakeoowrappers) { - Printf(f_phpcode, "abstract class %s {", Len(prefix) ? prefix : module); - Printf(f_phpcode, "%s", s_fakeoowrappers); - Printf(f_phpcode, "}\n\n"); - Delete(s_fakeoowrappers); - s_fakeoowrappers = NULL; + if (Len(pragma_incl) > 0 || Len(pragma_code) > 0) { + /* PHP module file */ + String *php_filename = NewStringEmpty(); + Printv(php_filename, SWIG_output_directory(), module, ".php", NIL); + + File *f_phpcode = NewFile(php_filename, "w", SWIG_output_files()); + if (!f_phpcode) { + FileErrorDisplay(php_filename); + SWIG_exit(EXIT_FAILURE); + } + + Printf(f_phpcode, "<?php\n\n"); + + if (Len(pragma_incl) > 0) { + Printv(f_phpcode, pragma_incl, "\n", NIL); + } + + if (Len(pragma_code) > 0) { + Printv(f_phpcode, pragma_code, "\n", NIL); + } + + Delete(f_phpcode); + Delete(php_filename); } - Printf(f_phpcode, "%s\n", s_phpclasses); - Delete(f_phpcode); return SWIG_OK; } /* Just need to append function names to function table to register with PHP. */ - void create_command(String *cname, String *iname, Node *n) { + void create_command(String *cname, String *fname, Node *n, bool overload, String *modes = NULL) { // This is for the single main zend_function_entry record - Printf(f_h, "ZEND_NAMED_FUNCTION(%s);\n", iname); - + bool has_this = false; + if (cname && Cmp(Getattr(n, "storage"), "friend") != 0) { + Printf(f_h, "PHP_METHOD(%s%s,%s);\n", prefix, cname, fname); + has_this = (wrapperType != staticmemberfn) && + (wrapperType != staticmembervar) && + (Cmp(fname, "__construct") != 0); + } else { + if (overload) { + Printf(f_h, "ZEND_NAMED_FUNCTION(%s);\n", fname); + } else { + Printf(f_h, "PHP_FUNCTION(%s);\n", fname); + } + } // We want to only emit each different arginfo once, as that reduces the // size of both the generated source code and the compiled extension - // module. To do this, we name the arginfo to encode the number of - // parameters and which (if any) are passed by reference by using a - // sequence of 0s (for non-reference) and 1s (for by references). + // module. The parameters at this level are just named arg1, arg2, etc + // so we generate an arginfo name with the number of parameters and a + // bitmap value saying which (if any) are passed by reference. ParmList *l = Getattr(n, "parms"); - String * arginfo_code = NewStringEmpty(); + unsigned long bitmap = 0, bit = 1; + bool overflowed = false; + bool skip_this = has_this; for (Parm *p = l; p; p = Getattr(p, "tmap:in:next")) { - /* Ignored parameters */ - if (checkAttribute(p, "tmap:in:numinputs", "0")) { + if (skip_this) { + skip_this = false; + continue; + } + String* tmap_in_numinputs = Getattr(p, "tmap:in:numinputs"); + // tmap:in:numinputs is unset for varargs, which we don't count here. + if (!tmap_in_numinputs || Equal(tmap_in_numinputs, "0")) { + /* Ignored parameter */ continue; } - Append(arginfo_code, GetFlag(p, "tmap:in:byref") ? "1" : "0"); + if (GetFlag(p, "tmap:in:byref")) { + bitmap |= bit; + if (bit == 0) overflowed = true; + } + bit <<= 1; + } + int num_arguments = emit_num_arguments(l); + int num_required = emit_num_required(l); + if (has_this) { + --num_arguments; + --num_required; + } + String * arginfo_code; + if (overflowed) { + // We overflowed the bitmap so just generate a unique name - this only + // happens for a function with more parameters than bits in a long + // where a high numbered parameter is passed by reference, so should be + // rare in practice. + static int overflowed_counter = 0; + arginfo_code = NewStringf("z%d", ++overflowed_counter); + } else if (bitmap == 0) { + // No parameters passed by reference. + if (num_required == num_arguments) { + arginfo_code = NewStringf("%d", num_arguments); + } else { + arginfo_code = NewStringf("%d_%d", num_required, num_arguments); + } + } else { + if (num_required == num_arguments) { + arginfo_code = NewStringf("%d_r%lx", num_arguments, bitmap); + } else { + arginfo_code = NewStringf("%d_%d_r%lx", num_required, num_arguments, bitmap); + } } if (!GetFlag(arginfo_used, arginfo_code)) { - // Not had this one before, so emit it. + // Not had this one before so emit it. SetFlag(arginfo_used, arginfo_code); - Printf(s_arginfo, "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_%s, 0, 0, 0)\n", arginfo_code); - for (const char * p = Char(arginfo_code); *p; ++p) { - Printf(s_arginfo, " ZEND_ARG_PASS_INFO(%c)\n", *p); + Printf(s_arginfo, "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_%s, 0, 0, %d)\n", arginfo_code, num_required); + bool skip_this = has_this; + int param_count = 0; + for (Parm *p = l; p; p = Getattr(p, "tmap:in:next")) { + if (skip_this) { + skip_this = false; + continue; + } + String* tmap_in_numinputs = Getattr(p, "tmap:in:numinputs"); + // tmap:in:numinputs is unset for varargs, which we don't count here. + if (!tmap_in_numinputs || Equal(tmap_in_numinputs, "0")) { + /* Ignored parameter */ + continue; + } + Printf(s_arginfo, " ZEND_ARG_INFO(%d,arg%d)\n", GetFlag(p, "tmap:in:byref"), ++param_count); } Printf(s_arginfo, "ZEND_END_ARG_INFO()\n"); } String * s = cs_entry; if (!s) s = s_entry; - Printf(s, " SWIG_ZEND_NAMED_FE(%(lower)s,%s,swig_arginfo_%s)\n", cname, iname, arginfo_code); + if (cname && Cmp(Getattr(n, "storage"), "friend") != 0) { + Printf(all_cs_entry, " PHP_ME(%s%s,%s,swig_arginfo_%s,%s)\n", prefix, cname, fname, arginfo_code, modes); + } else { + if (overload) { + if (wrap_nonclass_global) { + Printf(s, " ZEND_NAMED_FE(%(lower)s,%s,swig_arginfo_%s)\n", Getattr(n, "sym:name"), fname, arginfo_code); + } + + if (wrap_nonclass_fake_class) { + (void)fake_class_name(); + Printf(fake_cs_entry, " ZEND_NAMED_ME(%(lower)s,%s,swig_arginfo_%s,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)\n", Getattr(n, "sym:name"), fname, arginfo_code); + } + } else { + if (wrap_nonclass_global) { + Printf(s, " PHP_FE(%s,swig_arginfo_%s)\n", fname, arginfo_code); + } + + if (wrap_nonclass_fake_class) { + String *fake_class = fake_class_name(); + Printf(fake_cs_entry, " PHP_ME(%s,%s,swig_arginfo_%s,ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)\n", fake_class, fname, arginfo_code); + } + } + } Delete(arginfo_code); } /* ------------------------------------------------------------ * dispatchFunction() * ------------------------------------------------------------ */ - void dispatchFunction(Node *n) { + void dispatchFunction(Node *n, int constructor) { /* Last node in overloaded chain */ int maxargs; String *tmp = NewStringEmpty(); - if (Swig_directorclass(n) && wrapperType == directorconstructor) { - /* We have an extra 'this' parameter. */ - SetFlag(n, "wrap:this"); - } String *dispatch = Swig_overload_dispatch(n, "%s(INTERNAL_FUNCTION_PARAM_PASSTHRU); return;", &maxargs); /* Generate a dispatch wrapper for all overloaded functions */ Wrapper *f = NewWrapper(); String *symname = Getattr(n, "sym:name"); - String *wname = Swig_name_wrapper(symname); + String *wname = NULL; + String *modes = NULL; + bool constructorRenameOverload = false; + + if (constructor) { + // Renamed constructor - turn into static factory method + if (Cmp(class_name, Getattr(n, "constructorHandler:sym:name")) != 0) { + constructorRenameOverload = true; + wname = Copy(Getattr(n, "constructorHandler:sym:name")); + } else { + wname = NewString("__construct"); + } + } else if (class_name) { + wname = Getattr(n, "wrapper:method:name"); + } else { + wname = Swig_name_wrapper(symname); + } - create_command(symname, wname, n); - Printv(f->def, "ZEND_NAMED_FUNCTION(", wname, ") {\n", NIL); + if (constructor) { + modes = NewString("ZEND_ACC_PUBLIC | ZEND_ACC_CTOR"); + if (constructorRenameOverload) { + Append(modes, " | ZEND_ACC_STATIC"); + } + } else if (wrapperType == staticmemberfn || Cmp(Getattr(n, "storage"), "static") == 0) { + modes = NewString("ZEND_ACC_PUBLIC | ZEND_ACC_STATIC"); + } else { + modes = NewString("ZEND_ACC_PUBLIC"); + } + + create_command(class_name, wname, n, true, modes); + + if (class_name && Cmp(Getattr(n, "storage"), "friend") != 0) { + Printv(f->def, "PHP_METHOD(", prefix, class_name, ",", wname, ") {\n", NIL); + } else { + Printv(f->def, "ZEND_NAMED_FUNCTION(", wname, ") {\n", NIL); + } Wrapper_add_local(f, "argc", "int argc"); @@ -754,17 +808,15 @@ public: Printv(f->code, dispatch, "\n", NIL); - Printf(f->code, "SWIG_ErrorCode() = E_ERROR;\n"); - Printf(f->code, "SWIG_ErrorMsg() = \"No matching function for overloaded '%s'\";\n", symname); - Printv(f->code, "SWIG_FAIL();\n", NIL); - + Printf(f->code, "zend_throw_exception(zend_ce_type_error, \"No matching function for overloaded '%s'\", 0);\n", symname); + Printv(f->code, "fail:\n", NIL); + Printv(f->code, "return;\n", NIL); Printv(f->code, "}\n", NIL); Wrapper_print(f, s_wrappers); DelWrapper(f); Delete(dispatch); Delete(tmp); - Delete(wname); } /* ------------------------------------------------------------ @@ -784,7 +836,214 @@ public: return false; } + /* Helper method for PHP::functionWrapper to get class name for parameter*/ + String *get_class_name(SwigType *t) { + Node *n = classLookup(t); + String *r = NULL; + if (n) { + r = Getattr(n, "php:proxy"); // Set by classDeclaration() + if (!r) + r = Getattr(n, "sym:name"); // Not seen by classDeclaration yet, but this is the name + } + return r; + } + + /* Helper function to check if class is wrapped */ + bool is_class_wrapped(String *className) { + if (!className) + return false; + Node * n = symbolLookup(className); + return n && Getattr(n, "classtype") != NULL; + } + + /* Is special return type */ + bool is_param_type_pointer(SwigType *t) { + + if (SwigType_ispointer(t) || + SwigType_ismemberpointer(t) || + SwigType_isreference(t) || + SwigType_isarray(t)) + return true; + + return false; + } + + void generate_magic_property_methods(Node *class_node, String *base_class) { + if (Equal(base_class, "Exception") || !is_class_wrapped(base_class)) { + base_class = NULL; + } + + // Ensure arginfo_1 and arginfo_2 exist. + if (!GetFlag(arginfo_used, "1")) { + SetFlag(arginfo_used, "1"); + Append(s_arginfo, + "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_1, 0, 0, 1)\n" + " ZEND_ARG_INFO(0,arg1)\n" + "ZEND_END_ARG_INFO()\n"); + } + if (!GetFlag(arginfo_used, "2")) { + SetFlag(arginfo_used, "2"); + Append(s_arginfo, + "ZEND_BEGIN_ARG_INFO_EX(swig_arginfo_2, 0, 0, 2)\n" + " ZEND_ARG_INFO(0,arg1)\n" + " ZEND_ARG_INFO(0,arg2)\n" + "ZEND_END_ARG_INFO()\n"); + } + + Wrapper *f = NewWrapper(); + + Printf(f_h, "PHP_METHOD(%s%s,__set);\n", prefix, class_name); + Printf(all_cs_entry, " PHP_ME(%s%s,__set,swig_arginfo_2,ZEND_ACC_PUBLIC)\n", prefix, class_name); + Printf(f->code, "PHP_METHOD(%s%s,__set) {\n", prefix, class_name); + + Printf(f->code, " swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS);\n"); + Printf(f->code, " zval args[2];\n zval tempZval;\n zend_string *arg2 = 0;\n\n"); + Printf(f->code, " if(ZEND_NUM_ARGS() != 2 || zend_get_parameters_array_ex(2, args) != SUCCESS) {\n"); + Printf(f->code, "\tWRONG_PARAM_COUNT;\n}\n\n"); + Printf(f->code, " if (!arg) {\n"); + Printf(f->code, " zend_throw_exception(zend_ce_type_error, \"this pointer is NULL\", 0);\n"); + Printf(f->code, " return;\n"); + Printf(f->code, " }\n"); + Printf(f->code, " arg2 = Z_STR(args[0]);\n\n"); + + Printf(f->code, "if (!arg2) {\n RETVAL_NULL();\n}\n"); + if (magic_set) { + Append(f->code, magic_set); + } + Printf(f->code, "\nelse if (strcmp(ZSTR_VAL(arg2),\"thisown\") == 0) {\n"); + Printf(f->code, "arg->newobject = zval_get_long(&args[1]);\n"); + if (Swig_directorclass(class_node)) { + Printv(f->code, "if (arg->newobject == 0) {\n", + " Swig::Director *director = SWIG_DIRECTOR_CAST((", Getattr(class_node, "classtype"), "*)(arg->ptr));\n", + " if (director) director->swig_disown();\n", + "}\n", NIL); + } + Printf(f->code, "} else {\n"); + if (base_class) { + Printf(f->code, "PHP_MN(%s%s___set)(INTERNAL_FUNCTION_PARAM_PASSTHRU);\n}\n", prefix, base_class); + } else { + Printf(f->code, "add_property_zval_ex(ZEND_THIS, ZSTR_VAL(arg2), ZSTR_LEN(arg2), &args[1]);\n}\n"); + } + + Printf(f->code, "fail:\n"); + Printf(f->code, "return;\n"); + Printf(f->code, "}\n\n\n"); + + + Printf(f_h, "PHP_METHOD(%s%s,__get);\n", prefix, class_name); + Printf(all_cs_entry, " PHP_ME(%s%s,__get,swig_arginfo_1,ZEND_ACC_PUBLIC)\n", prefix, class_name); + Printf(f->code, "PHP_METHOD(%s%s,__get) {\n",prefix, class_name); + + Printf(f->code, " swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS);\n", class_name); + Printf(f->code, " zval args[1];\n zval tempZval;\n zend_string *arg2 = 0;\n\n"); + Printf(f->code, " if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {\n"); + Printf(f->code, "\tWRONG_PARAM_COUNT;\n}\n\n"); + Printf(f->code, " if (!arg) {\n"); + Printf(f->code, " zend_throw_exception(zend_ce_type_error, \"this pointer is NULL\", 0);\n"); + Printf(f->code, " return;\n"); + Printf(f->code, " }\n"); + Printf(f->code, " arg2 = Z_STR(args[0]);\n\n"); + + Printf(f->code, "if (!arg2) {\n RETVAL_NULL();\n}\n"); + if (magic_get) { + Append(f->code, magic_get); + } + Printf(f->code, "\nelse if (strcmp(ZSTR_VAL(arg2),\"thisown\") == 0) {\n"); + Printf(f->code, "if(arg->newobject) {\nRETVAL_LONG(1);\n}\nelse {\nRETVAL_LONG(0);\n}\n}\n\n"); + Printf(f->code, "else {\n"); + if (base_class) { + Printf(f->code, "PHP_MN(%s%s___get)(INTERNAL_FUNCTION_PARAM_PASSTHRU);\n}\n", prefix, base_class); + } else { + // __get is only called if the property isn't set on the zend_object. + Printf(f->code, "RETVAL_NULL();\n}\n"); + } + + Printf(f->code, "fail:\n"); + Printf(f->code, "return;\n"); + Printf(f->code, "}\n\n\n"); + + + Printf(f_h, "PHP_METHOD(%s%s,__isset);\n", prefix, class_name); + Printf(all_cs_entry, " PHP_ME(%s%s,__isset,swig_arginfo_1,ZEND_ACC_PUBLIC)\n", prefix, class_name); + Printf(f->code, "PHP_METHOD(%s%s,__isset) {\n",prefix, class_name); + + Printf(f->code, " swig_object_wrapper *arg = SWIG_Z_FETCH_OBJ_P(ZEND_THIS);\n", class_name); + Printf(f->code, " zval args[1];\n zend_string *arg2 = 0;\n\n"); + Printf(f->code, " if(ZEND_NUM_ARGS() != 1 || zend_get_parameters_array_ex(1, args) != SUCCESS) {\n"); + Printf(f->code, "\tWRONG_PARAM_COUNT;\n}\n\n"); + Printf(f->code, " if(!arg) {\n"); + Printf(f->code, " zend_throw_exception(zend_ce_type_error, \"this pointer is NULL\", 0);\n"); + Printf(f->code, " }\n"); + Printf(f->code, " arg2 = Z_STR(args[0]);\n\n"); + + Printf(f->code, "if (!arg2) {\n RETVAL_FALSE;\n}\n"); + Printf(f->code, "\nelse if (strcmp(ZSTR_VAL(arg2),\"thisown\") == 0) {\n"); + Printf(f->code, "RETVAL_TRUE;\n}\n\n"); + if (magic_isset) { + Append(f->code, magic_isset); + } + Printf(f->code, "else {\n"); + if (base_class) { + Printf(f->code, "PHP_MN(%s%s___isset)(INTERNAL_FUNCTION_PARAM_PASSTHRU);\n}\n", prefix, base_class); + } else { + // __isset is only called if the property isn't set on the zend_object. + Printf(f->code, "RETVAL_FALSE;\n}\n"); + } + + Printf(f->code, "fail:\n"); + Printf(f->code, "return;\n"); + Printf(f->code, "}\n\n\n"); + + Wrapper_print(f, s_wrappers); + DelWrapper(f); + f = NULL; + + Delete(magic_set); + Delete(magic_get); + Delete(magic_isset); + magic_set = NULL; + magic_get = NULL; + magic_isset = NULL; + } + + String *getAccessMode(String *access) { + if (Cmp(access, "protected") == 0) { + return NewString("ZEND_ACC_PROTECTED"); + } else if (Cmp(access, "private") == 0) { + return NewString("ZEND_ACC_PRIVATE"); + } + return NewString("ZEND_ACC_PUBLIC"); + } + + bool is_setter_method(Node *n) { + + const char *p = GetChar(n, "sym:name"); + if (strlen(p) > 4) { + p += strlen(p) - 4; + if (strcmp(p, "_set") == 0) { + return true; + } + } + return false; + } + + bool is_getter_method(Node *n) { + + const char *p = GetChar(n, "sym:name"); + if (strlen(p) > 4) { + p += strlen(p) - 4; + if (strcmp(p, "_get") == 0) { + return true; + } + } + return false; + } + virtual int functionWrapper(Node *n) { + if (wrapperType == directordisown) { + // Handled via __set magic method - no explicit wrapper method wanted. + return SWIG_OK; + } String *name = GetChar(n, "name"); String *iname = GetChar(n, "sym:name"); SwigType *d = Getattr(n, "type"); @@ -799,17 +1058,25 @@ public: String *tm; Wrapper *f; - String *wname; + String *wname = NewStringEmpty(); + String *overloadwname = NULL; int overloaded = 0; String *overname = 0; + String *modes = NULL; + bool static_setter = false; + bool static_getter = false; - if (Cmp(nodeType, "destructor") == 0) { - // We just generate the Zend List Destructor and let Zend manage the - // reference counting. There's no explicit destructor, but the user can - // just do `$obj = null;' to remove a reference to an object. - return CreateZendListDestructor(n); + modes = getAccessMode(Getattr(n, "access")); + + if (constructor) { + Append(modes, " | ZEND_ACC_CTOR"); + } + if (wrapperType == staticmemberfn || Cmp(Getattr(n, "storage"), "static") == 0) { + Append(modes, " | ZEND_ACC_STATIC"); } - // Test for overloading; + if (GetFlag(n, "abstract") && Swig_directorclass(Swig_methodclass(n)) && !is_member_director(n)) + Append(modes, " | ZEND_ACC_ABSTRACT"); + if (Getattr(n, "sym:overloaded")) { overloaded = 1; overname = Getattr(n, "sym:overname"); @@ -818,25 +1085,102 @@ public: return SWIG_ERROR; } - wname = Swig_name_wrapper(iname); if (overname) { - Printf(wname, "%s", overname); + // Test for overloading + overloadwname = NewString(Swig_name_wrapper(iname)); + Printf(overloadwname, "%s", overname); + } + + if (constructor) { + wname = NewString("__construct"); + } else if (wrapperType == membervar) { + wname = Copy(Getattr(n, "membervariableHandler:sym:name")); + if (is_setter_method(n)) { + Append(wname, "_set"); + } else if (is_getter_method(n)) { + Append(wname, "_get"); + } + } else if (wrapperType == memberfn) { + wname = Getattr(n, "memberfunctionHandler:sym:name"); + } else if (wrapperType == staticmembervar) { + // Shape::nshapes -> nshapes + wname = Getattr(n, "staticmembervariableHandler:sym:name"); + + /* We get called twice for getter and setter methods. But to maintain + compatibility, Shape::nshapes() is being used for both setter and + getter methods. So using static_setter and static_getter variables + to generate half of the code each time. + */ + static_setter = is_setter_method(n); + + if (is_getter_method(n)) { + // This is to overcome types that can't be set and hence no setter. + if (Cmp(Getattr(n, "feature:immutable"), "1") != 0) + static_getter = true; + } + } else if (wrapperType == staticmemberfn) { + wname = Getattr(n, "staticmemberfunctionHandler:sym:name"); + } else { + if (class_name) { + if (Cmp(Getattr(n, "storage"), "friend") == 0 && Cmp(Getattr(n, "view"), "globalfunctionHandler") == 0) { + wname = iname; + } else { + wname = Getattr(n, "destructorHandler:sym:name"); + } + } else { + wname = iname; + } + } + + if (Cmp(nodeType, "destructor") == 0) { + // We don't explicitly wrap the destructor for PHP - Zend manages the + // reference counting, and the user can just do `$obj = null;' or similar + // to remove a reference to an object. + return SWIG_OK; } f = NewWrapper(); + if (static_getter) { + Printf(f->def, "{\n"); + } + String *outarg = NewStringEmpty(); String *cleanup = NewStringEmpty(); - Printv(f->def, "ZEND_NAMED_FUNCTION(", wname, ") {\n", NIL); + if (!overloaded) { + if (!static_getter) { + if (class_name && Cmp(Getattr(n, "storage"), "friend") != 0) { + Printv(f->def, "PHP_METHOD(", prefix, class_name, ",", wname, ") {\n", NIL); + } else { + if (wrap_nonclass_global) { + Printv(f->def, "PHP_METHOD(", fake_class_name(), ",", wname, ") {\n", + " PHP_FN(", wname, ")(INTERNAL_FUNCTION_PARAM_PASSTHRU);\n", + "}\n\n", NIL); + } + + if (wrap_nonclass_fake_class) { + Printv(f->def, "PHP_FUNCTION(", wname, ") {\n", NIL); + } + } + } + } else { + Printv(f->def, "ZEND_NAMED_FUNCTION(", overloadwname, ") {\n", NIL); + } emit_parameter_variables(l, f); /* Attach standard typemaps */ emit_attach_parmmaps(l, f); // Not issued for overloaded functions. - if (!overloaded) { - create_command(iname, wname, n); + if (!overloaded && !static_getter) { + create_command(class_name, wname, n, false, modes); + } + + if (wrapperType == memberfn || wrapperType == membervar) { + // Assign "this" to arg1 and remove first entry from ParmList l. + Printf(f->code, "arg1 = (%s)SWIG_Z_FETCH_OBJ_P(ZEND_THIS)->ptr;\n", SwigType_lstr(Getattr(l, "type"), "")); + l = nextSibling(l); } // wrap:parms is used by overload resolution. @@ -846,18 +1190,16 @@ public: int num_required = emit_num_required(l); numopt = num_arguments - num_required; - if (wrapperType == directorconstructor) - num_arguments++; - if (num_arguments > 0) { String *args = NewStringEmpty(); - if (wrapperType == directorconstructor) - Wrapper_add_local(f, "arg0", "zval * arg0"); Printf(args, "zval args[%d]", num_arguments); Wrapper_add_local(f, "args", args); Delete(args); args = NULL; } + if (wrapperType == directorconstructor) { + Wrapper_add_local(f, "arg0", "zval *arg0 = ZEND_THIS"); + } // This generated code may be called: // 1) as an object method, or @@ -867,14 +1209,18 @@ public: // NOTE: possible we ignore this_ptr as a param for native constructor - Printf(f->code, "SWIG_ResetError();\n"); - if (numopt > 0) { // membervariable wrappers do not have optional args Wrapper_add_local(f, "arg_count", "int arg_count"); Printf(f->code, "arg_count = ZEND_NUM_ARGS();\n"); Printf(f->code, "if(arg_count<%d || arg_count>%d ||\n", num_required, num_arguments); Printf(f->code, " zend_get_parameters_array_ex(arg_count,args)!=SUCCESS)\n"); Printf(f->code, "\tWRONG_PARAM_COUNT;\n\n"); + } else if (static_setter || static_getter) { + if (num_arguments == 0) { + Printf(f->code, "if(ZEND_NUM_ARGS() == 0) {\n"); + } else { + Printf(f->code, "if(ZEND_NUM_ARGS() == %d && zend_get_parameters_array_ex(%d, args) == SUCCESS) {\n", num_arguments, num_arguments); + } } else { if (num_arguments == 0) { Printf(f->code, "if(ZEND_NUM_ARGS() != 0) {\n"); @@ -883,8 +1229,6 @@ public: } Printf(f->code, "WRONG_PARAM_COUNT;\n}\n\n"); } - if (wrapperType == directorconstructor) - Printf(f->code, "arg0 = &args[0];\n \n"); /* Now convert from PHP to C variables */ // At this point, argcount if used is the number of deliberately passed args @@ -896,10 +1240,7 @@ public: // _this and not the first argument. // This may mean looking at Language::memberfunctionHandler - int limit = num_arguments; - if (wrapperType == directorconstructor) - limit--; - for (i = 0, p = l; i < limit; i++) { + for (i = 0, p = l; i < num_arguments; i++) { String *source; /* Skip ignored arguments */ @@ -910,27 +1251,30 @@ public: SwigType *pt = Getattr(p, "type"); - if (wrapperType == directorconstructor) { - source = NewStringf("args[%d]", i+1); - } else { - source = NewStringf("args[%d]", i); - } - - String *ln = Getattr(p, "lname"); + source = NewStringf("args[%d]", i); /* Check if optional */ if (i >= num_required) { Printf(f->code, "\tif(arg_count > %d) {\n", i); } + String *paramType_class = NULL; + bool paramType_valid = is_class(pt); + + if (paramType_valid) { + paramType_class = get_class_name(pt); + Chop(paramType_class); + } + if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$source", &source); - Replaceall(tm, "$target", ln); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); Printf(f->code, "%s\n", tm); if (i == 0 && Getattr(p, "self")) { - Printf(f->code, "\tif(!arg1) SWIG_PHP_Error(E_ERROR, \"this pointer is NULL\");\n"); + Printf(f->code, "\tif(!arg1) {\n"); + Printf(f->code, "\t zend_throw_exception(zend_ce_type_error, \"this pointer is NULL\", 0);\n"); + Printf(f->code, "\t return;\n"); + Printf(f->code, "\t}\n"); } p = Getattr(p, "tmap:in:next"); if (i >= num_required) { @@ -948,8 +1292,8 @@ public: if (is_member_director(n)) { Wrapper_add_local(f, "upcall", "bool upcall = false"); - Printf(f->code, "upcall = !Swig::Director::swig_is_overridden_method(\"%s%s\", \"%s\");\n", - prefix, Swig_class_name(Swig_methodclass(n)), name); + Printf(f->code, "upcall = !Swig::Director::swig_is_overridden_method(\"%s%s\", ZEND_THIS);\n", + prefix, Swig_class_name(Swig_methodclass(n))); } Swig_director_emit_dynamic_cast(n, f); @@ -957,7 +1301,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -968,7 +1311,6 @@ public: /* Insert cleanup code */ for (i = 0, p = l; p; i++) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); p = Getattr(p, "tmap:freearg:next"); } else { @@ -977,13 +1319,8 @@ public: } /* Insert argument output code */ - bool hasargout = false; for (i = 0, p = l; p; i++) { if ((tm = Getattr(p, "tmap:argout")) && Len(tm)) { - hasargout = true; - Replaceall(tm, "$source", Getattr(p, "lname")); - // Replaceall(tm,"$input",Getattr(p,"lname")); - Replaceall(tm, "$target", "return_value"); Replaceall(tm, "$result", "return_value"); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); @@ -994,16 +1331,21 @@ public: } } - Setattr(n, "wrap:name", wname); + if (!overloaded) { + Setattr(n, "wrap:name", wname); + } else { + Setattr(n, "wrap:name", overloadwname); + } + Setattr(n, "wrapper:method:name", wname); + + bool php_constructor = (constructor && Cmp(class_name, Getattr(n, "constructorHandler:sym:name")) == 0); /* emit function call */ String *actioncode = emit_action(n); if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { Replaceall(tm, "$input", Swig_cresult_name()); - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "return_value"); - Replaceall(tm, "$result", "return_value"); + Replaceall(tm, "$result", php_constructor ? "ZEND_THIS" : "return_value"); Replaceall(tm, "$owner", newobject ? "1" : "0"); Printf(f->code, "%s\n", tm); } else { @@ -1033,15 +1375,20 @@ public: Delete(tm); } - Printf(f->code, "thrown:\n"); - Printf(f->code, "return;\n"); + if (static_getter) { + Printf(f->code, "}\n"); + } - /* Error handling code */ - Printf(f->code, "fail:\n"); - Printv(f->code, cleanup, NIL); - Append(f->code, "SWIG_FAIL();\n"); + if (static_setter || static_getter) { + Printf(f->code, "}\n"); + } - Printf(f->code, "}\n"); + if (!static_setter) { + Printf(f->code, "fail:\n"); + Printv(f->code, cleanup, NIL); + Printf(f->code, "return;\n"); + Printf(f->code, "}\n"); + } Replaceall(f->code, "$cleanup", cleanup); Replaceall(f->code, "$symname", iname); @@ -1049,828 +1396,10 @@ public: Wrapper_print(f, s_wrappers); DelWrapper(f); f = NULL; - - if (overloaded && !Getattr(n, "sym:nextSibling")) { - dispatchFunction(n); - } - - Delete(wname); wname = NULL; - if (!shadow) { - return SWIG_OK; - } - - // Handle getters and setters. - if (wrapperType == membervar) { - const char *p = Char(iname); - if (strlen(p) > 4) { - p += strlen(p) - 4; - String *varname = Getattr(n, "membervariableHandler:sym:name"); - if (strcmp(p, "_get") == 0) { - Setattr(shadow_get_vars, varname, Getattr(n, "type")); - } else if (strcmp(p, "_set") == 0) { - Setattr(shadow_set_vars, varname, iname); - } - } - return SWIG_OK; - } - - // Only look at non-overloaded methods and the last entry in each overload - // chain (we check the last so that wrap:parms and wrap:name have been set - // for them all). - if (overloaded && Getattr(n, "sym:nextSibling") != 0) - return SWIG_OK; - - if (!s_oowrappers) - s_oowrappers = NewStringEmpty(); - - if (newobject || wrapperType == memberfn || wrapperType == staticmemberfn || wrapperType == standard || wrapperType == staticmembervar) { - bool handle_as_overload = false; - String **arg_names; - String **arg_values; - unsigned char * byref; - // Method or static method or plain function. - const char *methodname = 0; - String *output = s_oowrappers; - if (constructor) { - class_has_ctor = true; - // Skip the Foo:: prefix. - char *ptr = strrchr(GetChar(current_class, "sym:name"), ':'); - if (ptr) { - ptr++; - } else { - ptr = GetChar(current_class, "sym:name"); - } - if (strcmp(ptr, GetChar(n, "constructorHandler:sym:name")) == 0) { - methodname = "__construct"; - } else { - // The class has multiple constructors and this one is - // renamed, so this will be a static factory function - methodname = GetChar(n, "constructorHandler:sym:name"); - } - } else if (wrapperType == memberfn) { - methodname = Char(Getattr(n, "memberfunctionHandler:sym:name")); - } else if (wrapperType == staticmemberfn) { - methodname = Char(Getattr(n, "staticmemberfunctionHandler:sym:name")); - } else if (wrapperType == staticmembervar) { - // Static member variable, wrapped as a function due to PHP limitations. - methodname = Char(Getattr(n, "staticmembervariableHandler:sym:name")); - } else { // wrapperType == standard - methodname = Char(iname); - if (!s_fakeoowrappers) - s_fakeoowrappers = NewStringEmpty(); - output = s_fakeoowrappers; - } - - bool really_overloaded = overloaded ? true : false; - int min_num_of_arguments = emit_num_required(l); - int max_num_of_arguments = emit_num_arguments(l); - - Hash *ret_types = NewHash(); - Setattr(ret_types, d, d); - - bool non_void_return = (Cmp(d, "void") != 0); - - if (overloaded) { - // Look at all the overloaded versions of this method in turn to - // decide if it's really an overloaded method, or just one where some - // parameters have default values. - Node *o = Getattr(n, "sym:overloaded"); - while (o) { - if (o == n) { - o = Getattr(o, "sym:nextSibling"); - continue; - } - - SwigType *d2 = Getattr(o, "type"); - if (!d2) { - assert(constructor); - } else if (!Getattr(ret_types, d2)) { - Setattr(ret_types, d2, d2); - non_void_return = non_void_return || (Cmp(d2, "void") != 0); - } - - ParmList *l2 = Getattr(o, "wrap:parms"); - int num_arguments = emit_num_arguments(l2); - int num_required = emit_num_required(l2); - if (num_required < min_num_of_arguments) - min_num_of_arguments = num_required; - - if (num_arguments > max_num_of_arguments) { - max_num_of_arguments = num_arguments; - } - o = Getattr(o, "sym:nextSibling"); - } - - o = Getattr(n, "sym:overloaded"); - while (o) { - if (o == n) { - o = Getattr(o, "sym:nextSibling"); - continue; - } - - ParmList *l2 = Getattr(o, "wrap:parms"); - Parm *p = l, *p2 = l2; - if (wrapperType == memberfn) { - p = nextSibling(p); - p2 = nextSibling(p2); - } - while (p && p2) { - if (Cmp(Getattr(p, "type"), Getattr(p2, "type")) != 0) - break; - if (Cmp(Getattr(p, "name"), Getattr(p2, "name")) != 0) - break; - String *value = Getattr(p, "value"); - String *value2 = Getattr(p2, "value"); - if (value && !value2) - break; - if (!value && value2) - break; - if (value) { - if (Cmp(value, value2) != 0) - break; - } - p = nextSibling(p); - p2 = nextSibling(p2); - } - if (p && p2) - break; - // One parameter list is a prefix of the other, so check that all - // remaining parameters of the longer list are optional. - if (p2) - p = p2; - while (p && Getattr(p, "value")) - p = nextSibling(p); - if (p) - break; - o = Getattr(o, "sym:nextSibling"); - } - if (!o) { - // This "overloaded method" is really just one with default args. - really_overloaded = false; - } - } - - if (wrapperType == memberfn) { - // Allow for the "this" pointer. - --min_num_of_arguments; - --max_num_of_arguments; - } - - arg_names = (String **) malloc(max_num_of_arguments * sizeof(String *)); - if (!arg_names) { - /* FIXME: How should this be handled? The rest of SWIG just seems - * to not bother checking for malloc failing! */ - fprintf(stderr, "Malloc failed!\n"); - SWIG_exit(EXIT_FAILURE); - } - for (i = 0; i < max_num_of_arguments; ++i) { - arg_names[i] = NULL; - } - - arg_values = (String **) malloc(max_num_of_arguments * sizeof(String *)); - byref = (unsigned char *) malloc(max_num_of_arguments); - if (!arg_values || !byref) { - /* FIXME: How should this be handled? The rest of SWIG just seems - * to not bother checking for malloc failing! */ - fprintf(stderr, "Malloc failed!\n"); - SWIG_exit(EXIT_FAILURE); - } - for (i = 0; i < max_num_of_arguments; ++i) { - arg_values[i] = NULL; - byref[i] = false; - } - - Node *o; - if (overloaded) { - o = Getattr(n, "sym:overloaded"); - } else { - o = n; - } - while (o) { - int argno = 0; - Parm *p = Getattr(o, "wrap:parms"); - if (wrapperType == memberfn) - p = nextSibling(p); - while (p) { - if (GetInt(p, "tmap:in:numinputs") == 0) { - p = nextSibling(p); - continue; - } - assert(0 <= argno && argno < max_num_of_arguments); - byref[argno] = GetFlag(p, "tmap:in:byref"); - String *&pname = arg_names[argno]; - const char *pname_cstr = GetChar(p, "name"); - // Just get rid of the C++ namespace part for now. - const char *ptr = NULL; - if (pname_cstr && (ptr = strrchr(pname_cstr, ':'))) { - pname_cstr = ptr + 1; - } - if (!pname_cstr) { - // Unnamed parameter, e.g. int foo(int); - } else if (!pname) { - pname = NewString(pname_cstr); - } else { - size_t len = strlen(pname_cstr); - size_t spc = 0; - size_t len_pname = strlen(Char(pname)); - while (spc + len <= len_pname) { - if (strncmp(pname_cstr, Char(pname) + spc, len) == 0) { - char ch = ((char *) Char(pname))[spc + len]; - if (ch == '\0' || ch == ' ') { - // Already have this pname_cstr. - pname_cstr = NULL; - break; - } - } - char *p = strchr(Char(pname) + spc, ' '); - if (!p) - break; - spc = (p + 4) - Char(pname); - } - if (pname_cstr) { - Printf(pname, " or_%s", pname_cstr); - } - } - String *value = NewString(Getattr(p, "value")); - if (Len(value)) { - /* Check that value is a valid constant in PHP (and adjust it if - * necessary, or replace it with "?" if it's just not valid). */ - SwigType *type = Getattr(p, "type"); - switch (SwigType_type(type)) { - case T_BOOL: { - if (Strcmp(value, "true") == 0 || Strcmp(value, "false") == 0) - break; - char *p; - errno = 0; - long n = strtol(Char(value), &p, 0); - Clear(value); - if (errno || *p) { - Append(value, "?"); - } else if (n) { - Append(value, "true"); - } else { - Append(value, "false"); - } - break; - } - case T_CHAR: - case T_SCHAR: - case T_SHORT: - case T_INT: - case T_LONG: - case T_LONGLONG: { - char *p; - errno = 0; - long n = strtol(Char(value), &p, 0); - (void) n; - if (errno || *p) { - Clear(value); - Append(value, "?"); - } - break; - } - case T_UCHAR: - case T_USHORT: - case T_UINT: - case T_ULONG: - case T_ULONGLONG: { - char *p; - errno = 0; - unsigned int n = strtoul(Char(value), &p, 0); - (void) n; - if (errno || *p) { - Clear(value); - Append(value, "?"); - } - break; - } - case T_FLOAT: - case T_DOUBLE: - case T_LONGDOUBLE: { - char *p; - errno = 0; - /* FIXME: strtod is locale dependent... */ - double val = strtod(Char(value), &p); - if (errno || *p) { - Clear(value); - Append(value, "?"); - } else if (strchr(Char(value), '.') == 0) { - // Ensure value is a double constant, not an integer one. - Append(value, ".0"); - double val2 = strtod(Char(value), &p); - if (errno || *p || val != val2) { - Clear(value); - Append(value, "?"); - } - } - break; - } - case T_STRING: - if (Len(value) < 2) { - // How can a string (including "" be less than 2 characters?) - Clear(value); - Append(value, "?"); - } else { - const char *v = Char(value); - if (v[0] != '"' || v[Len(value) - 1] != '"') { - Clear(value); - Append(value, "?"); - } - // Strings containing "$" require special handling, but we do - // that later. - } - break; - case T_VOID: - assert(false); - break; - case T_POINTER: { - const char *v = Char(value); - if (v[0] == '(') { - // Handle "(void*)0", "(TYPE*)0", "(char*)NULL", etc. - v += strcspn(v + 1, "*()") + 1; - if (*v == '*') { - do { - v++; - v += strspn(v, " \t"); - } while (*v == '*'); - if (*v++ == ')') { - v += strspn(v, " \t"); - String * old = value; - value = NewString(v); - Delete(old); - } - } - } - if (Strcmp(value, "NULL") == 0 || - Strcmp(value, "nullptr") == 0 || - Strcmp(value, "0") == 0 || - Strcmp(value, "0L") == 0) { - Clear(value); - Append(value, "null"); - } else { - Clear(value); - Append(value, "?"); - } - break; - } - default: - /* Safe default */ - Clear(value); - Append(value, "?"); - break; - } - - if (!arg_values[argno]) { - arg_values[argno] = value; - value = NULL; - } else if (Cmp(arg_values[argno], value) != 0) { - // If a parameter has two different default values in - // different overloaded forms of the function, we can't - // set its default in PHP. Flag this by setting its - // default to `?'. - Delete(arg_values[argno]); - arg_values[argno] = NewString("?"); - } - } else if (arg_values[argno]) { - // This argument already has a default value in another overloaded - // form, but doesn't in this form. So don't try to do anything - // clever, just let the C wrappers resolve the overload and set the - // default values. - // - // This handling is safe, but I'm wondering if it may be overly - // conservative (FIXME) in some cases. It seems it's only bad when - // there's an overloaded form with the appropriate number of - // parameters which doesn't want the default value, but I need to - // think about this more. - Delete(arg_values[argno]); - arg_values[argno] = NewString("?"); - } - Delete(value); - p = nextSibling(p); - ++argno; - } - if (!really_overloaded) - break; - o = Getattr(o, "sym:nextSibling"); - } - - /* Clean up any parameters which haven't yet got names, or whose - * names clash. */ - Hash *seen = NewHash(); - /* We need $this to refer to the current class, so can't allow it - * to be used as a parameter. */ - Setattr(seen, "this", seen); - - for (int argno = 0; argno < max_num_of_arguments; ++argno) { - String *&pname = arg_names[argno]; - if (pname) { - Replaceall(pname, " ", "_"); - } else { - /* We get here if the SWIG .i file has "int foo(int);" */ - pname = NewStringEmpty(); - Printf(pname, "arg%d", argno + 1); - } - // Check if we've already used this parameter name. - while (Getattr(seen, pname)) { - // Append "_" to clashing names until they stop clashing... - Printf(pname, "_"); - } - Setattr(seen, Char(pname), seen); - - if (arg_values[argno] && Cmp(arg_values[argno], "?") == 0) { - handle_as_overload = true; - } - } - Delete(seen); - seen = NULL; - - String *invoke = NewStringEmpty(); - String *prepare = NewStringEmpty(); - String *args = NewStringEmpty(); - - if (!handle_as_overload && !(really_overloaded && max_num_of_arguments > min_num_of_arguments)) { - Printf(invoke, "%s(", iname); - if (wrapperType == memberfn) { - Printf(invoke, "$this->%s", SWIG_PTR); - } - for (int i = 0; i < max_num_of_arguments; ++i) { - if (i) - Printf(args, ","); - if (i || wrapperType == memberfn) - Printf(invoke, ","); - if (byref[i]) Printf(args, "&"); - String *value = arg_values[i]; - if (value) { - const char *v = Char(value); - if (v[0] == '"') { - /* In a PHP double quoted string, $ needs to be escaped as \$. */ - Replaceall(value, "$", "\\$"); - } - Printf(args, "$%s=%s", arg_names[i], value); - } else if (constructor && strcmp(methodname, "__construct") == 0 && i >= 1 && i < min_num_of_arguments) { - // We need to be able to call __construct($resource). - Printf(args, "$%s=null", arg_names[i]); - } else { - Printf(args, "$%s", arg_names[i]); - } - Printf(invoke, "$%s", arg_names[i]); - } - Printf(invoke, ")"); - } else { - int i; - for (i = 0; i < min_num_of_arguments; ++i) { - if (i) - Printf(args, ","); - Printf(args, "$%s", arg_names[i]); - } - String *invoke_args = NewStringEmpty(); - if (wrapperType == memberfn) { - Printf(invoke_args, "$this->%s", SWIG_PTR); - if (min_num_of_arguments > 0) - Printf(invoke_args, ","); - } - Printf(invoke_args, "%s", args); - if (constructor && min_num_of_arguments > 1) { - // We need to be able to call __construct($resource). - Clear(args); - Printf(args, "$%s", arg_names[0]); - for (i = 1; i < min_num_of_arguments; ++i) { - Printf(args, ","); - Printf(args, "$%s=null", arg_names[i]); - } - } - bool had_a_case = false; - int last_handled_i = i - 1; - for (; i < max_num_of_arguments; ++i) { - if (i) - Printf(args, ","); - const char *value = Char(arg_values[i]); - // FIXME: (really_overloaded && handle_as_overload) is perhaps a - // little conservative, but it doesn't hit any cases that it - // shouldn't for Xapian at least (and we need it to handle - // "Enquire::get_mset()" correctly). - bool non_php_default = ((really_overloaded && handle_as_overload) || - !value || strcmp(value, "?") == 0); - if (non_php_default) - value = "null"; - Printf(args, "$%s=%s", arg_names[i], value); - if (non_php_default) { - if (!had_a_case) { - Printf(prepare, "\t\tswitch (func_num_args()) {\n"); - had_a_case = true; - } - Printf(prepare, "\t\t"); - while (last_handled_i < i) { - Printf(prepare, "case %d: ", ++last_handled_i); - } - if (non_void_return) { - if ((!directorsEnabled() || !Swig_directorclass(n)) && !constructor) { - Append(prepare, "$r="); - } else if (wrapperType == staticmemberfn || wrapperType == staticmembervar) { - Append(prepare, "$r="); - } else { - Printf(prepare, "$this->%s=", SWIG_PTR); - } - } - if (!directorsEnabled() || !Swig_directorclass(n) || !constructor) { - Printf(prepare, "%s(%s); break;\n", iname, invoke_args); - } else if (!i) { - Printf(prepare, "%s($_this%s); break;\n", iname, invoke_args); - } else { - Printf(prepare, "%s($_this, %s); break;\n", iname, invoke_args); - } - } - if (i || wrapperType == memberfn) - Printf(invoke_args, ","); - Printf(invoke_args, "$%s", arg_names[i]); - } - Printf(prepare, "\t\t"); - if (had_a_case) - Printf(prepare, "default: "); - if (non_void_return) { - if ((!directorsEnabled() || !Swig_directorclass(n)) && !constructor) { - Append(prepare, "$r="); - } else if (wrapperType == staticmemberfn || wrapperType == staticmembervar) { - Append(prepare, "$r="); - } else { - Printf(prepare, "$this->%s=", SWIG_PTR); - } - } - - if (!directorsEnabled() || !Swig_directorclass(n) || !constructor) { - Printf(prepare, "%s(%s);\n", iname, invoke_args); - } else { - Printf(prepare, "%s($_this, %s);\n", iname, invoke_args); - } - if (had_a_case) - Printf(prepare, "\t\t}\n"); - Delete(invoke_args); - Printf(invoke, "$r"); - } - - Printf(output, "\n"); - // If it's a member function or a class constructor... - if (wrapperType == memberfn || (constructor && current_class)) { - String *acc = NewString(Getattr(n, "access")); - // If a base has the same method with public access, then PHP - // requires to have it here as public as well - Node *bases = Getattr(Swig_methodclass(n), "bases"); - if (bases && Strcmp(acc, "public") != 0) { - String *warnmsg = 0; - int haspublicbase = 0; - Iterator i = First(bases); - while (i.item) { - Node *j = firstChild(i.item); - while (j) { - String *jname = Getattr(j, "name"); - if (!jname || Strcmp(jname, Getattr(n, "name")) != 0) { - j = nextSibling(j); - continue; - } - if (Strcmp(nodeType(j), "cdecl") == 0) { - if (!Getattr(j, "access") || checkAttribute(j, "access", "public")) { - haspublicbase = 1; - } - } else if (Strcmp(nodeType(j), "using") == 0 && firstChild(j) && Strcmp(nodeType(firstChild(j)), "cdecl") == 0) { - if (!Getattr(firstChild(j), "access") || checkAttribute(firstChild(j), "access", "public")) { - haspublicbase = 1; - } - } - if (haspublicbase) { - warnmsg = NewStringf("Modifying the access of '%s::%s' to public, as the base '%s' has it as public as well.\n", Getattr(current_class, "classtype"), Getattr(n, "name"), Getattr(i.item, "classtype")); - break; - } - j = nextSibling(j); - } - i = Next(i); - if (haspublicbase) { - break; - } - } - if (Getattr(n, "access") && haspublicbase) { - Delete(acc); - acc = NewStringEmpty(); // implicitly public - Swig_warning(WARN_PHP_PUBLIC_BASE, input_file, line_number, Char(warnmsg)); - Delete(warnmsg); - } - } - - if (Cmp(acc, "public") == 0) { - // The default visibility for methods is public, so don't specify - // that explicitly to keep the wrapper size down. - Delete(acc); - acc = NewStringEmpty(); - } else if (Cmp(acc, "") != 0) { - Append(acc, " "); - } - - if (constructor) { - // Discriminate between the PHP constructor and a C++ constructor - // renamed to become a factory function in PHP. - bool php_constructor = (strcmp(methodname, "__construct") == 0); - const char * arg0 = NULL; - if (max_num_of_arguments > 0) { - arg0 = Char(arg_names[0]); - } else if (php_constructor) { - // The PHP constructor needs to be able to wrap a resource, but a - // renamed constructor doesn't. - arg0 = "res"; - Delete(args); - args = NewString("$res=null"); - } - String *mangled_type = SwigType_manglestr(Getattr(n, "type")); - if (!php_constructor) { - // A renamed constructor should be a static method. - Append(acc, "static "); - } - Printf(output, "\t%sfunction %s(%s) {\n", acc, methodname, args); - if (php_constructor) { - // The PHP constructor needs to be able to wrap a resource, but a - // renamed constructor doesn't. - Printf(output, "\t\tif (is_resource($%s) && get_resource_type($%s) === '%s') {\n", arg0, arg0, mangled_type); - Printf(output, "\t\t\t$this->%s=$%s;\n", SWIG_PTR, arg0); - Printf(output, "\t\t\treturn;\n"); - Printf(output, "\t\t}\n"); - } - } else { - Printf(output, "\t%sfunction %s(%s) {\n", acc, methodname, args); - } - Delete(acc); - } else if (wrapperType == staticmembervar) { - // We're called twice for a writable static member variable - first - // with "foo_set" and then with "foo_get" - so generate half the - // wrapper function each time. - // - // For a const static member, we only get called once. - static bool started = false; - if (!started) { - Printf(output, "\tstatic function %s() {\n", methodname); - if (max_num_of_arguments) { - // Setter. - Printf(output, "\t\tif (func_num_args()) {\n"); - Printf(output, "\t\t\t%s(func_get_arg(0));\n", iname); - Printf(output, "\t\t\treturn;\n"); - Printf(output, "\t\t}\n"); - started = true; - goto done; - } - } - started = false; - } else { - Printf(output, "\tstatic function %s(%s) {\n", methodname, args); - } - - if (!constructor) - Printf(output, "%s", prepare); - if (constructor) { - if (!directorsEnabled() || !Swig_directorclass(n)) { - if (!Len(prepare)) { - if (strcmp(methodname, "__construct") == 0) { - Printf(output, "\t\t$this->%s=%s;\n", SWIG_PTR, invoke); - } else { - String *classname = Swig_class_name(current_class); - Printf(output, "\t\treturn new %s%s(%s);\n", prefix, classname, invoke); - } - } - } else { - Node *parent = Swig_methodclass(n); - String *classname = Swig_class_name(parent); - Printf(output, "\t\tif (get_class($this) === '%s%s') {\n", prefix, classname); - Printf(output, "\t\t\t$_this = null;\n"); - Printf(output, "\t\t} else {\n"); - Printf(output, "\t\t\t$_this = $this;\n"); - Printf(output, "\t\t}\n"); - if (!Len(prepare)) { - if (num_arguments > 1) { - Printf(output, "\t\t$this->%s=%s($_this, %s);\n", SWIG_PTR, iname, args); - } else { - Printf(output, "\t\t$this->%s=%s($_this);\n", SWIG_PTR, iname); - } - } - } - Printf(output, "%s", prepare); - } else if (!non_void_return && !hasargout) { - if (Cmp(invoke, "$r") != 0) - Printf(output, "\t\t%s;\n", invoke); - } else if (is_class(d)) { - if (Cmp(invoke, "$r") != 0) - Printf(output, "\t\t$r=%s;\n", invoke); - if (Len(ret_types) == 1) { - /* If d is abstract we can't create a new wrapper type d. */ - Node *d_class = classLookup(d); - int is_abstract = 0; - if (Getattr(d_class, "abstracts")) { - is_abstract = 1; - } - if (newobject || !is_abstract) { - Printf(output, "\t\tif (is_resource($r)) {\n"); - if (Getattr(classLookup(Getattr(n, "type")), "module")) { - /* - * _p_Foo -> Foo, _p_ns__Bar -> Bar - * TODO: do this in a more elegant way - */ - if (Len(prefix) == 0) { - Printf(output, "\t\t\t$c=substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));\n"); - } else { - Printf(output, "\t\t\t$c='%s'.substr(get_resource_type($r), (strpos(get_resource_type($r), '__') ? strpos(get_resource_type($r), '__') + 2 : 3));\n", prefix); - } - Printf(output, "\t\t\tif (class_exists($c)) return new $c($r);\n"); - Printf(output, "\t\t\treturn new %s%s($r);\n", prefix, Getattr(classLookup(d), "sym:name")); - } else { - Printf(output, "\t\t\t$c = new stdClass();\n"); - Printf(output, "\t\t\t$c->" SWIG_PTR " = $r;\n"); - Printf(output, "\t\t\treturn $c;\n"); - } - Printf(output, "\t\t}\n\t\treturn $r;\n"); - } else { - Printf(output, "\t\t$this->%s = $r;\n", SWIG_PTR); - Printf(output, "\t\treturn $this;\n"); - } - } else { - Printf(output, "\t\tif (!is_resource($r)) return $r;\n"); - String *wrapobj = NULL; - String *common = NULL; - Iterator i = First(ret_types); - while (i.item) { - SwigType *ret_type = i.item; - i = Next(i); - String *mangled = NewString("_p"); - Printf(mangled, "%s", SwigType_manglestr(ret_type)); - Node *class_node = Getattr(zend_types, mangled); - if (!class_node) { - /* This is needed when we're returning a pointer to a type - * rather than returning the type by value or reference. */ - Delete(mangled); - mangled = NewString(SwigType_manglestr(ret_type)); - class_node = Getattr(zend_types, mangled); - if (!class_node) { - // Return type isn't an object, so will be handled by the - // !is_resource() check before the switch. - continue; - } - } - const char *classname = GetChar(class_node, "sym:name"); - if (!classname) - classname = GetChar(class_node, "name"); - String * action = NewStringEmpty(); - if (classname) - Printf(action, "return new %s%s($r);\n", prefix, classname); - else - Printf(action, "return $r;\n"); - if (!wrapobj) { - wrapobj = NewString("\t\tswitch (get_resource_type($r)) {\n"); - common = action; - } else { - if (common && Cmp(common, action) != 0) { - Delete(common); - common = NULL; - } - } - Printf(wrapobj, "\t\t"); - if (i.item) { - Printf(wrapobj, "case '%s': ", mangled); - } else { - Printf(wrapobj, "default: "); - } - Printv(wrapobj, action, NIL); - if (action != common) Delete(action); - Delete(mangled); - } - Printf(wrapobj, "\t\t}\n"); - if (common) { - // All cases have the same action, so eliminate the switch - // wrapper. - Printf(output, "\t\t%s", common); - Delete(common); - } else { - Printv(output, wrapobj, NIL); - } - Delete(wrapobj); - } - } else { - if (non_void_return || hasargout) { - Printf(output, "\t\treturn %s;\n", invoke); - } else if (Cmp(invoke, "$r") != 0) { - Printf(output, "\t\t%s;\n", invoke); - } - } - Printf(output, "\t}\n"); - -done: - Delete(prepare); - Delete(invoke); - free(arg_values); - - Delete(args); - args = NULL; - - for (int i = 0; i < max_num_of_arguments; ++i) { - Delete(arg_names[i]); - } - free(arg_names); - arg_names = NULL; + if (overloaded && !Getattr(n, "sym:nextSibling")) { + dispatchFunction(n, constructor); } return SWIG_OK; @@ -1880,57 +1409,13 @@ done: * globalvariableHandler() * ------------------------------------------------------------ */ - virtual int globalvariableHandler(Node *n) { - char *name = GetChar(n, "name"); - char *iname = GetChar(n, "sym:name"); - SwigType *t = Getattr(n, "type"); - String *tm; - - /* First do the wrappers such as name_set(), name_get() - * as provided by the baseclass's implementation of variableWrapper - */ - if (Language::globalvariableHandler(n) == SWIG_NOWRAP) { - return SWIG_NOWRAP; - } - - if (!addSymbol(iname, n)) - return SWIG_ERROR; - - /* First link C variables to PHP */ - - tm = Swig_typemap_lookup("varinit", n, name, 0); - if (tm) { - Replaceall(tm, "$target", name); - Printf(s_vinit, "%s\n", tm); - } else { - Swig_error(input_file, line_number, "Unable to link with type %s\n", SwigType_str(t, 0)); - } - - /* Now generate PHP -> C sync blocks */ - /* - tm = Swig_typemap_lookup("varin", n, name, 0); - if(tm) { - Replaceall(tm, "$symname", iname); - Printf(f_c->code, "%s\n", tm); - } else { - Swig_error(input_file, line_number, "Unable to link with type %s\n", SwigType_str(t, 0)); - } - */ - /* Now generate C -> PHP sync blocks */ - /* - if(!GetFlag(n,"feature:immutable")) { - - tm = Swig_typemap_lookup("varout", n, name, 0); - if(tm) { - Replaceall(tm, "$symname", iname); - Printf(f_php->code, "%s\n", tm); - } else { - Swig_error(input_file, line_number, "Unable to link with type %s\n", SwigType_str(t, 0)); - } - } - */ - return SWIG_OK; - } + /* PHP doesn't support intercepting reads and writes to global variables + * (nor static property reads and writes so we can't wrap them as static + * properties on a dummy class) so just let SWIG do its default thing and + * wrap them as name_get() and name_set(). + */ + //virtual int globalvariableHandler(Node *n) { + //} /* ------------------------------------------------------------ * constantWrapper() @@ -1949,48 +1434,42 @@ done: SwigType_remember(type); - if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); - Replaceall(tm, "$value", value); - Printf(s_cinit, "%s\n", tm); - } - - if (shadow) { - String *enumvalue = GetChar(n, "enumvalue"); - String *set_to = iname; - - if (!enumvalue) { - enumvalue = GetChar(n, "enumvalueex"); + if (!wrapping_member_constant) { + { + tm = Swig_typemap_lookup("consttab", n, name, 0); + Replaceall(tm, "$value", value); + if (Getattr(n, "tmap:consttab:rinit")) { + Printf(r_init, "%s\n", tm); + } else { + Printf(s_cinit, "%s\n", tm); + } } - if (enumvalue && *Char(enumvalue)) { - // Check for a simple constant expression which is valid in PHP. - // If we find one, initialise the const member with it; otherwise - // we initialise it using the C/C++ wrapped constant. - const char *p; - for (p = Char(enumvalue); *p; ++p) { - if (!isdigit((unsigned char)*p) && !strchr(" +-", *p)) { - // FIXME: enhance to handle `<previous_enum> + 1' which is what - // we get for enums that don't have an explicit value set. - break; - } - } - if (!*p) - set_to = enumvalue; - } + { + tm = Swig_typemap_lookup("classconsttab", n, name, 0); - if (wrapping_member_constant) { - if (!s_oowrappers) - s_oowrappers = NewStringEmpty(); - Printf(s_oowrappers, "\n\tconst %s = %s;\n", wrapping_member_constant, set_to); + Replaceall(tm, "$class", fake_class_name()); + Replaceall(tm, "$const_name", iname); + Replaceall(tm, "$value", value); + if (Getattr(n, "tmap:classconsttab:rinit")) { + Printf(r_init, "%s\n", tm); + } else { + Printf(s_cinit, "%s\n", tm); + } + } + } else { + tm = Swig_typemap_lookup("classconsttab", n, name, 0); + Replaceall(tm, "$class", class_name); + Replaceall(tm, "$const_name", wrapping_member_constant); + Replaceall(tm, "$value", value); + if (Getattr(n, "tmap:classconsttab:rinit")) { + Printf(r_init, "%s\n", tm); } else { - if (!s_fakeoowrappers) - s_fakeoowrappers = NewStringEmpty(); - Printf(s_fakeoowrappers, "\n\tconst %s = %s;\n", iname, set_to); + Printf(s_cinit, "%s\n", tm); } } + wrapperType = standard; return SWIG_OK; } @@ -2052,219 +1531,156 @@ done: * ------------------------------------------------------------ */ virtual int classHandler(Node *n) { - constructors = 0; - current_class = n; + String *symname = Getattr(n, "sym:name"); + String *base_class = NULL; + + class_name = symname; + + Printf(all_cs_entry, "static zend_function_entry class_%s_functions[] = {\n", class_name); + + // namespace code to introduce namespaces into wrapper classes. + //if (nameSpace != NULL) + //Printf(s_oinit, "INIT_CLASS_ENTRY(internal_ce, \"%s\\\\%s\", class_%s_functions);\n", nameSpace, class_name, class_name); + //else + Printf(s_oinit, " INIT_CLASS_ENTRY(internal_ce, \"%s%s\", class_%s_functions);\n", prefix, class_name, class_name); if (shadow) { char *rename = GetChar(n, "sym:name"); if (!addSymbol(rename, n)) return SWIG_ERROR; - shadow_classname = NewString(rename); - - shadow_get_vars = NewHash(); - shadow_set_vars = NewHash(); /* Deal with inheritance */ List *baselist = Getattr(n, "bases"); if (baselist) { Iterator base = First(baselist); - while (base.item && GetFlag(base.item, "feature:ignore")) { - base = Next(base); - } - base = Next(base); - if (base.item) { - /* Warn about multiple inheritance for additional base class(es) */ - while (base.item) { - if (GetFlag(base.item, "feature:ignore")) { - base = Next(base); - continue; + while (base.item) { + if (!GetFlag(base.item, "feature:ignore")) { + if (!base_class) { + base_class = Getattr(base.item, "sym:name"); + } else { + /* Warn about multiple inheritance for additional base class(es) */ + String *proxyclassname = SwigType_str(Getattr(n, "classtypeobj"), 0); + String *baseclassname = SwigType_str(Getattr(base.item, "name"), 0); + Swig_warning(WARN_PHP_MULTIPLE_INHERITANCE, input_file, line_number, + "Warning for %s, base %s ignored. Multiple inheritance is not supported in PHP.\n", proxyclassname, baseclassname); } - String *proxyclassname = SwigType_str(Getattr(n, "classtypeobj"), 0); - String *baseclassname = SwigType_str(Getattr(base.item, "name"), 0); - Swig_warning(WARN_PHP_MULTIPLE_INHERITANCE, input_file, line_number, - "Warning for %s, base %s ignored. Multiple inheritance is not supported in PHP.\n", proxyclassname, baseclassname); - base = Next(base); } + base = Next(base); } } } - classnode = n; - Language::classHandler(n); - classnode = 0; - - if (shadow) { - List *baselist = Getattr(n, "bases"); - Iterator ki, base; + if (GetFlag(n, "feature:exceptionclass") && Getattr(n, "feature:except")) { + /* PHP requires thrown objects to be instances of or derived from + * Exception, so that really needs to take priority over any + * explicit base class. + */ + if (base_class) { + String *proxyclassname = SwigType_str(Getattr(n, "classtypeobj"), 0); + Swig_warning(WARN_PHP_MULTIPLE_INHERITANCE, input_file, line_number, + "Warning for %s, base %s ignored. Multiple inheritance is not supported in PHP.\n", proxyclassname, base_class); + } + base_class = NewString("Exception"); + } - if (baselist) { - base = First(baselist); - while (base.item && GetFlag(base.item, "feature:ignore")) { - base = Next(base); - } - } else { - base.item = NULL; - } + if (Equal(base_class, "Exception")) { + Printf(s_oinit, " SWIGTYPE_%s_ce = zend_register_internal_class_ex(&internal_ce, zend_ce_exception);\n", class_name); + } else if (is_class_wrapped(base_class)) { + Printf(s_oinit, " SWIGTYPE_%s_ce = zend_register_internal_class_ex(&internal_ce, SWIGTYPE_%s_ce);\n", class_name, base_class); + } else { + Printf(s_oinit, " SWIGTYPE_%s_ce = zend_register_internal_class(&internal_ce);\n", class_name); + } - if (Getattr(n, "abstracts") && !GetFlag(n, "feature:notabstract")) { - Printf(s_phpclasses, "abstract "); - } + if (Getattr(n, "abstracts") && !GetFlag(n, "feature:notabstract")) { + Printf(s_oinit, " SWIGTYPE_%s_ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;\n", class_name); + } - Printf(s_phpclasses, "class %s%s ", prefix, shadow_classname); - String *baseclass = NULL; - if (base.item && Getattr(base.item, "module")) { - baseclass = Getattr(base.item, "sym:name"); - if (!baseclass) - baseclass = Getattr(base.item, "name"); - Printf(s_phpclasses, "extends %s%s ", prefix, baseclass); - } else if (GetFlag(n, "feature:exceptionclass")) { - Append(s_phpclasses, "extends Exception "); - } - { - Node *node = NewHash(); - Setattr(node, "type", Getattr(n, "name")); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - String * interfaces = Swig_typemap_lookup("phpinterfaces", node, "", 0); - if (interfaces) { - Printf(s_phpclasses, "implements %s ", interfaces); - } - Delete(node); - } - Printf(s_phpclasses, "{\n\tpublic $%s=null;\n", SWIG_PTR); - if (!baseclass) { - // Only store this in the base class (NB !baseclass means we *are* - // a base class...) - Printf(s_phpclasses, "\tprotected $%s=array();\n", SWIG_DATA); - } + { + Node *node = NewHash(); + Setattr(node, "type", Getattr(n, "name")); + Setfile(node, Getfile(n)); + Setline(node, Getline(n)); + String *interfaces = Swig_typemap_lookup("phpinterfaces", node, "", 0); + Replaceall(interfaces, " ", ""); + if (interfaces && Len(interfaces) > 0) { + // It seems we need to wait until RINIT time to look up class entries + // for interfaces by name. The downside is that this then happens for + // every request. + // + // Most pre-defined interfaces are accessible via zend_class_entry* + // variables declared in the PHP C API - these we can use at MINIT + // time, so we special case them. This will also be a little faster + // than looking up by name. + Printv(s_header, + "#ifdef __cplusplus\n", + "extern \"C\" {\n", + "#endif\n", + NIL); - // Write property SET handlers - ki = First(shadow_set_vars); - if (ki.key) { - // This class has setters. - Printf(s_phpclasses, "\n\tfunction __set($var,$value) {\n"); - // FIXME: tune this threshold... - if (Len(shadow_set_vars) <= 2) { - // Not many setters, so avoid call_user_func. - for (; ki.key; ki = Next(ki)) { - DOH *key = ki.key; - String *iname = ki.item; - Printf(s_phpclasses, "\t\tif ($var === '%s') return %s($this->%s,$value);\n", key, iname, SWIG_PTR); - } - } else { - Printf(s_phpclasses, "\t\t$func = '%s_'.$var.'_set';\n", shadow_classname); - Printf(s_phpclasses, "\t\tif (function_exists($func)) return call_user_func($func,$this->%s,$value);\n", SWIG_PTR); - } - Printf(s_phpclasses, "\t\tif ($var === 'thisown') return swig_%s_alter_newobject($this->%s,$value);\n", module, SWIG_PTR); - if (baseclass) { - Printf(s_phpclasses, "\t\t%s%s::__set($var,$value);\n", prefix, baseclass); - } else { - Printf(s_phpclasses, "\t\t$this->%s[$var] = $value;\n", SWIG_DATA); - } - Printf(s_phpclasses, "\t}\n"); - } else { - Printf(s_phpclasses, "\n\tfunction __set($var,$value) {\n"); - Printf(s_phpclasses, "\t\tif ($var === 'thisown') return swig_%s_alter_newobject($this->%s,$value);\n", module, SWIG_PTR); - if (baseclass) { - Printf(s_phpclasses, "\t\t%s%s::__set($var,$value);\n", prefix, baseclass); - } else { - Printf(s_phpclasses, "\t\t$this->%s[$var] = $value;\n", SWIG_DATA); + String *r_init_prefix = NewStringEmpty(); + + List *interface_list = Split(interfaces, ',', -1); + int num_interfaces = Len(interface_list); + for (int i = 0; i < num_interfaces; ++i) { + String *interface = Getitem(interface_list, i); + // We generate conditional code in both minit and rinit - then we or the user + // just need to define SWIG_PHP_INTERFACE_xxx_CE (and optionally + // SWIG_PHP_INTERFACE_xxx_CE) to handle interface `xxx` at minit-time. + Printv(s_header, + "#ifdef SWIG_PHP_INTERFACE_", interface, "_HEADER\n", + "# include SWIG_PHP_INTERFACE_", interface, "_HEADER\n", + "#endif\n", + NIL); + Printv(s_oinit, + "#ifdef SWIG_PHP_INTERFACE_", interface, "_CE\n", + " zend_do_implement_interface(SWIGTYPE_", class_name, "_ce, SWIG_PHP_INTERFACE_", interface, "_CE);\n", + "#endif\n", + NIL); + Printv(r_init_prefix, + "#ifndef SWIG_PHP_INTERFACE_", interface, "_CE\n", + " {\n", + " zend_class_entry *swig_interface_ce = zend_lookup_class(zend_string_init(\"", interface, "\", sizeof(\"", interface, "\") - 1, 0));\n", + " if (!swig_interface_ce) zend_throw_exception(zend_ce_error, \"Interface \\\"", interface, "\\\" not found\", 0);\n", + " zend_do_implement_interface(SWIGTYPE_", class_name, "_ce, swig_interface_ce);\n", + " }\n", + "#endif\n", + NIL); } - Printf(s_phpclasses, "\t}\n"); - } - // Write property GET handlers - ki = First(shadow_get_vars); - if (ki.key) { - // This class has getters. - Printf(s_phpclasses, "\n\tfunction __get($var) {\n"); - int non_class_getters = 0; - for (; ki.key; ki = Next(ki)) { - DOH *key = ki.key; - SwigType *d = ki.item; - if (!is_class(d)) { - ++non_class_getters; - continue; - } - Printv(s_phpclasses, "\t\tif ($var === '", key, "') return new ", prefix, Getattr(classLookup(d), "sym:name"), "(", shadow_classname, "_", key, "_get($this->", SWIG_PTR, "));\n", NIL); - } - // FIXME: tune this threshold... - if (non_class_getters <= 2) { - // Not many non-class getters, so avoid call_user_func. - for (ki = First(shadow_get_vars); non_class_getters && ki.key; ki = Next(ki)) { - DOH *key = ki.key; - SwigType *d = ki.item; - if (is_class(d)) continue; - Printv(s_phpclasses, "\t\tif ($var === '", key, "') return ", shadow_classname, "_", key, "_get($this->", SWIG_PTR, ");\n", NIL); - --non_class_getters; - } - } else { - Printf(s_phpclasses, "\t\t$func = '%s_'.$var.'_get';\n", shadow_classname); - Printf(s_phpclasses, "\t\tif (function_exists($func)) return call_user_func($func,$this->%s);\n", SWIG_PTR); - } - Printf(s_phpclasses, "\t\tif ($var === 'thisown') return swig_%s_get_newobject($this->%s);\n", module, SWIG_PTR); - if (baseclass) { - Printf(s_phpclasses, "\t\treturn %s%s::__get($var);\n", prefix, baseclass); - } else { - // Reading an unknown property name gives null in PHP. - Printf(s_phpclasses, "\t\treturn $this->%s[$var];\n", SWIG_DATA); - } - Printf(s_phpclasses, "\t}\n"); - - /* __isset() should return true for read-only properties, so check for - * *_get() not *_set(). */ - Printf(s_phpclasses, "\n\tfunction __isset($var) {\n"); - Printf(s_phpclasses, "\t\tif (function_exists('%s_'.$var.'_get')) return true;\n", shadow_classname); - Printf(s_phpclasses, "\t\tif ($var === 'thisown') return true;\n"); - if (baseclass) { - Printf(s_phpclasses, "\t\treturn %s%s::__isset($var);\n", prefix, baseclass); - } else { - Printf(s_phpclasses, "\t\treturn array_key_exists($var, $this->%s);\n", SWIG_DATA); - } - Printf(s_phpclasses, "\t}\n"); - } else { - Printf(s_phpclasses, "\n\tfunction __get($var) {\n"); - Printf(s_phpclasses, "\t\tif ($var === 'thisown') return swig_%s_get_newobject($this->%s);\n", module, SWIG_PTR); - if (baseclass) { - Printf(s_phpclasses, "\t\treturn %s%s::__get($var);\n", prefix, baseclass); - } else { - Printf(s_phpclasses, "\t\treturn $this->%s[$var];\n", SWIG_DATA); - } - Printf(s_phpclasses, "\t}\n"); - Printf(s_phpclasses, "\n\tfunction __isset($var) {\n"); - Printf(s_phpclasses, "\t\tif ($var === 'thisown') return true;\n"); - if (baseclass) { - Printf(s_phpclasses, "\t\treturn %s%s::__isset($var);\n", prefix, baseclass); - } else { - Printf(s_phpclasses, "\t\treturn array_key_exists($var, $this->%s);\n", SWIG_DATA); - } - Printf(s_phpclasses, "\t}\n"); - } + // Handle interfaces at the start of rinit so that they're added + // before any potential constant objects, etc which might be created + // later in rinit. + Insert(r_init, 0, r_init_prefix); + Delete(r_init_prefix); - if (!class_has_ctor) { - Printf(s_phpclasses, "\tfunction __construct($h) {\n"); - Printf(s_phpclasses, "\t\t$this->%s=$h;\n", SWIG_PTR); - Printf(s_phpclasses, "\t}\n"); + Printv(s_header, + "#ifdef __cplusplus\n", + "}\n", + "#endif\n", + NIL); } + Delete(interfaces); + } - if (s_oowrappers) { - Printf(s_phpclasses, "%s", s_oowrappers); - Delete(s_oowrappers); - s_oowrappers = NULL; - } - class_has_ctor = false; + Printf(s_oinit, " SWIGTYPE_%s_ce->create_object = %s_object_new;\n", class_name, class_name); + Printf(s_oinit, " memcpy(&%s_object_handlers,zend_get_std_object_handlers(), sizeof(zend_object_handlers));\n", class_name); + Printf(s_oinit, " %s_object_handlers.clone_obj = NULL;\n", class_name); + // If not defined we aren't wrapping any functions which use this type as a + // parameter or return value, in which case we don't need the clientdata + // set. + Printf(s_oinit, "#ifdef SWIGTYPE_p%s\n", SwigType_manglestr(Getattr(n, "classtypeobj"))); + Printf(s_oinit, " SWIG_TypeClientData(SWIGTYPE_p%s,SWIGTYPE_%s_ce);\n", SwigType_manglestr(Getattr(n, "classtypeobj")), class_name); + Printf(s_oinit, "#endif\n"); + Printf(s_oinit, "\n"); - Printf(s_phpclasses, "}\n\n"); + Language::classHandler(n); - Delete(shadow_classname); - shadow_classname = NULL; + print_creation_free_wrapper(n); + generate_magic_property_methods(n, base_class); + Printf(all_cs_entry, " ZEND_FE_END\n};\n\n"); - Delete(shadow_set_vars); - shadow_set_vars = NULL; - Delete(shadow_get_vars); - shadow_get_vars = NULL; - } + class_name = NULL; return SWIG_OK; } @@ -2285,6 +1701,25 @@ done: * ------------------------------------------------------------ */ virtual int membervariableHandler(Node *n) { + if (magic_set == NULL) { + magic_set = NewStringEmpty(); + magic_get = NewStringEmpty(); + magic_isset = NewStringEmpty(); + } + + String *v_name = GetChar(n, "name"); + + Printf(magic_set, "\nelse if (strcmp(ZSTR_VAL(arg2),\"%s\") == 0) {\n", v_name); + Printf(magic_set, "ZVAL_STRING(&tempZval, \"%s_set\");\n", v_name); + Printf(magic_set, "call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,1,&args[1]);\n}\n"); + + Printf(magic_get, "\nelse if (strcmp(ZSTR_VAL(arg2),\"%s\") == 0) {\n", v_name); + Printf(magic_get, "ZVAL_STRING(&tempZval, \"%s_get\");\n", v_name); + Printf(magic_get, "call_user_function(EG(function_table),ZEND_THIS,&tempZval,return_value,0,NULL);\n}\n"); + + Printf(magic_isset, "\nelse if (strcmp(ZSTR_VAL(arg2),\"%s\") == 0) {\n", v_name); + Printf(magic_isset, "RETVAL_TRUE;\n}\n"); + wrapperType = membervar; Language::membervariableHandler(n); wrapperType = standard; @@ -2325,9 +1760,7 @@ done: * ------------------------------------------------------------ */ virtual int constructorHandler(Node *n) { - constructors++; if (Swig_directorclass(n)) { - String *name = GetChar(Swig_methodclass(n), "name"); String *ctype = GetChar(Swig_methodclass(n), "classtype"); String *sname = GetChar(Swig_methodclass(n), "sym:name"); String *args = NewStringEmpty(); @@ -2352,10 +1785,12 @@ done: Delete(director_ctor_code); director_ctor_code = NewStringEmpty(); director_prot_ctor_code = NewStringEmpty(); - Printf(director_ctor_code, "if (Z_TYPE_P(arg0) == IS_NULL) { /* not subclassed */\n"); - Printf(director_prot_ctor_code, "if (Z_TYPE_P(arg0) == IS_NULL) { /* not subclassed */\n"); - Printf(director_ctor_code, " %s = (%s *)new %s(%s);\n", Swig_cresult_name(), ctype, ctype, args); - Printf(director_prot_ctor_code, " SWIG_PHP_Error(E_ERROR, \"accessing abstract class or protected constructor\");\n", name, name, args); + Printf(director_ctor_code, "if (Swig::Director::swig_is_overridden_method(\"%s\", arg0)) { /* not subclassed */\n", class_name); + Printf(director_prot_ctor_code, "if (Swig::Director::swig_is_overridden_method(\"%s\", arg0)) { /* not subclassed */\n", class_name); + Printf(director_ctor_code, " %s = new %s(%s);\n", Swig_cresult_name(), ctype, args); + Printf(director_prot_ctor_code, + " zend_throw_exception(zend_ce_type_error, \"accessing abstract class or protected constructor\", 0);\n" + " return;\n"); if (i) { Insert(args, 0, ", "); } @@ -2374,62 +1809,10 @@ done: } /* ------------------------------------------------------------ - * CreateZendListDestructor() + * destructorHandler() * ------------------------------------------------------------ */ //virtual int destructorHandler(Node *n) { //} - int CreateZendListDestructor(Node *n) { - String *name = GetChar(Swig_methodclass(n), "name"); - String *iname = GetChar(n, "sym:name"); - ParmList *l = Getattr(n, "parms"); - - String *destructorname = NewStringEmpty(); - Printf(destructorname, "_%s", Swig_name_wrapper(iname)); - Setattr(classnode, "destructor", destructorname); - - Wrapper *f = NewWrapper(); - Printf(f->def, "/* This function is designed to be called by the zend list destructors */\n"); - Printf(f->def, "/* to typecast and do the actual destruction */\n"); - Printf(f->def, "static void %s(zend_resource *res, const char *type_name) {\n", destructorname); - - Wrapper_add_localv(f, "value", "swig_object_wrapper *value=(swig_object_wrapper *) res->ptr", NIL); - Wrapper_add_localv(f, "ptr", "void *ptr=value->ptr", NIL); - Wrapper_add_localv(f, "newobject", "int newobject=value->newobject", NIL); - - emit_parameter_variables(l, f); - emit_attach_parmmaps(l, f); - - // Get type of first arg, thing to be destructed - // Skip ignored arguments - Parm *p = l; - //while (Getattr(p,"tmap:ignore")) {p = Getattr(p,"tmap:ignore:next");} - while (checkAttribute(p, "tmap:in:numinputs", "0")) { - p = Getattr(p, "tmap:in:next"); - } - SwigType *pt = Getattr(p, "type"); - - Printf(f->code, " efree(value);\n"); - Printf(f->code, " if (! newobject) return; /* can't delete it! */\n"); - Printf(f->code, " arg1 = (%s)SWIG_ConvertResourceData(ptr, type_name, SWIGTYPE%s);\n", SwigType_lstr(pt, 0), SwigType_manglestr(pt)); - Printf(f->code, " if (! arg1) zend_error(E_ERROR, \"%s resource already free'd\");\n", Char(name)); - - Setattr(n, "wrap:name", destructorname); - - String *actioncode = emit_action(n); - Append(f->code, actioncode); - Delete(actioncode); - - Printf(f->code, "thrown:\n"); - Append(f->code, "return;\n"); - Append(f->code, "fail:\n"); - Append(f->code, "SWIG_FAIL();\n"); - Printf(f->code, "}\n"); - - Wrapper_print(f, s_wrappers); - DelWrapper(f); - - return SWIG_OK; - } /* ------------------------------------------------------------ * memberconstantHandler() @@ -2612,12 +1995,10 @@ done: Delete(super_call); } else { Printf(w->code, "Swig::DirectorPureVirtualException::raise(\"Attempted to invoke pure virtual method %s::%s\");\n", SwigType_namestr(c_classname), - SwigType_namestr(name)); + SwigType_namestr(name)); } } else { /* attach typemaps to arguments (C/C++ -> PHP) */ - String *parse_args = NewStringEmpty(); - Swig_director_parms_fixup(l); /* remove the wrapper 'w' since it was producing spurious temps */ @@ -2655,9 +2036,7 @@ done: Delete(input); Replaceall(tm, "$owner", "0"); Printv(wrap_args, tm, "\n", NIL); - Putc('O', parse_args); } else { - Append(parse_args, parse); Setattr(p, "emit:directorinput", pname); Replaceall(tm, "$input", pname); Replaceall(tm, "$owner", "0"); @@ -2676,25 +2055,6 @@ done: p = nextSibling(p); } - /* exception handling */ - bool error_used_in_typemap = false; - tm = Swig_typemap_lookup("director:except", n, Swig_cresult_name(), 0); - if (!tm) { - tm = Getattr(n, "feature:director:except"); - if (tm) - tm = Copy(tm); - } - if ((tm) && Len(tm) && (Strcmp(tm, "1") != 0)) { - if (Replaceall(tm, "$error", "error")) { - /* Only declare error if it is used by the typemap. */ - error_used_in_typemap = true; - Append(w->code, "int error;\n"); - } - } else { - Delete(tm); - tm = NULL; - } - if (!idx) { Printf(w->code, "zval *args = NULL;\n"); } else { @@ -2703,24 +2063,38 @@ done: // typemap_directorout testcase requires that 0 can be assigned to the // variable named after the result of Swig_cresult_name(), so that can't // be a zval - make it a pointer to one instead. - Printf(w->code, "zval swig_zval_result, swig_funcname;\n", Swig_cresult_name()); + Printf(w->code, "zval swig_zval_result;\n"); Printf(w->code, "zval * SWIGUNUSED %s = &swig_zval_result;\n", Swig_cresult_name()); - const char * funcname = GetChar(n, "sym:name"); - Printf(w->code, "ZVAL_STRINGL(&swig_funcname, \"%s\", %d);\n", funcname, strlen(funcname)); /* wrap complex arguments to zvals */ - Printv(w->code, wrap_args, NIL); + Append(w->code, wrap_args); - if (error_used_in_typemap) { - Append(w->code, "error = "); - } - Append(w->code, "call_user_function(EG(function_table), &swig_self, &swig_funcname,"); - Printf(w->code, " &swig_zval_result, %d, args);\n", idx); + const char * funcname = GetChar(n, "sym:name"); + Append(w->code, "{\n"); + Append(w->code, "#if PHP_MAJOR_VERSION < 8\n"); + Printf(w->code, "zval swig_funcname;\n"); + Printf(w->code, "ZVAL_STRINGL(&swig_funcname, \"%s\", %d);\n", funcname, strlen(funcname)); + Printf(w->code, "call_user_function(EG(function_table), &swig_self, &swig_funcname, &swig_zval_result, %d, args);\n", idx); + Append(w->code, "#else\n"); + Printf(w->code, "zend_string *swig_funcname = zend_string_init(\"%s\", %d, 0);\n", funcname, strlen(funcname)); + Append(w->code, "zend_function *swig_zend_func = zend_std_get_method(&Z_OBJ(swig_self), swig_funcname, NULL);\n"); + Append(w->code, "zend_string_release(swig_funcname);\n"); + Printf(w->code, "if (swig_zend_func) zend_call_known_instance_method(swig_zend_func, Z_OBJ(swig_self), &swig_zval_result, %d, args);\n", idx); + Append(w->code, "#endif\n"); - if (tm) { + /* exception handling */ + tm = Swig_typemap_lookup("director:except", n, Swig_cresult_name(), 0); + if (!tm) { + tm = Getattr(n, "feature:director:except"); + if (tm) + tm = Copy(tm); + } + if ((tm) && Len(tm) && (Strcmp(tm, "1") != 0)) { + Replaceall(tm, "$error", "EG(exception)"); Printv(w->code, Str(tm), "\n", NIL); - Delete(tm); } + Append(w->code, "}\n"); + Delete(tm); /* marshal return value from PHP to C/C++ type */ @@ -2749,8 +2123,8 @@ done: Delete(tm); } else { Swig_warning(WARN_TYPEMAP_DIRECTOROUT_UNDEF, input_file, line_number, - "Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0), SwigType_namestr(c_classname), - SwigType_namestr(name)); + "Unable to use return type %s in director method %s::%s (skipping method).\n", SwigType_str(returntype, 0), + SwigType_namestr(c_classname), SwigType_namestr(name)); status = SWIG_ERROR; } } @@ -2767,12 +2141,11 @@ done: } } - Delete(parse_args); Delete(cleanup); Delete(outarg); } - Append(w->code, "thrown:\n"); + Append(w->code, "fail: ;\n"); if (!is_void) { if (!(ignored_method && !pure_virtual)) { String *rettype = SwigType_str(returntype, 0); @@ -2783,12 +2156,7 @@ done: } Delete(rettype); } - } else { - Append(w->code, "return;\n"); } - - Append(w->code, "fail:\n"); - Append(w->code, "SWIG_FAIL();\n"); Append(w->code, "}\n"); // We expose protected methods via an extra public inline method which makes a straight call to the wrapped class' method @@ -2823,36 +2191,31 @@ done: return status; } - int classDirectorDisown(Node *) { - return SWIG_OK; + int classDirectorDisown(Node *n) { + wrapperType = directordisown; + int result = Language::classDirectorDisown(n); + wrapperType = standard; + return result; } }; /* class PHP */ static PHP *maininstance = 0; -// We use this function to be able to write out zend_register_list_destructor_ex -// lines for most things in the type table +// Collect non-class pointer types from the type table so we can set up PHP +// resource types for them later. +// // NOTE: it's a function NOT A PHP::METHOD extern "C" { static void typetrace(const SwigType *ty, String *mangled, String *clientdata) { - Node *class_node; - if (!zend_types) { - zend_types = NewHash(); - } - // we want to know if the type which reduced to this has a constructor - if ((class_node = maininstance->classLookup(ty))) { - if (!Getattr(zend_types, mangled)) { - // OK it may have been set before by a different SwigType but it would - // have had the same underlying class node I think - // - it is certainly required not to have different originating class - // nodes for the same SwigType - Setattr(zend_types, mangled, class_node); - } - } else { // a non-class pointer - Setattr(zend_types, mangled, NOTCLASS); + if (maininstance->classLookup(ty) == NULL) { + // a non-class pointer + if (!zend_types) { + zend_types = NewHash(); + } + Setattr(zend_types, mangled, mangled); } if (r_prevtracefunc) - (*r_prevtracefunc) (ty, mangled, (String *) clientdata); + (*r_prevtracefunc) (ty, mangled, clientdata); } } diff --git a/Source/Modules/pike.cxx b/Source/Modules/pike.cxx deleted file mode 100644 index b8ed4037a..000000000 --- a/Source/Modules/pike.cxx +++ /dev/null @@ -1,904 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * pike.cxx - * - * Pike language module for SWIG. - * ----------------------------------------------------------------------------- */ - -/* - * Notes: - * - * - The current approach used for "out" typemaps is inconsistent with - * how "out" typemaps are handled by other language modules. Instead - * of converting the C/C++ type ($1) to a Pike object type (e.g. a - * struct svalue), we're just calling the appropriate push_XXX - * (e.g. push_int) to push the return value onto the stack. - * - * - Pike classes can't have static member functions or data, so we need - * to find some other appropriate mapping for C++ static member functions - * and data. - * - * - Pike doesn't seem to provide any default way to print the memory - * address, etc. for extension objects. Should we do something here? - * - */ - -#include "swigmod.h" - -#include <ctype.h> // for isalnum() - -static const char *usage = "\ -Pike Options (available with -pike)\n\ - [no additional options]\n\ -\n"; - -class PIKE:public Language { -private: - - File *f_begin; - File *f_runtime; - File *f_header; - File *f_wrappers; - File *f_init; - File *f_classInit; - - String *PrefixPlusUnderscore; - int current; - - // Wrap modes - enum { - NO_CPP, - MEMBER_FUNC, - CONSTRUCTOR, - DESTRUCTOR, - MEMBER_VAR, - CLASS_CONST, - STATIC_FUNC, - STATIC_VAR - }; - -public: - - /* --------------------------------------------------------------------- - * PIKE() - * - * Initialize member data - * --------------------------------------------------------------------- */ - - PIKE() { - f_begin = 0; - f_runtime = 0; - f_header = 0; - f_wrappers = 0; - f_init = 0; - f_classInit = 0; - PrefixPlusUnderscore = 0; - current = NO_CPP; - } - - /* --------------------------------------------------------------------- - * main() - * - * Parse command line options and initializes variables. - * --------------------------------------------------------------------- */ - - virtual void main(int argc, char *argv[]) { - - /* Set location of SWIG library */ - SWIG_library_directory("pike"); - - /* Look for certain command line options */ - for (int i = 1; i < argc; i++) { - if (argv[i]) { - if (strcmp(argv[i], "-help") == 0) { - fputs(usage, stdout); - } - } - } - - /* Add a symbol to the parser for conditional compilation */ - Preprocessor_define("SWIGPIKE 1", 0); - - /* Set language-specific configuration file */ - SWIG_config_file("pike.swg"); - - /* Set typemap language */ - SWIG_typemap_lang("pike"); - - /* Enable overloaded methods support */ - allow_overloading(); - } - - /* --------------------------------------------------------------------- - * top() - * --------------------------------------------------------------------- */ - - virtual int top(Node *n) { - /* Get the module name */ - String *module = Getattr(n, "name"); - - /* Get the output file name */ - String *outfile = Getattr(n, "outfile"); - - /* Open the output file */ - f_begin = NewFile(outfile, "w", SWIG_output_files()); - if (!f_begin) { - FileErrorDisplay(outfile); - SWIG_exit(EXIT_FAILURE); - } - f_runtime = NewString(""); - f_init = NewString(""); - f_classInit = NewString(""); - f_header = NewString(""); - f_wrappers = NewString(""); - - /* Register file targets with the SWIG file handler */ - Swig_register_filebyname("header", f_header); - Swig_register_filebyname("wrapper", f_wrappers); - Swig_register_filebyname("begin", f_begin); - Swig_register_filebyname("runtime", f_runtime); - Swig_register_filebyname("init", f_init); - Swig_register_filebyname("classInit", f_classInit); - - /* Standard stuff for the SWIG runtime section */ - Swig_banner(f_begin); - - Printf(f_runtime, "\n\n#ifndef SWIGPIKE\n#define SWIGPIKE\n#endif\n\n"); - - Printf(f_header, "#define SWIG_init pike_module_init\n"); - Printf(f_header, "#define SWIG_name \"%s\"\n\n", module); - - /* Change naming scheme for constructors and destructors */ - Swig_name_register("construct", "%n%c_create"); - Swig_name_register("destroy", "%n%c_destroy"); - - /* Current wrap type */ - current = NO_CPP; - - /* Emit code for children */ - Language::top(n); - - /* Close the initialization function */ - Printf(f_init, "}\n"); - SwigType_emit_type_table(f_runtime, f_wrappers); - - /* Close all of the files */ - Dump(f_runtime, f_begin); - Dump(f_header, f_begin); - Dump(f_wrappers, f_begin); - Wrapper_pretty_print(f_init, f_begin); - - Delete(f_header); - Delete(f_wrappers); - Delete(f_init); - Delete(f_classInit); - Delete(f_runtime); - Delete(f_begin); - - /* Done */ - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * validIdentifier() - * ------------------------------------------------------------ */ - - virtual int validIdentifier(String *s) { - char *c = Char(s); - const char *c0 = c; - const char *c1 = c0 + 1; - while (*c) { - if (*c == '`' && c == c0) { - c++; - continue; - } - if ((*c == '+' || *c == '-' || *c == '*' || *c == '/') && c == c1) { - c++; - continue; - } - if (!(isalnum(*c) || (*c == '_'))) - return 0; - c++; - } - return 1; - } - - /* ------------------------------------------------------------ - * importDirective() - * ------------------------------------------------------------ */ - - virtual int importDirective(Node *n) { - String *modname = Getattr(n, "module"); - if (modname) { - Printf(f_init, "pike_require(\"%s\");\n", modname); - } - return Language::importDirective(n); - } - - /* ------------------------------------------------------------ - * strip() - * - * For names that begin with the current class prefix plus an - * underscore (e.g. "Foo_enum_test"), return the base function - * name (i.e. "enum_test"). - * ------------------------------------------------------------ */ - - String *strip(const DOHconst_String_or_char_ptr name) { - String *s = Copy(name); - if (Strncmp(name, PrefixPlusUnderscore, Len(PrefixPlusUnderscore)) != 0) { - return s; - } - Replaceall(s, PrefixPlusUnderscore, ""); - return s; - } - - /* ------------------------------------------------------------ - * add_method() - * ------------------------------------------------------------ */ - - void add_method(const DOHconst_String_or_char_ptr name, const DOHconst_String_or_char_ptr function, const DOHconst_String_or_char_ptr description) { - String *rename = NULL; - switch (current) { - case NO_CPP: - rename = NewString(name); - Printf(f_init, "ADD_FUNCTION(\"%s\", %s, tFunc(%s), 0);\n", rename, function, description); - break; - case STATIC_FUNC: - case STATIC_VAR: - rename = NewString(name); - Printf(f_init, "ADD_FUNCTION(\"%s\", %s, tFunc(%s), 0);\n", rename, function, description); - break; - case CONSTRUCTOR: - case DESTRUCTOR: - case MEMBER_FUNC: - case MEMBER_VAR: - rename = strip(name); - Printf(f_classInit, "ADD_FUNCTION(\"%s\", %s, tFunc(%s), 0);\n", rename, function, description); - break; - case CLASS_CONST: // shouldn't have gotten here for CLASS_CONST nodes - default: // what is this? - assert(false); - } - Delete(rename); - } - - /* --------------------------------------------------------------------- - * functionWrapper() - * - * Create a function declaration and register it with the interpreter. - * --------------------------------------------------------------------- */ - - virtual int functionWrapper(Node *n) { - - String *name = Getattr(n, "name"); - String *iname = Getattr(n, "sym:name"); - SwigType *d = Getattr(n, "type"); - ParmList *l = Getattr(n, "parms"); - - Parm *p; - String *tm; - int i; - - String *overname = 0; - if (Getattr(n, "sym:overloaded")) { - overname = Getattr(n, "sym:overname"); - } else { - if (!addSymbol(iname, n)) - return SWIG_ERROR; - } - - Wrapper *f = NewWrapper(); - - // Emit all of the local variables for holding arguments. - emit_parameter_variables(l, f); - - /* Attach the standard typemaps */ - emit_attach_parmmaps(l, f); - Setattr(n, "wrap:parms", l); - - /* Get number of required and total arguments */ - int num_arguments = emit_num_arguments(l); - int varargs = emit_isvarargs(l); - - /* Which input argument to start with? */ - int start = (current == MEMBER_FUNC || current == MEMBER_VAR || current == DESTRUCTOR) ? 1 : 0; - - /* Offset to skip over the attribute name */ - // int offset = (current == MEMBER_VAR) ? 1 : 0; - int offset = 0; - - String *wname = Swig_name_wrapper(iname); - if (overname) { - Append(wname, overname); - } - Setattr(n, "wrap:name", wname); - - Printv(f->def, "static void ", wname, "(INT32 args) {", NIL); - - /* Generate code for argument marshalling */ - String *description = NewString(""); - char source[64]; - for (i = 0, p = l; i < num_arguments; i++) { - - while (checkAttribute(p, "tmap:in:numinputs", "0")) { - p = Getattr(p, "tmap:in:next"); - } - - SwigType *pt = Getattr(p, "type"); - String *ln = Getattr(p, "lname"); - - if (i < start) { - String *lstr = SwigType_lstr(pt, 0); - Printf(f->code, "%s = (%s) THIS;\n", ln, lstr); - Delete(lstr); - } else { - /* Look for an input typemap */ - sprintf(source, "Pike_sp[%d-args]", i - start + offset); - if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", ln); - Replaceall(tm, "$input", source); - Setattr(p, "emit:input", source); - Printf(f->code, "%s\n", tm); - String *pikedesc = Getattr(p, "tmap:in:pikedesc"); - if (pikedesc) { - Printv(description, pikedesc, " ", NIL); - } - p = Getattr(p, "tmap:in:next"); - continue; - } else { - Swig_warning(WARN_TYPEMAP_IN_UNDEF, input_file, line_number, "Unable to use type %s as a function argument.\n", SwigType_str(pt, 0)); - break; - } - } - p = nextSibling(p); - } - - /* Check for trailing varargs */ - if (varargs) { - if (p && (tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$input", "varargs"); - Printv(f->code, tm, "\n", NIL); - } - } - - /* Insert constraint checking code */ - for (p = l; p;) { - if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); - Printv(f->code, tm, "\n", NIL); - p = Getattr(p, "tmap:check:next"); - } else { - p = nextSibling(p); - } - } - - /* Insert cleanup code */ - String *cleanup = NewString(""); - for (p = l; p;) { - if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Printv(cleanup, tm, "\n", NIL); - p = Getattr(p, "tmap:freearg:next"); - } else { - p = nextSibling(p); - } - } - - /* Insert argument output code */ - String *outarg = NewString(""); - for (p = l; p;) { - if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", "resultobj"); - Replaceall(tm, "$arg", Getattr(p, "emit:input")); - Replaceall(tm, "$input", Getattr(p, "emit:input")); - Printv(outarg, tm, "\n", NIL); - p = Getattr(p, "tmap:argout:next"); - } else { - p = nextSibling(p); - } - } - - /* Emit the function call */ - String *actioncode = emit_action(n); - - /* Clear the return stack */ - Printf(actioncode, "pop_n_elems(args);\n"); - - /* Return the function value */ - if (current == CONSTRUCTOR) { - Printv(actioncode, "THIS = (void *) ", Swig_cresult_name(), ";\n", NIL); - Printv(description, ", tVoid", NIL); - } else if (current == DESTRUCTOR) { - Printv(description, ", tVoid", NIL); - } else { - Printv(description, ", ", NIL); - if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - actioncode = 0; - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "resultobj"); - Replaceall(tm, "$result", "resultobj"); - if (GetFlag(n, "feature:new")) { - Replaceall(tm, "$owner", "1"); - } else { - Replaceall(tm, "$owner", "0"); - } - String *pikedesc = Getattr(n, "tmap:out:pikedesc"); - if (pikedesc) { - Printv(description, pikedesc, NIL); - } - Printf(f->code, "%s\n", tm); - } else { - Swig_warning(WARN_TYPEMAP_OUT_UNDEF, input_file, line_number, "Unable to use return type %s in function %s.\n", SwigType_str(d, 0), name); - } - } - if (actioncode) { - Append(f->code, actioncode); - Delete(actioncode); - } - emit_return_variable(n, d, f); - - /* Output argument output code */ - Printv(f->code, outarg, NIL); - - /* Output cleanup code */ - Printv(f->code, cleanup, NIL); - - /* Look to see if there is any newfree cleanup code */ - if (GetFlag(n, "feature:new")) { - if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Printf(f->code, "%s\n", tm); - } - } - - /* See if there is any return cleanup code */ - if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); - Printf(f->code, "%s\n", tm); - } - - /* Close the function */ - Printf(f->code, "}\n"); - - /* Substitute the cleanup code */ - Replaceall(f->code, "$cleanup", cleanup); - - /* Substitute the function name */ - Replaceall(f->code, "$symname", iname); - Replaceall(f->code, "$result", "resultobj"); - - /* Dump the function out */ - Wrapper_print(f, f_wrappers); - - /* Now register the function with the interpreter. */ - if (!Getattr(n, "sym:overloaded")) { - add_method(iname, wname, description); - } else { - if (!Getattr(n, "sym:nextSibling")) { - dispatchFunction(n); - } - } - - Delete(cleanup); - Delete(outarg); - Delete(description); - Delete(wname); - DelWrapper(f); - - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * dispatchFunction() - * - * Emit overloading dispatch function - * ------------------------------------------------------------ */ - - void dispatchFunction(Node *n) { - /* Last node in overloaded chain */ - - int maxargs; - String *tmp = NewString(""); - String *dispatch = Swig_overload_dispatch(n, "%s(args); return;", &maxargs); - - /* Generate a dispatch wrapper for all overloaded functions */ - - Wrapper *f = NewWrapper(); - String *symname = Getattr(n, "sym:name"); - String *wname = Swig_name_wrapper(symname); - - Printf(f->def, "static void %s(INT32 args) {", wname); - - Wrapper_add_local(f, "argc", "INT32 argc"); - Printf(tmp, "struct svalue argv[%d]", maxargs); - Wrapper_add_local(f, "argv", tmp); - Wrapper_add_local(f, "ii", "INT32 ii"); - - Printf(f->code, "argc = args;\n"); - Printf(f->code, "for (ii = 0; (ii < argc) && (ii < %d); ii++) {\n", maxargs); - Printf(f->code, "argv[ii] = Pike_sp[ii-args];\n"); - Printf(f->code, "}\n"); - - Replaceall(dispatch, "$args", "self, args"); - Printv(f->code, dispatch, "\n", NIL); - Printf(f->code, "Pike_error(\"No matching function for overloaded '%s'.\");\n", symname); - Printv(f->code, "}\n", NIL); - - Wrapper_print(f, f_wrappers); - - String *description = NewString(""); - Printf(description, "tAny,"); - if (current == CONSTRUCTOR || current == DESTRUCTOR) { - Printf(description, " tVoid"); - } else { - String *pd = Getattr(n, "tmap:out:pikedesc"); - if (pd) - Printf(description, " %s", pd); - } - add_method(symname, wname, description); - Delete(description); - - DelWrapper(f); - Delete(dispatch); - Delete(tmp); - Delete(wname); - } - - /* ------------------------------------------------------------ - * variableWrapper() - * ------------------------------------------------------------ */ - - virtual int variableWrapper(Node *n) { - return Language::variableWrapper(n); - } - - /* ------------------------------------------------------------ - * constantWrapper() - * ------------------------------------------------------------ */ - - virtual int constantWrapper(Node *n) { - - Swig_require("constantWrapper", n, "*sym:name", "type", "value", NIL); - - String *symname = Getattr(n, "sym:name"); - SwigType *type = Getattr(n, "type"); - String *value = Getattr(n, "value"); - bool is_enum_item = (Cmp(nodeType(n), "enumitem") == 0); - - if (SwigType_type(type) == T_MPOINTER) { - /* Special hook for member pointer */ - String *wname = Swig_name_wrapper(symname); - Printf(f_header, "static %s = %s;\n", SwigType_str(type, wname), value); - value = wname; - } else if (SwigType_type(type) == T_CHAR && is_enum_item) { - type = NewSwigType(T_INT); - Setattr(n, "type", type); - } - - /* Perform constant typemap substitution */ - String *tm = Swig_typemap_lookup("constant", n, value, 0); - if (tm) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", symname); - Replaceall(tm, "$symname", symname); - Replaceall(tm, "$value", value); - Printf(f_init, "%s\n", tm); - } else { - Swig_warning(WARN_TYPEMAP_CONST_UNDEF, input_file, line_number, "Unsupported constant value %s = %s\n", SwigType_str(type, 0), value); - } - - Swig_restore(n); - - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * nativeWrapper() - * ------------------------------------------------------------ */ - - virtual int nativeWrapper(Node *n) { - // return Language::nativeWrapper(n); - String *name = Getattr(n, "sym:name"); - String *wrapname = Getattr(n, "wrap:name"); - - if (!addSymbol(wrapname, n)) - return SWIG_ERROR; - - add_method(name, wrapname, 0); - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * enumDeclaration() - * ------------------------------------------------------------ */ - - virtual int enumDeclaration(Node *n) { - return Language::enumDeclaration(n); - } - - /* ------------------------------------------------------------ - * enumvalueDeclaration() - * ------------------------------------------------------------ */ - - virtual int enumvalueDeclaration(Node *n) { - return Language::enumvalueDeclaration(n); - } - - /* ------------------------------------------------------------ - * classDeclaration() - * ------------------------------------------------------------ */ - - virtual int classDeclaration(Node *n) { - return Language::classDeclaration(n); - } - - /* ------------------------------------------------------------ - * classHandler() - * ------------------------------------------------------------ */ - - virtual int classHandler(Node *n) { - - String *symname = Getattr(n, "sym:name"); - if (!addSymbol(symname, n)) - return SWIG_ERROR; - - PrefixPlusUnderscore = NewStringf("%s_", getClassPrefix()); - - Printf(f_classInit, "start_new_program();\n"); - - /* Handle inheritance */ - List *baselist = Getattr(n, "bases"); - if (baselist && Len(baselist) > 0) { - Iterator base = First(baselist); - while (base.item) { - String *basename = Getattr(base.item, "name"); - SwigType *basetype = NewString(basename); - SwigType_add_pointer(basetype); - SwigType_remember(basetype); - String *basemangle = SwigType_manglestr(basetype); - Printf(f_classInit, "low_inherit((struct program *) SWIGTYPE%s->clientdata, 0, 0, 0, 0, 0);\n", basemangle); - Delete(basemangle); - Delete(basetype); - base = Next(base); - } - } else { - Printf(f_classInit, "ADD_STORAGE(swig_object_wrapper);\n"); - } - - Language::classHandler(n); - - /* Accessors for member variables */ - /* - List *membervariables = Getattr(n,"membervariables"); - if (membervariables && Len(membervariables) > 0) { - membervariableAccessors(membervariables); - } - */ - - /* Done, close the class and dump its definition to the init function */ - Printf(f_classInit, "add_program_constant(\"%s\", pr = end_program(), 0);\n", symname); - Dump(f_classInit, f_init); - Clear(f_classInit); - - SwigType *tt = NewString(symname); - SwigType_add_pointer(tt); - SwigType_remember(tt); - String *tm = SwigType_manglestr(tt); - Printf(f_init, "SWIG_TypeClientData(SWIGTYPE%s, (void *) pr);\n", tm); - Delete(tm); - Delete(tt); - - Delete(PrefixPlusUnderscore); - PrefixPlusUnderscore = 0; - - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * memberfunctionHandler() - * - * Method for adding C++ member function - * ------------------------------------------------------------ */ - - virtual int memberfunctionHandler(Node *n) { - current = MEMBER_FUNC; - Language::memberfunctionHandler(n); - current = NO_CPP; - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * constructorHandler() - * - * Method for adding C++ member constructor - * ------------------------------------------------------------ */ - - virtual int constructorHandler(Node *n) { - current = CONSTRUCTOR; - Language::constructorHandler(n); - current = NO_CPP; - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * destructorHandler() - * ------------------------------------------------------------ */ - - virtual int destructorHandler(Node *n) { - current = DESTRUCTOR; - Language::destructorHandler(n); - current = NO_CPP; - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * membervariableAccessors() - * ------------------------------------------------------------ */ - - void membervariableAccessors(List *membervariables) { - String *name; - Iterator i; - bool need_setter; - String *funcname; - - /* If at least one of them is mutable, we need a setter */ - need_setter = false; - i = First(membervariables); - while (i.item) { - if (!GetFlag(i.item, "feature:immutable")) { - need_setter = true; - break; - } - i = Next(i); - } - - /* Create a function to set the values of the (mutable) variables */ - if (need_setter) { - Wrapper *wrapper = NewWrapper(); - String *setter = Swig_name_member(NSPACE_TODO, getClassPrefix(), "`->="); - String *wname = Swig_name_wrapper(setter); - Printv(wrapper->def, "static void ", wname, "(INT32 args) {", NIL); - Printf(wrapper->locals, "char *name = (char *) STR0(Pike_sp[0-args].u.string);\n"); - - i = First(membervariables); - while (i.item) { - if (!GetFlag(i.item, "feature:immutable")) { - name = Getattr(i.item, "name"); - funcname = Swig_name_wrapper(Swig_name_set(NSPACE_TODO, Swig_name_member(NSPACE_TODO, getClassPrefix(), name))); - Printf(wrapper->code, "if (!strcmp(name, \"%s\")) {\n", name); - Printf(wrapper->code, "%s(args);\n", funcname); - Printf(wrapper->code, "return;\n"); - Printf(wrapper->code, "}\n"); - Delete(funcname); - } - i = Next(i); - } - - /* Close the function */ - Printf(wrapper->code, "pop_n_elems(args);\n"); - Printf(wrapper->code, "}\n"); - - /* Dump wrapper code to the output file */ - Wrapper_print(wrapper, f_wrappers); - - /* Register it with Pike */ - String *description = NewString("tStr tFloat, tVoid"); - add_method("`->=", wname, description); - Delete(description); - - /* Clean up */ - Delete(wname); - Delete(setter); - DelWrapper(wrapper); - } - - /* Create a function to get the values of the (mutable) variables */ - Wrapper *wrapper = NewWrapper(); - String *getter = Swig_name_member(NSPACE_TODO, getClassPrefix(), "`->"); - String *wname = Swig_name_wrapper(getter); - Printv(wrapper->def, "static void ", wname, "(INT32 args) {", NIL); - Printf(wrapper->locals, "char *name = (char *) STR0(Pike_sp[0-args].u.string);\n"); - - i = First(membervariables); - while (i.item) { - name = Getattr(i.item, "name"); - funcname = Swig_name_wrapper(Swig_name_get(NSPACE_TODO, Swig_name_member(NSPACE_TODO, getClassPrefix(), name))); - Printf(wrapper->code, "if (!strcmp(name, \"%s\")) {\n", name); - Printf(wrapper->code, "%s(args);\n", funcname); - Printf(wrapper->code, "return;\n"); - Printf(wrapper->code, "}\n"); - Delete(funcname); - i = Next(i); - } - - /* Close the function */ - Printf(wrapper->code, "pop_n_elems(args);\n"); - Printf(wrapper->code, "}\n"); - - /* Dump wrapper code to the output file */ - Wrapper_print(wrapper, f_wrappers); - - /* Register it with Pike */ - String *description = NewString("tStr, tMix"); - add_method("`->", wname, description); - Delete(description); - - /* Clean up */ - Delete(wname); - Delete(getter); - DelWrapper(wrapper); - } - - /* ------------------------------------------------------------ - * membervariableHandler() - * ------------------------------------------------------------ */ - - virtual int membervariableHandler(Node *n) { - List *membervariables = Getattr(getCurrentClass(), "membervariables"); - if (!membervariables) { - membervariables = NewList(); - Setattr(getCurrentClass(), "membervariables", membervariables); - } - Append(membervariables, n); - current = MEMBER_VAR; - Language::membervariableHandler(n); - current = NO_CPP; - return SWIG_OK; - } - - /* ----------------------------------------------------------------------- - * staticmemberfunctionHandler() - * - * Wrap a static C++ function - * ---------------------------------------------------------------------- */ - - virtual int staticmemberfunctionHandler(Node *n) { - current = STATIC_FUNC; - Language::staticmemberfunctionHandler(n); - current = NO_CPP; - return SWIG_OK; - } - - /* ------------------------------------------------------------ - * memberconstantHandler() - * - * Create a C++ constant - * ------------------------------------------------------------ */ - - virtual int memberconstantHandler(Node *n) { - current = CLASS_CONST; - constantWrapper(n); - current = NO_CPP; - return SWIG_OK; - } - - /* --------------------------------------------------------------------- - * staticmembervariableHandler() - * --------------------------------------------------------------------- */ - - virtual int staticmembervariableHandler(Node *n) { - current = STATIC_VAR; - Language::staticmembervariableHandler(n); - current = NO_CPP; - return SWIG_OK; - } -}; - -/* ----------------------------------------------------------------------------- - * swig_pike() - Instantiate module - * ----------------------------------------------------------------------------- */ - -static Language *new_swig_pike() { - return new PIKE(); -} -extern "C" Language *swig_pike(void) { - return new_swig_pike(); -} diff --git a/Source/Modules/python.cxx b/Source/Modules/python.cxx index b437d2f6f..7d618635e 100644 --- a/Source/Modules/python.cxx +++ b/Source/Modules/python.cxx @@ -93,6 +93,7 @@ static int nortti = 0; static int relativeimport = 0; /* flags for the make_autodoc function */ +namespace { enum autodoc_t { AUTODOC_CLASS, AUTODOC_CTOR, @@ -103,7 +104,7 @@ enum autodoc_t { AUTODOC_CONST, AUTODOC_VAR }; - +} static const char *usage1 = "\ Python Options (available with -python)\n\ @@ -846,8 +847,13 @@ public: Printv(f_shadow_py, "\n", f_shadow_begin, "\n", NIL); Printv(f_shadow_py, "\nfrom sys import version_info as _swig_python_version_info\n", NULL); - Printv(f_shadow_py, "if _swig_python_version_info < (2, 7, 0):\n", NULL); - Printv(f_shadow_py, tab4, "raise RuntimeError(\"Python 2.7 or later required\")\n\n", NULL); + if (py3) { + Printv(f_shadow_py, "if _swig_python_version_info < (3, 0):\n", NULL); + Printv(f_shadow_py, tab4, "raise RuntimeError(\"Python 3.x or later required\")\n\n", NULL); + } else { + Printv(f_shadow_py, "if _swig_python_version_info < (2, 7, 0):\n", NULL); + Printv(f_shadow_py, tab4, "raise RuntimeError(\"Python 2.7 or later required\")\n\n", NULL); + } if (Len(f_shadow_after_begin) > 0) Printv(f_shadow_py, f_shadow_after_begin, "\n", NIL); @@ -2753,7 +2759,7 @@ public: if (!varargs) { Printv(f->def, linkage, wrap_return, wname, "(PyObject *", self_param, ", PyObject *args", builtin_kwargs, ") {", NIL); } else { - Printv(f->def, linkage, wrap_return, wname, "__varargs__", "(PyObject *", self_param, ", PyObject *args, PyObject *varargs) {", NIL); + Printv(f->def, linkage, wrap_return, wname, "__varargs__", "(PyObject *", self_param, ", PyObject *args, PyObject *varargs", builtin_kwargs, ") {", NIL); } if (allow_kwargs) { Swig_warning(WARN_LANG_OVERLOAD_KEYWORD, input_file, line_number, "Can't use keyword arguments with overloaded functions (%s).\n", Swig_name_decl(n)); @@ -2862,8 +2868,6 @@ public: } else { Replaceall(tm, "$self", "obj0"); } - Replaceall(tm, "$source", source); - Replaceall(tm, "$target", ln); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); /* Save the location of the object */ @@ -2971,7 +2975,6 @@ public: /* Insert constraint checking code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -2993,7 +2996,6 @@ public: } } if (tm && (Len(tm) != 0)) { - Replaceall(tm, "$source", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); } p = Getattr(p, "tmap:freearg:next"); @@ -3005,8 +3007,6 @@ public: /* Insert argument output code */ for (p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", "resultobj"); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); Printv(outarg, tm, "\n", NIL); @@ -3095,8 +3095,6 @@ public: } else { Replaceall(tm, "$self", "obj0"); } - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "resultobj"); Replaceall(tm, "$result", "resultobj"); if (builtin_ctor) { Replaceall(tm, "$owner", "SWIG_BUILTIN_INIT"); @@ -3162,7 +3160,6 @@ public: /* Look to see if there is any newfree cleanup code */ if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); Delete(tm); } @@ -3170,7 +3167,6 @@ public: /* See if there is any return cleanup code */ if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); Delete(tm); } @@ -3253,10 +3249,10 @@ public: Printf(f->code, " Py_XINCREF(swig_obj[i + %d]);\n", num_fixed_arguments); Printf(f->code, "}\n"); } else { - Printf(f->code, "newargs = PyTuple_GetSlice(args,0,%d);\n", num_fixed_arguments); - Printf(f->code, "varargs = PyTuple_GetSlice(args,%d,PyTuple_Size(args));\n", num_fixed_arguments); + Printf(f->code, "newargs = PyTuple_GetSlice(args, 0, %d);\n", num_fixed_arguments); + Printf(f->code, "varargs = PyTuple_GetSlice(args, %d, PyTuple_Size(args));\n", num_fixed_arguments); } - Printf(f->code, "resultobj = %s__varargs__(%s,newargs,varargs);\n", wname, builtin ? "self" : "NULL"); + Printf(f->code, "resultobj = %s__varargs__(%s, newargs, varargs%s);\n", wname, builtin ? "self" : "NULL", strlen(builtin_kwargs) == 0 ? "" : ", kwargs"); Append(f->code, "Py_XDECREF(newargs);\n"); Append(f->code, "Py_XDECREF(varargs);\n"); Append(f->code, "return resultobj;\n"); @@ -3456,8 +3452,6 @@ public: } Printf(setf->def, "SWIGINTERN int %s(PyObject *_val) {", varsetname); if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "_val"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "_val"); if (Getattr(n, "tmap:varin:implicitconv")) { Replaceall(tm, "$implicitconv", get_implicitconv_flag(n)); @@ -3498,8 +3492,6 @@ public: Append(getf->code, " (void)self;\n"); } if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "pyobj"); Replaceall(tm, "$result", "pyobj"); addfail = emit_action_code(n, getf->code, tm); Delete(tm); @@ -3579,8 +3571,6 @@ public: } if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", value); Printf(const_code, "%s,\n", tm); Delete(tm); @@ -3595,8 +3585,6 @@ public: } if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", value); if (needs_swigconstant(n) && !builtin && (shadow) && (!(shadow & PYSHADOW_MEMBER)) && (!in_class || !Getattr(n, "feature:python:callback"))) { // Generate `*_swigconstant()` method which registers the new constant. @@ -3608,7 +3596,7 @@ public: // class type (the SWIG_init() is called before shadow classes are // defined and registered). Printf(f_wrappers, "SWIGINTERN PyObject *%s_swigconstant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {\n", iname); - Printf(f_wrappers, tab2 "PyObject *module;\n", tm); + Printf(f_wrappers, tab2 "PyObject *module;\n"); Printf(f_wrappers, tab2 "PyObject *d;\n"); Printf(f_wrappers, tab2 "if (!SWIG_Python_UnpackTuple(args, \"swigconstant\", 1, 1, &module)) return NULL;\n"); Printf(f_wrappers, tab2 "d = PyModule_GetDict(module);\n"); @@ -4018,7 +4006,7 @@ public: if (GetFlag(mgetset, "static")) { Printf(f, "static PyGetSetDef %s_def = %s;\n", gspair, entry); Printf(f_init, "static_getset = SwigPyStaticVar_new_getset(metatype, &%s_def);\n", gspair); - Printf(f_init, "PyDict_SetItemString(d, static_getset->d_getset->name, (PyObject *) static_getset);\n", memname); + Printf(f_init, "PyDict_SetItemString(d, static_getset->d_getset->name, (PyObject *) static_getset);\n"); Printf(f_init, "Py_DECREF(static_getset);\n"); } else { Printf(getset_def, " %s,\n", entry); @@ -4467,7 +4455,9 @@ public: Printf(f_shadow, "(Exception)"); } else { Printf(f_shadow, "(object"); - Printf(f_shadow, py3 && GetFlag(n, "feature:python:nondynamic") ? ", metaclass=_SwigNonDynamicMeta" : "", ")"); + if (py3 && GetFlag(n, "feature:python:nondynamic")) { + Printf(f_shadow, ", metaclass=_SwigNonDynamicMeta"); + } Printf(f_shadow, ")"); } } @@ -4875,6 +4865,7 @@ public: String *classname = Swig_class_name(parent); String *rclassname = Swig_class_name(getCurrentClass()); assert(rclassname); + (void)rclassname; String *parms = make_pyParmList(n, true, false, allow_kwargs); /* Pass 'self' only if using director */ diff --git a/Source/Modules/r.cxx b/Source/Modules/r.cxx index 3e3c23e44..99db2275f 100644 --- a/Source/Modules/r.cxx +++ b/Source/Modules/r.cxx @@ -634,7 +634,6 @@ String * R::createFunctionPointerHandler(SwigType *t, Node *n, int *numArgs) { if(returnTM) { String *tm = returnTM; Replaceall(tm,"$input", "r_swig_cb_data->retValue"); - Replaceall(tm,"$target", Swig_cresult_name()); replaceRClass(tm, rettype); Replaceall(tm,"$owner", "0"); Replaceall(tm,"$disown","0"); @@ -1302,13 +1301,14 @@ void R::addAccessor(String *memberName, Wrapper *wrapper, String *name, #define MAX_OVERLOAD 256 +namespace { struct Overloaded { Node *n; /* Node */ int argc; /* Argument count */ ParmList *parms; /* Parameters used for overload check */ int error; /* Ambiguity error */ }; - +} List * R::Swig_overload_rank(Node *n, bool script_lang_wrapping) { @@ -1745,7 +1745,7 @@ int R::functionWrapper(Node *n) { /* Add the name of this member to a list for this class_name. We will dump all these at the end. */ - bool isSet(GetFlag(n, "memberset")); + bool isSet = GetFlag(n, "memberset") ? true : false; String *tmp = NewString(isSet ? Swig_name_set(NSPACE_TODO, class_name) : Swig_name_get(NSPACE_TODO, class_name)); @@ -1912,8 +1912,6 @@ int R::functionWrapper(Node *n) { if ((tm = Getattr(p,"tmap:scheck"))) { - Replaceall(tm,"$target", lname); - Replaceall(tm,"$source", name); Replaceall(tm,"$input", name); replaceRClass(tm, Getattr(p, "type")); Printf(sfun->code,"%s\n",tm); @@ -1924,8 +1922,6 @@ int R::functionWrapper(Node *n) { curP = p; if ((tm = Getattr(p,"tmap:in"))) { - Replaceall(tm,"$target", lname); - Replaceall(tm,"$source", name); Replaceall(tm,"$input", name); if (Getattr(p,"wrap:disown") || (Getattr(p,"tmap:in:disown"))) { @@ -1984,7 +1980,6 @@ int R::functionWrapper(Node *n) { String *cleanup = NewString(""); for (p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); if (tm && (Len(tm) != 0)) { Printv(cleanup, tm, "\n", NIL); } @@ -2001,7 +1996,6 @@ int R::functionWrapper(Node *n) { // String *lname = Getattr(p, "lname"); numOutArgs++; String *pos = NewStringf("%d", numOutArgs); - Replaceall(tm,"$source", Getattr(p, "lname")); Replaceall(tm,"$result", "r_ans"); Replaceall(tm,"$n", pos); // The position into which to store the answer. Replaceall(tm,"$arg", Getattr(p, "emit:input")); @@ -2076,14 +2070,12 @@ int R::functionWrapper(Node *n) { /* Look to see if there is any newfree cleanup code */ if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); /* deprecated */ Printf(f->code, "%s\n", tm); } } /* See if there is any return cleanup code */ if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); Delete(tm); } @@ -2092,7 +2084,6 @@ int R::functionWrapper(Node *n) { /*If the user gave us something to convert the result in */ if ((tm = Swig_typemap_lookup("scoerceout", n, Swig_cresult_name(), sfun))) { - Replaceall(tm,"$source","ans"); Replaceall(tm,"$result","ans"); if (constructor) { Node * parent = Getattr(n, "parentNode"); diff --git a/Source/Modules/ruby.cxx b/Source/Modules/ruby.cxx index 48b0efab3..ec4a75dbd 100644 --- a/Source/Modules/ruby.cxx +++ b/Source/Modules/ruby.cxx @@ -116,6 +116,7 @@ public: /* flags for the make_autodoc function */ +namespace { enum autodoc_t { AUTODOC_CLASS, AUTODOC_CTOR, @@ -127,6 +128,7 @@ enum autodoc_t { AUTODOC_SETTER, AUTODOC_NONE }; +} static const char *usage = "\ Ruby Options (available with -ruby)\n\ @@ -1425,16 +1427,14 @@ public: * applyInputTypemap() * * Look up the appropriate "in" typemap for this parameter (p), - * substitute the correct strings for the $target and $input typemap - * parameters, and dump the resulting code to the wrapper file. + * substitute the correct strings for the typemap parameters, and dump the + * resulting code to the wrapper file. * --------------------------------------------------------------------- */ - Parm *applyInputTypemap(Parm *p, String *ln, String *source, Wrapper *f, String *symname) { + Parm *applyInputTypemap(Parm *p, String *source, Wrapper *f, String *symname) { String *tm; SwigType *pt = Getattr(p, "type"); if ((tm = Getattr(p, "tmap:in"))) { - Replaceall(tm, "$target", ln); - Replaceall(tm, "$source", source); Replaceall(tm, "$input", source); Replaceall(tm, "$symname", symname); @@ -1474,10 +1474,8 @@ public: Parm *p; String *tm; String *source; - String *target; source = NewString(""); - target = NewString(""); bool ctor_director = (current == CONSTRUCTOR_INITIALIZE && Swig_directorclass(n)); @@ -1498,7 +1496,6 @@ public: p = skipIgnoredArgs(p); String *pn = Getattr(p, "name"); - String *ln = Getattr(p, "lname"); /* Produce string representation of source argument */ Clear(source); @@ -1510,10 +1507,6 @@ public: Printf(source, "argv[%d]", i - start); } - /* Produce string representation of target argument */ - Clear(target); - Printf(target, "%s", Char(ln)); - if (i >= (numreq)) { /* Check if parsing an optional argument */ Printf(f->code, " if (argc > %d) {\n", i - start); } @@ -1526,7 +1519,7 @@ public: } /* Look for an input typemap */ - p = applyInputTypemap(p, ln, source, f, Getattr(n, "name")); + p = applyInputTypemap(p, source, f, Getattr(n, "name")); if (i >= numreq) { Printf(f->code, "}\n"); } @@ -1553,7 +1546,6 @@ public: } Delete(source); - Delete(target); } /* --------------------------------------------------------------------- @@ -1569,7 +1561,6 @@ public: String *tm; for (p = l; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -1591,7 +1582,6 @@ public: for (Parm *p = l; p;) { if ((tm = Getattr(p, "tmap:freearg"))) { if (Len(tm) != 0) { - Replaceall(tm, "$source", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); } p = Getattr(p, "tmap:freearg:next"); @@ -1613,8 +1603,6 @@ public: String *tm; for (Parm *p = l; p;) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); - Replaceall(tm, "$target", "vresult"); Replaceall(tm, "$result", "vresult"); Replaceall(tm, "$arg", Getattr(p, "emit:input")); Replaceall(tm, "$input", Getattr(p, "emit:input")); @@ -1876,8 +1864,6 @@ public: actioncode = 0; if (tm) { Replaceall(tm, "$result", "vresult"); - Replaceall(tm, "$source", Swig_cresult_name()); - Replaceall(tm, "$target", "vresult"); if (GetFlag(n, "feature:new")) Replaceall(tm, "$owner", "SWIG_POINTER_OWN"); @@ -1975,7 +1961,6 @@ public: if (current != CONSTRUCTOR_ALLOCATE && GetFlag(n, "feature:new")) { tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0); if (tm) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, "\n", NIL); Delete(tm); } @@ -1984,7 +1969,6 @@ public: /* Special processing on return value. */ tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0); if (tm) { - Replaceall(tm, "$source", Swig_cresult_name()); Printv(f->code, tm, NIL); Delete(tm); } @@ -2214,8 +2198,6 @@ public: tm = Swig_typemap_lookup("varout", n, name, 0); if (tm) { Replaceall(tm, "$result", "_val"); - Replaceall(tm, "$target", "_val"); - Replaceall(tm, "$source", name); /* Printv(getf->code,tm, NIL); */ addfail = emit_action_code(n, getf->code, tm); } else { @@ -2250,8 +2232,6 @@ public: tm = Swig_typemap_lookup("varin", n, name, 0); if (tm) { Replaceall(tm, "$input", "_val"); - Replaceall(tm, "$source", "_val"); - Replaceall(tm, "$target", name); /* Printv(setf->code,tm,"\n",NIL); */ emit_action_code(n, setf->code, tm); } else { @@ -2363,8 +2343,6 @@ public: if (!tm) tm = Swig_typemap_lookup("constcode", n, value, 0); if (tm) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", iname); Replaceall(tm, "$symname", iname); Replaceall(tm, "$value", value); if (current == CLASS_CONST) { diff --git a/Source/Modules/s-exp.cxx b/Source/Modules/s-exp.cxx deleted file mode 100644 index fe3b1facc..000000000 --- a/Source/Modules/s-exp.cxx +++ /dev/null @@ -1,402 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * s-exp.cxx - * - * A parse tree represented as Lisp s-expressions. - * ----------------------------------------------------------------------------- */ - -#include "swigmod.h" -#include "dohint.h" - -static const char *usage = "\ -S-Exp Options (available with -sexp)\n\ - -typemaplang <lang> - Typemap language\n\n"; - -//static Node *view_top = 0; -static File *out = 0; - -class Sexp:public Language { - int indent_level; - DOHHash *print_circle_hash; - int print_circle_count; - int hanging_parens; - bool need_whitespace; - bool need_newline; - -public: - Sexp(): - indent_level(0), - print_circle_hash(0), - print_circle_count(0), - hanging_parens(0), - need_whitespace(0), - need_newline(0) { - } - - virtual ~ Sexp() { - } - - virtual void main(int argc, char *argv[]) { - // Add a symbol to the parser for conditional compilation - Preprocessor_define("SWIGSEXP 1", 0); - - SWIG_typemap_lang("sexp"); - for (int iX = 0; iX < argc; iX++) { - if (strcmp(argv[iX], "-typemaplang") == 0) { - Swig_mark_arg(iX); - iX++; - SWIG_typemap_lang(argv[iX]); - Swig_mark_arg(iX); - continue; - } - if (strcmp(argv[iX], "-help") == 0) { - fputs(usage, stdout); - } - } - } - - /* Top of the parse tree */ - virtual int top(Node *n) { - if (out == 0) { - String *outfile = Getattr(n, "outfile"); - Replaceall(outfile, "_wrap.cxx", ".lisp"); - Replaceall(outfile, "_wrap.c", ".lisp"); - out = NewFile(outfile, "w", SWIG_output_files()); - if (!out) { - FileErrorDisplay(outfile); - SWIG_exit(EXIT_FAILURE); - } - } - String *f_sink = NewString(""); - Swig_register_filebyname("header", f_sink); - Swig_register_filebyname("wrapper", f_sink); - Swig_register_filebyname("begin", f_sink); - Swig_register_filebyname("runtime", f_sink); - Swig_register_filebyname("init", f_sink); - - Swig_banner_target_lang(out, ";;;"); - - Language::top(n); - Printf(out, "\n"); - Printf(out, ";;; Lisp parse tree produced by SWIG\n"); - print_circle_hash = NewHash(); - print_circle_count = 0; - hanging_parens = 0; - need_whitespace = 0; - need_newline = 0; - Sexp_print_node(n); - flush_parens(); - return SWIG_OK; - } - - void print_indent() { - int i; - for (i = 0; i < indent_level; i++) { - Printf(out, " "); - } - } - - void open_paren(const String *oper) { - flush_parens(); - Printf(out, "("); - if (oper) - Printf(out, "%s ", oper); - indent_level += 2; - } - - void close_paren(bool neednewline = false) { - hanging_parens++; - if (neednewline) - print_lazy_whitespace(); - indent_level -= 2; - } - - void flush_parens() { - int i; - if (hanging_parens) { - for (i = 0; i < hanging_parens; i++) - Printf(out, ")"); - hanging_parens = 0; - need_newline = true; - need_whitespace = true; - } - if (need_newline) { - Printf(out, "\n"); - print_indent(); - need_newline = false; - need_whitespace = false; - } else if (need_whitespace) { - Printf(out, " "); - need_whitespace = false; - } - } - - void print_lazy_whitespace() { - need_whitespace = 1; - } - - void print_lazy_newline() { - need_newline = 1; - } - - bool internal_key_p(DOH *key) { - return ((Cmp(key, "nodeType") == 0) - || (Cmp(key, "firstChild") == 0) - || (Cmp(key, "lastChild") == 0) - || (Cmp(key, "parentNode") == 0) - || (Cmp(key, "nextSibling") == 0) - || (Cmp(key, "previousSibling") == 0) - || (Cmp(key, "csym:nextSibling") == 0) - || (Cmp(key, "csym:previousSibling") == 0) - || (Cmp(key, "typepass:visit") == 0) - || (Cmp(key, "allocate:visit") == 0) - || (*(Char(key)) == '$')); - } - - bool boolean_key_p(DOH *key) { - return ((Cmp(key, "allocate:default_constructor") == 0) - || (Cmp(key, "allocate:default_destructor") == 0) - || (Cmp(key, "allows_typedef") == 0) - || (Cmp(key, "feature:immutable") == 0)); - } - - bool list_key_p(DOH *key) { - return ((Cmp(key, "parms") == 0) - || (Cmp(key, "baselist") == 0)); - } - - bool plist_key_p(DOH *key) - // true if KEY is the name of data that is a mapping from keys to - // values, which should be printed as a plist. - { - return ((Cmp(key, "typescope") == 0)); - } - - bool maybe_plist_key_p(DOH *key) { - return (Strncmp(key, "tmap:", 5) == 0); - } - - bool print_circle(DOH *obj, bool list_p) - // We have a complex object, which might be referenced several - // times, or even recursively. Use Lisp's reader notation for - // circular structures (#n#, #n=). - // - // An object can be printed in list-mode or object-mode; LIST_P toggles. - // return TRUE if OBJ still needs to be printed - { - flush_parens(); - // Following is a silly hack. It works around the limitation of - // DOH's hash tables that only work with string keys! - char address[32]; - sprintf(address, "%p%c", obj, list_p ? 'L' : 'O'); - DOH *placeholder = Getattr(print_circle_hash, address); - if (placeholder) { - Printv(out, placeholder, NIL); - return false; - } else { - String *placeholder = NewStringf("#%d#", ++print_circle_count); - Setattr(print_circle_hash, address, placeholder); - Printf(out, "#%d=", print_circle_count); - return true; - } - } - - void Sexp_print_value_of_key(DOH *value, DOH *key) { - if ((Cmp(key, "parms") == 0) || (Cmp(key, "wrap:parms") == 0) - || (Cmp(key, "kwargs") == 0) || (Cmp(key, "pattern") == 0)) - Sexp_print_parms(value); - else if (plist_key_p(key)) - Sexp_print_plist(value); - else if (maybe_plist_key_p(key)) { - if (DohIsMapping(value)) - Sexp_print_plist(value); - else - Sexp_print_doh(value); - } else if (list_key_p(key)) - Sexp_print_list(value); - else if (boolean_key_p(key)) - Sexp_print_boolean(value); - else - Sexp_print_doh(value); - } - - void Sexp_print_boolean(DOH *obj) { - flush_parens(); - /* See DOH/Doh/base.c, DohGetInt() */ - if (DohIsString(obj)) { - if (atoi(Char(obj)) != 0) - Printf(out, "t"); - else - Printf(out, "nil"); - } else - Printf(out, "nil"); - } - - void Sexp_print_list(DOH *obj) { - if (print_circle(obj, true)) { - open_paren(NIL); - for (; obj; obj = nextSibling(obj)) { - Sexp_print_doh(obj); - print_lazy_whitespace(); - } - close_paren(true); - } - } - - void Sexp_print_parms(DOH *obj) { - // print it as a list of plists - if (print_circle(obj, true)) { - open_paren(NIL); - for (; obj; obj = nextSibling(obj)) { - if (DohIsMapping(obj)) { - Iterator k; - open_paren(NIL); - for (k = First(obj); k.key; k = Next(k)) { - if (!internal_key_p(k.key)) { - DOH *value = Getattr(obj, k.key); - Sexp_print_as_keyword(k.key); - Sexp_print_value_of_key(value, k.key); - print_lazy_whitespace(); - } - } - close_paren(true); - } else - Sexp_print_doh(obj); - print_lazy_whitespace(); - } - close_paren(true); - } - } - - void Sexp_print_doh(DOH *obj) { - flush_parens(); - if (DohIsString(obj)) { - String *o = Str(obj); - Replaceall(o, "\\", "\\\\"); - Replaceall(o, "\"", "\\\""); - Printf(out, "\"%s\"", o); - Delete(o); - } else { - if (print_circle(obj, false)) { - // Dispatch type - if (nodeType(obj)) { - Sexp_print_node(obj); - } - - else if (DohIsMapping(obj)) { - Iterator k; - open_paren(NIL); - for (k = First(obj); k.key; k = Next(k)) { - if (!internal_key_p(k.key)) { - DOH *value = Getattr(obj, k.key); - flush_parens(); - open_paren(NIL); - Sexp_print_doh(k.key); - Printf(out, " . "); - Sexp_print_value_of_key(value, k.key); - close_paren(); - } - } - close_paren(); - } else if (strcmp(ObjType(obj)->objname, "List") == 0) { - int i; - open_paren(NIL); - for (i = 0; i < Len(obj); i++) { - DOH *item = Getitem(obj, i); - Sexp_print_doh(item); - } - close_paren(); - } else { - // What is it? - Printf(out, "#<DOH %s %p>", ObjType(obj)->objname, obj); - } - } - } - } - - void Sexp_print_as_keyword(const DOH *k) { - /* Print key, replacing ":" with "-" because : is CL's package prefix */ - flush_parens(); - String *key = NewString(k); - Replaceall(key, ":", "-"); - Replaceall(key, "_", "-"); - Printf(out, ":%s ", key); - Delete(key); - } - - void Sexp_print_plist_noparens(DOH *obj) { - /* attributes map names to objects */ - Iterator k; - bool first; - for (k = First(obj), first = true; k.key; k = Next(k), first = false) { - if (!internal_key_p(k.key)) { - DOH *value = Getattr(obj, k.key); - flush_parens(); - if (!first) { - Printf(out, " "); - } - Sexp_print_as_keyword(k.key); - /* Print value */ - Sexp_print_value_of_key(value, k.key); - } - } - } - - void Sexp_print_plist(DOH *obj) { - flush_parens(); - if (print_circle(obj, true)) { - open_paren(NIL); - Sexp_print_plist_noparens(obj); - close_paren(); - } - } - - void Sexp_print_attributes(Node *obj) { - Sexp_print_plist_noparens(obj); - } - - void Sexp_print_node(Node *obj) { - Node *cobj; - open_paren(nodeType(obj)); - /* A node has an attribute list... */ - Sexp_print_attributes(obj); - /* ... and child nodes. */ - cobj = firstChild(obj); - if (cobj) { - print_lazy_newline(); - flush_parens(); - Sexp_print_as_keyword("children"); - open_paren(NIL); - for (; cobj; cobj = nextSibling(cobj)) { - Sexp_print_node(cobj); - } - close_paren(); - } - close_paren(); - } - - - virtual int functionWrapper(Node *n) { - ParmList *l = Getattr(n, "parms"); - Wrapper *f = NewWrapper(); - emit_attach_parmmaps(l, f); - Setattr(n, "wrap:parms", l); - DelWrapper(f); - return SWIG_OK; - } - -}; - - -static Language *new_swig_sexp() { - return new Sexp(); -} -extern "C" Language *swig_sexp(void) { - return new_swig_sexp(); -} diff --git a/Source/Modules/scilab.cxx b/Source/Modules/scilab.cxx index 23e45f787..697284a77 100644 --- a/Source/Modules/scilab.cxx +++ b/Source/Modules/scilab.cxx @@ -472,7 +472,6 @@ public: String *tm; if ((tm = Getattr(param, "tmap:freearg"))) { if (tm && (Len(tm) != 0)) { - Replaceall(tm, "$source", Getattr(param, "lname")); Printf(wrapper->code, "%s\n", tm); } param = Getattr(param, "tmap:freearg:next"); @@ -484,7 +483,6 @@ public: /* See if there is any return cleanup code */ String *tm; if ((tm = Swig_typemap_lookup("ret", node, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(wrapper->code, "%s\n", tm); Delete(tm); } diff --git a/Source/Modules/tcl8.cxx b/Source/Modules/tcl8.cxx index 7a78ede9b..fcf36d17d 100644 --- a/Source/Modules/tcl8.cxx +++ b/Source/Modules/tcl8.cxx @@ -336,8 +336,6 @@ public: if ((tm = Getattr(p, "tmap:in"))) { String *parse = Getattr(p, "tmap:in:parse"); if (!parse) { - Replaceall(tm, "$target", ln); - Replaceall(tm, "$source", source); Replaceall(tm, "$input", source); Setattr(p, "emit:input", source); @@ -401,7 +399,6 @@ public: /* Insert constraint checking code */ for (p = parms; p;) { if ((tm = Getattr(p, "tmap:check"))) { - Replaceall(tm, "$target", Getattr(p, "lname")); Printv(f->code, tm, "\n", NIL); p = Getattr(p, "tmap:check:next"); } else { @@ -414,7 +411,6 @@ public: if (!checkAttribute(p, "tmap:in:numinputs", "0") && !Getattr(p, "tmap:in:parse") && (tm = Getattr(p, "tmap:freearg"))) { if (Len(tm) != 0) { - Replaceall(tm, "$source", Getattr(p, "lname")); Printv(cleanup, tm, "\n", NIL); } p = Getattr(p, "tmap:freearg:next"); @@ -426,12 +422,9 @@ public: /* Insert argument output code */ for (i = 0, p = parms; p; i++) { if ((tm = Getattr(p, "tmap:argout"))) { - Replaceall(tm, "$source", Getattr(p, "lname")); #ifdef SWIG_USE_RESULTOBJ - Replaceall(tm, "$target", "resultobj"); Replaceall(tm, "$result", "resultobj"); #else - Replaceall(tm, "$target", "(Tcl_GetObjResult(interp))"); Replaceall(tm, "$result", "(Tcl_GetObjResult(interp))"); #endif Replaceall(tm, "$arg", Getattr(p, "emit:input")); @@ -450,12 +443,9 @@ public: /* Return value if necessary */ if ((tm = Swig_typemap_lookup_out("out", n, Swig_cresult_name(), f, actioncode))) { - Replaceall(tm, "$source", Swig_cresult_name()); #ifdef SWIG_USE_RESULTOBJ - Replaceall(tm, "$target", "resultobj"); Replaceall(tm, "$result", "resultobj"); #else - Replaceall(tm, "$target", "(Tcl_GetObjResult(interp))"); Replaceall(tm, "$result", "(Tcl_GetObjResult(interp))"); #endif if (GetFlag(n, "feature:new")) { @@ -478,13 +468,11 @@ public: /* Look for any remaining cleanup */ if (GetFlag(n, "feature:new")) { if ((tm = Swig_typemap_lookup("newfree", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } } if ((tm = Swig_typemap_lookup("ret", n, Swig_cresult_name(), 0))) { - Replaceall(tm, "$source", Swig_cresult_name()); Printf(f->code, "%s\n", tm); } #ifdef SWIG_USE_RESULTOBJ @@ -580,8 +568,6 @@ public: Printv(getf->def, "SWIGINTERN const char *", getfname, "(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, char *name1, char *name2, int flags) {", NIL); Wrapper_add_local(getf, "value", "Tcl_Obj *value = 0"); if ((tm = Swig_typemap_lookup("varout", n, name, 0))) { - Replaceall(tm, "$source", name); - Replaceall(tm, "$target", "value"); Replaceall(tm, "$result", "value"); /* Printf(getf->code, "%s\n",tm); */ addfail = emit_action_code(n, getf->code, tm); @@ -616,8 +602,6 @@ public: Wrapper_add_local(setf, "name1o", "Tcl_Obj *name1o = 0"); if ((tm = Swig_typemap_lookup("varin", n, name, 0))) { - Replaceall(tm, "$source", "value"); - Replaceall(tm, "$target", name); Replaceall(tm, "$input", "value"); Printf(setf->code, "name1o = Tcl_NewStringObj(name1,-1);\n"); Printf(setf->code, "value = Tcl_ObjGetVar2(interp, name1o, 0, flags);\n"); @@ -690,14 +674,10 @@ public: } if ((tm = Swig_typemap_lookup("consttab", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", value); Replaceall(tm, "$nsname", nsname); Printf(const_tab, "%s,\n", tm); } else if ((tm = Swig_typemap_lookup("constcode", n, name, 0))) { - Replaceall(tm, "$source", value); - Replaceall(tm, "$target", name); Replaceall(tm, "$value", value); Replaceall(tm, "$nsname", nsname); Printf(f_init, "%s\n", tm); diff --git a/Source/Modules/uffi.cxx b/Source/Modules/uffi.cxx deleted file mode 100644 index 10a53a561..000000000 --- a/Source/Modules/uffi.cxx +++ /dev/null @@ -1,405 +0,0 @@ -/* ----------------------------------------------------------------------------- - * This file is part of SWIG, which is licensed as a whole under version 3 - * (or any later version) of the GNU General Public License. Some additional - * terms also apply to certain portions of SWIG. The full details of the SWIG - * license and copyrights can be found in the LICENSE and COPYRIGHT files - * included with the SWIG source code as distributed by the SWIG developers - * and at http://www.swig.org/legal.html. - * - * uffi.cxx - * - * Uffi language module for SWIG. - * ----------------------------------------------------------------------------- */ - -// TODO: remove remnants of lisptype - -#include "swigmod.h" - -static const char *usage = "\ -UFFI Options (available with -uffi)\n\ - -identifier-converter <type or funcname> - \n\ - Specifies the type of conversion to do on C identifiers\n\ - to convert them to symbols. There are two built-in\n\ - converters: 'null' and 'lispify'. The default is\n\ - 'null'. If you supply a name other than one of the\n\ - built-ins, then a function by that name will be\n\ - called to convert identifiers to symbols.\n\ -"; - -class UFFI:public Language { -public: - - virtual void main(int argc, char *argv[]); - virtual int top(Node *n); - virtual int functionWrapper(Node *n); - virtual int constantWrapper(Node *n); - virtual int classHandler(Node *n); - virtual int membervariableHandler(Node *n); - -}; - -static File *f_cl = 0; - -static struct { - int count; - String **entries; -} defined_foreign_types; - -static String *identifier_converter = NewString("identifier-convert-null"); - -static int any_varargs(ParmList *pl) { - Parm *p; - - for (p = pl; p; p = nextSibling(p)) { - if (SwigType_isvarargs(Getattr(p, "type"))) - return 1; - } - - return 0; -} - - -/* utilities */ -/* returns new string w/ parens stripped */ -static String *strip_parens(String *string) { - char *s = Char(string), *p; - int len = Len(string); - String *res; - - if (len == 0 || s[0] != '(' || s[len - 1] != ')') { - return NewString(string); - } - - p = (char *) malloc(len - 2 + 1); - if (!p) { - Printf(stderr, "Malloc failed\n"); - SWIG_exit(EXIT_FAILURE); - } - - strncpy(p, s + 1, len - 1); - p[len - 2] = 0; /* null terminate */ - - res = NewString(p); - free(p); - - return res; -} - - -static String *convert_literal(String *num_param, String *type) { - String *num = strip_parens(num_param), *res; - char *s = Char(num); - - /* Make sure doubles use 'd' instead of 'e' */ - if (!Strcmp(type, "double")) { - String *updated = Copy(num); - if (Replace(updated, "e", "d", DOH_REPLACE_ANY) > 1) { - Printf(stderr, "Weird!! number %s looks invalid.\n", num); - SWIG_exit(EXIT_FAILURE); - } - Delete(num); - return updated; - } - - if (SwigType_type(type) == T_CHAR) { - /* Use CL syntax for character literals */ - return NewStringf("#\\%s", num_param); - } else if (SwigType_type(type) == T_STRING) { - /* Use CL syntax for string literals */ - return NewStringf("\"%s\"", num_param); - } - - if (Len(num) < 2 || s[0] != '0') { - return num; - } - - /* octal or hex */ - - res = NewStringf("#%c%s", s[1] == 'x' ? 'x' : 'o', s + 2); - Delete(num); - - return res; -} - -static void add_defined_foreign_type(String *type) { - if (!defined_foreign_types.count) { - /* Make fresh */ - defined_foreign_types.count = 1; - defined_foreign_types.entries = (String **) malloc(sizeof(String *)); - } else { - /* make room */ - defined_foreign_types.count++; - defined_foreign_types.entries = (String **) - realloc(defined_foreign_types.entries, defined_foreign_types.count * sizeof(String *)); - } - - if (!defined_foreign_types.entries) { - Printf(stderr, "Out of memory\n"); - SWIG_exit(EXIT_FAILURE); - } - - /* Fill in the new data */ - defined_foreign_types.entries[defined_foreign_types.count - 1] = Copy(type); - -} - - -static String *get_ffi_type(Node *n, SwigType *ty, const_String_or_char_ptr name) { - Node *node = NewHash(); - Setattr(node, "type", ty); - Setattr(node, "name", name); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup("ffitype", node, "", 0); - Delete(node); - - if (tm) { - return NewString(tm); - } else { - SwigType *tr = SwigType_typedef_resolve_all(ty); - char *type_reduced = Char(tr); - int i; - - //Printf(stdout,"convert_type %s\n", ty); - if (SwigType_isconst(tr)) { - SwigType_pop(tr); - type_reduced = Char(tr); - } - - if (SwigType_ispointer(type_reduced) || SwigType_isarray(ty) || !strncmp(type_reduced, "p.f", 3)) { - return NewString(":pointer-void"); - } - - for (i = 0; i < defined_foreign_types.count; i++) { - if (!Strcmp(ty, defined_foreign_types.entries[i])) { - return NewStringf("#.(%s \"%s\" :type :type)", identifier_converter, ty); - } - } - - if (!Strncmp(type_reduced, "enum ", 5)) { - return NewString(":int"); - } - - Printf(stderr, "Unsupported data type: %s (was: %s)\n", type_reduced, ty); - SWIG_exit(EXIT_FAILURE); - } - return 0; -} - -static String *get_lisp_type(Node *n, SwigType *ty, const_String_or_char_ptr name) { - Node *node = NewHash(); - Setattr(node, "type", ty); - Setattr(node, "name", name); - Setfile(node, Getfile(n)); - Setline(node, Getline(n)); - const String *tm = Swig_typemap_lookup("lisptype", node, "", 0); - Delete(node); - - return tm ? NewString(tm) : NewString(""); -} - -void UFFI::main(int argc, char *argv[]) { - int i; - - Preprocessor_define("SWIGUFFI 1", 0); - SWIG_library_directory("uffi"); - SWIG_config_file("uffi.swg"); - - - for (i = 1; i < argc; i++) { - if (!strcmp(argv[i], "-identifier-converter")) { - char *conv = argv[i + 1]; - - if (!conv) - Swig_arg_error(); - - Swig_mark_arg(i); - Swig_mark_arg(i + 1); - i++; - - /* check for built-ins */ - if (!strcmp(conv, "lispify")) { - Delete(identifier_converter); - identifier_converter = NewString("identifier-convert-lispify"); - } else if (!strcmp(conv, "null")) { - Delete(identifier_converter); - identifier_converter = NewString("identifier-convert-null"); - } else { - /* Must be user defined */ - Delete(identifier_converter); - identifier_converter = NewString(conv); - } - } - - if (!strcmp(argv[i], "-help")) { - Printf(stdout, "%s\n", usage); - } - } -} - -int UFFI::top(Node *n) { - String *module = Getattr(n, "name"); - String *output_filename = NewString(""); - File *f_null = NewString(""); - - Printf(output_filename, "%s%s.cl", SWIG_output_directory(), module); - - - f_cl = NewFile(output_filename, "w", SWIG_output_files()); - if (!f_cl) { - FileErrorDisplay(output_filename); - SWIG_exit(EXIT_FAILURE); - } - - Swig_register_filebyname("header", f_null); - Swig_register_filebyname("begin", f_null); - Swig_register_filebyname("runtime", f_null); - Swig_register_filebyname("wrapper", f_cl); - - Swig_banner_target_lang(f_cl, ";;"); - - Printf(f_cl, "\n" - ";; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; Base: 10; package: %s -*-\n\n(defpackage :%s\n (:use :common-lisp :uffi))\n\n(in-package :%s)\n", - module, module, module); - Printf(f_cl, "(eval-when (compile load eval)\n (defparameter *swig-identifier-converter* '%s))\n", identifier_converter); - - Language::top(n); - - Delete(f_cl); // Delete the handle, not the file - Delete(f_null); - - return SWIG_OK; -} - -int UFFI::functionWrapper(Node *n) { - String *funcname = Getattr(n, "sym:name"); - ParmList *pl = Getattr(n, "parms"); - Parm *p; - int argnum = 0, first = 1; -// int varargs = 0; - - //Language::functionWrapper(n); - - Printf(f_cl, "(swig-defun \"%s\"\n", funcname); - Printf(f_cl, " ("); - - /* Special cases */ - - if (ParmList_len(pl) == 0) { - Printf(f_cl, ":void"); - } else if (any_varargs(pl)) { - Printf(f_cl, "#| varargs |#"); -// varargs = 1; - } else { - for (p = pl; p; p = nextSibling(p), argnum++) { - String *argname = Getattr(p, "name"); - SwigType *argtype = Getattr(p, "type"); - String *ffitype = get_ffi_type(n, argtype, argname); - String *lisptype = get_lisp_type(n, argtype, argname); - int tempargname = 0; - - if (!argname) { - argname = NewStringf("arg%d", argnum); - tempargname = 1; - } - - if (!first) { - Printf(f_cl, "\n "); - } - Printf(f_cl, "(%s %s %s)", argname, ffitype, lisptype); - first = 0; - - Delete(ffitype); - Delete(lisptype); - if (tempargname) - Delete(argname); - - } - } - Printf(f_cl, ")\n"); /* finish arg list */ - Printf(f_cl, " :returning %s\n" - //" :strings-convert t\n" - //" :call-direct %s\n" - //" :optimize-for-space t" - ")\n", get_ffi_type(n, Getattr(n, "type"), Swig_cresult_name()) - //,varargs ? "nil" : "t" - ); - - - return SWIG_OK; -} - -int UFFI::constantWrapper(Node *n) { - String *type = Getattr(n, "type"); - String *converted_value = convert_literal(Getattr(n, "value"), type); - String *name = Getattr(n, "sym:name"); - -#if 0 - Printf(stdout, "constant %s is of type %s. value: %s\n", name, type, converted_value); -#endif - - Printf(f_cl, "(swig-defconstant \"%s\" %s)\n", name, converted_value); - - Delete(converted_value); - - return SWIG_OK; -} - -// Includes structs -int UFFI::classHandler(Node *n) { - - String *name = Getattr(n, "sym:name"); - String *kind = Getattr(n, "kind"); - Node *c; - - if (Strcmp(kind, "struct")) { - Printf(stderr, "Don't know how to deal with %s kind of class yet.\n", kind); - Printf(stderr, " (name: %s)\n", name); - SWIG_exit(EXIT_FAILURE); - } - - Printf(f_cl, "(swig-def-struct \"%s\"\n \n", name); - - for (c = firstChild(n); c; c = nextSibling(c)) { - SwigType *type = Getattr(c, "type"); - SwigType *decl = Getattr(c, "decl"); - if (type) { - type = Copy(type); - SwigType_push(type, decl); - String *lisp_type; - - if (Strcmp(nodeType(c), "cdecl")) { - Printf(stderr, "Structure %s has a slot that we can't deal with.\n", name); - Printf(stderr, "nodeType: %s, name: %s, type: %s\n", nodeType(c), Getattr(c, "name"), Getattr(c, "type")); - SWIG_exit(EXIT_FAILURE); - } - - /* Printf(stdout, "Converting %s in %s\n", type, name); */ - lisp_type = get_ffi_type(n, type, Getattr(c, "sym:name")); - - Printf(f_cl, " (#.(%s \"%s\" :type :slot) %s)\n", identifier_converter, Getattr(c, "sym:name"), lisp_type); - - Delete(lisp_type); - } - } - - // Language::classHandler(n); - - Printf(f_cl, " )\n"); - - /* Add this structure to the known lisp types */ - //Printf(stdout, "Adding %s foreign type\n", name); - add_defined_foreign_type(name); - - return SWIG_OK; -} - -int UFFI::membervariableHandler(Node *n) { - Language::membervariableHandler(n); - return SWIG_OK; -} - - -extern "C" Language *swig_uffi(void) { - return new UFFI(); -} diff --git a/Source/Preprocessor/cpp.c b/Source/Preprocessor/cpp.c index 557b5482b..75bec61fd 100644 --- a/Source/Preprocessor/cpp.c +++ b/Source/Preprocessor/cpp.c @@ -113,7 +113,7 @@ static int is_digits(const String *str) { const char *s = Char(str); int isdigits = (*s != 0); while (*s) { - if (!isdigit(*s)) { + if (!isdigit((int)*s)) { isdigits = 0; break; } diff --git a/Source/README b/Source/README index 814ec45bd..088933308 100644 --- a/Source/README +++ b/Source/README @@ -13,13 +13,3 @@ SWIG Source directory Source/Modules - Language modules. Source/Include - Include files. - -Historic directories which may be in CVS, but have been removed: - - Source/Modules1.1 - Old SWIG-1.1 modules. Empty. - - Source/LParse - Experimental parser. Officially dead - as CParse is more capable. - - Source/SWIG1.1 - Old SWIG1.1 core. Completely empty now. - diff --git a/Source/Swig/cwrap.c b/Source/Swig/cwrap.c index d6e5e0cdc..7bf6641c8 100644 --- a/Source/Swig/cwrap.c +++ b/Source/Swig/cwrap.c @@ -632,7 +632,7 @@ String *Swig_cppconstructor_director_call(const_String_or_char_ptr name, ParmLis * If you define SWIG_FAST_REC_SEARCH, the method will set the found * 'attr' in the target class 'n'. If not, the method will set the * 'noattr' one. This prevents of having to navigate the entire - * hierarchy tree everytime, so, it is an O(1) method... or something + * hierarchy tree every time, so, it is an O(1) method... or something * like that. However, it populates all the parsed classes with the * 'attr' and/or 'noattr' attributes. * diff --git a/Source/Swig/fragment.c b/Source/Swig/fragment.c index 5b30e86e0..4ec26f955 100644 --- a/Source/Swig/fragment.c +++ b/Source/Swig/fragment.c @@ -29,7 +29,7 @@ static int debug = 0; * Swig_fragment_register() * * Add a fragment. Use the original Node*, so, if something needs to be - * changed, lang.cxx doesn't nedd to be touched again. + * changed, lang.cxx doesn't need to be touched again. * ----------------------------------------------------------------------------- */ void Swig_fragment_register(Node *fragment) { diff --git a/Source/Swig/naming.c b/Source/Swig/naming.c index 1d78e7a47..871a9e5bb 100644 --- a/Source/Swig/naming.c +++ b/Source/Swig/naming.c @@ -1514,7 +1514,7 @@ String *Swig_name_make(Node *n, String *prefix, const_String_or_char_ptr cname, if (n) { /* Parameter renaming is not fully implemented. Mainly because there is no C/C++ syntax to * for %rename to fully qualify a function's parameter name from outside the function. Hence it - * is not possible to implemented targetted warning suppression on one parameter in one function. */ + * is not possible to implemented targeted warning suppression on one parameter in one function. */ int suppress_parameter_rename_warning = Equal(nodeType(n), "parm"); if (!suppress_parameter_rename_warning) { SWIG_WARN_NODE_BEGIN(n); diff --git a/Source/Swig/stype.c b/Source/Swig/stype.c index fbf02bb1f..5f876ff04 100644 --- a/Source/Swig/stype.c +++ b/Source/Swig/stype.c @@ -1291,11 +1291,29 @@ void SwigType_typename_replace(SwigType *t, String *pat, String *rep) { Replace(e, pat, rep, DOH_REPLACE_ANY); } else if (SwigType_istemplate(e)) { /* Replaces a type of the form 'pat<args>' with 'rep' */ - if (Equal(e, pat)) { - String *repbase = SwigType_templateprefix(rep); - Replace(e, pat, repbase, DOH_REPLACE_ID | DOH_REPLACE_FIRST); - Delete(repbase); + { + /* To match "e=TemplateTemplateT<(float)>" + * with "pat=TemplateTemplateT" + * we need to compare only the first part of the string e. + */ + int len = Len(pat); + + /* Len(e) > len, not >= (because we expect at least a + * character '<' following the template typename) + */ + if (Len(e) > len) { + String *firstPartOfType = NewStringWithSize(e, len); + const char* e_as_char = Char(e); + + if (Equal(firstPartOfType, pat) && e_as_char[len] == '<') { + String *repbase = SwigType_templateprefix(rep); + Replace(e, pat, repbase, DOH_REPLACE_ID | DOH_REPLACE_FIRST); + Delete(repbase); + } + Delete(firstPartOfType); + } } + { String *tsuffix; List *tparms = SwigType_parmlist(e); diff --git a/Source/Swig/typeobj.c b/Source/Swig/typeobj.c index 69fb6662b..9944a9eeb 100644 --- a/Source/Swig/typeobj.c +++ b/Source/Swig/typeobj.c @@ -404,6 +404,7 @@ SwigType *SwigType_del_reference(SwigType *t) { char *c = Char(t); int check = strncmp(c, "r.", 2); assert(check == 0); + (void)check; Delslice(t, 0, 2); return t; } @@ -439,6 +440,7 @@ SwigType *SwigType_del_rvalue_reference(SwigType *t) { char *c = Char(t); int check = strncmp(c, "z.", 2); assert(check == 0); + (void)check; Delslice(t, 0, 2); return t; } @@ -529,6 +531,7 @@ SwigType *SwigType_del_qualifier(SwigType *t) { char *c = Char(t); int check = strncmp(c, "q(", 2); assert(check == 0); + (void)check; Delslice(t, 0, element_size(c)); return t; } @@ -597,6 +600,7 @@ SwigType *SwigType_del_memberpointer(SwigType *t) { char *c = Char(t); int check = strncmp(c, "m(", 2); assert(check == 0); + (void)check; Delslice(t, 0, element_size(c)); return t; } @@ -641,6 +645,7 @@ SwigType *SwigType_del_array(SwigType *t) { char *c = Char(t); int check = strncmp(c, "a(", 2); assert(check == 0); + (void)check; Delslice(t, 0, element_size(c)); return t; } diff --git a/Tools/CI-linux-environment.sh b/Tools/CI-linux-environment.sh new file mode 100644 index 000000000..0e9526dcf --- /dev/null +++ b/Tools/CI-linux-environment.sh @@ -0,0 +1,39 @@ +#!/bin/bash +# Expected to be called from elsewhere with same variables set as CI-linux-install.sh +# e.g. RETRY=travis-retry SWIGLANG=python +# Sets up environment for using various target languages +# For Github Actions where the environment is not preserved between steps +set -e # exit on failure (same as -o errexit) + +case "$SWIGLANG" in + "go") + if [[ "$VER" ]]; then + eval "$($HOME/bin/gimme ${VER}.x)" + $HOME/bin/gimme --list + fi + ;; + "javascript") + case "$ENGINE" in + "node") + export NVM_DIR="$HOME/.nvm" + [ -s "$NVM_DIR/nvm.sh" ] && source "$NVM_DIR/nvm.sh" + nvm use ${VER} + ;; + *) ;; + esac + ;; + "ruby") + if ! command -v rvm; then + set +x + source $HOME/.rvm/scripts/rvm + set -x + fi + ;; + "scilab") + # Travis has the wrong version of Java pre-installed resulting in error using scilab: + # /usr/bin/scilab-bin: error while loading shared libraries: libjava.so: cannot open shared object file: No such file or directory + echo "JAVA_HOME was set to $JAVA_HOME" + unset JAVA_HOME + ;; + *) ;; +esac diff --git a/Tools/CI-linux-install.sh b/Tools/CI-linux-install.sh new file mode 100644 index 000000000..7bd141080 --- /dev/null +++ b/Tools/CI-linux-install.sh @@ -0,0 +1,145 @@ +#!/bin/bash +# Expected to be called from elsewhere with certain variables set +# e.g. RETRY=travis-retry SWIGLANG=python GCC=7 +set -e # exit on failure (same as -o errexit) + +if [[ -n "$GCC" ]]; then + $RETRY sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test + $RETRY sudo apt-get -qq update + $RETRY sudo apt-get install -qq g++-$GCC +else + $RETRY sudo apt-get -qq update +fi + +$RETRY sudo apt-get -qq install libboost-dev libpcre3-dev +# testflags.py needs python +$RETRY sudo apt-get install -qq python + +WITHLANG=$SWIGLANG + +case "$SWIGLANG" in + "") ;; + "csharp") + $RETRY sudo apt-get -qq install mono-devel + ;; + "d") + $RETRY wget http://downloads.dlang.org/releases/2.x/${VER}/dmd_${VER}-0_amd64.deb + $RETRY sudo dpkg -i dmd_${VER}-0_amd64.deb + ;; + "go") + if [[ "$VER" ]]; then + mkdir -p $HOME/bin + curl -sL -o $HOME/bin/gimme https://raw.githubusercontent.com/travis-ci/gimme/master/gimme + chmod +x $HOME/bin/gimme + eval "$($HOME/bin/gimme ${VER}.x)" + $HOME/bin/gimme --list + fi + ;; + "javascript") + case "$ENGINE" in + "node") + $RETRY wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.33.10/install.sh | bash + export NVM_DIR="$HOME/.nvm" + [ -s "$NVM_DIR/nvm.sh" ] && source "$NVM_DIR/nvm.sh" + $RETRY nvm install ${VER} + nvm use ${VER} + if [ "$VER" == "0.10" ] || [ "$VER" == "0.12" ] || [ "$VER" == "4" ] || [ "$VER" == "6" ] ; then +# $RETRY sudo apt-get install -qq nodejs node-gyp + $RETRY npm install -g node-gyp@$VER + elif [ "$VER" == "8" ] ; then + $RETRY npm install -g node-gyp@6 + elif [ "$VER" == "10" ] || [ "$VER" == "12" ] || [ "$VER" == "14" ] || [ "$VER" == "16" ]; then + $RETRY npm install -g node-gyp@7 + else + $RETRY npm install -g node-gyp + fi + ;; + "jsc") + $RETRY sudo apt-get install -qq libjavascriptcoregtk-4.0-dev + ;; + "v8") + $RETRY sudo apt-get install -qq libv8-dev + ;; + esac + ;; + "guile") + $RETRY sudo apt-get -qq install guile-2.0-dev + ;; + "lua") + if [[ -z "$VER" ]]; then + $RETRY sudo apt-get -qq install lua5.2 liblua5.2-dev + else + $RETRY sudo apt-get -qq install lua${VER} liblua${VER}-dev + fi + ;; + "mzscheme") + $RETRY sudo apt-get -qq install racket + ;; + "ocaml") + $RETRY sudo apt-get -qq install ocaml camlp4 + ;; + "octave") + $RETRY sudo apt-get -qq update + $RETRY sudo apt-get -qq install liboctave-dev + ;; + "php") + if [[ "$VER" ]]; then + $RETRY sudo apt-get -qq remove "php*-cli" "php*-dev" # Multiple versions are pre-installed + $RETRY sudo add-apt-repository -y ppa:ondrej/php + $RETRY sudo apt-get -qq update + $RETRY sudo apt-get -qq install php$VER-cli php$VER-dev + fi + ;; + "python") + pip install --user pycodestyle + if [[ "$VER" ]]; then + $RETRY sudo add-apt-repository -y ppa:deadsnakes/ppa + $RETRY sudo apt-get -qq update + $RETRY sudo apt-get -qq install python${VER}-dev + WITHLANG=$SWIGLANG$PY3=$SWIGLANG$VER + else + $RETRY sudo apt-get install -qq python${PY3}-dev + WITHLANG=$SWIGLANG$PY3 + fi + ;; + "r") + $RETRY sudo apt-get -qq install r-base + ;; + "ruby") + if ! command -v rvm; then + case "$VER" in + 1.9 | 2.0 | 2.1 | 2.2 | 2.3 ) + $RETRY sudo apt-get -qq install libgdbm-dev libncurses5-dev libyaml-dev libssl1.0-dev + ;; + esac + # YOLO + curl -sSL https://rvm.io/mpapis.asc | gpg --import - + curl -sSL https://rvm.io/pkuczynski.asc | gpg --import - + curl -sSL https://get.rvm.io | bash -s stable + set +x + source $HOME/.rvm/scripts/rvm + set -x + fi + if [[ "$VER" == "2.7" || "$VER" == "3.0" ]]; then + # Ruby 2.7+ support is currently only rvm master (30 Dec 2019) + $RETRY rvm get master + rvm reload + rvm list known + fi + if [[ "$VER" ]]; then + $RETRY rvm install $VER + fi + ;; + "scilab") + # Travis has the wrong version of Java pre-installed resulting in error using scilab: + # /usr/bin/scilab-bin: error while loading shared libraries: libjava.so: cannot open shared object file: No such file or directory + echo "JAVA_HOME was set to $JAVA_HOME" + unset JAVA_HOME + $RETRY sudo apt-get -qq install scilab + ;; + "tcl") + $RETRY sudo apt-get -qq install tcl-dev + ;; +esac + +set +e # turn off exit on failure (same as +o errexit) diff --git a/Tools/GHA-linux-install.sh b/Tools/GHA-linux-install.sh new file mode 100644 index 000000000..ea2108fce --- /dev/null +++ b/Tools/GHA-linux-install.sh @@ -0,0 +1,9 @@ +#!/bin/bash + +#lsb_release -a +# find location of current script (only works in bash) +script_dir="$( dirname "${BASH_SOURCE[0]}")" + +# run generic script +RETRY= +source "$script_dir"/CI-linux-install.sh diff --git a/Tools/check-include-path.pike b/Tools/check-include-path.pike deleted file mode 100644 index 2bfb2b901..000000000 --- a/Tools/check-include-path.pike +++ /dev/null @@ -1,20 +0,0 @@ -/** - * This is a helper script to identify the proper include path - * for Pike header files. It should be run with the full path - * to the Pike executable as its single argument, e.g. - * - * pike check-include-path.pike /usr/local/bin/pike - * - * and its output should be the correct path to the header - * files, e.g. - * - * /usr/local/pike/7.2.239/include/pike - * - */ - -int main(int argc, array(string) argv) -{ - string prefix = replace(argv[1], "/bin/pike", ""); - write(prefix + "/pike/" + __MAJOR__ + "." + __MINOR__ + "." + __BUILD__ + "/include/pike"); - return 0; -} diff --git a/Tools/config/ac_compile_warnings.m4 b/Tools/config/ac_compile_warnings.m4 index 7e4239a3c..04f146387 100644 --- a/Tools/config/ac_compile_warnings.m4 +++ b/Tools/config/ac_compile_warnings.m4 @@ -34,7 +34,7 @@ AC_MSG_CHECKING([maximum warning verbosity option]) then if test "$GXX" = "yes" then - ac_compile_warnings_opt='-Wall -W -ansi -pedantic' + ac_compile_warnings_opt='-Wall -W -pedantic' fi CXXFLAGS="$CXXFLAGS $ac_compile_warnings_opt" ac_compile_warnings_msg="$ac_compile_warnings_opt for C++" @@ -44,7 +44,7 @@ AC_MSG_CHECKING([maximum warning verbosity option]) then if test "$GCC" = "yes" then - ac_compile_warnings_opt='-Wall -W -ansi -pedantic' + ac_compile_warnings_opt='-Wall -W -pedantic' fi CFLAGS="$CFLAGS $ac_compile_warnings_opt" ac_compile_warnings_msg="$ac_compile_warnings_msg $ac_compile_warnings_opt for C" diff --git a/Tools/config/ax_boost_base.m4 b/Tools/config/ax_boost_base.m4 index f5a935cd6..94fb2a0d4 100644 --- a/Tools/config/ax_boost_base.m4 +++ b/Tools/config/ax_boost_base.m4 @@ -10,7 +10,7 @@ # # Test for the Boost C++ libraries of a particular version (or newer) # -# If no path to the installed boost library is given the macro searchs +# If no path to the installed boost library is given the macro searches # under /usr, /usr/local, /opt and /opt/local and evaluates the # $BOOST_ROOT environment variable. Further documentation is available at # <http://randspringer.de/boost/index.html>. diff --git a/Tools/config/ax_cxx_compile_stdcxx_11.m4 b/Tools/config/ax_cxx_compile_stdcxx_11.m4 deleted file mode 100644 index 138ca2aca..000000000 --- a/Tools/config/ax_cxx_compile_stdcxx_11.m4 +++ /dev/null @@ -1,121 +0,0 @@ -# ============================================================================ -# http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html -# ============================================================================ -# -# SYNOPSIS -# -# AX_CXX_COMPILE_STDCXX_11([ext|noext], [nostop]) -# -# DESCRIPTION -# -# Check for baseline language coverage in the compiler for the C++11 -# standard; if necessary, add switches to CXXFLAGS to enable support. -# CXX11FLAGS will also contain any necessary switches to enable support. -# HAVE_CXX11_COMPILER will additionally be set to yes if there is support. -# If the second argument is not specified, errors out if no mode that -# supports C++11 baseline syntax can be found. The first argument, if -# specified, indicates whether you insist on an extended mode -# (e.g. -std=gnu++11) or a strict conformance mode (e.g. -std=c++11). -# If neither is specified, you get whatever works, with preference for an -# extended mode. -# -# LICENSE -# -# Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com> -# Copyright (c) 2012 Zack Weinberg <zackw@panix.com> -# Copyright (c) 2012 William Fulton <wsf@fultondesigns.co.uk> -# -# Copying and distribution of this file, with or without modification, are -# permitted in any medium without royalty provided the copyright notice -# and this notice are preserved. This file is offered as-is, without any -# warranty. - -#serial 1 - -m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [ - template <typename T> - struct check - { - static_assert(sizeof(int) <= sizeof(T), "not big enough"); - }; - - typedef check<check<bool>> right_angle_brackets; - - int a; - decltype(a) b; - - typedef check<int> check_type; - check_type c; - check_type&& cr = static_cast<check_type&&>(c); -]) - -AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl - m4_if([$1], [], [], - [$1], [ext], [], - [$1], [noext], [], - [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl - m4_if([$2], [], [], - [$2], [nostop], [], - [m4_fatal([invalid argument `$2' to AX_CXX_COMPILE_STDCXX_11])])dnl - AC_LANG_ASSERT([C++])dnl - ac_success=no - CXX11FLAGS= - AC_CACHE_CHECK(whether $CXX supports C++11 features by default, - ax_cv_cxx_compile_cxx11, - [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])], - [ax_cv_cxx_compile_cxx11=yes], - [ax_cv_cxx_compile_cxx11=no])]) - if test x$ax_cv_cxx_compile_cxx11 = xyes; then - ac_success=yes - fi - - m4_if([$1], [noext], [], [dnl - if test x$ac_success = xno; then - for switch in -std=gnu++11 -std=gnu++0x; do - cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch]) - AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch, - $cachevar, - [ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS $switch" - AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])], - [eval $cachevar=yes], - [eval $cachevar=no]) - CXXFLAGS="$ac_save_CXXFLAGS"]) - if eval test x\$$cachevar = xyes; then - CXXFLAGS="$CXXFLAGS $switch" - CXX11FLAGS=$switch - ac_success=yes - break - fi - done - fi]) - - m4_if([$1], [ext], [], [dnl - if test x$ac_success = xno; then - for switch in -std=c++11 -std=c++0x; do - cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch]) - AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch, - $cachevar, - [ac_save_CXXFLAGS="$CXXFLAGS" - CXXFLAGS="$CXXFLAGS $switch" - AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])], - [eval $cachevar=yes], - [eval $cachevar=no]) - CXXFLAGS="$ac_save_CXXFLAGS"]) - if eval test x\$$cachevar = xyes; then - CXXFLAGS="$CXXFLAGS $switch" - CXX11FLAGS=$switch - ac_success=yes - break - fi - done - fi]) - - if test x$ac_success = xno; then - if test x$2 != xnostop; then - AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.]) - fi - else - HAVE_CXX11_COMPILER=yes - fi -]) diff --git a/Tools/config/m4_ax_cxx_compile_stdcxx.m4 b/Tools/config/m4_ax_cxx_compile_stdcxx.m4 new file mode 100644 index 000000000..9413da624 --- /dev/null +++ b/Tools/config/m4_ax_cxx_compile_stdcxx.m4 @@ -0,0 +1,962 @@ +# =========================================================================== +# https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html +# =========================================================================== +# +# SYNOPSIS +# +# AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional]) +# +# DESCRIPTION +# +# Check for baseline language coverage in the compiler for the specified +# version of the C++ standard. If necessary, add switches to CXX and +# CXXCPP to enable support. VERSION may be '11' (for the C++11 standard) +# or '14' (for the C++14 standard). +# +# The second argument, if specified, indicates whether you insist on an +# extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g. +# -std=c++11). If neither is specified, you get whatever works, with +# preference for no added switch, and then for an extended mode. +# +# The third argument, if specified 'mandatory' or if left unspecified, +# indicates that baseline support for the specified C++ standard is +# required and that the macro should error out if no mode with that +# support is found. If specified 'optional', then configuration proceeds +# regardless, after defining HAVE_CXX${VERSION} if and only if a +# supporting mode is found. +# +# LICENSE +# +# Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com> +# Copyright (c) 2012 Zack Weinberg <zackw@panix.com> +# Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu> +# Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com> +# Copyright (c) 2015 Paul Norman <penorman@mac.com> +# Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu> +# Copyright (c) 2016, 2018 Krzesimir Nowak <qdlacz@gmail.com> +# Copyright (c) 2019 Enji Cooper <yaneurabeya@gmail.com> +# Copyright (c) 2020 Jason Merrill <jason@redhat.com> +# +# Copying and distribution of this file, with or without modification, are +# permitted in any medium without royalty provided the copyright notice +# and this notice are preserved. This file is offered as-is, without any +# warranty. + +#serial 12 + +dnl This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro +dnl (serial version number 13). + +AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl + m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"], + [$1], [14], [ax_cxx_compile_alternatives="14 1y"], + [$1], [17], [ax_cxx_compile_alternatives="17 1z"], + [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$2], [], [], + [$2], [ext], [], + [$2], [noext], [], + [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl + m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true], + [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true], + [$3], [optional], [ax_cxx_compile_cxx$1_required=false], + [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])]) + AC_LANG_PUSH([C++])dnl + ac_success=no + + m4_if([$2], [], [dnl + AC_CACHE_CHECK(whether $CXX supports C++$1 features by default, + ax_cv_cxx_compile_cxx$1, + [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [ax_cv_cxx_compile_cxx$1=yes], + [ax_cv_cxx_compile_cxx$1=no])]) + if test x$ax_cv_cxx_compile_cxx$1 = xyes; then + ac_success=yes + fi]) + + m4_if([$2], [noext], [], [dnl + if test x$ac_success = xno; then + for alternative in ${ax_cxx_compile_alternatives}; do + switch="-std=gnu++${alternative}" + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + fi]) + + m4_if([$2], [ext], [], [dnl + if test x$ac_success = xno; then + dnl HP's aCC needs +std=c++11 according to: + dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf + dnl Cray's crayCC needs "-h std=c++11" + for alternative in ${ax_cxx_compile_alternatives}; do + for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do + cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch]) + AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch, + $cachevar, + [ac_save_CXX="$CXX" + CXX="$CXX $switch" + AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])], + [eval $cachevar=yes], + [eval $cachevar=no]) + CXX="$ac_save_CXX"]) + if eval test x\$$cachevar = xyes; then + CXX="$CXX $switch" + if test -n "$CXXCPP" ; then + CXXCPP="$CXXCPP $switch" + fi + ac_success=yes + break + fi + done + if test x$ac_success = xyes; then + break + fi + done + fi]) + AC_LANG_POP([C++]) + if test x$ax_cxx_compile_cxx$1_required = xtrue; then + if test x$ac_success = xno; then + AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.]) + fi + fi + if test x$ac_success = xno; then + HAVE_CXX$1=0 + AC_MSG_NOTICE([No compiler with C++$1 support was found]) + else + HAVE_CXX$1=1 + AC_DEFINE(HAVE_CXX$1,1, + [define if the compiler supports basic C++$1 syntax]) + fi + AC_SUBST(HAVE_CXX$1) +]) + + +dnl Test body for checking C++11 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 +) + + +dnl Test body for checking C++14 support + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 +) + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17], + _AX_CXX_COMPILE_STDCXX_testbody_new_in_11 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_14 + _AX_CXX_COMPILE_STDCXX_testbody_new_in_17 +) + +dnl Tests for new features in C++11 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[ + +// If the compiler admits that it is not ready for C++11, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201103L + +#error "This is not a C++11 compiler" + +#else + +namespace cxx11 +{ + + namespace test_static_assert + { + + template <typename T> + struct check + { + static_assert(sizeof(int) <= sizeof(T), "not big enough"); + }; + + } + + namespace test_final_override + { + + struct Base + { + virtual ~Base() {} + virtual void f() {} + }; + + struct Derived : public Base + { + virtual ~Derived() override {} + virtual void f() override {} + }; + + } + + namespace test_double_right_angle_brackets + { + + template < typename T > + struct check {}; + + typedef check<void> single_type; + typedef check<check<void>> double_type; + typedef check<check<check<void>>> triple_type; + typedef check<check<check<check<void>>>> quadruple_type; + + } + + namespace test_decltype + { + + int + f() + { + int a = 1; + decltype(a) b = 2; + return a + b; + } + + } + + namespace test_type_deduction + { + + template < typename T1, typename T2 > + struct is_same + { + static const bool value = false; + }; + + template < typename T > + struct is_same<T, T> + { + static const bool value = true; + }; + + template < typename T1, typename T2 > + auto + add(T1 a1, T2 a2) -> decltype(a1 + a2) + { + return a1 + a2; + } + + int + test(const int c, volatile int v) + { + static_assert(is_same<int, decltype(0)>::value == true, ""); + static_assert(is_same<int, decltype(c)>::value == false, ""); + static_assert(is_same<int, decltype(v)>::value == false, ""); + auto ac = c; + auto av = v; + auto sumi = ac + av + 'x'; + auto sumf = ac + av + 1.0; + static_assert(is_same<int, decltype(ac)>::value == true, ""); + static_assert(is_same<int, decltype(av)>::value == true, ""); + static_assert(is_same<int, decltype(sumi)>::value == true, ""); + static_assert(is_same<int, decltype(sumf)>::value == false, ""); + static_assert(is_same<int, decltype(add(c, v))>::value == true, ""); + return (sumf > 0.0) ? sumi : add(c, v); + } + + } + + namespace test_noexcept + { + + int f() { return 0; } + int g() noexcept { return 0; } + + static_assert(noexcept(f()) == false, ""); + static_assert(noexcept(g()) == true, ""); + + } + + namespace test_constexpr + { + + template < typename CharT > + unsigned long constexpr + strlen_c_r(const CharT *const s, const unsigned long acc) noexcept + { + return *s ? strlen_c_r(s + 1, acc + 1) : acc; + } + + template < typename CharT > + unsigned long constexpr + strlen_c(const CharT *const s) noexcept + { + return strlen_c_r(s, 0UL); + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("1") == 1UL, ""); + static_assert(strlen_c("example") == 7UL, ""); + static_assert(strlen_c("another\0example") == 7UL, ""); + + } + + namespace test_rvalue_references + { + + template < int N > + struct answer + { + static constexpr int value = N; + }; + + answer<1> f(int&) { return answer<1>(); } + answer<2> f(const int&) { return answer<2>(); } + answer<3> f(int&&) { return answer<3>(); } + + void + test() + { + int i = 0; + const int c = 0; + static_assert(decltype(f(i))::value == 1, ""); + static_assert(decltype(f(c))::value == 2, ""); + static_assert(decltype(f(0))::value == 3, ""); + } + + } + + namespace test_uniform_initialization + { + + struct test + { + static const int zero {}; + static const int one {1}; + }; + + static_assert(test::zero == 0, ""); + static_assert(test::one == 1, ""); + + } + + namespace test_lambdas + { + + void + test1() + { + auto lambda1 = [](){}; + auto lambda2 = lambda1; + lambda1(); + lambda2(); + } + + int + test2() + { + auto a = [](int i, int j){ return i + j; }(1, 2); + auto b = []() -> int { return '0'; }(); + auto c = [=](){ return a + b; }(); + auto d = [&](){ return c; }(); + auto e = [a, &b](int x) mutable { + const auto identity = [](int y){ return y; }; + for (auto i = 0; i < a; ++i) + a += b--; + return x + identity(a + b); + }(0); + return a + b + c + d + e; + } + + int + test3() + { + const auto nullary = [](){ return 0; }; + const auto unary = [](int x){ return x; }; + using nullary_t = decltype(nullary); + using unary_t = decltype(unary); + const auto higher1st = [](nullary_t f){ return f(); }; + const auto higher2nd = [unary](nullary_t f1){ + return [unary, f1](unary_t f2){ return f2(unary(f1())); }; + }; + return higher1st(nullary) + higher2nd(nullary)(unary); + } + + } + + namespace test_variadic_templates + { + + template <int...> + struct sum; + + template <int N0, int... N1toN> + struct sum<N0, N1toN...> + { + static constexpr auto value = N0 + sum<N1toN...>::value; + }; + + template <> + struct sum<> + { + static constexpr auto value = 0; + }; + + static_assert(sum<>::value == 0, ""); + static_assert(sum<1>::value == 1, ""); + static_assert(sum<23>::value == 23, ""); + static_assert(sum<1, 2>::value == 3, ""); + static_assert(sum<5, 5, 11>::value == 21, ""); + static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, ""); + + } + + // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae + // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function + // because of this. + namespace test_template_alias_sfinae + { + + struct foo {}; + + template<typename T> + using member = typename T::member_type; + + template<typename T> + void func(...) {} + + template<typename T> + void func(member<T>*) {} + + void test(); + + void test() { func<foo>(0); } + + } + +} // namespace cxx11 + +#endif // __cplusplus >= 201103L + +]]) + + +dnl Tests for new features in C++14 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[ + +// If the compiler admits that it is not ready for C++14, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201402L + +#error "This is not a C++14 compiler" + +#else + +namespace cxx14 +{ + + namespace test_polymorphic_lambdas + { + + int + test() + { + const auto lambda = [](auto&&... args){ + const auto istiny = [](auto x){ + return (sizeof(x) == 1UL) ? 1 : 0; + }; + const int aretiny[] = { istiny(args)... }; + return aretiny[0]; + }; + return lambda(1, 1L, 1.0f, '1'); + } + + } + + namespace test_binary_literals + { + + constexpr auto ivii = 0b0000000000101010; + static_assert(ivii == 42, "wrong value"); + + } + + namespace test_generalized_constexpr + { + + template < typename CharT > + constexpr unsigned long + strlen_c(const CharT *const s) noexcept + { + auto length = 0UL; + for (auto p = s; *p; ++p) + ++length; + return length; + } + + static_assert(strlen_c("") == 0UL, ""); + static_assert(strlen_c("x") == 1UL, ""); + static_assert(strlen_c("test") == 4UL, ""); + static_assert(strlen_c("another\0test") == 7UL, ""); + + } + + namespace test_lambda_init_capture + { + + int + test() + { + auto x = 0; + const auto lambda1 = [a = x](int b){ return a + b; }; + const auto lambda2 = [a = lambda1(x)](){ return a; }; + return lambda2(); + } + + } + + namespace test_digit_separators + { + + constexpr auto ten_million = 100'000'000; + static_assert(ten_million == 100000000, ""); + + } + + namespace test_return_type_deduction + { + + auto f(int& x) { return x; } + decltype(auto) g(int& x) { return x; } + + template < typename T1, typename T2 > + struct is_same + { + static constexpr auto value = false; + }; + + template < typename T > + struct is_same<T, T> + { + static constexpr auto value = true; + }; + + int + test() + { + auto x = 0; + static_assert(is_same<int, decltype(f(x))>::value, ""); + static_assert(is_same<int&, decltype(g(x))>::value, ""); + return x; + } + + } + +} // namespace cxx14 + +#endif // __cplusplus >= 201402L + +]]) + + +dnl Tests for new features in C++17 + +m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[ + +// If the compiler admits that it is not ready for C++17, why torture it? +// Hopefully, this will speed up the test. + +#ifndef __cplusplus + +#error "This is not a C++ compiler" + +#elif __cplusplus < 201703L + +#error "This is not a C++17 compiler" + +#else + +#include <initializer_list> +#include <utility> +#include <type_traits> + +namespace cxx17 +{ + + namespace test_constexpr_lambdas + { + + constexpr int foo = [](){return 42;}(); + + } + + namespace test::nested_namespace::definitions + { + + } + + namespace test_fold_expression + { + + template<typename... Args> + int multiply(Args... args) + { + return (args * ... * 1); + } + + template<typename... Args> + bool all(Args... args) + { + return (args && ...); + } + + } + + namespace test_extended_static_assert + { + + static_assert (true); + + } + + namespace test_auto_brace_init_list + { + + auto foo = {5}; + auto bar {5}; + + static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value); + static_assert(std::is_same<int, decltype(bar)>::value); + } + + namespace test_typename_in_template_template_parameter + { + + template<template<typename> typename X> struct D; + + } + + namespace test_fallthrough_nodiscard_maybe_unused_attributes + { + + int f1() + { + return 42; + } + + [[nodiscard]] int f2() + { + [[maybe_unused]] auto unused = f1(); + + switch (f1()) + { + case 17: + f1(); + [[fallthrough]]; + case 42: + f1(); + } + return f1(); + } + + } + + namespace test_extended_aggregate_initialization + { + + struct base1 + { + int b1, b2 = 42; + }; + + struct base2 + { + base2() { + b3 = 42; + } + int b3; + }; + + struct derived : base1, base2 + { + int d; + }; + + derived d1 {{1, 2}, {}, 4}; // full initialization + derived d2 {{}, {}, 4}; // value-initialized bases + + } + + namespace test_general_range_based_for_loop + { + + struct iter + { + int i; + + int& operator* () + { + return i; + } + + const int& operator* () const + { + return i; + } + + iter& operator++() + { + ++i; + return *this; + } + }; + + struct sentinel + { + int i; + }; + + bool operator== (const iter& i, const sentinel& s) + { + return i.i == s.i; + } + + bool operator!= (const iter& i, const sentinel& s) + { + return !(i == s); + } + + struct range + { + iter begin() const + { + return {0}; + } + + sentinel end() const + { + return {5}; + } + }; + + void f() + { + range r {}; + + for (auto i : r) + { + [[maybe_unused]] auto v = i; + } + } + + } + + namespace test_lambda_capture_asterisk_this_by_value + { + + struct t + { + int i; + int foo() + { + return [*this]() + { + return i; + }(); + } + }; + + } + + namespace test_enum_class_construction + { + + enum class byte : unsigned char + {}; + + byte foo {42}; + + } + + namespace test_constexpr_if + { + + template <bool cond> + int f () + { + if constexpr(cond) + { + return 13; + } + else + { + return 42; + } + } + + } + + namespace test_selection_statement_with_initializer + { + + int f() + { + return 13; + } + + int f2() + { + if (auto i = f(); i > 0) + { + return 3; + } + + switch (auto i = f(); i + 4) + { + case 17: + return 2; + + default: + return 1; + } + } + + } + + namespace test_template_argument_deduction_for_class_templates + { + + template <typename T1, typename T2> + struct pair + { + pair (T1 p1, T2 p2) + : m1 {p1}, + m2 {p2} + {} + + T1 m1; + T2 m2; + }; + + void f() + { + [[maybe_unused]] auto p = pair{13, 42u}; + } + + } + + namespace test_non_type_auto_template_parameters + { + + template <auto n> + struct B + {}; + + B<5> b1; + B<'a'> b2; + + } + + namespace test_structured_bindings + { + + int arr[2] = { 1, 2 }; + std::pair<int, int> pr = { 1, 2 }; + + auto f1() -> int(&)[2] + { + return arr; + } + + auto f2() -> std::pair<int, int>& + { + return pr; + } + + struct S + { + int x1 : 2; + volatile double y1; + }; + + S f3() + { + return {}; + } + + auto [ x1, y1 ] = f1(); + auto& [ xr1, yr1 ] = f1(); + auto [ x2, y2 ] = f2(); + auto& [ xr2, yr2 ] = f2(); + const auto [ x3, y3 ] = f3(); + + } + + namespace test_exception_spec_type_system + { + + struct Good {}; + struct Bad {}; + + void g1() noexcept; + void g2(); + + template<typename T> + Bad + f(T*, T*); + + template<typename T1, typename T2> + Good + f(T1*, T2*); + + static_assert (std::is_same_v<Good, decltype(f(g1, g2))>); + + } + + namespace test_inline_variables + { + + template<class T> void f(T) + {} + + template<class T> inline T g(T) + { + return T{}; + } + + template<> inline void f<>(int) + {} + + template<> int g<>(int) + { + return 5; + } + + } + +} // namespace cxx17 + +#endif // __cplusplus < 201703L + +]]) diff --git a/Tools/mkdist.py b/Tools/mkdist.py index 7116144a0..4fba4701d 100755 --- a/Tools/mkdist.py +++ b/Tools/mkdist.py @@ -3,6 +3,7 @@ import sys import os import subprocess +from utils import * def failed(): print("mkdist.py failed to complete") @@ -22,6 +23,15 @@ dirname = "swig-" + version force_tag = args.force_tag skip_checks = args.skip_checks +# Tools directory path $ENV/swig/Tools +toolsdir = os.path.dirname(os.path.abspath(__file__)) +# Root directory path (swig) $ENV/swig +rootdir = os.path.abspath(os.path.join(toolsdir, os.pardir)) +# current directory +current_dir = os.getcwd() +# version directory path $ENV/swig/<x.x.x> +dirpath = os.path.join(current_dir, dirname) + if sys.version_info[0:2] < (2, 7): print("Error: Python 2.7 or higher is required") sys.exit(3) @@ -33,21 +43,26 @@ if dirname.lower() != dirname: # If directory and tarball exist, remove it print("Removing " + dirname) -os.system("rm -rf " + dirname) +if check_dir_exists(dirpath): + run_command("rm", "-rf", dirpath) print("Removing " + dirname + ".tar if exists") -os.system("rm -f " + dirname + ".tar.gz") +filename = dirpath + ".tar" +if check_file_exists(filename): + run_command("rm", "-rf", filename) print("Removing " + dirname + ".tar.gz if exists") -os.system("rm -f " + dirname + ".tar") +filename += ".gz" +if check_file_exists(filename): + run_command("rm", "-rf", filename) # Grab the code from git print("Checking there are no local changes in git repo") -os.system("git remote update origin") == 0 or failed() +run_command("git", "remote", "update", "origin") == 0 or failed() command = ["git", "status", "--porcelain", "-uno"] out = subprocess.check_output(command) -if out.strip() != "": +if out.strip(): print("Local git repository has modifications") print(" ".join(command)) print(out) @@ -57,7 +72,7 @@ if not skip_checks: print("Checking git repository is in sync with remote repository") command = ["git", "log", "--oneline", branch + "..origin/" + branch] out = subprocess.check_output(command) - if out.strip() != "": + if out.strip(): print("Remote repository has additional modifications to local repository") print(" ".join(command)) print(out) @@ -65,7 +80,7 @@ if not skip_checks: command = ["git", "log", "--oneline", "origin/" + branch + ".." + branch] out = subprocess.check_output(command) - if out.strip() != "": + if out.strip(): print("Local repository has modifications not pushed to the remote repository") print("These should be pushed and checked that they pass Continuous Integration testing before continuing") print(" ".join(command)) @@ -73,31 +88,49 @@ if not skip_checks: sys.exit(3) print("Tagging release") -tag = "'v" + version + "'" +tag = "v" + version force = "-f " if force_tag else "" -os.system("git tag -a -m 'Release version " + version + "' " + force + tag) == 0 or failed() +command = ["git", "tag", "-a", "-m", "'Release version " + version + "'"] +force and command.extend(force, tag) +not force and command.append(tag) +run_command(*command) == 0 or failed() -outdir = os.path.basename(os.getcwd()) + "/" + dirname + "/" +outdir = dirname + "/" print("Grabbing tagged release git repository using 'git archive' into " + outdir) -os.system("(cd .. && git archive --prefix=" + outdir + " " + tag + " . | tar -xf -)") == 0 or failed() + +# using pipe operator without shell=True; split commands into individual ones. +# git archive command +command = ["git", "archive", "--prefix=" + outdir, tag, "."] +archive_ps = subprocess.Popen(command, cwd=rootdir, stdout=subprocess.PIPE) +# tar -xf - +tar_ps = subprocess.Popen(("tar", "-xf", "-"), stdin=archive_ps.stdout, stdout=subprocess.PIPE) +archive_ps.stdout.close() # Allow archive_ps to receive a SIGPIPE if tar_ps exits. +output = tar_ps.communicate() # Go build the system print("Building system") -os.system("cd " + dirname + " && ./autogen.sh") == 0 or failed() -os.system("cd " + dirname + "/Source/CParse && bison -y -d parser.y && mv y.tab.c parser.c && mv y.tab.h parser.h") == 0 or failed() -os.system("cd " + dirname + " && make -f Makefile.in libfiles srcdir=./") == 0 or failed() +run_command("mkdir", "-p", dirpath) +run_command("./autogen.sh", cwd=dirpath) == 0 or failed() + +cmdpath = os.path.join(dirpath, "Source", "CParse") +run_command("bison", "-y", "-d", "parser.y", cwd=cmdpath) == 0 or failed() +run_command("mv", "y.tab.c", "parser.c", cwd=cmdpath) == 0 or failed() +run_command("mv", "y.tab.h", "parser.h", cwd=cmdpath) == 0 or failed() + +run_command("make", "-f", "Makefile.in", "libfiles", "srcdir=./", cwd=dirpath) == 0 or failed() # Remove autoconf files -os.system("find " + dirname + " -name autom4te.cache -exec rm -rf {} \\;") +run_command("find", dirname, "-name", "autom4te.cache", "-exec", "rm", "-rf", "{}", ";", cwd=rootdir) # Build documentation print("Building html documentation") -os.system("cd " + dirname + "/Doc/Manual && make all clean-baks") == 0 or failed() +docpath = os.path.join(dirpath, "Doc", "Manual") +run_command("make", "all", "clean-baks", cwd=docpath) == 0 or failed() # Build the tar-ball -os.system("tar -cf " + dirname + ".tar " + dirname) == 0 or failed() -os.system("gzip " + dirname + ".tar") == 0 or failed() +run_command("tar", "-cf", dirname + ".tar", dirname, stdout=open(dirname + ".tar", "w")) == 0 or failed() +run_command("gzip", dirname + ".tar", stdout=open(dirname + ".tar.gz", "w")) == 0 or failed() print("Finished building " + dirname + ".tar.gz") diff --git a/Tools/mkrelease.py b/Tools/mkrelease.py index 014cef227..28dca265b 100755 --- a/Tools/mkrelease.py +++ b/Tools/mkrelease.py @@ -2,6 +2,7 @@ import sys import os +from utils import * def failed(message): if message == "": @@ -27,15 +28,17 @@ skip_checks = args.skip_checks username = args.username print("Looking for rsync") -os.system("which rsync") and failed("rsync not installed/found. Please install.") +run_command("which", "rsync") and failed("rsync not installed/found. Please install.") print("Making source tarball") force = "--force-tag" if force_tag else "" skip = "--skip-checks" if skip_checks else "" -os.system("python ./mkdist.py {} {} --branch {} {}".format(force, skip, branch, version)) and failed("") +toolsdir = os.path.dirname(os.path.abspath(__file__)) +cmd = "python {}/mkdist.py {} {} --branch {} {}".format(toolsdir, force, skip, branch, version).split() +run_command(*cmd) and failed("") print("Build Windows package") -os.system("./mkwindows.sh " + version) and failed("") +run_command("{}/mkwindows.sh".format(toolsdir), version) and failed("") if username: print("Uploading to SourceForge") @@ -45,11 +48,11 @@ if username: # If a file with 'readme' in the name exists in the same folder as the zip/tarball, it gets automatically displayed as the release notes by SF full_readme_file = "readme-" + version + ".txt" - os.system("rm -f " + full_readme_file) - os.system("cat swig-" + version + "/README " + "swig-" + version + "/CHANGES.current " + "swig-" + version + "/RELEASENOTES " + "> " + full_readme_file) + run_command("rm", "-f", full_readme_file) + run_command("cat", "swig-" + version + "/README", "swig-" + version + "/CHANGES.current", "swig-" + version + "/RELEASENOTES", ">", full_readme_file) - os.system("rsync --archive --verbose -P --times -e ssh " + "swig-" + version + ".tar.gz " + full_readme_file + " " + swig_dir_sf) and failed("") - os.system("rsync --archive --verbose -P --times -e ssh " + "swigwin-" + version + ".zip " + full_readme_file + " " + swigwin_dir_sf) and failed("") + run_command("rsync", "--archive", "--verbose", "-P", "--times", "-e", "ssh", "swig-" + version + ".tar.gz", full_readme_file, swig_dir_sf) and failed("") + run_command("rsync", "--archive", "--verbose", "-P", "--times", "-e", "ssh", "swigwin-" + version + ".zip", full_readme_file, swigwin_dir_sf) and failed("") print("Finished") diff --git a/Tools/testflags.py b/Tools/testflags.py index f3d216b59..16e4d8aee 100755 --- a/Tools/testflags.py +++ b/Tools/testflags.py @@ -3,11 +3,15 @@ def get_cflags(language, std, compiler): if std == None or len(std) == 0: std = "gnu89" - c_common = "-fdiagnostics-show-option -std=" + std + " -Wno-long-long -Wreturn-type -Wdeclaration-after-statement -Wmissing-field-initializers" + c_common = "-fdiagnostics-show-option -std=" + std + " -Wno-long-long -Wreturn-type -Wmissing-field-initializers" + if std == "gnu89" or std == "gnu90": + # gnu89 standard allows declaration after headers + # use c99 or gnu99 if feature is necessary for using target language + c_common = c_common + " -Wdeclaration-after-statement" cflags = { "csharp":"-Werror " + c_common, "d":"-Werror " + c_common, - "go":"-Werror " + c_common + " -Wno-declaration-after-statement", + "go":"-Werror " + c_common, "guile":"-Werror " + c_common, "java":"-Werror " + c_common, "javascript":"-Werror " + c_common, diff --git a/Tools/travis-linux-install.sh b/Tools/travis-linux-install.sh index e25b85f04..cb64d57d2 100755 --- a/Tools/travis-linux-install.sh +++ b/Tools/travis-linux-install.sh @@ -1,122 +1,11 @@ #!/bin/bash -# Install Linux packages where the version has been overidden in .travis.yml - -set -e # exit on failure (same as -o errexit) +# Install Linux packages where the version has been overridden in .travis.yml lsb_release -a -travis_retry sudo apt-get -qq update - -if [[ -n "$GCC" ]]; then - travis_retry sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test - travis_retry sudo apt-get -qq update - travis_retry sudo apt-get install -qq g++-$GCC -fi - -travis_retry sudo apt-get -qq install libboost-dev libpcre3-dev - -WITHLANG=$SWIGLANG - -case "$SWIGLANG" in - "") ;; - "csharp") - travis_retry sudo apt-get -qq install mono-devel - ;; - "d") - travis_retry wget http://downloads.dlang.org/releases/2.x/${VER}/dmd_${VER}-0_amd64.deb - travis_retry sudo dpkg -i dmd_${VER}-0_amd64.deb - ;; - "go") - if [[ "$VER" ]]; then - eval "$(gimme ${VER}.x)" - fi - ;; - "javascript") - case "$ENGINE" in - "node") - travis_retry wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.33.10/install.sh | bash - export NVM_DIR="$HOME/.nvm" - [ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" - travis_retry nvm install ${VER} - nvm use ${VER} - if [ "$VER" == "0.10" ] || [ "$VER" == "0.12" ] || [ "$VER" == "4" ] || [ "$VER" == "6" ] ; then -# travis_retry sudo apt-get install -qq nodejs node-gyp - travis_retry npm install -g node-gyp@$VER - elif [ "$VER" == "8" ] ; then - travis_retry npm install -g node-gyp@6 - else - travis_retry npm install -g node-gyp - fi - ;; - "jsc") - travis_retry sudo apt-get install -qq libwebkitgtk-dev - ;; - "v8") - travis_retry sudo apt-get install -qq libv8-dev - ;; - esac - ;; - "guile") - travis_retry sudo apt-get -qq install guile-2.0-dev - ;; - "lua") - if [[ -z "$VER" ]]; then - travis_retry sudo apt-get -qq install lua5.2 liblua5.2-dev - else - travis_retry sudo apt-get -qq install lua${VER} liblua${VER}-dev - fi - ;; - "mzscheme") - travis_retry sudo apt-get -qq install racket - ;; - "ocaml") - travis_retry sudo apt-get -qq install ocaml camlp4 - ;; - "octave") - travis_retry sudo apt-get -qq install liboctave-dev - ;; - "php") - travis_retry sudo add-apt-repository -y ppa:ondrej/php - travis_retry sudo apt-get -qq update - travis_retry sudo apt-get -qq install php$VER-cli php$VER-dev - ;; - "python") - pip install --user pycodestyle - if [[ "$PY3" ]]; then - travis_retry sudo apt-get install -qq python3-dev - fi - WITHLANG=$SWIGLANG$PY3 - if [[ "$VER" ]]; then - travis_retry sudo add-apt-repository -y ppa:deadsnakes/ppa - travis_retry sudo apt-get -qq update - travis_retry sudo apt-get -qq install python${VER}-dev - WITHLANG=$SWIGLANG$PY3=$SWIGLANG$VER - fi - ;; - "r") - travis_retry sudo apt-get -qq install r-base - ;; - "ruby") - if [[ "$VER" == "2.7" ]]; then - # Ruby 2.7 support is currently only rvm master (30 Dec 2019) - travis_retry rvm get master - rvm reload - rvm list known - fi - if [[ "$VER" ]]; then - travis_retry rvm install $VER - fi - ;; - "scilab") - # Travis has the wrong version of Java pre-installed resulting in error using scilab: - # /usr/bin/scilab-bin: error while loading shared libraries: libjava.so: cannot open shared object file: No such file or directory - echo "JAVA_HOME was set to $JAVA_HOME" - unset JAVA_HOME - travis_retry sudo apt-get -qq install scilab - ;; - "tcl") - travis_retry sudo apt-get -qq install tcl-dev - ;; -esac +# find location of current script (only works in bash) +script_dir="$( dirname "${BASH_SOURCE[0]}")" -set +e # turn off exit on failure (same as +o errexit) +# run generic script +RETRY=travis-retry +source "$script_dir"/CI-linux-install.sh diff --git a/Tools/travis-osx-install.sh b/Tools/travis-osx-install.sh index 71545ad5c..fc69c6654 100755 --- a/Tools/travis-osx-install.sh +++ b/Tools/travis-osx-install.sh @@ -1,6 +1,6 @@ #!/bin/bash -# Install MacOS packages where the version has been overidden in .travis.yml +# Install MacOS packages where the version has been overridden in .travis.yml set -e # exit on failure (same as -o errexit) diff --git a/Tools/utils.py b/Tools/utils.py new file mode 100644 index 000000000..496882f19 --- /dev/null +++ b/Tools/utils.py @@ -0,0 +1,26 @@ +import os, subprocess + + +def check_file_exists(path): + """ + Checks if a file exists or not. + """ + return os.path.isfile(path) + + +def check_dir_exists(path): + """ + Checks if a folder exists or not. + """ + return os.path.isdir(path) + + +def run_command(*args, **kwargs): + """ + Runs an os command using subprocess module. + """ + redirect_out = list(map(str.strip, " ".join(args).split(" > "))) + if len(redirect_out) > 1: + args, filepath = redirect_out[0].split(), redirect_out[-1] + kwargs.update(stdout=open(filepath, "w")) + return subprocess.call(args, **kwargs) diff --git a/appveyor.yml b/appveyor.yml index 47cf893bb..07c4fac28 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -2,6 +2,13 @@ platform: - x86 - x64 +skip_commits: + files: + - '.github/**' + - 'CHANGES*' + - 'Doc/**' + - 'Tools/CI-*' + environment: global: MAKEJOBS: 2 @@ -16,29 +23,43 @@ environment: - SWIGLANG: python VSVER: 14 VER: 27 -# - SWIGLANG: python -# VSVER: 14 -# VER: 36 -# PY3: 3 + - SWIGLANG: python + VSVER: 15 + VER: 38 + PY3: 3 + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 + - SWIGLANG: python + VSVER: 16 + VER: 39 + PY3: 3 + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 - SWIGLANG: python OSVARIANT: cygwin -# - SWIGLANG: python -# OSVARIANT: mingw -# VER: 27 -# - SWIGLANG: python -# OSVARIANT: mingw -# WITHLANG: python -# VER: 37 -# PY3: 3 + - SWIGLANG: java + OSVARIANT: mingw + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 + - SWIGLANG: python + OSVARIANT: mingw + WITHLANG: python + VER: 37 + PY3: 3 + APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019 - BUILDSYSTEM: cmake VSVER: 14 matrix: allow_failures: - # Currently failing due to not detecting header files/include paths - SWIGLANG: python OSVARIANT: cygwin +# Skip stale commits (pull requests only), see https://github.com/appveyor/ci/issues/38#issuecomment-70628826 +init: +- ps: | + if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod ` + https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | ` + Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { ` + throw "There are newer queued builds for this pull request, failing early." } + install: - date /T & time /T - ps: >- @@ -56,7 +77,7 @@ install: $env:VSARCH="" } else { $env:PCRE_PLATFORM="x64" - $env:JAVA_HOME="C:/Program Files/Java/jdk1.8.0" + $env:JAVA_HOME="C:/Program Files/Java/jdk15" $env:VCVARS_PLATFORM="amd64" $env:LANG_PLATFORM="-x64" $env:CYGWINBIN="C:\cygwin64\bin" @@ -71,9 +92,20 @@ install: if (!$env:OSVARIANT) { $env:PATH="$env:CYGWINBIN;$env:PATH" $env:CYGWIN="nodosfilewarning" - $env:VSCOMNTOOLS=(Get-Content ("env:VS" + "$env:VSVER" + "0COMNTOOLS")) $env:CC="cccl" $env:CXX="cccl" + if ($env:VSVER -ge 16) { + $env:VCVARSBAT="C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars$env:MBITS.bat" + $env:BOOSTROOT="C:/Libraries/boost_1_73_0" + } elseif ($env:VSVER -eq 15) { + $env:VCVARSBAT="C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars$env:MBITS.bat" + $env:BOOSTROOT="C:/Libraries/boost_1_69_0" + } else { + $env:VSCOMNTOOLS=(Get-Content ("env:VS" + "$env:VSVER" + "0COMNTOOLS")) + $env:VCVARSBAT="$env:VSCOMNTOOLS..\..\VC\vcvarsall.bat" + $env:VCVARSARG="$env:VCVARS_PLATFORM" + $env:BOOSTROOT="C:/Libraries/boost_1_69_0" + } } elseif ($env:OSVARIANT -eq "cygwin") { $env:PATH="$env:CYGWINBIN;$env:PATH" $env:CYGWIN="nodosfilewarning" @@ -89,9 +121,8 @@ install: $env:CHECK_OPTIONS2="CFLAGS+=-DMS_WIN64 CXXFLAGS+=-DMS_WIN64" } } -- if "%OSVARIANT%"=="" bash -c "cd /usr/bin && curl --retry 15 -s -L https://github.com/swig/cccl/archive/cccl-1.0.tar.gz | tar -xz --strip 1 cccl-cccl-1.0/cccl" -- if "%OSVARIANT%"=="" echo Using Visual Studio %VSVER%.0 at %VSCOMNTOOLS% -- if "%OSVARIANT%"=="" call "%VSCOMNTOOLS%\..\..\VC\vcvarsall.bat" %VCVARS_PLATFORM% +- if "%OSVARIANT%"=="" bash -c "cd /usr/bin && curl --retry 15 -s -L https://github.com/swig/cccl/archive/cccl-1.2.tar.gz | tar -xz --strip 1 cccl-cccl-1.2/cccl" +- if "%OSVARIANT%"=="" call "%VCVARSBAT%" %VCVARSARG% - if "%OSVARIANT%"=="" Tools\nuget-install.cmd pcre -Verbosity quiet -Version 8.33.0.1 -OutputDirectory C:\pcre - if "%OSVARIANT%"=="" set PCRE_ROOT=C:/pcre/pcre.8.33.0.1/build/native - if not "%OSVARIANT%"=="cygwin" set PATH=C:\Python%VER%%LANG_PLATFORM%;%PATH% @@ -117,9 +148,9 @@ install: build_script: - set CCCL_OPTIONS=--cccl-muffle /W3 /EHsc - set CHECK_OPTIONS=CSHARPOPTIONS=-platform:%Platform% +- if "%BUILDSYSTEM%"=="cmake" cmake --version && cmake -G "Visual Studio 14 2015%VSARCH%" -DCMAKE_INSTALL_PREFIX="%CD:\=/%/install2" -DCMAKE_C_FLAGS="/WX /DPCRE_STATIC" -DCMAKE_CXX_FLAGS="/WX /DPCRE_STATIC" -DPCRE_INCLUDE_DIR=%PCRE_ROOT%/include -DPCRE_LIBRARY=%PCRE_ROOT%/lib/v110/%PCRE_PLATFORM%/Release/static/utf8/pcre8.lib -DBISON_EXECUTABLE=C:/cygwin/bin/bison.exe . && cmake --build . --config Release --target install && ctest --output-on-failure -V -C Release && appveyor exit # Open dummy file descriptor to fix error on cygwin: ./configure: line 560: 0: Bad file descriptor -- if "%BUILDSYSTEM%"=="cmake" cmake -G "Visual Studio 14 2015%VSARCH%" -DCMAKE_INSTALL_PREFIX="%CD:\=/%/install2" -DCMAKE_C_FLAGS="/DPCRE_STATIC" -DCMAKE_CXX_FLAGS="/DPCRE_STATIC" -DPCRE_INCLUDE_DIR=%PCRE_ROOT%/include -DPCRE_LIBRARY=%PCRE_ROOT%/lib/v110/%PCRE_PLATFORM%/Release/static/utf8/pcre8.lib -DBISON_EXECUTABLE=C:/cygwin/bin/bison.exe . && cmake --build . --config Release --target install && ctest --output-on-failure -V -C Release && appveyor exit -- if "%OSVARIANT%"=="" bash -c "exec 0</dev/null && ./autogen.sh && time ./configure --disable-dependency-tracking --disable-ccache CC=$CC CXX=$CXX CFLAGS='-O2' CXXFLAGS='-O2' LDFLAGS='--cccl-link /LTCG' PCRE_CFLAGS='-I%PCRE_ROOT%/include -DPCRE_STATIC' PCRE_LIBS='-L%PCRE_ROOT%/lib/v110/%PCRE_PLATFORM%/Release/static/utf8 -lpcre8' --without-perl5 --without-go --with-boost=C:/Libraries/boost_1_67_0 || cat config.log" +- if "%OSVARIANT%"=="" bash -c "exec 0</dev/null && ./autogen.sh && time ./configure --disable-dependency-tracking --disable-ccache --enable-cpp11-testing CC=$CC CXX=$CXX CFLAGS='-O2' CXXFLAGS='-O2' LDFLAGS='--cccl-link /LTCG' PCRE_CFLAGS='-I%PCRE_ROOT%/include -DPCRE_STATIC' PCRE_LIBS='-L%PCRE_ROOT%/lib/v110/%PCRE_PLATFORM%/Release/static/utf8 -lpcre8' --without-perl5 --without-go --with-boost=%BOOSTROOT% || cat config.log" - if not "%OSVARIANT%"=="" bash -c "exec 0</dev/null && ./autogen.sh && time ./configure CC=%CC% CXX=%CXX% --without-alllang --with-$SWIGLANG$PY3$SWIGWITHLANG --enable-cpp11-testing || cat config.log" - bash -c "time make -s -j%MAKEJOBS%" diff --git a/configure.ac b/configure.ac index 77c94a696..9bf45c765 100644 --- a/configure.ac +++ b/configure.ac @@ -3,7 +3,7 @@ dnl The macros which aren't shipped with the autotools are stored in the dnl Tools/config directory in .m4 files. AC_INIT([swig],[4.1.0],[http://www.swig.org]) -AC_PREREQ(2.60) +AC_PREREQ([2.60]) AC_CONFIG_SRCDIR([Source/Swig/swig.h]) AC_CONFIG_AUX_DIR([Tools/config]) @@ -26,11 +26,16 @@ AM_PROG_CC_C_O # Needed for subdir-objects in AUTOMAKE_OPTIONS AC_COMPILE_WARNINGS # Increase warning levels +AC_MSG_CHECKING([CFLAGS to compile SWIG executable]) +AC_MSG_RESULT([$CFLAGS]) +AC_MSG_CHECKING([CXXFLAGS to compile SWIG executable]) +AC_MSG_RESULT([$CXXFLAGS]) + AC_DEFINE_UNQUOTED(SWIG_CXX, ["$CXX"], [Compiler that built SWIG]) AC_DEFINE_UNQUOTED(SWIG_PLATFORM, ["$host"], [Platform that SWIG is built for]) -dnl Checks for header files. -AC_HEADER_STDC +# For AC_EGREP_CPP +AC_PROG_EGREP dnl Look for popen AC_ARG_WITH(popen, AS_HELP_STRING([--without-popen], [Disable popen]), with_popen="$withval") @@ -141,14 +146,14 @@ then *-*-aix*) LDSHARED="\$(srcdir)/ld_so_aix \$(CC)";; *-*-cygwin* | *-*-mingw*) if test "$GCC" = yes; then - LDSHARED="$CC -shared" + LDSHARED="\$(CC) -shared" else if test "cl" = $CC ; then # Microsoft Visual C++ (MSVC) - LDSHARED="$CC -nologo -LD" + LDSHARED="\$(CC) -nologo -LD" else # Unknown compiler try gcc approach - LDSHARED="$CC -shared" + LDSHARED="\$(CC) -shared" fi fi ;; *-*-irix5*) LDSHARED="ld -shared";; @@ -160,25 +165,25 @@ then *-sequent-sysv4) LDSHARED="ld -G";; *-*-next*) if test "$ns_dyld" - then LDSHARED='$(CC) $(LDFLAGS) -bundle -prebind' - else LDSHARED='$(CC) $(CFLAGS) -nostdlib -r' + then LDSHARED="\$(CC) \$(LDFLAGS) -bundle -prebind" + else LDSHARED="\$(CC) \$(CFLAGS) -nostdlib -r" fi if test "$with_next_framework" ; then LDSHARED="$LDSHARED \$(LDLIBRARY)" fi ;; - *-*-linux*) LDSHARED="$CC -shared";; + *-*-linux*) LDSHARED="\$(CC) -shared";; *-*-dgux*) LDSHARED="ld -G";; - *-*-freebsd3*) LDSHARED="$CC -shared";; + *-*-freebsd3*) LDSHARED="\$(CC) -shared";; *-*-freebsd* | *-*-openbsd*) LDSHARED="ld -Bshareable";; *-*-netbsd*) - if [[ "`$CC -dM -E - </dev/null | grep __ELF__`" != "" ]] + if [[ "`\$(CC) -dM -E - </dev/null | grep __ELF__`" != "" ]] then - LDSHARED="$CC -shared" + LDSHARED="\$(CC) -shared" else LDSHARED="ld -Bshareable" fi;; - *-sco-sysv*) LDSHARED="$CC -G -KPIC -Ki486 -belf -Wl,-Bexport";; - *-*-darwin*) LDSHARED="$CC -bundle -undefined suppress -flat_namespace";; + *-sco-sysv*) LDSHARED="\$(CC) -G -KPIC -Ki486 -belf -Wl,-Bexport";; + *-*-darwin*) LDSHARED="\$(CC) -bundle -undefined suppress -flat_namespace";; *) LDSHARED="ld";; esac fi @@ -200,23 +205,23 @@ if test -z "$TRYLINKINGWITHCXX" then case $host in *-*-solaris*) if test "$GCC" = yes - then TRYLINKINGWITHCXX="CXXSHARED= $CXX -Wl,-G" - else TRYLINKINGWITHCXX="CXXSHARED= $CXX -G -L/opt/SUNWspro/lib -lCrun -lCstd" + then TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) -Wl,-G" + else TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) -G -L/opt/SUNWspro/lib -lCrun -lCstd" fi;; - *-*-hp*) TRYLINKINGWITHCXX="CXXSHARED= $CXX +z ";; - *-*-darwin*) TRYLINKINGWITHCXX="CXXSHARED= $CXX -bundle -undefined suppress -flat_namespace";; + *-*-hp*) TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) +z ";; + *-*-darwin*) TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) -bundle -undefined suppress -flat_namespace";; *-*-cygwin* | *-*-mingw*) if test "$GCC" = yes; then - TRYLINKINGWITHCXX="CXXSHARED= $CXX -shared " + TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) -shared " else if test "cl" = $CXX ; then # Microsoft Visual C++ (MSVC) - TRYLINKINGWITHCXX="CXXSHARED= $CXX -nologo -LD" + TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) -nologo -LD" else TRYLINKINGWITHCXX="#unknown Windows compiler" fi fi ;; - *) TRYLINKINGWITHCXX="CXXSHARED= $CXX -shared ";; + *) TRYLINKINGWITHCXX="CXXSHARED= \$(CXX) -shared ";; esac fi AC_MSG_RESULT($TRYLINKINGWITHCXX) @@ -289,27 +294,58 @@ AC_MSG_RESULT($PLATCFLAGS) # Add switch if necessary to enable C++11 support - just for tests AC_ARG_ENABLE([cpp11-testing], AS_HELP_STRING([--enable-cpp11-testing], [enable C++11 testing if supported by compiler (default disabled)]), [enable_cpp11_testing=$enableval], [enable_cpp11_testing=no]) -AC_MSG_CHECKING([whether to enable C++11 testing]) +AC_MSG_CHECKING([whether to attempt to enable C++11 testing]) AC_MSG_RESULT([$enable_cpp11_testing]) PLATCXXFLAGS="$PLATCFLAGS" if test x"$enable_cpp11_testing" = xyes; then - AC_LANG_PUSH([C++]) - CXXFLAGS_SAVED=$CXXFLAGS - CXXFLAGS= - AX_CXX_COMPILE_STDCXX_11([noext], [nostop]) - CXXFLAGS=$CXXFLAGS_SAVED - AC_LANG_POP([C++]) - if test x"$CXX11FLAGS" != x; then - PLATCXXFLAGS="$CXX11FLAGS $PLATCXXFLAGS" - fi - AC_MSG_CHECKING([for C++11 enabled compiler]) - if test x"$HAVE_CXX11_COMPILER" = x; then - AC_MSG_RESULT([no]) + CXX_SAVED=$CXX + CXXCPP_SAVED=$CXXCPP + + # Test for c++17 + CXXCPP=" " + AX_CXX_COMPILE_STDCXX(17, [noext], [optional]) + AC_MSG_CHECKING([whether C++17 and earlier testing is enabled]) + if test "$HAVE_CXX17" = "1"; then + AC_MSG_RESULT([yes]) + PLATCXXFLAGS="$CXXCPP $PLATCXXFLAGS" + HAVE_CXX14="1" + HAVE_CXX11="1" else - AC_MSG_RESULT([$HAVE_CXX11_COMPILER]) + AC_MSG_RESULT([no]) + + # Test for c++14 + CXXCPP=" " + CXX=$CXX_SAVED + AX_CXX_COMPILE_STDCXX(14, [noext], [optional]) + AC_MSG_CHECKING([whether C++14 and earlier testing is enabled]) + if test "$HAVE_CXX14" = "1"; then + AC_MSG_RESULT([yes]) + PLATCXXFLAGS="$CXXCPP $PLATCXXFLAGS" + HAVE_CXX11="1" + else + AC_MSG_RESULT([no]) + + # Test for c++11 + CXXCPP=" " + CXX=$CXX_SAVED + AX_CXX_COMPILE_STDCXX(11, [noext], [optional]) + AC_MSG_CHECKING([whether C++11 and earlier testing is enabled]) + if test "$HAVE_CXX11" = "1"; then + AC_MSG_RESULT([yes]) + PLATCXXFLAGS="$CXXCPP $PLATCXXFLAGS" + else + AC_MSG_RESULT([no]) + fi + + fi + fi + + CXX=$CXX_SAVED + CXXCPP=$CXXCPP_SAVED fi +AC_SUBST(HAVE_CXX11) # On darwin 10.7,10.8,10.9 using clang++, need to ensure using # libc++ for tests and examples to run under mono. May affect @@ -366,7 +402,6 @@ AC_SUBST(TRYLINKINGWITHCXX) AC_SUBST(RPATH) AC_SUBST(PLATCFLAGS) AC_SUBST(PLATCXXFLAGS) -AC_SUBST(HAVE_CXX11_COMPILER) AC_SUBST(LINKFORSHARED) # This variation is needed on OS-X because there is no (apparent) consistency in shared library naming. @@ -468,6 +503,7 @@ AC_PATH_TOOL([PKG_CONFIG], [pkg-config]) TCLINCLUDE= TCLLIB= TCLPACKAGE= +TCLLINK= AC_ARG_WITH(tclconfig, AS_HELP_STRING([--without-tcl], [Disable Tcl]) AS_HELP_STRING([--with-tclconfig=path], [Set location of tclConfig.sh]), [with_tclconfig="$withval"], [with_tclconfig=]) @@ -540,7 +576,7 @@ fi AC_MSG_CHECKING(for Tcl header files) if test -z "$TCLINCLUDE"; then -AC_TRY_CPP([#include <tcl.h>], , TCLINCLUDE="") +AC_PREPROC_IFELSE([AC_LANG_SOURCE([[#include <tcl.h>]])],[],[TCLINCLUDE=""]) if test -z "$TCLINCLUDE"; then dirs="/usr/local/include /usr/include /opt/local/include" for i in $dirs ; do @@ -560,7 +596,7 @@ fi AC_MSG_CHECKING(for Tcl library) if test -z "$TCLLIB"; then -dirs="/usr/local/lib /usr/lib /opt/local/lib" +dirs="/usr/local/lib /usr/lib /opt/local/lib /opt/freeware/lib" for i in $dirs ; do if test -r $i/libtcl.a; then AC_MSG_RESULT($i) @@ -578,9 +614,16 @@ fi # Cygwin (Windows) needs the library for dynamic linking case $host in *-*-cygwin* | *-*-mingw*) TCLDYNAMICLINKING="$TCLLIB";; +*-*-aix*) TCLDYNAMICLINKING="$TCLLIB";; *)TCLDYNAMICLINKING="";; esac +# AIX needs -ltcl for linking at test time +case $host in +*-*-aix*) TCLLINK="-ltcl";; +*)TCLLINK="";; +esac + case $host in *-*-darwin*) TCLLDSHARED='$(CC) -dynamiclib -undefined suppress -flat_namespace' @@ -599,6 +642,7 @@ AC_SUBST(TCLLIB) AC_SUBST(TCLDYNAMICLINKING) AC_SUBST(TCLLDSHARED) AC_SUBST(TCLCXXSHARED) +AC_SUBST(TCLLINK) #---------------------------------------------------------------- # Look for Python @@ -1207,6 +1251,9 @@ else if test $SCILAB_VERSION -ge 540; then SCILABOPT+=" -noatomsautoload" fi + if test $SCILAB_VERSION -ge 600; then + SCILABOPT+=" -quit" + fi AC_MSG_RESULT($SCILABOPT) # Check for Scilab header files @@ -1546,7 +1593,7 @@ else # Look for Node.js which is the default Javascript engine #---------------------------------------------------------------- - AC_CHECK_PROGS(NODEJS, [nodejs node]) + AC_CHECK_PROGS(NODEJS, [node nodejs]) if test -n "$NODEJS"; then # node-gyp is needed to run the test-suite/examples @@ -1600,15 +1647,15 @@ else if test -z "$JSCORELIB" -a -n "$PKG_CONFIG "; then AC_MSG_CHECKING(for JavaScriptCore/Webkit library) - if $PKG_CONFIG javascriptcoregtk-4.0; then + if $PKG_CONFIG javascriptcoregtk-4.0 2>/dev/null ; then JSCORELIB=`$PKG_CONFIG --libs javascriptcoregtk-4.0` JSCOREINC=`$PKG_CONFIG --cflags-only-I javascriptcoregtk-4.0` JSCOREVERSION=`$PKG_CONFIG --modversion javascriptcoregtk-4.0` - elif $PKG_CONFIG javascriptcoregtk-3.0; then + elif $PKG_CONFIG javascriptcoregtk-3.0 2>/dev/null ; then JSCORELIB=`$PKG_CONFIG --libs javascriptcoregtk-3.0` JSCOREINC=`$PKG_CONFIG --cflags-only-I javascriptcoregtk-3.0` JSCOREVERSION=`$PKG_CONFIG --modversion javascriptcoregtk-3.0` - elif $PKG_CONFIG javascriptcoregtk-1.0; then + elif $PKG_CONFIG javascriptcoregtk-1.0 2>/dev/null ; then JSCORELIB=`$PKG_CONFIG --libs javascriptcoregtk-1.0` JSCOREVERSION=`$PKG_CONFIG --modversion javascriptcoregtk-1.0` fi @@ -2021,7 +2068,7 @@ AC_SUBST(RUBYSO) AC_SUBST(RUBYDYNAMICLINKING) #------------------------------------------------------------------------- -# Look for PHP7 +# Look for PHP #------------------------------------------------------------------------- PHPBIN= @@ -2035,7 +2082,7 @@ if test x"${PHPBIN}" = xno; then PHP= else if test "x$PHPBIN" = xyes; then - AC_CHECK_PROGS(PHP, [php7.3 php7.2 php7.1 php7.0 php]) + AC_CHECK_PROGS(PHP, [php8.0 php7.4 php7.3 php7.2 php7.1 php7.0 php]) else PHP=$PHPBIN fi @@ -2046,12 +2093,14 @@ else case $PHP in *7.*) PHPCONFIG=`echo "$PHP"|sed 's/7\...*$/-config&/'` ;; + *8.*) + PHPCONFIG=`echo "$PHP"|sed 's/8\...*$/-config&/'` ;; *) PHPCONFIG=$PHP-config ;; esac php_version=`$PHPCONFIG --version 2>/dev/null` case $php_version in - 7.*) + 7.*|8.*) PHPINC=`$PHPCONFIG --includes 2>/dev/null` if test -n "$PHPINC"; then AC_MSG_RESULT($PHPINC) @@ -2062,7 +2111,7 @@ else "") AC_MSG_RESULT([could not find $PHPCONFIG or obtain PHP version from it]) ;; *) - AC_MSG_RESULT([found PHP $php_version - not PHP 7]) ;; + AC_MSG_RESULT([found PHP $php_version - not PHP 7 or 8]) ;; esac fi fi |