From 2d5959d669f58080061fbfecc3c9a66807da866b Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 05:55:54 +0200 Subject: [PATCH 01/57] [#3] Build with Nix https://github.com/kisp/asgl/issues/3 From dc873a1934fe325d3988e981bfa7decee02766e6 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:24:45 +0200 Subject: [PATCH 02/57] wip --- nix-build.sh | 12 ++++++++++++ shell.nix | 14 ++++++++++++++ steps.sh | 5 +++++ 3 files changed, 31 insertions(+) create mode 100755 nix-build.sh create mode 100644 shell.nix create mode 100644 steps.sh diff --git a/nix-build.sh b/nix-build.sh new file mode 100755 index 0000000..6adec70 --- /dev/null +++ b/nix-build.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +set -euxo pipefail + +git add . + +git commit -m wip + +git clean -nxd + +nix-shell \ + --pure --run 'bash steps.sh' diff --git a/shell.nix b/shell.nix new file mode 100644 index 0000000..43fc416 --- /dev/null +++ b/shell.nix @@ -0,0 +1,14 @@ +{ + pkgs ? import { }, +}: + +pkgs.mkShell { + buildInputs = [ + pkgs.cowsay + pkgs.which + pkgs.autoconf + ]; + shellHook = '' + echo "Welcome to the development environment!" + ''; +} diff --git a/steps.sh b/steps.sh new file mode 100644 index 0000000..41ed779 --- /dev/null +++ b/steps.sh @@ -0,0 +1,5 @@ +set -euxo pipefail + +echo hello + +autoconf configure.ac > configure From 26fdd44f7b984ea0c7be2d07dfefbd082b1bfbd1 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:25:30 +0200 Subject: [PATCH 03/57] wip --- nix-build.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nix-build.sh b/nix-build.sh index 6adec70..43e38f3 100755 --- a/nix-build.sh +++ b/nix-build.sh @@ -4,7 +4,7 @@ set -euxo pipefail git add . -git commit -m wip +git commit -m wip || true git clean -nxd From bf07143041d5f1e11e0691b1470f05b725e68d2d Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:25:48 +0200 Subject: [PATCH 04/57] wip --- nix-build.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nix-build.sh b/nix-build.sh index 43e38f3..29311eb 100755 --- a/nix-build.sh +++ b/nix-build.sh @@ -6,7 +6,7 @@ git add . git commit -m wip || true -git clean -nxd +git clean -fxd nix-shell \ --pure --run 'bash steps.sh' From 8e888d8168c0c34d7428bc733324dd92a3d63903 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:26:12 +0200 Subject: [PATCH 05/57] wip --- steps.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/steps.sh b/steps.sh index 41ed779..b8c6a72 100644 --- a/steps.sh +++ b/steps.sh @@ -3,3 +3,5 @@ set -euxo pipefail echo hello autoconf configure.ac > configure + +./configure From d488a3aafe4ef42edb8f5acc41d60a70b96c0ca4 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:26:25 +0200 Subject: [PATCH 06/57] wip --- steps.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/steps.sh b/steps.sh index b8c6a72..3226de4 100644 --- a/steps.sh +++ b/steps.sh @@ -3,5 +3,6 @@ set -euxo pipefail echo hello autoconf configure.ac > configure +chmod +x configure ./configure From bcb2513d62b645af1979c9f62a4f557e58298dbb Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:27:28 +0200 Subject: [PATCH 07/57] wip --- shell.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/shell.nix b/shell.nix index 43fc416..5680b58 100644 --- a/shell.nix +++ b/shell.nix @@ -7,6 +7,7 @@ pkgs.mkShell { pkgs.cowsay pkgs.which pkgs.autoconf + pkgs.gmp ]; shellHook = '' echo "Welcome to the development environment!" From e7e0a09d199b628f1949b11a35166a12811c1cf6 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:27:59 +0200 Subject: [PATCH 08/57] wip --- shell.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shell.nix b/shell.nix index 5680b58..681b1ca 100644 --- a/shell.nix +++ b/shell.nix @@ -4,10 +4,10 @@ pkgs.mkShell { buildInputs = [ - pkgs.cowsay pkgs.which pkgs.autoconf pkgs.gmp + pkgs.ecl ]; shellHook = '' echo "Welcome to the development environment!" From 716e8d26e70ffab17ac073a6287ff8853d6c019c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:28:24 +0200 Subject: [PATCH 09/57] wip --- shell.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/shell.nix b/shell.nix index 681b1ca..c4b4dee 100644 --- a/shell.nix +++ b/shell.nix @@ -8,6 +8,7 @@ pkgs.mkShell { pkgs.autoconf pkgs.gmp pkgs.ecl + pkgs.gecode ]; shellHook = '' echo "Welcome to the development environment!" From a3431faf1b0b0373997756435fda3e3c34274e0d Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:29:29 +0200 Subject: [PATCH 10/57] wip --- steps.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/steps.sh b/steps.sh index 3226de4..ee55c4e 100644 --- a/steps.sh +++ b/steps.sh @@ -6,3 +6,5 @@ autoconf configure.ac > configure chmod +x configure ./configure + +make From 3ed6b652308fa5fca38c9380bfb80a1649b9b377 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:29:56 +0200 Subject: [PATCH 11/57] wip --- steps.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/steps.sh b/steps.sh index ee55c4e..9cfc2a7 100644 --- a/steps.sh +++ b/steps.sh @@ -7,4 +7,6 @@ chmod +x configure ./configure +./scripts/generate-make-mk.sh + make From b516a219987d7154b889f642bb86d439af3fb171 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:30:48 +0200 Subject: [PATCH 12/57] wip --- shell.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/shell.nix b/shell.nix index c4b4dee..6377089 100644 --- a/shell.nix +++ b/shell.nix @@ -9,6 +9,7 @@ pkgs.mkShell { pkgs.gmp pkgs.ecl pkgs.gecode + pkgs.ragel ]; shellHook = '' echo "Welcome to the development environment!" From 0727741408a60c3408931e22c3aa4d0d88d28d4c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:37:43 +0200 Subject: [PATCH 13/57] wip --- ecl-cpp.nix | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++++ shell.nix | 8 ++++- 2 files changed, 99 insertions(+), 1 deletion(-) create mode 100644 ecl-cpp.nix diff --git a/ecl-cpp.nix b/ecl-cpp.nix new file mode 100644 index 0000000..c11f471 --- /dev/null +++ b/ecl-cpp.nix @@ -0,0 +1,92 @@ +{ lib +, stdenv +, fetchurl +, fetchpatch +, libtool +, autoconf +, automake +, texinfo +, gmp +, mpfr +, libffi +, makeWrapper +, noUnicode ? false +, gcc +, threadSupport ? true +, useBoehmgc ? false +, boehmgc +}: + +stdenv.mkDerivation rec { + pname = "ecl"; + version = "24.5.10"; + + src = fetchurl { + url = "https://common-lisp.net/project/ecl/static/files/release/ecl-${version}.tgz"; + hash = "sha256-5Opluxhh4OSVOGv6i8ZzvQFOltPPnZHpA4+RQ1y+Yis="; + }; + + nativeBuildInputs = [ + libtool + autoconf + automake + texinfo + makeWrapper + ]; + propagatedBuildInputs = [ + libffi + gmp + mpfr + gcc + # replaces ecl's own gc which other packages can depend on, thus propagated + ] ++ lib.optionals useBoehmgc [ + # replaces ecl's own gc which other packages can depend on, thus propagated + boehmgc + ]; + + patches = [ + # https://gitlab.com/embeddable-common-lisp/ecl/-/merge_requests/1 + (fetchpatch { + url = "https://raw.githubusercontent.com/sagemath/sage/9.2/build/pkgs/ecl/patches/write_error.patch"; + sha256 = "0hfxacpgn4919hg0mn4wf4m8r7y592r4gw7aqfnva7sckxi6w089"; + }) + ]; + + configureFlags = [ + (if threadSupport then "--enable-threads" else "--disable-threads") + "--with-gmp-incdir=${lib.getDev gmp}/include" + "--with-gmp-libdir=${lib.getLib gmp}/lib" + "--with-libffi-incdir=${lib.getDev libffi}/include" + "--with-libffi-libdir=${lib.getLib libffi}/lib" + ] ++ lib.optionals useBoehmgc [ + "--with-libgc-incdir=${lib.getDev boehmgc}/include" + "--with-libgc-libdir=${lib.getLib boehmgc}/lib" + ] ++ lib.optional (!noUnicode) "--enable-unicode"; + + hardeningDisable = [ "format" ]; + + # ECL’s ‘make check’ only works after install, making it a de-facto + # installCheck. + doInstallCheck = true; + installCheckTarget = "check"; + + postInstall = '' + sed -e 's/@[-a-zA-Z_]*@//g' -i $out/bin/ecl-config + wrapProgram "$out/bin/ecl" --prefix PATH ':' "${ + lib.makeBinPath [ + gcc # for the C compiler + gcc.bintools.bintools # for ar + ] + }" + ''; + + meta = with lib; { + description = "Lisp implementation aiming to be small, fast and easy to embed"; + homepage = "https://common-lisp.net/project/ecl/"; + license = licenses.mit; + mainProgram = "ecl"; + maintainers = lib.teams.lisp.members; + platforms = platforms.unix; + changelog = "https://gitlab.com/embeddable-common-lisp/ecl/-/raw/${version}/CHANGELOG"; + }; +} diff --git a/shell.nix b/shell.nix index 6377089..3cbd2a6 100644 --- a/shell.nix +++ b/shell.nix @@ -2,12 +2,18 @@ pkgs ? import { }, }: +let + +ecl_cpp = pkgs.callPackage ./ecl_cpp.nix {}; + +in + pkgs.mkShell { buildInputs = [ pkgs.which pkgs.autoconf pkgs.gmp - pkgs.ecl + ecl_cpp pkgs.gecode pkgs.ragel ]; From 04156867c26fe55b9c19b0c18bba3958c35980fa Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:38:00 +0200 Subject: [PATCH 14/57] wip --- shell.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shell.nix b/shell.nix index 3cbd2a6..fecab90 100644 --- a/shell.nix +++ b/shell.nix @@ -4,7 +4,7 @@ let -ecl_cpp = pkgs.callPackage ./ecl_cpp.nix {}; +ecl_cpp = pkgs.callPackage ./ecl-cpp.nix {}; in From 3960dbbefeccedc9bab751d67a4c105f39aff4cc Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:39:33 +0200 Subject: [PATCH 15/57] wip --- ecl-cpp.nix | 1 + 1 file changed, 1 insertion(+) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index c11f471..54ca1ab 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -55,6 +55,7 @@ stdenv.mkDerivation rec { configureFlags = [ (if threadSupport then "--enable-threads" else "--disable-threads") "--with-gmp-incdir=${lib.getDev gmp}/include" + "--with-blah=123" "--with-gmp-libdir=${lib.getLib gmp}/lib" "--with-libffi-incdir=${lib.getDev libffi}/include" "--with-libffi-libdir=${lib.getLib libffi}/lib" From c595b548797aa0d2a3530009dbe7913e0f0a9da6 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:45:20 +0200 Subject: [PATCH 16/57] wip --- ecl-cpp.nix | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 54ca1ab..8fc9c90 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -68,7 +68,8 @@ stdenv.mkDerivation rec { # ECL’s ‘make check’ only works after install, making it a de-facto # installCheck. - doInstallCheck = true; + # doInstallCheck = true; + doInstallCheck = false; installCheckTarget = "check"; postInstall = '' From e3bd168cdfbe491d03db6f2478bba7e2772385a0 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:50:08 +0200 Subject: [PATCH 17/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 8fc9c90..140090a 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -55,7 +55,7 @@ stdenv.mkDerivation rec { configureFlags = [ (if threadSupport then "--enable-threads" else "--disable-threads") "--with-gmp-incdir=${lib.getDev gmp}/include" - "--with-blah=123" + "--with-cxx" "--with-gmp-libdir=${lib.getLib gmp}/lib" "--with-libffi-incdir=${lib.getDev libffi}/include" "--with-libffi-libdir=${lib.getLib libffi}/lib" From 155e63f7a025fabc825268466b987460ae9734db Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:57:00 +0200 Subject: [PATCH 18/57] wip --- common/asgl-config/asgl-config.cxx | 222 ++ common/early/apx.cxx | 242 +++ common/early/cover.cxx | 72 + common/early/graph-input.cxx | 445 ++++ common/early/graph.cxx | 1485 +++++++++++++ common/early/package.cxx | 36 + common/early/utils.cxx | 589 +++++ ecl-cpp.nix | 2 +- lib/alexandria/arrays.cxx | 109 + lib/alexandria/binding.cxx | 339 +++ lib/alexandria/conditions.cxx | 395 ++++ lib/alexandria/control-flow.cxx | 860 ++++++++ lib/alexandria/definitions.cxx | 297 +++ lib/alexandria/features.cxx | 131 ++ lib/alexandria/functions.cxx | 1383 ++++++++++++ lib/alexandria/hash-tables.cxx | 676 ++++++ lib/alexandria/io.cxx | 1014 +++++++++ lib/alexandria/lists.cxx | 3195 ++++++++++++++++++++++++++++ lib/alexandria/macros.cxx | 1497 +++++++++++++ lib/alexandria/numbers.cxx | 1656 ++++++++++++++ lib/alexandria/package.cxx | 36 + lib/alexandria/sequences.cxx | 2721 +++++++++++++++++++++++ lib/alexandria/strings.cxx | 65 + lib/alexandria/symbols.cxx | 356 ++++ lib/alexandria/types.cxx | 2164 +++++++++++++++++++ 25 files changed, 19986 insertions(+), 1 deletion(-) create mode 100644 common/asgl-config/asgl-config.cxx create mode 100644 common/early/apx.cxx create mode 100644 common/early/cover.cxx create mode 100644 common/early/graph-input.cxx create mode 100644 common/early/graph.cxx create mode 100644 common/early/package.cxx create mode 100644 common/early/utils.cxx create mode 100644 lib/alexandria/arrays.cxx create mode 100644 lib/alexandria/binding.cxx create mode 100644 lib/alexandria/conditions.cxx create mode 100644 lib/alexandria/control-flow.cxx create mode 100644 lib/alexandria/definitions.cxx create mode 100644 lib/alexandria/features.cxx create mode 100644 lib/alexandria/functions.cxx create mode 100644 lib/alexandria/hash-tables.cxx create mode 100644 lib/alexandria/io.cxx create mode 100644 lib/alexandria/lists.cxx create mode 100644 lib/alexandria/macros.cxx create mode 100644 lib/alexandria/numbers.cxx create mode 100644 lib/alexandria/package.cxx create mode 100644 lib/alexandria/sequences.cxx create mode 100644 lib/alexandria/strings.cxx create mode 100644 lib/alexandria/symbols.cxx create mode 100644 lib/alexandria/types.cxx diff --git a/common/asgl-config/asgl-config.cxx b/common/asgl-config/asgl-config.cxx new file mode 100644 index 0000000..e7e4a23 --- /dev/null +++ b/common/asgl-config/asgl-config.cxx @@ -0,0 +1,222 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:54 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/asgl-config/asgl-config.lisp */ +#include +#include "common/asgl-config/asgl-config.eclh" +/* function definition for HAVE-GECODE-GIST-HH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1have_gecode_gist_hh() +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v1; + { + int v2; + { +int res; +#ifdef HAVE_GECODE_GIST_HH +res = 0; +#else +res = 1; +#endif +v2= res; +} + v1 = (cl_fixnum)(v2); + } + value0 = ecl_make_bool((v1)==0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ENABLE-COVER */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L2enable_cover() +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v1; + { + int v2; + { +int res; +#ifdef ENABLE_COVER +res = 0; +#else +res = 1; +#endif +v2= res; +} + v1 = (cl_fixnum)(v2); + } + value0 = ecl_make_bool((v1)==0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ENABLE-TIMING */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L3enable_timing() +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v1; + { + int v2; + { +int res; +#ifdef ENABLE_TIMING +res = 0; +#else +res = 1; +#endif +v2= res; +} + v1 = (cl_fixnum)(v2); + } + value0 = ecl_make_bool((v1)==0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ENABLE-LOGGING */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4enable_logging() +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v1; + { + int v2; + { +int res; +#ifdef ENABLE_LOGGING +res = 0; +#else +res = 1; +#endif +v2= res; +} + v1 = (cl_fixnum)(v2); + } + value0 = ecl_make_bool((v1)==0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ENABLE-FOBJ-LEAK-CHECKS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5enable_fobj_leak_checks() +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v1; + { + int v2; + { +int res; +#ifdef ENABLE_FOBJ_LEAK_CHECKS +res = 0; +#else +res = 1; +#endif +v2= res; +} + v1 = (cl_fixnum)(v2); + } + value0 = ecl_make_bool((v1)==0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} + +#include "common/asgl-config/asgl-config.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclXWUiJ5qKAXSIM_ObCycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/asgl-config/asgl-config.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclXWUiJ5qKAXSIM_ObCycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + ecl_function_dispatch(cl_env_copy,VV[10])(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[11]); /* HAVE-GECODE-GIST-HH */ + if (Null(L1have_gecode_gist_hh())) { goto L9; } + cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[1],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); +L9:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[4], VVtemp[5]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[12]); /* ENABLE-COVER */ + if (Null(L2enable_cover())) { goto L17; } + cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[3],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); +L17:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[13]); /* ENABLE-TIMING */ + if (Null(L3enable_timing())) { goto L25; } + cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[5],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); +L25:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[14]); /* ENABLE-LOGGING */ + if (Null(L4enable_logging())) { goto L33; } + cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[7],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); +L33:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[15]); /* ENABLE-FOBJ-LEAK-CHECKS */ + if (Null(L5enable_fobj_leak_checks())) { goto L41; } + cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[9],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); +L41:; +} diff --git a/common/early/apx.cxx b/common/early/apx.cxx new file mode 100644 index 0000000..7f7206f --- /dev/null +++ b/common/early/apx.cxx @@ -0,0 +1,242 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/early/apx.lisp */ +#include +#include "common/early/apx.eclh" +/* function definition for HASH-TABLE2VECTOR */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L1hash_table2vector(cl_object v1hash, cl_object v2vector) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4k; + cl_object v5v; + v3 = ECL_NIL; + v4k = ECL_NIL; + v5v = ECL_NIL; + { + cl_object v6; + v6 = si_hash_table_iterator(v1hash); +L5:; + { + cl_object v8; + cl_object v9; + cl_object v10; + value0 = ecl_function_dispatch(cl_env_copy,v6)(0); + { + const int v11 = cl_env_copy->nvalues; + v8 = value0; + cl_object v12; + v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1]; + v9 = v12; + v12 = (v11<=2)? ECL_NIL : cl_env_copy->values[2]; + v10 = v12; + } + if (Null(v8)) { goto L10; } + v5v = v10; + v4k = v9; +L10:; + v3 = v8; + if ((v3)!=ECL_NIL) { goto L7; } + } + goto L6; +L7:; + { + cl_object v7; + v7 = v2vector; + T0 = v7; + { + cl_fixnum v8; + { + cl_object v9; + v9 = v5v; + if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = ecl_fixnum(v9); + } + ecl_aset_unsafe(T0,v8,v4k); + } + } + goto L5; +L6:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* local function WITH-APX-READTABLE */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC2with_apx_readtable(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[8])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4 = v5; + } + if (Null(v4)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[9])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + value0 = cl_listX(4, ECL_SYM("LET",479), VV[2], VV[3], v3); + return value0; + } + } +} +/* function definition for READ-APX-FILE */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L4read_apx_file(cl_object v1pathname) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + if ((cl_probe_file(v1pathname))!=ECL_NIL) { goto L1; } + cl_error(2, VV[5], v1pathname); +L1:; + { + cl_object v3; /* BUFFER */ + cl_object v4; /* SIZE */ + T0 = cl_merge_pathnames(1, v1pathname); + T1 = cl_namestring(T0); + T2 = ecl_function_dispatch(cl_env_copy,VV[11])(4, T1, ECL_SYM("BASE-CHAR",122), ECL_SYM("*",20), ECL_NIL) /* COERCE-TO-VECTOR */; + { + void* v5; + long v6; + { +long msize = 99; + +v5= slurp_file(T2, &msize); +v6= msize; +} + cl_env_copy->values[0] = ecl_make_pointer(v5); + cl_env_copy->values[1] = ecl_make_long(v6);cl_env_copy->nvalues = 2; + value0 = cl_env_copy->values[0]; + } + { + v3 = value0; + v4 = cl_env_copy->values[1]; + } + { + cl_fixnum v5arg_count; + { + int v6; + { v6= count_args((char*)ecl_to_pointer(v3), ecl_to_long(v4)); } + v5arg_count = (cl_fixnum)(v6); + } + { + cl_object v6; + cl_object v7; + cl_object v8; + cl_object v9hash; + cl_object env1 = env0; + v6 = si_make_pure_array(ECL_T, ecl_make_fixnum(v5arg_count), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + T0 = (ECL_SYM("EQUAL",337)->symbol.gfdef); + v7 = cl_make_hash_table(2, ECL_SYM("TEST",1350), T0); + v8 = si_make_pure_array(ECL_T, ecl_make_fixnum(v5arg_count), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + v9hash = v7; + env1 = ECL_NIL; + CLV0 = env1 = CONS(v8,env1); /* GRAPH */ + { + cl_object v10; + v10 = ecl_make_cclosure_va((cl_objectfn)LC3__lambda63,env1,Cblock,2); + T0 = v10; + } + { ragel_apx_parse((char*)ecl_to_pointer(v3), ecl_to_long(v4), v9hash, T0); } + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + L1hash_table2vector(v9hash, v6); + cl_env_copy->nvalues = 3; + cl_env_copy->values[2] = v9hash; + cl_env_copy->values[1] = v6; + cl_env_copy->values[0] = ECL_CONS_CAR(CLV0); + return cl_env_copy->values[0]; + } + } + } + } +} +/* closure LAMBDA63 */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC3__lambda63(cl_narg narg, cl_object v1from, cl_object v2to, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV0 = env0; /* GRAPH */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,VV[12])(3, ECL_CONS_CAR(CLV0), v1from, v2to) /* ADD-EDGE */; + return value0; + } + } +} + +#include "common/early/apx.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclqMFRzztbaOQJM_7uDycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/apx.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclqMFRzztbaOQJM_7uDycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[6]); /* HASH-TABLE2VECTOR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[7]); /* WITH-APX-READTABLE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[10]); /* READ-APX-FILE */ +} diff --git a/common/early/cover.cxx b/common/early/cover.cxx new file mode 100644 index 0000000..a8cf57e --- /dev/null +++ b/common/early/cover.cxx @@ -0,0 +1,72 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:54 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/early/cover.lisp */ +#include +#include "common/early/cover.eclh" +/* local function ANNOTATE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1annotate(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4t_or_nil; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[3])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4t_or_nil = v5; + } + if (Null(v3)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[4])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} + +#include "common/early/cover.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclO8FY5RRFEZrGM_brCycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/cover.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclO8FY5RRFEZrGM_brCycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + ecl_function_dispatch(cl_env_copy,VV[1])(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, VVtemp[2], ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[4], VVtemp[5]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[6]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[2]); /* ANNOTATE */ +} diff --git a/common/early/graph-input.cxx b/common/early/graph-input.cxx new file mode 100644 index 0000000..bde8de9 --- /dev/null +++ b/common/early/graph-input.cxx @@ -0,0 +1,445 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/early/graph-input.lisp */ +#include +#include "common/early/graph-input.eclh" +/* local function READ-GRAPH-INPUT */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC1read_graph_input(cl_object v1input) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* READ-APX-FILE */; + return value0; + } +} +/* local function READ-GRAPH-INPUT */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC2read_graph_input(cl_object v1input) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* READ-APX-FILE */; + return value0; + } +} +/* local function READ-GRAPH-INPUT */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC3read_graph_input(cl_object v1input) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v2items; + { + cl_object v3; + cl_object v4; + cl_object v5i; + v3 = ecl_function_dispatch(cl_env_copy,VV[4])(1, v1input) /* ORDER */; + { + cl_object v6; + v6 = v3; + { + bool v7; + v7 = ecl_numberp(v6); + if (ecl_unlikely(!(v7))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v6); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v4 = v6; + } + v5i = ecl_make_fixnum(0); + { + cl_object v6; + cl_object v7; + v6 = ecl_list1(ECL_NIL); + v7 = v6; +L9:; + if (!(ecl_greatereq(v5i,v4))) { goto L11; } + goto L10; +L11:; + { + cl_object v8; + v8 = v7; + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v8; + } + v7 = ecl_list1(v5i); + (ECL_CONS_CDR(T0)=v7,T0); + v5i = ecl_one_plus(v5i); + goto L9; +L10:; + v2items = _ecl_cdr(v6); + goto L1; + } + } +L1:; + T0 = ecl_function_dispatch(cl_env_copy,VV[4])(1, v1input) /* ORDER */; + T1 = cl_make_array(3, T0, ECL_SYM("INITIAL-CONTENTS",1284), v2items); + { + cl_object v3hash; + v3hash = cl_make_hash_table(0); + { + cl_object v4; + v4 = v2items; + goto L28; +L27:; + { + cl_object v5item; + v5item = ECL_CONS_CAR(v4); + si_hash_set(v5item, v3hash, v5item); + } + v4 = ECL_CONS_CDR(v4); +L28:; + if (Null(v4)) { goto L35; } + goto L27; +L35:; + } + T2 = v3hash; + } + cl_env_copy->nvalues = 3; + cl_env_copy->values[2] = T2; + cl_env_copy->values[1] = T1; + cl_env_copy->values[0] = v1input; + return cl_env_copy->values[0]; + } + } +} +/* local function READ-GRAPH-INPUT */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC4read_graph_input(cl_object v1input) +{ + cl_object T0, T1, T2, T3; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v2; + cl_fixnum v3order; + v2 = v1input; + { + cl_object v4; + if (!(v2==ECL_NIL)) { goto L4; } + ecl_function_dispatch(cl_env_copy,VV[5])(1, v1input) /* DM-TOO-FEW-ARGUMENTS */; +L4:; + { + cl_object v5; + v5 = ECL_CONS_CAR(v2); + v2 = ECL_CONS_CDR(v2); + v4 = v5; + } + { + bool v5; + v5 = ECL_FIXNUMP(v4); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(ECL_SYM("FIXNUM",374),v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v3order = ecl_fixnum(v4); + } + { + cl_object v4; + cl_object v5; + cl_object v6; + v4 = ecl_make_integer((v3order)-1); + T0 = ecl_expt(ecl_make_fixnum(2),ecl_make_fixnum(v3order)); + v5 = ecl_one_minus(T0); + T0 = si_make_pure_array(ECL_T, ecl_make_fixnum(v3order), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + v6 = si_fill_array_with_elt(T0, ECL_NIL, ecl_make_fixnum(0), ECL_NIL); + { + cl_object v7i; + v7i = ecl_make_fixnum(0); + { + cl_object v8; + cl_object v9position; + T0 = ecl_make_integer((v3order)-1); + v8 = ecl_times(ecl_make_fixnum(v3order),T0); + v9position = v8; + { + cl_object v10row; + v10row = ECL_NIL; + if (!(ecl_greatereq(v7i,ecl_make_fixnum(v3order)))) { goto L20; } + goto L19; +L20:; +L18:; + { + cl_object v11; + cl_object v12; + { + cl_object v13; + v13 = ecl_make_fixnum(v3order); + { + cl_object v14; + v14 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L30; } + v14 = v13; + T0 = ecl_make_bool(ecl_greatereq(v14,ecl_make_fixnum(0))); + goto L27; +L30:; + T0 = ECL_NIL; + goto L27; + } +L27:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",887),v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v13; + } + { + cl_object v13; + v13 = v9position; + { + cl_object v14; + v14 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L40; } + v14 = v13; + T0 = ecl_make_bool(ecl_greatereq(v14,ecl_make_fixnum(0))); + goto L37; +L40:; + T0 = ECL_NIL; + goto L37; + } +L37:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",887),v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v12 = v13; + } + T0 = cl_ash(ecl_make_fixnum(-1), v11); + T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1)); + T2 = ecl_negate(v12); + T3 = cl_ash(v2, T2); + v10row = ecl_boole(ECL_BOOLAND,(T1),(T3)); + } + { + cl_object v11; + v11 = ecl_make_bool(ecl_zerop(v10row)); + if (Null(v11)) { goto L46; } + goto L44; +L46:; + if (!(ecl_eql(v10row,v5))) { goto L48; } + { + cl_fixnum v12j; + v12j = 0; + goto L52; +L51:; + { + cl_object v13; + cl_object v14; + v13 = ecl_minus(v4,ecl_make_fixnum(v12j)); + { + cl_object v15; + v15 = v6; + T1 = v15; + { + cl_fixnum v16; + { + cl_object v17; + v17 = v13; + if (ecl_unlikely((ecl_fixnum(v17))>=(v15)->vector.dim)) + FEwrong_index(ECL_NIL,v15,-1,ecl_make_fixnum(ecl_fixnum(v17)),(v15)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v16 = ecl_fixnum(v17); + } + T0 = ecl_aref_unsafe(T1,v16); + } + } + v14 = CONS(v7i,T0); + { + cl_object v15; + v15 = v6; + T0 = v15; + { + cl_fixnum v16; + { + cl_object v17; + v17 = v13; + if (ecl_unlikely((ecl_fixnum(v17))>=(v15)->vector.dim)) + FEwrong_index(ECL_NIL,v15,-1,ecl_make_fixnum(ecl_fixnum(v17)),(v15)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v16 = ecl_fixnum(v17); + } + ecl_aset_unsafe(T0,v16,v14); + } + } + } + v12j = (v12j)+1; +L52:; + if (!((v12j)<(v3order))) { goto L70; } + goto L51; +L70:; + goto L44; + } +L48:; + { + cl_fixnum v13j; + v13j = 0; + goto L74; +L73:; + if (Null(cl_logbitp(ecl_make_fixnum(v13j), v10row))) { goto L76; } + { + cl_object v14; + cl_object v15; + v14 = ecl_minus(v4,ecl_make_fixnum(v13j)); + { + cl_object v16; + v16 = v6; + T1 = v16; + { + cl_fixnum v17; + { + cl_object v18; + v18 = v14; + if (ecl_unlikely((ecl_fixnum(v18))>=(v16)->vector.dim)) + FEwrong_index(ECL_NIL,v16,-1,ecl_make_fixnum(ecl_fixnum(v18)),(v16)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v17 = ecl_fixnum(v18); + } + T0 = ecl_aref_unsafe(T1,v17); + } + } + v15 = CONS(v7i,T0); + { + cl_object v16; + v16 = v6; + T0 = v16; + { + cl_fixnum v17; + { + cl_object v18; + v18 = v14; + if (ecl_unlikely((ecl_fixnum(v18))>=(v16)->vector.dim)) + FEwrong_index(ECL_NIL,v16,-1,ecl_make_fixnum(ecl_fixnum(v18)),(v16)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v17 = ecl_fixnum(v18); + } + ecl_aset_unsafe(T0,v17,v15); + } + } + } +L76:; + v13j = (v13j)+1; +L74:; + if (!((v13j)<(v3order))) { goto L93; } + goto L73; +L93:; + } + } +L44:; + v7i = ecl_one_plus(v7i); + if (!(ecl_greatereq(v7i,ecl_make_fixnum(v3order)))) { goto L97; } + goto L19; +L97:; + v9position = ecl_minus(v9position,ecl_make_fixnum(v3order)); + goto L18; +L19:; + } + } + } + value0 = ecl_function_dispatch(cl_env_copy,VV[0])(1, v6) /* READ-GRAPH-INPUT */; + return value0; + } + } + } +} + +#include "common/early/graph-input.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclkTNz1HtborJCM_MODycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph-input.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclkTNz1HtborJCM_MODycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",944)->symbol.gfdef))->cfun.entry(5, VV[0], VV[1], ECL_T, ECL_SYM("LAMBDA-LIST",1000), VVtemp[4]) /* ENSURE-GENERIC-FUNCTION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC1read_graph_input,ECL_NIL,Cblock,1); + T0 = v1; + } + ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[7], VVtemp[4], T0) /* INSTALL-METHOD */; + } + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC2read_graph_input,ECL_NIL,Cblock,1); + T0 = v1; + } + ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[10], VVtemp[4], T0) /* INSTALL-METHOD */; + } + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC3read_graph_input,ECL_NIL,Cblock,1); + T0 = v1; + } + ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[13], VVtemp[4], T0) /* INSTALL-METHOD */; + } + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC4read_graph_input,ECL_NIL,Cblock,1); + T0 = v1; + } + ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[16], VVtemp[4], T0) /* INSTALL-METHOD */; + } +} diff --git a/common/early/graph.cxx b/common/early/graph.cxx new file mode 100644 index 0000000..6a3d184 --- /dev/null +++ b/common/early/graph.cxx @@ -0,0 +1,1485 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/early/graph.lisp */ +#include +#include "common/early/graph.eclh" +/* function definition for %%ORDER */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L1__order(cl_object v1graph) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v1graph) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v1graph); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + value0 = ecl_make_fixnum(ecl_length(v1graph)); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for %%PARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L2__parents(cl_object v1graph, cl_object v2node) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v1graph) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v1graph); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + bool v3; + v3 = ECL_FIXNUMP(v2node); + if (ecl_unlikely(!(v3))) + FEwrong_type_argument(VV[1],v2node); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + { + cl_object v3; + v3 = v1graph; + T0 = v3; + { + cl_fixnum v4; + { + cl_fixnum v5; + v5 = ecl_fixnum(v2node); + if (ecl_unlikely((v5)>=(v3)->vector.dim)) + FEwrong_index(ECL_NIL,v3,-1,ecl_make_fixnum(v5),(v3)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v4 = v5; + } + value0 = ecl_aref_unsafe(T0,v4); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* function definition for (SETF %%PARENTS) */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L3_setf___parents_(cl_object v1value, cl_object v2graph, cl_object v3node) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v2graph) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v2graph); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + bool v4; + v4 = ECL_FIXNUMP(v3node); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(VV[1],v3node); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + { + cl_object v4; + v4 = v2graph; + T0 = v4; + { + cl_fixnum v5; + { + cl_fixnum v6; + v6 = ecl_fixnum(v3node); + if (ecl_unlikely((v6)>=(v4)->vector.dim)) + FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = v6; + } + value0 = ecl_aset_unsafe(T0,v5,v1value); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* local function DO-%%PARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC4do___parents(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6node; + cl_object v7parents; + cl_object v8return; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4 = v9; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v6node = v9; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v7parents = v9; + } + if (Null(v5)) { goto L22; } + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v8return = v9; + goto L21; + } +L22:; + v8return = ECL_NIL; +L21:; + if (Null(v5)) { goto L27; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L27:; + T0 = cl_list(3, v6node, v7parents, v8return); + T1 = ecl_append(v3,VV[6]); + value0 = cl_listX(3, ECL_SYM("DOLIST",315), T0, T1); + return value0; + } + } +} +/* function definition for %%PARENTS-ADD */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L5__parents_add(cl_object v1node, cl_object v2parents) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + bool v3; + v3 = ECL_FIXNUMP(v1node); + if (ecl_unlikely(!(v3))) + FEwrong_type_argument(VV[1],v1node); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + value0 = CONS(v1node,v2parents); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function %%PUSH-PARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC6__push_parents(cl_object v1, cl_object v2env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4obj; + cl_object v5place; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4obj = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v5place = v6; + } + if (Null(v3)) { goto L14; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L14:; + { + cl_object v7; /* DUMMIES */ + cl_object v8; /* VALS */ + cl_object v9; /* NEWVAL */ + cl_object v10; /* SETTER */ + cl_object v11; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v5place, v2env) /* GET-SETF-EXPANSION */; + { + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; + } + { + cl_object v12g; + v12g = cl_gensym(0); + T0 = cl_list(2, v12g, v4obj); + { + cl_object v13; + v13 = (ECL_SYM("LIST",483)->symbol.gfdef); + { + cl_object v14; + cl_object v15; + v14 = ECL_NIL; + { + cl_object v16; + v16 = v7; + if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v15 = v16; + } + { + cl_object v16; + cl_object v17; + v16 = ECL_NIL; + { + cl_object v18; + v18 = v8; + if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v17 = v18; + } + { + cl_object v18; + cl_object v19; + v18 = ecl_list1(ECL_NIL); + v19 = v18; +L30:; + if (!(v15==ECL_NIL)) { goto L32; } + goto L31; +L32:; + v14 = ECL_CONS_CAR(v15); + { + cl_object v20; + v20 = ECL_CONS_CDR(v15); + if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v15 = v20; + } + if (!(v17==ECL_NIL)) { goto L40; } + goto L31; +L40:; + v16 = ECL_CONS_CAR(v17); + { + cl_object v20; + v20 = ECL_CONS_CDR(v17); + if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v17 = v20; + } + { + cl_object v20; + v20 = v19; + if (ecl_unlikely(ECL_ATOM(v20))) FEtype_error_cons(v20); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T2 = v20; + } + T3 = ecl_function_dispatch(cl_env_copy,v13)(2, v14, v16); + v19 = ecl_list1(T3); + (ECL_CONS_CDR(T2)=v19,T2); + goto L30; +L31:; + T1 = _ecl_cdr(v18); + goto L18; + } + } + } + } +L18:; + T2 = _ecl_car(v9); + T3 = cl_list(3, VV[7], v12g, v11); + T4 = cl_list(2, T2, T3); + T5 = _ecl_cdr(v9); + T6 = CONS(T4,T5); + T7 = ecl_append(T1,T6); + T8 = CONS(T0,T7); + value0 = cl_list(3, ECL_SYM("LET*",480), T8, v10); + return value0; + } + } + } + } +} +/* function definition for ORDER */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L7order(cl_object v1graph) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v2graph; + { + cl_object v3; + v3 = v1graph; + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v3) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v3); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v2graph = v3; + } + value0 = ecl_make_fixnum(ecl_length(v2graph)); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for SIZE */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L8size(cl_object v1graph) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = (ECL_SYM("+",16)->symbol.gfdef); + T1 = (ECL_SYM("LENGTH",478)->symbol.gfdef); + value0 = cl_reduce(4, T0, v1graph, ECL_SYM("KEY",1294), T1); + return value0; + } +} +/* function definition for INDEGREES */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L9indegrees(cl_object v1graph) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = (ECL_SYM("LENGTH",478)->symbol.gfdef); + value0 = cl_map(3, ECL_SYM("VECTOR",900), T0, v1graph); + return value0; + } +} +/* local function DO-EDGES */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC10do_edges(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6from; + cl_object v7to; + cl_object v8graph; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4 = v9; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v6from = v9; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v7to = v9; + } + if (!(v5==ECL_NIL)) { goto L22; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L22:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v8graph = v9; + } + if (Null(v5)) { goto L27; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L27:; + T0 = cl_list(2, v6from, v7to); + T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + value0 = cl_list(3, VV[14], T1, v8graph); + return value0; + } + } +} +/* local function DO-PARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC11do_parents(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6node; + cl_object v7parents; + cl_object v8graph; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4 = v9; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v6node = v9; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v7parents = v9; + } + if (!(v5==ECL_NIL)) { goto L22; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L22:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v8graph = v9; + } + if (Null(v5)) { goto L27; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L27:; + T0 = cl_list(2, v6node, v7parents); + T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + value0 = cl_list(3, VV[16], T1, v8graph); + return value0; + } + } +} +/* local function DO-PARENTS-GRANDPARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC12do_parents_grandparents(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6node; + cl_object v7parents_grandparents; + cl_object v8graph; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4 = v9; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v6node = v9; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v7parents_grandparents = v9; + } + if (!(v5==ECL_NIL)) { goto L22; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L22:; + { + cl_object v9; + v9 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v8graph = v9; + } + if (Null(v5)) { goto L27; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L27:; + T0 = cl_list(2, v6node, v7parents_grandparents); + T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + value0 = cl_list(3, VV[18], T1, v8graph); + return value0; + } + } +} +/* function definition for OUTDEGREES */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L14outdegrees(cl_object v1graph) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object env1 = env0; + { + cl_object v2; + v2 = L7order(v1graph); + T1 = si_make_pure_array(ECL_T, v2, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + T0 = si_fill_array_with_elt(T1, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); + } + env1 = ECL_NIL; + CLV0 = env1 = CONS(T0,env1); /* VECTOR */ + { + cl_object v2; + v2 = ecl_make_cclosure_va((cl_objectfn)LC13__lambda100,env1,Cblock,2); + T0 = v2; + } + L19map_edges(T0, v1graph); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA100 */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC13__lambda100(cl_narg narg, cl_object v1from, cl_object v2to, ...) +{ + cl_object T0, T1; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV0 = env0; /* VECTOR */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v3; + { + cl_object v4; + v4 = ECL_CONS_CAR(CLV0); + T1 = v4; + { + cl_fixnum v5; + { + cl_object v6; + v6 = v1from; + if (ecl_unlikely((ecl_fixnum(v6))>=(v4)->vector.dim)) + FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(ecl_fixnum(v6)),(v4)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = ecl_fixnum(v6); + } + T0 = ecl_aref_unsafe(T1,v5); + } + } + v3 = ecl_plus(T0,ecl_make_fixnum(1)); + { + cl_object v4; + v4 = ECL_CONS_CAR(CLV0); + T0 = v4; + { + cl_fixnum v5; + { + cl_object v6; + v6 = v1from; + if (ecl_unlikely((ecl_fixnum(v6))>=(v4)->vector.dim)) + FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(ecl_fixnum(v6)),(v4)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = ecl_fixnum(v6); + } + value0 = ecl_aset_unsafe(T0,v5,v3); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } + } +} +/* function definition for ADD-EDGE */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v4; + { + cl_object v5; + cl_fixnum v6node; + { + cl_object v7graph; + cl_fixnum v8node; + { + cl_object v9; + v9 = v1graph; + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v9) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7graph = v9; + } + { + cl_object v9; + v9 = v3to; + { + bool v10; + v10 = ECL_FIXNUMP(v9); + if (ecl_unlikely(!(v10))) + FEwrong_type_argument(VV[1],v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v8node = ecl_fixnum(v9); + } + { + cl_object v9; + v9 = v7graph; + T0 = v9; + { + cl_fixnum v10; + { + cl_fixnum v11; + v11 = v8node; + if (ecl_unlikely((v11)>=(v9)->vector.dim)) + FEwrong_index(ECL_NIL,v9,-1,ecl_make_fixnum(v11),(v9)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v10 = v11; + } + v5 = ecl_aref_unsafe(T0,v10); + } + } + } + { + cl_object v7; + v7 = v2from; + { + bool v8; + v8 = ECL_FIXNUMP(v7); + if (ecl_unlikely(!(v8))) + FEwrong_type_argument(VV[1],v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v6node = ecl_fixnum(v7); + } + v4 = CONS(ecl_make_fixnum(v6node),v5); + } + { + cl_object v5graph; + cl_fixnum v6node; + { + cl_object v7; + v7 = v1graph; + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v7) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5graph = v7; + } + { + cl_object v7; + v7 = v3to; + { + bool v8; + v8 = ECL_FIXNUMP(v7); + if (ecl_unlikely(!(v8))) + FEwrong_type_argument(VV[1],v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v6node = ecl_fixnum(v7); + } + { + cl_object v7; + v7 = v5graph; + T0 = v7; + { + cl_fixnum v8; + { + cl_fixnum v9; + v9 = v6node; + if (ecl_unlikely((v9)>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(v9),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v9; + } + value0 = ecl_aset_unsafe(T0,v8,v4); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } + } +} +/* function definition for MAKE-GRAPH-FROM-ADJ */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L16make_graph_from_adj(cl_object v1adj) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_fixnum v2order; + cl_object v3graph; + v2order = ecl_array_dimension(v1adj,0); + v3graph = si_make_pure_array(ECL_T, ecl_make_fixnum(v2order), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + { + cl_object v4i; + v4i = ecl_make_fixnum(0); + goto L6; +L5:; + { + cl_object v5j; + v5j = ecl_make_fixnum(0); + goto L11; +L10:; + { + cl_object v6; + v6 = v1adj; + T1 = v6; + { + cl_fixnum v7; + { + cl_fixnum v8dim6; + cl_fixnum v9dim7; + cl_fixnum v10; + v8dim6 = (v6)->array.dims[0]; + v9dim7 = (v6)->array.dims[1]; + v10 = 0; + if (ecl_unlikely((v6)->array.rank != (2))) + FEwrong_dimensions(v6,2); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_fixnum v11; + v11 = ecl_fixnum(v4i); + if (ecl_unlikely((v11)>=(v8dim6))) + FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v11),v8dim6); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v10 = (v10)+(v11); + } + v10 = (v10)*(v9dim7); + { + cl_fixnum v11; + v11 = ecl_fixnum(v5j); + if (ecl_unlikely((v11)>=(v9dim7))) + FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v11),v9dim7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v10 = (v10)+(v11); + } + v7 = v10; + } + T0 = ecl_aref_unsafe(T1,v7); + } + } + if (!((ecl_make_fixnum(1))==(T0))) { goto L13; } + L15add_edge(v3graph, v4i, v5j); +L13:; + v5j = ecl_one_plus(v5j); +L11:; + if (!(ecl_lower(v5j,ecl_make_fixnum(v2order)))) { goto L35; } + goto L10; +L35:; + } + v4i = ecl_one_plus(v4i); +L6:; + if (!(ecl_lower(v4i,ecl_make_fixnum(v2order)))) { goto L39; } + goto L5; +L39:; + } + value0 = v3graph; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MAP-NODES */ +/* optimize speed 3, debug 0, space 0, safety 0 */ +static cl_object L17map_nodes(cl_object v1fn, cl_object v2graph) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; +TTL: + { + cl_fixnum v3; + v3 = ecl_length(v2graph); + { + cl_fixnum v4node; + v4node = 0; + goto L4; +L3:; + ecl_function_dispatch(cl_env_copy,v1fn)(1, ecl_make_fixnum(v4node)); + v4node = (v4node)+1; +L4:; + if (!((v4node)<(v3))) { goto L9; } + goto L3; +L9:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function DO-NODES */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC18do_nodes(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6node; + cl_object v7graph; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v8; + v8 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4 = v8; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v8; + v8 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v6node = v8; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v8; + v8 = ECL_CONS_CAR(v5); + v5 = ECL_CONS_CDR(v5); + v7graph = v8; + } + if (Null(v5)) { goto L21; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L21:; + T0 = ecl_list1(v6node); + T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + value0 = cl_list(3, VV[22], T1, v7graph); + return value0; + } + } +} +/* function definition for MAP-EDGES */ +/* optimize speed 3, debug 0, space 0, safety 0 */ +static cl_object L19map_edges(cl_object v1fn, cl_object v2graph) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; +TTL: + { + cl_fixnum v3; + v3 = ecl_length(v2graph); + { + cl_fixnum v4i; + v4i = 0; + goto L4; +L3:; + { + cl_object v5; + { + cl_object v6; + v6 = v2graph; + T0 = v6; + { + cl_fixnum v7; + { + cl_fixnum v8; + v8 = v4i; + if (ecl_unlikely((v8)>=(v6)->vector.dim)) + FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v8),(v6)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v8; + } + v5 = ecl_aref_unsafe(T0,v7); + } + } + goto L15; +L14:; + { + cl_object v6j; + v6j = _ecl_car(v5); + ecl_function_dispatch(cl_env_copy,v1fn)(2, v6j, ecl_make_fixnum(v4i)); + } + v5 = _ecl_cdr(v5); +L15:; + if (Null(v5)) { goto L22; } + goto L14; +L22:; + } + v4i = (v4i)+1; +L4:; + if (!((v4i)<(v3))) { goto L26; } + goto L3; +L26:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MAP-PARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L21map_parents(cl_object v1fn, cl_object v2graph) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1fn,env0); /* FN */ + CLV1 = env0 = CONS(v2graph,env0); /* GRAPH */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC20__lambda190,env0,Cblock,1); + T0 = v3; + } + value0 = L17map_nodes(T0, ECL_CONS_CAR(CLV1)); + return value0; + } +} +/* closure LAMBDA190 */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC20__lambda190(cl_narg narg, cl_object v1node, ...) +{ + cl_object T0, T1; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* GRAPH */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v2graph; + cl_fixnum v3node; + { + cl_object v4; + v4 = ECL_CONS_CAR(CLV1); + T1 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v4) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T1)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v2graph = v4; + } + { + cl_object v4; + v4 = v1node; + { + bool v5; + v5 = ECL_FIXNUMP(v4); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(VV[1],v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v3node = ecl_fixnum(v4); + } + { + cl_object v4; + v4 = v2graph; + T1 = v4; + { + cl_fixnum v5; + { + cl_fixnum v6; + v6 = v3node; + if (ecl_unlikely((v6)>=(v4)->vector.dim)) + FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = v6; + } + T0 = ecl_aref_unsafe(T1,v5); + } + } + } + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, v1node, T0); + return value0; + } + } +} +/* function definition for MAP-PARENTS-GRANDPARENTS */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L24map_parents_grandparents(cl_object v1fn, cl_object v2graph) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1fn,env0); /* FN */ + CLV1 = env0 = CONS(v2graph,env0); /* GRAPH */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC23__lambda193,env0,Cblock,2); + T0 = v3; + } + value0 = L21map_parents(T0, ECL_CONS_CAR(CLV1)); + return value0; + } +} +/* closure LAMBDA193 */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC23__lambda193(cl_narg narg, cl_object v1node, cl_object v2parents, ...) +{ + cl_object T0, T1, T2; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* GRAPH */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v3; + v3 = (ECL_SYM("CONS",253)->symbol.gfdef); + { + cl_object v4; + cl_object v5; + v4 = ECL_NIL; + { + cl_object v6; + v6 = v2parents; + if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = v6; + } + { + cl_object v6; + cl_object v7; + cl_object v8; + { + cl_object v9; + { + cl_object v10; + v10 = ecl_make_cclosure_va((cl_objectfn)LC22__lambda210,env0,Cblock,1); + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ECL_NIL; + { + cl_object v12; + v12 = v2parents; + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v12; + } + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L15:; + if (!(v11==ECL_NIL)) { goto L17; } + goto L16; +L17:; + v10 = ECL_CONS_CAR(v11); + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v14; + } + T2 = ecl_function_dispatch(cl_env_copy,v9)(1, v10); + v13 = ecl_list1(T2); + (ECL_CONS_CDR(T1)=v13,T1); + goto L15; +L16:; + v6 = _ecl_cdr(v12); + goto L7; + } + } + } +L7:; + v7 = ECL_NIL; + { + cl_object v9; + v9 = v6; + if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v9; + } + { + cl_object v9; + cl_object v10; + v9 = ecl_list1(ECL_NIL); + v10 = v9; +L39:; + if (!(v5==ECL_NIL)) { goto L41; } + goto L40; +L41:; + v4 = ECL_CONS_CAR(v5); + { + cl_object v11; + v11 = ECL_CONS_CDR(v5); + if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = v11; + } + if (!(v8==ECL_NIL)) { goto L49; } + goto L40; +L49:; + v7 = ECL_CONS_CAR(v8); + { + cl_object v11; + v11 = ECL_CONS_CDR(v8); + if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v11; + } + { + cl_object v11; + v11 = v10; + if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v11; + } + T2 = ecl_function_dispatch(cl_env_copy,v3)(2, v4, v7); + v10 = ecl_list1(T2); + (ECL_CONS_CDR(T1)=v10,T1); + goto L39; +L40:; + T0 = _ecl_cdr(v9); + goto L1; + } + } + } + } +L1:; + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, v1node, T0); + return value0; + } + } +} +/* closure LAMBDA210 */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC22__lambda210(cl_narg narg, cl_object v1parent, ...) +{ + cl_object T0; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* GRAPH */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v2graph; + cl_fixnum v3node; + { + cl_object v4; + v4 = ECL_CONS_CAR(CLV1); + T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v4) /* SIMPLE-ARRAY-P */; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[0],v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v2graph = v4; + } + { + cl_object v4; + v4 = v1parent; + { + bool v5; + v5 = ECL_FIXNUMP(v4); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(VV[1],v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v3node = ecl_fixnum(v4); + } + { + cl_object v4; + v4 = v2graph; + T0 = v4; + { + cl_fixnum v5; + { + cl_fixnum v6; + v6 = v3node; + if (ecl_unlikely((v6)>=(v4)->vector.dim)) + FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = v6; + } + value0 = ecl_aref_unsafe(T0,v5); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } + } +} + +#include "common/early/graph.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclLTqb7ItxYx5DM_HeDycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclLTqb7ItxYx5DM_HeDycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + si_do_deftype(3, VV[0], VVtemp[2], ECL_SYM("SIMPLE-ARRAY",765)); + si_do_deftype(3, VV[1], VVtemp[3], ECL_SYM("FIXNUM",374)); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[4]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[24]); /* %%ORDER */ + si_put_sysprop(VV[2], ECL_SYM("INLINE",436), VVtemp[8]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[11]) /* ANNOTATE */; + ecl_cmp_defun(VV[26]); /* %%PARENTS */ + si_put_sysprop(VV[3], ECL_SYM("INLINE",436), VVtemp[12]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[13], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[27]); /* (SETF %%PARENTS) */ + si_put_sysprop(VV[4], ECL_SYM("INLINE",436), VVtemp[17]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[28]); /* DO-%%PARENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[21], VVtemp[22]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[23]) /* ANNOTATE */; + ecl_cmp_defun(VV[31]); /* %%PARENTS-ADD */ + si_put_sysprop(VV[7], ECL_SYM("INLINE",436), VVtemp[24]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[25], VVtemp[26]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[27]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[32]); /* %%PUSH-PARENTS */ + si_do_deftype(3, VV[9], VVtemp[28], ECL_SYM("SIMPLE-ARRAY",765)); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[33]); /* ORDER */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[34]); /* SIZE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[35]); /* INDEGREES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[35], VVtemp[36]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[37]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[36]); /* DO-EDGES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[38], VVtemp[39]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[40]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[37]); /* DO-PARENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[38]); /* DO-PARENTS-GRANDPARENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[19], ECL_SYM("LOCATION",1862), VVtemp[44], VVtemp[45]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[19], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[39]); /* OUTDEGREES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[46], VVtemp[47]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[48]) /* ANNOTATE */; + ecl_cmp_defun(VV[40]); /* ADD-EDGE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LOCATION",1862), VVtemp[49], VVtemp[50]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[51]) /* ANNOTATE */; + ecl_cmp_defun(VV[41]); /* MAKE-GRAPH-FROM-ADJ */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[52], VVtemp[53]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; + ecl_cmp_defun(VV[42]); /* MAP-NODES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[55], VVtemp[56]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[57]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[43]); /* DO-NODES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[58], VVtemp[59]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* MAP-EDGES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; + ecl_cmp_defun(VV[45]); /* MAP-PARENTS */ + ecl_function_dispatch(cl_env_copy,VV[46])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[62]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LOCATION",1862), VVtemp[63], VVtemp[64]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* MAP-PARENTS-GRANDPARENTS */ + ecl_function_dispatch(cl_env_copy,VV[46])(3, VV[18], ECL_SYM("FUNCTION",398), VVtemp[65]) /* SET-DOCUMENTATION */; +} diff --git a/common/early/package.cxx b/common/early/package.cxx new file mode 100644 index 0000000..083c88f --- /dev/null +++ b/common/early/package.cxx @@ -0,0 +1,36 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/early/package.lisp */ +#include +#include "common/early/package.eclh" + +#include "common/early/package.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclhQzNQYq3zy1HM_f7DycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/package.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclhQzNQYq3zy1HM_f7DycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + ecl_function_dispatch(cl_env_copy,VV[0])(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; +} diff --git a/common/early/utils.cxx b/common/early/utils.cxx new file mode 100644 index 0000000..12b13d9 --- /dev/null +++ b/common/early/utils.cxx @@ -0,0 +1,589 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/common/early/utils.lisp */ +#include +#include "common/early/utils.eclh" +/* function definition for COMPONENT-PRESENT-P */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L1component_present_p(cl_object v1value) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + if (Null(v1value)) { goto L2; } + { + bool v2; + v2 = ecl_eql(v1value,ECL_SYM("UNSPECIFIC",1354)); + value0 = (v2)?ECL_NIL:ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for DIRECTORY-PATHNAME-P */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L2directory_pathname_p(cl_object v1pathspec) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = cl_pathname_name(1, v1pathspec); + if ((L1component_present_p(T0))!=ECL_NIL) { goto L2; } + T0 = cl_pathname_type(1, v1pathspec); + if ((L1component_present_p(T0))!=ECL_NIL) { goto L2; } + value0 = v1pathspec; + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for ASGL-HOME */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L3asgl_home() +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v1var; + value0 = si_getenv(VV[3]); + if ((value0)!=ECL_NIL) { goto L3; } + v1var = ECL_NIL; + goto L1; +L3:; + v1var = value0; + goto L1; +L1:; + if ((v1var)!=ECL_NIL) { goto L5; } + cl_error(1, VV[4]); +L5:; + { + cl_object v2home; + v2home = cl_probe_file(v1var); + if (Null(v2home)) { goto L11; } + if ((L2directory_pathname_p(v2home))!=ECL_NIL) { goto L8; } + goto L9; +L11:; + goto L9; +L9:; + T0 = si_getenv(VV[3]); + cl_error(2, VV[5], T0); +L8:; + value0 = v2home; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* local function AIF */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC4aif(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4test; + cl_object v5then; + cl_object v6else; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v7; + v7 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4test = v7; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v7; + v7 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v5then = v7; + } + if (Null(v3)) { goto L15; } + { + cl_object v7; + v7 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v6else = v7; + goto L14; + } +L15:; + v6else = ECL_NIL; +L14:; + if (Null(v3)) { goto L20; } + ecl_function_dispatch(cl_env_copy,VV[41])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L20:; + T0 = cl_list(2, VV[7], v4test); + T1 = ecl_list1(T0); + T2 = cl_list(4, ECL_SYM("IF",948), VV[7], v5then, v6else); + value0 = cl_list(3, ECL_SYM("LET",479), T1, T2); + return value0; + } + } +} +/* local function WITH-TIMING */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC5with_timing(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4form; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4form = v5; + } + if (Null(v3)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[41])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + value0 = v4form; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function LOG* */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC6log_(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4level; + v3 = ECL_CONS_CDR(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ECL_CONS_CAR(v3); + v3 = ECL_CONS_CDR(v3); + v4level = v5; + } + { + cl_object v5; + v5 = v4level; + { + cl_object v6; + v6 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v5)||ECL_BIGNUMP(v5))) { goto L14; } + v6 = v5; + if (ecl_greatereq(v6,ecl_make_fixnum(0))) { goto L10; } + goto L11; +L14:; + goto L11; + } +L11:; + v4level = si_do_check_type(v5, VV[13], ECL_NIL, VV[14]); +L10:; + } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for PRINT-ERROR-LOG */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L7print_error_log(cl_object v1eout, cl_object v2e) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + cl_format(2, v1eout, VV[16]); + cl_format(3, v1eout, VV[17], v2e); + cl_format(2, v1eout, VV[18]); + { + cl_object v3x; + T0 = si_ihs_top(); + v3x = ecl_minus(T0,ecl_make_fixnum(2)); +L6:; + if (!(ecl_lower(v3x,ecl_make_fixnum(1)))) { goto L8; } + goto L7; +L8:; + T0 = si_ihs_fun(v3x); + cl_format(3, v1eout, VV[17], T0); + cl_format(2, v1eout, VV[19]); + { + cl_object v4env; + T0 = si_ihs_env(v3x); + v4env = ecl_function_dispatch(cl_env_copy,VV[45])(1, T0) /* DECODE-IHS-ENV */; + { + cl_object v5; + v5 = v4env; + goto L18; +L17:; + { + cl_object v6ip; + v6ip = ECL_CONS_CAR(v5); + T0 = _ecl_car(v6ip); + T1 = _ecl_cdr(v6ip); + cl_format(4, v1eout, VV[20], T0, T1); + } + v5 = ECL_CONS_CDR(v5); +L18:; + if (Null(v5)) { goto L25; } + goto L17; +L25:; + } + } + cl_format(2, v1eout, VV[21]); + v3x = ecl_one_minus(v3x); + goto L6; +L7:; + } + value0 = cl_format(2, v1eout, VV[21]); + return value0; + } +} +/* function definition for REQUIRES-COMPILE-P */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L9requires_compile_p(cl_object v1source_file) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v2fasl_file; + T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(1, v1source_file) /* COMPILE-FILE-PATHNAME */; + v2fasl_file = cl_probe_file(T0); + value0 = Null(v2fasl_file)?ECL_T:ECL_NIL; + if ((value0)!=ECL_NIL) { goto L3; } + value0 = LC8file_newer_p(v1source_file, v2fasl_file); + return value0; +L3:; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function FILE-NEWER-P */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object LC8file_newer_p(cl_object v1new_file, cl_object v2old_file) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = cl_file_write_date(v1new_file); + T1 = cl_file_write_date(v2old_file); + value0 = ecl_make_bool(ecl_greater(T0,T1)); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for COMPILE-FILE-IF-NEEDED */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L10compile_file_if_needed(cl_object v1filename, cl_object v2loadp) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + if (Null(L9requires_compile_p(v1filename))) { goto L1; } + (cl_env_copy->function=(ECL_SYM("COMPILE-FILE",236)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE */; +L1:; + if (Null(v2loadp)) { goto L3; } + T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; + cl_load(1, T0); +L3:; + value0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; + return value0; + } +} +/* function definition for MEAN */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L11mean(cl_object v1sequence) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + T0 = (ECL_SYM("+",16)->symbol.gfdef); + T1 = cl_reduce(2, T0, v1sequence); + { + cl_fixnum v2; + v2 = ecl_length(v1sequence); + value0 = ecl_divide(T1,ecl_make_fixnum(v2)); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MEDIAN */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L12median(cl_object v1sequence) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + value0 = L13percentile(v1sequence, ecl_make_fixnum(50)); + return value0; + } +} +/* function definition for PERCENTILE */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L13percentile(cl_object v1sequence, cl_object v2percent) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3sorted_vect; + cl_fixnum v4n; + cl_object v5k; + cl_object v6floor_k; + T0 = ecl_copy_seq(v1sequence); + T1 = (ECL_SYM("<",74)->symbol.gfdef); + T2 = cl_sort(2, T0, T1); + v3sorted_vect = ecl_function_dispatch(cl_env_copy,VV[51])(4, T2, ECL_T, ECL_SYM("*",20), ECL_T) /* COERCE-TO-VECTOR */; + v4n = (v3sorted_vect)->vector.fillp; + T0 = ecl_divide(v2percent,ecl_make_fixnum(100)); + v5k = ecl_times(ecl_make_fixnum(v4n),T0); + v6floor_k = ecl_floor1(v5k); + if (!(ecl_number_equalp(v5k,v6floor_k))) { goto L6; } + { + cl_object v7; + v7 = v3sorted_vect; + T1 = v7; + { + cl_fixnum v8; + { + cl_object v9; + v9 = v5k; + if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = ecl_fixnum(v9); + } + T0 = ecl_aref_unsafe(T1,v8); + } + } + { + cl_object v7; + v7 = v3sorted_vect; + T2 = v7; + { + cl_fixnum v8; + { + cl_object v9; + v9 = ecl_one_minus(v5k); + if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = ecl_fixnum(v9); + } + T1 = ecl_aref_unsafe(T2,v8); + } + } + T2 = ecl_plus(T0,T1); + value0 = ecl_divide(T2,ecl_make_fixnum(2)); + cl_env_copy->nvalues = 1; + return value0; +L6:; + { + cl_object v7; + v7 = v3sorted_vect; + T0 = v7; + { + cl_fixnum v8; + { + cl_object v9; + v9 = v6floor_k; + if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = ecl_fixnum(v9); + } + value0 = ecl_aref_unsafe(T0,v8); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* function definition for SUMMARY */ +/* optimize speed 3, debug 0, space 0, safety 1 */ +static cl_object L14summary(cl_object v1sequence) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_fixnum v2; + v2 = ecl_length(v1sequence); + if (!((v2)<(1000))) { goto L1; } + } + T0 = (ECL_SYM("MIN",559)->symbol.gfdef); + T1 = cl_reduce(2, T0, v1sequence); + T2 = L13percentile(v1sequence, ecl_make_fixnum(25)); + T3 = cl_format(3, ECL_NIL, VV[30], T2); + T4 = L12median(v1sequence); + T5 = cl_format(3, ECL_NIL, VV[30], T4); + T6 = L11mean(v1sequence); + T7 = cl_format(3, ECL_NIL, VV[30], T6); + T8 = L13percentile(v1sequence, ecl_make_fixnum(75)); + T9 = cl_format(3, ECL_NIL, VV[30], T8); + T10 = (ECL_SYM("MAX",553)->symbol.gfdef); + T11 = cl_reduce(2, T10, v1sequence); + value0 = cl_list(12, VV[28], T1, VV[29], T3, VV[31], T5, VV[32], T7, VV[33], T9, VV[34], T11); + return value0; +L1:; + T0 = (ECL_SYM("MIN",559)->symbol.gfdef); + T1 = cl_reduce(2, T0, v1sequence); + T2 = L11mean(v1sequence); + T3 = cl_format(3, ECL_NIL, VV[30], T2); + T4 = (ECL_SYM("MAX",553)->symbol.gfdef); + T5 = cl_reduce(2, T4, v1sequence); + value0 = cl_list(6, VV[28], T1, VV[32], T3, VV[34], T5); + return value0; + } +} + +#include "common/early/utils.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclb840kDV4LgEAM_JODycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/utils.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclb840kDV4LgEAM_JODycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[35]); /* COMPONENT-PRESENT-P */ + ecl_function_dispatch(cl_env_copy,VV[36])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[37]); /* DIRECTORY-PATHNAME-P */ + ecl_function_dispatch(cl_env_copy,VV[36])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[9]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[38]); /* ASGL-HOME */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[39]); /* AIF */ + si_Xmake_special(VV[8]); + if (ECL_SYM_VAL(cl_env_copy,VV[8])!=OBJNULL) { goto L27; } + cl_set(VV[8],ECL_NIL); +L27:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[17], VVtemp[18]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[19]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[42]); /* WITH-TIMING */ + si_Xmake_special(VV[10]); + if (ECL_SYM_VAL(cl_env_copy,VV[10])!=OBJNULL) { goto L40; } + cl_set(VV[10],ECL_NIL); +L40:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + si_do_deftype(3, VV[11], VVtemp[22], VVtemp[23]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[43]); /* LOG* */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* PRINT-ERROR-LOG */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[30], VVtemp[31]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; + ecl_cmp_defun(VV[46]); /* REQUIRES-COMPILE-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* COMPILE-FILE-IF-NEEDED */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LOCATION",1862), VVtemp[36], VVtemp[37]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[38]) /* ANNOTATE */; + ecl_cmp_defun(VV[48]); /* MEAN */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[40]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[38]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* MEDIAN */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[50]); /* PERCENTILE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LOCATION",1862), VVtemp[44], VVtemp[45]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[38]) /* ANNOTATE */; + ecl_cmp_defun(VV[52]); /* SUMMARY */ +} diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 140090a..20a3f89 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -19,7 +19,7 @@ stdenv.mkDerivation rec { pname = "ecl"; - version = "24.5.10"; + version = "16.1.2"; src = fetchurl { url = "https://common-lisp.net/project/ecl/static/files/release/ecl-${version}.tgz"; diff --git a/lib/alexandria/arrays.cxx b/lib/alexandria/arrays.cxx new file mode 100644 index 0000000..f397be0 --- /dev/null +++ b/lib/alexandria/arrays.cxx @@ -0,0 +1,109 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/arrays.lisp */ +#include +#include "lib/alexandria/arrays.eclh" +/* function definition for COPY-ARRAY */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1copy_array(cl_narg narg, cl_object v1array, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2element_type; + cl_object v3fill_pointer; + cl_object v4adjustable; + ecl_va_list args; ecl_va_start(args,v1array,narg,1); + { + cl_object keyvars[6]; + cl_parse_key(args,3,L1copy_arraykeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[3])) { + v2element_type = cl_array_element_type(v1array); + } else { + v2element_type = keyvars[0]; + } + if (Null(keyvars[4])) { + if (!((ECL_ARRAYP(v1array)?(void)0:FEtype_error_array(v1array),ECL_ARRAY_HAS_FILL_POINTER_P(v1array)))) { goto L4; } + v3fill_pointer = cl_fill_pointer(v1array); + goto L2; +L4:; + v3fill_pointer = ECL_NIL; + goto L2; +L2:; + } else { + v3fill_pointer = keyvars[1]; + } + if (Null(keyvars[5])) { + v4adjustable = ecl_make_bool((ECL_ARRAYP(v1array)? (void)0: FEtype_error_array(v1array),ECL_ADJUSTABLE_ARRAY_P(v1array))); + } else { + v4adjustable = keyvars[2]; + } + } + { + cl_object v5dimensions; + cl_object v6new_array; + v5dimensions = cl_array_dimensions(v1array); + v6new_array = si_make_pure_array(v2element_type, v5dimensions, v4adjustable, v3fill_pointer, ECL_NIL, ecl_make_fixnum(0)); + { + cl_fixnum v7; + v7 = ecl_fixnum(cl_array_total_size(v1array)); + { + cl_fixnum v8i; + v8i = 0; + goto L13; +L12:; + T0 = ecl_aref(v1array,v8i); + ecl_aset(v6new_array,v8i,T0); + v8i = (v8i)+1; +L13:; + if (!((v8i)<(v7))) { goto L18; } + goto L12; +L18:; + } + } + value0 = v6new_array; + cl_env_copy->nvalues = 1; + return value0; + } + } +} + +#include "lib/alexandria/arrays.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecl6zVmPLti1MIGM_KoHycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/arrays.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl6zVmPLti1MIGM_KoHycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defun(VV[1]); /* COPY-ARRAY */ + ecl_function_dispatch(cl_env_copy,VV[2])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/binding.cxx b/lib/alexandria/binding.cxx new file mode 100644 index 0000000..4a91397 --- /dev/null +++ b/lib/alexandria/binding.cxx @@ -0,0 +1,339 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/binding.lisp */ +#include +#include "lib/alexandria/binding.eclh" +/* local function IF-LET */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1if_let(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4bindings; + cl_object v5; + cl_object v6then_form; + cl_object v7else_form; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4bindings = v8; + } + v5 = v3; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v8; + v8 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6then_form = v8; + } + if (Null(v5)) { goto L16; } + { + cl_object v8; + v8 = ecl_car(v5); + v5 = ecl_cdr(v5); + v7else_form = v8; + goto L15; + } +L16:; + v7else_form = ECL_NIL; +L15:; + if (Null(v5)) { goto L21; } + ecl_function_dispatch(cl_env_copy,VV[6])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L21:; + { + cl_object v8binding_list; + cl_object v9variables; + if (!(ECL_CONSP(v4bindings))) { goto L24; } + T0 = ecl_car(v4bindings); + if (!(ECL_SYMBOLP(T0))) { goto L24; } + v8binding_list = ecl_list1(v4bindings); + goto L23; +L24:; + v8binding_list = v4bindings; +L23:; + { + cl_object v10; + v10 = (ECL_SYM("CAR",182)->symbol.gfdef); + { + cl_object v11; + cl_object v12; + v11 = ECL_NIL; + { + cl_object v13; + v13 = v8binding_list; + if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v12 = v13; + } + { + cl_object v13; + cl_object v14; + v13 = ecl_list1(ECL_NIL); + v14 = v13; +L35:; + if (!(ecl_endp(v12))) { goto L37; } + goto L36; +L37:; + v11 = ECL_CONS_CAR(v12); + { + cl_object v15; + v15 = ECL_CONS_CDR(v12); + if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v12 = v15; + } + { + cl_object v15; + v15 = v14; + if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v15; + } + T1 = ecl_function_dispatch(cl_env_copy,v10)(1, v11); + v14 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v14,T0); + goto L35; +L36:; + v9variables = ecl_cdr(v13); + goto L27; + } + } + } +L27:; + T0 = CONS(ECL_SYM("AND",89),v9variables); + T1 = cl_list(4, ECL_SYM("IF",948), T0, v6then_form, v7else_form); + value0 = cl_list(3, ECL_SYM("LET",479), v8binding_list, T1); + return value0; + } + } + } +} +/* local function WHEN-LET */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2when_let(cl_object v1, cl_object v2) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4bindings; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4bindings = v5; + } + { + cl_object v5binding_list; + cl_object v6variables; + if (!(ECL_CONSP(v4bindings))) { goto L9; } + T0 = ecl_car(v4bindings); + if (!(ECL_SYMBOLP(T0))) { goto L9; } + v5binding_list = ecl_list1(v4bindings); + goto L8; +L9:; + v5binding_list = v4bindings; +L8:; + { + cl_object v7; + v7 = (ECL_SYM("CAR",182)->symbol.gfdef); + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v5binding_list; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ecl_list1(ECL_NIL); + v11 = v10; +L20:; + if (!(ecl_endp(v9))) { goto L22; } + goto L21; +L22:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v12; + v12 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v12; + } + { + cl_object v12; + v12 = v11; + if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v12; + } + T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); + v11 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v11,T0); + goto L20; +L21:; + v6variables = ecl_cdr(v10); + goto L12; + } + } + } +L12:; + T0 = CONS(ECL_SYM("AND",89),v6variables); + T1 = cl_listX(3, ECL_SYM("WHEN",907), T0, v3); + value0 = cl_list(3, ECL_SYM("LET",479), v5binding_list, T1); + return value0; + } + } + } +} +/* local function WHEN-LET* */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC4when_let_(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4bindings; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4bindings = v5; + } + { + cl_object v5binding_list; + if (!(ECL_CONSP(v4bindings))) { goto L9; } + T0 = ecl_car(v4bindings); + if (!(ECL_SYMBOLP(T0))) { goto L9; } + v5binding_list = ecl_list1(v4bindings); + goto L8; +L9:; + v5binding_list = v4bindings; +L8:; + T0 = ecl_car(v5binding_list); + T1 = ecl_list1(T0); + T2 = ecl_caar(v5binding_list); + T4 = ecl_cdr(v5binding_list); + T3 = LC3bind(T4, v3); + T4 = cl_listX(3, ECL_SYM("WHEN",907), T2, T3); + value0 = cl_list(3, ECL_SYM("LET",479), T1, T4); + return value0; + } + } + } +} +/* local function BIND */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3bind(cl_object v1bindings, cl_object v2forms) +{ + cl_object T0, T1, T2, T3, T4, T5; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1bindings)) { goto L1; } + T0 = ecl_car(v1bindings); + T1 = ecl_list1(T0); + T2 = ecl_caar(v1bindings); + T4 = ecl_cdr(v1bindings); + T3 = LC3bind(T4, v2forms); + T4 = cl_listX(3, ECL_SYM("WHEN",907), T2, T3); + T5 = cl_list(3, ECL_SYM("LET",479), T1, T4); + value0 = ecl_list1(T5); + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = v2forms; + cl_env_copy->nvalues = 1; + return value0; + } +} + +#include "lib/alexandria/binding.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclam0zuatJiYACM_4hEycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/binding.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclam0zuatJiYACM_4hEycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[3]); /* IF-LET */ + ecl_function_dispatch(cl_env_copy,VV[4])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[7]); /* WHEN-LET */ + ecl_function_dispatch(cl_env_copy,VV[4])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[8]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[8]); /* WHEN-LET* */ + ecl_function_dispatch(cl_env_copy,VV[4])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/conditions.cxx b/lib/alexandria/conditions.cxx new file mode 100644 index 0000000..b6c884c --- /dev/null +++ b/lib/alexandria/conditions.cxx @@ -0,0 +1,395 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/conditions.lisp */ +#include +#include "lib/alexandria/conditions.eclh" +/* function definition for REQUIRED-ARGUMENT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1required_argument(cl_narg narg, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg>1)) FEwrong_num_arguments_anonym(); + { + cl_object v1name; + va_list args; va_start(args,narg); + { + int i = 0; + if (i >= narg) { + v1name = ECL_NIL; + } else { + i++; + v1name = va_arg(args,cl_object); + } + } + va_end(args); + value0 = cl_error(2, VV[1], v1name); + return value0; + } +} +/* function definition for SIMPLE-STYLE-WARNING */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L2simple_style_warning(cl_narg narg, cl_object v1message, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2args; + ecl_va_list args; ecl_va_start(args,v1message,narg,1); + v2args = cl_grab_rest_args(args); + ecl_va_end(args); + value0 = (cl_env_copy->function=(ECL_SYM("WARN",905)->symbol.gfdef))->cfun.entry(5, VV[2], ECL_SYM("FORMAT-CONTROL",1269), v1message, ECL_SYM("FORMAT-ARGUMENTS",1268), v2args) /* WARN */; + return value0; + } +} +/* function definition for SIMPLE-READER-ERROR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L3simple_reader_error(cl_narg narg, cl_object v1stream, cl_object v2message, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3args; + ecl_va_list args; ecl_va_start(args,v2message,narg,2); + v3args = cl_grab_rest_args(args); + ecl_va_end(args); + value0 = cl_error(7, VV[3], ECL_SYM("STREAM",1347), v1stream, ECL_SYM("FORMAT-CONTROL",1269), v2message, ECL_SYM("FORMAT-ARGUMENTS",1268), v3args); + return value0; + } +} +/* function definition for SIMPLE-PARSE-ERROR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4simple_parse_error(cl_narg narg, cl_object v1message, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2args; + ecl_va_list args; ecl_va_start(args,v1message,narg,1); + v2args = cl_grab_rest_args(args); + ecl_va_end(args); + value0 = cl_error(5, VV[4], ECL_SYM("FORMAT-CONTROL",1269), v1message, ECL_SYM("FORMAT-ARGUMENTS",1268), v2args); + return value0; + } +} +/* function definition for SIMPLE-PROGRAM-ERROR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5simple_program_error(cl_narg narg, cl_object v1message, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2args; + ecl_va_list args; ecl_va_start(args,v1message,narg,1); + v2args = cl_grab_rest_args(args); + ecl_va_end(args); + value0 = cl_error(5, VV[5], ECL_SYM("FORMAT-CONTROL",1269), v1message, ECL_SYM("FORMAT-ARGUMENTS",1268), v2args); + return value0; + } +} +/* local function IGNORE-SOME-CONDITIONS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC6ignore_some_conditions(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[22])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v5; + } + T0 = CONS(ECL_SYM("PROGN",673),v3); + { + cl_object v5condition; + cl_object v6; + v5condition = ECL_NIL; + { + cl_object v7; + v7 = v4; + if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v7; + } + { + cl_object v7; + cl_object v8; + v7 = ecl_list1(ECL_NIL); + v8 = v7; +L15:; + if (!(ecl_endp(v6))) { goto L17; } + goto L16; +L17:; + v5condition = ECL_CONS_CAR(v6); + { + cl_object v9; + v9 = ECL_CONS_CDR(v6); + if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v9; + } + { + cl_object v9; + v9 = v8; + if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T2 = v9; + } + T3 = CONS(v5condition,VV[7]); + v8 = ecl_list1(T3); + (ECL_CONS_CDR(T2)=v8,T2); + goto L15; +L16:; + T1 = ecl_cdr(v7); + goto L8; + } + } +L8:; + value0 = cl_listX(3, ECL_SYM("HANDLER-CASE",418), T0, T1); + return value0; + } + } +} +/* local function UNWIND-PROTECT-CASE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC7unwind_protect_case(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6abort_flag; + cl_object v7protected_form; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[22])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v8; + } + v5 = v4; + if (Null(v5)) { goto L10; } + { + cl_object v8; + v8 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6abort_flag = v8; + goto L9; + } +L10:; + v6abort_flag = ECL_NIL; +L9:; + if (!(v3==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[22])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v7protected_form = v8; + } + if (Null(v5)) { goto L21; } + ecl_function_dispatch(cl_env_copy,VV[24])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L21:; + { + cl_object v8; + v8 = v6abort_flag; + if (ECL_SYMBOLP(v8)) { goto L25; } + v6abort_flag = si_do_check_type(v8, VV[9], ECL_NIL, VV[10]); +L25:; + } + { + cl_object v8gflag; + v8gflag = cl_gensym(1, VV[11]); + T0 = cl_list(2, v8gflag, ECL_T); + T1 = ecl_list1(T0); + T2 = cl_list(3, ECL_SYM("SETF",752), v8gflag, ECL_NIL); + T3 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), v7protected_form, T2); + if (Null(v6abort_flag)) { goto L31; } + T5 = cl_list(2, v6abort_flag, v8gflag); + T4 = ecl_list1(T5); + goto L29; +L31:; + T4 = ECL_NIL; + goto L29; +L29:; + { + cl_object v9cleanup_kind; + cl_object v10forms; + cl_object v11; + v9cleanup_kind = ECL_NIL; + v10forms = ECL_NIL; + { + cl_object v12; + v12 = v3; + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v12; + } + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L41:; + if (!(ecl_endp(v11))) { goto L43; } + goto L42; +L43:; + { + cl_object v14; + v14 = ECL_CONS_CAR(v11); + v9cleanup_kind = ecl_car(v14); + v14 = ecl_cdr(v14); + v10forms = v14; + } + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T6 = v14; + } + if (!((v9cleanup_kind)==(VV[12]))) { goto L62; } + T8 = cl_list(2, ECL_SYM("NOT",586), v8gflag); + T7 = cl_listX(3, ECL_SYM("WHEN",907), T8, v10forms); + goto L61; +L62:; + if (!((v9cleanup_kind)==(ECL_SYM("ABORT",1222)))) { goto L64; } + T7 = cl_listX(3, ECL_SYM("WHEN",907), v8gflag, v10forms); + goto L61; +L64:; + if (!((v9cleanup_kind)==(VV[13]))) { goto L66; } + T7 = CONS(ECL_SYM("PROGN",673),v10forms); + goto L61; +L66:; + T7 = si_ecase_error(v9cleanup_kind, VV[14]); +L61:; + v13 = ecl_list1(T7); + (ECL_CONS_CDR(T6)=v13,T6); + goto L41; +L42:; + T5 = ecl_cdr(v12); + goto L33; + } + } +L33:; + T6 = cl_listX(3, ECL_SYM("LET",479), T4, T5); + T7 = cl_list(3, ECL_SYM("UNWIND-PROTECT",890), T3, T6); + value0 = cl_list(3, ECL_SYM("LET",479), T1, T7); + return value0; + } + } + } +} + +#include "lib/alexandria/conditions.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecl0sKp2nr5Zar9M_tCFycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/conditions.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl0sKp2nr5Zar9M_tCFycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defun(VV[15]); /* REQUIRED-ARGUMENT */ + ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + clos_load_defclass(VV[2], VVtemp[7], ECL_NIL, ECL_NIL); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[17]); /* SIMPLE-STYLE-WARNING */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + clos_load_defclass(VV[3], VVtemp[13], ECL_NIL, ECL_NIL); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[18]); /* SIMPLE-READER-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[17], VVtemp[18]) /* ANNOTATE */; + clos_load_defclass(VV[4], VVtemp[19], ECL_NIL, ECL_NIL); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[19]); /* SIMPLE-PARSE-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[23]) /* ANNOTATE */; + clos_load_defclass(VV[5], VVtemp[24], ECL_NIL, ECL_NIL); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[25], VVtemp[26]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[20]); /* SIMPLE-PROGRAM-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[21]); /* IGNORE-SOME-CONDITIONS */ + ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[30]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[23]); /* UNWIND-PROTECT-CASE */ + ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[34]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/control-flow.cxx b/lib/alexandria/control-flow.cxx new file mode 100644 index 0000000..87ad2cf --- /dev/null +++ b/lib/alexandria/control-flow.cxx @@ -0,0 +1,860 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/control-flow.lisp */ +#include +#include "lib/alexandria/control-flow.eclh" +/* function definition for EXTRACT-FUNCTION-NAME */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1extract_function_name(cl_object v1spec) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_CONSP(v1spec))) { goto L1; } + { + cl_object v2; + v2 = ecl_car(v1spec); + if (!((v2)==(ECL_SYM("QUOTE",681)))) { goto L8; } + goto L5; + goto L6; +L8:; + goto L6; +L6:; + if (!((v2)==(ECL_SYM("FUNCTION",398)))) { goto L1; } + goto L2; +L5:; + } +L2:; + value0 = ecl_cadr(v1spec); + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = v1spec; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for GENERATE-SWITCH-BODY */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L3generate_switch_body(cl_narg narg, cl_object v1whole, cl_object v2object, cl_object v3clauses, cl_object v4test, cl_object v5key, ...) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1, CLV2, CLV3; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<5)) FEwrong_num_arguments_anonym(); + if (ecl_unlikely(narg>6)) FEwrong_num_arguments_anonym(); + { + va_list args; va_start(args,v5key); + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1whole,env0); /* WHOLE */ + CLV1 = env0 = CONS(v4test,env0); /* TEST */ + { + int i = 5; + if (i >= narg) { + CLV2 = env0 = CONS(ECL_NIL,env0); /* DEFAULT */ + } else { + i++; + CLV2 = env0 = CONS(va_arg(args,cl_object),env0); /* DEFAULT */ + } + } + va_end(args); + { + cl_object env1 = env0; + T0 = cl_gensym(1, VV[4]); + CLV3 = env1 = CONS(T0,env1); /* VALUE */ + ECL_CONS_CAR(CLV1) = L1extract_function_name(ECL_CONS_CAR(CLV1)); + v5key = L1extract_function_name(v5key); + if (!(ECL_CONSP(ECL_CONS_CAR(CLV2)))) { goto L5; } + { + cl_object v6; + v6 = ecl_car(ECL_CONS_CAR(CLV2)); + if (!((v6)==(ECL_SYM("ERROR",339)))) { goto L12; } + goto L9; + goto L10; +L12:; + goto L10; +L10:; + if (!((v6)==(ECL_SYM("CERROR",204)))) { goto L5; } + goto L6; +L9:; + } +L6:; + T0 = ECL_CONS_CAR(CLV2); + T1 = cl_list(2, ECL_SYM("QUOTE",681), ECL_CONS_CAR(CLV1)); + T2 = cl_list(3, VV[7], ECL_CONS_CAR(CLV3), T1); + ECL_CONS_CAR(CLV2) = ecl_append(T0,T2); +L5:; + T0 = cl_list(2, v5key, v2object); + T1 = cl_list(2, ECL_CONS_CAR(CLV3), T0); + T2 = ecl_list1(T1); + { + cl_object v6; + { + cl_object v7; + v7 = ecl_make_cclosure_va((cl_objectfn)LC2__lambda28,env1,Cblock,1); + v6 = v7; + } + { + cl_object v7; + cl_object v8; + v7 = ECL_NIL; + { + cl_object v9; + v9 = v3clauses; + if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v9; + } + { + cl_object v9; + cl_object v10; + v9 = ecl_list1(ECL_NIL); + v10 = v9; +L24:; + if (!(ecl_endp(v8))) { goto L26; } + goto L25; +L26:; + v7 = ECL_CONS_CAR(v8); + { + cl_object v11; + v11 = ECL_CONS_CDR(v8); + if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v11; + } + { + cl_object v11; + v11 = v10; + if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T4 = v11; + } + T5 = ecl_function_dispatch(cl_env_copy,v6)(1, v7); + v10 = ecl_list1(T5); + (ECL_CONS_CDR(T4)=v10,T4); + goto L24; +L25:; + T3 = ecl_cdr(v9); + goto L16; + } + } + } +L16:; + T4 = cl_list(2, ECL_T, ECL_CONS_CAR(CLV2)); + T5 = ecl_list1(T4); + T6 = ecl_append(T3,T5); + T7 = CONS(ECL_SYM("COND",249),T6); + value0 = cl_list(3, ECL_SYM("LET",479), T2, T7); + return value0; + } + } +} +/* closure LAMBDA28 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2__lambda28(cl_narg narg, cl_object v1clause, ...) +{ + cl_object T0; + cl_object CLV0, CLV1, CLV2, CLV3; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV3 = env0; /* VALUE */ + CLV2 = _ecl_cdr(CLV3); + CLV1 = _ecl_cdr(CLV2); + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v2; + v2 = ecl_car(v1clause); + if (!(ecl_eql(v2,ECL_T))) { goto L7; } + goto L4; + goto L5; +L7:; + goto L5; +L5:; + if (!((v2)==(ECL_SYM("OTHERWISE",617)))) { goto L1; } + goto L2; +L4:; + } +L2:; + if (Null(ECL_CONS_CAR(CLV2))) { goto L10; } + cl_error(2, VV[10], ECL_CONS_CAR(CLV0)); +L10:; + T0 = ecl_cdr(v1clause); + ECL_CONS_CAR(CLV2) = CONS(ECL_SYM("PROGN",673),T0); + value0 = VV[11]; + cl_env_copy->nvalues = 1; + return value0; +L1:; + { + cl_object v2; + cl_object v3key_form; + v2 = v1clause; + if (!(v2==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1clause) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v4; + v4 = ecl_car(v2); + v2 = ecl_cdr(v2); + v3key_form = v4; + } + T0 = cl_list(3, ECL_CONS_CAR(CLV1), ECL_CONS_CAR(CLV3), v3key_form); + value0 = CONS(T0,v2); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* local function SWITCH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC4switch(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6object; + cl_object v7; + cl_object v8test; + cl_object v9; + cl_object v10key; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v11; + v11 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v11; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v11; + v11 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6object = v11; + } + v7 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; + if (!((v7)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L17; } + v8test = ECL_SYM("EQL",336); + goto L16; +L17:; + v8test = v7; +L16:; + v9 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("KEY",1294)) /* SEARCH-KEYWORD */; + if (!((v9)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L21; } + v10key = ECL_SYM("IDENTITY",428); + goto L20; +L21:; + v10key = v9; +L20:; + ecl_function_dispatch(cl_env_copy,VV[35])(2, v5, VV[13]) /* CHECK-KEYWORD */; + value0 = L3generate_switch_body(5, v1, v6object, v3, v8test, v10key); + return value0; + } + } +} +/* local function ESWITCH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC5eswitch(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6object; + cl_object v7; + cl_object v8test; + cl_object v9; + cl_object v10key; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v11; + v11 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v11; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v11; + v11 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6object = v11; + } + v7 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; + if (!((v7)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L17; } + v8test = ECL_SYM("EQL",336); + goto L16; +L17:; + v8test = v7; +L16:; + v9 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("KEY",1294)) /* SEARCH-KEYWORD */; + if (!((v9)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L21; } + v10key = ECL_SYM("IDENTITY",428); + goto L20; +L21:; + v10key = v9; +L20:; + ecl_function_dispatch(cl_env_copy,VV[35])(2, v5, VV[13]) /* CHECK-KEYWORD */; + value0 = L3generate_switch_body(6, v1, v6object, v3, v8test, v10key, VV[15]); + return value0; + } + } +} +/* local function CSWITCH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC6cswitch(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6object; + cl_object v7; + cl_object v8test; + cl_object v9; + cl_object v10key; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v11; + v11 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v11; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v11; + v11 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6object = v11; + } + v7 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; + if (!((v7)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L17; } + v8test = ECL_SYM("EQL",336); + goto L16; +L17:; + v8test = v7; +L16:; + v9 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("KEY",1294)) /* SEARCH-KEYWORD */; + if (!((v9)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L21; } + v10key = ECL_SYM("IDENTITY",428); + goto L20; +L21:; + v10key = v9; +L20:; + ecl_function_dispatch(cl_env_copy,VV[35])(2, v5, VV[13]) /* CHECK-KEYWORD */; + value0 = L3generate_switch_body(6, v1, v6object, v3, v8test, v10key, VV[17]); + return value0; + } + } +} +/* local function WHICHEVER */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC10whichever(cl_object v1, cl_object v2env) +{ + cl_object T0, T1, T2, T3; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v2env,env0); /* ENV */ + { + cl_object v3; + cl_object v4possibilities; + v3 = ecl_cdr(v1); + v4possibilities = v3; + { + cl_object v5; + { + cl_object v6; + v6 = ecl_make_cclosure_va((cl_objectfn)LC7__lambda107,env0,Cblock,1); + v5 = v6; + } + { + cl_object v6; + cl_object v7; + v6 = ECL_NIL; + { + cl_object v8; + v8 = v4possibilities; + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ecl_list1(ECL_NIL); + v9 = v8; +L12:; + if (!(ecl_endp(v7))) { goto L14; } + goto L13; +L14:; + v6 = ECL_CONS_CAR(v7); + { + cl_object v10; + v10 = ECL_CONS_CDR(v7); + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v10; + } + { + cl_object v10; + v10 = v9; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v10; + } + T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); + v9 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v9,T0); + goto L12; +L13:; + v4possibilities = ecl_cdr(v8); + goto L4; + } + } + } +L4:; + { + cl_object v5; + v5 = ecl_make_cfun((cl_objectfn_fixed)LC8__lambda110,ECL_NIL,Cblock,1); + T0 = v5; + } + if (Null(cl_every(2, T0, v4possibilities))) { goto L30; } + T0 = CONS(ECL_SYM("VECTOR",900),v4possibilities); + T1 = cl_list(2, ECL_SYM("LOAD-TIME-VALUE",491), T0); + { + cl_fixnum v5; + v5 = ecl_length(v4possibilities); + T2 = cl_list(2, ECL_SYM("RANDOM",682), ecl_make_fixnum(v5)); + value0 = cl_list(3, ECL_SYM("SVREF",840), T1, T2); + return value0; + } +L30:; + { + cl_object v6random_number; + v6random_number = cl_gensym(1, VV[19]); + { + cl_fixnum v7length; + v7length = ecl_length(v4possibilities); + T0 = cl_list(2, ECL_SYM("RANDOM",682), ecl_make_fixnum(v7length)); + T1 = cl_list(2, v6random_number, T0); + T2 = ecl_list1(T1); + T3 = LC9expand(v4possibilities, ecl_make_fixnum(0), v6random_number); + value0 = cl_list(3, ECL_SYM("LET",479), T2, T3); + return value0; + } + } + } + } +} +/* closure LAMBDA107 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC7__lambda107(cl_narg narg, cl_object v1p, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* ENV */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = cl_macroexpand(2, v1p, ECL_CONS_CAR(CLV0)); + return value0; + } + } +} +/* local function LAMBDA110 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC8__lambda110(cl_object v1p) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_constantp(1, v1p); + return value0; + } +} +/* local function EXPAND */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC9expand(cl_object v1possibilities, cl_object v2position, cl_object v3random_number) +{ + cl_object T0, T1, T2, T3, T4; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = ecl_cdr(v1possibilities); + if (!(T0==ECL_NIL)) { goto L1; } + value0 = ecl_car(v1possibilities); + cl_env_copy->nvalues = 1; + return value0; +L1:; + { + cl_fixnum v4length; + cl_object v5half; + cl_object v6second_half; + cl_object v7first_half; + v4length = ecl_length(v1possibilities); + v5half = ecl_truncate2(ecl_make_fixnum(v4length),ecl_make_fixnum(2)); + v6second_half = ecl_nthcdr(ecl_to_size(v5half),v1possibilities); + T0 = ecl_minus(ecl_make_fixnum(v4length),v5half); + v7first_half = cl_butlast(2, v1possibilities, T0); + T0 = ecl_plus(v2position,v5half); + T1 = cl_list(3, ECL_SYM("<",74), v3random_number, T0); + T2 = LC9expand(v7first_half, v2position, v3random_number); + T4 = ecl_plus(v2position,v5half); + T3 = LC9expand(v6second_half, T4, v3random_number); + value0 = cl_list(4, ECL_SYM("IF",948), T1, T2, T3); + return value0; + } + } +} +/* local function XOR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC12xor(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1, CLV2; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + v3 = ecl_cdr(v1); + { + cl_object v4; + cl_object v5; + cl_object v6; + cl_object env1 = env0; + v4 = cl_gensym(1, VV[21]); + v5 = cl_gensym(1, VV[22]); + v6 = cl_gensym(1, VV[23]); + env1 = ECL_NIL; + CLV0 = env1 = CONS(v4,env1); /* XOR */ + CLV1 = env1 = CONS(v5,env1); /* TMP */ + CLV2 = env1 = CONS(v6,env1); /* TRUE */ + T0 = cl_list(2, ECL_CONS_CAR(CLV1), ECL_CONS_CAR(CLV2)); + { + cl_object v7; + { + cl_object v8; + v8 = ecl_make_cclosure_va((cl_objectfn)LC11__lambda125,env1,Cblock,1); + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v3; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ecl_list1(ECL_NIL); + v11 = v10; +L13:; + if (!(ecl_endp(v9))) { goto L15; } + goto L14; +L15:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v12; + v12 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v12; + } + { + cl_object v12; + v12 = v11; + if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T2 = v12; + } + T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); + v11 = ecl_list1(T3); + (ECL_CONS_CDR(T2)=v11,T2); + goto L13; +L14:; + T1 = ecl_cdr(v10); + goto L5; + } + } + } +L5:; + T2 = cl_list(3, ECL_SYM("VALUES",897), ECL_CONS_CAR(CLV2), ECL_T); + T3 = cl_list(3, ECL_SYM("RETURN-FROM",727), ECL_CONS_CAR(CLV0), T2); + T4 = ecl_list1(T3); + T5 = ecl_append(T1,T4); + T6 = cl_listX(3, ECL_SYM("BLOCK",139), ECL_CONS_CAR(CLV0), T5); + value0 = cl_list(3, ECL_SYM("LET",479), T0, T6); + return value0; + } + } + } +} +/* closure LAMBDA125 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC11__lambda125(cl_narg narg, cl_object v1datum, ...) +{ + cl_object T0, T1, T2, T3; + cl_object CLV0, CLV1, CLV2; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV2 = env0; /* TRUE */ + CLV1 = _ecl_cdr(CLV2); + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = cl_list(3, ECL_SYM("SETF",752), ECL_CONS_CAR(CLV1), v1datum); + T1 = cl_list(3, ECL_SYM("RETURN-FROM",727), ECL_CONS_CAR(CLV0), VV[24]); + T2 = cl_list(3, ECL_SYM("SETF",752), ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV1)); + T3 = cl_list(4, ECL_SYM("IF",948), ECL_CONS_CAR(CLV2), T1, T2); + value0 = cl_list(3, ECL_SYM("IF",948), T0, T3); + return value0; + } + } +} +/* local function NTH-VALUE-OR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC13nth_value_or(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4nth_value; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4nth_value = v5; + } + { + cl_object v5; + v5 = cl_gensym(1, VV[26]); + T0 = cl_list(2, v5, v4nth_value); + T1 = ecl_list1(T0); + { + cl_object v6values; + v6values = cl_gensym(1, VV[27]); + T3 = ecl_car(v3); + T4 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",576), T3); + T5 = cl_list(2, v6values, T4); + T6 = ecl_list1(T5); + T7 = cl_list(3, ECL_SYM("NTH",604), v5, v6values); + T8 = cl_list(2, ECL_SYM("VALUES-LIST",898), v6values); + if (Null(ecl_cdr(v3))) { goto L12; } + T10 = ecl_cdr(v3); + T9 = cl_listX(3, VV[25], v5, T10); + goto L11; +L12:; + T9 = ECL_NIL; +L11:; + T10 = cl_list(4, ECL_SYM("IF",948), T7, T8, T9); + T2 = cl_list(3, ECL_SYM("LET",479), T6, T10); + } + value0 = cl_list(3, ECL_SYM("LET",479), T1, T2); + return value0; + } + } + } +} +/* local function MULTIPLE-VALUE-PROG2 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC14multiple_value_prog2(cl_object v1, cl_object v2) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4first_form; + cl_object v5second_form; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4first_form = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5second_form = v6; + } + T0 = cl_listX(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), v5second_form, v3); + value0 = cl_list(3, ECL_SYM("PROGN",673), v4first_form, T0); + return value0; + } + } +} + +#include "lib/alexandria/control-flow.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclCnSaUWKBItpDM_zzFycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/control-flow.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclCnSaUWKBItpDM_zzFycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defun(VV[29]); /* EXTRACT-FUNCTION-NAME */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[31]); /* GENERATE-SWITCH-BODY */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[33]); /* SWITCH */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[12], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[36]); /* ESWITCH */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[14], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[37]); /* CSWITCH */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[17]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[38]); /* WHICHEVER */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[18], ECL_SYM("FUNCTION",398), VVtemp[21]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[23]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[24]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[39]); /* XOR */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[25]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[28]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[40]); /* NTH-VALUE-OR */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[25], ECL_SYM("FUNCTION",398), VVtemp[29]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[30], VVtemp[31]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[41]); /* MULTIPLE-VALUE-PROG2 */ + ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[33]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/definitions.cxx b/lib/alexandria/definitions.cxx new file mode 100644 index 0000000..594806f --- /dev/null +++ b/lib/alexandria/definitions.cxx @@ -0,0 +1,297 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/definitions.lisp */ +#include +#include "lib/alexandria/definitions.eclh" +/* function definition for %REEVALUATE-CONSTANT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5_reevaluate_constant(cl_object volatile v1name, cl_object volatile v2value, cl_object volatile v3test) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7; + cl_object volatile env0 = ECL_NIL; + cl_object volatile CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (ecl_boundp(cl_env_copy,v1name)) { goto L1; } + value0 = v2value; + cl_env_copy->nvalues = 1; + return value0; +L1:; + { + volatile cl_object v4; + v4 = cl_symbol_value(v1name); + if ((cl_constantp(1, v1name))!=ECL_NIL) { goto L4; } + cl_cerror(4, VV[1], VV[2], v1name, v4); + value0 = v2value; + cl_env_copy->nvalues = 1; + return value0; +L4:; + if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v4, v2value))) { goto L7; } + value0 = v4; + cl_env_copy->nvalues = 1; + return value0; +L7:; + { + volatile cl_object env1 = env0; + env1 = ECL_NIL; + CLV0 = env1 = CONS(ECL_NIL,env1); + { + volatile cl_object env2 = env1; + CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /* TAGBODY */ + { + ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1)); + if (__ecl_frs_push_result) { + if (cl_env_copy->values[0]==ecl_make_fixnum(0))goto L9; + if (cl_env_copy->values[0]==ecl_make_fixnum(1))goto L10; + ecl_internal_error("GO found an inexistent tag"); + } + } + { + cl_object v5; + v5 = ecl_make_cclosure_va((cl_objectfn)LC1__lambda8,env2,Cblock,0); + T0 = v5; + } + { + cl_object v5; + v5 = ecl_make_cfun((cl_objectfn_fixed)LC2__lambda9,ECL_NIL,Cblock,1); + T1 = v5; + } + T2 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1306), ECL_SYM("IGNORE",430), ECL_SYM("FUNCTION",1270), T0, VV[3], T1) /* MAKE-RESTART */; + { + cl_object v5; + v5 = ecl_make_cclosure_va((cl_objectfn)LC3__lambda10,env2,Cblock,0); + T3 = v5; + } + { + cl_object v5; + v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda11,ECL_NIL,Cblock,1); + T4 = v5; + } + T5 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1306), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1270), T3, VV[3], T4) /* MAKE-RESTART */; + T6 = cl_list(2, T2, T5); + T7 = CONS(T6,ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",5))); + ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T7); /* *RESTART-CLUSTERS* */ + { + cl_object v5; + T0 = cl_list(4, v1name, v4, v2value, v3test); + v5 = ecl_function_dispatch(cl_env_copy,VV[13])(4, VV[6], T0, ECL_SYM("SIMPLE-ERROR",772), ECL_SYM("ERROR",339)) /* COERCE-TO-CONDITION */; + T0 = ecl_car(ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",5))); + T1 = CONS(v5,T0); + T2 = CONS(T1,ecl_symbol_value(VV[7])); + ecl_bds_bind(cl_env_copy,VV[7],T2); /* *CONDITION-RESTARTS* */ + value0 = cl_error(1, v5); + ecl_frs_pop(cl_env_copy); + ecl_bds_unwind1(cl_env_copy); + ecl_bds_unwind1(cl_env_copy); + return value0; + } +L9:; + { + cl_object v5; + v5 = ECL_CONS_CAR(CLV0); + if (Null(v5)) { goto L19; } + ecl_function_dispatch(cl_env_copy,VV[14])(1, ECL_NIL) /* DM-TOO-MANY-ARGUMENTS */; +L19:; + value0 = v4; + cl_env_copy->nvalues = 1; + ecl_frs_pop(cl_env_copy); + return value0; + } +L10:; + { + cl_object v5; + v5 = ECL_CONS_CAR(CLV0); + if (Null(v5)) { goto L23; } + ecl_function_dispatch(cl_env_copy,VV[14])(1, ECL_NIL) /* DM-TOO-MANY-ARGUMENTS */; +L23:; + value0 = v2value; + cl_env_copy->nvalues = 1; + ecl_frs_pop(cl_env_copy); + return value0; + } + } + } + } + } +} +/* closure LAMBDA8 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1__lambda8(cl_narg narg, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* TAGBODY */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1si__temp; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1si__temp = cl_grab_rest_args(args); + ecl_va_end(args); + ECL_CONS_CAR(CLV0) = v1si__temp; + cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0)); + } + } +} +/* local function LAMBDA9 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2__lambda9(cl_object v1stream) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_write_string(2, VV[4], v1stream); + return value0; + } +} +/* closure LAMBDA10 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3__lambda10(cl_narg narg, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* TAGBODY */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1si__temp; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1si__temp = cl_grab_rest_args(args); + ecl_va_end(args); + ECL_CONS_CAR(CLV0) = v1si__temp; + cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(1)); + } + } +} +/* local function LAMBDA11 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC4__lambda11(cl_object v1stream) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_write_string(2, VV[5], v1stream); + return value0; + } +} +/* local function DEFINE-CONSTANT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC6define_constant(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4name; + cl_object v5initial_value; + cl_object v6; + cl_object v7test; + cl_object v8; + cl_object v9documentation; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[17])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v10; + v10 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4name = v10; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[17])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v10; + v10 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5initial_value = v10; + } + v6 = ecl_function_dispatch(cl_env_copy,VV[18])(2, v3, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; + if (!((v6)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L16; } + v7test = VV[9]; + goto L15; +L16:; + v7test = v6; +L15:; + v8 = ecl_function_dispatch(cl_env_copy,VV[18])(2, v3, ECL_SYM("DOCUMENTATION",1250)) /* SEARCH-KEYWORD */; + if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L20; } + v9documentation = ECL_NIL; + goto L19; +L20:; + v9documentation = v8; +L19:; + ecl_function_dispatch(cl_env_copy,VV[19])(2, v3, VV[10]) /* CHECK-KEYWORD */; + T0 = cl_list(2, ECL_SYM("QUOTE",681), v4name); + T1 = cl_list(4, VV[0], T0, v5initial_value, v7test); + if (Null(v9documentation)) { goto L24; } + T2 = ecl_list1(v9documentation); + goto L23; +L24:; + T2 = ECL_NIL; +L23:; + value0 = cl_listX(4, ECL_SYM("DEFCONSTANT",279), v4name, T1, T2); + return value0; + } + } +} + +#include "lib/alexandria/definitions.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclEwTbx6vhJ21IM_CgEycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/definitions.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclEwTbx6vhJ21IM_CgEycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defun(VV[11]); /* %REEVALUATE-CONSTANT */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[4], VVtemp[5]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[6]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[15]); /* DEFINE-CONSTANT */ + ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[7]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/features.cxx b/lib/alexandria/features.cxx new file mode 100644 index 0000000..8e13cdf --- /dev/null +++ b/lib/alexandria/features.cxx @@ -0,0 +1,131 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/features.lisp */ +#include +#include "lib/alexandria/features.eclh" +/* function definition for FEATUREP */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1featurep(cl_object v1feature_expression) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SYMBOLP(v1feature_expression))) { goto L1; } + { + cl_object v2; + cl_object v3; + cl_object v4; + v2 = ecl_symbol_value(ECL_SYM("*FEATURES*",36)); + v3 = v1feature_expression; + v4 = v2; + T0 = ecl_memql(v3,v4); + } + { + bool v2; + v2 = T0==ECL_NIL; + value0 = (v2)?ECL_NIL:ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } +L1:; + if (!(ECL_CONSP(v1feature_expression))) { goto L7; } + { + cl_object v3; + v3 = ecl_car(v1feature_expression); + if (ECL_SYMBOLP(v3)) { goto L11; } + { + cl_object v4; + v4 = si_do_check_type(v3, ECL_SYM("SYMBOL",842), ECL_NIL, VV[1]); + { + cl_object v5; + v5 = v1feature_expression; + if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v5; + } + (ECL_CONS_CAR(T0)=v4,T0); + } +L11:; + } + { + cl_object v3; + T0 = ecl_car(v1feature_expression); + v3 = cl_identity(T0); + if (Null(cl_stringE(2, v3, VV[2]))) { goto L19; } + T0 = ecl_fdefinition(VV[0]); + T1 = ecl_cdr(v1feature_expression); + value0 = cl_every(2, T0, T1); + return value0; +L19:; + if (Null(cl_stringE(2, v3, VV[3]))) { goto L22; } + T0 = ecl_fdefinition(VV[0]); + T1 = ecl_cdr(v1feature_expression); + value0 = cl_some(2, T0, T1); + return value0; +L22:; + if (Null(cl_stringE(2, v3, VV[4]))) { goto L25; } + goto L29; +L28:; + si_assert_failure(1, VV[5]); +L29:; + { + cl_fixnum v4; + v4 = ecl_length(v1feature_expression); + if ((2)==(v4)) { goto L32; } + } + goto L28; +L32:; + T0 = ecl_cadr(v1feature_expression); + T1 = L1featurep(T0); + value0 = Null(T1)?ECL_T:ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L25:; + value0 = cl_error(3, VV[6], v3, ECL_SYM("STRING=",824)); + return value0; + } +L7:; + value0 = si_etypecase_error(v1feature_expression, VV[7]); + return value0; + } +} + +#include "lib/alexandria/features.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclq3qz1Rgh1vqFM_kFGycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/features.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclq3qz1Rgh1vqFM_kFGycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defun(VV[8]); /* FEATUREP */ + ecl_function_dispatch(cl_env_copy,VV[9])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/functions.cxx b/lib/alexandria/functions.cxx new file mode 100644 index 0000000..6d59c39 --- /dev/null +++ b/lib/alexandria/functions.cxx @@ -0,0 +1,1383 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/functions.lisp */ +#include +#include "lib/alexandria/functions.eclh" +/* function definition for ENSURE-FUNCTION */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1ensure_function(cl_object v1function_designator) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_functionp(v1function_designator))) { goto L1; } + value0 = v1function_designator; + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = cl_fdefinition(v1function_designator); + return value0; + } +} +/* local function ENSURE-FUNCTIONF/1 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3ensure_functionf_1(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + if (Null(v3)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[26])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC2__lambda5,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = ECL_NIL; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L13; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[0], v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[2],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L13:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L22; +L21:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L22:; + if (v12si__d==ECL_NIL) { goto L28; } + goto L21; +L28:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, VV[0], v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[2],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA5 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2__lambda5(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function ENSURE-FUNCTIONF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC5ensure_functionf(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + v3 = ecl_cdr(v1); + { + cl_object v4; + { + cl_object v5; + v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda22,ECL_NIL,Cblock,1); + v4 = v5; + } + { + cl_object v5; + cl_object v6; + v5 = ECL_NIL; + { + cl_object v7; + v7 = v3; + if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v7; + } + { + cl_object v7; + cl_object v8; + v7 = ecl_list1(ECL_NIL); + v8 = v7; +L10:; + if (!(ecl_endp(v6))) { goto L12; } + goto L11; +L12:; + v5 = ECL_CONS_CAR(v6); + { + cl_object v9; + v9 = ECL_CONS_CDR(v6); + if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v9; + } + { + cl_object v9; + v9 = v8; + if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v9; + } + T2 = ecl_function_dispatch(cl_env_copy,v4)(1, v5); + v8 = ecl_list1(T2); + (ECL_CONS_CDR(T1)=v8,T1); + goto L10; +L11:; + T0 = ecl_cdr(v7); + goto L2; + } + } + } +L2:; + value0 = CONS(ECL_SYM("PROGN",673),T0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function LAMBDA22 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC4__lambda22(cl_object v1x) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_list(2, VV[1], v1x); + return value0; + } +} +/* function definition for DISJOIN */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object L8disjoin(cl_narg narg, cl_object v1predicate, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2more_predicates; + ecl_va_list args; ecl_va_start(args,v1predicate,narg,1); + v2more_predicates = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3; + cl_object v4; + cl_object env1 = env0; + if (Null(cl_functionp(v1predicate))) { goto L2; } + v3 = v1predicate; + goto L1; +L2:; + v3 = cl_fdefinition(v1predicate); +L1:; + { + cl_object v5; + v5 = (VV[0]->symbol.gfdef); + { + cl_object v6; + cl_object v7; + v6 = ECL_NIL; + { + cl_object v8; + v8 = v2more_predicates; + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ecl_list1(ECL_NIL); + v9 = v8; +L12:; + if (!(v7==ECL_NIL)) { goto L14; } + goto L13; +L14:; + v6 = ECL_CONS_CAR(v7); + { + cl_object v10; + v10 = ECL_CONS_CDR(v7); + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v10; + } + { + cl_object v10; + v10 = v9; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v10; + } + T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); + v9 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v9,T0); + goto L12; +L13:; + v4 = _ecl_cdr(v8); + goto L4; + } + } + } +L4:; + env1 = ECL_NIL; + CLV0 = env1 = CONS(v3,env1); /* PREDICATE */ + CLV1 = env1 = CONS(v4,env1); /* MORE-PREDICATES */ + { + cl_object v5; + v5 = ecl_make_cclosure_va((cl_objectfn)LC7__lambda35,env1,Cblock,0); + value0 = v5; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* closure LAMBDA35 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC7__lambda35(cl_narg narg, ...) +{ + cl_object T0; + cl_object CLV0, CLV1, CLV2; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* MORE-PREDICATES */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1arguments; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1arguments = cl_grab_rest_args(args); + CLV2 = env0 = CONS(v1arguments,env0); /* ARGUMENTS */ + ecl_va_end(args); + value0 = cl_apply(2, ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV2)); + if ((value0)!=ECL_NIL) { goto L2; } + { + cl_object v2; + v2 = ecl_make_cclosure_va((cl_objectfn)LC6__lambda36,env0,Cblock,1); + T0 = v2; + } + value0 = cl_some(2, T0, ECL_CONS_CAR(CLV1)); + return value0; +L2:; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA36 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC6__lambda36(cl_narg narg, cl_object v1p, ...) +{ + cl_object T0; + cl_object CLV0, CLV1, CLV2; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV2 = env0; /* ARGUMENTS */ + CLV1 = _ecl_cdr(CLV2); + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = cl_functionp(v1p); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("FUNCTION",398),v1p); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + value0 = cl_apply(2, v1p, ECL_CONS_CAR(CLV2)); + return value0; + } + } +} +/* function definition for CONJOIN */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L10conjoin(cl_narg narg, cl_object v1predicate, ...) +{ + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2more_predicates; + ecl_va_list args; ecl_va_start(args,v1predicate,narg,1); + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1predicate,env0); /* PREDICATE */ + v2more_predicates = cl_grab_rest_args(args); + CLV1 = env0 = CONS(v2more_predicates,env0); /* MORE-PREDICATES */ + ecl_va_end(args); + if (!(ECL_CONS_CAR(CLV1)==ECL_NIL)) { goto L1; } + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; +L1:; + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC9__lambda37,env0,Cblock,0); + value0 = v3; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA37 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC9__lambda37(cl_narg narg, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* MORE-PREDICATES */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1arguments; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1arguments = cl_grab_rest_args(args); + ecl_va_end(args); + if (Null(cl_apply(2, ECL_CONS_CAR(CLV0), v1arguments))) { goto L2; } + { + cl_object v2; + cl_object v3; + cl_object v4tail; + cl_object v5head; + v2 = ecl_cdr(ECL_CONS_CAR(CLV1)); + v3 = ecl_car(ECL_CONS_CAR(CLV1)); + v4tail = v2; + v5head = v3; + goto L10; +L9:; + if ((cl_apply(2, v5head, v1arguments))!=ECL_NIL) { goto L12; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L12:; + { + cl_object v6; + v6 = ecl_cdr(v4tail); + v5head = ecl_car(v4tail); + v4tail = v6; + } +L10:; + if (Null(v4tail)) { goto L17; } + goto L9; +L17:; + value0 = cl_apply(2, v5head, v1arguments); + return value0; + } +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for COMPOSE */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object L13compose(cl_narg narg, cl_object v1function, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2more_functions; + ecl_va_list args; ecl_va_start(args,v1function,narg,1); + v2more_functions = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3; + v3 = ecl_make_cfun((cl_objectfn_fixed)LC12__lambda42,ECL_NIL,Cblock,2); + T0 = v3; + } + value0 = cl_reduce(4, T0, v2more_functions, VV[7], v1function); + return value0; + } +} +/* local function LAMBDA42 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC12__lambda42(cl_object v1f, cl_object v2g) +{ + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object env1 = env0; + if (Null(cl_functionp(v1f))) { goto L2; } + v3 = v1f; + goto L1; +L2:; + v3 = cl_fdefinition(v1f); +L1:; + if (Null(cl_functionp(v2g))) { goto L5; } + v4 = v2g; + goto L4; +L5:; + v4 = cl_fdefinition(v2g); +L4:; + env1 = ECL_NIL; + CLV0 = env1 = CONS(v3,env1); /* F */ + CLV1 = env1 = CONS(v4,env1); /* G */ + { + cl_object v5; + v5 = ecl_make_cclosure_va((cl_objectfn)LC11__lambda47,env1,Cblock,0); + value0 = v5; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* closure LAMBDA47 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC11__lambda47(cl_narg narg, ...) +{ + cl_object T0; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* G */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1arguments; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1arguments = cl_grab_rest_args(args); + ecl_va_end(args); + T0 = cl_apply(2, ECL_CONS_CAR(CLV1), v1arguments); + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, T0); + return value0; + } + } +} +/* local function LAMBDA51 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC15__lambda51(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4function; + T0 = ecl_car(v1); + if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + T0 = ecl_caadr(v1); + if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + v3 = ecl_cddr(v1); + goto L1; +L2:; + v3 = ecl_cdr(v1); +L1:; + if (!(v3==ECL_NIL)) { goto L6; } + ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L6:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4function = v5; + } + { + cl_object v5args; + cl_object v6funs; + v5args = CONS(v4function,v3); + { + cl_fixnum v7; + v7 = ecl_length(v5args); + v6funs = ecl_function_dispatch(cl_env_copy,VV[31])(2, ecl_make_fixnum(v7), VV[9]) /* MAKE-GENSYM-LIST */; + } + { + cl_object v7f; + cl_object v8; + v7f = ECL_NIL; + { + cl_object v9; + v9 = v6funs; + if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v9; + } + { + cl_object v9arg; + cl_object v10; + v9arg = ECL_NIL; + v10 = v5args; + { + cl_object v11; + cl_object v12; + v11 = ecl_list1(ECL_NIL); + v12 = v11; +L22:; + if (!(ecl_endp(v8))) { goto L24; } + goto L23; +L24:; + v7f = ECL_CONS_CAR(v8); + { + cl_object v13; + v13 = ECL_CONS_CDR(v8); + if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = v13; + } + if (!(ecl_endp(v10))) { goto L32; } + goto L23; +L32:; + v9arg = ECL_CONS_CAR(v10); + { + cl_object v13; + v13 = ECL_CONS_CDR(v10); + if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v10 = v13; + } + { + cl_object v13; + v13 = v12; + if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v13; + } + T2 = cl_list(2, VV[0], v9arg); + T3 = cl_list(2, v7f, T2); + v12 = ecl_list1(T3); + (ECL_CONS_CDR(T1)=v12,T1); + goto L22; +L23:; + T0 = ecl_cdr(v11); + goto L13; + } + } + } +L13:; + T1 = LC14compose_1(v6funs); + T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[11], VV[12], T1); + value0 = cl_list(4, ECL_SYM("LET",479), T0, VV[10], T2); + return value0; + } + } + } +} +/* local function COMPOSE-1 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC14compose_1(cl_object v1funs) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(ecl_cdr(v1funs))) { goto L1; } + T0 = ecl_car(v1funs); + T2 = ecl_cdr(v1funs); + T1 = LC14compose_1(T2); + value0 = cl_list(3, ECL_SYM("FUNCALL",396), T0, T1); + return value0; +L1:; + T0 = ecl_car(v1funs); + value0 = cl_list(3, ECL_SYM("APPLY",91), T0, VV[8]); + return value0; + } +} +/* function definition for MULTIPLE-VALUE-COMPOSE */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object L18multiple_value_compose(cl_narg narg, cl_object v1function, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2more_functions; + ecl_va_list args; ecl_va_start(args,v1function,narg,1); + v2more_functions = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3; + v3 = ecl_make_cfun((cl_objectfn_fixed)LC17__lambda61,ECL_NIL,Cblock,2); + T0 = v3; + } + value0 = cl_reduce(4, T0, v2more_functions, VV[7], v1function); + return value0; + } +} +/* local function LAMBDA61 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC17__lambda61(cl_object v1f, cl_object v2g) +{ + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object env1 = env0; + if (Null(cl_functionp(v1f))) { goto L2; } + v3 = v1f; + goto L1; +L2:; + v3 = cl_fdefinition(v1f); +L1:; + if (Null(cl_functionp(v2g))) { goto L5; } + v4 = v2g; + goto L4; +L5:; + v4 = cl_fdefinition(v2g); +L4:; + env1 = ECL_NIL; + CLV0 = env1 = CONS(v3,env1); /* F */ + CLV1 = env1 = CONS(v4,env1); /* G */ + { + cl_object v5; + v5 = ecl_make_cclosure_va((cl_objectfn)LC16__lambda66,env1,Cblock,0); + value0 = v5; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* closure LAMBDA66 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC16__lambda66(cl_narg narg, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* G */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1arguments; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1arguments = cl_grab_rest_args(args); + ecl_va_end(args); + { + struct ecl_stack_frame _ecl_inner_frame_aux; + cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0); + { + cl_object v2; + v2 = _ecl_inner_frame; + { + cl_object v3; + v3 = ECL_CONS_CAR(CLV0); + cl_env_copy->values[0] = cl_apply(2, ECL_CONS_CAR(CLV1), v1arguments); + ecl_stack_frame_push_values(v2); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0;cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); + value0 = cl_env_copy->values[0]; + } + } + ecl_stack_frame_close(_ecl_inner_frame); + } + return value0; + } + } +} +/* local function LAMBDA72 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC20__lambda72(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4function; + T0 = ecl_car(v1); + if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + T0 = ecl_caadr(v1); + if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + v3 = ecl_cddr(v1); + goto L1; +L2:; + v3 = ecl_cdr(v1); +L1:; + if (!(v3==ECL_NIL)) { goto L6; } + ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L6:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4function = v5; + } + { + cl_object v5args; + cl_object v6funs; + v5args = CONS(v4function,v3); + { + cl_fixnum v7; + v7 = ecl_length(v5args); + v6funs = ecl_function_dispatch(cl_env_copy,VV[31])(2, ecl_make_fixnum(v7), VV[14]) /* MAKE-GENSYM-LIST */; + } + { + cl_object v7; + v7 = (ECL_SYM("LIST",483)->symbol.gfdef); + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v6funs; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ECL_NIL; + v11 = v5args; + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L23:; + if (!(ecl_endp(v9))) { goto L25; } + goto L24; +L25:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v14; + v14 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v14; + } + if (!(ecl_endp(v11))) { goto L33; } + goto L24; +L33:; + v10 = ECL_CONS_CAR(v11); + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v14; + } + T2 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); + v13 = ecl_list1(T2); + (ECL_CONS_CDR(T1)=v13,T1); + goto L23; +L24:; + T0 = ecl_cdr(v12); + goto L13; + } + } + } + } +L13:; + T1 = LC19compose_1(v6funs); + T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[11], VV[12], T1); + value0 = cl_list(4, ECL_SYM("LET",479), T0, VV[10], T2); + return value0; + } + } + } +} +/* local function COMPOSE-1 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC19compose_1(cl_object v1funs) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(ecl_cdr(v1funs))) { goto L1; } + T0 = ecl_car(v1funs); + T2 = ecl_cdr(v1funs); + T1 = LC19compose_1(T2); + value0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",575), T0, T1); + return value0; +L1:; + T0 = ecl_car(v1funs); + value0 = cl_list(3, ECL_SYM("APPLY",91), T0, VV[8]); + return value0; + } +} +/* function definition for CURRY */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object L22curry(cl_narg narg, cl_object v1function, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2arguments; + ecl_va_list args; ecl_va_start(args,v1function,narg,1); + v2arguments = cl_grab_rest_args(args); + env0 = ECL_NIL; + CLV0 = env0 = CONS(v2arguments,env0); /* ARGUMENTS */ + ecl_va_end(args); + { + cl_object env1 = env0; + if (Null(cl_functionp(v1function))) { goto L2; } + T0 = v1function; + goto L1; +L2:; + T0 = cl_fdefinition(v1function); +L1:; + CLV1 = env1 = CONS(T0,env1); /* FN */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC21__lambda86,env1,Cblock,0); + value0 = v3; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* closure LAMBDA86 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC21__lambda86(cl_narg narg, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* FN */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1more; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1more = cl_grab_rest_args(args); + ecl_va_end(args); + { + struct ecl_stack_frame _ecl_inner_frame_aux; + cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0); + { + cl_object v2; + v2 = _ecl_inner_frame; + { + cl_object v3; + v3 = ECL_CONS_CAR(CLV1); + cl_env_copy->values[0] = cl_values_list(ECL_CONS_CAR(CLV0)); + ecl_stack_frame_push_values(v2); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + cl_env_copy->values[0] = cl_values_list(v1more); + ecl_stack_frame_push_values(v2); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0;cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); + value0 = cl_env_copy->values[0]; + } + } + ecl_stack_frame_close(_ecl_inner_frame); + } + return value0; + } + } +} +/* local function LAMBDA92 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC23__lambda92(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4function; + T0 = ecl_car(v1); + if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + T0 = ecl_caadr(v1); + if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + v3 = ecl_cddr(v1); + goto L1; +L2:; + v3 = ecl_cdr(v1); +L1:; + if (!(v3==ECL_NIL)) { goto L6; } + ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L6:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4function = v5; + } + { + cl_object v5; + cl_object v6; + { + cl_fixnum v7; + v7 = ecl_length(v3); + v5 = ecl_function_dispatch(cl_env_copy,VV[31])(2, ecl_make_fixnum(v7), VV[16]) /* MAKE-GENSYM-LIST */; + } + v6 = cl_gensym(1, VV[17]); + T0 = cl_list(2, VV[0], v4function); + T1 = cl_list(2, v6, T0); + { + cl_object v7; + v7 = (ECL_SYM("LIST",483)->symbol.gfdef); + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v5; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ECL_NIL; + { + cl_object v12; + v12 = v3; + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v12; + } + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L25:; + if (!(ecl_endp(v9))) { goto L27; } + goto L26; +L27:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v14; + v14 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v14; + } + if (!(ecl_endp(v11))) { goto L35; } + goto L26; +L35:; + v10 = ECL_CONS_CAR(v11); + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T3 = v14; + } + T4 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); + v13 = ecl_list1(T4); + (ECL_CONS_CDR(T3)=v13,T3); + goto L25; +L26:; + T2 = ecl_cdr(v12); + goto L13; + } + } + } + } +L13:; + T3 = CONS(T1,T2); + T4 = ecl_append(v5,VV[19]); + T5 = cl_listX(3, ECL_SYM("APPLY",91), v6, T4); + T6 = cl_list(3, ECL_SYM("LAMBDA",454), VV[18], T5); + value0 = cl_list(4, ECL_SYM("LET",479), T3, VV[10], T6); + return value0; + } + } + } +} +/* function definition for RCURRY */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object L25rcurry(cl_narg narg, cl_object v1function, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2arguments; + ecl_va_list args; ecl_va_start(args,v1function,narg,1); + v2arguments = cl_grab_rest_args(args); + env0 = ECL_NIL; + CLV0 = env0 = CONS(v2arguments,env0); /* ARGUMENTS */ + ecl_va_end(args); + { + cl_object env1 = env0; + if (Null(cl_functionp(v1function))) { goto L2; } + T0 = v1function; + goto L1; +L2:; + T0 = cl_fdefinition(v1function); +L1:; + CLV1 = env1 = CONS(T0,env1); /* FN */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC24__lambda108,env1,Cblock,0); + value0 = v3; + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* closure LAMBDA108 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC24__lambda108(cl_narg narg, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV1 = env0; /* FN */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1more; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1more = cl_grab_rest_args(args); + ecl_va_end(args); + { + struct ecl_stack_frame _ecl_inner_frame_aux; + cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0); + { + cl_object v2; + v2 = _ecl_inner_frame; + { + cl_object v3; + v3 = ECL_CONS_CAR(CLV1); + cl_env_copy->values[0] = cl_values_list(v1more); + ecl_stack_frame_push_values(v2); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + cl_env_copy->values[0] = cl_values_list(ECL_CONS_CAR(CLV0)); + ecl_stack_frame_push_values(v2); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0;cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); + value0 = cl_env_copy->values[0]; + } + } + ecl_stack_frame_close(_ecl_inner_frame); + } + return value0; + } + } +} +/* local function NAMED-LAMBDA */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC26named_lambda(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4name; + cl_object v5lambda_list; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4name = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5lambda_list = v6; + } + T0 = cl_listX(3, v4name, v5lambda_list, v3); + T1 = ecl_list1(T0); + T2 = cl_list(2, ECL_SYM("FUNCTION",398), v4name); + value0 = cl_list(3, ECL_SYM("LABELS",453), T1, T2); + return value0; + } + } +} + +#include "lib/alexandria/functions.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclNfUD6Zhj9JNJM_QVGycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/functions.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclNfUD6Zhj9JNJM_QVGycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[2]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[3], VVtemp[4]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[5]) /* ANNOTATE */; + ecl_cmp_defun(VV[22]); /* ENSURE-FUNCTION */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[6]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[7]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[24]); /* ENSURE-FUNCTIONF/1 */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[13]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[27]); /* ENSURE-FUNCTIONF */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[17]) /* ANNOTATE */; + ecl_cmp_defun(VV[28]); /* DISJOIN */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[18]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[19], VVtemp[20]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[17]) /* ANNOTATE */; + ecl_cmp_defun(VV[29]); /* CONJOIN */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[21]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[23]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[24]) /* ANNOTATE */; + ecl_cmp_defun(VV[30]); /* COMPOSE */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[25]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC15__lambda51,ECL_NIL,Cblock,2); + T0 = v1; + } + si_put_sysprop(VV[6], ECL_SYM("COMPILER-MACRO",240), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[28], VVtemp[29]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[24]) /* ANNOTATE */; + ecl_cmp_defun(VV[32]); /* MULTIPLE-VALUE-COMPOSE */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[30]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC20__lambda72,ECL_NIL,Cblock,2); + T0 = v1; + } + si_put_sysprop(VV[13], ECL_SYM("COMPILER-MACRO",240), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; + ecl_cmp_defun(VV[33]); /* CURRY */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[15], ECL_SYM("FUNCTION",398), VVtemp[36]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC23__lambda92,ECL_NIL,Cblock,2); + T0 = v1; + } + si_put_sysprop(VV[15], ECL_SYM("COMPILER-MACRO",240), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[37], VVtemp[38]) /* ANNOTATE */; + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[40]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; + ecl_cmp_defun(VV[34]); /* RCURRY */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[41]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LOCATION",1862), VVtemp[42], VVtemp[43]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[44]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[35]); /* NAMED-LAMBDA */ + ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[21], ECL_SYM("FUNCTION",398), VVtemp[45]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/hash-tables.cxx b/lib/alexandria/hash-tables.cxx new file mode 100644 index 0000000..5e4017f --- /dev/null +++ b/lib/alexandria/hash-tables.cxx @@ -0,0 +1,676 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/hash-tables.lisp */ +#include +#include "lib/alexandria/hash-tables.eclh" +/* function definition for COPY-HASH-TABLE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L2copy_hash_table(cl_narg narg, cl_object v1table, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2test; + cl_object v3size; + cl_object v4rehash_size; + cl_object v5rehash_threshold; + ecl_va_list args; ecl_va_start(args,v1table,narg,1); + { + cl_object keyvars[10]; + cl_parse_key(args,5,L2copy_hash_tablekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + env0 = ECL_NIL; + CLV0 = env0 = CONS(keyvars[0],env0); /* KEY */ + v2test = keyvars[1]; + v3size = keyvars[2]; + v4rehash_size = keyvars[3]; + v5rehash_threshold = keyvars[4]; + } + value0 = ECL_CONS_CAR(CLV0); + if ((value0)!=ECL_NIL) { goto L4; } + ECL_CONS_CAR(CLV0) = ECL_SYM("IDENTITY",428); + goto L2; +L4:; + ECL_CONS_CAR(CLV0) = value0; + goto L2; +L2:; + value0 = v2test; + if ((value0)!=ECL_NIL) { goto L9; } + v2test = cl_hash_table_test(v1table); + goto L7; +L9:; + v2test = value0; + goto L7; +L7:; + value0 = v3size; + if ((value0)!=ECL_NIL) { goto L14; } + v3size = cl_hash_table_size(v1table); + goto L12; +L14:; + v3size = value0; + goto L12; +L12:; + value0 = v4rehash_size; + if ((value0)!=ECL_NIL) { goto L19; } + v4rehash_size = cl_hash_table_rehash_size(v1table); + goto L17; +L19:; + v4rehash_size = value0; + goto L17; +L17:; + value0 = v5rehash_threshold; + if ((value0)!=ECL_NIL) { goto L24; } + v5rehash_threshold = cl_hash_table_rehash_threshold(v1table); + goto L22; +L24:; + v5rehash_threshold = value0; + goto L22; +L22:; + { + cl_object env1 = env0; + T0 = cl_make_hash_table(8, ECL_SYM("TEST",1350), v2test, ECL_SYM("SIZE",1342), v3size, ECL_SYM("REHASH-SIZE",1331), v4rehash_size, ECL_SYM("REHASH-THRESHOLD",1332), v5rehash_threshold); + CLV1 = env1 = CONS(T0,env1); /* COPY */ + { + cl_object v6; + v6 = ecl_make_cclosure_va((cl_objectfn)LC1__lambda5,env1,Cblock,2); + T0 = v6; + } + cl_maphash(T0, v1table); + value0 = ECL_CONS_CAR(CLV1); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA5 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1__lambda5(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object T0; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* COPY */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v2v); + value0 = si_hash_set(v1k, ECL_CONS_CAR(CLV1), T0); + return value0; + } + } +} +/* function definition for MAPHASH-KEYS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4maphash_keys(cl_object v1function, cl_object v2table) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC3__lambda9,env0,Cblock,2); + T0 = v3; + } + value0 = cl_maphash(T0, v2table); + return value0; + } +} +/* closure LAMBDA9 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3__lambda9(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* FUNCTION */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v1k); + return value0; + } + } +} +/* function definition for MAPHASH-VALUES */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L6maphash_values(cl_object v1function, cl_object v2table) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC5__lambda10,env0,Cblock,2); + T0 = v3; + } + value0 = cl_maphash(T0, v2table); + return value0; + } +} +/* closure LAMBDA10 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC5__lambda10(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* FUNCTION */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v2v); + return value0; + } + } +} +/* function definition for HASH-TABLE-KEYS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L9hash_table_keys(cl_object v1table) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object env1 = env0; + env1 = ECL_NIL; + CLV0 = env1 = CONS(ECL_NIL,env1); /* KEYS */ + { + cl_object v2; + cl_object env2 = env1; + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC7__lambda13,env2,Cblock,1); + v2 = v3; + } + CLV1 = env2 = CONS(v2,env2); /* FUNCTION */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC8__lambda15,env2,Cblock,2); + T0 = v3; + } + cl_maphash(T0, v1table); + } + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA13 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC7__lambda13(cl_narg narg, cl_object v1k, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* KEYS */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + ECL_CONS_CAR(CLV0) = CONS(v1k,ECL_CONS_CAR(CLV0)); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA15 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC8__lambda15(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* FUNCTION */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v1k); + return value0; + } + } +} +/* function definition for HASH-TABLE-VALUES */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L12hash_table_values(cl_object v1table) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object env1 = env0; + env1 = ECL_NIL; + CLV0 = env1 = CONS(ECL_NIL,env1); /* VALUES */ + { + cl_object v2; + cl_object env2 = env1; + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC10__lambda18,env2,Cblock,1); + v2 = v3; + } + CLV1 = env2 = CONS(v2,env2); /* FUNCTION */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC11__lambda20,env2,Cblock,2); + T0 = v3; + } + cl_maphash(T0, v1table); + } + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA18 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC10__lambda18(cl_narg narg, cl_object v1v, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* VALUES */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + ECL_CONS_CAR(CLV0) = CONS(v1v,ECL_CONS_CAR(CLV0)); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA20 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC11__lambda20(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* FUNCTION */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v2v); + return value0; + } + } +} +/* function definition for HASH-TABLE-ALIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L14hash_table_alist(cl_object v1table) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object env1 = env0; + env1 = ECL_NIL; + CLV0 = env1 = CONS(ECL_NIL,env1); /* ALIST */ + { + cl_object v2; + v2 = ecl_make_cclosure_va((cl_objectfn)LC13__lambda21,env1,Cblock,2); + T0 = v2; + } + cl_maphash(T0, v1table); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA21 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC13__lambda21(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object T0; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* ALIST */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = CONS(v1k,v2v); + ECL_CONS_CAR(CLV0) = CONS(T0,ECL_CONS_CAR(CLV0)); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for HASH-TABLE-PLIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L16hash_table_plist(cl_object v1table) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object env1 = env0; + env1 = ECL_NIL; + CLV0 = env1 = CONS(ECL_NIL,env1); /* PLIST */ + { + cl_object v2; + v2 = ecl_make_cclosure_va((cl_objectfn)LC15__lambda23,env1,Cblock,2); + T0 = v2; + } + cl_maphash(T0, v1table); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA23 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC15__lambda23(cl_narg narg, cl_object v1k, cl_object v2v, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* PLIST */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + ECL_CONS_CAR(CLV0) = cl_listX(3, v1k, v2v, ECL_CONS_CAR(CLV0)); + value0 = ECL_CONS_CAR(CLV0); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ALIST-HASH-TABLE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L17alist_hash_table(cl_narg narg, cl_object v1alist, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2hash_table_initargs; + ecl_va_list args; ecl_va_start(args,v1alist,narg,1); + v2hash_table_initargs = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3table; + T0 = (ECL_SYM("MAKE-HASH-TABLE",530)->symbol.gfdef); + v3table = cl_apply(2, T0, v2hash_table_initargs); + { + cl_object v4; + v4 = v1alist; + goto L7; +L6:; + { + cl_object v5cons; + v5cons = ecl_car(v4); + T0 = ecl_car(v5cons); + T1 = ecl_cdr(v5cons); + si_hash_set(T0, v3table, T1); + } + v4 = ecl_cdr(v4); +L7:; + if (Null(v4)) { goto L14; } + goto L6; +L14:; + } + value0 = v3table; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for PLIST-HASH-TABLE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L18plist_hash_table(cl_narg narg, cl_object v1plist, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2hash_table_initargs; + ecl_va_list args; ecl_va_start(args,v1plist,narg,1); + v2hash_table_initargs = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3table; + T0 = (ECL_SYM("MAKE-HASH-TABLE",530)->symbol.gfdef); + v3table = cl_apply(2, T0, v2hash_table_initargs); + { + cl_object v4tail; + v4tail = v1plist; + goto L7; +L6:; + T0 = ecl_car(v4tail); + T1 = ecl_cadr(v4tail); + si_hash_set(T0, v3table, T1); + v4tail = ecl_cddr(v4tail); +L7:; + if (Null(v4tail)) { goto L12; } + goto L6; +L12:; + } + value0 = v3table; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function ENSURE-GETHASH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC19ensure_gethash(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4key; + cl_object v5hash_table; + cl_object v6default; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v7; + v7 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4key = v7; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v7; + v7 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5hash_table = v7; + } + if (Null(v3)) { goto L15; } + { + cl_object v7; + v7 = ecl_car(v3); + v3 = ecl_cdr(v3); + v6default = v7; + goto L14; + } +L15:; + v6default = ECL_NIL; +L14:; + if (Null(v3)) { goto L20; } + ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L20:; + T0 = cl_list(3, ECL_SYM("GETHASH",415), v4key, v5hash_table); + T1 = cl_list(3, ECL_SYM("GETHASH",415), v4key, v5hash_table); + T2 = cl_list(3, ECL_SYM("SETF",752), T1, v6default); + T3 = cl_list(3, ECL_SYM("VALUES",897), T2, ECL_NIL); + T4 = cl_list(4, ECL_SYM("IF",948), VV[11], VV[12], T3); + value0 = cl_list(4, ECL_SYM("MULTIPLE-VALUE-BIND",574), VV[10], T0, T4); + return value0; + } + } +} + +#include "lib/alexandria/hash-tables.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecl7ZmCSEYoe0NCM_eTFycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/hash-tables.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl7ZmCSEYoe0NCM_eTFycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defun(VV[13]); /* COPY-HASH-TABLE */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[5]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[20]); /* MAPHASH-KEYS */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[9]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[1], ECL_SYM("INLINE",436), VVtemp[10]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[11]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[21]); /* MAPHASH-VALUES */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[2], ECL_SYM("INLINE",436), VVtemp[15]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[22]); /* HASH-TABLE-KEYS */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[23]); /* HASH-TABLE-VALUES */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[22]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[23], VVtemp[24]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[24]); /* HASH-TABLE-ALIST */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[25]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[25]); /* HASH-TABLE-PLIST */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[28]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[31]) /* ANNOTATE */; + ecl_cmp_defun(VV[26]); /* ALIST-HASH-TABLE */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[7], ECL_SYM("FUNCTION",398), VVtemp[32]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; + ecl_cmp_defun(VV[27]); /* PLIST-HASH-TABLE */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[36]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[37], VVtemp[38]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[39]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[28]); /* ENSURE-GETHASH */ + ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[9], ECL_SYM("FUNCTION",398), VVtemp[40]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/io.cxx b/lib/alexandria/io.cxx new file mode 100644 index 0000000..1def85f --- /dev/null +++ b/lib/alexandria/io.cxx @@ -0,0 +1,1014 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/io.lisp */ +#include +#include "lib/alexandria/io.eclh" +/* local function WITH-OPEN-FILE* */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1with_open_file_(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6stream; + cl_object v7filespec; + cl_object v8; + cl_object v9direction; + cl_object v10; + cl_object v11element_type; + cl_object v12; + cl_object v13if_exists; + cl_object v14; + cl_object v15if_does_not_exist; + cl_object v16; + cl_object v17external_format; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v18; + v18 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v18; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v18; + v18 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6stream = v18; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v18; + v18 = ecl_car(v5); + v5 = ecl_cdr(v5); + v7filespec = v18; + } + v8 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("DIRECTION",1246)) /* SEARCH-KEYWORD */; + if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L23; } + v9direction = ECL_NIL; + goto L22; +L23:; + v9direction = v8; +L22:; + v10 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("ELEMENT-TYPE",1252)) /* SEARCH-KEYWORD */; + if (!((v10)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L27; } + v11element_type = ECL_NIL; + goto L26; +L27:; + v11element_type = v10; +L26:; + v12 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("IF-EXISTS",1276)) /* SEARCH-KEYWORD */; + if (!((v12)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L31; } + v13if_exists = ECL_NIL; + goto L30; +L31:; + v13if_exists = v12; +L30:; + v14 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("IF-DOES-NOT-EXIST",1274)) /* SEARCH-KEYWORD */; + if (!((v14)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L35; } + v15if_does_not_exist = ECL_NIL; + goto L34; +L35:; + v15if_does_not_exist = v14; +L34:; + v16 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("EXTERNAL-FORMAT",1264)) /* SEARCH-KEYWORD */; + if (!((v16)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L39; } + v17external_format = ECL_NIL; + goto L38; +L39:; + v17external_format = v16; +L38:; + ecl_function_dispatch(cl_env_copy,VV[37])(2, v5, VV[1]) /* CHECK-KEYWORD */; + { + cl_object v18; + cl_object v19; + cl_object v20; + cl_object v21; + cl_object v22; + v18 = cl_gensym(1, VV[2]); + v19 = cl_gensym(1, VV[3]); + v20 = cl_gensym(1, VV[4]); + v21 = cl_gensym(1, VV[5]); + v22 = cl_gensym(1, VV[6]); + T0 = cl_list(2, v18, v9direction); + T1 = cl_list(2, v19, v11element_type); + T2 = cl_list(2, v20, v13if_exists); + T3 = cl_list(2, v21, v15if_does_not_exist); + T4 = cl_list(2, v22, v17external_format); + T5 = cl_list(5, T0, T1, T2, T3, T4); + T7 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("DIRECTION",1246), v18); + T8 = cl_list(3, ECL_SYM("WHEN",907), v18, T7); + T9 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("ELEMENT-TYPE",1252), v19); + T10 = cl_list(3, ECL_SYM("WHEN",907), v19, T9); + T11 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("IF-EXISTS",1276), v20); + T12 = cl_list(3, ECL_SYM("WHEN",907), v20, T11); + T13 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("IF-DOES-NOT-EXIST",1274), v21); + T14 = cl_list(3, ECL_SYM("WHEN",907), v21, T13); + T15 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("EXTERNAL-FORMAT",1264), v22); + T16 = cl_list(3, ECL_SYM("WHEN",907), v22, T15); + T17 = cl_list(6, ECL_SYM("APPEND",90), T8, T10, T12, T14, T16); + T18 = cl_list(4, ECL_SYM("APPLY",91), VV[7], v7filespec, T17); + T19 = cl_list(2, v6stream, T18); + T6 = cl_listX(3, ECL_SYM("WITH-OPEN-STREAM",914), T19, v3); + value0 = cl_list(3, ECL_SYM("LET",479), T5, T6); + return value0; + } + } + } +} +/* local function WITH-INPUT-FROM-FILE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2with_input_from_file(cl_object v1, cl_object v2) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6stream_name; + cl_object v7file_name; + cl_object v8; + cl_object v9direction_p; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v10; + v10 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v10; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6stream_name = v10; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v7file_name = v10; + } + v8 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("DIRECTION",1246)) /* SEARCH-KEYWORD */; + { + bool v10; + v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",2037)); + v9direction_p = (v10)?ECL_NIL:ECL_T; + } + ecl_function_dispatch(cl_env_copy,VV[37])(3, v5, VV[9], ECL_T) /* CHECK-KEYWORD */; + if (Null(v9direction_p)) { goto L24; } + cl_error(1, VV[10]); +L24:; + T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286), v5); + value0 = cl_listX(3, VV[0], T0, v3); + return value0; + } + } +} +/* local function WITH-OUTPUT-TO-FILE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3with_output_to_file(cl_object v1, cl_object v2) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6stream_name; + cl_object v7file_name; + cl_object v8; + cl_object v9direction_p; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v10; + v10 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v10; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6stream_name = v10; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v7file_name = v10; + } + v8 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("DIRECTION",1246)) /* SEARCH-KEYWORD */; + { + bool v10; + v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",2037)); + v9direction_p = (v10)?ECL_NIL:ECL_T; + } + ecl_function_dispatch(cl_env_copy,VV[37])(3, v5, VV[9], ECL_T) /* CHECK-KEYWORD */; + if (Null(v9direction_p)) { goto L24; } + cl_error(1, VV[12]); +L24:; + T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316), v5); + value0 = cl_listX(3, VV[0], T0, v3); + return value0; + } + } +} +/* function definition for READ-FILE-INTO-STRING */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4read_file_into_string(volatile cl_narg narg, cl_object volatile v1pathname, ...) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object volatile env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object volatile v2buffer_size; + cl_object volatile v3external_format; + ecl_va_list args; ecl_va_start(args,v1pathname,narg,1); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L4read_file_into_stringkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v2buffer_size = ecl_make_fixnum(4096); + } else { + v2buffer_size = keyvars[0]; + } + v3external_format = keyvars[1]; + } + { + volatile cl_object v4file_stream; + T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); + if (Null(ECL_SYM("INPUT",1286))) { goto L5; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286)); + goto L4; +L5:; + T1 = ECL_NIL; +L4:; + goto L8; + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), ECL_NIL); + goto L7; +L8:; + T2 = ECL_NIL; +L7:; + goto L11; + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), ECL_NIL); + goto L10; +L11:; + T3 = ECL_NIL; +L10:; + goto L14; + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + goto L13; +L14:; + T4 = ECL_NIL; +L13:; + if (Null(v3external_format)) { goto L17; } + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), v3external_format); + goto L16; +L17:; + T5 = ECL_NIL; +L16:; + T6 = cl_append(5, T1, T2, T3, T4, T5); + v4file_stream = cl_apply(3, T0, v1pathname, T6); + { + volatile bool unwinding = FALSE; + cl_index v5=ECL_STACK_INDEX(cl_env_copy),v6; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /* *PRINT-PRETTY* */ + { + volatile cl_object v7datum; + v7datum = cl_make_string_output_stream(0); + { + volatile bool unwinding = FALSE; + cl_index v8=ECL_STACK_INDEX(cl_env_copy),v9; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + { + cl_object v10buffer; + v10buffer = si_make_pure_array(ECL_SYM("CHARACTER",224), v2buffer_size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + { + cl_object v11bytes_read; + v11bytes_read = ECL_NIL; +L25:; + v11bytes_read = cl_read_sequence(2, v10buffer, v4file_stream); + cl_write_sequence(6, v10buffer, v7datum, ECL_SYM("START",1344), ecl_make_fixnum(0), ECL_SYM("END",1253), v11bytes_read); + if (ecl_number_equalp(v11bytes_read,v2buffer_size)) { goto L30; } + goto L26; +L30:; + goto L25; +L26:; + } + } + cl_env_copy->values[0] = cl_get_output_stream_string(v7datum); + } + ecl_frs_pop(cl_env_copy); + v9=ecl_stack_push_values(cl_env_copy); + cl_close(1, v7datum); + ecl_stack_pop_values(cl_env_copy,v9); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v8); + ecl_bds_unwind1(cl_env_copy); + } + } + } + ecl_frs_pop(cl_env_copy); + v6=ecl_stack_push_values(cl_env_copy); + cl_close(1, v4file_stream); + ecl_stack_pop_values(cl_env_copy,v6); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v5); + return cl_env_copy->values[0]; + } + } + } +} +/* function definition for WRITE-STRING-INTO-FILE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5write_string_into_file(volatile cl_narg narg, cl_object volatile v1string, cl_object volatile v2pathname, ...) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object volatile env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object volatile v3if_exists; + cl_object volatile v4if_does_not_exist; + cl_object volatile v5external_format; + ecl_va_list args; ecl_va_start(args,v2pathname,narg,2); + { + cl_object keyvars[6]; + cl_parse_key(args,3,L5write_string_into_filekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[3])) { + v3if_exists = ECL_SYM("ERROR",1257); + } else { + v3if_exists = keyvars[0]; + } + v4if_does_not_exist = keyvars[1]; + v5external_format = keyvars[2]; + } + { + volatile cl_object v6file_stream; + T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); + if (Null(ECL_SYM("OUTPUT",1316))) { goto L5; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316)); + goto L4; +L5:; + T1 = ECL_NIL; +L4:; + goto L8; + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), ECL_NIL); + goto L7; +L8:; + T2 = ECL_NIL; +L7:; + if (Null(v3if_exists)) { goto L11; } + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), v3if_exists); + goto L10; +L11:; + T3 = ECL_NIL; +L10:; + if (Null(v4if_does_not_exist)) { goto L14; } + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), v4if_does_not_exist); + goto L13; +L14:; + T4 = ECL_NIL; +L13:; + if (Null(v5external_format)) { goto L17; } + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), v5external_format); + goto L16; +L17:; + T5 = ECL_NIL; +L16:; + T6 = cl_append(5, T1, T2, T3, T4, T5); + v6file_stream = cl_apply(3, T0, v2pathname, T6); + { + volatile bool unwinding = FALSE; + cl_index v7=ECL_STACK_INDEX(cl_env_copy),v8; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + cl_env_copy->values[0] = cl_write_sequence(2, v1string, v6file_stream); + } + ecl_frs_pop(cl_env_copy); + v8=ecl_stack_push_values(cl_env_copy); + cl_close(1, v6file_stream); + ecl_stack_pop_values(cl_env_copy,v8); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v7); + return cl_env_copy->values[0]; + } + } + } +} +/* function definition for READ-FILE-INTO-BYTE-VECTOR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L6read_file_into_byte_vector(cl_object volatile v1pathname) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object volatile env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + volatile cl_object v2stream; + T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); + if (Null(ECL_SYM("INPUT",1286))) { goto L4; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286)); + goto L3; +L4:; + T1 = ECL_NIL; +L3:; + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), VV[16]); + goto L6; + T2 = ECL_NIL; +L6:; + goto L10; + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), ECL_NIL); + goto L9; +L10:; + T3 = ECL_NIL; +L9:; + goto L13; + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + goto L12; +L13:; + T4 = ECL_NIL; +L12:; + goto L16; + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + goto L15; +L16:; + T5 = ECL_NIL; +L15:; + T6 = cl_append(5, T1, T2, T3, T4, T5); + v2stream = cl_apply(3, T0, v1pathname, T6); + { + volatile bool unwinding = FALSE; + cl_index v3=ECL_STACK_INDEX(cl_env_copy),v4; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + { + cl_object v5length; + v5length = cl_file_length(v2stream); + goto L22; +L21:; + si_assert_failure(1, ECL_SYM("LENGTH",478)); +L22:; + if ((v5length)!=ECL_NIL) { goto L25; } + goto L21; +L25:; + { + cl_object v6result; + v6result = si_make_pure_array(ECL_SYM("BYTE8",1365), v5length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + cl_read_sequence(2, v6result, v2stream); + cl_env_copy->values[0] = v6result; + cl_env_copy->nvalues = 1; + } + } + } + ecl_frs_pop(cl_env_copy); + v4=ecl_stack_push_values(cl_env_copy); + cl_close(1, v2stream); + ecl_stack_pop_values(cl_env_copy,v4); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v3); + return cl_env_copy->values[0]; + } + } + } +} +/* function definition for WRITE-BYTE-VECTOR-INTO-FILE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L7write_byte_vector_into_file(volatile cl_narg narg, cl_object volatile v1bytes, cl_object volatile v2pathname, ...) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object volatile env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object volatile v3if_exists; + cl_object volatile v4if_does_not_exist; + ecl_va_list args; ecl_va_start(args,v2pathname,narg,2); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L7write_byte_vector_into_filekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v3if_exists = ECL_SYM("ERROR",1257); + } else { + v3if_exists = keyvars[0]; + } + v4if_does_not_exist = keyvars[1]; + } + { + cl_object v5; + v5 = v1bytes; + if ((cl_typep(2, v5, VV[18]))!=ECL_NIL) { goto L4; } + v1bytes = si_do_check_type(v5, VV[18], ECL_NIL, VV[19]); +L4:; + } + { + volatile cl_object v5stream; + T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); + if (Null(ECL_SYM("OUTPUT",1316))) { goto L10; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316)); + goto L9; +L10:; + T1 = ECL_NIL; +L9:; + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), VV[16]); + goto L12; + T2 = ECL_NIL; +L12:; + if (Null(v3if_exists)) { goto L16; } + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), v3if_exists); + goto L15; +L16:; + T3 = ECL_NIL; +L15:; + if (Null(v4if_does_not_exist)) { goto L19; } + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), v4if_does_not_exist); + goto L18; +L19:; + T4 = ECL_NIL; +L18:; + goto L22; + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + goto L21; +L22:; + T5 = ECL_NIL; +L21:; + T6 = cl_append(5, T1, T2, T3, T4, T5); + v5stream = cl_apply(3, T0, v2pathname, T6); + { + volatile bool unwinding = FALSE; + cl_index v6=ECL_STACK_INDEX(cl_env_copy),v7; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + cl_env_copy->values[0] = cl_write_sequence(2, v1bytes, v5stream); + } + ecl_frs_pop(cl_env_copy); + v7=ecl_stack_push_values(cl_env_copy); + cl_close(1, v5stream); + ecl_stack_pop_values(cl_env_copy,v7); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v6); + return cl_env_copy->values[0]; + } + } + } +} +/* function definition for COPY-FILE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L8copy_file(volatile cl_narg narg, cl_object volatile v1from, cl_object volatile v2to, ...) +{ + cl_object T0, T1, T2, T3, T4, T5, T6; + cl_object volatile env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object volatile v3if_to_exists; + cl_object volatile v4element_type; + cl_object volatile v5finish_output; + ecl_va_list args; ecl_va_start(args,v2to,narg,2); + { + cl_object keyvars[6]; + cl_parse_key(args,3,L8copy_filekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[3])) { + v3if_to_exists = ECL_SYM("SUPERSEDE",1348); + } else { + v3if_to_exists = keyvars[0]; + } + if (Null(keyvars[4])) { + v4element_type = VV[16]; + } else { + v4element_type = keyvars[1]; + } + v5finish_output = keyvars[2]; + } + { + volatile cl_object v6input; + T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); + if (Null(ECL_SYM("INPUT",1286))) { goto L6; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286)); + goto L5; +L6:; + T1 = ECL_NIL; +L5:; + if (Null(v4element_type)) { goto L9; } + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), v4element_type); + goto L8; +L9:; + T2 = ECL_NIL; +L8:; + goto L12; + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), ECL_NIL); + goto L11; +L12:; + T3 = ECL_NIL; +L11:; + goto L15; + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + goto L14; +L15:; + T4 = ECL_NIL; +L14:; + goto L18; + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + goto L17; +L18:; + T5 = ECL_NIL; +L17:; + T6 = cl_append(5, T1, T2, T3, T4, T5); + v6input = cl_apply(3, T0, v1from, T6); + { + volatile bool unwinding = FALSE; + cl_index v7=ECL_STACK_INDEX(cl_env_copy),v8; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + { + volatile cl_object v9output; + T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); + if (Null(ECL_SYM("OUTPUT",1316))) { goto L24; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316)); + goto L23; +L24:; + T1 = ECL_NIL; +L23:; + if (Null(v4element_type)) { goto L27; } + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), v4element_type); + goto L26; +L27:; + T2 = ECL_NIL; +L26:; + if (Null(v3if_to_exists)) { goto L30; } + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), v3if_to_exists); + goto L29; +L30:; + T3 = ECL_NIL; +L29:; + goto L33; + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + goto L32; +L33:; + T4 = ECL_NIL; +L32:; + goto L36; + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + goto L35; +L36:; + T5 = ECL_NIL; +L35:; + T6 = cl_append(5, T1, T2, T3, T4, T5); + v9output = cl_apply(3, T0, v2to, T6); + { + volatile bool unwinding = FALSE; + cl_index v10=ECL_STACK_INDEX(cl_env_copy),v11; + ecl_frame_ptr next_fr; + ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); + if (__ecl_frs_push_result) { + unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; + } else { + cl_env_copy->values[0] = L9copy_stream(6, v6input, v9output, ECL_SYM("ELEMENT-TYPE",1252), v4element_type, VV[21], v5finish_output); + } + ecl_frs_pop(cl_env_copy); + v11=ecl_stack_push_values(cl_env_copy); + cl_close(1, v9output); + ecl_stack_pop_values(cl_env_copy,v11); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v10); + } + } + } + ecl_frs_pop(cl_env_copy); + v8=ecl_stack_push_values(cl_env_copy); + cl_close(1, v6input); + ecl_stack_pop_values(cl_env_copy,v8); + if (unwinding) ecl_unwind(cl_env_copy,next_fr); + ECL_STACK_SET_INDEX(cl_env_copy,v7); + return cl_env_copy->values[0]; + } + } + } +} +/* function definition for COPY-STREAM */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L9copy_stream(cl_narg narg, cl_object v1input, cl_object v2output, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3element_type; + cl_object v4buffer_size; + cl_object v5buffer; + cl_object v6start; + cl_object v7end; + cl_object v8finish_output; + ecl_va_list args; ecl_va_start(args,v2output,narg,2); + { + cl_object keyvars[12]; + cl_parse_key(args,6,L9copy_streamkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[6])) { + v3element_type = cl_stream_element_type(v1input); + } else { + v3element_type = keyvars[0]; + } + if (Null(keyvars[7])) { + v4buffer_size = ecl_make_fixnum(4096); + } else { + v4buffer_size = keyvars[1]; + } + if (Null(keyvars[8])) { + v5buffer = si_make_pure_array(v3element_type, v4buffer_size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + } else { + v5buffer = keyvars[2]; + } + if (Null(keyvars[9])) { + v6start = ecl_make_fixnum(0); + } else { + v6start = keyvars[3]; + } + v7end = keyvars[4]; + v8finish_output = keyvars[5]; + } + { + cl_object v9; + v9 = v6start; + { + cl_object v10; + v10 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L11; } + v10 = v9; + if (ecl_greatereq(v10,ecl_make_fixnum(0))) { goto L7; } + goto L8; +L11:; + goto L8; + } +L8:; + v6start = si_do_check_type(v9, VV[23], ECL_NIL, VV[24]); +L7:; + } + { + cl_object v9; + v9 = v7end; + if (v9==ECL_NIL) { goto L18; } + { + cl_object v10; + v10 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L23; } + v10 = v9; + if (ecl_greatereq(v10,ecl_make_fixnum(0))) { goto L18; } + goto L19; +L23:; + goto L19; + } +L19:; + v7end = si_do_check_type(v9, VV[25], ECL_NIL, VV[26]); +L18:; + } + { + cl_object v9; + v9 = v4buffer_size; + { + cl_object v10; + v10 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L34; } + v10 = v9; + if (ecl_greatereq(v10,ecl_make_fixnum(1))) { goto L30; } + goto L31; +L34:; + goto L31; + } +L31:; + v4buffer_size = si_do_check_type(v9, VV[27], ECL_NIL, VV[28]); +L30:; + } + if (Null(v7end)) { goto L39; } + if (!(ecl_lower(v7end,v6start))) { goto L39; } + cl_error(2, VV[29], VV[22]); +L39:; + { + cl_object v9output_position; + cl_object v10input_position; + v9output_position = ecl_make_fixnum(0); + v10input_position = ecl_make_fixnum(0); + if (ecl_zerop(v6start)) { goto L44; } +L46:; + if (ecl_lower(v10input_position,v6start)) { goto L48; } + goto L47; +L48:; + { + cl_fixnum v11n; + { + cl_fixnum v12; + v12 = ecl_length(v5buffer); + T0 = ecl_minus(v6start,v10input_position); + T1 = ((ecl_float_nan_p(T0) || ecl_lowereq(ecl_make_fixnum(v12),T0))?ecl_make_fixnum(v12):T0); + v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1253), T1)); + } + if (!((v11n)==0)) { goto L52; } + cl_error(3, VV[30], VV[22], v6start); +L52:; + v10input_position = ecl_plus(v10input_position,ecl_make_fixnum(v11n)); + } + goto L46; +L47:; +L44:; + goto L58; +L57:; + si_assert_failure(1, VV[31]); +L58:; + if (ecl_number_equalp(v10input_position,v6start)) { goto L61; } + goto L57; +L61:; +L64:; + if (v7end==ECL_NIL) { goto L66; } + if (ecl_lower(v10input_position,v7end)) { goto L66; } + goto L65; +L66:; + { + cl_fixnum v11n; + if (Null(v7end)) { goto L72; } + { + cl_fixnum v12; + v12 = ecl_length(v5buffer); + T1 = ecl_minus(v7end,v10input_position); + T0 = ((ecl_float_nan_p(T1) || ecl_lowereq(ecl_make_fixnum(v12),T1))?ecl_make_fixnum(v12):T1); + goto L71; + } +L72:; + T0 = ECL_NIL; +L71:; + v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1253), T0)); + if (!((v11n)==0)) { goto L74; } + if (Null(v7end)) { goto L76; } + cl_error(3, VV[32], VV[22], v7end); + goto L74; +L76:; + goto L63; +L74:; + v10input_position = ecl_plus(v10input_position,ecl_make_fixnum(v11n)); + cl_write_sequence(4, v5buffer, v2output, ECL_SYM("END",1253), ecl_make_fixnum(v11n)); + v9output_position = ecl_plus(v9output_position,ecl_make_fixnum(v11n)); + } + goto L64; +L65:; +L63:; + if (Null(v8finish_output)) { goto L83; } + cl_finish_output(1, v2output); +L83:; + value0 = v9output_position; + cl_env_copy->nvalues = 1; + return value0; + } + } +} + +#include "lib/alexandria/io.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecliPHAkciDuw0AM_cYHycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/io.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecliPHAkciDuw0AM_cYHycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[33]); /* WITH-OPEN-FILE* */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[38]); /* WITH-INPUT-FROM-FILE */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[8]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[39]); /* WITH-OUTPUT-TO-FILE */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[11], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defun(VV[40]); /* READ-FILE-INTO-STRING */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[43]); /* WRITE-STRING-INTO-FILE */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[14], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* READ-FILE-INTO-BYTE-VECTOR */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[15], ECL_SYM("FUNCTION",398), VVtemp[23]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defun(VV[48]); /* WRITE-BYTE-VECTOR-INTO-FILE */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[17], ECL_SYM("FUNCTION",398), VVtemp[27]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[28], VVtemp[29]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[30]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* COPY-FILE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defun(VV[53]); /* COPY-STREAM */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[22], ECL_SYM("FUNCTION",398), VVtemp[34]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/lists.cxx b/lib/alexandria/lists.cxx new file mode 100644 index 0000000..a622b99 --- /dev/null +++ b/lib/alexandria/lists.cxx @@ -0,0 +1,3195 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/lists.lisp */ +#include +#include "lib/alexandria/lists.eclh" +/* function definition for SAFE-ENDP */ +/* optimize speed 3, debug 0, space 0, safety 3 */ +static cl_object L1safe_endp(cl_object v1x) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = ecl_make_bool(ecl_endp(v1x)); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for ALIST-PLIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L2alist_plist(cl_object v1alist) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2plist; + v2plist = ECL_NIL; + { + cl_object v3; + v3 = v1alist; + goto L6; +L5:; + { + cl_object v4pair; + v4pair = ecl_car(v3); + T0 = ecl_car(v4pair); + v2plist = CONS(T0,v2plist); + T0 = ecl_cdr(v4pair); + v2plist = CONS(T0,v2plist); + } + v3 = ecl_cdr(v3); +L6:; + if (Null(v3)) { goto L16; } + goto L5; +L16:; + } + value0 = cl_nreverse(v2plist); + return value0; + } + } +} +/* function definition for PLIST-ALIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L3plist_alist(cl_object v1plist) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2alist; + v2alist = ECL_NIL; + { + cl_object v3tail; + v3tail = v1plist; + goto L5; +L4:; + T0 = ecl_car(v3tail); + T1 = ecl_cadr(v3tail); + T2 = CONS(T0,T1); + v2alist = CONS(T2,v2alist); + v3tail = ecl_cddr(v3tail); +L5:; + if (ecl_endp(v3tail)) { goto L11; } + goto L4; +L11:; + value0 = cl_nreverse(v2alist); + return value0; + } + } + } +} +/* function definition for RACONS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4racons(cl_object v1key, cl_object v2value, cl_object v3ralist) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_acons(v2value, v1key, v3ralist); + return value0; + } +} +/* function definition for ASSOC-VALUE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5assoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3test; + ecl_va_list args; ecl_va_start(args,v2key,narg,2); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L5assoc_valuekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v3test = ECL_SYM("EQL",336); + } else { + v3test = keyvars[0]; + } + } + { + cl_object v4entry; + { + cl_object v5; + v5 = v1alist; + goto L6; +L5:; + { + cl_object v6; + cl_object v7; + { + cl_object v8; + v8 = v5; + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v8; + } + v7 = ECL_CONS_CAR(v6); + if (Null(v7)) { goto L8; } + { + cl_object v8; + { + cl_object v9; + v9 = v7; + if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v9; + } + v8 = ECL_CONS_CAR(T0); + if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v2key, v8))) { goto L8; } + v4entry = v7; + goto L2; + } + } +L8:; + v5 = ECL_CONS_CDR(v5); +L6:; + if (v5==ECL_NIL) { goto L21; } + goto L5; +L21:; + v4entry = ECL_NIL; + } +L2:; + T0 = ecl_cdr(v4entry); + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = v4entry; + cl_env_copy->values[0] = T0; + return cl_env_copy->values[0]; + } + } +} +/* local function LAMBDA30 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC6__lambda30(cl_object v1, cl_object v2env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4place; + cl_object v5key; + cl_object v6; + cl_object v7test; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4place = v8; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5key = v8; + } + v6 = ecl_function_dispatch(cl_env_copy,VV[63])(2, v3, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; + if (!((v6)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L16; } + v7test = VV[5]; + goto L15; +L16:; + v7test = v6; +L15:; + ecl_function_dispatch(cl_env_copy,VV[64])(2, v3, VV[6]) /* CHECK-KEYWORD */; + { + cl_object v9; /* TEMPORARY-VARIABLES */ + cl_object v10; /* INITFORMS */ + cl_object v11; /* NEWVALS */ + cl_object v12; /* SETTER */ + cl_object v13; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4place, v2env) /* GET-SETF-EXPANSION */; + { + v9 = value0; + v10 = cl_env_copy->values[1]; + v11 = cl_env_copy->values[2]; + v12 = cl_env_copy->values[3]; + v13 = cl_env_copy->values[4]; + } + if (Null(ecl_cdr(v11))) { goto L20; } + cl_error(2, VV[7], VV[4]); +L20:; + { + cl_object v14; + cl_object v15; + cl_object v16; + cl_object v17; + cl_object v18; + v14 = cl_gensym(1, VV[8]); + v15 = cl_gensym(1, VV[9]); + v16 = cl_gensym(1, VV[10]); + v17 = cl_gensym(1, VV[11]); + v18 = cl_gensym(1, VV[12]); + T0 = cl_list(4, v17, v15, v16, v18); + T1 = ecl_append(v9,T0); + T2 = cl_list(5, ECL_SYM("ASSOC",116), v15, v17, ECL_SYM("TEST",1350), v16); + T3 = cl_list(4, v13, v5key, v7test, T2); + T4 = ecl_append(v10,T3); + T5 = ecl_list1(v14); + T6 = cl_list(2, ECL_SYM("CDR",200), v18); + T7 = cl_list(3, ECL_SYM("SETF",752), T6, v14); + T8 = cl_list(2, v18, T7); + T9 = ecl_car(v11); + T10 = cl_list(4, ECL_SYM("ACONS",81), v5key, v14, v17); + T11 = cl_list(3, ECL_SYM("SETF",752), T9, T10); + T12 = cl_list(5, ECL_SYM("LET",479), v11, T11, v12, v14); + T13 = cl_list(2, ECL_T, T12); + T14 = cl_list(3, ECL_SYM("COND",249), T8, T13); + T15 = cl_list(2, ECL_SYM("CDR",200), v18); + cl_env_copy->nvalues = 5; + cl_env_copy->values[4] = T15; + cl_env_copy->values[3] = T14; + cl_env_copy->values[2] = T5; + cl_env_copy->values[1] = T4; + cl_env_copy->values[0] = T1; + return cl_env_copy->values[0]; + } + } + } + } +} +/* function definition for RASSOC-VALUE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L7rassoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3test; + ecl_va_list args; ecl_va_start(args,v2key,narg,2); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L7rassoc_valuekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v3test = ECL_SYM("EQL",336); + } else { + v3test = keyvars[0]; + } + } + { + cl_object v4entry; + v4entry = cl_rassoc(4, v2key, v1alist, ECL_SYM("TEST",1350), v3test); + T0 = ecl_car(v4entry); + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = v4entry; + cl_env_copy->values[0] = T0; + return cl_env_copy->values[0]; + } + } +} +/* local function LAMBDA41 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC8__lambda41(cl_object v1, cl_object v2env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4place; + cl_object v5key; + cl_object v6; + cl_object v7test; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4place = v8; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v8; + v8 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5key = v8; + } + v6 = ecl_function_dispatch(cl_env_copy,VV[63])(2, v3, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; + if (!((v6)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L16; } + v7test = VV[5]; + goto L15; +L16:; + v7test = v6; +L15:; + ecl_function_dispatch(cl_env_copy,VV[64])(2, v3, VV[6]) /* CHECK-KEYWORD */; + { + cl_object v9; /* TEMPORARY-VARIABLES */ + cl_object v10; /* INITFORMS */ + cl_object v11; /* NEWVALS */ + cl_object v12; /* SETTER */ + cl_object v13; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4place, v2env) /* GET-SETF-EXPANSION */; + { + v9 = value0; + v10 = cl_env_copy->values[1]; + v11 = cl_env_copy->values[2]; + v12 = cl_env_copy->values[3]; + v13 = cl_env_copy->values[4]; + } + if (Null(ecl_cdr(v11))) { goto L20; } + cl_error(2, VV[7], VV[13]); +L20:; + { + cl_object v14; + cl_object v15; + cl_object v16; + cl_object v17; + cl_object v18; + v14 = cl_gensym(1, VV[8]); + v15 = cl_gensym(1, VV[9]); + v16 = cl_gensym(1, VV[10]); + v17 = cl_gensym(1, VV[11]); + v18 = cl_gensym(1, VV[12]); + T0 = cl_list(4, v17, v15, v16, v18); + T1 = ecl_append(v9,T0); + T2 = cl_list(5, ECL_SYM("RASSOC",685), v15, v17, ECL_SYM("TEST",1350), v16); + T3 = cl_list(4, v13, v5key, v7test, T2); + T4 = ecl_append(v10,T3); + T5 = ecl_list1(v14); + T6 = cl_list(2, ECL_SYM("CAR",182), v18); + T7 = cl_list(3, ECL_SYM("SETF",752), T6, v14); + T8 = cl_list(2, v18, T7); + T9 = ecl_car(v11); + T10 = cl_list(4, VV[3], v5key, v14, v17); + T11 = cl_list(3, ECL_SYM("SETF",752), T9, T10); + T12 = cl_list(5, ECL_SYM("LET",479), v11, T11, v12, v14); + T13 = cl_list(2, ECL_T, T12); + T14 = cl_list(3, ECL_SYM("COND",249), T8, T13); + T15 = cl_list(2, ECL_SYM("CAR",182), v18); + cl_env_copy->nvalues = 5; + cl_env_copy->values[4] = T15; + cl_env_copy->values[3] = T14; + cl_env_copy->values[2] = T5; + cl_env_copy->values[1] = T4; + cl_env_copy->values[0] = T1; + return cl_env_copy->values[0]; + } + } + } + } +} +/* function definition for MALFORMED-PLIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L9malformed_plist(cl_object v1plist) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_error(2, VV[15], v1plist); + return value0; + } +} +/* local function DOPLIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC10doplist(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4; + cl_object v5; + cl_object v6key; + cl_object v7val; + cl_object v8plist; + cl_object v9values; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v10; + v10 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4 = v10; + } + v5 = v4; + if (!(v5==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v6key = v10; + } + if (!(v5==ECL_NIL)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L16:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v7val = v10; + } + if (!(v5==ECL_NIL)) { goto L22; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L22:; + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v8plist = v10; + } + if (Null(v5)) { goto L28; } + { + cl_object v10; + v10 = ecl_car(v5); + v5 = ecl_cdr(v5); + v9values = v10; + goto L27; + } +L28:; + v9values = ECL_NIL; +L27:; + if (Null(v5)) { goto L33; } + ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L33:; + { + cl_object v11; /* FORMS */ + cl_object v12; /* DECLARATIONS */ + value0 = ecl_function_dispatch(cl_env_copy,VV[68])(1, v3) /* PARSE-BODY */; + { + const int v13 = cl_env_copy->nvalues; + v11 = value0; + cl_object v14; + v14 = (v13<=1)? ECL_NIL : cl_env_copy->values[1]; + v12 = v14; + } + { + cl_object v13; + cl_object v14; + cl_object v15; + v13 = cl_gensym(1, VV[17]); + v14 = cl_gensym(1, VV[18]); + v15 = cl_gensym(1, VV[19]); + T0 = cl_list(2, v6key, v7val); + T1 = cl_list(3, ECL_SYM("IGNORABLE",429), v6key, v7val); + T2 = cl_list(2, ECL_SYM("DECLARE",276), T1); + T3 = cl_list(2, ECL_SYM("RETURN",726), v9values); + T4 = cl_list(4, ECL_SYM("LET",479), T0, T2, T3); + T5 = cl_list(3, v15, ECL_NIL, T4); + T6 = ecl_list1(T5); + T7 = cl_list(2, v13, v8plist); + T8 = cl_list(2, ECL_SYM("POP",645), v13); + T9 = ecl_list1(v15); + T10 = cl_list(4, ECL_SYM("IF",948), v13, T8, T9); + T11 = cl_list(2, v6key, T10); + T12 = cl_list(2, ECL_SYM("POP",645), v13); + T13 = cl_list(2, ECL_SYM("QUOTE",681), v8plist); + T14 = cl_list(2, VV[14], T13); + T15 = cl_list(4, ECL_SYM("IF",948), v13, T12, T14); + T16 = cl_list(2, v7val, T15); + T17 = cl_list(3, T7, T11, T16); + T18 = cl_list(3, ECL_SYM("IGNORABLE",429), v6key, v7val); + T19 = cl_list(2, ECL_SYM("DECLARE",276), T18); + T20 = cl_list(2, ECL_SYM("POP",645), v13); + T21 = ecl_list1(v15); + T22 = cl_list(4, ECL_SYM("IF",948), v13, T20, T21); + T23 = cl_list(2, ECL_SYM("POP",645), v13); + T24 = cl_list(2, ECL_SYM("QUOTE",681), v8plist); + T25 = cl_list(2, VV[14], T24); + T26 = cl_list(4, ECL_SYM("IF",948), v13, T23, T25); + T27 = cl_list(5, ECL_SYM("SETF",752), v6key, T22, v7val, T26); + T28 = cl_list(2, ECL_SYM("GO",416), v14); + T29 = cl_list(2, T27, T28); + T30 = ecl_append(v11,T29); + T31 = cl_listX(3, ECL_SYM("TAGBODY",852), v14, T30); + T32 = ecl_list1(T31); + T33 = ecl_append(v12,T32); + T34 = cl_listX(4, ECL_SYM("LET*",480), T17, T19, T33); + T35 = cl_list(3, ECL_SYM("FLET",375), T6, T34); + value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, T35); + return value0; + } + } + } + } +} +/* local function APPENDF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC12appendf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC11__lambda72,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = v3; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L11; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("APPEND",90), v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L11:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L20; +L19:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L20:; + if (v12si__d==ECL_NIL) { goto L26; } + goto L19; +L26:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("APPEND",90), v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA72 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC11__lambda72(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function NCONCF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC14nconcf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC13__lambda83,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = v3; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L11; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("NCONC",583), v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L11:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L20; +L19:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L20:; + if (v12si__d==ECL_NIL) { goto L26; } + goto L19; +L26:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("NCONC",583), v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA83 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC13__lambda83(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function UNIONF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC16unionf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + cl_object v5list; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5list = v6; + } + { + cl_object v7; /* VARS */ + cl_object v8; /* VALS */ + cl_object v9; /* STORES */ + cl_object v10; /* SETTER */ + cl_object v11; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; + } + { + cl_object v12si__all_vars; + { + cl_object v13; + v13 = ecl_make_cfun((cl_objectfn_fixed)LC15__lambda95,ECL_NIL,Cblock,1); + T0 = v13; + } + T1 = CONS(v5list,v3); + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v11))) { goto L17; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("UNION",884), v11, T1); + T3 = ecl_car(v9); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L17:; + { + cl_object v13si__d; + cl_object v14si__v; + cl_object v15si__let_list; + v13si__d = v7; + v14si__v = v8; + v15si__let_list = ECL_NIL; + goto L26; +L25:; + { + cl_object v16; + v16 = ecl_cdr(v13si__d); + { + cl_object v17; + v17 = ecl_cdr(v14si__v); + T0 = ecl_car(v13si__d); + T1 = ecl_car(v14si__v); + T2 = cl_list(2, T0, T1); + v15si__let_list = CONS(T2,v15si__let_list); + v14si__v = v17; + v13si__d = v16; + } + } +L26:; + if (v13si__d==ECL_NIL) { goto L32; } + goto L25; +L32:; + T0 = ecl_car(v9); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("UNION",884), v11, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v15si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v7); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + return value0; + } + } + } + } + } +} +/* local function LAMBDA95 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC15__lambda95(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function NUNIONF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC18nunionf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + cl_object v5list; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5list = v6; + } + { + cl_object v7; /* VARS */ + cl_object v8; /* VALS */ + cl_object v9; /* STORES */ + cl_object v10; /* SETTER */ + cl_object v11; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; + } + { + cl_object v12si__all_vars; + { + cl_object v13; + v13 = ecl_make_cfun((cl_objectfn_fixed)LC17__lambda107,ECL_NIL,Cblock,1); + T0 = v13; + } + T1 = CONS(v5list,v3); + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v11))) { goto L17; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("NUNION",611), v11, T1); + T3 = ecl_car(v9); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L17:; + { + cl_object v13si__d; + cl_object v14si__v; + cl_object v15si__let_list; + v13si__d = v7; + v14si__v = v8; + v15si__let_list = ECL_NIL; + goto L26; +L25:; + { + cl_object v16; + v16 = ecl_cdr(v13si__d); + { + cl_object v17; + v17 = ecl_cdr(v14si__v); + T0 = ecl_car(v13si__d); + T1 = ecl_car(v14si__v); + T2 = cl_list(2, T0, T1); + v15si__let_list = CONS(T2,v15si__let_list); + v14si__v = v17; + v13si__d = v16; + } + } +L26:; + if (v13si__d==ECL_NIL) { goto L32; } + goto L25; +L32:; + T0 = ecl_car(v9); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("NUNION",611), v11, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v15si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v7); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + return value0; + } + } + } + } + } +} +/* local function LAMBDA107 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC17__lambda107(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function REVERSEF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC20reversef(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + if (Null(v3)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC19__lambda118,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = ECL_NIL; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L13; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("REVERSE",729), v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L13:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L22; +L21:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L22:; + if (v12si__d==ECL_NIL) { goto L28; } + goto L21; +L28:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("REVERSE",729), v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA118 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC19__lambda118(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function NREVERSEF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC22nreversef(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + if (Null(v3)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC21__lambda129,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = ECL_NIL; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L13; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("NREVERSE",591), v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L13:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L22; +L21:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L22:; + if (v12si__d==ECL_NIL) { goto L28; } + goto L21; +L28:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("NREVERSE",591), v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA129 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC21__lambda129(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* function definition for CIRCULAR-LIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L23circular_list(cl_narg narg, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + cl_object v1elements; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1elements = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v2cycle; + v2cycle = cl_copy_list(v1elements); + value0 = ecl_nconc(v2cycle,v2cycle); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for CIRCULAR-LIST-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L24circular_list_p(cl_object v1object) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LISTP(v1object))) { goto L2; } + { + cl_object v2; + cl_object v3fast; + cl_object v4slow; + T0 = ecl_car(v1object); + T1 = ecl_cdr(v1object); + v2 = CONS(T0,T1); + v3fast = v1object; + v4slow = v2; + goto L9; +L8:; + if (!(ECL_CONSP(v3fast))) { goto L14; } + T0 = ecl_cdr(v3fast); + if (ECL_LISTP(T0)) { goto L11; } + goto L12; +L14:; + goto L12; +L12:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L11:; + if (!((v3fast)==(v4slow))) { goto L16; } + value0 = ECL_T; + cl_env_copy->nvalues = 1; + return value0; +L16:; + v3fast = ecl_cddr(v3fast); + v4slow = ecl_cdr(v4slow); +L9:; + goto L8; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for CIRCULAR-TREE-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L26circular_tree_p(cl_object volatile v1object) +{ + cl_object volatile env0 = ECL_NIL; + volatile struct ecl_cclosure aux_closure; + cl_object volatile CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object volatile value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env0); /* CIRCULAR-TREE-P */ + { + ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV0)); + if (__ecl_frs_push_result!=0) { + value0 = cl_env_copy->values[0]; + ecl_frs_pop(cl_env_copy); + return value0; + } else { + value0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC25circularp(2, v1object, ECL_NIL)); + ecl_frs_pop(cl_env_copy); + return value0;} + } + } + } +} +/* closure CIRCULARP */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC25circularp(cl_narg narg, cl_object v1object, cl_object v2seen, ...) +{ + cl_object T0, T1; + volatile struct ecl_cclosure aux_closure; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* CIRCULAR-TREE-P */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + if (!(ECL_CONSP(v1object))) { goto L2; } + { + cl_object v3; + cl_object v4fast; + cl_object v5slow; + T0 = ecl_car(v1object); + T1 = ecl_cdr(v1object); + v3 = CONS(T0,T1); + v4fast = v3; + v5slow = v1object; + goto L9; +L8:; + if ((v4fast)==(v5slow)) { goto L13; } + { + cl_object v6; + cl_object v7; + v6 = v5slow; + v7 = v2seen; + if (Null(ecl_memql(v6,v7))) { goto L11; } + goto L12; + } +L13:; +L12:; + cl_env_copy->values[0] = ECL_T; + cl_env_copy->nvalues = 1; + cl_return_from(ECL_CONS_CAR(CLV0),VV[29]); +L11:; + if (!(ECL_CONSP(v4fast))) { goto L20; } + T0 = ecl_cdr(v5slow); + if (ECL_CONSP(T0)) { goto L18; } + goto L19; +L20:; +L19:; + { + cl_object v6tail; + v6tail = v1object; + goto L25; +L24:; + { + cl_object v7elt; + v7elt = ecl_car(v6tail); + T0 = CONS(v1object,v2seen); + (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC25circularp(2, v7elt, T0)); + } + v6tail = ecl_cdr(v6tail); +L25:; + if (!(ECL_CONSP(v6tail))) { goto L31; } + goto L24; +L31:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L18:; + v4fast = ecl_cddr(v4fast); + v5slow = ecl_cdr(v5slow); +L9:; + goto L8; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for PROPER-LIST-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L27proper_list_p(cl_object v1object) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if ((v1object)!=ECL_NIL) { goto L1; } + value0 = ECL_T; + cl_env_copy->nvalues = 1; + return value0; +L1:; + if (!(ECL_CONSP(v1object))) { goto L3; } + { + cl_object v2; + cl_object v3fast; + cl_object v4slow; + T0 = ecl_car(v1object); + T1 = ecl_cdr(v1object); + v2 = CONS(T0,T1); + v3fast = v1object; + v4slow = v2; + goto L10; +L9:; + if (!(ECL_LISTP(v3fast))) { goto L15; } + T0 = ecl_cdr(v3fast); + if (ECL_CONSP(T0)) { goto L12; } + goto L13; +L15:; + goto L13; +L13:; + if (!(ECL_LISTP(v3fast))) { goto L18; } + T0 = ecl_cdr(v3fast); + value0 = Null(T0)?ECL_T:ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L18:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L12:; + if (!((v3fast)==(v4slow))) { goto L20; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L20:; + v3fast = ecl_cddr(v3fast); + v4slow = ecl_cdr(v4slow); +L10:; + goto L9; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L3:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA161 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC28__lambda161(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = VV[32]; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for CIRCULAR-LIST-ERROR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L29circular_list_error(cl_object v1list) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1list, ECL_SYM("EXPECTED-TYPE",1260), VV[34]); + return value0; + } +} +/* function definition for PROPER-LIST-LENGTH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L30proper_list_length(cl_object v1list) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + cl_object v3last; + cl_object v4fast; + cl_object v5slow; + cl_fixnum v6n; + T0 = ecl_car(v1list); + T1 = ecl_cdr(v1list); + v2 = CONS(T0,T1); + v3last = v1list; + v4fast = v1list; + v5slow = v2; + v6n = 1; + goto L8; +L7:; + if (!(ecl_endp(v4fast))) { goto L10; } + value0 = ecl_make_integer((v6n)-1); + cl_env_copy->nvalues = 1; + return value0; +L10:; + { + cl_object v7; + v7 = ecl_cdr(v4fast); + if (!(ecl_endp(v7))) { goto L12; } + } + value0 = ecl_make_fixnum(v6n); + cl_env_copy->nvalues = 1; + return value0; +L12:; + if (!((v4fast)==(v5slow))) { goto L15; } + L29circular_list_error(v1list); +L15:; + v3last = v4fast; + v4fast = ecl_cddr(v4fast); + v5slow = ecl_cdr(v5slow); + { + cl_object v7; + v7 = ecl_plus(ecl_make_fixnum(v6n),ecl_make_fixnum(2)); + { + bool v8; + v8 = ECL_FIXNUMP(v7); + if (ecl_unlikely(!(v8))) + FEwrong_type_argument(ECL_SYM("FIXNUM",374),v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v6n = ecl_fixnum(v7); + } +L8:; + goto L7; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for LASTCAR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L31lastcar(cl_object v1list) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + cl_object v3last; + cl_object v4fast; + cl_object v5slow; + T0 = ecl_car(v1list); + T1 = ecl_cdr(v1list); + v2 = CONS(T0,T1); + v3last = v1list; + v4fast = v1list; + v5slow = v2; + goto L7; +L6:; + if (!(ecl_endp(v4fast))) { goto L9; } + value0 = ecl_cadr(v3last); + cl_env_copy->nvalues = 1; + return value0; +L9:; + { + cl_object v6; + v6 = ecl_cdr(v4fast); + if (!(ecl_endp(v6))) { goto L11; } + } + value0 = ecl_car(v4fast); + cl_env_copy->nvalues = 1; + return value0; +L11:; + if (!((v4fast)==(v5slow))) { goto L14; } + L29circular_list_error(v1list); +L14:; + v3last = v4fast; + v4fast = ecl_cddr(v4fast); + v5slow = ecl_cdr(v5slow); +L7:; + goto L6; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for (SETF LASTCAR) */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L32_setf_lastcar_(cl_object v1object, cl_object v2list) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4last; + cl_object v5fast; + cl_object v6slow; + T0 = ecl_car(v2list); + T1 = ecl_cdr(v2list); + v3 = CONS(T0,T1); + v4last = v2list; + v5fast = v2list; + v6slow = v3; + goto L7; +L6:; + if (!(ecl_endp(v5fast))) { goto L9; } + { + cl_object v7; + v7 = v1object; + { + cl_object v8; + v8 = ecl_cdr(v4last); + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v8; + } + (ECL_CONS_CAR(T0)=v7,T0); + value0 = v7; + cl_env_copy->nvalues = 1; + return value0; + } +L9:; + { + cl_object v7; + v7 = ecl_cdr(v5fast); + if (!(ecl_endp(v7))) { goto L16; } + } + { + cl_object v7; + v7 = v1object; + { + cl_object v8; + v8 = v5fast; + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v8; + } + (ECL_CONS_CAR(T0)=v7,T0); + value0 = v7; + cl_env_copy->nvalues = 1; + return value0; + } +L16:; + if (!((v5fast)==(v6slow))) { goto L24; } + L29circular_list_error(v2list); +L24:; + v4last = v5fast; + v5fast = ecl_cddr(v5fast); + v6slow = ecl_cdr(v6slow); +L7:; + goto L6; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MAKE-CIRCULAR-LIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L33make_circular_list(cl_narg narg, cl_object v1length, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2initial_element; + ecl_va_list args; ecl_va_start(args,v1length,narg,1); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L33make_circular_listkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + v2initial_element = keyvars[0]; + } + { + cl_object v3cycle; + v3cycle = cl_make_list(3, v1length, ECL_SYM("INITIAL-ELEMENT",1283), v2initial_element); + value0 = ecl_nconc(v3cycle,v3cycle); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function LAMBDA193 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC34__lambda193(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = VV[39]; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for ENSURE-CAR */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L35ensure_car(cl_object v1thing) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_CONSP(v1thing))) { goto L1; } + value0 = ecl_car(v1thing); + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = v1thing; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for ENSURE-CONS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L36ensure_cons(cl_object v1cons) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_CONSP(v1cons))) { goto L1; } + value0 = v1cons; + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = CONS(v1cons,ECL_NIL); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for ENSURE-LIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L37ensure_list(cl_object v1list) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LISTP(v1list))) { goto L1; } + value0 = v1list; + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = ecl_list1(v1list); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for REMOVE-FROM-PLIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L38remove_from_plist(cl_narg narg, cl_object v1plist, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2keys; + ecl_va_list args; ecl_va_start(args,v1plist,narg,1); + v2keys = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3; + cl_object v4key; + cl_object v5rest; + v3 = v1plist; + v4key = ECL_NIL; + v5rest = ECL_NIL; + { + cl_object v6; + cl_object v7; + v6 = ecl_list1(ECL_NIL); + v7 = v6; +L6:; + if (!(ECL_ATOM(v3))) { goto L8; } + goto L7; +L8:; + { + cl_object v8; + v8 = v3; + v4key = ecl_car(v8); + v8 = ecl_cdr(v8); + v5rest = v8; + } + v3 = ecl_cddr(v3); + goto L21; +L20:; + si_assert_failure(5, ECL_SYM("REST",721), ECL_NIL, ECL_NIL, VV[44], v1plist); +L21:; + if ((v5rest)!=ECL_NIL) { goto L24; } + goto L20; +L24:; + { + cl_object v8; + cl_object v9; + cl_object v10; + v8 = (ECL_SYM("EQ",335)->symbol.gfdef); + v9 = v4key; + v10 = v2keys; + if ((si_memq(v9,v10))!=ECL_NIL) { goto L26; } + } + { + cl_object v8; + v8 = v7; + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v8; + } + v7 = ecl_list1(v4key); + (ECL_CONS_CDR(T0)=v7,T0); + { + cl_object v8; + v8 = v7; + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v8; + } + T1 = ecl_car(v5rest); + v7 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v7,T0); +L26:; + goto L6; +L7:; + value0 = ecl_cdr(v6); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* function definition for DELETE-FROM-PLIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L39delete_from_plist(cl_narg narg, cl_object v1plist, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2keys; + ecl_va_list args; ecl_va_start(args,v1plist,narg,1); + v2keys = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3head; + v3head = v1plist; + { + cl_object v4tail; + v4tail = ECL_NIL; + { + cl_object v5; + cl_object v6key; + cl_object v7rest; + v5 = v1plist; + v6key = ECL_NIL; + v7rest = ECL_NIL; +L6:; + if (!(ECL_ATOM(v5))) { goto L8; } + goto L7; +L8:; + { + cl_object v8; + v8 = v5; + v6key = ecl_car(v8); + v8 = ecl_cdr(v8); + v7rest = v8; + } + v5 = ecl_cddr(v5); + goto L22; +L21:; + si_assert_failure(5, ECL_SYM("REST",721), ECL_NIL, ECL_NIL, VV[44], v1plist); +L22:; + if ((v7rest)!=ECL_NIL) { goto L25; } + goto L21; +L25:; + { + cl_object v8; + cl_object v9; + cl_object v10; + v8 = (ECL_SYM("EQ",335)->symbol.gfdef); + v9 = v6key; + v10 = v2keys; + if (Null(si_memq(v9,v10))) { goto L27; } + } + { + cl_object v8next; + v8next = ecl_cdr(v7rest); + if (Null(v4tail)) { goto L33; } + { + cl_object v9; + v9 = v8next; + { + cl_object v10; + v10 = v4tail; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v10; + } + (ECL_CONS_CDR(T0)=v9,T0); + goto L19; + } +L33:; + v3head = v8next; + goto L19; + } +L27:; + v4tail = v7rest; +L19:; + goto L6; +L7:; + value0 = v3head; + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* local function REMOVE-FROM-PLISTF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC41remove_from_plistf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC40__lambda237,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = v3; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L11; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[43], v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L11:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L20; +L19:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L20:; + if (v12si__d==ECL_NIL) { goto L26; } + goto L19; +L26:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, VV[43], v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA237 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC40__lambda237(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function DELETE-FROM-PLISTF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC43delete_from_plistf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC42__lambda248,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = v3; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L11; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[45], v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[21],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L11:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L20; +L19:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L20:; + if (v12si__d==ECL_NIL) { goto L26; } + goto L19; +L26:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, VV[45], v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[21],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA248 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC42__lambda248(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* function definition for SANS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L44sans(cl_narg narg, cl_object v1plist, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2keys; + ecl_va_list args; ecl_va_start(args,v1plist,narg,1); + v2keys = cl_grab_rest_args(args); + ecl_va_end(args); + T0 = ecl_fdefinition(VV[43]); + value0 = cl_apply(3, T0, v1plist, v2keys); + return value0; + } +} +/* function definition for MAPPEND */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L45mappend(cl_narg narg, cl_object v1function, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2lists; + ecl_va_list args; ecl_va_start(args,v1function,narg,1); + v2lists = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v3; + cl_object v4results; + cl_object v5; + T0 = (ECL_SYM("MAPCAR",547)->symbol.gfdef); + v3 = cl_apply(3, T0, v1function, v2lists); + v4results = ECL_NIL; + v5 = v3; + { + cl_object v6; + cl_object v7; + v6 = ecl_list1(ECL_NIL); + v7 = v6; +L7:; + if (!(ecl_endp(v5))) { goto L9; } + goto L8; +L9:; + v4results = ECL_CONS_CAR(v5); + { + cl_object v8; + v8 = ECL_CONS_CDR(v5); + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5 = v8; + } + { + cl_object v8; + v8 = cl_copy_list(v4results); + { + cl_object v9; + v9 = v7; + if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v9; + } + (ECL_CONS_CDR(T0)=v8,T0); + if (Null(v8)) { goto L17; } + } + T0 = ecl_cdr(v7); + v7 = ecl_last(T0,1); +L17:; + goto L7; +L8:; + value0 = ecl_cdr(v6); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* function definition for SETP */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L46setp(cl_narg narg, cl_object v1object, ...) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2test; + cl_object v3key; + ecl_va_list args; ecl_va_start(args,v1object,narg,1); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L46setpkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v2test = (ECL_SYM("EQL",336)->symbol.gfdef); + } else { + v2test = keyvars[0]; + } + if (Null(keyvars[3])) { + v3key = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + } else { + v3key = keyvars[1]; + } + } + if (!(ECL_LISTP(v1object))) { goto L4; } + { + cl_object v4seen; + v4seen = ECL_NIL; + { + cl_object v5; + v5 = v1object; + goto L10; +L9:; + { + cl_object v6elt; + v6elt = ecl_car(v5); + { + cl_object v7key; + v7key = ecl_function_dispatch(cl_env_copy,v3key)(1, v6elt); + { + cl_object v8; + v8 = v4seen; + goto L21; +L20:; + { + cl_object v9; + cl_object v10; + { + cl_object v11; + v11 = v8; + if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v11; + } + v10 = ECL_CONS_CAR(v9); + if (Null(ecl_function_dispatch(cl_env_copy,v2test)(2, v7key, v10))) { goto L23; } + if (Null(v9)) { goto L16; } + goto L17; + } +L23:; + v8 = ECL_CONS_CDR(v8); +L21:; + if (v8==ECL_NIL) { goto L31; } + goto L20; +L31:; + goto L16; + } +L17:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L16:; + v4seen = CONS(v7key,v4seen); + } + } + v5 = ecl_cdr(v5); +L10:; + if (Null(v5)) { goto L36; } + goto L9; +L36:; + value0 = ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } + } +L4:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for SET-EQUAL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L47set_equal(cl_narg narg, cl_object v1list1, cl_object v2list2, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3test; + cl_object v4key; + cl_object v5keyp; + ecl_va_list args; ecl_va_start(args,v2list2,narg,2); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L47set_equalkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + } else { + v3test = keyvars[0]; + } + v4key = keyvars[1]; + v5keyp = keyvars[3]; + } + { + cl_object v6; + cl_object v7; + if (Null(v5keyp)) { goto L3; } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v1list1; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ecl_list1(ECL_NIL); + v11 = v10; +L11:; + if (!(ecl_endp(v9))) { goto L13; } + goto L12; +L13:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v12; + v12 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v12; + } + { + cl_object v12; + v12 = v11; + if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v12; + } + T1 = ecl_function_dispatch(cl_env_copy,v4key)(1, v8); + v11 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v11,T0); + goto L11; +L12:; + v6 = ecl_cdr(v10); + goto L2; + } + } +L3:; + v6 = v1list1; +L2:; + if (Null(v5keyp)) { goto L30; } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v2list2; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ecl_list1(ECL_NIL); + v11 = v10; +L38:; + if (!(ecl_endp(v9))) { goto L40; } + goto L39; +L40:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v12; + v12 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v12; + } + { + cl_object v12; + v12 = v11; + if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v12; + } + T1 = ecl_function_dispatch(cl_env_copy,v4key)(1, v8); + v11 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v11,T0); + goto L38; +L39:; + v7 = ecl_cdr(v10); + goto L29; + } + } +L30:; + v7 = v2list2; +L29:; + { + cl_object v8; + v8 = v6; + goto L62; +L61:; + { + cl_object v9elt; + v9elt = ecl_car(v8); + { + cl_object v10; + v10 = v7; + goto L73; +L72:; + { + cl_object v11; + cl_object v12; + { + cl_object v13; + v13 = v10; + if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v13; + } + v12 = ECL_CONS_CAR(v11); + if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v9elt, v12))) { goto L75; } + value0 = v11; + goto L69; + } +L75:; + v10 = ECL_CONS_CDR(v10); +L73:; + if (v10==ECL_NIL) { goto L83; } + goto L72; +L83:; + value0 = ECL_NIL; + } +L69:; + if ((value0)!=ECL_NIL) { goto L68; } + goto L57; +L68:; + goto L66; +L66:; + } + v8 = ecl_cdr(v8); +L62:; + if (Null(v8)) { goto L87; } + goto L61; +L87:; + } + { + cl_object v8; + v8 = v7; + goto L92; +L91:; + { + cl_object v9elt; + v9elt = ecl_car(v8); + { + cl_object v10; + v10 = v6; + goto L103; +L102:; + { + cl_object v11; + cl_object v12; + { + cl_object v13; + v13 = v10; + if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v13; + } + v12 = ECL_CONS_CAR(v11); + if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v9elt, v12))) { goto L105; } + value0 = v11; + goto L99; + } +L105:; + v10 = ECL_CONS_CDR(v10); +L103:; + if (v10==ECL_NIL) { goto L113; } + goto L102; +L113:; + value0 = ECL_NIL; + } +L99:; + if ((value0)!=ECL_NIL) { goto L98; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L98:; + goto L96; +L96:; + } + v8 = ecl_cdr(v8); +L92:; + if (Null(v8)) { goto L117; } + goto L91; +L117:; + value0 = ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } +L57:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MAP-PRODUCT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L51map_product(cl_narg narg, cl_object v1function, cl_object v2list, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3more_lists; + ecl_va_list args; ecl_va_start(args,v2list,narg,2); + v3more_lists = cl_grab_rest_args(args); + ecl_va_end(args); + T0 = ecl_function_dispatch(cl_env_copy,VV[99])(1, v1function) /* ENSURE-FUNCTION */; + T1 = CONS(v2list,v3more_lists); + value0 = LC50_map_product(T0, T1); + return value0; + } +} +/* local function %MAP-PRODUCT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC50_map_product(cl_object v1f, cl_object v2lists) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1f,env0); /* F */ + { + cl_object v3; + cl_object v4; + cl_object env1 = env0; + v3 = ecl_cdr(v2lists); + v4 = ecl_car(v2lists); + CLV1 = env1 = CONS(v3,env1); /* MORE */ + if ((ECL_CONS_CAR(CLV1))!=ECL_NIL) { goto L3; } + { + cl_object v5; + cl_object v6; + v5 = ECL_NIL; + { + cl_object v7; + v7 = v4; + if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v7; + } + { + cl_object v7; + cl_object v8; + v7 = ecl_list1(ECL_NIL); + v8 = v7; +L11:; + if (!(ecl_endp(v6))) { goto L13; } + goto L12; +L13:; + v5 = ECL_CONS_CAR(v6); + { + cl_object v9; + v9 = ECL_CONS_CDR(v6); + if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = v9; + } + { + cl_object v9; + v9 = v8; + if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v9; + } + T1 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v5); + v8 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v8,T0); + goto L11; +L12:; + value0 = ecl_cdr(v7); + cl_env_copy->nvalues = 1; + return value0; + } + } +L3:; + { + cl_object v9; + v9 = ecl_make_cclosure_va((cl_objectfn)LC49__lambda338,env1,Cblock,1); + T0 = v9; + } + value0 = L45mappend(2, T0, v4); + return value0; + } + } +} +/* closure LAMBDA338 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC49__lambda338(cl_narg narg, cl_object v1x, ...) +{ + cl_object T0; + cl_object CLV0, CLV1, CLV2, CLV3; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* MORE */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v2; + cl_object env1 = env0; + v2 = ecl_function_dispatch(cl_env_copy,VV[99])(1, ECL_CONS_CAR(CLV0)) /* ENSURE-FUNCTION */; + CLV2 = env1 = CONS(v2,env1); + CLV3 = env1 = CONS(v1x,env1); + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC48__lambda343,env1,Cblock,0); + T0 = v3; + } + } + value0 = LC50_map_product(T0, ECL_CONS_CAR(CLV1)); + return value0; + } + } +} +/* closure LAMBDA343 */ +/* optimize speed 3, debug 1, space 0, safety 1 */ +static cl_object LC48__lambda343(cl_narg narg, ...) +{ + cl_object CLV0, CLV1, CLV2, CLV3; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + /* Scanning closure data ... */ + CLV3 = env0; + CLV2 = _ecl_cdr(CLV3); + CLV1 = _ecl_cdr(CLV2); + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + { + cl_object v1more; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1more = cl_grab_rest_args(args); + ecl_va_end(args); + value0 = cl_apply(3, ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV3), v1more); + return value0; + } + } +} +/* function definition for FLATTEN */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L53flatten(cl_object v1tree) +{ + volatile cl_object lex0[1]; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + lex0[0] = ECL_NIL; /* LIST */ + LC52traverse(lex0, v1tree); + value0 = cl_nreverse(lex0[0]); + return value0; + } +} +/* local function TRAVERSE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC52traverse(volatile cl_object *lex0, cl_object v1subtree) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1subtree)) { goto L1; } + if (!(ECL_CONSP(v1subtree))) { goto L3; } + T0 = ecl_car(v1subtree); + LC52traverse(lex0, T0); + v1subtree = ecl_cdr(v1subtree); + goto TTL; +L3:; + lex0[0] = CONS(v1subtree,lex0[0]); + value0 = lex0[0]; + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} + +#include "lib/alexandria/lists.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecli7UuzzMOVz39M_TlGycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/lists.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecli7UuzzMOVz39M_TlGycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[54]); /* SAFE-ENDP */ + si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[5]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[55]); /* ALIST-PLIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[9]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[12]) /* ANNOTATE */; + ecl_cmp_defun(VV[57]); /* PLIST-ALIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[13]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[14]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[17]) /* ANNOTATE */; + ecl_cmp_defun(VV[58]); /* RACONS */ + si_put_sysprop(VV[3], ECL_SYM("INLINE",436), VVtemp[18]); + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[19]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; + ecl_cmp_defun(VV[59]); /* ASSOC-VALUE */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[23]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[4], ECL_SYM("INLINE",436), VVtemp[24]); + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC6__lambda30,ECL_NIL,Cblock,2); + T0 = v1; + } + si_do_define_setf_method(VV[4], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[25]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; + ecl_cmp_defun(VV[60]); /* RASSOC-VALUE */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[27]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[13], ECL_SYM("INLINE",436), VVtemp[28]); + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC8__lambda41,ECL_NIL,Cblock,2); + T0 = v1; + } + si_do_define_setf_method(VV[13], T0); + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[12]) /* ANNOTATE */; + ecl_cmp_defun(VV[65]); /* MALFORMED-PLIST */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[66]); /* DOPLIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[34]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[35], VVtemp[36]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[37]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[69]); /* APPENDF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[38]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[40]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[37]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[70]); /* NCONCF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[22], ECL_SYM("FUNCTION",398), VVtemp[41]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[42], VVtemp[43]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[44]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[71]); /* UNIONF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[23], ECL_SYM("FUNCTION",398), VVtemp[45]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LOCATION",1862), VVtemp[46], VVtemp[47]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[44]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[72]); /* NUNIONF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[24], ECL_SYM("FUNCTION",398), VVtemp[48]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[49], VVtemp[50]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[51]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[73]); /* REVERSEF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[25], ECL_SYM("FUNCTION",398), VVtemp[52]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[53], VVtemp[54]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[51]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[74]); /* NREVERSEF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[26], ECL_SYM("FUNCTION",398), VVtemp[55]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LOCATION",1862), VVtemp[56], VVtemp[57]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[58]) /* ANNOTATE */; + ecl_cmp_defun(VV[75]); /* CIRCULAR-LIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[27], ECL_SYM("FUNCTION",398), VVtemp[59]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; + ecl_cmp_defun(VV[76]); /* CIRCULAR-LIST-P */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[63]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LOCATION",1862), VVtemp[64], VVtemp[65]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; + ecl_cmp_defun(VV[77]); /* CIRCULAR-TREE-P */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[29], ECL_SYM("FUNCTION",398), VVtemp[66]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[30], ECL_SYM("LOCATION",1862), VVtemp[67], VVtemp[68]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[30], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; + ecl_cmp_defun(VV[78]); /* PROPER-LIST-P */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[30], ECL_SYM("FUNCTION",398), VVtemp[69]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[31], ECL_SYM("TYPE",871), VVtemp[70]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC28__lambda161,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[31], VVtemp[71], T0); + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LOCATION",1862), VVtemp[72], VVtemp[73]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; + ecl_cmp_defun(VV[79]); /* CIRCULAR-LIST-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[35], ECL_SYM("LOCATION",1862), VVtemp[75], VVtemp[76]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[35], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; + ecl_cmp_defun(VV[80]); /* PROPER-LIST-LENGTH */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[35], ECL_SYM("FUNCTION",398), VVtemp[77]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LOCATION",1862), VVtemp[78], VVtemp[76]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; + ecl_cmp_defun(VV[81]); /* LASTCAR */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[36], ECL_SYM("FUNCTION",398), VVtemp[79]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[80], ECL_SYM("LOCATION",1862), VVtemp[81], VVtemp[76]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[80], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[82]) /* ANNOTATE */; + ecl_cmp_defun(VV[82]); /* (SETF LASTCAR) */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[37], ECL_SYM("FUNCTION",398), VVtemp[83]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LOCATION",1862), VVtemp[84], VVtemp[85]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[86]) /* ANNOTATE */; + ecl_cmp_defun(VV[83]); /* MAKE-CIRCULAR-LIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[38], ECL_SYM("FUNCTION",398), VVtemp[87]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[27], ECL_SYM("TYPE",871), VVtemp[88]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC34__lambda193,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[27], VVtemp[89], T0); + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[90], VVtemp[91]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[92]) /* ANNOTATE */; + ecl_cmp_defun(VV[85]); /* ENSURE-CAR */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[40], ECL_SYM("FUNCTION",398), VVtemp[93]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LOCATION",1862), VVtemp[94], VVtemp[95]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[96]) /* ANNOTATE */; + ecl_cmp_defun(VV[86]); /* ENSURE-CONS */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[41], ECL_SYM("FUNCTION",398), VVtemp[97]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[98], VVtemp[99]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; + ecl_cmp_defun(VV[87]); /* ENSURE-LIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[42], ECL_SYM("FUNCTION",398), VVtemp[100]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LOCATION",1862), VVtemp[101], VVtemp[102]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[103]) /* ANNOTATE */; + ecl_cmp_defun(VV[88]); /* REMOVE-FROM-PLIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[43], ECL_SYM("FUNCTION",398), VVtemp[104]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LOCATION",1862), VVtemp[105], VVtemp[106]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[103]) /* ANNOTATE */; + ecl_cmp_defun(VV[89]); /* DELETE-FROM-PLIST */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[45], ECL_SYM("FUNCTION",398), VVtemp[107]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[46], ECL_SYM("LOCATION",1862), VVtemp[108], VVtemp[109]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[46], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[110]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[90]); /* REMOVE-FROM-PLISTF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[46], ECL_SYM("FUNCTION",398), VVtemp[111]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[47], ECL_SYM("LOCATION",1862), VVtemp[112], VVtemp[113]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[47], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[110]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[91]); /* DELETE-FROM-PLISTF */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[47], ECL_SYM("FUNCTION",398), VVtemp[114]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[115]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LOCATION",1862), VVtemp[116], VVtemp[117]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[103]) /* ANNOTATE */; + ecl_cmp_defun(VV[92]); /* SANS */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[48], ECL_SYM("FUNCTION",398), VVtemp[118]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[48], ECL_SYM("INLINE",436), VVtemp[119]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LOCATION",1862), VVtemp[120], VVtemp[121]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[122]) /* ANNOTATE */; + ecl_cmp_defun(VV[93]); /* MAPPEND */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[49], ECL_SYM("FUNCTION",398), VVtemp[123]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LOCATION",1862), VVtemp[124], VVtemp[125]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[126]) /* ANNOTATE */; + ecl_cmp_defun(VV[94]); /* SETP */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[50], ECL_SYM("FUNCTION",398), VVtemp[127]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LOCATION",1862), VVtemp[128], VVtemp[129]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[130]) /* ANNOTATE */; + ecl_cmp_defun(VV[97]); /* SET-EQUAL */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[51], ECL_SYM("FUNCTION",398), VVtemp[131]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[52], ECL_SYM("LOCATION",1862), VVtemp[132], VVtemp[133]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[52], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[134]) /* ANNOTATE */; + ecl_cmp_defun(VV[98]); /* MAP-PRODUCT */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[52], ECL_SYM("FUNCTION",398), VVtemp[135]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[53], ECL_SYM("LOCATION",1862), VVtemp[136], VVtemp[137]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[53], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[138]) /* ANNOTATE */; + ecl_cmp_defun(VV[100]); /* FLATTEN */ + ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[53], ECL_SYM("FUNCTION",398), VVtemp[139]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/macros.cxx b/lib/alexandria/macros.cxx new file mode 100644 index 0000000..af4271c --- /dev/null +++ b/lib/alexandria/macros.cxx @@ -0,0 +1,1497 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/macros.lisp */ +#include +#include "lib/alexandria/macros.eclh" +/* local function WITH-GENSYMS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2with_gensyms(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4names; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4names = v5; + } + { + cl_object v5; + { + cl_object v6; + v6 = ecl_make_cfun((cl_objectfn_fixed)LC1__lambda16,ECL_NIL,Cblock,1); + v5 = v6; + } + { + cl_object v6; + cl_object v7; + v6 = ECL_NIL; + { + cl_object v8; + v8 = v4names; + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ecl_list1(ECL_NIL); + v9 = v8; +L16:; + if (!(ecl_endp(v7))) { goto L18; } + goto L17; +L18:; + v6 = ECL_CONS_CAR(v7); + { + cl_object v10; + v10 = ECL_CONS_CDR(v7); + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v10; + } + { + cl_object v10; + v10 = v9; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v10; + } + T2 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); + v9 = ecl_list1(T2); + (ECL_CONS_CDR(T1)=v9,T1); + goto L16; +L17:; + T0 = ecl_cdr(v8); + goto L8; + } + } + } +L8:; + value0 = cl_listX(3, ECL_SYM("LET",479), T0, v3); + return value0; + } + } +} +/* local function LAMBDA16 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1__lambda16(cl_object v1name) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; /* SYMBOL */ + cl_object v4; /* STRING */ + if (!(ECL_SYMBOLP(v1name))) { goto L2; } + T0 = ecl_symbol_name(v1name); + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = T0; + cl_env_copy->values[0] = v1name; + value0 = cl_env_copy->values[0]; + goto L1; +L2:; + if (Null(cl_typep(2, v1name, VV[1]))) { goto L4; } + T0 = ecl_car(v1name); + T1 = ecl_cadr(v1name); + T2 = cl_string(T1); + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = T2; + cl_env_copy->values[0] = T0; + value0 = cl_env_copy->values[0]; + goto L1; +L4:; + value0 = si_etypecase_error(v1name, VV[2]); +L1:; + { + const int v5 = cl_env_copy->nvalues; + v3 = value0; + cl_object v6; + v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1]; + v4 = v6; + } + T0 = cl_list(2, ECL_SYM("GENSYM",402), v4); + value0 = cl_list(2, v3, T0); + return value0; + } + } +} +/* local function WITH-UNIQUE-NAMES */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3with_unique_names(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4names; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4names = v5; + } + value0 = cl_listX(3, VV[0], v4names, v3); + return value0; + } + } +} +/* local function ONCE-ONLY */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC8once_only(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4specs; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4specs = v5; + } + { + cl_object v5; + cl_object v6; + { + cl_fixnum v7; + v7 = ecl_length(v4specs); + v5 = ecl_function_dispatch(cl_env_copy,VV[48])(2, ecl_make_fixnum(v7), VV[5]) /* MAKE-GENSYM-LIST */; + } + { + cl_object v7; + { + cl_object v8; + v8 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda53,ECL_NIL,Cblock,1); + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v4specs; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ecl_list1(ECL_NIL); + v11 = v10; +L17:; + if (!(ecl_endp(v9))) { goto L19; } + goto L18; +L19:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v12; + v12 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v12; + } + { + cl_object v12; + v12 = v11; + if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v12; + } + T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); + v11 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v11,T0); + goto L17; +L18:; + v6 = ecl_cdr(v10); + goto L9; + } + } + } +L9:; + { + cl_object v7; + { + cl_object v8; + v8 = ecl_make_cfun((cl_objectfn_fixed)LC5__lambda68,ECL_NIL,Cblock,2); + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v5; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ECL_NIL; + { + cl_object v12; + v12 = v6; + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v12; + } + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L47:; + if (!(ecl_endp(v9))) { goto L49; } + goto L48; +L49:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v14; + v14 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v14; + } + if (!(ecl_endp(v11))) { goto L57; } + goto L48; +L57:; + v10 = ECL_CONS_CAR(v11); + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T1 = v14; + } + T2 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); + v13 = ecl_list1(T2); + (ECL_CONS_CDR(T1)=v13,T1); + goto L47; +L48:; + T0 = ecl_cdr(v12); + goto L35; + } + } + } + } +L35:; + { + cl_object v7; + { + cl_object v8; + v8 = ecl_make_cfun((cl_objectfn_fixed)LC6__lambda80,ECL_NIL,Cblock,2); + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v5; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ECL_NIL; + { + cl_object v12; + v12 = v6; + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v12; + } + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L85:; + if (!(ecl_endp(v9))) { goto L87; } + goto L86; +L87:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v14; + v14 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v14; + } + if (!(ecl_endp(v11))) { goto L95; } + goto L86; +L95:; + v10 = ECL_CONS_CAR(v11); + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T2 = v14; + } + T3 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); + v13 = ecl_list1(T3); + (ECL_CONS_CDR(T2)=v13,T2); + goto L85; +L86:; + T1 = ecl_cdr(v12); + goto L73; + } + } + } + } +L73:; + T2 = CONS(ECL_SYM("LIST",483),T1); + { + cl_object v7; + { + cl_object v8; + v8 = ecl_make_cfun((cl_objectfn_fixed)LC7__lambda92,ECL_NIL,Cblock,2); + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ECL_NIL; + { + cl_object v10; + v10 = v6; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ECL_NIL; + { + cl_object v12; + v12 = v5; + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v12; + } + { + cl_object v12; + cl_object v13; + v12 = ecl_list1(ECL_NIL); + v13 = v12; +L123:; + if (!(ecl_endp(v9))) { goto L125; } + goto L124; +L125:; + v8 = ECL_CONS_CAR(v9); + { + cl_object v14; + v14 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v14; + } + if (!(ecl_endp(v11))) { goto L133; } + goto L124; +L133:; + v10 = ECL_CONS_CAR(v11); + { + cl_object v14; + v14 = ECL_CONS_CDR(v11); + if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v11 = v14; + } + { + cl_object v14; + v14 = v13; + if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T4 = v14; + } + T5 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); + v13 = ecl_list1(T5); + (ECL_CONS_CDR(T4)=v13,T4); + goto L123; +L124:; + T3 = ecl_cdr(v12); + goto L111; + } + } + } + } +L111:; + T4 = cl_listX(3, ECL_SYM("LET",479), T3, v3); + T5 = cl_list(4, ECL_SYM("LIST",483), VV[7], T2, T4); + value0 = cl_list(3, ECL_SYM("LET",479), T0, T5); + return value0; + } + } + } +} +/* local function LAMBDA53 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC4__lambda53(cl_object v1spec) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LISTP(v1spec))) { goto L1; } + { + cl_object v2; + cl_object v3name; + cl_object v4form; + v2 = v1spec; + if (!(v2==ECL_NIL)) { goto L5; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; +L5:; + { + cl_object v5; + v5 = ecl_car(v2); + v2 = ecl_cdr(v2); + v3name = v5; + } + if (!(v2==ECL_NIL)) { goto L11; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; +L11:; + { + cl_object v5; + v5 = ecl_car(v2); + v2 = ecl_cdr(v2); + v4form = v5; + } + if (Null(v2)) { goto L16; } + ecl_function_dispatch(cl_env_copy,VV[49])(1, v1spec) /* DM-TOO-MANY-ARGUMENTS */; +L16:; + value0 = CONS(v3name,v4form); + cl_env_copy->nvalues = 1; + return value0; + } +L1:; + if (!(ECL_SYMBOLP(v1spec))) { goto L18; } + value0 = CONS(v1spec,v1spec); + cl_env_copy->nvalues = 1; + return value0; +L18:; + value0 = si_etypecase_error(v1spec, VV[6]); + return value0; + } +} +/* local function LAMBDA68 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC5__lambda68(cl_object v1g, cl_object v2n) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = ecl_car(v2n); + T1 = cl_string(T0); + T2 = cl_list(2, ECL_SYM("GENSYM",402), T1); + value0 = cl_list(2, v1g, T2); + return value0; + } +} +/* local function LAMBDA80 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC6__lambda80(cl_object v1g, cl_object v2n) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = ecl_cdr(v2n); + value0 = cl_list(3, ECL_SYM("LIST",483), v1g, T0); + return value0; + } +} +/* local function LAMBDA92 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC7__lambda92(cl_object v1n, cl_object v2g) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = ecl_car(v1n); + value0 = cl_list(2, T0, v2g); + return value0; + } +} +/* function definition for PARSE-BODY */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L9parse_body(cl_narg narg, cl_object v1body, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2documentation; + cl_object v3whole; + ecl_va_list args; ecl_va_start(args,v1body,narg,1); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L9parse_bodykeys,keyvars,NULL,FALSE); + ecl_va_end(args); + v2documentation = keyvars[0]; + v3whole = keyvars[1]; + } + { + cl_object v4doc; + cl_object v5decls; + cl_object v6current; + v4doc = ECL_NIL; + v5decls = ECL_NIL; + v6current = ECL_NIL; +L5:; + v6current = ecl_car(v1body); + if (Null(v2documentation)) { goto L8; } + if (!(ECL_STRINGP(v6current))) { goto L8; } + if (Null(ecl_cdr(v1body))) { goto L8; } + if (Null(v4doc)) { goto L13; } + value0 = v3whole; + if ((value0)!=ECL_NIL) { goto L17; } + T0 = v1body; + goto L15; +L17:; + T0 = value0; + goto L15; +L15:; + cl_error(2, VV[9], T0); + goto L12; +L13:; + { + cl_object v7; + v7 = v1body; + { + cl_object v8; + v8 = v7; + { + bool v9; + v9 = ECL_LISTP(v8); + if (ecl_unlikely(!(v9))) + FEwrong_type_argument(VV[10],v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + if (Null(v7)) { goto L24; } + { + cl_object v8; + v8 = ECL_CONS_CDR(v7); + v1body = v8; + v7 = ECL_CONS_CAR(v7); + } +L24:; + v4doc = v7; + } +L12:; + goto L5; +L8:; + if (!(ECL_LISTP(v6current))) { goto L30; } + T0 = ecl_car(v6current); + if (!((T0)==(ECL_SYM("DECLARE",276)))) { goto L30; } + { + cl_object v7; + v7 = v1body; + { + cl_object v8; + v8 = v7; + { + bool v9; + v9 = ECL_LISTP(v8); + if (ecl_unlikely(!(v9))) + FEwrong_type_argument(VV[10],v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + if (Null(v7)) { goto L40; } + { + cl_object v8; + v8 = ECL_CONS_CDR(v7); + v1body = v8; + v7 = ECL_CONS_CAR(v7); + } +L40:; + T0 = v7; + } + v5decls = CONS(T0,v5decls); + goto L5; +L30:; + T0 = cl_nreverse(v5decls); + cl_env_copy->nvalues = 3; + cl_env_copy->values[2] = v4doc; + cl_env_copy->values[1] = T0; + cl_env_copy->values[0] = v1body; + return cl_env_copy->values[0]; + } + } +} +/* function definition for PARSE-ORDINARY-LAMBDA-LIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L13parse_ordinary_lambda_list(cl_narg narg, cl_object v1lambda_list, ...) +{ + cl_object T0, T1, T2, T3; + volatile cl_object lex0[2]; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2normalize; + cl_object v3normalize_optional; + cl_object v4normalize_keyword; + cl_object v5normalize_auxilary; + ecl_va_list args; ecl_va_start(args,v1lambda_list,narg,1); + lex0[0] = v1lambda_list; /* LAMBDA-LIST */ + { + cl_object keyvars[10]; + cl_parse_key(args,5,L13parse_ordinary_lambda_listkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[5])) { + v2normalize = ECL_T; + } else { + v2normalize = keyvars[0]; + } + lex0[1] = keyvars[1]; /* ALLOW-SPECIALIZERS */ + if (Null(keyvars[7])) { + v3normalize_optional = v2normalize; + } else { + v3normalize_optional = keyvars[2]; + } + if (Null(keyvars[8])) { + v4normalize_keyword = v2normalize; + } else { + v4normalize_keyword = keyvars[3]; + } + if (Null(keyvars[9])) { + v5normalize_auxilary = v2normalize; + } else { + v5normalize_auxilary = keyvars[4]; + } + } + { + cl_object v6state; + cl_object v7allow_other_keys; + cl_object v8auxp; + cl_object v9required; + cl_object v10optional; + cl_object v11rest; + cl_object v12keys; + cl_object v13keyp; + cl_object v14aux; + v6state = ECL_SYM("REQUIRED",1010); + v7allow_other_keys = ECL_NIL; + v8auxp = ECL_NIL; + v9required = ECL_NIL; + v10optional = ECL_NIL; + v11rest = ECL_NIL; + v12keys = ECL_NIL; + v13keyp = ECL_NIL; + v14aux = ECL_NIL; + { + cl_object v15; + v15 = lex0[0]; + goto L18; +L17:; + { + cl_object v16elt; + v16elt = ecl_car(v15); + { + cl_object v17; + v17 = v16elt; + if (!((v17)==(ECL_SYM("&OPTIONAL",13)))) { goto L24; } + if (!((v6state)==(ECL_SYM("REQUIRED",1010)))) { goto L26; } + v6state = v16elt; + goto L22; +L26:; + LC10fail(lex0, v16elt); + goto L22; +L24:; + if (!((v17)==(ECL_SYM("&REST",14)))) { goto L29; } + if (!((v6state)==(ECL_SYM("REQUIRED",1010)))) { goto L36; } + goto L33; + goto L34; +L36:; + goto L34; +L34:; + if (!((v6state)==(ECL_SYM("&OPTIONAL",13)))) { goto L31; } + goto L32; +L33:; +L32:; + v6state = v16elt; + goto L22; +L31:; + LC10fail(lex0, v16elt); + goto L22; +L29:; + if (!((v17)==(ECL_SYM("&KEY",12)))) { goto L40; } + if (!((v6state)==(ECL_SYM("REQUIRED",1010)))) { goto L48; } + goto L45; + goto L46; +L48:; + goto L46; +L46:; + if (!((v6state)==(ECL_SYM("&OPTIONAL",13)))) { goto L52; } + goto L45; + goto L50; +L52:; + goto L50; +L50:; + if (!((v6state)==(VV[18]))) { goto L43; } + goto L44; +L45:; +L44:; + v6state = v16elt; + goto L42; +L43:; + LC10fail(lex0, v16elt); +L42:; + v13keyp = ECL_T; + goto L22; +L40:; + if (!((v17)==(ECL_SYM("&ALLOW-OTHER-KEYS",8)))) { goto L57; } + if (!((v6state)==(ECL_SYM("&KEY",12)))) { goto L59; } + v7allow_other_keys = ECL_T; + v6state = v16elt; + goto L22; +L59:; + LC10fail(lex0, v16elt); + goto L22; +L57:; + if (!((v17)==(ECL_SYM("&AUX",9)))) { goto L64; } + if (!((v6state)==(ECL_SYM("&REST",14)))) { goto L66; } + LC10fail(lex0, v16elt); + goto L22; +L66:; + if (Null(v8auxp)) { goto L68; } + ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[20], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + goto L22; +L68:; + v8auxp = ECL_T; + v6state = v16elt; + goto L22; +L64:; + if (!((v16elt)==(ECL_SYM("&WHOLE",15)))) { goto L78; } + goto L75; + goto L76; +L78:; + goto L76; +L76:; + if (!((v16elt)==(ECL_SYM("&ENVIRONMENT",11)))) { goto L82; } + goto L75; + goto L80; +L82:; + goto L80; +L80:; + if (!((v16elt)==(ECL_SYM("&BODY",10)))) { goto L73; } + goto L74; +L75:; +L74:; + ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[24], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; +L73:; + { + cl_object v18; + v18 = v6state; + if (!((v18)==(ECL_SYM("REQUIRED",1010)))) { goto L86; } + LC11check_variable(2, lex0, v16elt, VV[25]); + v9required = CONS(v16elt,v9required); + goto L22; +L86:; + if (!((v18)==(ECL_SYM("&OPTIONAL",13)))) { goto L90; } + if (!(ECL_CONSP(v16elt))) { goto L93; } + { + cl_object v19; + cl_object v20; + cl_object v21name; + v19 = v16elt; + v20 = v19; + if (!(v20==ECL_NIL)) { goto L98; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v19) /* DM-TOO-FEW-ARGUMENTS */; +L98:; + { + cl_object v22; + v22 = ecl_car(v20); + v20 = ecl_cdr(v20); + v21name = v22; + } + LC11check_variable(2, lex0, v21name, VV[26]); + if (Null(ecl_cdr(v20))) { goto L104; } + LC12check_spec(lex0, v20, VV[27]); + goto L92; +L104:; + if (Null(v3normalize_optional)) { goto L92; } + v16elt = ecl_append(v16elt,VV[28]); + goto L92; + } +L93:; + LC11check_variable(2, lex0, v16elt, VV[26]); + if (Null(v3normalize_optional)) { goto L92; } + v16elt = CONS(v16elt,VV[29]); +L92:; + T0 = ecl_function_dispatch(cl_env_copy,VV[60])(1, v16elt) /* ENSURE-LIST */; + v10optional = CONS(T0,v10optional); + goto L22; +L90:; + if (!((v18)==(ECL_SYM("&REST",14)))) { goto L112; } + LC11check_variable(2, lex0, v16elt, VV[30]); + v11rest = v16elt; + v6state = VV[18]; + goto L22; +L112:; + if (!((v18)==(ECL_SYM("&KEY",12)))) { goto L118; } + if (!(ECL_CONSP(v16elt))) { goto L121; } + { + cl_object v19; + cl_object v20; + cl_object v21var_or_kv; + cl_object v22tail; + v19 = v16elt; + v20 = v19; + if (!(v20==ECL_NIL)) { goto L126; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v19) /* DM-TOO-FEW-ARGUMENTS */; +L126:; + { + cl_object v23; + v23 = ecl_car(v20); + v20 = ecl_cdr(v20); + v21var_or_kv = v23; + } + v22tail = v20; + if (!(ECL_CONSP(v21var_or_kv))) { goto L133; } + { + cl_object v23; + cl_object v24keyword; + cl_object v25var; + v23 = v21var_or_kv; + if (!(v23==ECL_NIL)) { goto L137; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v21var_or_kv) /* DM-TOO-FEW-ARGUMENTS */; +L137:; + { + cl_object v26; + v26 = ecl_car(v23); + v23 = ecl_cdr(v23); + v24keyword = v26; + } + if (!(v23==ECL_NIL)) { goto L143; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v21var_or_kv) /* DM-TOO-FEW-ARGUMENTS */; +L143:; + { + cl_object v26; + v26 = ecl_car(v23); + v23 = ecl_cdr(v23); + v25var = v26; + } + if (Null(v23)) { goto L148; } + ecl_function_dispatch(cl_env_copy,VV[49])(1, v21var_or_kv) /* DM-TOO-MANY-ARGUMENTS */; +L148:; + if (ECL_SYMBOLP(v24keyword)) { goto L150; } + ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[31], v24keyword, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; +L150:; + LC11check_variable(2, lex0, v25var, VV[32]); + goto L132; + } +L133:; + LC11check_variable(2, lex0, v21var_or_kv, VV[32]); + if (Null(v4normalize_keyword)) { goto L132; } + T0 = ecl_function_dispatch(cl_env_copy,VV[61])(1, v21var_or_kv) /* MAKE-KEYWORD */; + v21var_or_kv = cl_list(2, T0, v21var_or_kv); +L132:; + if (Null(ecl_cdr(v22tail))) { goto L156; } + LC12check_spec(lex0, v22tail, VV[33]); + goto L155; +L156:; + if (Null(v4normalize_keyword)) { goto L155; } + v22tail = ecl_append(v22tail,VV[28]); +L155:; + v16elt = CONS(v21var_or_kv,v22tail); + goto L120; + } +L121:; + LC11check_variable(2, lex0, v16elt, VV[32]); + if (Null(v4normalize_keyword)) { goto L163; } + T0 = ecl_function_dispatch(cl_env_copy,VV[61])(1, v16elt) /* MAKE-KEYWORD */; + T1 = cl_list(2, T0, v16elt); + v16elt = cl_list(3, T1, ECL_NIL, ECL_NIL); + goto L162; +L163:; +L162:; +L120:; + v12keys = CONS(v16elt,v12keys); + goto L22; +L118:; + if (!((v18)==(ECL_SYM("&AUX",9)))) { goto L166; } + if (!(ECL_CONSP(v16elt))) { goto L169; } + { + cl_object v19; + cl_object v20var; + cl_object v21init; + v19 = v16elt; + if (!(v19==ECL_NIL)) { goto L173; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v16elt) /* DM-TOO-FEW-ARGUMENTS */; +L173:; + { + cl_object v22; + v22 = ecl_car(v19); + v19 = ecl_cdr(v19); + v20var = v22; + } + if (Null(v19)) { goto L179; } + { + cl_object v22; + v22 = ecl_car(v19); + v19 = ecl_cdr(v19); + v21init = v22; + goto L178; + } +L179:; + v21init = ECL_NIL; +L178:; + if (Null(v19)) { goto L184; } + ecl_function_dispatch(cl_env_copy,VV[49])(1, v16elt) /* DM-TOO-MANY-ARGUMENTS */; +L184:; + LC11check_variable(2, lex0, v20var, VV[34]); + goto L168; + } +L169:; + LC11check_variable(2, lex0, v16elt, VV[34]); + if (Null(v5normalize_auxilary)) { goto L189; } + T0 = VV[28]; + goto L188; +L189:; + T0 = ECL_NIL; +L188:; + v16elt = CONS(v16elt,T0); +L168:; + v14aux = CONS(v16elt,v14aux); + goto L22; +L166:; + ecl_function_dispatch(cl_env_copy,VV[59])(2, VV[35], lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + } + } +L22:; + } + v15 = ecl_cdr(v15); +L18:; + if (Null(v15)) { goto L194; } + goto L17; +L194:; + } + T0 = cl_nreverse(v9required); + T1 = cl_nreverse(v10optional); + T2 = cl_nreverse(v12keys); + T3 = cl_nreverse(v14aux); + cl_env_copy->nvalues = 7; + cl_env_copy->values[6] = v13keyp; + cl_env_copy->values[5] = T3; + cl_env_copy->values[4] = v7allow_other_keys; + cl_env_copy->values[3] = T2; + cl_env_copy->values[2] = v11rest; + cl_env_copy->values[1] = T1; + cl_env_copy->values[0] = T0; + return cl_env_copy->values[0]; + } + } +} +/* local function CHECK-SPEC */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC12check_spec(volatile cl_object *lex0, cl_object v1spec, cl_object v2what) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4init; + cl_object v5suppliedp; + v3 = v1spec; + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4init = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5suppliedp = v6; + } + if (Null(v3)) { goto L14; } + ecl_function_dispatch(cl_env_copy,VV[49])(1, v1spec) /* DM-TOO-MANY-ARGUMENTS */; +L14:; + value0 = LC11check_variable(3, lex0, v5suppliedp, v2what, ECL_NIL); + return value0; + } + } +} +/* local function CHECK-VARIABLE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC11check_variable(cl_narg narg, volatile cl_object *lex0, cl_object v1elt, cl_object v2what, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + if (ecl_unlikely(narg>3)) FEwrong_num_arguments_anonym(); + { + cl_object v3allow_specializers; + va_list args; va_start(args,v2what); + { + int i = 2; + if (i >= narg) { + v3allow_specializers = lex0[1]; + } else { + i++; + v3allow_specializers = va_arg(args,cl_object); + } + } + va_end(args); + if (ECL_SYMBOLP(v1elt)) { goto L7; } + if (Null(v3allow_specializers)) { goto L5; } + if (!(ECL_CONSP(v1elt))) { goto L5; } + { + cl_fixnum v4; + v4 = ecl_length(v1elt); + if (!((2)==(v4))) { goto L5; } + } + T0 = ecl_car(v1elt); + if (!(ECL_SYMBOLP(T0))) { goto L5; } + goto L6; +L7:; +L6:; + if (Null(cl_constantp(1, v1elt))) { goto L2; } + goto L3; +L5:; + goto L3; +L3:; + value0 = ecl_function_dispatch(cl_env_copy,VV[59])(4, VV[13], v2what, v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function FAIL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC10fail(volatile cl_object *lex0, cl_object v1elt) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[12], v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + return value0; + } +} +/* function definition for EXPAND-DESTRUCTURING-CASE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L15expand_destructuring_case(cl_object v1key, cl_object v2clauses, cl_object v3case) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v4; + v4 = cl_gensym(1, VV[37]); + T0 = cl_list(2, v4, v1key); + T1 = ecl_list1(T0); + { + cl_object env1 = env0; + env1 = ECL_NIL; + CLV0 = env1 = CONS(v4,env1); /* KEY */ + T3 = cl_list(3, ECL_SYM("TYPEP",877), ECL_CONS_CAR(CLV0), VV[38]); + T4 = cl_list(2, ECL_SYM("CAR",182), ECL_CONS_CAR(CLV0)); + { + cl_object v5; + { + cl_object v6; + v6 = ecl_make_cclosure_va((cl_objectfn)LC14__lambda196,env1,Cblock,1); + v5 = v6; + } + { + cl_object v6; + cl_object v7; + v6 = ECL_NIL; + { + cl_object v8; + v8 = v2clauses; + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v8; + } + { + cl_object v8; + cl_object v9; + v8 = ecl_list1(ECL_NIL); + v9 = v8; +L11:; + if (!(ecl_endp(v7))) { goto L13; } + goto L12; +L13:; + v6 = ECL_CONS_CAR(v7); + { + cl_object v10; + v10 = ECL_CONS_CDR(v7); + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = v10; + } + { + cl_object v10; + v10 = v9; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T6 = v10; + } + T7 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); + v9 = ecl_list1(T7); + (ECL_CONS_CDR(T6)=v9,T6); + goto L11; +L12:; + T5 = ecl_cdr(v8); + goto L3; + } + } + } +L3:; + T6 = cl_listX(3, v3case, T4, T5); + T7 = cl_list(2, ECL_SYM("QUOTE",681), v3case); + T8 = cl_list(4, ECL_SYM("ERROR",339), VV[39], T7, ECL_CONS_CAR(CLV0)); + T2 = cl_list(4, ECL_SYM("IF",948), T3, T6, T8); + } + value0 = cl_list(3, ECL_SYM("LET",479), T1, T2); + return value0; + } + } +} +/* closure LAMBDA196 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC14__lambda196(cl_narg narg, cl_object v1clause, ...) +{ + cl_object T0, T1; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* KEY */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v2; + cl_object v3; + cl_object v4; + cl_object v5keys; + v2 = v1clause; + if (!(v2==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1clause) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v2); + v2 = ecl_cdr(v2); + v3 = v6; + } + v4 = v3; + if (!(v4==ECL_NIL)) { goto L10; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1clause) /* DM-TOO-FEW-ARGUMENTS */; +L10:; + { + cl_object v6; + v6 = ecl_car(v4); + v4 = ecl_cdr(v4); + v5keys = v6; + } + T0 = cl_list(2, ECL_SYM("CDR",200), ECL_CONS_CAR(CLV0)); + T1 = cl_listX(4, ECL_SYM("DESTRUCTURING-BIND",302), v4, T0, v2); + value0 = cl_list(2, v5keys, T1); + return value0; + } + } + } +} +/* local function DESTRUCTURING-CASE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC16destructuring_case(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4keyform; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4keyform = v5; + } + value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CASE",183)); + return value0; + } + } +} +/* local function DESTRUCTURING-CCASE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC17destructuring_ccase(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4keyform; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4keyform = v5; + } + value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CCASE",185)); + return value0; + } + } +} +/* local function DESTRUCTURING-ECASE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC18destructuring_ecase(cl_object v1, cl_object v2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4keyform; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4keyform = v5; + } + value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("ECASE",323)); + return value0; + } + } +} + +#include "lib/alexandria/macros.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecl4KRmknIfrdJJM_OjFycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/macros.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4KRmknIfrdJJM_OjFycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[43]); /* WITH-GENSYMS */ + ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[46]); /* WITH-UNIQUE-NAMES */ + ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[7]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[47]); /* ONCE-ONLY */ + ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defun(VV[50]); /* PARSE-BODY */ + ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[53]); /* PARSE-ORDINARY-LAMBDA-LIST */ + ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[11], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; + ecl_cmp_defun(VV[62]); /* EXPAND-DESTRUCTURING-CASE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[23], VVtemp[24]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[63]); /* DESTRUCTURING-CASE */ + ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[40], ECL_SYM("FUNCTION",398), VVtemp[26]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[64]); /* DESTRUCTURING-CCASE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[65]); /* DESTRUCTURING-ECASE */ + { + cl_object v1; + v1 = VVtemp[31]; + goto L51; +L50:; + { + cl_object v2name; + v2name = ecl_car(v1); + { + cl_object v3; + v3 = (cl_env_copy->function=(ECL_SYM("DOCUMENTATION",314)->symbol.gfdef))->cfun.entry(2, VV[40], ECL_SYM("FUNCTION",398)) /* DOCUMENTATION */; + (cl_env_copy->function=ECL_CONS_CAR(VV[66]))->cfun.entry(3, v3, v2name, ECL_SYM("FUNCTION",398)) /* (SETF DOCUMENTATION) */; + } + } + v1 = ecl_cdr(v1); +L51:; + if (Null(v1)) { goto L59; } + goto L50; +L59:; + } +} diff --git a/lib/alexandria/numbers.cxx b/lib/alexandria/numbers.cxx new file mode 100644 index 0000000..f7b9393 --- /dev/null +++ b/lib/alexandria/numbers.cxx @@ -0,0 +1,1656 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/numbers.lisp */ +#include +#include "lib/alexandria/numbers.eclh" +/* function definition for CLAMP */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1clamp(cl_object v1number, cl_object v2min, cl_object v3max) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ecl_lower(v1number,v2min))) { goto L1; } + value0 = v2min; + cl_env_copy->nvalues = 1; + return value0; +L1:; + if (!(ecl_greater(v1number,v3max))) { goto L3; } + value0 = v3max; + cl_env_copy->nvalues = 1; + return value0; +L3:; + value0 = v1number; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for GAUSSIAN-RANDOM */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4gaussian_random(cl_narg narg, ...) +{ + cl_object T0, T1; + volatile cl_object lex0[2]; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); + { + va_list args; va_start(args,narg); + { + int i = 0; + if (i >= narg) { + lex0[0] = ECL_NIL; /* MIN */ + } else { + i++; + lex0[0] = va_arg(args,cl_object); /* MIN */ + } + if (i >= narg) { + lex0[1] = ECL_NIL; /* MAX */ + } else { + i++; + lex0[1] = va_arg(args,cl_object); /* MAX */ + } + } + va_end(args); + { + cl_object v2; /* G1 */ + cl_object v3; /* G2 */ + value0 = LC2gauss(); + { + const int v4 = cl_env_copy->nvalues; + v2 = value0; + cl_object v5; + v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1]; + v3 = v5; + } + T0 = LC3guard(lex0, v2); + T1 = LC3guard(lex0, v3); + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = T1; + cl_env_copy->values[0] = T0; + return cl_env_copy->values[0]; + } + } +} +/* local function GUARD */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3guard(volatile cl_object *lex0, cl_object v1x) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = lex0[0]; + if ((value0)!=ECL_NIL) { goto L5; } + T0 = v1x; + goto L3; +L5:; + T0 = value0; + goto L3; +L3:; + value0 = lex0[1]; + if ((value0)!=ECL_NIL) { goto L9; } + T1 = v1x; + goto L7; +L9:; + T1 = value0; + goto L7; +L7:; + if ((cl_LE(3, T0, v1x, T1))!=ECL_NIL) { goto L1; } +L11:; + { + cl_object v3; /* X1 */ + cl_object v4; /* X2 */ + value0 = LC2gauss(); + { + const int v5 = cl_env_copy->nvalues; + v3 = value0; + cl_object v6; + v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1]; + v4 = v6; + } + value0 = lex0[0]; + if ((value0)!=ECL_NIL) { goto L19; } + T0 = v3; + goto L17; +L19:; + T0 = value0; + goto L17; +L17:; + value0 = lex0[1]; + if ((value0)!=ECL_NIL) { goto L23; } + T1 = v3; + goto L21; +L23:; + T1 = value0; + goto L21; +L21:; + if (Null(cl_LE(3, T0, v3, T1))) { goto L15; } + v1x = v3; + goto L12; +L15:; + value0 = lex0[0]; + if ((value0)!=ECL_NIL) { goto L31; } + T0 = v4; + goto L29; +L31:; + T0 = value0; + goto L29; +L29:; + value0 = lex0[1]; + if ((value0)!=ECL_NIL) { goto L35; } + T1 = v4; + goto L33; +L35:; + T1 = value0; + goto L33; +L33:; + if (Null(cl_LE(3, T0, v4, T1))) { goto L27; } + v1x = v4; + goto L12; +L27:; + goto L11; + } +L12:; +L1:; + value0 = v1x; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function GAUSS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2gauss() +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v1x1; + v1x1 = ECL_NIL; + { + cl_object v2x2; + v2x2 = ECL_NIL; + { + cl_object v3w; + v3w = ECL_NIL; +L4:; + T0 = cl_random(1, VV[2]); + v1x1 = ecl_minus(T0,VV[3]); + T0 = cl_random(1, VV[2]); + v2x2 = ecl_minus(T0,VV[3]); + T0 = ecl_expt(v1x1,ecl_make_fixnum(2)); + T1 = ecl_expt(v2x2,ecl_make_fixnum(2)); + v3w = ecl_plus(T0,T1); + if (!(ecl_lower(v3w,VV[3]))) { goto L11; } + { + cl_object v4v; + T0 = cl_log(1, v3w); + T1 = ecl_times(VV[4],T0); + T2 = ecl_divide(T1,v3w); + v4v = ecl_sqrt(T2); + T0 = ecl_times(v1x1,v4v); + T1 = ecl_times(v2x2,v4v); + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = T1; + cl_env_copy->values[0] = T0; + return cl_env_copy->values[0]; + } +L11:; + goto L4; + } + } + } + } +} +/* function definition for IOTA */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5iota(cl_narg narg, cl_object v1n, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2start; + cl_object v3step; + ecl_va_list args; ecl_va_start(args,v1n,narg,1); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L5iotakeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v2start = ecl_make_fixnum(0); + } else { + v2start = keyvars[0]; + { + bool v4; + v4 = ecl_numberp(v2start); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v2start); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + if (Null(keyvars[3])) { + v3step = ecl_make_fixnum(1); + } else { + v3step = keyvars[1]; + { + bool v4; + v4 = ecl_numberp(v3step); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v3step); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + } + { + cl_object v4; + v4 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L9; } + v4 = v1n; + T0 = ecl_make_bool(ecl_greatereq(v4,ecl_make_fixnum(0))); + goto L6; +L9:; + T0 = ECL_NIL; + goto L6; + } +L6:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[6],v1n); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_object v4; + cl_object v5i; + v4 = v1n; + v5i = ECL_NIL; + { + cl_object v6; + cl_object v7; + v6 = ecl_list1(ECL_NIL); + v7 = v6; + v4 = ecl_minus(v4,ecl_make_fixnum(1)); + T0 = v4; + if (!(ecl_minusp(T0))) { goto L19; } + goto L18; +L19:; + T0 = ecl_plus(v2start,v3step); + v5i = ecl_minus(T0,v3step); +L17:; + { + cl_object v8; + v8 = v7; + if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v8; + } + v7 = ecl_list1(v5i); + (ECL_CONS_CDR(T0)=v7,T0); + v4 = ecl_minus(v4,ecl_make_fixnum(1)); + T0 = v4; + if (!(ecl_minusp(T0))) { goto L30; } + goto L18; +L30:; + v5i = ecl_plus(v5i,v3step); + goto L17; +L18:; + value0 = ecl_cdr(v6); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* function definition for MAP-IOTA */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L6map_iota(cl_narg narg, cl_object v1function, cl_object v2n, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3start; + cl_object v4step; + ecl_va_list args; ecl_va_start(args,v2n,narg,2); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L6map_iotakeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v3start = ecl_make_fixnum(0); + } else { + v3start = keyvars[0]; + { + bool v5; + v5 = ecl_numberp(v3start); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v3start); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + if (Null(keyvars[3])) { + v4step = ecl_make_fixnum(1); + } else { + v4step = keyvars[1]; + { + bool v5; + v5 = ecl_numberp(v4step); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v4step); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + } + { + cl_object v5; + v5 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L9; } + v5 = v2n; + T0 = ecl_make_bool(ecl_greatereq(v5,ecl_make_fixnum(0))); + goto L6; +L9:; + T0 = ECL_NIL; + goto L6; + } +L6:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[6],v2n); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_object v5; + cl_object v6i; + v5 = v2n; + v6i = ECL_NIL; + v5 = ecl_minus(v5,ecl_make_fixnum(1)); + T0 = v5; + if (!(ecl_minusp(T0))) { goto L18; } + goto L17; +L18:; + T0 = ecl_minus(v4step,v4step); + v6i = ecl_plus(v3start,T0); +L16:; + ecl_function_dispatch(cl_env_copy,v1function)(1, v6i); + v5 = ecl_minus(v5,ecl_make_fixnum(1)); + T0 = v5; + if (!(ecl_minusp(T0))) { goto L25; } + goto L17; +L25:; + v6i = ecl_plus(v6i,v4step); + goto L16; +L17:; + } + value0 = v2n; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for LERP */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L7lerp(cl_object v1v, cl_object v2a, cl_object v3b) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = ecl_minus(v3b,v2a); + T1 = ecl_times(v1v,T0); + value0 = ecl_plus(v2a,T1); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for MEAN */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L8mean(cl_object v1sample) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = (ECL_SYM("+",16)->symbol.gfdef); + T1 = cl_reduce(2, T0, v1sample); + { + cl_fixnum v2; + v2 = ecl_length(v1sample); + value0 = ecl_divide(T1,ecl_make_fixnum(v2)); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MEDIAN */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L9median(cl_object v1sample) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2vector; + cl_fixnum v3length; + cl_object v4middle; + T0 = ecl_function_dispatch(cl_env_copy,VV[43])(2, ECL_SYM("VECTOR",900), v1sample) /* COPY-SEQUENCE */; + T1 = (ECL_SYM("<",74)->symbol.gfdef); + v2vector = cl_sort(2, T0, T1); + v3length = ecl_length(v2vector); + v4middle = ecl_truncate2(ecl_make_fixnum(v3length),ecl_make_fixnum(2)); + if (!(ecl_oddp(ecl_make_fixnum(v3length)))) { goto L5; } + { + cl_object v5; + v5 = v2vector; + T0 = v5; + { + cl_fixnum v6; + { + cl_object v7; + v7 = v4middle; + if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) + FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = ecl_fixnum(v7); + } + value0 = ecl_aref_unsafe(T0,v6); + cl_env_copy->nvalues = 1; + return value0; + } + } +L5:; + { + cl_object v7; + v7 = v2vector; + T1 = v7; + { + cl_fixnum v8; + { + cl_object v9; + v9 = v4middle; + if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = ecl_fixnum(v9); + } + T0 = ecl_aref_unsafe(T1,v8); + } + } + { + cl_object v7; + v7 = v2vector; + T2 = v7; + { + cl_fixnum v8; + { + cl_object v9; + v9 = ecl_one_minus(v4middle); + if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) + FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v8 = ecl_fixnum(v9); + } + T1 = ecl_aref_unsafe(T2,v8); + } + } + T2 = ecl_plus(T0,T1); + value0 = ecl_divide(T2,ecl_make_fixnum(2)); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for VARIANCE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L11variance(cl_narg narg, cl_object v1sample, ...) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2biased; + ecl_va_list args; ecl_va_start(args,v1sample,narg,1); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L11variancekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v2biased = ECL_T; + } else { + v2biased = keyvars[0]; + } + } + { + cl_object env1 = env0; + T1 = (ECL_SYM("+",16)->symbol.gfdef); + T2 = cl_reduce(2, T1, v1sample); + { + cl_fixnum v3; + v3 = ecl_length(v1sample); + T0 = ecl_divide(T2,ecl_make_fixnum(v3)); + } + env1 = ECL_NIL; + CLV0 = env1 = CONS(T0,env1); /* MEAN */ + { + cl_object v3; + v3 = ecl_make_cclosure_va((cl_objectfn)LC10__lambda32,env1,Cblock,2); + T0 = v3; + } + T1 = cl_reduce(4, T0, v1sample, VV[12], ecl_make_fixnum(0)); + { + cl_fixnum v3; + v3 = ecl_length(v1sample); + { + cl_fixnum v4; + if (Null(v2biased)) { goto L6; } + v4 = 0; + goto L5; +L6:; + v4 = 1; +L5:; + T2 = ecl_minus(ecl_make_fixnum(v3),ecl_make_fixnum(v4)); + value0 = ecl_divide(T1,T2); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* closure LAMBDA32 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC10__lambda32(cl_narg narg, cl_object v1a, cl_object v2b, ...) +{ + cl_object T0, T1; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* MEAN */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = ecl_minus(v2b,ECL_CONS_CAR(CLV0)); + T1 = ecl_expt(T0,ecl_make_fixnum(2)); + value0 = ecl_plus(v1a,T1); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for STANDARD-DEVIATION */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L13standard_deviation(cl_narg narg, cl_object v1sample, ...) +{ + cl_object T0, T1, T2, T3; + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2biased; + ecl_va_list args; ecl_va_start(args,v1sample,narg,1); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L13standard_deviationkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v2biased = ECL_T; + } else { + v2biased = keyvars[0]; + } + } + { + cl_object v3; + cl_object v4; + cl_object v5biased; + v3 = cl_list(2, VV[14], v2biased); + v4 = ecl_function_dispatch(cl_env_copy,VV[46])(2, v3, VV[14]) /* SEARCH-KEYWORD */; + if (!((v4)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L6; } + v5biased = ECL_T; + goto L5; +L6:; + v5biased = v4; +L5:; + ecl_function_dispatch(cl_env_copy,VV[47])(2, v3, VV[15]) /* CHECK-KEYWORD */; + { + cl_object env1 = env0; + T2 = (ECL_SYM("+",16)->symbol.gfdef); + T3 = cl_reduce(2, T2, v1sample); + { + cl_fixnum v6; + v6 = ecl_length(v1sample); + T1 = ecl_divide(T3,ecl_make_fixnum(v6)); + } + env1 = ECL_NIL; + CLV0 = env1 = CONS(T1,env1); /* MEAN */ + { + cl_object v6; + v6 = ecl_make_cclosure_va((cl_objectfn)LC12__lambda40,env1,Cblock,2); + T1 = v6; + } + T2 = cl_reduce(4, T1, v1sample, VV[12], ecl_make_fixnum(0)); + { + cl_fixnum v6; + v6 = ecl_length(v1sample); + { + cl_fixnum v7; + if (Null(v5biased)) { goto L15; } + v7 = 0; + goto L14; +L15:; + v7 = 1; +L14:; + T3 = ecl_minus(ecl_make_fixnum(v6),ecl_make_fixnum(v7)); + T0 = ecl_divide(T2,T3); + } + } + } + } + value0 = ecl_sqrt(T0); + cl_env_copy->nvalues = 1; + return value0; + } +} +/* closure LAMBDA40 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC12__lambda40(cl_narg narg, cl_object v1a, cl_object v2b, ...) +{ + cl_object T0, T1; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* MEAN */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = ecl_minus(v2b,ECL_CONS_CAR(CLV0)); + T1 = ecl_expt(T0,ecl_make_fixnum(2)); + value0 = ecl_plus(v1a,T1); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function MAXF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC15maxf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[49])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC14__lambda46,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = v3; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L11; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("MAX",553), v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[17],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L11:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L20; +L19:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L20:; + if (v12si__d==ECL_NIL) { goto L26; } + goto L19; +L26:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("MAX",553), v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[17],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA46 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC14__lambda46(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function MINF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC17minf(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[49])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v5; + } + { + cl_object v6; /* VARS */ + cl_object v7; /* VALS */ + cl_object v8; /* STORES */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + } + { + cl_object v11si__all_vars; + { + cl_object v12; + v12 = ecl_make_cfun((cl_objectfn_fixed)LC16__lambda57,ECL_NIL,Cblock,1); + T0 = v12; + } + T1 = v3; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v10))) { goto L11; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("MIN",559), v10, T1); + T3 = ecl_car(v8); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[17],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L11:; + { + cl_object v12si__d; + cl_object v13si__v; + cl_object v14si__let_list; + v12si__d = v6; + v13si__v = v7; + v14si__let_list = ECL_NIL; + goto L20; +L19:; + { + cl_object v15; + v15 = ecl_cdr(v12si__d); + { + cl_object v16; + v16 = ecl_cdr(v13si__v); + T0 = ecl_car(v12si__d); + T1 = ecl_car(v13si__v); + T2 = cl_list(2, T0, T1); + v14si__let_list = CONS(T2,v14si__let_list); + v13si__v = v16; + v12si__d = v15; + } + } +L20:; + if (v12si__d==ECL_NIL) { goto L26; } + goto L19; +L26:; + T0 = ecl_car(v8); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("MIN",559), v10, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v14si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v6); + T4 = CONS(VV[17],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + return value0; + } + } + } + } + } +} +/* local function LAMBDA57 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC16__lambda57(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* function definition for %MULTIPLY-RANGE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L21_multiply_range(cl_object v1i, cl_object v2j) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1i))) { goto L1; } + if (!(ECL_FIXNUMP(v2j))) { goto L1; } + value0 = LC18bisect(v1i, v2j); + return value0; +L1:; + value0 = LC19bisect_big(v1i, v2j); + return value0; + } +} +/* local function MULTIPLY-RANGE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC20multiply_range(cl_object v1j, cl_object v2k) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v3; + v3 = 0; + if (!(ECL_FIXNUMP(v1j))) { goto L5; } + v3 = ecl_fixnum(v1j); + if (!((v3)<=(2305843009213693951))) { goto L10; } + T0 = ecl_make_bool((v3)>=(1)); + goto L2; +L10:; + T0 = ECL_NIL; + goto L2; +L5:; + T0 = ECL_NIL; + goto L2; + } +L2:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[22],v1j); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_fixnum v3; + v3 = 0; + if (!(ECL_FIXNUMP(v2k))) { goto L16; } + v3 = ecl_fixnum(v2k); + if (!((v3)<=(2305843009213693951))) { goto L21; } + T0 = ecl_make_bool((v3)>=(1)); + goto L13; +L21:; + T0 = ECL_NIL; + goto L13; +L16:; + T0 = ECL_NIL; + goto L13; + } +L13:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[22],v2k); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_object v3; + cl_object v4f; + cl_fixnum v5m; + v3 = ecl_make_integer((ecl_to_fixnum(v2k))-1); + v4f = v2k; + { + cl_object v6; + v6 = v3; + { + cl_fixnum v7; + v7 = 0; + if (!(ECL_FIXNUMP(v6))) { goto L31; } + v7 = ecl_fixnum(v6); + if (!((v7)<(2305843009213693951))) { goto L36; } + T0 = ecl_make_bool((v7)>=(0)); + goto L28; +L36:; + T0 = ECL_NIL; + goto L28; +L31:; + T0 = ECL_NIL; + goto L28; + } +L28:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[24],v6); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5m = ecl_fixnum(v6); + } + goto L40; +L39:; + { + cl_object v6; + v6 = ecl_times(v4f,ecl_make_fixnum(v5m)); + { + cl_object v7; + v7 = ecl_make_fixnum(0); + v7 = v6; + T0 = ecl_make_bool(ecl_greatereq(v7,ecl_make_fixnum(0))); + goto L46; + T0 = ECL_NIL; + goto L46; + } +L46:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",887),v6); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v4f = v6; + } + { + cl_object v6; + v6 = ecl_make_integer((v5m)-1); + { + cl_fixnum v7; + v7 = 0; + if (!(ECL_FIXNUMP(v6))) { goto L59; } + v7 = ecl_fixnum(v6); + if (!((v7)<(2305843009213693951))) { goto L64; } + T0 = ecl_make_bool((v7)>=(0)); + goto L56; +L64:; + T0 = ECL_NIL; + goto L56; +L59:; + T0 = ECL_NIL; + goto L56; + } +L56:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[24],v6); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v5m = ecl_fixnum(v6); + } +L40:; + if ((v5m)<(ecl_to_fixnum(v1j))) { goto L66; } + goto L39; +L66:; + value0 = v4f; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function BISECT-BIG */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC19bisect_big(cl_object v1j, cl_object v2k) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + v3 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v1j)||ECL_BIGNUMP(v1j))) { goto L5; } + v3 = v1j; + T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + goto L2; +L5:; + T0 = ECL_NIL; + goto L2; + } +L2:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[23],v1j); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_object v3; + v3 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2k)||ECL_BIGNUMP(v2k))) { goto L13; } + v3 = v2k; + T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + goto L10; +L13:; + T0 = ECL_NIL; + goto L10; + } +L10:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[23],v2k); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + if (!(ecl_number_equalp(v1j,v2k))) { goto L17; } + value0 = v1j; + cl_env_copy->nvalues = 1; + return value0; +L17:; + { + cl_object v3middle; + T0 = ecl_minus(v2k,v1j); + T1 = ecl_truncate2(T0,ecl_make_fixnum(2)); + v3middle = ecl_plus(v1j,T1); + if (!(ecl_lowereq(v3middle,ecl_make_fixnum(2305843009213693951)))) { goto L21; } + T0 = LC18bisect(v1j, v3middle); + goto L20; +L21:; + T0 = LC19bisect_big(v1j, v3middle); +L20:; + T2 = ecl_plus(v3middle,ecl_make_fixnum(1)); + T1 = LC19bisect_big(T2, v2k); + value0 = ecl_times(T0,T1); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function BISECT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC18bisect(cl_object v1j, cl_object v2k) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v3; + v3 = 0; + if (!(ECL_FIXNUMP(v1j))) { goto L5; } + v3 = ecl_fixnum(v1j); + if (!((v3)<=(2305843009213693951))) { goto L10; } + T0 = ecl_make_bool((v3)>=(1)); + goto L2; +L10:; + T0 = ECL_NIL; + goto L2; +L5:; + T0 = ECL_NIL; + goto L2; + } +L2:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[22],v1j); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_fixnum v3; + v3 = 0; + if (!(ECL_FIXNUMP(v2k))) { goto L16; } + v3 = ecl_fixnum(v2k); + if (!((v3)<=(2305843009213693951))) { goto L21; } + T0 = ecl_make_bool((v3)>=(1)); + goto L13; +L21:; + T0 = ECL_NIL; + goto L13; +L16:; + T0 = ECL_NIL; + goto L13; + } +L13:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[22],v2k); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = ecl_minus(v2k,v1j); + if (!(ecl_lower(T0,ecl_make_fixnum(8)))) { goto L23; } + value0 = LC20multiply_range(v1j, v2k); + return value0; +L23:; + { + cl_object v3middle; + T0 = ecl_minus(v2k,v1j); + T1 = ecl_truncate2(T0,ecl_make_fixnum(2)); + v3middle = ecl_plus(v1j,T1); + T0 = LC18bisect(v1j, v3middle); + T2 = ecl_plus(v3middle,ecl_make_fixnum(1)); + T1 = LC18bisect(T2, v2k); + value0 = ecl_times(T0,T1); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for %FACTORIAL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L22_factorial(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ecl_lower(v1n,ecl_make_fixnum(2)))) { goto L1; } + value0 = ecl_make_fixnum(1); + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = L21_multiply_range(ecl_make_fixnum(1), v1n); + return value0; + } +} +/* function definition for FACTORIAL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L23factorial(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + v2 = v1n; + { + cl_object v3; + v3 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))) { goto L7; } + v3 = v2; + if (ecl_greatereq(v3,ecl_make_fixnum(0))) { goto L3; } + goto L4; +L7:; + goto L4; + } +L4:; + v1n = si_do_check_type(v2, VV[6], ECL_NIL, VV[27]); +L3:; + } + value0 = L22_factorial(v1n); + return value0; + } +} +/* function definition for BINOMIAL-COEFFICIENT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L24binomial_coefficient(cl_object v1n, cl_object v2k) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + v3 = v1n; + { + cl_object v4; + v4 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L7; } + v4 = v3; + if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L3; } + goto L4; +L7:; + goto L4; + } +L4:; + v1n = si_do_check_type(v3, VV[6], ECL_NIL, VV[27]); +L3:; + } + { + cl_object v3; + v3 = v2k; + { + cl_object v4; + v4 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L18; } + v4 = v3; + if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L14; } + goto L15; +L18:; + goto L15; + } +L15:; + v2k = si_do_check_type(v3, VV[6], ECL_NIL, VV[29]); +L14:; + } + goto L25; +L24:; + si_assert_failure(1, VV[30]); +L25:; + if (ecl_greatereq(v1n,v2k)) { goto L28; } + goto L24; +L28:; + if (ecl_zerop(v2k)) { goto L32; } + if (!(ecl_number_equalp(v1n,v2k))) { goto L30; } + goto L31; +L32:; +L31:; + value0 = ecl_make_fixnum(1); + cl_env_copy->nvalues = 1; + return value0; +L30:; + { + cl_object v3n_k; + v3n_k = ecl_minus(v1n,v2k); + if (!(ecl_lower(v2k,v3n_k))) { goto L35; } + { + cl_object v4; + v4 = v3n_k; + { + cl_object v5; + v5 = v2k; + v2k = v4; + v3n_k = v5; + } + } +L35:; + if (!(ecl_number_equalp(ecl_make_fixnum(1),v3n_k))) { goto L43; } + value0 = v1n; + cl_env_copy->nvalues = 1; + return value0; +L43:; + T0 = ecl_plus(v2k,ecl_make_fixnum(1)); + T1 = L21_multiply_range(T0, v1n); + T2 = L22_factorial(v3n_k); + value0 = ecl_divide(T1,T2); + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for SUBFACTORIAL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L25subfactorial(cl_object v1n) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + v2 = v1n; + { + cl_object v3; + v3 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))) { goto L7; } + v3 = v2; + if (ecl_greatereq(v3,ecl_make_fixnum(0))) { goto L3; } + goto L4; +L7:; + goto L4; + } +L4:; + v1n = si_do_check_type(v2, VV[6], ECL_NIL, VV[27]); +L3:; + } + if (!(ecl_zerop(v1n))) { goto L12; } + value0 = ecl_make_fixnum(1); + cl_env_copy->nvalues = 1; + return value0; +L12:; + { + cl_object v2x; + cl_object v3a; + cl_object v4b; + v2x = ecl_make_fixnum(1); + v3a = ecl_make_fixnum(0); + v4b = ecl_make_fixnum(1); + goto L19; +L18:; + { + cl_object v5; + v5 = ecl_one_plus(v2x); + { + cl_object v6; + T0 = ecl_plus(v3a,v4b); + v6 = ecl_times(v2x,T0); + v4b = v3a; + v3a = v6; + v2x = v5; + } + } +L19:; + if (ecl_number_equalp(v1n,v2x)) { goto L25; } + goto L18; +L25:; + value0 = v3a; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for COUNT-PERMUTATIONS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L26count_permutations(cl_narg narg, cl_object v1n, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); + { + cl_object v2k; + va_list args; va_start(args,v1n); + { + int i = 1; + if (i >= narg) { + v2k = v1n; + } else { + i++; + v2k = va_arg(args,cl_object); + } + } + va_end(args); + { + cl_object v3; + v3 = v1n; + { + cl_object v4; + v4 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L8; } + v4 = v3; + if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L4; } + goto L5; +L8:; + goto L5; + } +L5:; + v1n = si_do_check_type(v3, VV[6], ECL_NIL, VV[27]); +L4:; + } + { + cl_object v3; + v3 = v2k; + { + cl_object v4; + v4 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L19; } + v4 = v3; + if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L15; } + goto L16; +L19:; + goto L16; + } +L16:; + v2k = si_do_check_type(v3, VV[6], ECL_NIL, VV[29]); +L15:; + } + goto L26; +L25:; + si_assert_failure(1, VV[30]); +L26:; + if (ecl_greatereq(v1n,v2k)) { goto L29; } + goto L25; +L29:; + T0 = ecl_minus(v1n,v2k); + T1 = ecl_one_plus(T0); + value0 = L21_multiply_range(T1, v1n); + return value0; + } +} + +#include "lib/alexandria/numbers.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclGV3xc4hVq7NJM_aLIycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/numbers.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclGV3xc4hVq7NJM_aLIycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[33]); /* CLAMP */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[6]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[7], VVtemp[8]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; + ecl_cmp_defun(VV[35]); /* GAUSSIAN-RANDOM */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[10]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[11]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defun(VV[36]); /* IOTA */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[5], ECL_SYM("INLINE",436), VVtemp[16]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[17]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defun(VV[39]); /* MAP-IOTA */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[7], ECL_SYM("FUNCTION",398), VVtemp[21]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[7], ECL_SYM("INLINE",436), VVtemp[22]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[23]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defun(VV[40]); /* LERP */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[27]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[8], ECL_SYM("INLINE",436), VVtemp[28]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[29]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[30], VVtemp[31]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; + ecl_cmp_defun(VV[41]); /* MEAN */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[9], ECL_SYM("FUNCTION",398), VVtemp[33]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[9], ECL_SYM("INLINE",436), VVtemp[34]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[35]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[36], VVtemp[37]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; + ecl_cmp_defun(VV[42]); /* MEDIAN */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[10], ECL_SYM("FUNCTION",398), VVtemp[38]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[10], ECL_SYM("INLINE",436), VVtemp[39]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[40]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* VARIANCE */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[11], ECL_SYM("FUNCTION",398), VVtemp[44]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[11], ECL_SYM("INLINE",436), VVtemp[45]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[46]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[47], VVtemp[48]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[45]); /* STANDARD-DEVIATION */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[49]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[13], ECL_SYM("INLINE",436), VVtemp[50]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[51], VVtemp[52]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[53]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[48]); /* MAXF */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[54]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LOCATION",1862), VVtemp[55], VVtemp[56]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[53]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[50]); /* MINF */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[18], ECL_SYM("FUNCTION",398), VVtemp[57]) /* SET-DOCUMENTATION */; + si_Xmake_constant(VV[19], ecl_make_fixnum(8)); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[19], ECL_SYM("LOCATION",1862), VVtemp[58], VVtemp[59]) /* ANNOTATE */; + si_Xmake_constant(VV[20], ecl_make_fixnum(13)); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LOCATION",1862), VVtemp[62], VVtemp[63]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[64]) /* ANNOTATE */; + ecl_cmp_defun(VV[51]); /* %MULTIPLY-RANGE */ + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[65]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[66], VVtemp[67]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[68]) /* ANNOTATE */; + ecl_cmp_defun(VV[52]); /* %FACTORIAL */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[69], VVtemp[70]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[68]) /* ANNOTATE */; + ecl_cmp_defun(VV[53]); /* FACTORIAL */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[26], ECL_SYM("FUNCTION",398), VVtemp[71]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[26], ECL_SYM("INLINE",436), VVtemp[72]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[73], VVtemp[74]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[75]) /* ANNOTATE */; + ecl_cmp_defun(VV[54]); /* BINOMIAL-COEFFICIENT */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[76]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LOCATION",1862), VVtemp[77], VVtemp[78]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[68]) /* ANNOTATE */; + ecl_cmp_defun(VV[55]); /* SUBFACTORIAL */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[31], ECL_SYM("FUNCTION",398), VVtemp[79]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LOCATION",1862), VVtemp[80], VVtemp[81]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[82]) /* ANNOTATE */; + ecl_cmp_defun(VV[56]); /* COUNT-PERMUTATIONS */ + ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[32], ECL_SYM("FUNCTION",398), VVtemp[83]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/package.cxx b/lib/alexandria/package.cxx new file mode 100644 index 0000000..095f252 --- /dev/null +++ b/lib/alexandria/package.cxx @@ -0,0 +1,36 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/package.lisp */ +#include +#include "lib/alexandria/package.eclh" + +#include "lib/alexandria/package.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclFO5a0GhkppGJM_GREycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/package.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclFO5a0GhkppGJM_GREycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + ecl_function_dispatch(cl_env_copy,VV[0])(12, VVtemp[0], VVtemp[1], ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; +} diff --git a/lib/alexandria/sequences.cxx b/lib/alexandria/sequences.cxx new file mode 100644 index 0000000..88b53e9 --- /dev/null +++ b/lib/alexandria/sequences.cxx @@ -0,0 +1,2721 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/sequences.lisp */ +#include +#include "lib/alexandria/sequences.eclh" +/* function definition for SEQUENCE-OF-LENGTH-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1sequence_of_length_p(cl_object v1sequence, cl_object v2length) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_fixnum v3; + v3 = 0; + if (!(ECL_FIXNUMP(v2length))) { goto L5; } + v3 = ecl_fixnum(v2length); + if (!((v3)<(2305843009213693950))) { goto L10; } + T0 = ecl_make_bool((v3)>=(0)); + goto L2; +L10:; + T0 = ECL_NIL; + goto L2; +L5:; + T0 = ECL_NIL; + goto L2; + } +L2:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[1],v2length); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + if (!(v1sequence==ECL_NIL)) { goto L12; } + value0 = ecl_make_bool((ecl_to_fixnum(v2length))==0); + cl_env_copy->nvalues = 1; + return value0; +L12:; + if (!(ECL_CONSP(v1sequence))) { goto L14; } + { + cl_object v3n; + v3n = ecl_make_integer((ecl_to_fixnum(v2length))-1); + if (ecl_minusp(v3n)) { goto L17; } + { + cl_object v4tail; + v4tail = ecl_nthcdr(ecl_to_size(v3n),v1sequence); + if (Null(v4tail)) { goto L21; } + T0 = ecl_cdr(v4tail); + value0 = ecl_make_bool(T0==ECL_NIL); + cl_env_copy->nvalues = 1; + return value0; +L21:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L17:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L14:; + if (!(ECL_VECTORP(v1sequence))) { goto L23; } + { + cl_fixnum v5; + v5 = ecl_length(v1sequence); + value0 = ecl_make_bool((ecl_to_fixnum(v2length))==(v5)); + cl_env_copy->nvalues = 1; + return value0; + } +L23:; + if (ECL_CONSP(v1sequence)) { goto L27; } + if (v1sequence==ECL_NIL) { goto L27; } + if (!(ECL_VECTORP(v1sequence))) { goto L25; } + goto L26; +L27:; +L26:; + { + cl_fixnum v6; + v6 = ecl_length(v1sequence); + value0 = ecl_make_bool((ecl_to_fixnum(v2length))==(v6)); + cl_env_copy->nvalues = 1; + return value0; + } +L25:; + value0 = si_etypecase_error(v1sequence, VV[2]); + return value0; + } +} +/* function definition for ROTATE-TAIL-TO-HEAD */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L2rotate_tail_to_head(cl_object v1sequence, cl_object v2n) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + v3 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L5; } + v3 = v2n; + T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + goto L2; +L5:; + T0 = ECL_NIL; + goto L2; + } +L2:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[4],v2n); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + if (!(ECL_LISTP(v1sequence))) { goto L9; } + { + cl_object v3m; + T0 = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; + v3m = (ecl_floor2(v2n,T0),cl_env_copy->values[1]); + T0 = ecl_cdr(v1sequence); + if (!(T0==ECL_NIL)) { goto L12; } + value0 = v1sequence; + cl_env_copy->nvalues = 1; + return value0; +L12:; + { + cl_object v4tail; + cl_object v5last; + T0 = ecl_plus(v3m,ecl_make_fixnum(1)); + v4tail = cl_last(2, v1sequence, T0); + v5last = ecl_cdr(v4tail); + { + cl_object v6; + v6 = ECL_NIL; + { + cl_object v7; + v7 = v4tail; + if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v7; + } + (ECL_CONS_CDR(T0)=v6,T0); + } + value0 = ecl_nconc(v5last,v1sequence); + cl_env_copy->nvalues = 1; + return value0; + } + } +L9:; + { + cl_fixnum v6len; + cl_object v7m; + cl_object v8tail; + v6len = ecl_length(v1sequence); + v7m = (ecl_floor2(v2n,ecl_make_fixnum(v6len)),cl_env_copy->values[1]); + T0 = ecl_minus(ecl_make_fixnum(v6len),v7m); + v8tail = cl_subseq(2, v1sequence, T0); + cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1345), v7m, ECL_SYM("START2",1346), ecl_make_fixnum(0)); + cl_replace(2, v1sequence, v8tail); + value0 = v1sequence; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ROTATE-HEAD-TO-TAIL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L3rotate_head_to_tail(cl_object v1sequence, cl_object v2n) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + v3 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L5; } + v3 = v2n; + T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + goto L2; +L5:; + T0 = ECL_NIL; + goto L2; + } +L2:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[4],v2n); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + if (!(ECL_LISTP(v1sequence))) { goto L9; } + { + cl_object v3m; + T0 = ecl_one_minus(v2n); + T1 = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; + v3m = (ecl_floor2(T0,T1),cl_env_copy->values[1]); + T0 = ecl_cdr(v1sequence); + if (!(T0==ECL_NIL)) { goto L12; } + value0 = v1sequence; + cl_env_copy->nvalues = 1; + return value0; +L12:; + { + cl_object v4headtail; + cl_object v5tail; + v4headtail = ecl_nthcdr(ecl_to_size(v3m),v1sequence); + v5tail = ecl_cdr(v4headtail); + { + cl_object v6; + v6 = ECL_NIL; + { + cl_object v7; + v7 = v4headtail; + if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v7; + } + (ECL_CONS_CDR(T0)=v6,T0); + } + value0 = ecl_nconc(v5tail,v1sequence); + cl_env_copy->nvalues = 1; + return value0; + } + } +L9:; + { + cl_fixnum v6len; + cl_object v7m; + cl_object v8head; + v6len = ecl_length(v1sequence); + v7m = (ecl_floor2(v2n,ecl_make_fixnum(v6len)),cl_env_copy->values[1]); + v8head = cl_subseq(3, v1sequence, ecl_make_fixnum(0), v7m); + cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1345), ecl_make_fixnum(0), ECL_SYM("START2",1346), v7m); + T0 = ecl_minus(ecl_make_fixnum(v6len),v7m); + cl_replace(4, v1sequence, v8head, ECL_SYM("START1",1345), T0); + value0 = v1sequence; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for ROTATE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4rotate(cl_narg narg, cl_object v1sequence, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); + { + cl_object v2n; + va_list args; va_start(args,v1sequence); + { + int i = 1; + if (i >= narg) { + v2n = ecl_make_fixnum(1); + } else { + i++; + v2n = va_arg(args,cl_object); + } + } + va_end(args); + if (!(ecl_plusp(v2n))) { goto L2; } + value0 = L2rotate_tail_to_head(v1sequence, v2n); + return value0; +L2:; + if (!(ecl_minusp(v2n))) { goto L4; } + T0 = ecl_negate(v2n); + value0 = L3rotate_head_to_tail(v1sequence, T0); + return value0; +L4:; + value0 = v1sequence; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for SHUFFLE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5shuffle(cl_narg narg, cl_object v1sequence, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2start; + cl_object v3end; + ecl_va_list args; ecl_va_start(args,v1sequence,narg,1); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L5shufflekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v2start = ecl_make_fixnum(0); + } else { + v2start = keyvars[0]; + { + bool v4; + v4 = ECL_FIXNUMP(v2start); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("FIXNUM",374),v2start); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + v3end = keyvars[1]; + } + if (!(ECL_LISTP(v1sequence))) { goto L4; } + { + cl_object v4end; + cl_object v5n; + value0 = v3end; + if ((value0)!=ECL_NIL) { goto L8; } + v4end = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; + goto L6; +L8:; + v4end = value0; + goto L6; +L6:; + v5n = ecl_minus(v4end,v2start); + { + cl_object v6tail; + v6tail = ecl_nthcdr(ecl_to_fixnum(v2start),v1sequence); + goto L14; +L13:; + { + cl_object v7; + T0 = cl_random(1, v5n); + v7 = ecl_nthcdr(ecl_to_size(T0),v6tail); + { + cl_object v8; + v8 = ecl_car(v7); + { + cl_object v9; + v9 = ecl_car(v6tail); + { + cl_object v10; + v10 = v6tail; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v10; + } + (ECL_CONS_CAR(T0)=v8,T0); + { + cl_object v10; + v10 = v7; + if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v10; + } + (ECL_CONS_CAR(T0)=v9,T0); + } + } + } + v5n = ecl_minus(v5n,ecl_make_fixnum(1)); + v6tail = ecl_cdr(v6tail); +L14:; + if (ecl_zerop(v5n)) { goto L34; } + goto L13; +L34:; + goto L3; + } + } +L4:; + if (!(ECL_VECTORP(v1sequence))) { goto L36; } + { + cl_object v7end; + value0 = v3end; + if ((value0)!=ECL_NIL) { goto L40; } + v7end = ecl_make_fixnum(ecl_length(v1sequence)); + goto L38; +L40:; + v7end = value0; + goto L38; +L38:; + { + cl_object v8i; + cl_object v9; + v8i = v2start; + { + cl_object v10; + v10 = v7end; + { + bool v11; + v11 = ecl_numberp(v10); + if (ecl_unlikely(!(v11))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v9 = v10; + } +L46:; + if (!(ecl_greatereq(v8i,v9))) { goto L48; } + goto L47; +L48:; + { + cl_object v10; + T0 = ecl_minus(v7end,v8i); + T1 = cl_random(1, T0); + v10 = ecl_plus(v8i,T1); + { + cl_object v11; + { + cl_object v12; + v12 = v1sequence; + T0 = v12; + { + cl_fixnum v13; + { + cl_object v14; + v14 = v10; + if (ecl_unlikely((ecl_fixnum(v14))>=(v12)->vector.dim)) + FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v14)),(v12)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v13 = ecl_fixnum(v14); + } + v11 = ecl_aref_unsafe(T0,v13); + } + } + { + cl_object v12; + { + cl_object v13; + v13 = v1sequence; + T0 = v13; + { + cl_fixnum v14; + { + cl_object v15; + v15 = v8i; + if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) + FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v14 = ecl_fixnum(v15); + } + v12 = ecl_aref_unsafe(T0,v14); + } + } + { + cl_object v13; + v13 = v1sequence; + T0 = v13; + { + cl_fixnum v14; + { + cl_object v15; + v15 = v8i; + if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) + FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v14 = ecl_fixnum(v15); + } + ecl_aset_unsafe(T0,v14,v11); + } + } + { + cl_object v13; + v13 = v1sequence; + T0 = v13; + { + cl_fixnum v14; + { + cl_object v15; + v15 = v10; + if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) + FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v14 = ecl_fixnum(v15); + } + ecl_aset_unsafe(T0,v14,v12); + } + } + } + } + } + v8i = ecl_one_plus(v8i); + goto L46; +L47:; + goto L3; + } + } +L36:; + if (ECL_CONSP(v1sequence)) { goto L81; } + if (v1sequence==ECL_NIL) { goto L81; } + if (!(ECL_VECTORP(v1sequence))) { goto L79; } + goto L80; +L81:; +L80:; + { + cl_object v10end; + value0 = v3end; + if ((value0)!=ECL_NIL) { goto L86; } + v10end = ecl_make_fixnum(ecl_length(v1sequence)); + goto L84; +L86:; + v10end = value0; + goto L84; +L84:; + { + cl_object v11; + cl_object v12i; + v11 = ecl_minus(v10end,ecl_make_fixnum(1)); + v12i = v11; +L90:; + if (!(ecl_lower(v12i,v2start))) { goto L92; } + goto L91; +L92:; + { + cl_object v13; + T0 = ecl_minus(v10end,v12i); + T1 = cl_random(1, T0); + v13 = ecl_plus(v12i,T1); + { + cl_object v14; + v14 = ecl_elt(v1sequence,ecl_to_size(v13)); + { + cl_object v15; + v15 = ecl_elt(v1sequence,ecl_to_size(v12i)); + ecl_elt_set(v1sequence,ecl_to_size(v12i),v14); + ecl_elt_set(v1sequence,ecl_to_size(v13),v15); + } + } + } + v12i = ecl_one_minus(v12i); + goto L90; +L91:; + goto L3; + } + } +L79:; + si_etypecase_error(v1sequence, VV[8]); +L3:; + value0 = v1sequence; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for RANDOM-ELT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L6random_elt(cl_narg narg, cl_object v1sequence, ...) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + { + cl_object v2start; + cl_object v3end; + ecl_va_list args; ecl_va_start(args,v1sequence,narg,1); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L6random_eltkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v2start = ecl_make_fixnum(0); + } else { + v2start = keyvars[0]; + { + bool v4; + v4 = ECL_FIXNUMP(v2start); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("FIXNUM",374),v2start); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + v3end = keyvars[1]; + } + if (ecl_unlikely(!(ECL_LISTP(v1sequence) || ECL_VECTORP(v1sequence)))) + FEtype_error_sequence(v1sequence); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + { + cl_object v4size; + cl_object v5end2; + if (!(ECL_LISTP(v1sequence))) { goto L5; } + v4size = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; + goto L4; +L5:; + v4size = ecl_make_fixnum(ecl_length(v1sequence)); +L4:; + value0 = v3end; + if ((value0)!=ECL_NIL) { goto L9; } + v5end2 = v4size; + goto L7; +L9:; + v5end2 = value0; + goto L7; +L7:; + if (!(ecl_zerop(v4size))) { goto L11; } + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[11]); + return value0; +L11:; + if (!((0)<=(ecl_to_fixnum(v2start)))) { goto L16; } + if (!(ecl_lower(v2start,v5end2))) { goto L16; } + if (ecl_lowereq(v5end2,v4size)) { goto L13; } + goto L14; +L16:; + goto L14; +L14:; + T0 = CONS(v2start,v3end); + T1 = ecl_list1(v5end2); + T2 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), T1); + T3 = ecl_list1(v2start); + T4 = cl_list(3, ECL_SYM("INTEGER",439), T3, v4size); + T5 = cl_list(3, ECL_SYM("OR",616), ECL_SYM("NULL",607), T4); + T6 = cl_list(3, ECL_SYM("CONS",253), T2, T5); + T7 = cl_list(3, v2start, v3end, v4size); + value0 = cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",775), ECL_SYM("DATUM",1242), T0, ECL_SYM("EXPECTED-TYPE",1260), T6, ECL_SYM("FORMAT-CONTROL",1269), VV[12], ECL_SYM("FORMAT-ARGUMENTS",1268), T7); + return value0; +L13:; + { + cl_object v6index; + T0 = ecl_minus(v5end2,v2start); + T1 = cl_random(1, T0); + v6index = ecl_plus(v2start,T1); + value0 = ecl_elt(v1sequence,ecl_to_size(v6index)); + cl_env_copy->nvalues = 1; + return value0; + } + } + } +} +/* function definition for REMOVE/SWAPPED-ARGUMENTS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L7remove_swapped_arguments(cl_narg narg, cl_object v1sequence, cl_object v2item, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3keyword_arguments; + ecl_va_list args; ecl_va_start(args,v2item,narg,2); + v3keyword_arguments = cl_grab_rest_args(args); + ecl_va_end(args); + T0 = (ECL_SYM("REMOVE",712)->symbol.gfdef); + value0 = cl_apply(4, T0, v2item, v1sequence, v3keyword_arguments); + return value0; + } +} +/* local function REMOVEF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC9removef(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + cl_object v5item; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5item = v6; + } + { + cl_object v7; /* VARS */ + cl_object v8; /* VALS */ + cl_object v9; /* STORES */ + cl_object v10; /* SETTER */ + cl_object v11; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; + } + { + cl_object v12si__all_vars; + { + cl_object v13; + v13 = ecl_make_cfun((cl_objectfn_fixed)LC8__lambda59,ECL_NIL,Cblock,1); + T0 = v13; + } + T1 = CONS(v5item,v3); + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v11))) { goto L17; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[13], v11, T1); + T3 = ecl_car(v9); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[15],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L17:; + { + cl_object v13si__d; + cl_object v14si__v; + cl_object v15si__let_list; + v13si__d = v7; + v14si__v = v8; + v15si__let_list = ECL_NIL; + goto L26; +L25:; + { + cl_object v16; + v16 = ecl_cdr(v13si__d); + { + cl_object v17; + v17 = ecl_cdr(v14si__v); + T0 = ecl_car(v13si__d); + T1 = ecl_car(v14si__v); + T2 = cl_list(2, T0, T1); + v15si__let_list = CONS(T2,v15si__let_list); + v14si__v = v17; + v13si__d = v16; + } + } +L26:; + if (v13si__d==ECL_NIL) { goto L32; } + goto L25; +L32:; + T0 = ecl_car(v9); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, VV[13], v11, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v15si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v7); + T4 = CONS(VV[15],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + return value0; + } + } + } + } + } +} +/* local function LAMBDA59 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC8__lambda59(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* function definition for DELETE/SWAPPED-ARGUMENTS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L10delete_swapped_arguments(cl_narg narg, cl_object v1sequence, cl_object v2item, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3keyword_arguments; + ecl_va_list args; ecl_va_start(args,v2item,narg,2); + v3keyword_arguments = cl_grab_rest_args(args); + ecl_va_end(args); + T0 = (ECL_SYM("DELETE",293)->symbol.gfdef); + value0 = cl_apply(4, T0, v2item, v1sequence, v3keyword_arguments); + return value0; + } +} +/* local function DELETEF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC12deletef(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + cl_object v5item; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5item = v6; + } + { + cl_object v7; /* VARS */ + cl_object v8; /* VALS */ + cl_object v9; /* STORES */ + cl_object v10; /* SETTER */ + cl_object v11; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; + } + { + cl_object v12si__all_vars; + { + cl_object v13; + v13 = ecl_make_cfun((cl_objectfn_fixed)LC11__lambda71,ECL_NIL,Cblock,1); + T0 = v13; + } + T1 = CONS(v5item,v3); + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v11))) { goto L17; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[16], v11, T1); + T3 = ecl_car(v9); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[15],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L17:; + { + cl_object v13si__d; + cl_object v14si__v; + cl_object v15si__let_list; + v13si__d = v7; + v14si__v = v8; + v15si__let_list = ECL_NIL; + goto L26; +L25:; + { + cl_object v16; + v16 = ecl_cdr(v13si__d); + { + cl_object v17; + v17 = ecl_cdr(v14si__v); + T0 = ecl_car(v13si__d); + T1 = ecl_car(v14si__v); + T2 = cl_list(2, T0, T1); + v15si__let_list = CONS(T2,v15si__let_list); + v14si__v = v17; + v13si__d = v16; + } + } +L26:; + if (v13si__d==ECL_NIL) { goto L32; } + goto L25; +L32:; + T0 = ecl_car(v9); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, VV[16], v11, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v15si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v7); + T4 = CONS(VV[15],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + return value0; + } + } + } + } + } +} +/* local function LAMBDA71 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC11__lambda71(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} +/* local function LAMBDA79 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC13__lambda79(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = VV[19]; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for EMPTYP */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L14emptyp(cl_object v1sequence) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LISTP(v1sequence))) { goto L1; } + value0 = ecl_make_bool(v1sequence==ECL_NIL); + cl_env_copy->nvalues = 1; + return value0; +L1:; + if (ECL_CONSP(v1sequence)) { goto L5; } + if (v1sequence==ECL_NIL) { goto L5; } + if (!(ECL_VECTORP(v1sequence))) { goto L3; } + goto L4; +L5:; +L4:; + { + cl_fixnum v2; + v2 = ecl_length(v1sequence); + value0 = ecl_make_bool((v2)==0); + cl_env_copy->nvalues = 1; + return value0; + } +L3:; + value0 = si_etypecase_error(v1sequence, VV[21]); + return value0; + } +} +/* function definition for LENGTH= */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L15length_(cl_narg narg, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + cl_object v1sequences; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1sequences = cl_grab_rest_args(args); + ecl_va_end(args); + if ((ecl_cdr(v1sequences))!=ECL_NIL) { goto L1; } + cl_error(1, VV[23]); +L1:; + { + cl_object v2first; + cl_fixnum v3current; + { + cl_object v4; + v4 = v1sequences; + { + cl_object v5; + v5 = v4; + { + bool v6; + v6 = ECL_LISTP(v5); + if (ecl_unlikely(!(v6))) + FEwrong_type_argument(VV[24],v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + } + if (Null(v4)) { goto L9; } + { + cl_object v5; + v5 = ECL_CONS_CDR(v4); + v1sequences = v5; + v4 = ECL_CONS_CAR(v4); + } +L9:; + v2first = v4; + } + { + cl_object v4; + if (!(ECL_FIXNUMP(v2first)||ECL_BIGNUMP(v2first))) { goto L17; } + v4 = v2first; + goto L16; +L17:; + v4 = ecl_make_fixnum(ecl_length(v2first)); +L16:; + { + cl_fixnum v5; + v5 = 0; + if (!(ECL_FIXNUMP(v4))) { goto L23; } + v5 = ecl_fixnum(v4); + if (!((v5)<(2305843009213693950))) { goto L28; } + T0 = ecl_make_bool((v5)>=(0)); + goto L20; +L28:; + T0 = ECL_NIL; + goto L20; +L23:; + T0 = ECL_NIL; + goto L20; + } +L20:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[1],v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v3current = ecl_fixnum(v4); + } + { + cl_object v4; + v4 = v1sequences; + goto L33; +L32:; + { + cl_object v5el; + v5el = ecl_car(v4); + if (!(ECL_FIXNUMP(v5el)||ECL_BIGNUMP(v5el))) { goto L38; } + if (ecl_number_equalp(v5el,ecl_make_fixnum(v3current))) { goto L37; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L38:; + { + cl_fixnum v6length; + v6length = v3current; + if (!(v5el==ECL_NIL)) { goto L43; } + if ((v6length)==0) { goto L37; } + goto L41; +L43:; + if (!(ECL_CONSP(v5el))) { goto L45; } + { + cl_object v7n; + v7n = ecl_make_integer((v6length)-1); + if (ecl_minusp(v7n)) { goto L48; } + { + cl_object v8tail; + v8tail = ecl_nthcdr(ecl_to_size(v7n),v5el); + if (Null(v8tail)) { goto L52; } + T0 = ecl_cdr(v8tail); + if (T0==ECL_NIL) { goto L37; } + goto L41; +L52:; + goto L41; + } +L48:; + goto L41; + } +L45:; + if (!(ECL_VECTORP(v5el))) { goto L54; } + { + cl_fixnum v9; + v9 = ecl_length(v5el); + if ((v6length)==(v9)) { goto L37; } + goto L41; + } +L54:; + if (ECL_CONSP(v5el)) { goto L58; } + if (v5el==ECL_NIL) { goto L58; } + if (!(ECL_VECTORP(v5el))) { goto L56; } + goto L57; +L58:; +L57:; + { + cl_fixnum v10; + v10 = ecl_length(v5el); + if ((v6length)==(v10)) { goto L37; } + goto L41; + } +L56:; + if ((si_etypecase_error(v5el, VV[2]))!=ECL_NIL) { goto L37; } + } +L41:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L37:; + } + v4 = ecl_cdr(v4); +L33:; + if (Null(v4)) { goto L63; } + goto L32; +L63:; + } + } + value0 = ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA104 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC16__lambda104(cl_object v1, cl_object v2) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4length; + T0 = ecl_car(v1); + if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + T0 = ecl_caadr(v1); + if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + v3 = ecl_cddr(v1); + goto L1; +L2:; + v3 = ecl_cdr(v1); +L1:; + if (!(v3==ECL_NIL)) { goto L6; } + ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L6:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4length = v5; + } + { + cl_fixnum v5; + v5 = ecl_length(v3); + if (!((v5)==0)) { goto L11; } + } + value0 = v1; + cl_env_copy->nvalues = 1; + return value0; +L11:; + { + cl_object v5optimizedp; + v5optimizedp = ecl_make_bool(ECL_FIXNUMP(v4length)||ECL_BIGNUMP(v4length)); + { + cl_object v6; + cl_object v7; + v6 = cl_gensym(1, VV[25]); + v7 = cl_gensym(1, VV[26]); + T0 = ecl_list1(v6); + if ((v5optimizedp)!=ECL_NIL) { goto L17; } + T2 = cl_list(2, v7, v4length); + T1 = ecl_list1(T2); + goto L16; +L17:; + T1 = ECL_NIL; +L16:; + T2 = CONS(T0,T1); + if ((v5optimizedp)!=ECL_NIL) { goto L20; } + T4 = cl_list(2, ECL_SYM("INTEGERP",442), v7); + T5 = cl_list(2, ECL_SYM("LENGTH",478), v7); + T6 = cl_list(3, ECL_SYM("SETF",752), v7, T5); + T7 = cl_list(3, ECL_SYM("UNLESS",885), T4, T6); + T3 = ecl_list1(T7); + goto L19; +L20:; + T3 = ECL_NIL; +L19:; + { + cl_object v8sequence; + cl_object v9; + v8sequence = ECL_NIL; + { + cl_object v10; + v10 = v3; + if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v10; + } + { + cl_object v10; + cl_object v11; + v10 = ecl_list1(ECL_NIL); + v11 = v10; +L29:; + if (!(ecl_endp(v9))) { goto L31; } + goto L30; +L31:; + v8sequence = ECL_CONS_CAR(v9); + { + cl_object v12; + v12 = ECL_CONS_CDR(v9); + if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v9 = v12; + } + { + cl_object v12; + v12 = v11; + if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T5 = v12; + } + T6 = cl_list(3, ECL_SYM("SETF",752), v6, v8sequence); + T7 = cl_list(2, ECL_SYM("INTEGERP",442), v6); + if (Null(v5optimizedp)) { goto L45; } + T8 = v4length; + goto L44; +L45:; + T8 = v7; +L44:; + T9 = cl_list(3, ECL_SYM("=",76), v6, T8); + if (Null(v5optimizedp)) { goto L48; } + T10 = v4length; + goto L47; +L48:; + T10 = v7; +L47:; + T11 = cl_list(3, VV[0], v6, T10); + T12 = cl_list(4, ECL_SYM("IF",948), T7, T9, T11); + T13 = cl_list(3, ECL_SYM("PROGN",673), T6, T12); + v11 = ecl_list1(T13); + (ECL_CONS_CDR(T5)=v11,T5); + goto L29; +L30:; + T4 = ecl_cdr(v10); + goto L22; + } + } +L22:; + T5 = CONS(ECL_SYM("AND",89),T4); + T6 = ecl_list1(T5); + T7 = ecl_append(T3,T6); + T8 = cl_listX(3, ECL_SYM("LET",479), T2, T7); + value0 = cl_list(3, ECL_SYM("LOCALLY",492), VV[27], T8); + return value0; + } + } + } + } +} +/* function definition for COPY-SEQUENCE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L17copy_sequence(cl_object v1type, cl_object v2sequence) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_typep(2, v2sequence, v1type))) { goto L1; } + value0 = ecl_copy_seq(v2sequence); + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = cl_coerce(v2sequence, v1type); + return value0; + } +} +/* function definition for FIRST-ELT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L18first_elt(cl_object v1sequence) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_CONSP(v1sequence))) { goto L1; } + value0 = ecl_car(v1sequence); + cl_env_copy->nvalues = 1; + return value0; +L1:; + if (!(ECL_VECTORP(v1sequence))) { goto L3; } + { + cl_fixnum v2; + v2 = ecl_length(v1sequence); + if (!((v2)>0)) { goto L3; } + } + value0 = ecl_elt(v1sequence,0); + cl_env_copy->nvalues = 1; + return value0; +L3:; + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[11]); + return value0; + } +} +/* function definition for (SETF FIRST-ELT) */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L19_setf_first_elt_(cl_object v1object, cl_object v2sequence) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_CONSP(v2sequence))) { goto L1; } + { + cl_object v3; + v3 = v1object; + { + cl_object v4; + v4 = v2sequence; + if (ecl_unlikely(ECL_ATOM(v4))) FEtype_error_cons(v4); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v4; + } + (ECL_CONS_CAR(T0)=v3,T0); + value0 = v3; + cl_env_copy->nvalues = 1; + return value0; + } +L1:; + if (!(ECL_VECTORP(v2sequence))) { goto L8; } + { + cl_fixnum v4; + v4 = ecl_length(v2sequence); + if (!((v4)>0)) { goto L8; } + } + value0 = ecl_elt_set(v2sequence,0,v1object); + cl_env_copy->nvalues = 1; + return value0; +L8:; + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v2sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[11]); + return value0; + } +} +/* function definition for LAST-ELT */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L20last_elt(cl_object v1sequence) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2len; + v2len = ecl_make_fixnum(0); + if (!(ECL_CONSP(v1sequence))) { goto L2; } + value0 = ecl_function_dispatch(cl_env_copy,VV[69])(1, v1sequence) /* LASTCAR */; + return value0; +L2:; + if (!(ECL_VECTORP(v1sequence))) { goto L4; } + v2len = ecl_make_fixnum(ecl_length(v1sequence)); + if (!((ecl_to_fixnum(v2len))>0)) { goto L4; } + T0 = ecl_one_minus(v2len); + value0 = ecl_elt(v1sequence,ecl_to_size(T0)); + cl_env_copy->nvalues = 1; + return value0; +L4:; + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[32]); + return value0; + } + } +} +/* function definition for (SETF LAST-ELT) */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L21_setf_last_elt_(cl_object v1object, cl_object v2sequence) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3len; + v3len = ecl_make_fixnum(0); + if (!(ECL_CONSP(v2sequence))) { goto L2; } + value0 = (cl_env_copy->function=ecl_fdefinition(VV[71]))->cfun.entry(2, v1object, v2sequence) /* (SETF LASTCAR) */; + return value0; +L2:; + if (!(ECL_VECTORP(v2sequence))) { goto L4; } + v3len = ecl_make_fixnum(ecl_length(v2sequence)); + if (!((ecl_to_fixnum(v3len))>0)) { goto L4; } + T0 = ecl_one_minus(v3len); + value0 = ecl_elt_set(v2sequence,ecl_to_size(T0),v1object); + cl_env_copy->nvalues = 1; + return value0; +L4:; + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v2sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[32]); + return value0; + } + } +} +/* function definition for STARTS-WITH-SUBSEQ */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L22starts_with_subseq(cl_narg narg, cl_object v1prefix, cl_object v2sequence, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3args; + cl_object v4return_suffix; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L22starts_with_subseqkeys,keyvars,(cl_object*)&v3args,TRUE); + ecl_va_end(args); + v4return_suffix = keyvars[0]; + } + v3args = ecl_function_dispatch(cl_env_copy,VV[73])(2, v3args, VV[35]) /* REMOVE-FROM-PLIST */; + { + cl_fixnum v5; + cl_fixnum v6; + v5 = ecl_length(v2sequence); + v6 = ecl_length(v1prefix); + if (!((v6)<=(v5))) { goto L5; } + { + cl_object v7mismatch; + T0 = (ECL_SYM("MISMATCH",561)->symbol.gfdef); + v7mismatch = cl_apply(4, T0, v1prefix, v2sequence, v3args); + if (Null(v7mismatch)) { goto L9; } + if (!(ecl_lower(v7mismatch,ecl_make_fixnum(v6)))) { goto L11; } + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = ECL_NIL; + cl_env_copy->values[0] = ECL_NIL; + return cl_env_copy->values[0]; +L11:; + if (Null(v4return_suffix)) { goto L14; } + { + cl_object v8; + cl_object v9; + v8 = ecl_minus(ecl_make_fixnum(v5),v7mismatch); + v9 = cl_array_element_type(v2sequence); + T0 = si_make_pure_array(v9, v8, ECL_NIL, ECL_NIL, v2sequence, ecl_make_fixnum(v6)); + goto L13; + } +L14:; + T0 = ECL_NIL; +L13:; + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = T0; + cl_env_copy->values[0] = ECL_T; + return cl_env_copy->values[0]; +L9:; + if (Null(v4return_suffix)) { goto L19; } + { + cl_object v8; + v8 = cl_array_element_type(v2sequence); + T0 = si_make_vector(v8, ecl_make_fixnum(0), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + goto L18; + } +L19:; + T0 = ECL_NIL; +L18:; + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = T0; + cl_env_copy->values[0] = ECL_T; + return cl_env_copy->values[0]; + } +L5:; + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = ECL_NIL; + cl_env_copy->values[0] = ECL_NIL; + return cl_env_copy->values[0]; + } + } +} +/* function definition for ENDS-WITH-SUBSEQ */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L23ends_with_subseq(cl_narg narg, cl_object v1suffix, cl_object v2sequence, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3test; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + { + cl_object keyvars[2]; + cl_parse_key(args,1,L23ends_with_subseqkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + } else { + v3test = keyvars[0]; + } + } + { + cl_fixnum v4; + cl_fixnum v5; + v4 = ecl_length(v2sequence); + v5 = ecl_length(v1suffix); + if (!((v4)<(v5))) { goto L4; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L4:; + { + cl_object v6; + cl_object v7sequence_index; + cl_object v8; + v6 = ecl_minus(ecl_make_fixnum(v4),ecl_make_fixnum(v5)); + v7sequence_index = v6; + v8 = ecl_make_fixnum(v4); + { + cl_object v9suffix_index; + cl_object v10; + v9suffix_index = ecl_make_fixnum(0); + v10 = ecl_make_fixnum(v5); + if (!(ecl_greatereq(v7sequence_index,v8))) { goto L13; } + goto L12; +L13:; +L11:; + if (!(ecl_greatereq(v9suffix_index,v10))) { goto L15; } + goto L12; +L15:; + T0 = ecl_elt(v2sequence,ecl_to_size(v7sequence_index)); + T1 = ecl_elt(v1suffix,ecl_to_size(v9suffix_index)); + if ((ecl_function_dispatch(cl_env_copy,v3test)(2, T0, T1))!=ECL_NIL) { goto L17; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L17:; + v7sequence_index = ecl_one_plus(v7sequence_index); + if (!(ecl_greatereq(v7sequence_index,v8))) { goto L21; } + goto L12; +L21:; + v9suffix_index = ecl_one_plus(v9suffix_index); + goto L11; +L12:; + value0 = ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* function definition for STARTS-WITH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L24starts_with(cl_narg narg, cl_object v1object, cl_object v2sequence, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3test; + cl_object v4key; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L24starts_withkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + } else { + v3test = keyvars[0]; + } + if (Null(keyvars[3])) { + v4key = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + } else { + v4key = keyvars[1]; + } + } + if (!(ECL_CONSP(v2sequence))) { goto L5; } + T1 = ecl_car(v2sequence); + goto L4; +L5:; + if (ECL_CONSP(v2sequence)) { goto L9; } + if (v2sequence==ECL_NIL) { goto L9; } + if (!(ECL_VECTORP(v2sequence))) { goto L7; } + goto L8; +L9:; +L8:; + { + cl_fixnum v5; + v5 = ecl_length(v2sequence); + if (!((v5)>0)) { goto L12; } + } + T1 = ecl_elt(v2sequence,0); + goto L4; +L12:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L7:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L4:; + T0 = ecl_function_dispatch(cl_env_copy,v4key)(1, T1); + value0 = ecl_function_dispatch(cl_env_copy,v3test)(2, T0, v1object); + return value0; + } +} +/* function definition for ENDS-WITH */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L25ends_with(cl_narg narg, cl_object v1object, cl_object v2sequence, ...) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3test; + cl_object v4key; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + { + cl_object keyvars[4]; + cl_parse_key(args,2,L25ends_withkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[2])) { + v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + } else { + v3test = keyvars[0]; + } + if (Null(keyvars[3])) { + v4key = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + } else { + v4key = keyvars[1]; + } + } + if (!(ECL_CONSP(v2sequence))) { goto L5; } + T1 = ecl_function_dispatch(cl_env_copy,VV[69])(1, v2sequence) /* LASTCAR */; + goto L4; +L5:; + if (ECL_CONSP(v2sequence)) { goto L9; } + if (v2sequence==ECL_NIL) { goto L9; } + if (!(ECL_VECTORP(v2sequence))) { goto L7; } + goto L8; +L9:; +L8:; + { + cl_fixnum v5len; + v5len = ecl_length(v2sequence); + if (!((v5len)>0)) { goto L13; } + T2 = ecl_make_integer((v5len)-1); + T1 = ecl_elt(v2sequence,ecl_to_size(T2)); + goto L4; +L13:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +L7:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L4:; + T0 = ecl_function_dispatch(cl_env_copy,v4key)(1, T1); + value0 = ecl_function_dispatch(cl_env_copy,v3test)(2, T0, v1object); + return value0; + } +} +/* function definition for MAP-COMBINATIONS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L30map_combinations(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) +{ + cl_object T0; + volatile cl_object lex0[5]; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3start; + cl_object v4end; + cl_object v5length; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + lex0[0] = v2sequence; /* SEQUENCE */ + { + cl_object keyvars[8]; + cl_parse_key(args,4,L30map_combinationskeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[4])) { + v3start = ecl_make_fixnum(0); + } else { + v3start = keyvars[0]; + } + v4end = keyvars[1]; + v5length = keyvars[2]; + if (Null(keyvars[7])) { + lex0[1] = ECL_T; /* COPY */ + } else { + lex0[1] = keyvars[3]; /* COPY */ + } + } + { + cl_object v6size; + cl_object v7length; + value0 = v4end; + if ((value0)!=ECL_NIL) { goto L5; } + T0 = ecl_make_fixnum(ecl_length(lex0[0])); + goto L3; +L5:; + T0 = value0; + goto L3; +L3:; + lex0[2] = T0; /* END */ + v6size = ecl_minus(lex0[2],v3start); + value0 = v5length; + if ((value0)!=ECL_NIL) { goto L10; } + v7length = v6size; + goto L8; +L10:; + v7length = value0; + goto L8; +L8:; + T0 = cl_subseq(3, lex0[0], ecl_make_fixnum(0), v7length); + lex0[3] = T0; /* COMBINATION */ + T0 = ecl_function_dispatch(cl_env_copy,VV[85])(1, v1function) /* ENSURE-FUNCTION */; + lex0[4] = T0; /* FUNCTION */ + if (!(ecl_number_equalp(v7length,v6size))) { goto L12; } + ecl_function_dispatch(cl_env_copy,lex0[4])(1, lex0[3]); + goto L2; +L12:; + if (!(ECL_LISTP(lex0[0]))) { goto L14; } + T0 = ecl_nthcdr(ecl_to_size(v3start),lex0[0]); + LC27combine_list(lex0, lex0[3], T0); + goto L2; +L14:; + if (!(ECL_VECTORP(lex0[0]))) { goto L16; } + LC28combine(lex0, v7length, v3start); + goto L2; +L16:; + if (ECL_CONSP(lex0[0])) { goto L20; } + if (lex0[0]==ECL_NIL) { goto L20; } + if (!(ECL_VECTORP(lex0[0]))) { goto L18; } + goto L19; +L20:; +L19:; + LC29combine(lex0, v7length, v3start); + goto L2; +L18:; + si_etypecase_error(lex0[0], VV[8]); + } +L2:; + value0 = lex0[0]; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function CALL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC26call(volatile cl_object *lex0) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(lex0[1])) { goto L2; } + T0 = ecl_copy_seq(lex0[3]); + goto L1; +L2:; + T0 = lex0[3]; +L1:; + value0 = ecl_function_dispatch(cl_env_copy,lex0[4])(1, T0); + return value0; + } +} +/* local function COMBINE-LIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC27combine_list(volatile cl_object *lex0, cl_object v1c_tail, cl_object v2o_tail) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if ((v1c_tail)!=ECL_NIL) { goto L1; } + value0 = LC26call(lex0); + return value0; +L1:; + { + cl_object v3tail; + v3tail = v2o_tail; + goto L6; +L5:; + { + cl_object v4; + v4 = ecl_car(v3tail); + { + cl_object v5; + v5 = v1c_tail; + if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v5; + } + (ECL_CONS_CAR(T0)=v4,T0); + } + T0 = ecl_cdr(v1c_tail); + T1 = ecl_cdr(v3tail); + LC27combine_list(lex0, T0, T1); + v3tail = ecl_cdr(v3tail); +L6:; + if (Null(v3tail)) { goto L17; } + goto L5; +L17:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function COMBINE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC28combine(volatile cl_object *lex0, cl_object v1count, cl_object v2start) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ecl_zerop(v1count))) { goto L1; } + value0 = LC26call(lex0); + return value0; +L1:; + { + cl_object v3i; + cl_object v4; + { + cl_object v5; + v5 = v2start; + { + bool v6; + v6 = ecl_numberp(v5); + if (ecl_unlikely(!(v6))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v3i = v5; + } + { + cl_object v5; + v5 = lex0[2]; + { + bool v6; + v6 = ecl_numberp(v5); + if (ecl_unlikely(!(v6))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v4 = v5; + } +L9:; + if (!(ecl_greatereq(v3i,v4))) { goto L11; } + goto L10; +L11:; + { + cl_object v5j; + v5j = ecl_minus(v1count,ecl_make_fixnum(1)); + { + cl_object v6; + v6 = lex0[3]; + T0 = v6; + { + cl_fixnum v7; + { + cl_object v8; + v8 = v5j; + if (ecl_unlikely((ecl_fixnum(v8))>=(v6)->vector.dim)) + FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(ecl_fixnum(v8)),(v6)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v7 = ecl_fixnum(v8); + } + T1 = ecl_aref_unsafe(lex0[0],ecl_fixnum(v3i)); + ecl_aset_unsafe(T0,v7,T1); + } + } + T0 = ecl_plus(v3i,ecl_make_fixnum(1)); + LC28combine(lex0, v5j, T0); + } + v3i = ecl_one_plus(v3i); + goto L9; +L10:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function COMBINE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC29combine(volatile cl_object *lex0, cl_object v1count, cl_object v2start) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ecl_zerop(v1count))) { goto L1; } + value0 = LC26call(lex0); + return value0; +L1:; + { + cl_object v3i; + cl_object v4; + { + cl_object v5; + v5 = v2start; + { + bool v6; + v6 = ecl_numberp(v5); + if (ecl_unlikely(!(v6))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v3i = v5; + } + { + cl_object v5; + v5 = lex0[2]; + { + bool v6; + v6 = ecl_numberp(v5); + if (ecl_unlikely(!(v6))) + FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + } + v4 = v5; + } +L9:; + if (!(ecl_greatereq(v3i,v4))) { goto L11; } + goto L10; +L11:; + { + cl_object v5j; + v5j = ecl_minus(v1count,ecl_make_fixnum(1)); + T0 = ecl_elt(lex0[0],ecl_to_size(v3i)); + ecl_elt_set(lex0[3],ecl_to_size(v5j),T0); + T0 = ecl_plus(v3i,ecl_make_fixnum(1)); + LC29combine(lex0, v5j, T0); + } + v3i = ecl_one_plus(v3i); + goto L9; +L10:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for MAP-PERMUTATIONS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L34map_permutations(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + volatile struct ecl_cclosure aux_closure; + cl_object CLV0, CLV1, CLV2, CLV3; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3start; + cl_object v4end; + cl_object v5length; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ + { + cl_object keyvars[8]; + cl_parse_key(args,4,L34map_permutationskeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[4])) { + v3start = ecl_make_fixnum(0); + } else { + v3start = keyvars[0]; + } + v4end = keyvars[1]; + v5length = keyvars[2]; + if (Null(keyvars[7])) { + CLV1 = env0 = CONS(ECL_T,env0); /* COPY */ + } else { + CLV1 = env0 = CONS(keyvars[3],env0); /* COPY */ + } + } + { + cl_object v6end; + cl_object v7size; + cl_object env1 = env0; + value0 = v4end; + if ((value0)!=ECL_NIL) { goto L4; } + v6end = ecl_make_fixnum(ecl_length(v2sequence)); + goto L2; +L4:; + v6end = value0; + goto L2; +L2:; + v7size = ecl_minus(v6end,v3start); + value0 = v5length; + if ((value0)!=ECL_NIL) { goto L9; } + T0 = v7size; + goto L7; +L9:; + T0 = value0; + goto L7; +L7:; + CLV2 = env1 = CONS(T0,env1); /* LENGTH */ + if (!(ecl_number_equalp(ECL_CONS_CAR(CLV2),v7size))) { goto L11; } + T0 = cl_subseq(3, v2sequence, v3start, v6end); + value0 = (aux_closure.env=env1,cl_env_copy->function=(cl_object)&aux_closure,LC32permute_sequence(1, T0)); + return value0; +L11:; + { + cl_object env2 = env1; + T0 = cl_subseq(3, v2sequence, ecl_make_fixnum(0), ECL_CONS_CAR(CLV2)); + CLV3 = env2 = CONS(T0,env2); /* PERMUTATION */ + { + cl_object v8; + v8 = ecl_make_cclosure_va((cl_objectfn)LC33permute_combination,env2,Cblock,1); + value0 = L30map_combinations(10, v8, v2sequence, ECL_SYM("START",1344), v3start, ECL_SYM("END",1253), v6end, ECL_SYM("LENGTH",1295), ECL_CONS_CAR(CLV2), VV[41], ECL_NIL); + return value0; + } + } + } + } +} +/* closure PERMUTE-SEQUENCE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC32permute_sequence(cl_narg narg, cl_object v1seq, ...) +{ + volatile struct ecl_cclosure aux_closure; + cl_object CLV0, CLV1, CLV2; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV2 = env0; /* LENGTH */ + CLV1 = _ecl_cdr(CLV2); + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC31permute(2, v1seq, ECL_CONS_CAR(CLV2))); + return value0; + } + } +} +/* closure PERMUTE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC31permute(cl_narg narg, cl_object v1seq, cl_object v2n, ...) +{ + cl_object T0; + volatile struct ecl_cclosure aux_closure; + cl_object CLV0, CLV1, CLV2; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV2 = env0; + CLV1 = _ecl_cdr(CLV2); /* COPY */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + { + cl_object v3n_1; + v3n_1 = ecl_minus(v2n,ecl_make_fixnum(1)); + if (!(ecl_zerop(v3n_1))) { goto L2; } + if (Null(ECL_CONS_CAR(CLV1))) { goto L5; } + T0 = ecl_copy_seq(v1seq); + goto L4; +L5:; + T0 = v1seq; +L4:; + value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, T0); + return value0; +L2:; + { + cl_object v4i; + cl_object v5; + v4i = ecl_make_fixnum(0); + v5 = v3n_1; +L9:; + if (!(ecl_greater(v4i,v5))) { goto L11; } + goto L10; +L11:; + (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC31permute(2, v1seq, v3n_1)); + if (!(ecl_evenp(v3n_1))) { goto L15; } + { + cl_object v6; + v6 = ecl_elt(v1seq,ecl_to_size(v3n_1)); + { + cl_object v7; + v7 = ecl_elt(v1seq,0); + ecl_elt_set(v1seq,0,v6); + ecl_elt_set(v1seq,ecl_to_size(v3n_1),v7); + } + } + goto L13; +L15:; + { + cl_object v6; + v6 = ecl_elt(v1seq,ecl_to_size(v3n_1)); + { + cl_object v7; + v7 = ecl_elt(v1seq,ecl_to_size(v4i)); + ecl_elt_set(v1seq,ecl_to_size(v4i),v6); + ecl_elt_set(v1seq,ecl_to_size(v3n_1),v7); + } + } +L13:; + v4i = ecl_one_plus(v4i); + goto L9; +L10:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* closure PERMUTE-COMBINATION */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC33permute_combination(cl_narg narg, cl_object v1combination, ...) +{ + cl_object T0; + volatile struct ecl_cclosure aux_closure; + cl_object CLV0, CLV1, CLV2, CLV3; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV3 = env0; /* PERMUTATION */ + CLV2 = _ecl_cdr(CLV3); + CLV1 = _ecl_cdr(CLV2); + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = cl_replace(2, ECL_CONS_CAR(CLV3), v1combination); + value0 = (aux_closure.env=ecl_nthcdr(1,env0),cl_env_copy->function=(cl_object)&aux_closure,LC32permute_sequence(1, T0)); + return value0; + } + } +} +/* function definition for MAP-DERANGEMENTS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L36map_derangements(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) +{ + cl_object T0, T1; + volatile cl_object lex0[7]; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3end; + ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); + lex0[0] = v1function; /* FUNCTION */ + lex0[1] = v2sequence; /* SEQUENCE */ + { + cl_object keyvars[6]; + cl_parse_key(args,3,L36map_derangementskeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[3])) { + lex0[2] = ecl_make_fixnum(0); /* START */ + } else { + lex0[2] = keyvars[0]; /* START */ + } + v3end = keyvars[1]; + if (Null(keyvars[5])) { + lex0[3] = ECL_T; /* COPY */ + } else { + lex0[3] = keyvars[2]; /* COPY */ + } + } + { + cl_object v4end; + value0 = v3end; + if ((value0)!=ECL_NIL) { goto L3; } + v4end = ecl_make_fixnum(ecl_length(lex0[1])); + goto L1; +L3:; + v4end = value0; + goto L1; +L1:; + T0 = ecl_minus(v4end,lex0[2]); + lex0[4] = T0; /* SIZE */ + T0 = cl_subseq(3, lex0[1], ecl_make_fixnum(0), lex0[4]); + lex0[5] = T0; /* DERANGEMENT */ + T1 = si_make_pure_array(ECL_SYM("BIT",125), lex0[4], ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + T0 = si_fill_array_with_elt(T1, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); + lex0[6] = T0; /* MASK */ + LC35derange(lex0, lex0[2], lex0[4]); + value0 = lex0[1]; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function DERANGE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC35derange(volatile cl_object *lex0, cl_object v1place, cl_object v2n) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ecl_zerop(v2n))) { goto L1; } + if (Null(lex0[3])) { goto L4; } + T0 = ecl_copy_seq(lex0[5]); + goto L3; +L4:; + T0 = lex0[5]; +L3:; + value0 = ecl_function_dispatch(cl_env_copy,lex0[0])(1, T0); + return value0; +L1:; + { + cl_object v3i; + cl_object v4; + v3i = ecl_make_fixnum(0); + v4 = lex0[4]; +L8:; + if (!(ecl_greatereq(v3i,v4))) { goto L10; } + goto L9; +L10:; + T0 = ecl_plus(v3i,lex0[2]); + if (ecl_number_equalp(v1place,T0)) { goto L12; } + T0 = cl_bit(2, lex0[6], v3i); + if (!((ecl_to_fixnum(T0))==0)) { goto L12; } + T0 = ecl_elt(lex0[1],ecl_to_size(v1place)); + ecl_elt_set(lex0[5],ecl_to_size(v3i),T0); + { + cl_object v5; + v5 = lex0[6]; + T0 = v5; + { + cl_fixnum v6; + { + cl_object v7; + v7 = v3i; + if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) + FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = ecl_fixnum(v7); + } + ecl_aset_unsafe(T0,v6,ecl_make_fixnum(1)); + } + } + T0 = ecl_one_plus(v1place); + T1 = ecl_one_minus(v2n); + LC35derange(lex0, T0, T1); + { + cl_object v5; + v5 = lex0[6]; + T0 = v5; + { + cl_fixnum v6; + { + cl_object v7; + v7 = v3i; + if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) + FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v6 = ecl_fixnum(v7); + } + ecl_aset_unsafe(T0,v6,ecl_make_fixnum(0)); + } + } +L12:; + v3i = ecl_one_plus(v3i); + goto L8; +L9:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function LAMBDA235 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC38__lambda235() +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC37__lambda236,ECL_NIL,Cblock,2); + value0 = v1; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* local function LAMBDA236 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC37__lambda236(cl_object v1condition, cl_object v2stream) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + value0 = cl_format(3, v2stream, VV[44], VV[45]); + return value0; + } +} +/* function definition for EXTREMUM */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L41extremum(cl_narg narg, cl_object v1sequence, cl_object v2predicate, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3key; + cl_object v4start; + cl_object v5end; + ecl_va_list args; ecl_va_start(args,v2predicate,narg,2); + { + cl_object keyvars[6]; + cl_parse_key(args,3,L41extremumkeys,keyvars,NULL,FALSE); + ecl_va_end(args); + v3key = keyvars[0]; + if (Null(keyvars[4])) { + v4start = ecl_make_fixnum(0); + } else { + v4start = keyvars[1]; + } + v5end = keyvars[2]; + } + { + cl_object v6real_end; + cl_object env1 = env0; + T0 = ecl_function_dispatch(cl_env_copy,VV[85])(1, v2predicate) /* ENSURE-FUNCTION */; + env1 = ECL_NIL; + CLV0 = env1 = CONS(T0,env1); /* PRED-FUN */ + if (Null(v3key)) { goto L3; } + if ((v3key)==(ECL_SYM("IDENTITY",428))) { goto L3; } + T1 = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + if ((v3key)==(T1)) { goto L3; } + T0 = ecl_function_dispatch(cl_env_copy,VV[85])(1, v3key) /* ENSURE-FUNCTION */; + goto L2; +L3:; + T0 = ECL_NIL; +L2:; + CLV1 = env1 = CONS(T0,env1); /* KEY-FUN */ + value0 = v5end; + if ((value0)!=ECL_NIL) { goto L10; } + v6real_end = ecl_make_fixnum(ecl_length(v1sequence)); + goto L8; +L10:; + v6real_end = value0; + goto L8; +L8:; + if (!(ecl_greater(v6real_end,v4start))) { goto L12; } + if (Null(ECL_CONS_CAR(CLV1))) { goto L14; } + { + cl_object v7; + v7 = ecl_make_cclosure_va((cl_objectfn)LC39reduce_keys,env1,Cblock,2); + value0 = cl_reduce(6, v7, v1sequence, ECL_SYM("START",1344), v4start, ECL_SYM("END",1253), v6real_end); + return value0; + } +L14:; + { + cl_object v8; + v8 = ecl_make_cclosure_va((cl_objectfn)LC40reduce_elts,env1,Cblock,2); + value0 = cl_reduce(6, v8, v1sequence, ECL_SYM("START",1344), v4start, ECL_SYM("END",1253), v6real_end); + return value0; + } +L12:; + if (!(ecl_number_equalp(v6real_end,v4start))) { goto L16; } + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L16:; + { + cl_fixnum v9; + v9 = ecl_length(v1sequence); + value0 = cl_error(6, VV[46], ecl_make_fixnum(v9), ECL_SYM("START",1344), v4start, ECL_SYM("END",1253), v5end); + return value0; + } + } + } +} +/* closure REDUCE-KEYS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC39reduce_keys(cl_narg narg, cl_object v1a, cl_object v2b, ...) +{ + cl_object T0, T1; + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; /* KEY-FUN */ + CLV0 = _ecl_cdr(CLV1); + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + T0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v1a); + T1 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v2b); + if (Null(ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, T0, T1))) { goto L1; } + value0 = v1a; + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = v2b; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure REDUCE-ELTS */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC40reduce_elts(cl_narg narg, cl_object v1a, cl_object v2b, ...) +{ + cl_object CLV0, CLV1; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV1 = env0; + CLV0 = _ecl_cdr(CLV1); /* PRED-FUN */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); + { +TTL: + if (Null(ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, v1a, v2b))) { goto L1; } + value0 = v1a; + cl_env_copy->nvalues = 1; + return value0; +L1:; + value0 = v2b; + cl_env_copy->nvalues = 1; + return value0; + } + } +} + +#include "lib/alexandria/sequences.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecl4y48pVyvO59HM_y7IycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/sequences.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4y48pVyvO59HM_y7IycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* SEQUENCE-OF-LENGTH-P */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[6]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[7], VVtemp[8]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* ROTATE-TAIL-TO-HEAD */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; + ecl_cmp_defun(VV[51]); /* ROTATE-HEAD-TO-TAIL */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defun(VV[52]); /* ROTATE */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[53]); /* SHUFFLE */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[7], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[56]); /* RANDOM-ELT */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[10], ECL_SYM("FUNCTION",398), VVtemp[22]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[23]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defun(VV[57]); /* REMOVE/SWAPPED-ARGUMENTS */ + si_put_sysprop(VV[13], ECL_SYM("INLINE",436), VVtemp[27]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[28], VVtemp[29]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[30]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[58]); /* REMOVEF */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[14], ECL_SYM("FUNCTION",398), VVtemp[31]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[32]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defun(VV[60]); /* DELETE/SWAPPED-ARGUMENTS */ + si_put_sysprop(VV[16], ECL_SYM("INLINE",436), VVtemp[35]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[36], VVtemp[37]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[30]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[61]); /* DELETEF */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[17], ECL_SYM("FUNCTION",398), VVtemp[38]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[18], ECL_SYM("TYPE",871), VVtemp[39]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC13__lambda79,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[18], VVtemp[40], T0); + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[63]); /* EMPTYP */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[44]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[45], VVtemp[46]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[47]) /* ANNOTATE */; + ecl_cmp_defun(VV[64]); /* LENGTH= */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[22], ECL_SYM("FUNCTION",398), VVtemp[48]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC16__lambda104,ECL_NIL,Cblock,2); + T0 = v1; + } + si_put_sysprop(VV[22], ECL_SYM("COMPILER-MACRO",240), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[49], VVtemp[50]) /* ANNOTATE */; + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[51], VVtemp[52]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[53]) /* ANNOTATE */; + ecl_cmp_defun(VV[65]); /* COPY-SEQUENCE */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[54]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[28], ECL_SYM("INLINE",436), VVtemp[55]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LOCATION",1862), VVtemp[56], VVtemp[57]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[66]); /* FIRST-ELT */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[29], ECL_SYM("FUNCTION",398), VVtemp[58]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[59], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[59], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; + ecl_cmp_defun(VV[67]); /* (SETF FIRST-ELT) */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[30], ECL_SYM("FUNCTION",398), VVtemp[63]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LOCATION",1862), VVtemp[64], VVtemp[65]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[68]); /* LAST-ELT */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[31], ECL_SYM("FUNCTION",398), VVtemp[66]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[67], ECL_SYM("LOCATION",1862), VVtemp[68], VVtemp[69]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[67], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; + ecl_cmp_defun(VV[70]); /* (SETF LAST-ELT) */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[33], ECL_SYM("FUNCTION",398), VVtemp[70]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LOCATION",1862), VVtemp[71], VVtemp[72]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[73]) /* ANNOTATE */; + ecl_cmp_defun(VV[72]); /* STARTS-WITH-SUBSEQ */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[34], ECL_SYM("FUNCTION",398), VVtemp[74]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LOCATION",1862), VVtemp[75], VVtemp[76]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[77]) /* ANNOTATE */; + ecl_cmp_defun(VV[74]); /* ENDS-WITH-SUBSEQ */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[36], ECL_SYM("FUNCTION",398), VVtemp[78]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[37], ECL_SYM("LOCATION",1862), VVtemp[79], VVtemp[80]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[37], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[81]) /* ANNOTATE */; + ecl_cmp_defun(VV[76]); /* STARTS-WITH */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[37], ECL_SYM("FUNCTION",398), VVtemp[82]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LOCATION",1862), VVtemp[83], VVtemp[84]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[81]) /* ANNOTATE */; + ecl_cmp_defun(VV[79]); /* ENDS-WITH */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[38], ECL_SYM("FUNCTION",398), VVtemp[85]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[39], ECL_SYM("LOCATION",1862), VVtemp[86], VVtemp[87]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[39], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[88]) /* ANNOTATE */; + ecl_cmp_defun(VV[80]); /* MAP-COMBINATIONS */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[39], ECL_SYM("FUNCTION",398), VVtemp[89]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[90], VVtemp[91]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[88]) /* ANNOTATE */; + ecl_cmp_defun(VV[86]); /* MAP-PERMUTATIONS */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[40], ECL_SYM("FUNCTION",398), VVtemp[92]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[93], VVtemp[94]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[95]) /* ANNOTATE */; + ecl_cmp_defun(VV[87]); /* MAP-DERANGEMENTS */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[42], ECL_SYM("FUNCTION",398), VVtemp[96]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[97]) /* MAPC */; + { + cl_object T0, T1, T2; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LOCATION",1862), VVtemp[98], VVtemp[99]) /* ANNOTATE */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC38__lambda235,ECL_NIL,Cblock,0); + T0 = v1; + } + T1 = cl_listX(3, ECL_SYM("INITFUNCTION",999), T0, VVtemp[101]); + T2 = ecl_list1(T1); + clos_load_defclass(VV[43], VVtemp[100], T2, ECL_NIL); + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LOCATION",1862), VVtemp[102], VVtemp[103]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[104]) /* ANNOTATE */; + ecl_cmp_defun(VV[91]); /* EXTREMUM */ + ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[45], ECL_SYM("FUNCTION",398), VVtemp[105]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/strings.cxx b/lib/alexandria/strings.cxx new file mode 100644 index 0000000..db38415 --- /dev/null +++ b/lib/alexandria/strings.cxx @@ -0,0 +1,65 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/strings.lisp */ +#include +#include "lib/alexandria/strings.eclh" +/* local function LAMBDA2 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1__lambda2(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[3])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = VV[1]; + cl_env_copy->nvalues = 1; + return value0; + } +} + +#include "lib/alexandria/strings.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclOk91d7g9HuD9M_CxEycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/strings.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclOk91d7g9HuD9M_CxEycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[2])(3, VV[0], ECL_SYM("TYPE",871), VVtemp[1]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC1__lambda2,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[0], VVtemp[2], T0); + } +} diff --git a/lib/alexandria/symbols.cxx b/lib/alexandria/symbols.cxx new file mode 100644 index 0000000..586d712 --- /dev/null +++ b/lib/alexandria/symbols.cxx @@ -0,0 +1,356 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/symbols.lisp */ +#include +#include "lib/alexandria/symbols.eclh" +/* function definition for ENSURE-SYMBOL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L1ensure_symbol(cl_narg narg, cl_object v1name, ...) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); + { + cl_object v2package; + va_list args; va_start(args,v1name); + { + int i = 1; + if (i >= narg) { + v2package = ecl_symbol_value(ECL_SYM("*PACKAGE*",45)); + } else { + i++; + v2package = va_arg(args,cl_object); + } + } + va_end(args); + T0 = cl_string(v1name); + value0 = cl_intern(2, T0, v2package); + return value0; + } +} +/* function definition for MAYBE-INTERN */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L2maybe_intern(cl_object v1name, cl_object v2package) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v2package)) { goto L2; } + if (!((ECL_T)==(v2package))) { goto L5; } + T0 = ecl_symbol_value(ECL_SYM("*PACKAGE*",45)); + goto L4; +L5:; + T0 = v2package; +L4:; + value0 = cl_intern(2, v1name, T0); + goto L1; +L2:; + value0 = cl_make_symbol(v1name); +L1:; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for FORMAT-SYMBOL */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L3format_symbol(cl_narg narg, cl_object v1package, cl_object v2control, ...) +{ + cl_object T0, T1, T2; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); + { + cl_object v3arguments; + ecl_va_list args; ecl_va_start(args,v2control,narg,2); + v3arguments = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v4; + v4 = ecl_symbol_value(ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1798)); + { + cl_object v6, v7; cl_index v5; + v6 = ECL_CONS_CAR(v4); + v7 = ECL_CONS_CDR(v4); + v5 = ecl_progv(cl_env_copy, v6, v7); + T1 = (ECL_SYM("FORMAT",389)->symbol.gfdef); + T2 = cl_string(v2control); + T0 = cl_apply(4, T1, ECL_NIL, T2, v3arguments); + ecl_bds_unwind(cl_env_copy,v5); + } + } + value0 = L2maybe_intern(T0, v1package); + return value0; + } +} +/* function definition for MAKE-KEYWORD */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L4make_keyword(cl_object v1name) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_string(v1name); + value0 = cl_intern(2, T0, VV[4]); + return value0; + } +} +/* function definition for MAKE-GENSYM */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L5make_gensym(cl_object v1name) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + v2 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v1name)||ECL_BIGNUMP(v1name))) { goto L2; } + v2 = v1name; + if (!(ecl_greatereq(v2,ecl_make_fixnum(0)))) { goto L2; } + } + T0 = v1name; + goto L1; +L2:; + T0 = cl_string(v1name); +L1:; + value0 = cl_gensym(1, T0); + return value0; + } +} +/* function definition for MAKE-GENSYM-LIST */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L6make_gensym_list(cl_narg narg, cl_object v1length, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); + if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); + { + cl_object v2x; + va_list args; va_start(args,v1length); + { + int i = 1; + if (i >= narg) { + v2x = VV[7]; + } else { + i++; + v2x = va_arg(args,cl_object); + } + } + va_end(args); + { + cl_object v3g; + { + cl_object v4; + v4 = ecl_make_fixnum(0); + if (!(ECL_FIXNUMP(v2x)||ECL_BIGNUMP(v2x))) { goto L3; } + v4 = v2x; + if (!(ecl_greatereq(v4,ecl_make_fixnum(0)))) { goto L3; } + } + v3g = v2x; + goto L2; +L3:; + v3g = cl_string(v2x); +L2:; + { + cl_object v4; + { + cl_object v5; + v5 = v1length; + T0 = cl_realp(v5); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",705),v5); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + v4 = v5; + } + { + cl_object v5; + cl_object v6; + v5 = ecl_list1(ECL_NIL); + v6 = v5; +L14:; + v4 = ecl_minus(v4,ecl_make_fixnum(1)); + T0 = v4; + if (!(ecl_minusp(T0))) { goto L16; } + goto L15; +L16:; + { + cl_object v7; + v7 = v6; + if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); + value0 = ECL_NIL; + cl_env_copy->nvalues = 0; + T0 = v7; + } + T1 = cl_gensym(1, v3g); + v6 = ecl_list1(T1); + (ECL_CONS_CDR(T0)=v6,T0); + goto L14; +L15:; + value0 = ecl_cdr(v5); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* function definition for SYMBOLICATE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L8symbolicate(cl_narg narg, ...) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + cl_object v1things; + ecl_va_list args; ecl_va_start(args,narg,narg,0); + v1things = cl_grab_rest_args(args); + ecl_va_end(args); + { + cl_object v2length; + cl_object v3name; + T0 = (ECL_SYM("+",16)->symbol.gfdef); + { + cl_object v4; + v4 = ecl_make_cfun((cl_objectfn_fixed)LC7__lambda15,ECL_NIL,Cblock,1); + T1 = v4; + } + v2length = cl_reduce(4, T0, v1things, ECL_SYM("KEY",1294), T1); + v3name = si_make_pure_array(ECL_SYM("CHARACTER",224), v2length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + { + cl_object v4index; + v4index = ecl_make_fixnum(0); + { + cl_object v5; + v5 = v1things; + goto L9; +L8:; + { + cl_object v6thing; + v6thing = ecl_car(v5); + { + cl_object v7x; + cl_fixnum v8len; + v7x = cl_string(v6thing); + v8len = ecl_length(v7x); + cl_replace(4, v3name, v7x, ECL_SYM("START1",1345), v4index); + v4index = ecl_plus(v4index,ecl_make_fixnum(v8len)); + } + } + v5 = ecl_cdr(v5); +L9:; + if (Null(v5)) { goto L20; } + goto L8; +L20:; + value0 = cl_intern(1, v3name); + cl_env_copy->nvalues = 1; + return value0; + } + } + } + } +} +/* local function LAMBDA15 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC7__lambda15(cl_object v1x) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_string(v1x); + value0 = ecl_make_fixnum(ecl_length(T0)); + cl_env_copy->nvalues = 1; + return value0; + } +} + +#include "lib/alexandria/symbols.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _ecljVTgFlYFBNMEM_qiFycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/symbols.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecljVTgFlYFBNMEM_qiFycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[9]); /* ENSURE-SYMBOL */ + ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[6]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[7], VVtemp[8]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; + ecl_cmp_defun(VV[11]); /* MAYBE-INTERN */ + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[10]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[13]) /* ANNOTATE */; + ecl_cmp_defun(VV[12]); /* FORMAT-SYMBOL */ + ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[2], ECL_SYM("INLINE",436), VVtemp[15]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[13]); /* MAKE-KEYWORD */ + ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[14]); /* MAKE-GENSYM */ + ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[22]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[23], VVtemp[24]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defun(VV[15]); /* MAKE-GENSYM-LIST */ + ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[26]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defun(VV[16]); /* SYMBOLICATE */ + ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[30]) /* SET-DOCUMENTATION */; +} diff --git a/lib/alexandria/types.cxx b/lib/alexandria/types.cxx new file mode 100644 index 0000000..40a7ca4 --- /dev/null +++ b/lib/alexandria/types.cxx @@ -0,0 +1,2164 @@ +/* Compiler: ECL 24.5.10 */ +/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Machine: Linux 6.9.7-arch1-1 x86_64 */ +/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/types.lisp */ +#include +#include "lib/alexandria/types.eclh" +/* local function LAMBDA2 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC1__lambda2(cl_object v1) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + cl_object v3length; + v2 = v1; + if (Null(v2)) { goto L3; } + { + cl_object v4; + v4 = ecl_car(v2); + v2 = ecl_cdr(v2); + v3length = v4; + goto L2; + } +L3:; + v3length = ecl_make_fixnum(2305843009213693950); +L2:; + if (Null(v2)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + T0 = ecl_list1(v3length); + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), T0); + return value0; + } + } +} +/* local function LAMBDA6 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC2__lambda6(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v2; + cl_object v3length; + v2 = v1; + if (Null(v2)) { goto L3; } + { + cl_object v4; + v4 = ecl_car(v2); + v2 = ecl_cdr(v2); + v3length = v4; + goto L2; + } +L3:; + v3length = ecl_make_fixnum(2305843009213693950); +L2:; + if (Null(v2)) { goto L8; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L8:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), v3length); + return value0; + } + } +} +/* local function LAMBDA37 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC3__lambda37(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(-1)); + return value0; + } +} +/* local function LAMBDA40 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC4__lambda40(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(0)); + return value0; + } +} +/* local function LAMBDA43 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC5__lambda43(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), ecl_make_fixnum(2305843009213693951)); + return value0; + } +} +/* local function LAMBDA46 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC6__lambda46(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(1), ecl_make_fixnum(2305843009213693951)); + return value0; + } +} +/* function definition for NEGATIVE-FIXNUM-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L7negative_fixnum_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-FIXNUM-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L8non_positive_fixnum_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-FIXNUM-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L9non_negative_fixnum_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-FIXNUM-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L10positive_fixnum_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA49 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC11__lambda49(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ECL_SYM("*",20), ecl_make_fixnum(-1)); + return value0; + } +} +/* local function LAMBDA52 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC12__lambda52(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ECL_SYM("*",20), ecl_make_fixnum(0)); + return value0; + } +} +/* local function LAMBDA55 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC13__lambda55(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA58 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC14__lambda58(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(1), ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-INTEGER-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L15negative_integer_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-INTEGER-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L16non_positive_integer_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-INTEGER-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L17non_negative_integer_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-INTEGER-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L18positive_integer_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA61 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC19__lambda61(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("RATIONAL",689), ECL_SYM("*",20), VV[19]); + return value0; + } +} +/* local function LAMBDA64 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC20__lambda64(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("RATIONAL",689), ECL_SYM("*",20), ecl_make_fixnum(0)); + return value0; + } +} +/* local function LAMBDA67 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC21__lambda67(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("RATIONAL",689), ecl_make_fixnum(0), ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA70 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC22__lambda70(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("RATIONAL",689), VV[19], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-RATIONAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L23negative_rational_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_rationalp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-RATIONAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L24non_positive_rational_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_rationalp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-RATIONAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L25non_negative_rational_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_rationalp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-RATIONAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L26positive_rational_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_rationalp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA73 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC27__lambda73(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("REAL",705), ECL_SYM("*",20), VV[19]); + return value0; + } +} +/* local function LAMBDA76 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC28__lambda76(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("REAL",705), ECL_SYM("*",20), ecl_make_fixnum(0)); + return value0; + } +} +/* local function LAMBDA79 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC29__lambda79(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("REAL",705), ecl_make_fixnum(0), ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA82 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC30__lambda82(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("REAL",705), VV[19], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-REAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L31negative_real_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_realp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-REAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L32non_positive_real_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_realp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-REAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L33non_negative_real_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_realp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-REAL-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L34positive_real_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(cl_realp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA85 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC35__lambda85(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("FLOAT",376), ECL_SYM("*",20), VV[36]); + return value0; + } +} +/* local function LAMBDA88 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC36__lambda88(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("FLOAT",376), ECL_SYM("*",20), cl_core.singlefloat_zero); + return value0; + } +} +/* local function LAMBDA91 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC37__lambda91(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("FLOAT",376), cl_core.singlefloat_zero, ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA94 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC38__lambda94(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("FLOAT",376), VV[36], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L39negative_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(floatp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,cl_core.singlefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L40non_positive_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(floatp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.singlefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L41non_negative_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(floatp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(cl_core.singlefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L42positive_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(floatp(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(cl_core.singlefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA97 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC43__lambda97(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), ECL_SYM("*",20), VV[36]); + return value0; + } +} +/* local function LAMBDA100 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC44__lambda100(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), ECL_SYM("*",20), cl_core.singlefloat_zero); + return value0; + } +} +/* local function LAMBDA103 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC45__lambda103(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), cl_core.singlefloat_zero, ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA106 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC46__lambda106(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), VV[36], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-SHORT-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L47negative_short_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,cl_core.singlefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-SHORT-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L48non_positive_short_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.singlefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-SHORT-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L49non_negative_short_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(cl_core.singlefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-SHORT-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L50positive_short_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(cl_core.singlefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA109 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC51__lambda109(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), ECL_SYM("*",20), VV[36]); + return value0; + } +} +/* local function LAMBDA112 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC52__lambda112(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), ECL_SYM("*",20), cl_core.singlefloat_zero); + return value0; + } +} +/* local function LAMBDA115 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC53__lambda115(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), cl_core.singlefloat_zero, ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA118 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC54__lambda118(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), VV[36], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-SINGLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L55negative_single_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,cl_core.singlefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-SINGLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L56non_positive_single_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.singlefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-SINGLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L57non_negative_single_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(cl_core.singlefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-SINGLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L58positive_single_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(cl_core.singlefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA121 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC59__lambda121(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), ECL_SYM("*",20), VV[61]); + return value0; + } +} +/* local function LAMBDA124 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC60__lambda124(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), ECL_SYM("*",20), cl_core.doublefloat_zero); + return value0; + } +} +/* local function LAMBDA127 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC61__lambda127(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), cl_core.doublefloat_zero, ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA130 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC62__lambda130(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), VV[61], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-DOUBLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L63negative_double_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,cl_core.doublefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-DOUBLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L64non_positive_double_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.doublefloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-DOUBLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L65non_negative_double_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(cl_core.doublefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-DOUBLE-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L66positive_double_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(cl_core.doublefloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* local function LAMBDA133 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC67__lambda133(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), ECL_SYM("*",20), VV[70]); + return value0; + } +} +/* local function LAMBDA136 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC68__lambda136(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), ECL_SYM("*",20), cl_core.longfloat_zero); + return value0; + } +} +/* local function LAMBDA139 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC69__lambda139(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), cl_core.longfloat_zero, ECL_SYM("*",20)); + return value0; + } +} +/* local function LAMBDA142 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC70__lambda142(cl_object v1) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (Null(v1)) { goto L1; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L1:; + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), VV[70], ECL_SYM("*",20)); + return value0; + } +} +/* function definition for NEGATIVE-LONG-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L71negative_long_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(v1n,cl_core.longfloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-POSITIVE-LONG-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L72non_positive_long_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.longfloat_zero)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for NON-NEGATIVE-LONG-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L73non_negative_long_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lowereq(cl_core.longfloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for POSITIVE-LONG-FLOAT-P */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L74positive_long_float_p(cl_object v1n) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } + value0 = ecl_make_bool(ecl_lower(cl_core.longfloat_zero,v1n)); + cl_env_copy->nvalues = 1; + return value0; +L2:; + value0 = ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; + } +} +/* function definition for OF-TYPE */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L76of_type(cl_object v1type) +{ + cl_object env0 = ECL_NIL; + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { + env0 = ECL_NIL; + CLV0 = env0 = CONS(v1type,env0); /* TYPE */ + { + cl_object v2; + v2 = ecl_make_cclosure_va((cl_objectfn)LC75__lambda143,env0,Cblock,1); + value0 = v2; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* closure LAMBDA143 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC75__lambda143(cl_narg narg, cl_object v1thing, ...) +{ + cl_object CLV0; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object env0 = cl_env_copy->function->cclosure.env; + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + /* Scanning closure data ... */ + CLV0 = env0; /* TYPE */ + { /* ... closure scanning finished */ + if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); + { +TTL: + value0 = cl_typep(2, v1thing, ECL_CONS_CAR(CLV0)); + return value0; + } + } +} +/* local function LAMBDA146 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC77__lambda146(cl_object v1, cl_object v2env) +{ + cl_object T0, T1; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4type; + T0 = ecl_car(v1); + if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + T0 = ecl_caadr(v1); + if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + v3 = ecl_cddr(v1); + goto L1; +L2:; + v3 = ecl_cdr(v1); +L1:; + if (!(v3==ECL_NIL)) { goto L6; } + ecl_function_dispatch(cl_env_copy,VV[122])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L6:; + { + cl_object v5; + v5 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4type = v5; + } + if (Null(v3)) { goto L11; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L11:; + if (Null(cl_constantp(2, v4type, v2env))) { goto L13; } + { + cl_object v5thing; + v5thing = cl_gensym(1, VV[79]); + T0 = ecl_list1(v5thing); + T1 = cl_list(3, ECL_SYM("TYPEP",877), v5thing, v4type); + value0 = cl_list(3, ECL_SYM("LAMBDA",454), T0, T1); + return value0; + } +L13:; + value0 = v1; + cl_env_copy->nvalues = 1; + return value0; + } + } +} +/* function definition for TYPE= */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object L78type_(cl_object v1type1, cl_object v2type2) +{ + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v4; /* SUB */ + cl_object v5; /* OK */ + value0 = cl_subtypep(2, v1type1, v2type2); + { + v4 = value0; + v5 = cl_env_copy->values[1]; + } + if (Null(v5)) { goto L2; } + if (Null(v4)) { goto L2; } + value0 = cl_subtypep(2, v2type2, v1type1); + return value0; +L2:; + if (Null(v5)) { goto L5; } + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = v5; + cl_env_copy->values[0] = ECL_NIL; + return cl_env_copy->values[0]; +L5:; + { + cl_object v7; /* OK */ + value0 = cl_subtypep(2, v2type2, v1type1); + { + v7 = cl_env_copy->values[1]; + } + cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = v7; + cl_env_copy->values[0] = ECL_NIL; + return cl_env_copy->values[0]; + } + } + } +} +/* local function COERCEF */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC80coercef(cl_object v1, cl_object v2si__env) +{ + cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + { + cl_object v3; + cl_object v4si___reference; + cl_object v5type_spec; + v3 = ecl_cdr(v1); + if (!(v3==ECL_NIL)) { goto L3; } + ecl_function_dispatch(cl_env_copy,VV[122])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L3:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v4si___reference = v6; + } + if (!(v3==ECL_NIL)) { goto L9; } + ecl_function_dispatch(cl_env_copy,VV[122])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; +L9:; + { + cl_object v6; + v6 = ecl_car(v3); + v3 = ecl_cdr(v3); + v5type_spec = v6; + } + if (Null(v3)) { goto L14; } + ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; +L14:; + { + cl_object v7; /* VARS */ + cl_object v8; /* VALS */ + cl_object v9; /* STORES */ + cl_object v10; /* SETTER */ + cl_object v11; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + { + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; + } + { + cl_object v12si__all_vars; + { + cl_object v13; + v13 = ecl_make_cfun((cl_objectfn_fixed)LC79__lambda154,ECL_NIL,Cblock,1); + T0 = v13; + } + T1 = CONS(v5type_spec,ECL_NIL); + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + if (!(ECL_SYMBOLP(v11))) { goto L19; } + T0 = (ECL_SYM("CAR",182)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("COERCE",233), v11, T1); + T3 = ecl_car(v9); + T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[82],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); + T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + value0 = cl_subst(3, T2, T3, T8); + return value0; +L19:; + { + cl_object v13si__d; + cl_object v14si__v; + cl_object v15si__let_list; + v13si__d = v7; + v14si__v = v8; + v15si__let_list = ECL_NIL; + goto L28; +L27:; + { + cl_object v16; + v16 = ecl_cdr(v13si__d); + { + cl_object v17; + v17 = ecl_cdr(v14si__v); + T0 = ecl_car(v13si__d); + T1 = ecl_car(v14si__v); + T2 = cl_list(2, T0, T1); + v15si__let_list = CONS(T2,v15si__let_list); + v14si__v = v17; + v13si__d = v16; + } + } +L28:; + if (v13si__d==ECL_NIL) { goto L34; } + goto L27; +L34:; + T0 = ecl_car(v9); + T1 = (ECL_SYM("CAR",182)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = cl_listX(3, ECL_SYM("COERCE",233), v11, T2); + T4 = cl_list(2, T0, T3); + T5 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T4,T5); + T0 = cl_nreverse(v15si__let_list); + T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T3 = ecl_append(T2,v7); + T4 = CONS(VV[82],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); + value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + return value0; + } + } + } + } + } +} +/* local function LAMBDA154 */ +/* optimize speed 3, debug 0, space 0, safety 2 */ +static cl_object LC79__lambda154(cl_object v1si__v) +{ + cl_object T0; + cl_object env0 = ECL_NIL; + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + ecl_cs_check(cl_env_copy,value0); + { +TTL: + T0 = cl_gensym(0); + value0 = cl_list(2, T0, v1si__v); + return value0; + } +} + +#include "lib/alexandria/types.data" +#ifdef __cplusplus +extern "C" +#endif +ECL_DLLEXPORT void _eclYKIWc8zWYNLAM_M2HycC71(cl_object flag) +{ + const cl_env_ptr cl_env_copy = ecl_process_env(); + cl_object value0; + cl_object *VVtemp; + if (flag != OBJNULL){ + Cblock = flag; + #ifndef ECL_DYNAMIC_VV + flag->cblock.data = VV; + #endif + flag->cblock.data_size = VM; + flag->cblock.temp_data_size = VMtemp; + flag->cblock.data_text = compiler_data_text; + flag->cblock.cfuns_size = compiler_cfuns_size; + flag->cblock.cfuns = compiler_cfuns; + flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/types.lisp",-1); + return;} + #ifdef ECL_DYNAMIC_VV + VV = Cblock->cblock.data; + #endif + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclYKIWc8zWYNLAM_M2HycC71@"; + VVtemp = Cblock->cblock.temp_data; + ECL_DEFINE_SETF_FUNCTIONS + si_select_package(VVtemp[0]); + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[0], ECL_SYM("TYPE",871), VVtemp[1]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC1__lambda2,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[0], VVtemp[2], T0); + } + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[1], ECL_SYM("TYPE",871), VVtemp[3]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC2__lambda6,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[1], VVtemp[4], T0); + } + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[2], ECL_SYM("TYPE",871), VVtemp[5]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC3__lambda37,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[2], VVtemp[6], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[3], ECL_SYM("TYPE",871), VVtemp[7]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda40,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[3], VVtemp[8], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[4], ECL_SYM("TYPE",871), VVtemp[9]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC5__lambda43,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[4], VVtemp[10], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[5], ECL_SYM("TYPE",871), VVtemp[11]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC6__lambda46,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[5], VVtemp[12], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[13]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[85]); /* NEGATIVE-FIXNUM-P */ + si_put_sysprop(VV[6], ECL_SYM("INLINE",436), VVtemp[17]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[86]); /* NON-POSITIVE-FIXNUM-P */ + si_put_sysprop(VV[7], ECL_SYM("INLINE",436), VVtemp[19]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[87]); /* NON-NEGATIVE-FIXNUM-P */ + si_put_sysprop(VV[8], ECL_SYM("INLINE",436), VVtemp[21]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[88]); /* POSITIVE-FIXNUM-P */ + si_put_sysprop(VV[9], ECL_SYM("INLINE",436), VVtemp[23]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[10], ECL_SYM("TYPE",871), VVtemp[24]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC11__lambda49,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[10], VVtemp[25], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[11], ECL_SYM("TYPE",871), VVtemp[26]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC12__lambda52,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[11], VVtemp[27], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[12], ECL_SYM("TYPE",871), VVtemp[28]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC13__lambda55,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[12], VVtemp[29], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[13], ECL_SYM("TYPE",871), VVtemp[30]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC14__lambda58,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[13], VVtemp[31], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[32]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[89]); /* NEGATIVE-INTEGER-P */ + si_put_sysprop(VV[14], ECL_SYM("INLINE",436), VVtemp[34]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[35], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[90]); /* NON-POSITIVE-INTEGER-P */ + si_put_sysprop(VV[15], ECL_SYM("INLINE",436), VVtemp[36]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[37], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[91]); /* NON-NEGATIVE-INTEGER-P */ + si_put_sysprop(VV[16], ECL_SYM("INLINE",436), VVtemp[38]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[92]); /* POSITIVE-INTEGER-P */ + si_put_sysprop(VV[17], ECL_SYM("INLINE",436), VVtemp[40]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[18], ECL_SYM("TYPE",871), VVtemp[41]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC19__lambda61,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[18], VVtemp[42], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[20], ECL_SYM("TYPE",871), VVtemp[41]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC20__lambda64,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[20], VVtemp[43], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[21], ECL_SYM("TYPE",871), VVtemp[44]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC21__lambda67,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[21], VVtemp[45], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[22], ECL_SYM("TYPE",871), VVtemp[44]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC22__lambda70,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[22], VVtemp[46], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[47]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[48], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[93]); /* NEGATIVE-RATIONAL-P */ + si_put_sysprop(VV[23], ECL_SYM("INLINE",436), VVtemp[49]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LOCATION",1862), VVtemp[50], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[94]); /* NON-POSITIVE-RATIONAL-P */ + si_put_sysprop(VV[24], ECL_SYM("INLINE",436), VVtemp[51]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[52], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[95]); /* NON-NEGATIVE-RATIONAL-P */ + si_put_sysprop(VV[25], ECL_SYM("INLINE",436), VVtemp[53]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[54], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[96]); /* POSITIVE-RATIONAL-P */ + si_put_sysprop(VV[26], ECL_SYM("INLINE",436), VVtemp[55]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[27], ECL_SYM("TYPE",871), VVtemp[56]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC27__lambda73,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[27], VVtemp[57], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[28], ECL_SYM("TYPE",871), VVtemp[56]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC28__lambda76,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[28], VVtemp[58], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[29], ECL_SYM("TYPE",871), VVtemp[59]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC29__lambda79,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[29], VVtemp[60], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[30], ECL_SYM("TYPE",871), VVtemp[59]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC30__lambda82,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[30], VVtemp[61], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[62]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LOCATION",1862), VVtemp[63], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[97]); /* NEGATIVE-REAL-P */ + si_put_sysprop(VV[31], ECL_SYM("INLINE",436), VVtemp[64]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LOCATION",1862), VVtemp[65], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[98]); /* NON-POSITIVE-REAL-P */ + si_put_sysprop(VV[32], ECL_SYM("INLINE",436), VVtemp[66]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LOCATION",1862), VVtemp[67], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[99]); /* NON-NEGATIVE-REAL-P */ + si_put_sysprop(VV[33], ECL_SYM("INLINE",436), VVtemp[68]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LOCATION",1862), VVtemp[69], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[100]); /* POSITIVE-REAL-P */ + si_put_sysprop(VV[34], ECL_SYM("INLINE",436), VVtemp[70]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[35], ECL_SYM("TYPE",871), VVtemp[71]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC35__lambda85,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[35], VVtemp[72], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[37], ECL_SYM("TYPE",871), VVtemp[71]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC36__lambda88,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[37], VVtemp[73], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[38], ECL_SYM("TYPE",871), VVtemp[74]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC37__lambda91,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[38], VVtemp[75], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[39], ECL_SYM("TYPE",871), VVtemp[74]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC38__lambda94,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[39], VVtemp[76], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[77]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[78], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[101]); /* NEGATIVE-FLOAT-P */ + si_put_sysprop(VV[40], ECL_SYM("INLINE",436), VVtemp[79]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LOCATION",1862), VVtemp[80], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[102]); /* NON-POSITIVE-FLOAT-P */ + si_put_sysprop(VV[41], ECL_SYM("INLINE",436), VVtemp[81]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[82], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[103]); /* NON-NEGATIVE-FLOAT-P */ + si_put_sysprop(VV[42], ECL_SYM("INLINE",436), VVtemp[83]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LOCATION",1862), VVtemp[84], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[104]); /* POSITIVE-FLOAT-P */ + si_put_sysprop(VV[43], ECL_SYM("INLINE",436), VVtemp[85]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[44], ECL_SYM("TYPE",871), VVtemp[86]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC43__lambda97,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[44], VVtemp[87], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[45], ECL_SYM("TYPE",871), VVtemp[86]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC44__lambda100,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[45], VVtemp[88], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[46], ECL_SYM("TYPE",871), VVtemp[89]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC45__lambda103,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[46], VVtemp[90], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[47], ECL_SYM("TYPE",871), VVtemp[89]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC46__lambda106,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[47], VVtemp[91], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[92]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LOCATION",1862), VVtemp[93], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[105]); /* NEGATIVE-SHORT-FLOAT-P */ + si_put_sysprop(VV[48], ECL_SYM("INLINE",436), VVtemp[94]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LOCATION",1862), VVtemp[95], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[106]); /* NON-POSITIVE-SHORT-FLOAT-P */ + si_put_sysprop(VV[49], ECL_SYM("INLINE",436), VVtemp[96]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LOCATION",1862), VVtemp[97], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[107]); /* NON-NEGATIVE-SHORT-FLOAT-P */ + si_put_sysprop(VV[50], ECL_SYM("INLINE",436), VVtemp[98]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LOCATION",1862), VVtemp[99], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[108]); /* POSITIVE-SHORT-FLOAT-P */ + si_put_sysprop(VV[51], ECL_SYM("INLINE",436), VVtemp[100]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[52], ECL_SYM("TYPE",871), VVtemp[101]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC51__lambda109,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[52], VVtemp[102], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[53], ECL_SYM("TYPE",871), VVtemp[101]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC52__lambda112,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[53], VVtemp[103], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[54], ECL_SYM("TYPE",871), VVtemp[104]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC53__lambda115,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[54], VVtemp[105], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[55], ECL_SYM("TYPE",871), VVtemp[104]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC54__lambda118,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[55], VVtemp[106], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[107]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[56], ECL_SYM("LOCATION",1862), VVtemp[108], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[56], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[109]); /* NEGATIVE-SINGLE-FLOAT-P */ + si_put_sysprop(VV[56], ECL_SYM("INLINE",436), VVtemp[109]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[57], ECL_SYM("LOCATION",1862), VVtemp[110], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[57], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[110]); /* NON-POSITIVE-SINGLE-FLOAT-P */ + si_put_sysprop(VV[57], ECL_SYM("INLINE",436), VVtemp[111]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[58], ECL_SYM("LOCATION",1862), VVtemp[112], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[58], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[111]); /* NON-NEGATIVE-SINGLE-FLOAT-P */ + si_put_sysprop(VV[58], ECL_SYM("INLINE",436), VVtemp[113]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[59], ECL_SYM("LOCATION",1862), VVtemp[114], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[59], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[112]); /* POSITIVE-SINGLE-FLOAT-P */ + si_put_sysprop(VV[59], ECL_SYM("INLINE",436), VVtemp[115]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[60], ECL_SYM("TYPE",871), VVtemp[116]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC59__lambda121,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[60], VVtemp[117], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[62], ECL_SYM("TYPE",871), VVtemp[116]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC60__lambda124,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[62], VVtemp[118], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[63], ECL_SYM("TYPE",871), VVtemp[119]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC61__lambda127,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[63], VVtemp[120], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[64], ECL_SYM("TYPE",871), VVtemp[119]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC62__lambda130,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[64], VVtemp[121], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[122]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[65], ECL_SYM("LOCATION",1862), VVtemp[123], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[65], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[113]); /* NEGATIVE-DOUBLE-FLOAT-P */ + si_put_sysprop(VV[65], ECL_SYM("INLINE",436), VVtemp[124]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[66], ECL_SYM("LOCATION",1862), VVtemp[125], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[66], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[114]); /* NON-POSITIVE-DOUBLE-FLOAT-P */ + si_put_sysprop(VV[66], ECL_SYM("INLINE",436), VVtemp[126]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[67], ECL_SYM("LOCATION",1862), VVtemp[127], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[67], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[115]); /* NON-NEGATIVE-DOUBLE-FLOAT-P */ + si_put_sysprop(VV[67], ECL_SYM("INLINE",436), VVtemp[128]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[68], ECL_SYM("LOCATION",1862), VVtemp[129], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[68], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[116]); /* POSITIVE-DOUBLE-FLOAT-P */ + si_put_sysprop(VV[68], ECL_SYM("INLINE",436), VVtemp[130]); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[69], ECL_SYM("TYPE",871), VVtemp[131]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC67__lambda133,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[69], VVtemp[132], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[71], ECL_SYM("TYPE",871), VVtemp[131]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC68__lambda136,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[71], VVtemp[133], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[72], ECL_SYM("TYPE",871), VVtemp[134]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC69__lambda139,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[72], VVtemp[135], T0); + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[73], ECL_SYM("TYPE",871), VVtemp[134]) /* SET-DOCUMENTATION */; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC70__lambda142,ECL_NIL,Cblock,1); + T0 = v1; + } + si_do_deftype(3, VV[73], VVtemp[136], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[137]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[74], ECL_SYM("LOCATION",1862), VVtemp[138], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[74], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[117]); /* NEGATIVE-LONG-FLOAT-P */ + si_put_sysprop(VV[74], ECL_SYM("INLINE",436), VVtemp[139]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[75], ECL_SYM("LOCATION",1862), VVtemp[140], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[75], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[118]); /* NON-POSITIVE-LONG-FLOAT-P */ + si_put_sysprop(VV[75], ECL_SYM("INLINE",436), VVtemp[141]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[76], ECL_SYM("LOCATION",1862), VVtemp[142], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[76], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[119]); /* NON-NEGATIVE-LONG-FLOAT-P */ + si_put_sysprop(VV[76], ECL_SYM("INLINE",436), VVtemp[143]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[77], ECL_SYM("LOCATION",1862), VVtemp[144], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[77], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[120]); /* POSITIVE-LONG-FLOAT-P */ + si_put_sysprop(VV[77], ECL_SYM("INLINE",436), VVtemp[145]); + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[78], ECL_SYM("LOCATION",1862), VVtemp[146], VVtemp[147]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[78], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[148]) /* ANNOTATE */; + ecl_cmp_defun(VV[121]); /* OF-TYPE */ + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[78], ECL_SYM("FUNCTION",398), VVtemp[149]) /* SET-DOCUMENTATION */; + { + cl_object T0; + cl_object volatile env0 = ECL_NIL; + { + cl_object volatile v1; + v1 = ecl_make_cfun((cl_objectfn_fixed)LC77__lambda146,ECL_NIL,Cblock,2); + T0 = v1; + } + si_put_sysprop(VV[78], ECL_SYM("COMPILER-MACRO",240), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[78], ECL_SYM("LOCATION",1862), VVtemp[150], VVtemp[151]) /* ANNOTATE */; + } + (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[152]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[80], ECL_SYM("LOCATION",1862), VVtemp[153], VVtemp[154]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[80], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[155]) /* ANNOTATE */; + ecl_cmp_defun(VV[123]); /* TYPE= */ + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[80], ECL_SYM("FUNCTION",398), VVtemp[156]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[80], ECL_SYM("INLINE",436), VVtemp[157]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[81], ECL_SYM("LOCATION",1862), VVtemp[158], VVtemp[159]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[81], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[160]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[124]); /* COERCEF */ + ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[81], ECL_SYM("FUNCTION",398), VVtemp[161]) /* SET-DOCUMENTATION */; +} From 20a46d09127b8f91894e954fc2d626856fb2b11c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:57:41 +0200 Subject: [PATCH 19/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 20a3f89..74615e2 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -23,7 +23,7 @@ stdenv.mkDerivation rec { src = fetchurl { url = "https://common-lisp.net/project/ecl/static/files/release/ecl-${version}.tgz"; - hash = "sha256-5Opluxhh4OSVOGv6i8ZzvQFOltPPnZHpA4+RQ1y+Yis="; + hash = "sha256-LUgrGgpPvV2IFDRRcDInnYCMtkBeIt2R721zNTRGS5k="; }; nativeBuildInputs = [ From 3076a791d832f896f0fd517371c29c2a30c7565b Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 06:58:16 +0200 Subject: [PATCH 20/57] wip --- ecl-cpp.nix | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 74615e2..148288e 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -45,11 +45,11 @@ stdenv.mkDerivation rec { ]; patches = [ - # https://gitlab.com/embeddable-common-lisp/ecl/-/merge_requests/1 - (fetchpatch { - url = "https://raw.githubusercontent.com/sagemath/sage/9.2/build/pkgs/ecl/patches/write_error.patch"; - sha256 = "0hfxacpgn4919hg0mn4wf4m8r7y592r4gw7aqfnva7sckxi6w089"; - }) + # # https://gitlab.com/embeddable-common-lisp/ecl/-/merge_requests/1 + # (fetchpatch { + # url = "https://raw.githubusercontent.com/sagemath/sage/9.2/build/pkgs/ecl/patches/write_error.patch"; + # sha256 = "0hfxacpgn4919hg0mn4wf4m8r7y592r4gw7aqfnva7sckxi6w089"; + # }) ]; configureFlags = [ From 4a7cba42b8d14c392956973281b282c53841d44a Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:01:08 +0200 Subject: [PATCH 21/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 148288e..7c1c8e4 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -19,7 +19,7 @@ stdenv.mkDerivation rec { pname = "ecl"; - version = "16.1.2"; + version = "16.1.3"; src = fetchurl { url = "https://common-lisp.net/project/ecl/static/files/release/ecl-${version}.tgz"; From a9465ff32576c62ea0f1bc5d642069ae1035d293 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:01:35 +0200 Subject: [PATCH 22/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 7c1c8e4..d6f8570 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -23,7 +23,7 @@ stdenv.mkDerivation rec { src = fetchurl { url = "https://common-lisp.net/project/ecl/static/files/release/ecl-${version}.tgz"; - hash = "sha256-LUgrGgpPvV2IFDRRcDInnYCMtkBeIt2R721zNTRGS5k="; + hash = "sha256-dqWFxhbo+oOmtyCTJaMJ2lvAymjgZY85b0mVVjgRElQ="; }; nativeBuildInputs = [ From 1bef0e292af2ce950deb7af7b6f3d8e431efd638 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:05:50 +0200 Subject: [PATCH 23/57] wip --- ecl-cpp.nix | 144 ++++++++++++++++++++++++++-------------------------- shell.nix | 2 +- 2 files changed, 74 insertions(+), 72 deletions(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index d6f8570..8372b36 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -1,94 +1,96 @@ -{ lib -, stdenv -, fetchurl -, fetchpatch -, libtool -, autoconf -, automake -, texinfo -, gmp -, mpfr -, libffi -, makeWrapper -, noUnicode ? false -, gcc -, threadSupport ? true -, useBoehmgc ? false -, boehmgc +{ + stdenv, + fetchurl, + fetchpatch, + libtool, + autoconf, + automake, + gmp, + mpfr, + libffi, + makeWrapper, + noUnicode ? false, + gcc, + threadSupport ? false, + useBoehmgc ? true, + boehmgc, }: -stdenv.mkDerivation rec { - pname = "ecl"; - version = "16.1.3"; +assert useBoehmgc -> boehmgc != null; - src = fetchurl { - url = "https://common-lisp.net/project/ecl/static/files/release/ecl-${version}.tgz"; - hash = "sha256-dqWFxhbo+oOmtyCTJaMJ2lvAymjgZY85b0mVVjgRElQ="; - }; - - nativeBuildInputs = [ +let + s = # Generated upstream information + rec { + baseName = "ecl"; + version = "16.1.2"; + name = "${baseName}-${version}"; + url = "https://common-lisp.net/project/ecl/static/files/release/ecl-16.1.2.tgz"; + sha256 = "16ab8qs3awvdxy8xs8jy82v8r04x4wr70l9l2j45vgag18d2nj1d"; + }; + buildInputs = [ libtool autoconf automake - texinfo makeWrapper ]; - propagatedBuildInputs = [ - libffi - gmp - mpfr - gcc - # replaces ecl's own gc which other packages can depend on, thus propagated - ] ++ lib.optionals useBoehmgc [ - # replaces ecl's own gc which other packages can depend on, thus propagated - boehmgc - ]; + propagatedBuildInputs = + [ + libffi + gmp + mpfr + gcc + ] + ++ stdenv.lib.optionals useBoehmgc [ + # replaces ecl's own gc which other packages can depend on, thus propagated + boehmgc + ]; +in +stdenv.mkDerivation { + inherit (s) name version; + inherit buildInputs propagatedBuildInputs; - patches = [ - # # https://gitlab.com/embeddable-common-lisp/ecl/-/merge_requests/1 - # (fetchpatch { - # url = "https://raw.githubusercontent.com/sagemath/sage/9.2/build/pkgs/ecl/patches/write_error.patch"; - # sha256 = "0hfxacpgn4919hg0mn4wf4m8r7y592r4gw7aqfnva7sckxi6w089"; - # }) - ]; + src = fetchurl { inherit (s) url sha256; }; configureFlags = [ (if threadSupport then "--enable-threads" else "--disable-threads") - "--with-gmp-incdir=${lib.getDev gmp}/include" + "--with-gmp-prefix=${gmp.dev}" "--with-cxx" - "--with-gmp-libdir=${lib.getLib gmp}/lib" - "--with-libffi-incdir=${lib.getDev libffi}/include" - "--with-libffi-libdir=${lib.getLib libffi}/lib" - ] ++ lib.optionals useBoehmgc [ - "--with-libgc-incdir=${lib.getDev boehmgc}/include" - "--with-libgc-libdir=${lib.getLib boehmgc}/lib" - ] ++ lib.optional (!noUnicode) "--enable-unicode"; + "--with-libffi-prefix=${libffi.dev}" + ] ++ (stdenv.lib.optional (!noUnicode) "--enable-unicode"); - hardeningDisable = [ "format" ]; + patches = [ + (fetchpatch { + # Avoid infinite loop, see https://gitlab.com/embeddable-common-lisp/ecl/issues/43 (fixed upstream) + name = "avoid-infinite-loop.patch"; + url = "https://gitlab.com/embeddable-common-lisp/ecl/commit/caba1989f40ef917e7486f41b9cd5c7e3c5c2d79.patch"; + sha256 = "07vw91psbc9gdn8grql46ra8lq3bgkzg5v480chnbryna4sv6lbb"; + }) + (fetchpatch { + # Fix getcwd with long pathnames + # Rebased version of + # https://gitlab.com/embeddable-common-lisp/ecl/commit/ac5f011f57a85a38627af154bc3ee7580e7fecd4.patch + name = "getcwd.patch"; + url = "https://git.sagemath.org/sage.git/plain/build/pkgs/ecl/patches/16.1.2-getcwd.patch?id=07d6c37d18811e2b377a9689790a7c5e24da16ba"; + sha256 = "1fbi8gn7rv8nqff5mpaijsrch3k3z7qc5cn4h1vl8qrr8xwqlqhb"; + }) + ./ecl-1.16.2-libffi-3.3-abi.patch + ]; - # ECL’s ‘make check’ only works after install, making it a de-facto - # installCheck. - # doInstallCheck = true; - doInstallCheck = false; - installCheckTarget = "check"; + hardeningDisable = [ "format" ]; postInstall = '' sed -e 's/@[-a-zA-Z_]*@//g' -i $out/bin/ecl-config - wrapProgram "$out/bin/ecl" --prefix PATH ':' "${ - lib.makeBinPath [ - gcc # for the C compiler - gcc.bintools.bintools # for ar - ] - }" + wrapProgram "$out/bin/ecl" \ + --prefix PATH ':' "${gcc}/bin" \ + --prefix NIX_LDFLAGS ' ' "-L${gmp.lib or gmp.out or gmp}/lib" \ + --prefix NIX_LDFLAGS ' ' "-L${libffi.lib or libffi.out or libffi}/lib" ''; - meta = with lib; { + meta = { + inherit (s) version; description = "Lisp implementation aiming to be small, fast and easy to embed"; - homepage = "https://common-lisp.net/project/ecl/"; - license = licenses.mit; - mainProgram = "ecl"; - maintainers = lib.teams.lisp.members; - platforms = platforms.unix; - changelog = "https://gitlab.com/embeddable-common-lisp/ecl/-/raw/${version}/CHANGELOG"; + license = stdenv.lib.licenses.mit; + maintainers = [ stdenv.lib.maintainers.raskin ]; + platforms = stdenv.lib.platforms.unix; }; } diff --git a/shell.nix b/shell.nix index fecab90..ececd02 100644 --- a/shell.nix +++ b/shell.nix @@ -4,7 +4,7 @@ let -ecl_cpp = pkgs.callPackage ./ecl-cpp.nix {}; + ecl_cpp = pkgs.callPackage ./ecl-cpp.nix { }; in From 748a1469f9da5159f3d33640e3ad154e6d502090 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:06:43 +0200 Subject: [PATCH 24/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 8372b36..ead043b 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -89,7 +89,7 @@ stdenv.mkDerivation { meta = { inherit (s) version; description = "Lisp implementation aiming to be small, fast and easy to embed"; - license = stdenv.lib.licenses.mit; + license = lib.licenses.mit; maintainers = [ stdenv.lib.maintainers.raskin ]; platforms = stdenv.lib.platforms.unix; }; From bbeee218276a3d870ee4d3273a8921b1a72de789 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:07:04 +0200 Subject: [PATCH 25/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index ead043b..d20ee2b 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -89,7 +89,7 @@ stdenv.mkDerivation { meta = { inherit (s) version; description = "Lisp implementation aiming to be small, fast and easy to embed"; - license = lib.licenses.mit; + license = pkgs.lib.licenses.mit; maintainers = [ stdenv.lib.maintainers.raskin ]; platforms = stdenv.lib.platforms.unix; }; From a49a5e09bbf099067bd8c6826788b3273cc6255f Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:07:36 +0200 Subject: [PATCH 26/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index d20ee2b..ead043b 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -89,7 +89,7 @@ stdenv.mkDerivation { meta = { inherit (s) version; description = "Lisp implementation aiming to be small, fast and easy to embed"; - license = pkgs.lib.licenses.mit; + license = lib.licenses.mit; maintainers = [ stdenv.lib.maintainers.raskin ]; platforms = stdenv.lib.platforms.unix; }; From 3c69682e4b716a212df14bbb8e4904fec2a783ac Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:07:52 +0200 Subject: [PATCH 27/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index ead043b..0688b49 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -1,5 +1,5 @@ { - stdenv, + lib, stdenv, fetchurl, fetchpatch, libtool, From fe5582534317b03b091e32fd060b1bd264080c35 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:08:11 +0200 Subject: [PATCH 28/57] wip --- ecl-cpp.nix | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 0688b49..412145e 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -1,5 +1,6 @@ { - lib, stdenv, + lib, + stdenv, fetchurl, fetchpatch, libtool, @@ -90,7 +91,7 @@ stdenv.mkDerivation { inherit (s) version; description = "Lisp implementation aiming to be small, fast and easy to embed"; license = lib.licenses.mit; - maintainers = [ stdenv.lib.maintainers.raskin ]; - platforms = stdenv.lib.platforms.unix; + maintainers = [ lib.maintainers.raskin ]; + platforms = lib.platforms.unix; }; } From 727e73d9f5ecb5fc003f6be02c43e60147ff6a4c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:08:30 +0200 Subject: [PATCH 29/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 412145e..3c03195 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -41,7 +41,7 @@ let mpfr gcc ] - ++ stdenv.lib.optionals useBoehmgc [ + ++ lib.optionals useBoehmgc [ # replaces ecl's own gc which other packages can depend on, thus propagated boehmgc ]; From d72210f934b9f289246c34f16033c7695d107b6c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:08:45 +0200 Subject: [PATCH 30/57] wip --- ecl-cpp.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ecl-cpp.nix b/ecl-cpp.nix index 3c03195..280641f 100644 --- a/ecl-cpp.nix +++ b/ecl-cpp.nix @@ -57,7 +57,7 @@ stdenv.mkDerivation { "--with-gmp-prefix=${gmp.dev}" "--with-cxx" "--with-libffi-prefix=${libffi.dev}" - ] ++ (stdenv.lib.optional (!noUnicode) "--enable-unicode"); + ] ++ (lib.optional (!noUnicode) "--enable-unicode"); patches = [ (fetchpatch { From 481be353ba55879516679583de84fc0c54b5397f Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:09:40 +0200 Subject: [PATCH 31/57] wip --- ecl-1.16.2-libffi-3.3-abi.patch | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 ecl-1.16.2-libffi-3.3-abi.patch diff --git a/ecl-1.16.2-libffi-3.3-abi.patch b/ecl-1.16.2-libffi-3.3-abi.patch new file mode 100644 index 0000000..807687b --- /dev/null +++ b/ecl-1.16.2-libffi-3.3-abi.patch @@ -0,0 +1,15 @@ +diff --git a/src/c/ffi.d b/src/c/ffi.d +index 8861303e..8a959c23 100644 +--- a/src/c/ffi.d ++++ b/src/c/ffi.d +@@ -145,8 +145,8 @@ static struct { + #elif defined(X86_WIN64) + {@':win64', FFI_WIN64}, + #elif defined(X86_ANY) || defined(X86) || defined(X86_64) +- {@':cdecl', FFI_SYSV}, +- {@':sysv', FFI_SYSV}, ++ {@':cdecl', FFI_UNIX64}, ++ {@':sysv', FFI_UNIX64}, + {@':unix64', FFI_UNIX64}, + #endif + }; \ No newline at end of file From 6f2297a1c73902eb3b823d853fe8c13a46b8fdbd Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:14:19 +0200 Subject: [PATCH 32/57] ch --- common/asgl-config/asgl-config.cxx | 69 +- common/early/apx.cxx | 66 +- common/early/cover.cxx | 23 +- common/early/graph-input.cxx | 206 ++-- common/early/graph.cxx | 418 +++----- common/early/package.cxx | 14 +- common/early/utils.cxx | 174 ++- lib/alexandria/arrays.cxx | 19 +- lib/alexandria/binding.cxx | 92 +- lib/alexandria/conditions.cxx | 137 +-- lib/alexandria/control-flow.cxx | 278 +++-- lib/alexandria/definitions.cxx | 124 +-- lib/alexandria/features.cxx | 145 ++- lib/alexandria/functions.cxx | 424 ++++---- lib/alexandria/hash-tables.cxx | 193 ++-- lib/alexandria/io.cxx | 355 +++--- lib/alexandria/lists.cxx | 1604 +++++++++++++--------------- lib/alexandria/macros.cxx | 432 +++----- lib/alexandria/numbers.cxx | 521 ++++----- lib/alexandria/package.cxx | 14 +- lib/alexandria/sequences.cxx | 1065 +++++++++--------- lib/alexandria/strings.cxx | 24 +- lib/alexandria/symbols.cxx | 114 +- lib/alexandria/types.cxx | 1098 +++++++++---------- 24 files changed, 3379 insertions(+), 4230 deletions(-) diff --git a/common/asgl-config/asgl-config.cxx b/common/asgl-config/asgl-config.cxx index e7e4a23..2d8035f 100644 --- a/common/asgl-config/asgl-config.cxx +++ b/common/asgl-config/asgl-config.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:54 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/asgl-config/asgl-config.lisp */ +/* Source: common/asgl-config/asgl-config.lisp */ #include #include "common/asgl-config/asgl-config.eclh" /* function definition for HAVE-GECODE-GIST-HH */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L1have_gecode_gist_hh() { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -39,7 +38,6 @@ v2= res; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L2enable_cover() { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -70,7 +68,6 @@ v2= res; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L3enable_timing() { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -101,7 +98,6 @@ v2= res; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L4enable_logging() { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -132,7 +128,6 @@ v2= res; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L5enable_fobj_leak_checks() { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -164,7 +159,7 @@ v2= res; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclXWUiJ5qKAXSIM_ObCycC71(cl_object flag) +ECL_DLLEXPORT void _eclXWUiJ5qKAXSIM_7re2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -179,44 +174,44 @@ ECL_DLLEXPORT void _eclXWUiJ5qKAXSIM_ObCycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/asgl-config/asgl-config.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/asgl-config/asgl-config.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclXWUiJ5qKAXSIM_ObCycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclXWUiJ5qKAXSIM_7re2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[10])(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; + ecl_function_dispatch(cl_env_copy,VV[10])(10, VVtemp[0], ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; ecl_cmp_defun(VV[11]); /* HAVE-GECODE-GIST-HH */ - if (Null(L1have_gecode_gist_hh())) { goto L9; } - cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[1],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); -L9:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[4], VVtemp[5]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + if (Null(L1have_gecode_gist_hh())) { goto L10; } + cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[1],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); +L10:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[4], VVtemp[5]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; ecl_cmp_defun(VV[12]); /* ENABLE-COVER */ - if (Null(L2enable_cover())) { goto L17; } - cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[3],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); -L17:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + if (Null(L2enable_cover())) { goto L19; } + cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[3],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); +L19:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; ecl_cmp_defun(VV[13]); /* ENABLE-TIMING */ - if (Null(L3enable_timing())) { goto L25; } - cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[5],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); -L25:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + if (Null(L3enable_timing())) { goto L28; } + cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[5],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); +L28:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; ecl_cmp_defun(VV[14]); /* ENABLE-LOGGING */ - if (Null(L4enable_logging())) { goto L33; } - cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[7],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); -L33:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; + if (Null(L4enable_logging())) { goto L37; } + cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[7],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); +L37:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; ecl_cmp_defun(VV[15]); /* ENABLE-FOBJ-LEAK-CHECKS */ - if (Null(L5enable_fobj_leak_checks())) { goto L41; } - cl_set(ECL_SYM("*FEATURES*",36),CONS(VV[9],ecl_symbol_value(ECL_SYM("*FEATURES*",36)))); -L41:; + if (Null(L5enable_fobj_leak_checks())) { goto L46; } + cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[9],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); +L46:; } diff --git a/common/early/apx.cxx b/common/early/apx.cxx index 7f7206f..629a8ba 100644 --- a/common/early/apx.cxx +++ b/common/early/apx.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/early/apx.lisp */ +/* Source: common/early/apx.lisp */ #include #include "common/early/apx.eclh" /* function definition for HASH-TABLE2VECTOR */ @@ -9,7 +9,6 @@ static cl_object L1hash_table2vector(cl_object v1hash, cl_object v2vector) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -30,9 +29,9 @@ L5:; cl_object v9; cl_object v10; value0 = ecl_function_dispatch(cl_env_copy,v6)(0); + v8 = value0; { const int v11 = cl_env_copy->nvalues; - v8 = value0; cl_object v12; v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1]; v9 = v12; @@ -59,8 +58,6 @@ L7:; v9 = v5v; if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = ecl_fixnum(v9); } ecl_aset_unsafe(T0,v8,v4k); @@ -79,7 +76,6 @@ L6:; /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object LC2with_apx_readtable(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -89,7 +85,7 @@ static cl_object LC2with_apx_readtable(cl_object v1, cl_object v2) cl_object v4; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[8])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -98,9 +94,9 @@ L3:; v4 = v5; } if (Null(v4)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[9])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; - value0 = cl_listX(4, ECL_SYM("LET",479), VV[2], VV[3], v3); + value0 = cl_listX(4, ECL_SYM("LET",477), VV[2], VV[3], v3); return value0; } } @@ -110,7 +106,7 @@ L8:; static cl_object L4read_apx_file(cl_object v1pathname) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -124,7 +120,7 @@ L1:; cl_object v4; /* SIZE */ T0 = cl_merge_pathnames(1, v1pathname); T1 = cl_namestring(T0); - T2 = ecl_function_dispatch(cl_env_copy,VV[11])(4, T1, ECL_SYM("BASE-CHAR",122), ECL_SYM("*",20), ECL_NIL) /* COERCE-TO-VECTOR */; + T2 = si_coerce_to_vector(T1, ECL_SYM("BASE-CHAR",120), ECL_SYM("*",18), ECL_NIL); { void* v5; long v6; @@ -135,13 +131,11 @@ v5= slurp_file(T2, &msize); v6= msize; } cl_env_copy->values[0] = ecl_make_pointer(v5); - cl_env_copy->values[1] = ecl_make_long(v6);cl_env_copy->nvalues = 2; + cl_env_copy->values[1] = ecl_make_long(v6);cl_env_copy->nvalues=2; value0 = cl_env_copy->values[0]; } - { - v3 = value0; - v4 = cl_env_copy->values[1]; - } + v3 = value0; + v4 = cl_env_copy->values[1]; { cl_fixnum v5arg_count; { @@ -156,20 +150,18 @@ v6= msize; cl_object v9hash; cl_object env1 = env0; v6 = si_make_pure_array(ECL_T, ecl_make_fixnum(v5arg_count), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - T0 = (ECL_SYM("EQUAL",337)->symbol.gfdef); - v7 = cl_make_hash_table(2, ECL_SYM("TEST",1350), T0); + T0 = (ECL_SYM("EQUAL",335)->symbol.gfdef); + v7 = cl_make_hash_table(2, ECL_SYM("TEST",1321), T0); v8 = si_make_pure_array(ECL_T, ecl_make_fixnum(v5arg_count), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); v9hash = v7; env1 = ECL_NIL; CLV0 = env1 = CONS(v8,env1); /* GRAPH */ { cl_object v10; - v10 = ecl_make_cclosure_va((cl_objectfn)LC3__lambda63,env1,Cblock,2); + v10 = ecl_make_cclosure_va((cl_objectfn)LC3__g31,env1,Cblock); T0 = v10; } { ragel_apx_parse((char*)ecl_to_pointer(v3), ecl_to_long(v4), v9hash, T0); } - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; L1hash_table2vector(v9hash, v6); cl_env_copy->nvalues = 3; cl_env_copy->values[2] = v9hash; @@ -181,9 +173,9 @@ v6= msize; } } } -/* closure LAMBDA63 */ +/* closure G31 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC3__lambda63(cl_narg narg, cl_object v1from, cl_object v2to, ...) +static cl_object LC3__g31(cl_narg narg, cl_object v1from, cl_object v2to, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -195,7 +187,7 @@ static cl_object LC3__lambda63(cl_narg narg, cl_object v1from, cl_object v2to, . if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); { TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[12])(3, ECL_CONS_CAR(CLV0), v1from, v2to) /* ADD-EDGE */; + value0 = ecl_function_dispatch(cl_env_copy,VV[9])(3, ECL_CONS_CAR(CLV0), v1from, v2to) /* ADD-EDGE */; return value0; } } @@ -205,7 +197,7 @@ static cl_object LC3__lambda63(cl_narg narg, cl_object v1from, cl_object v2to, . #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclqMFRzztbaOQJM_7uDycC71(cl_object flag) +ECL_DLLEXPORT void _eclqMFRzztbaOQJM_adf2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -220,23 +212,23 @@ ECL_DLLEXPORT void _eclqMFRzztbaOQJM_7uDycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/apx.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/apx.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclqMFRzztbaOQJM_7uDycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclqMFRzztbaOQJM_adf2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; ecl_cmp_defun(VV[6]); /* HASH-TABLE2VECTOR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; ecl_cmp_defmacro(VV[7]); /* WITH-APX-READTABLE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[10]); /* READ-APX-FILE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[8]); /* READ-APX-FILE */ } diff --git a/common/early/cover.cxx b/common/early/cover.cxx index a8cf57e..2a2fcc3 100644 --- a/common/early/cover.cxx +++ b/common/early/cover.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:54 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/early/cover.lisp */ +/* Source: common/early/cover.lisp */ #include #include "common/early/cover.eclh" /* local function ANNOTATE */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC1annotate(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -19,7 +18,7 @@ static cl_object LC1annotate(cl_object v1, cl_object v2) cl_object v4t_or_nil; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[3])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -28,7 +27,7 @@ L3:; v4t_or_nil = v5; } if (Null(v3)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[4])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; value0 = ECL_NIL; cl_env_copy->nvalues = 1; @@ -41,7 +40,7 @@ L8:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclO8FY5RRFEZrGM_brCycC71(cl_object flag) +ECL_DLLEXPORT void _eclO8FY5RRFEZrGM_M7f2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -56,17 +55,17 @@ ECL_DLLEXPORT void _eclO8FY5RRFEZrGM_brCycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/cover.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/cover.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclO8FY5RRFEZrGM_brCycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclO8FY5RRFEZrGM_M7f2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[1])(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, VVtemp[2], ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; + ecl_function_dispatch(cl_env_copy,VV[1])(10, VVtemp[0], ECL_NIL, ECL_NIL, VVtemp[1], VVtemp[2], ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[4], VVtemp[5]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[4], VVtemp[5]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[6]) /* ANNOTATE */; ecl_cmp_defmacro(VV[2]); /* ANNOTATE */ } diff --git a/common/early/graph-input.cxx b/common/early/graph-input.cxx index bde8de9..ec5a0af 100644 --- a/common/early/graph-input.cxx +++ b/common/early/graph-input.cxx @@ -1,41 +1,38 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/early/graph-input.lisp */ +/* Source: common/early/graph-input.lisp */ #include #include "common/early/graph-input.eclh" -/* local function READ-GRAPH-INPUT */ +/* local function G0 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC1read_graph_input(cl_object v1input) +static cl_object LC1__g0(cl_object v1input) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* READ-APX-FILE */; + value0 = ecl_function_dispatch(cl_env_copy,VV[2])(1, v1input) /* READ-APX-FILE */; return value0; } } -/* local function READ-GRAPH-INPUT */ +/* local function G1 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC2read_graph_input(cl_object v1input) +static cl_object LC2__g1(cl_object v1input) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* READ-APX-FILE */; + value0 = ecl_function_dispatch(cl_env_copy,VV[2])(1, v1input) /* READ-APX-FILE */; return value0; } } -/* local function READ-GRAPH-INPUT */ +/* local function G20 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC3read_graph_input(cl_object v1input) +static cl_object LC3__g20(cl_object v1input) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -46,18 +43,13 @@ static cl_object LC3read_graph_input(cl_object v1input) cl_object v3; cl_object v4; cl_object v5i; - v3 = ecl_function_dispatch(cl_env_copy,VV[4])(1, v1input) /* ORDER */; + v3 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* ORDER */; { cl_object v6; v6 = v3; - { - bool v7; - v7 = ecl_numberp(v6); - if (ecl_unlikely(!(v7))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v6); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + T0 = cl_realp(v6); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v6); v4 = v6; } v5i = ecl_make_fixnum(0); @@ -67,15 +59,13 @@ static cl_object LC3read_graph_input(cl_object v1input) v6 = ecl_list1(ECL_NIL); v7 = v6; L9:; - if (!(ecl_greatereq(v5i,v4))) { goto L11; } + if (!(ecl_number_compare(v5i,v4)>=0)) { goto L11; } goto L10; L11:; { cl_object v8; v8 = v7; if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v8; } v7 = ecl_list1(v5i); @@ -88,8 +78,8 @@ L10:; } } L1:; - T0 = ecl_function_dispatch(cl_env_copy,VV[4])(1, v1input) /* ORDER */; - T1 = cl_make_array(3, T0, ECL_SYM("INITIAL-CONTENTS",1284), v2items); + T0 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* ORDER */; + T1 = cl_make_array(3, T0, ECL_SYM("INITIAL-CONTENTS",1257), v2items); { cl_object v3hash; v3hash = cl_make_hash_table(0); @@ -119,12 +109,11 @@ L35:; } } } -/* local function READ-GRAPH-INPUT */ +/* local function G104 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC4read_graph_input(cl_object v1input) +static cl_object LC4__g104(cl_object v1input) { cl_object T0, T1, T2, T3; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -136,7 +125,7 @@ static cl_object LC4read_graph_input(cl_object v1input) { cl_object v4; if (!(v2==ECL_NIL)) { goto L4; } - ecl_function_dispatch(cl_env_copy,VV[5])(1, v1input) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1input); L4:; { cl_object v5; @@ -148,9 +137,7 @@ L4:; bool v5; v5 = ECL_FIXNUMP(v4); if (ecl_unlikely(!(v5))) - FEwrong_type_argument(ECL_SYM("FIXNUM",374),v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("FIXNUM",372),v4); } v3order = ecl_fixnum(v4); } @@ -171,14 +158,21 @@ L4:; cl_object v9position; T0 = ecl_make_integer((v3order)-1); v8 = ecl_times(ecl_make_fixnum(v3order),T0); - v9position = v8; + { + cl_object v10; + v10 = v8; + T0 = cl_realp(v10); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v10); + v9position = v10; + } { cl_object v10row; v10row = ECL_NIL; - if (!(ecl_greatereq(v7i,ecl_make_fixnum(v3order)))) { goto L20; } - goto L19; + if (!(ecl_number_compare(v7i,ecl_make_fixnum(v3order))>=0)) { goto L22; } + goto L21; +L22:; L20:; -L18:; { cl_object v11; cl_object v12; @@ -188,19 +182,17 @@ L18:; { cl_object v14; v14 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L30; } + if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L32; } v14 = v13; - T0 = ecl_make_bool(ecl_greatereq(v14,ecl_make_fixnum(0))); - goto L27; -L30:; + T0 = ecl_make_bool(ecl_number_compare(v14,ecl_make_fixnum(0))>=0); + goto L29; +L32:; T0 = ECL_NIL; - goto L27; + goto L29; } -L27:; +L29:; if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",887),v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",885),v13); v11 = v13; } { @@ -209,19 +201,17 @@ L27:; { cl_object v14; v14 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L40; } + if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L42; } v14 = v13; - T0 = ecl_make_bool(ecl_greatereq(v14,ecl_make_fixnum(0))); - goto L37; -L40:; + T0 = ecl_make_bool(ecl_number_compare(v14,ecl_make_fixnum(0))>=0); + goto L39; +L42:; T0 = ECL_NIL; - goto L37; + goto L39; } -L37:; +L39:; if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",887),v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",885),v13); v12 = v13; } T0 = cl_ash(ecl_make_fixnum(-1), v11); @@ -233,15 +223,15 @@ L37:; { cl_object v11; v11 = ecl_make_bool(ecl_zerop(v10row)); - if (Null(v11)) { goto L46; } - goto L44; -L46:; - if (!(ecl_eql(v10row,v5))) { goto L48; } + if (Null(v11)) { goto L48; } + goto L46; +L48:; + if (!(ecl_eql(v10row,v5))) { goto L50; } { cl_fixnum v12j; v12j = 0; - goto L52; -L51:; + goto L54; +L53:; { cl_object v13; cl_object v14; @@ -257,8 +247,6 @@ L51:; v17 = v13; if (ecl_unlikely((ecl_fixnum(v17))>=(v15)->vector.dim)) FEwrong_index(ECL_NIL,v15,-1,ecl_make_fixnum(ecl_fixnum(v17)),(v15)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v16 = ecl_fixnum(v17); } T0 = ecl_aref_unsafe(T1,v16); @@ -276,8 +264,6 @@ L51:; v17 = v13; if (ecl_unlikely((ecl_fixnum(v17))>=(v15)->vector.dim)) FEwrong_index(ECL_NIL,v15,-1,ecl_make_fixnum(ecl_fixnum(v17)),(v15)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v16 = ecl_fixnum(v17); } ecl_aset_unsafe(T0,v16,v14); @@ -285,19 +271,19 @@ L51:; } } v12j = (v12j)+1; -L52:; - if (!((v12j)<(v3order))) { goto L70; } - goto L51; -L70:; - goto L44; +L54:; + if (!((v12j)<(v3order))) { goto L72; } + goto L53; +L72:; + goto L46; } -L48:; +L50:; { cl_fixnum v13j; v13j = 0; - goto L74; -L73:; - if (Null(cl_logbitp(ecl_make_fixnum(v13j), v10row))) { goto L76; } + goto L76; +L75:; + if (Null(cl_logbitp(ecl_make_fixnum(v13j), v10row))) { goto L78; } { cl_object v14; cl_object v15; @@ -313,8 +299,6 @@ L73:; v18 = v14; if (ecl_unlikely((ecl_fixnum(v18))>=(v16)->vector.dim)) FEwrong_index(ECL_NIL,v16,-1,ecl_make_fixnum(ecl_fixnum(v18)),(v16)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v17 = ecl_fixnum(v18); } T0 = ecl_aref_unsafe(T1,v17); @@ -332,30 +316,28 @@ L73:; v18 = v14; if (ecl_unlikely((ecl_fixnum(v18))>=(v16)->vector.dim)) FEwrong_index(ECL_NIL,v16,-1,ecl_make_fixnum(ecl_fixnum(v18)),(v16)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v17 = ecl_fixnum(v18); } ecl_aset_unsafe(T0,v17,v15); } } } -L76:; +L78:; v13j = (v13j)+1; -L74:; - if (!((v13j)<(v3order))) { goto L93; } - goto L73; -L93:; +L76:; + if (!((v13j)<(v3order))) { goto L95; } + goto L75; +L95:; } } -L44:; +L46:; v7i = ecl_one_plus(v7i); - if (!(ecl_greatereq(v7i,ecl_make_fixnum(v3order)))) { goto L97; } - goto L19; -L97:; + if (!(ecl_number_compare(v7i,ecl_make_fixnum(v3order))>=0)) { goto L99; } + goto L21; +L99:; v9position = ecl_minus(v9position,ecl_make_fixnum(v3order)); - goto L18; -L19:; + goto L20; +L21:; } } } @@ -370,7 +352,7 @@ L19:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclkTNz1HtborJCM_MODycC71(cl_object flag) +ECL_DLLEXPORT void _eclkTNz1HtborJCM_WNf2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -385,61 +367,57 @@ ECL_DLLEXPORT void _eclkTNz1HtborJCM_MODycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph-input.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph-input.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclkTNz1HtborJCM_MODycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclkTNz1HtborJCM_WNf2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",944)->symbol.gfdef))->cfun.entry(5, VV[0], VV[1], ECL_T, ECL_SYM("LAMBDA-LIST",1000), VVtemp[4]) /* ENSURE-GENERIC-FUNCTION */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",942)->symbol.gfdef))->cfun.entry(5, VV[0], VV[1], ECL_T, ECL_SYM("LAMBDA-LIST",998), VVtemp[4]) /* ENSURE-GENERIC-FUNCTION */; { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC1read_graph_input,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC1__g0,ECL_NIL,Cblock,1); T0 = v1; } - ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[7], VVtemp[4], T0) /* INSTALL-METHOD */; + clos_install_method(6, VV[0], ECL_NIL, VVtemp[7], VVtemp[4], T0, ECL_T); } { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC2read_graph_input,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC2__g1,ECL_NIL,Cblock,1); T0 = v1; } - ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[10], VVtemp[4], T0) /* INSTALL-METHOD */; + clos_install_method(6, VV[0], ECL_NIL, VVtemp[10], VVtemp[4], T0, ECL_T); } { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC3read_graph_input,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC3__g20,ECL_NIL,Cblock,1); T0 = v1; } - ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[13], VVtemp[4], T0) /* INSTALL-METHOD */; + clos_install_method(6, VV[0], ECL_NIL, VVtemp[13], VVtemp[4], T0, ECL_T); } { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC4read_graph_input,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC4__g104,ECL_NIL,Cblock,1); T0 = v1; } - ecl_function_dispatch(cl_env_copy,VV[2])(5, VV[0], ECL_NIL, VVtemp[16], VVtemp[4], T0) /* INSTALL-METHOD */; + clos_install_method(6, VV[0], ECL_NIL, VVtemp[16], VVtemp[4], T0, ECL_T); } } diff --git a/common/early/graph.cxx b/common/early/graph.cxx index 6a3d184..83315da 100644 --- a/common/early/graph.cxx +++ b/common/early/graph.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/early/graph.lisp */ +/* Source: common/early/graph.lisp */ #include #include "common/early/graph.eclh" /* function definition for %%ORDER */ @@ -9,7 +9,6 @@ static cl_object L1__order(cl_object v1graph) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -17,8 +16,6 @@ static cl_object L1__order(cl_object v1graph) T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v1graph) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v1graph); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; value0 = ecl_make_fixnum(ecl_length(v1graph)); cl_env_copy->nvalues = 1; return value0; @@ -29,7 +26,6 @@ static cl_object L1__order(cl_object v1graph) static cl_object L2__parents(cl_object v1graph, cl_object v2node) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -37,15 +33,11 @@ static cl_object L2__parents(cl_object v1graph, cl_object v2node) T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v1graph) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v1graph); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { bool v3; v3 = ECL_FIXNUMP(v2node); if (ecl_unlikely(!(v3))) FEwrong_type_argument(VV[1],v2node); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } { cl_object v3; @@ -58,8 +50,6 @@ static cl_object L2__parents(cl_object v1graph, cl_object v2node) v5 = ecl_fixnum(v2node); if (ecl_unlikely((v5)>=(v3)->vector.dim)) FEwrong_index(ECL_NIL,v3,-1,ecl_make_fixnum(v5),(v3)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v4 = v5; } value0 = ecl_aref_unsafe(T0,v4); @@ -74,7 +64,6 @@ static cl_object L2__parents(cl_object v1graph, cl_object v2node) static cl_object L3_setf___parents_(cl_object v1value, cl_object v2graph, cl_object v3node) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -82,15 +71,11 @@ static cl_object L3_setf___parents_(cl_object v1value, cl_object v2graph, cl_obj T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v2graph) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v2graph); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { bool v4; v4 = ECL_FIXNUMP(v3node); if (ecl_unlikely(!(v4))) FEwrong_type_argument(VV[1],v3node); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } { cl_object v4; @@ -103,8 +88,6 @@ static cl_object L3_setf___parents_(cl_object v1value, cl_object v2graph, cl_obj v6 = ecl_fixnum(v3node); if (ecl_unlikely((v6)>=(v4)->vector.dim)) FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = v6; } value0 = ecl_aset_unsafe(T0,v5,v1value); @@ -119,7 +102,6 @@ static cl_object L3_setf___parents_(cl_object v1value, cl_object v2graph, cl_obj static cl_object LC4do___parents(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -133,7 +115,7 @@ static cl_object LC4do___parents(cl_object v1, cl_object v2) cl_object v8return; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v9; @@ -143,7 +125,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v9; @@ -152,7 +134,7 @@ L10:; v6node = v9; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v9; @@ -172,11 +154,11 @@ L22:; v8return = ECL_NIL; L21:; if (Null(v5)) { goto L27; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L27:; T0 = cl_list(3, v6node, v7parents, v8return); T1 = ecl_append(v3,VV[6]); - value0 = cl_listX(3, ECL_SYM("DOLIST",315), T0, T1); + value0 = cl_listX(3, ECL_SYM("DOLIST",313), T0, T1); return value0; } } @@ -185,7 +167,6 @@ L27:; /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object L5__parents_add(cl_object v1node, cl_object v2parents) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -195,8 +176,6 @@ static cl_object L5__parents_add(cl_object v1node, cl_object v2parents) v3 = ECL_FIXNUMP(v1node); if (ecl_unlikely(!(v3))) FEwrong_type_argument(VV[1],v1node); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } value0 = CONS(v1node,v2parents); cl_env_copy->nvalues = 1; @@ -208,7 +187,6 @@ static cl_object L5__parents_add(cl_object v1node, cl_object v2parents) static cl_object LC6__push_parents(cl_object v1, cl_object v2env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -219,7 +197,7 @@ static cl_object LC6__push_parents(cl_object v1, cl_object v2env) cl_object v5place; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -228,7 +206,7 @@ L3:; v4obj = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -237,7 +215,7 @@ L9:; v5place = v6; } if (Null(v3)) { goto L14; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L14:; { cl_object v7; /* DUMMIES */ @@ -245,21 +223,19 @@ L14:; cl_object v9; /* NEWVAL */ cl_object v10; /* SETTER */ cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v5place, v2env) /* GET-SETF-EXPANSION */; - { - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v5place, v2env) /* GET-SETF-EXPANSION */; + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; { cl_object v12g; v12g = cl_gensym(0); T0 = cl_list(2, v12g, v4obj); { cl_object v13; - v13 = (ECL_SYM("LIST",483)->symbol.gfdef); + v13 = (ECL_SYM("LIST",481)->symbol.gfdef); { cl_object v14; cl_object v15; @@ -268,8 +244,6 @@ L14:; cl_object v16; v16 = v7; if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v15 = v16; } { @@ -280,8 +254,6 @@ L14:; cl_object v18; v18 = v8; if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v17 = v18; } { @@ -298,8 +270,6 @@ L32:; cl_object v20; v20 = ECL_CONS_CDR(v15); if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v15 = v20; } if (!(v17==ECL_NIL)) { goto L40; } @@ -310,16 +280,12 @@ L40:; cl_object v20; v20 = ECL_CONS_CDR(v17); if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v17 = v20; } { cl_object v20; v20 = v19; if (ecl_unlikely(ECL_ATOM(v20))) FEtype_error_cons(v20); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T2 = v20; } T3 = ecl_function_dispatch(cl_env_copy,v13)(2, v14, v16); @@ -341,7 +307,7 @@ L18:; T6 = CONS(T4,T5); T7 = ecl_append(T1,T6); T8 = CONS(T0,T7); - value0 = cl_list(3, ECL_SYM("LET*",480), T8, v10); + value0 = cl_list(3, ECL_SYM("LET*",478), T8, v10); return value0; } } @@ -353,7 +319,6 @@ L18:; static cl_object L7order(cl_object v1graph) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -366,8 +331,6 @@ static cl_object L7order(cl_object v1graph) T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v3) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v3); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v2graph = v3; } value0 = ecl_make_fixnum(ecl_length(v2graph)); @@ -381,14 +344,13 @@ static cl_object L7order(cl_object v1graph) static cl_object L8size(cl_object v1graph) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: - T0 = (ECL_SYM("+",16)->symbol.gfdef); - T1 = (ECL_SYM("LENGTH",478)->symbol.gfdef); - value0 = cl_reduce(4, T0, v1graph, ECL_SYM("KEY",1294), T1); + T0 = (ECL_SYM("+",14)->symbol.gfdef); + T1 = (ECL_SYM("LENGTH",476)->symbol.gfdef); + value0 = cl_reduce(4, T0, v1graph, ECL_SYM("KEY",1267), T1); return value0; } } @@ -397,13 +359,12 @@ static cl_object L8size(cl_object v1graph) static cl_object L9indegrees(cl_object v1graph) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: - T0 = (ECL_SYM("LENGTH",478)->symbol.gfdef); - value0 = cl_map(3, ECL_SYM("VECTOR",900), T0, v1graph); + T0 = (ECL_SYM("LENGTH",476)->symbol.gfdef); + value0 = cl_map(3, ECL_SYM("VECTOR",898), T0, v1graph); return value0; } } @@ -412,7 +373,6 @@ static cl_object L9indegrees(cl_object v1graph) static cl_object LC10do_edges(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -426,7 +386,7 @@ static cl_object LC10do_edges(cl_object v1, cl_object v2) cl_object v8graph; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v9; @@ -436,7 +396,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v9; @@ -445,7 +405,7 @@ L10:; v6from = v9; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v9; @@ -454,7 +414,7 @@ L16:; v7to = v9; } if (!(v5==ECL_NIL)) { goto L22; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L22:; { cl_object v9; @@ -463,10 +423,10 @@ L22:; v8graph = v9; } if (Null(v5)) { goto L27; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L27:; T0 = cl_list(2, v6from, v7to); - T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); value0 = cl_list(3, VV[14], T1, v8graph); return value0; } @@ -477,7 +437,6 @@ L27:; static cl_object LC11do_parents(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -491,7 +450,7 @@ static cl_object LC11do_parents(cl_object v1, cl_object v2) cl_object v8graph; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v9; @@ -501,7 +460,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v9; @@ -510,7 +469,7 @@ L10:; v6node = v9; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v9; @@ -519,7 +478,7 @@ L16:; v7parents = v9; } if (!(v5==ECL_NIL)) { goto L22; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L22:; { cl_object v9; @@ -528,10 +487,10 @@ L22:; v8graph = v9; } if (Null(v5)) { goto L27; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L27:; T0 = cl_list(2, v6node, v7parents); - T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); value0 = cl_list(3, VV[16], T1, v8graph); return value0; } @@ -542,7 +501,6 @@ L27:; static cl_object LC12do_parents_grandparents(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -556,7 +514,7 @@ static cl_object LC12do_parents_grandparents(cl_object v1, cl_object v2) cl_object v8graph; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v9; @@ -566,7 +524,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v9; @@ -575,7 +533,7 @@ L10:; v6node = v9; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v9; @@ -584,7 +542,7 @@ L16:; v7parents_grandparents = v9; } if (!(v5==ECL_NIL)) { goto L22; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L22:; { cl_object v9; @@ -593,10 +551,10 @@ L22:; v8graph = v9; } if (Null(v5)) { goto L27; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L27:; T0 = cl_list(2, v6node, v7parents_grandparents); - T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); value0 = cl_list(3, VV[18], T1, v8graph); return value0; } @@ -606,8 +564,8 @@ L27:; /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object L14outdegrees(cl_object v1graph) { - cl_object T0, T1; - cl_object env0 = ECL_NIL; + cl_object T0, T1, T2; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -615,17 +573,14 @@ static cl_object L14outdegrees(cl_object v1graph) TTL: { cl_object env1 = env0; - { - cl_object v2; - v2 = L7order(v1graph); - T1 = si_make_pure_array(ECL_T, v2, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - T0 = si_fill_array_with_elt(T1, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); - } + T0 = L7order(v1graph); + T1 = si_make_pure_array(ECL_T, T0, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + T2 = si_fill_array_with_elt(T1, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); env1 = ECL_NIL; - CLV0 = env1 = CONS(T0,env1); /* VECTOR */ + CLV0 = env1 = CONS(T2,env1); /* VECTOR */ { cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC13__lambda100,env1,Cblock,2); + v2 = ecl_make_cclosure_va((cl_objectfn)LC13__g84,env1,Cblock); T0 = v2; } L19map_edges(T0, v1graph); @@ -635,9 +590,9 @@ static cl_object L14outdegrees(cl_object v1graph) } } } -/* closure LAMBDA100 */ +/* closure G84 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC13__lambda100(cl_narg narg, cl_object v1from, cl_object v2to, ...) +static cl_object LC13__g84(cl_narg narg, cl_object v1from, cl_object v2to, ...) { cl_object T0, T1; cl_object CLV0; @@ -663,8 +618,6 @@ static cl_object LC13__lambda100(cl_narg narg, cl_object v1from, cl_object v2to, v6 = v1from; if (ecl_unlikely((ecl_fixnum(v6))>=(v4)->vector.dim)) FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(ecl_fixnum(v6)),(v4)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = ecl_fixnum(v6); } T0 = ecl_aref_unsafe(T1,v5); @@ -682,8 +635,6 @@ static cl_object LC13__lambda100(cl_narg narg, cl_object v1from, cl_object v2to, v6 = v1from; if (ecl_unlikely((ecl_fixnum(v6))>=(v4)->vector.dim)) FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(ecl_fixnum(v6)),(v4)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = ecl_fixnum(v6); } value0 = ecl_aset_unsafe(T0,v5,v3); @@ -700,7 +651,6 @@ static cl_object LC13__lambda100(cl_narg narg, cl_object v1from, cl_object v2to, static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -719,8 +669,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v9) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7graph = v9; } { @@ -731,8 +679,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to v10 = ECL_FIXNUMP(v9); if (ecl_unlikely(!(v10))) FEwrong_type_argument(VV[1],v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } v8node = ecl_fixnum(v9); } @@ -747,8 +693,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to v11 = v8node; if (ecl_unlikely((v11)>=(v9)->vector.dim)) FEwrong_index(ECL_NIL,v9,-1,ecl_make_fixnum(v11),(v9)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v10 = v11; } v5 = ecl_aref_unsafe(T0,v10); @@ -763,8 +707,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to v8 = ECL_FIXNUMP(v7); if (ecl_unlikely(!(v8))) FEwrong_type_argument(VV[1],v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } v6node = ecl_fixnum(v7); } @@ -779,8 +721,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v7) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5graph = v7; } { @@ -791,8 +731,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to v8 = ECL_FIXNUMP(v7); if (ecl_unlikely(!(v8))) FEwrong_type_argument(VV[1],v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } v6node = ecl_fixnum(v7); } @@ -807,8 +745,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to v9 = v6node; if (ecl_unlikely((v9)>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(v9),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v9; } value0 = ecl_aset_unsafe(T0,v8,v4); @@ -825,7 +761,6 @@ static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to static cl_object L16make_graph_from_adj(cl_object v1adj) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -860,15 +795,11 @@ L10:; v10 = 0; if (ecl_unlikely((v6)->array.rank != (2))) FEwrong_dimensions(v6,2); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { cl_fixnum v11; v11 = ecl_fixnum(v4i); if (ecl_unlikely((v11)>=(v8dim6))) FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v11),v8dim6); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v10 = (v10)+(v11); } v10 = (v10)*(v9dim7); @@ -877,8 +808,6 @@ L10:; v11 = ecl_fixnum(v5j); if (ecl_unlikely((v11)>=(v9dim7))) FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v11),v9dim7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v10 = (v10)+(v11); } v7 = v10; @@ -891,13 +820,13 @@ L10:; L13:; v5j = ecl_one_plus(v5j); L11:; - if (!(ecl_lower(v5j,ecl_make_fixnum(v2order)))) { goto L35; } + if (!(ecl_number_compare(v5j,ecl_make_fixnum(v2order))<0)) { goto L35; } goto L10; L35:; } v4i = ecl_one_plus(v4i); L6:; - if (!(ecl_lower(v4i,ecl_make_fixnum(v2order)))) { goto L39; } + if (!(ecl_number_compare(v4i,ecl_make_fixnum(v2order))<0)) { goto L39; } goto L5; L39:; } @@ -911,13 +840,12 @@ L39:; /* optimize speed 3, debug 0, space 0, safety 0 */ static cl_object L17map_nodes(cl_object v1fn, cl_object v2graph) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; TTL: { cl_fixnum v3; - v3 = ecl_length(v2graph); + v3 = (v2graph)->vector.fillp; { cl_fixnum v4node; v4node = 0; @@ -940,7 +868,6 @@ L9:; static cl_object LC18do_nodes(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -953,7 +880,7 @@ static cl_object LC18do_nodes(cl_object v1, cl_object v2) cl_object v7graph; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v8; @@ -963,7 +890,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v8; @@ -972,7 +899,7 @@ L10:; v6node = v8; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v8; @@ -981,10 +908,10 @@ L16:; v7graph = v8; } if (Null(v5)) { goto L21; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L21:; T0 = ecl_list1(v6node); - T1 = cl_listX(3, ECL_SYM("LAMBDA",454), T0, v3); + T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); value0 = cl_list(3, VV[22], T1, v7graph); return value0; } @@ -994,14 +921,12 @@ L21:; /* optimize speed 3, debug 0, space 0, safety 0 */ static cl_object L19map_edges(cl_object v1fn, cl_object v2graph) { - cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; TTL: { cl_fixnum v3; - v3 = ecl_length(v2graph); + v3 = (v2graph)->vector.fillp; { cl_fixnum v4i; v4i = 0; @@ -1009,42 +934,25 @@ static cl_object L19map_edges(cl_object v1fn, cl_object v2graph) L3:; { cl_object v5; - { - cl_object v6; - v6 = v2graph; - T0 = v6; - { - cl_fixnum v7; - { - cl_fixnum v8; - v8 = v4i; - if (ecl_unlikely((v8)>=(v6)->vector.dim)) - FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v8),(v6)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - v7 = v8; - } - v5 = ecl_aref_unsafe(T0,v7); - } - } - goto L15; -L14:; + v5 = ecl_aref_unsafe(v2graph,v4i); + goto L10; +L9:; { cl_object v6j; v6j = _ecl_car(v5); ecl_function_dispatch(cl_env_copy,v1fn)(2, v6j, ecl_make_fixnum(v4i)); } v5 = _ecl_cdr(v5); -L15:; - if (Null(v5)) { goto L22; } - goto L14; -L22:; +L10:; + if (Null(v5)) { goto L17; } + goto L9; +L17:; } v4i = (v4i)+1; L4:; - if (!((v4i)<(v3))) { goto L26; } + if (!((v4i)<(v3))) { goto L21; } goto L3; -L26:; +L21:; value0 = ECL_NIL; cl_env_copy->nvalues = 1; return value0; @@ -1056,7 +964,7 @@ L26:; static cl_object L21map_parents(cl_object v1fn, cl_object v2graph) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1066,16 +974,16 @@ static cl_object L21map_parents(cl_object v1fn, cl_object v2graph) CLV1 = env0 = CONS(v2graph,env0); /* GRAPH */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC20__lambda190,env0,Cblock,1); + v3 = ecl_make_cclosure_va((cl_objectfn)LC20__g158,env0,Cblock); T0 = v3; } value0 = L17map_nodes(T0, ECL_CONS_CAR(CLV1)); return value0; } } -/* closure LAMBDA190 */ +/* closure G158 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC20__lambda190(cl_narg narg, cl_object v1node, ...) +static cl_object LC20__g158(cl_narg narg, cl_object v1node, ...) { cl_object T0, T1; cl_object CLV0, CLV1; @@ -1098,8 +1006,6 @@ static cl_object LC20__lambda190(cl_narg narg, cl_object v1node, ...) T1 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v4) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T1)!=ECL_NIL))) FEwrong_type_argument(VV[0],v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v2graph = v4; } { @@ -1110,8 +1016,6 @@ static cl_object LC20__lambda190(cl_narg narg, cl_object v1node, ...) v5 = ECL_FIXNUMP(v4); if (ecl_unlikely(!(v5))) FEwrong_type_argument(VV[1],v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } v3node = ecl_fixnum(v4); } @@ -1126,8 +1030,6 @@ static cl_object LC20__lambda190(cl_narg narg, cl_object v1node, ...) v6 = v3node; if (ecl_unlikely((v6)>=(v4)->vector.dim)) FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = v6; } T0 = ecl_aref_unsafe(T1,v5); @@ -1144,7 +1046,7 @@ static cl_object LC20__lambda190(cl_narg narg, cl_object v1node, ...) static cl_object L24map_parents_grandparents(cl_object v1fn, cl_object v2graph) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1154,16 +1056,16 @@ static cl_object L24map_parents_grandparents(cl_object v1fn, cl_object v2graph) CLV1 = env0 = CONS(v2graph,env0); /* GRAPH */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC23__lambda193,env0,Cblock,2); + v3 = ecl_make_cclosure_va((cl_objectfn)LC23__g161,env0,Cblock); T0 = v3; } value0 = L21map_parents(T0, ECL_CONS_CAR(CLV1)); return value0; } } -/* closure LAMBDA193 */ +/* closure G161 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC23__lambda193(cl_narg narg, cl_object v1node, cl_object v2parents, ...) +static cl_object LC23__g161(cl_narg narg, cl_object v1node, cl_object v2parents, ...) { cl_object T0, T1, T2; cl_object CLV0, CLV1; @@ -1179,7 +1081,7 @@ static cl_object LC23__lambda193(cl_narg narg, cl_object v1node, cl_object v2par TTL: { cl_object v3; - v3 = (ECL_SYM("CONS",253)->symbol.gfdef); + v3 = (ECL_SYM("CONS",251)->symbol.gfdef); { cl_object v4; cl_object v5; @@ -1188,8 +1090,6 @@ static cl_object LC23__lambda193(cl_narg narg, cl_object v1node, cl_object v2par cl_object v6; v6 = v2parents; if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = v6; } { @@ -1200,7 +1100,7 @@ static cl_object LC23__lambda193(cl_narg narg, cl_object v1node, cl_object v2par cl_object v9; { cl_object v10; - v10 = ecl_make_cclosure_va((cl_objectfn)LC22__lambda210,env0,Cblock,1); + v10 = ecl_make_cclosure_va((cl_objectfn)LC22__g178,env0,Cblock); v9 = v10; } { @@ -1211,8 +1111,6 @@ static cl_object LC23__lambda193(cl_narg narg, cl_object v1node, cl_object v2par cl_object v12; v12 = v2parents; if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v12; } { @@ -1229,16 +1127,12 @@ L17:; cl_object v14; v14 = ECL_CONS_CDR(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v14; } T2 = ecl_function_dispatch(cl_env_copy,v9)(1, v10); @@ -1257,8 +1151,6 @@ L7:; cl_object v9; v9 = v6; if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v9; } { @@ -1275,8 +1167,6 @@ L41:; cl_object v11; v11 = ECL_CONS_CDR(v5); if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = v11; } if (!(v8==ECL_NIL)) { goto L49; } @@ -1287,16 +1177,12 @@ L49:; cl_object v11; v11 = ECL_CONS_CDR(v8); if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v11; } { cl_object v11; v11 = v10; if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v11; } T2 = ecl_function_dispatch(cl_env_copy,v3)(2, v4, v7); @@ -1316,9 +1202,9 @@ L1:; } } } -/* closure LAMBDA210 */ +/* closure G178 */ /* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC22__lambda210(cl_narg narg, cl_object v1parent, ...) +static cl_object LC22__g178(cl_narg narg, cl_object v1parent, ...) { cl_object T0; cl_object CLV0, CLV1; @@ -1341,8 +1227,6 @@ static cl_object LC22__lambda210(cl_narg narg, cl_object v1parent, ...) T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v4) /* SIMPLE-ARRAY-P */; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[0],v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v2graph = v4; } { @@ -1353,8 +1237,6 @@ static cl_object LC22__lambda210(cl_narg narg, cl_object v1parent, ...) v5 = ECL_FIXNUMP(v4); if (ecl_unlikely(!(v5))) FEwrong_type_argument(VV[1],v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; } v3node = ecl_fixnum(v4); } @@ -1369,8 +1251,6 @@ static cl_object LC22__lambda210(cl_narg narg, cl_object v1parent, ...) v6 = v3node; if (ecl_unlikely((v6)>=(v4)->vector.dim)) FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = v6; } value0 = ecl_aref_unsafe(T0,v5); @@ -1387,7 +1267,7 @@ static cl_object LC22__lambda210(cl_narg narg, cl_object v1parent, ...) #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclLTqb7ItxYx5DM_HeDycC71(cl_object flag) +ECL_DLLEXPORT void _eclLTqb7ItxYx5DM_hNf2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1402,84 +1282,80 @@ ECL_DLLEXPORT void _eclLTqb7ItxYx5DM_HeDycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclLTqb7ItxYx5DM_HeDycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclLTqb7ItxYx5DM_hNf2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - si_do_deftype(3, VV[0], VVtemp[2], ECL_SYM("SIMPLE-ARRAY",765)); - si_do_deftype(3, VV[1], VVtemp[3], ECL_SYM("FIXNUM",374)); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[4]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + si_do_deftype(3, VV[0], VVtemp[2], ECL_SYM("SIMPLE-ARRAY",763)); + si_do_deftype(3, VV[1], VVtemp[3], ECL_SYM("FIXNUM",372)); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[4]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; ecl_cmp_defun(VV[24]); /* %%ORDER */ - si_put_sysprop(VV[2], ECL_SYM("INLINE",436), VVtemp[8]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; ecl_cmp_defun(VV[26]); /* %%PARENTS */ - si_put_sysprop(VV[3], ECL_SYM("INLINE",436), VVtemp[12]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[13], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[11], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; ecl_cmp_defun(VV[27]); /* (SETF %%PARENTS) */ - si_put_sysprop(VV[4], ECL_SYM("INLINE",436), VVtemp[17]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[17]) /* ANNOTATE */; ecl_cmp_defmacro(VV[28]); /* DO-%%PARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[21], VVtemp[22]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[23]) /* ANNOTATE */; - ecl_cmp_defun(VV[31]); /* %%PARENTS-ADD */ - si_put_sysprop(VV[7], ECL_SYM("INLINE",436), VVtemp[24]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[27]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[32]); /* %%PUSH-PARENTS */ - si_do_deftype(3, VV[9], VVtemp[28], ECL_SYM("SIMPLE-ARRAY",765)); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[33]); /* ORDER */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[34]); /* SIZE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[35]); /* INDEGREES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[35], VVtemp[36]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[37]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[36]); /* DO-EDGES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[38], VVtemp[39]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[40]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[37]); /* DO-PARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[38]); /* DO-PARENTS-GRANDPARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[19], ECL_SYM("LOCATION",1862), VVtemp[44], VVtemp[45]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[19], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[39]); /* OUTDEGREES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[46], VVtemp[47]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[48]) /* ANNOTATE */; - ecl_cmp_defun(VV[40]); /* ADD-EDGE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LOCATION",1862), VVtemp[49], VVtemp[50]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[51]) /* ANNOTATE */; - ecl_cmp_defun(VV[41]); /* MAKE-GRAPH-FROM-ADJ */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[52], VVtemp[53]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; - ecl_cmp_defun(VV[42]); /* MAP-NODES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[55], VVtemp[56]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[57]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[43]); /* DO-NODES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[58], VVtemp[59]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* MAP-EDGES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; - ecl_cmp_defun(VV[45]); /* MAP-PARENTS */ - ecl_function_dispatch(cl_env_copy,VV[46])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[62]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LOCATION",1862), VVtemp[63], VVtemp[64]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[54]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* MAP-PARENTS-GRANDPARENTS */ - ecl_function_dispatch(cl_env_copy,VV[46])(3, VV[18], ECL_SYM("FUNCTION",398), VVtemp[65]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defun(VV[29]); /* %%PARENTS-ADD */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[30]); /* %%PUSH-PARENTS */ + si_do_deftype(3, VV[9], VVtemp[24], ECL_SYM("SIMPLE-ARRAY",763)); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[31]); /* ORDER */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[32]); /* SIZE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[29], VVtemp[30]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[33]); /* INDEGREES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[34]); /* DO-EDGES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[34], VVtemp[35]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[36]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[35]); /* DO-PARENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[37], VVtemp[38]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[39]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[36]); /* DO-PARENTS-GRANDPARENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LOCATION",1777), VVtemp[40], VVtemp[41]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[37]); /* OUTDEGREES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[43]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[44]) /* ANNOTATE */; + ecl_cmp_defun(VV[38]); /* ADD-EDGE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[45], VVtemp[46]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[47]) /* ANNOTATE */; + ecl_cmp_defun(VV[39]); /* MAKE-GRAPH-FROM-ADJ */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[48], VVtemp[49]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; + ecl_cmp_defun(VV[40]); /* MAP-NODES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[51], VVtemp[52]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[53]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[41]); /* DO-NODES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[54], VVtemp[55]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; + ecl_cmp_defun(VV[42]); /* MAP-EDGES */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[56], VVtemp[57]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; + ecl_cmp_defun(VV[43]); /* MAP-PARENTS */ + si_set_documentation(3, VV[16], ECL_SYM("FUNCTION",396), VVtemp[58]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LOCATION",1777), VVtemp[59], VVtemp[60]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* MAP-PARENTS-GRANDPARENTS */ + si_set_documentation(3, VV[18], ECL_SYM("FUNCTION",396), VVtemp[61]); } diff --git a/common/early/package.cxx b/common/early/package.cxx index 083c88f..960a194 100644 --- a/common/early/package.cxx +++ b/common/early/package.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/early/package.lisp */ +/* Source: common/early/package.lisp */ #include #include "common/early/package.eclh" @@ -9,7 +9,7 @@ #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclhQzNQYq3zy1HM_f7DycC71(cl_object flag) +ECL_DLLEXPORT void _eclhQzNQYq3zy1HM_J7f2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -24,13 +24,13 @@ ECL_DLLEXPORT void _eclhQzNQYq3zy1HM_f7DycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/package.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/package.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclhQzNQYq3zy1HM_f7DycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclhQzNQYq3zy1HM_J7f2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[0])(12, VVtemp[0], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; + ecl_function_dispatch(cl_env_copy,VV[0])(10, VVtemp[0], ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; } diff --git a/common/early/utils.cxx b/common/early/utils.cxx index 12b13d9..761a445 100644 --- a/common/early/utils.cxx +++ b/common/early/utils.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/common/early/utils.lisp */ +/* Source: common/early/utils.lisp */ #include #include "common/early/utils.eclh" /* function definition for COMPONENT-PRESENT-P */ /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object L1component_present_p(cl_object v1value) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -16,7 +15,7 @@ static cl_object L1component_present_p(cl_object v1value) if (Null(v1value)) { goto L2; } { bool v2; - v2 = ecl_eql(v1value,ECL_SYM("UNSPECIFIC",1354)); + v2 = ecl_eql(v1value,ECL_SYM("UNSPECIFIC",1324)); value0 = (v2)?ECL_NIL:ECL_T; cl_env_copy->nvalues = 1; return value0; @@ -32,7 +31,6 @@ L2:; static cl_object L2directory_pathname_p(cl_object v1pathspec) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -55,7 +53,6 @@ L2:; static cl_object L3asgl_home() { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -97,7 +94,6 @@ L8:; static cl_object LC4aif(cl_object v1, cl_object v2) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -109,7 +105,7 @@ static cl_object LC4aif(cl_object v1, cl_object v2) cl_object v6else; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v7; @@ -118,7 +114,7 @@ L3:; v4test = v7; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v7; @@ -138,12 +134,12 @@ L15:; v6else = ECL_NIL; L14:; if (Null(v3)) { goto L20; } - ecl_function_dispatch(cl_env_copy,VV[41])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L20:; T0 = cl_list(2, VV[7], v4test); T1 = ecl_list1(T0); - T2 = cl_list(4, ECL_SYM("IF",948), VV[7], v5then, v6else); - value0 = cl_list(3, ECL_SYM("LET",479), T1, T2); + T2 = cl_list(4, ECL_SYM("IF",946), VV[7], v5then, v6else); + value0 = cl_list(3, ECL_SYM("LET",477), T1, T2); return value0; } } @@ -152,7 +148,6 @@ L20:; /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object LC5with_timing(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -162,7 +157,7 @@ static cl_object LC5with_timing(cl_object v1, cl_object v2) cl_object v4form; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -171,7 +166,7 @@ L3:; v4form = v5; } if (Null(v3)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[41])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; value0 = v4form; cl_env_copy->nvalues = 1; @@ -183,7 +178,6 @@ L8:; /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object LC6log_(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -193,7 +187,7 @@ static cl_object LC6log_(cl_object v1, cl_object v2) cl_object v4level; v3 = ECL_CONS_CDR(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[40])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -209,7 +203,7 @@ L3:; v6 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v5)||ECL_BIGNUMP(v5))) { goto L14; } v6 = v5; - if (ecl_greatereq(v6,ecl_make_fixnum(0))) { goto L10; } + if (ecl_number_compare(v6,ecl_make_fixnum(0))>=0) { goto L10; } goto L11; L14:; goto L11; @@ -229,7 +223,6 @@ L10:; static cl_object L7print_error_log(cl_object v1eout, cl_object v2e) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -242,7 +235,7 @@ static cl_object L7print_error_log(cl_object v1eout, cl_object v2e) T0 = si_ihs_top(); v3x = ecl_minus(T0,ecl_make_fixnum(2)); L6:; - if (!(ecl_lower(v3x,ecl_make_fixnum(1)))) { goto L8; } + if (!(ecl_number_compare(v3x,ecl_make_fixnum(1))<0)) { goto L8; } goto L7; L8:; T0 = si_ihs_fun(v3x); @@ -251,7 +244,7 @@ L8:; { cl_object v4env; T0 = si_ihs_env(v3x); - v4env = ecl_function_dispatch(cl_env_copy,VV[45])(1, T0) /* DECODE-IHS-ENV */; + v4env = ecl_function_dispatch(cl_env_copy,VV[42])(1, T0) /* DECODE-IHS-ENV */; { cl_object v5; v5 = v4env; @@ -285,14 +278,13 @@ L7:; static cl_object L9requires_compile_p(cl_object v1source_file) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: { cl_object v2fasl_file; - T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(1, v1source_file) /* COMPILE-FILE-PATHNAME */; + T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",235)->symbol.gfdef))->cfun.entry(1, v1source_file) /* COMPILE-FILE-PATHNAME */; v2fasl_file = cl_probe_file(T0); value0 = Null(v2fasl_file)?ECL_T:ECL_NIL; if ((value0)!=ECL_NIL) { goto L3; } @@ -309,14 +301,13 @@ L3:; static cl_object LC8file_newer_p(cl_object v1new_file, cl_object v2old_file) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: T0 = cl_file_write_date(v1new_file); T1 = cl_file_write_date(v2old_file); - value0 = ecl_make_bool(ecl_greater(T0,T1)); + value0 = ecl_make_bool(ecl_number_compare(T0,T1)>0); cl_env_copy->nvalues = 1; return value0; } @@ -326,19 +317,18 @@ static cl_object LC8file_newer_p(cl_object v1new_file, cl_object v2old_file) static cl_object L10compile_file_if_needed(cl_object v1filename, cl_object v2loadp) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: if (Null(L9requires_compile_p(v1filename))) { goto L1; } - (cl_env_copy->function=(ECL_SYM("COMPILE-FILE",236)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE */; + (cl_env_copy->function=(ECL_SYM("COMPILE-FILE",234)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE */; L1:; if (Null(v2loadp)) { goto L3; } - T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; + T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",235)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; cl_load(1, T0); L3:; - value0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",237)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; + value0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",235)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; return value0; } } @@ -347,12 +337,11 @@ L3:; static cl_object L11mean(cl_object v1sequence) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { TTL: - T0 = (ECL_SYM("+",16)->symbol.gfdef); + T0 = (ECL_SYM("+",14)->symbol.gfdef); T1 = cl_reduce(2, T0, v1sequence); { cl_fixnum v2; @@ -367,7 +356,6 @@ static cl_object L11mean(cl_object v1sequence) /* optimize speed 3, debug 0, space 0, safety 1 */ static cl_object L12median(cl_object v1sequence) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -381,7 +369,6 @@ static cl_object L12median(cl_object v1sequence) static cl_object L13percentile(cl_object v1sequence, cl_object v2percent) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -392,9 +379,9 @@ static cl_object L13percentile(cl_object v1sequence, cl_object v2percent) cl_object v5k; cl_object v6floor_k; T0 = ecl_copy_seq(v1sequence); - T1 = (ECL_SYM("<",74)->symbol.gfdef); + T1 = (ECL_SYM("<",72)->symbol.gfdef); T2 = cl_sort(2, T0, T1); - v3sorted_vect = ecl_function_dispatch(cl_env_copy,VV[51])(4, T2, ECL_T, ECL_SYM("*",20), ECL_T) /* COERCE-TO-VECTOR */; + v3sorted_vect = si_coerce_to_vector(T2, ECL_T, ECL_SYM("*",18), ECL_T); v4n = (v3sorted_vect)->vector.fillp; T0 = ecl_divide(v2percent,ecl_make_fixnum(100)); v5k = ecl_times(ecl_make_fixnum(v4n),T0); @@ -411,8 +398,6 @@ static cl_object L13percentile(cl_object v1sequence, cl_object v2percent) v9 = v5k; if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = ecl_fixnum(v9); } T0 = ecl_aref_unsafe(T1,v8); @@ -429,8 +414,6 @@ static cl_object L13percentile(cl_object v1sequence, cl_object v2percent) v9 = ecl_one_minus(v5k); if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = ecl_fixnum(v9); } T1 = ecl_aref_unsafe(T2,v8); @@ -452,8 +435,6 @@ L6:; v9 = v6floor_k; if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = ecl_fixnum(v9); } value0 = ecl_aref_unsafe(T0,v8); @@ -469,7 +450,6 @@ L6:; static cl_object L14summary(cl_object v1sequence) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; { @@ -479,7 +459,7 @@ static cl_object L14summary(cl_object v1sequence) v2 = ecl_length(v1sequence); if (!((v2)<(1000))) { goto L1; } } - T0 = (ECL_SYM("MIN",559)->symbol.gfdef); + T0 = (ECL_SYM("MIN",557)->symbol.gfdef); T1 = cl_reduce(2, T0, v1sequence); T2 = L13percentile(v1sequence, ecl_make_fixnum(25)); T3 = cl_format(3, ECL_NIL, VV[30], T2); @@ -489,16 +469,16 @@ static cl_object L14summary(cl_object v1sequence) T7 = cl_format(3, ECL_NIL, VV[30], T6); T8 = L13percentile(v1sequence, ecl_make_fixnum(75)); T9 = cl_format(3, ECL_NIL, VV[30], T8); - T10 = (ECL_SYM("MAX",553)->symbol.gfdef); + T10 = (ECL_SYM("MAX",551)->symbol.gfdef); T11 = cl_reduce(2, T10, v1sequence); value0 = cl_list(12, VV[28], T1, VV[29], T3, VV[31], T5, VV[32], T7, VV[33], T9, VV[34], T11); return value0; L1:; - T0 = (ECL_SYM("MIN",559)->symbol.gfdef); + T0 = (ECL_SYM("MIN",557)->symbol.gfdef); T1 = cl_reduce(2, T0, v1sequence); T2 = L11mean(v1sequence); T3 = cl_format(3, ECL_NIL, VV[30], T2); - T4 = (ECL_SYM("MAX",553)->symbol.gfdef); + T4 = (ECL_SYM("MAX",551)->symbol.gfdef); T5 = cl_reduce(2, T4, v1sequence); value0 = cl_list(6, VV[28], T1, VV[32], T3, VV[34], T5); return value0; @@ -509,7 +489,7 @@ L1:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclb840kDV4LgEAM_JODycC71(cl_object flag) +ECL_DLLEXPORT void _eclb840kDV4LgEAM_N7f2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -524,66 +504,66 @@ ECL_DLLEXPORT void _eclb840kDV4LgEAM_JODycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/utils.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/utils.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclb840kDV4LgEAM_JODycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclb840kDV4LgEAM_N7f2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; ecl_cmp_defun(VV[35]); /* COMPONENT-PRESENT-P */ - ecl_function_dispatch(cl_env_copy,VV[36])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[37]); /* DIRECTORY-PATHNAME-P */ - ecl_function_dispatch(cl_env_copy,VV[36])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[9]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[38]); /* ASGL-HOME */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[39]); /* AIF */ + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[36]); /* DIRECTORY-PATHNAME-P */ + si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[9]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; + ecl_cmp_defun(VV[37]); /* ASGL-HOME */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[38]); /* AIF */ si_Xmake_special(VV[8]); - if (ECL_SYM_VAL(cl_env_copy,VV[8])!=OBJNULL) { goto L27; } + if (ecl_boundp(cl_env_copy,VV[8])) { goto L30; } cl_set(VV[8],ECL_NIL); -L27:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[17], VVtemp[18]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[19]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[42]); /* WITH-TIMING */ +L30:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[17], VVtemp[18]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[19]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[39]); /* WITH-TIMING */ si_Xmake_special(VV[10]); - if (ECL_SYM_VAL(cl_env_copy,VV[10])!=OBJNULL) { goto L40; } + if (ecl_boundp(cl_env_copy,VV[10])) { goto L43; } cl_set(VV[10],ECL_NIL); -L40:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; +L43:; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; si_do_deftype(3, VV[11], VVtemp[22], VVtemp[23]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[43]); /* LOG* */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* PRINT-ERROR-LOG */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[30], VVtemp[31]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; - ecl_cmp_defun(VV[46]); /* REQUIRES-COMPILE-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* COMPILE-FILE-IF-NEEDED */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LOCATION",1862), VVtemp[36], VVtemp[37]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[38]) /* ANNOTATE */; - ecl_cmp_defun(VV[48]); /* MEAN */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[40]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[38]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* MEDIAN */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[50]); /* PERCENTILE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LOCATION",1862), VVtemp[44], VVtemp[45]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[38]) /* ANNOTATE */; - ecl_cmp_defun(VV[52]); /* SUMMARY */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[40]); /* LOG* */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defun(VV[41]); /* PRINT-ERROR-LOG */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[31]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[32]) /* ANNOTATE */; + ecl_cmp_defun(VV[43]); /* REQUIRES-COMPILE-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[35]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* COMPILE-FILE-IF-NEEDED */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LOCATION",1777), VVtemp[36], VVtemp[37]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[38]) /* ANNOTATE */; + ecl_cmp_defun(VV[45]); /* MEAN */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[39], VVtemp[40]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[38]) /* ANNOTATE */; + ecl_cmp_defun(VV[46]); /* MEDIAN */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[41], VVtemp[42]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* PERCENTILE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LOCATION",1777), VVtemp[44], VVtemp[45]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[38]) /* ANNOTATE */; + ecl_cmp_defun(VV[48]); /* SUMMARY */ } diff --git a/lib/alexandria/arrays.cxx b/lib/alexandria/arrays.cxx index f397be0..4b5bfe7 100644 --- a/lib/alexandria/arrays.cxx +++ b/lib/alexandria/arrays.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/arrays.lisp */ +/* Source: lib/alexandria/arrays.lisp */ #include #include "lib/alexandria/arrays.eclh" /* function definition for COPY-ARRAY */ @@ -9,7 +9,6 @@ static cl_object L1copy_array(cl_narg narg, cl_object v1array, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -78,7 +77,7 @@ L18:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecl6zVmPLti1MIGM_KoHycC71(cl_object flag) +ECL_DLLEXPORT void _ecl6zVmPLti1MIGM_syh2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -93,17 +92,17 @@ ECL_DLLEXPORT void _ecl6zVmPLti1MIGM_KoHycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/arrays.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/arrays.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl6zVmPLti1MIGM_KoHycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl6zVmPLti1MIGM_syh2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defun(VV[1]); /* COPY-ARRAY */ - ecl_function_dispatch(cl_env_copy,VV[2])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); } diff --git a/lib/alexandria/binding.cxx b/lib/alexandria/binding.cxx index 4a91397..5db590c 100644 --- a/lib/alexandria/binding.cxx +++ b/lib/alexandria/binding.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/binding.lisp */ +/* Source: lib/alexandria/binding.lisp */ #include #include "lib/alexandria/binding.eclh" /* local function IF-LET */ @@ -9,7 +9,6 @@ static cl_object LC1if_let(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -23,7 +22,7 @@ static cl_object LC1if_let(cl_object v1, cl_object v2) cl_object v7else_form; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v8; @@ -33,7 +32,7 @@ L3:; } v5 = v3; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v8; @@ -53,7 +52,7 @@ L16:; v7else_form = ECL_NIL; L15:; if (Null(v5)) { goto L21; } - ecl_function_dispatch(cl_env_copy,VV[6])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L21:; { cl_object v8binding_list; @@ -68,7 +67,7 @@ L24:; L23:; { cl_object v10; - v10 = (ECL_SYM("CAR",182)->symbol.gfdef); + v10 = (ECL_SYM("CAR",180)->symbol.gfdef); { cl_object v11; cl_object v12; @@ -77,8 +76,6 @@ L23:; cl_object v13; v13 = v8binding_list; if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v12 = v13; } { @@ -90,21 +87,17 @@ L35:; if (!(ecl_endp(v12))) { goto L37; } goto L36; L37:; - v11 = ECL_CONS_CAR(v12); + v11 = _ecl_car(v12); { cl_object v15; - v15 = ECL_CONS_CDR(v12); + v15 = _ecl_cdr(v12); if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v12 = v15; } { cl_object v15; v15 = v14; if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v15; } T1 = ecl_function_dispatch(cl_env_copy,v10)(1, v11); @@ -118,9 +111,9 @@ L36:; } } L27:; - T0 = CONS(ECL_SYM("AND",89),v9variables); - T1 = cl_list(4, ECL_SYM("IF",948), T0, v6then_form, v7else_form); - value0 = cl_list(3, ECL_SYM("LET",479), v8binding_list, T1); + T0 = CONS(ECL_SYM("AND",87),v9variables); + T1 = cl_list(4, ECL_SYM("IF",946), T0, v6then_form, v7else_form); + value0 = cl_list(3, ECL_SYM("LET",477), v8binding_list, T1); return value0; } } @@ -131,7 +124,6 @@ L27:; static cl_object LC2when_let(cl_object v1, cl_object v2) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -142,7 +134,7 @@ static cl_object LC2when_let(cl_object v1, cl_object v2) cl_object v4bindings; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -163,7 +155,7 @@ L9:; L8:; { cl_object v7; - v7 = (ECL_SYM("CAR",182)->symbol.gfdef); + v7 = (ECL_SYM("CAR",180)->symbol.gfdef); { cl_object v8; cl_object v9; @@ -172,8 +164,6 @@ L8:; cl_object v10; v10 = v5binding_list; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -185,21 +175,17 @@ L20:; if (!(ecl_endp(v9))) { goto L22; } goto L21; L22:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v12; - v12 = ECL_CONS_CDR(v9); + v12 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v12; } { cl_object v12; v12 = v11; if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v12; } T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); @@ -213,9 +199,9 @@ L21:; } } L12:; - T0 = CONS(ECL_SYM("AND",89),v6variables); - T1 = cl_listX(3, ECL_SYM("WHEN",907), T0, v3); - value0 = cl_list(3, ECL_SYM("LET",479), v5binding_list, T1); + T0 = CONS(ECL_SYM("AND",87),v6variables); + T1 = cl_listX(3, ECL_SYM("WHEN",905), T0, v3); + value0 = cl_list(3, ECL_SYM("LET",477), v5binding_list, T1); return value0; } } @@ -226,7 +212,6 @@ L12:; static cl_object LC4when_let_(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -237,7 +222,7 @@ static cl_object LC4when_let_(cl_object v1, cl_object v2) cl_object v4bindings; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[5])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -260,8 +245,8 @@ L8:; T2 = ecl_caar(v5binding_list); T4 = ecl_cdr(v5binding_list); T3 = LC3bind(T4, v3); - T4 = cl_listX(3, ECL_SYM("WHEN",907), T2, T3); - value0 = cl_list(3, ECL_SYM("LET",479), T1, T4); + T4 = cl_listX(3, ECL_SYM("WHEN",905), T2, T3); + value0 = cl_list(3, ECL_SYM("LET",477), T1, T4); return value0; } } @@ -272,7 +257,6 @@ L8:; static cl_object LC3bind(cl_object v1bindings, cl_object v2forms) { cl_object T0, T1, T2, T3, T4, T5; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -284,8 +268,8 @@ static cl_object LC3bind(cl_object v1bindings, cl_object v2forms) T2 = ecl_caar(v1bindings); T4 = ecl_cdr(v1bindings); T3 = LC3bind(T4, v2forms); - T4 = cl_listX(3, ECL_SYM("WHEN",907), T2, T3); - T5 = cl_list(3, ECL_SYM("LET",479), T1, T4); + T4 = cl_listX(3, ECL_SYM("WHEN",905), T2, T3); + T5 = cl_list(3, ECL_SYM("LET",477), T1, T4); value0 = ecl_list1(T5); cl_env_copy->nvalues = 1; return value0; @@ -300,7 +284,7 @@ L1:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclam0zuatJiYACM_4hEycC71(cl_object flag) +ECL_DLLEXPORT void _eclam0zuatJiYACM_r9g2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -315,25 +299,25 @@ ECL_DLLEXPORT void _eclam0zuatJiYACM_4hEycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/binding.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/binding.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclam0zuatJiYACM_4hEycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclam0zuatJiYACM_r9g2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defmacro(VV[3]); /* IF-LET */ - ecl_function_dispatch(cl_env_copy,VV[4])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[7]); /* WHEN-LET */ - ecl_function_dispatch(cl_env_copy,VV[4])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[8]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[8]); /* WHEN-LET* */ - ecl_function_dispatch(cl_env_copy,VV[4])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[4]); /* WHEN-LET */ + si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[8]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[5]); /* WHEN-LET* */ + si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[11]); } diff --git a/lib/alexandria/conditions.cxx b/lib/alexandria/conditions.cxx index b6c884c..ae27b0f 100644 --- a/lib/alexandria/conditions.cxx +++ b/lib/alexandria/conditions.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/conditions.lisp */ +/* Source: lib/alexandria/conditions.lisp */ #include #include "lib/alexandria/conditions.eclh" /* function definition for REQUIRED-ARGUMENT */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L1required_argument(cl_narg narg, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -34,7 +33,6 @@ static cl_object L1required_argument(cl_narg narg, ...) /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L2simple_style_warning(cl_narg narg, cl_object v1message, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -44,7 +42,7 @@ static cl_object L2simple_style_warning(cl_narg narg, cl_object v1message, ...) ecl_va_list args; ecl_va_start(args,v1message,narg,1); v2args = cl_grab_rest_args(args); ecl_va_end(args); - value0 = (cl_env_copy->function=(ECL_SYM("WARN",905)->symbol.gfdef))->cfun.entry(5, VV[2], ECL_SYM("FORMAT-CONTROL",1269), v1message, ECL_SYM("FORMAT-ARGUMENTS",1268), v2args) /* WARN */; + value0 = (cl_env_copy->function=(ECL_SYM("WARN",903)->symbol.gfdef))->cfun.entry(5, VV[2], ECL_SYM("FORMAT-CONTROL",1243), v1message, ECL_SYM("FORMAT-ARGUMENTS",1242), v2args) /* WARN */; return value0; } } @@ -52,7 +50,6 @@ static cl_object L2simple_style_warning(cl_narg narg, cl_object v1message, ...) /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L3simple_reader_error(cl_narg narg, cl_object v1stream, cl_object v2message, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -62,7 +59,7 @@ static cl_object L3simple_reader_error(cl_narg narg, cl_object v1stream, cl_obje ecl_va_list args; ecl_va_start(args,v2message,narg,2); v3args = cl_grab_rest_args(args); ecl_va_end(args); - value0 = cl_error(7, VV[3], ECL_SYM("STREAM",1347), v1stream, ECL_SYM("FORMAT-CONTROL",1269), v2message, ECL_SYM("FORMAT-ARGUMENTS",1268), v3args); + value0 = cl_error(7, VV[3], ECL_SYM("STREAM",1318), v1stream, ECL_SYM("FORMAT-CONTROL",1243), v2message, ECL_SYM("FORMAT-ARGUMENTS",1242), v3args); return value0; } } @@ -70,7 +67,6 @@ static cl_object L3simple_reader_error(cl_narg narg, cl_object v1stream, cl_obje /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L4simple_parse_error(cl_narg narg, cl_object v1message, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -80,7 +76,7 @@ static cl_object L4simple_parse_error(cl_narg narg, cl_object v1message, ...) ecl_va_list args; ecl_va_start(args,v1message,narg,1); v2args = cl_grab_rest_args(args); ecl_va_end(args); - value0 = cl_error(5, VV[4], ECL_SYM("FORMAT-CONTROL",1269), v1message, ECL_SYM("FORMAT-ARGUMENTS",1268), v2args); + value0 = cl_error(5, VV[4], ECL_SYM("FORMAT-CONTROL",1243), v1message, ECL_SYM("FORMAT-ARGUMENTS",1242), v2args); return value0; } } @@ -88,7 +84,6 @@ static cl_object L4simple_parse_error(cl_narg narg, cl_object v1message, ...) /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L5simple_program_error(cl_narg narg, cl_object v1message, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -98,7 +93,7 @@ static cl_object L5simple_program_error(cl_narg narg, cl_object v1message, ...) ecl_va_list args; ecl_va_start(args,v1message,narg,1); v2args = cl_grab_rest_args(args); ecl_va_end(args); - value0 = cl_error(5, VV[5], ECL_SYM("FORMAT-CONTROL",1269), v1message, ECL_SYM("FORMAT-ARGUMENTS",1268), v2args); + value0 = cl_error(5, VV[5], ECL_SYM("FORMAT-CONTROL",1243), v1message, ECL_SYM("FORMAT-ARGUMENTS",1242), v2args); return value0; } } @@ -107,7 +102,6 @@ static cl_object L5simple_program_error(cl_narg narg, cl_object v1message, ...) static cl_object LC6ignore_some_conditions(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -118,7 +112,7 @@ static cl_object LC6ignore_some_conditions(cl_object v1, cl_object v2) cl_object v4; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[22])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -126,7 +120,7 @@ L3:; v3 = ecl_cdr(v3); v4 = v5; } - T0 = CONS(ECL_SYM("PROGN",673),v3); + T0 = CONS(ECL_SYM("PROGN",671),v3); { cl_object v5condition; cl_object v6; @@ -135,8 +129,6 @@ L3:; cl_object v7; v7 = v4; if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v7; } { @@ -148,21 +140,17 @@ L15:; if (!(ecl_endp(v6))) { goto L17; } goto L16; L17:; - v5condition = ECL_CONS_CAR(v6); + v5condition = _ecl_car(v6); { cl_object v9; - v9 = ECL_CONS_CDR(v6); + v9 = _ecl_cdr(v6); if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v9; } { cl_object v9; v9 = v8; if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T2 = v9; } T3 = CONS(v5condition,VV[7]); @@ -175,7 +163,7 @@ L16:; } } L8:; - value0 = cl_listX(3, ECL_SYM("HANDLER-CASE",418), T0, T1); + value0 = cl_listX(3, ECL_SYM("HANDLER-CASE",416), T0, T1); return value0; } } @@ -185,7 +173,6 @@ L8:; static cl_object LC7unwind_protect_case(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -199,7 +186,7 @@ static cl_object LC7unwind_protect_case(cl_object v1, cl_object v2) cl_object v7protected_form; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[22])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v8; @@ -220,7 +207,7 @@ L10:; v6abort_flag = ECL_NIL; L9:; if (!(v3==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[22])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v8; @@ -229,7 +216,7 @@ L16:; v7protected_form = v8; } if (Null(v5)) { goto L21; } - ecl_function_dispatch(cl_env_copy,VV[24])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L21:; { cl_object v8; @@ -243,8 +230,8 @@ L25:; v8gflag = cl_gensym(1, VV[11]); T0 = cl_list(2, v8gflag, ECL_T); T1 = ecl_list1(T0); - T2 = cl_list(3, ECL_SYM("SETF",752), v8gflag, ECL_NIL); - T3 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), v7protected_form, T2); + T2 = cl_list(3, ECL_SYM("SETF",750), v8gflag, ECL_NIL); + T3 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",575), v7protected_form, T2); if (Null(v6abort_flag)) { goto L31; } T5 = cl_list(2, v6abort_flag, v8gflag); T4 = ecl_list1(T5); @@ -263,8 +250,6 @@ L29:; cl_object v12; v12 = v3; if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v12; } { @@ -278,38 +263,34 @@ L41:; L43:; { cl_object v14; - v14 = ECL_CONS_CAR(v11); + v14 = _ecl_car(v11); v9cleanup_kind = ecl_car(v14); v14 = ecl_cdr(v14); v10forms = v14; } { cl_object v14; - v14 = ECL_CONS_CDR(v11); + v14 = _ecl_cdr(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T6 = v14; } - if (!((v9cleanup_kind)==(VV[12]))) { goto L62; } - T8 = cl_list(2, ECL_SYM("NOT",586), v8gflag); - T7 = cl_listX(3, ECL_SYM("WHEN",907), T8, v10forms); + if (!(ecl_eql(v9cleanup_kind,VV[12]))) { goto L62; } + T8 = cl_list(2, ECL_SYM("NOT",584), v8gflag); + T7 = cl_listX(3, ECL_SYM("WHEN",905), T8, v10forms); goto L61; L62:; - if (!((v9cleanup_kind)==(ECL_SYM("ABORT",1222)))) { goto L64; } - T7 = cl_listX(3, ECL_SYM("WHEN",907), v8gflag, v10forms); + if (!(ecl_eql(v9cleanup_kind,ECL_SYM("ABORT",1198)))) { goto L64; } + T7 = cl_listX(3, ECL_SYM("WHEN",905), v8gflag, v10forms); goto L61; L64:; - if (!((v9cleanup_kind)==(VV[13]))) { goto L66; } - T7 = CONS(ECL_SYM("PROGN",673),v10forms); + if (!(ecl_eql(v9cleanup_kind,VV[13]))) { goto L66; } + T7 = CONS(ECL_SYM("PROGN",671),v10forms); goto L61; L66:; T7 = si_ecase_error(v9cleanup_kind, VV[14]); @@ -323,9 +304,9 @@ L42:; } } L33:; - T6 = cl_listX(3, ECL_SYM("LET",479), T4, T5); - T7 = cl_list(3, ECL_SYM("UNWIND-PROTECT",890), T3, T6); - value0 = cl_list(3, ECL_SYM("LET",479), T1, T7); + T6 = cl_listX(3, ECL_SYM("LET",477), T4, T5); + T7 = cl_list(3, ECL_SYM("UNWIND-PROTECT",888), T3, T6); + value0 = cl_list(3, ECL_SYM("LET",477), T1, T7); return value0; } } @@ -336,7 +317,7 @@ L33:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecl0sKp2nr5Zar9M_tCFycC71(cl_object flag) +ECL_DLLEXPORT void _ecl0sKp2nr5Zar9M_0Qg2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -351,45 +332,45 @@ ECL_DLLEXPORT void _ecl0sKp2nr5Zar9M_tCFycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/conditions.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/conditions.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl0sKp2nr5Zar9M_tCFycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl0sKp2nr5Zar9M_0Qg2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defun(VV[15]); /* REQUIRED-ARGUMENT */ - ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; clos_load_defclass(VV[2], VVtemp[7], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[17]); /* SIMPLE-STYLE-WARNING */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[16]); /* SIMPLE-STYLE-WARNING */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; clos_load_defclass(VV[3], VVtemp[13], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[18]); /* SIMPLE-READER-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[17], VVtemp[18]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[17]); /* SIMPLE-READER-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[17], VVtemp[18]) /* ANNOTATE */; clos_load_defclass(VV[4], VVtemp[19], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[19]); /* SIMPLE-PARSE-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[23]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[18]); /* SIMPLE-PARSE-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[22], VVtemp[23]) /* ANNOTATE */; clos_load_defclass(VV[5], VVtemp[24], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[20]); /* SIMPLE-PROGRAM-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[21]); /* IGNORE-SOME-CONDITIONS */ - ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[30]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[23]); /* UNWIND-PROTECT-CASE */ - ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[34]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defun(VV[19]); /* SIMPLE-PROGRAM-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[20]); /* IGNORE-SOME-CONDITIONS */ + si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[30]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[21]); /* UNWIND-PROTECT-CASE */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[34]); } diff --git a/lib/alexandria/control-flow.cxx b/lib/alexandria/control-flow.cxx index 87ad2cf..0bff75b 100644 --- a/lib/alexandria/control-flow.cxx +++ b/lib/alexandria/control-flow.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/control-flow.lisp */ +/* Source: lib/alexandria/control-flow.lisp */ #include #include "lib/alexandria/control-flow.eclh" /* function definition for EXTRACT-FUNCTION-NAME */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L1extract_function_name(cl_object v1spec) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -18,13 +17,13 @@ static cl_object L1extract_function_name(cl_object v1spec) { cl_object v2; v2 = ecl_car(v1spec); - if (!((v2)==(ECL_SYM("QUOTE",681)))) { goto L8; } + if (!((v2)==(ECL_SYM("QUOTE",679)))) { goto L8; } goto L5; goto L6; L8:; goto L6; L6:; - if (!((v2)==(ECL_SYM("FUNCTION",398)))) { goto L1; } + if (!((v2)==(ECL_SYM("FUNCTION",396)))) { goto L1; } goto L2; L5:; } @@ -43,7 +42,7 @@ L1:; static cl_object L3generate_switch_body(cl_narg narg, cl_object v1whole, cl_object v2object, cl_object v3clauses, cl_object v4test, cl_object v5key, ...) { cl_object T0, T1, T2, T3, T4, T5, T6, T7; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1, CLV2, CLV3; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -75,19 +74,19 @@ static cl_object L3generate_switch_body(cl_narg narg, cl_object v1whole, cl_obje { cl_object v6; v6 = ecl_car(ECL_CONS_CAR(CLV2)); - if (!((v6)==(ECL_SYM("ERROR",339)))) { goto L12; } + if (!((v6)==(ECL_SYM("ERROR",337)))) { goto L12; } goto L9; goto L10; L12:; goto L10; L10:; - if (!((v6)==(ECL_SYM("CERROR",204)))) { goto L5; } + if (!((v6)==(ECL_SYM("CERROR",202)))) { goto L5; } goto L6; L9:; } L6:; T0 = ECL_CONS_CAR(CLV2); - T1 = cl_list(2, ECL_SYM("QUOTE",681), ECL_CONS_CAR(CLV1)); + T1 = cl_list(2, ECL_SYM("QUOTE",679), ECL_CONS_CAR(CLV1)); T2 = cl_list(3, VV[7], ECL_CONS_CAR(CLV3), T1); ECL_CONS_CAR(CLV2) = ecl_append(T0,T2); L5:; @@ -98,7 +97,7 @@ L5:; cl_object v6; { cl_object v7; - v7 = ecl_make_cclosure_va((cl_objectfn)LC2__lambda28,env1,Cblock,1); + v7 = ecl_make_cclosure_va((cl_objectfn)LC2__g10,env1,Cblock); v6 = v7; } { @@ -109,8 +108,6 @@ L5:; cl_object v9; v9 = v3clauses; if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v9; } { @@ -122,21 +119,17 @@ L24:; if (!(ecl_endp(v8))) { goto L26; } goto L25; L26:; - v7 = ECL_CONS_CAR(v8); + v7 = _ecl_car(v8); { cl_object v11; - v11 = ECL_CONS_CDR(v8); + v11 = _ecl_cdr(v8); if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v11; } { cl_object v11; v11 = v10; if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T4 = v11; } T5 = ecl_function_dispatch(cl_env_copy,v6)(1, v7); @@ -153,15 +146,15 @@ L16:; T4 = cl_list(2, ECL_T, ECL_CONS_CAR(CLV2)); T5 = ecl_list1(T4); T6 = ecl_append(T3,T5); - T7 = CONS(ECL_SYM("COND",249),T6); - value0 = cl_list(3, ECL_SYM("LET",479), T2, T7); + T7 = CONS(ECL_SYM("COND",247),T6); + value0 = cl_list(3, ECL_SYM("LET",477), T2, T7); return value0; } } } -/* closure LAMBDA28 */ +/* closure G10 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__lambda28(cl_narg narg, cl_object v1clause, ...) +static cl_object LC2__g10(cl_narg narg, cl_object v1clause, ...) { cl_object T0; cl_object CLV0, CLV1, CLV2, CLV3; @@ -187,7 +180,7 @@ static cl_object LC2__lambda28(cl_narg narg, cl_object v1clause, ...) L7:; goto L5; L5:; - if (!((v2)==(ECL_SYM("OTHERWISE",617)))) { goto L1; } + if (!((v2)==(ECL_SYM("OTHERWISE",615)))) { goto L1; } goto L2; L4:; } @@ -196,7 +189,7 @@ L2:; cl_error(2, VV[10], ECL_CONS_CAR(CLV0)); L10:; T0 = ecl_cdr(v1clause); - ECL_CONS_CAR(CLV2) = CONS(ECL_SYM("PROGN",673),T0); + ECL_CONS_CAR(CLV2) = CONS(ECL_SYM("PROGN",671),T0); value0 = VV[11]; cl_env_copy->nvalues = 1; return value0; @@ -206,7 +199,7 @@ L1:; cl_object v3key_form; v2 = v1clause; if (!(v2==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1clause) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1clause); L16:; { cl_object v4; @@ -226,7 +219,6 @@ L16:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC4switch(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -243,7 +235,7 @@ static cl_object LC4switch(cl_object v1, cl_object v2) cl_object v10key; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v11; @@ -253,7 +245,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v11; @@ -261,21 +253,21 @@ L10:; v5 = ecl_cdr(v5); v6object = v11; } - v7 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; - if (!((v7)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L17; } - v8test = ECL_SYM("EQL",336); + v7 = si_search_keyword(2, v5, ECL_SYM("TEST",1321)); + if (!((v7)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L17; } + v8test = ECL_SYM("EQL",334); goto L16; L17:; v8test = v7; L16:; - v9 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("KEY",1294)) /* SEARCH-KEYWORD */; - if (!((v9)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L21; } - v10key = ECL_SYM("IDENTITY",428); + v9 = si_search_keyword(2, v5, ECL_SYM("KEY",1267)); + if (!((v9)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L21; } + v10key = ECL_SYM("IDENTITY",426); goto L20; L21:; v10key = v9; L20:; - ecl_function_dispatch(cl_env_copy,VV[35])(2, v5, VV[13]) /* CHECK-KEYWORD */; + si_check_keyword(2, v5, VV[13]); value0 = L3generate_switch_body(5, v1, v6object, v3, v8test, v10key); return value0; } @@ -285,7 +277,6 @@ L20:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC5eswitch(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -302,7 +293,7 @@ static cl_object LC5eswitch(cl_object v1, cl_object v2) cl_object v10key; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v11; @@ -312,7 +303,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v11; @@ -320,21 +311,21 @@ L10:; v5 = ecl_cdr(v5); v6object = v11; } - v7 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; - if (!((v7)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L17; } - v8test = ECL_SYM("EQL",336); + v7 = si_search_keyword(2, v5, ECL_SYM("TEST",1321)); + if (!((v7)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L17; } + v8test = ECL_SYM("EQL",334); goto L16; L17:; v8test = v7; L16:; - v9 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("KEY",1294)) /* SEARCH-KEYWORD */; - if (!((v9)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L21; } - v10key = ECL_SYM("IDENTITY",428); + v9 = si_search_keyword(2, v5, ECL_SYM("KEY",1267)); + if (!((v9)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L21; } + v10key = ECL_SYM("IDENTITY",426); goto L20; L21:; v10key = v9; L20:; - ecl_function_dispatch(cl_env_copy,VV[35])(2, v5, VV[13]) /* CHECK-KEYWORD */; + si_check_keyword(2, v5, VV[13]); value0 = L3generate_switch_body(6, v1, v6object, v3, v8test, v10key, VV[15]); return value0; } @@ -344,7 +335,6 @@ L20:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC6cswitch(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -361,7 +351,7 @@ static cl_object LC6cswitch(cl_object v1, cl_object v2) cl_object v10key; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v11; @@ -371,7 +361,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v11; @@ -379,21 +369,21 @@ L10:; v5 = ecl_cdr(v5); v6object = v11; } - v7 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; - if (!((v7)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L17; } - v8test = ECL_SYM("EQL",336); + v7 = si_search_keyword(2, v5, ECL_SYM("TEST",1321)); + if (!((v7)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L17; } + v8test = ECL_SYM("EQL",334); goto L16; L17:; v8test = v7; L16:; - v9 = ecl_function_dispatch(cl_env_copy,VV[34])(2, v5, ECL_SYM("KEY",1294)) /* SEARCH-KEYWORD */; - if (!((v9)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L21; } - v10key = ECL_SYM("IDENTITY",428); + v9 = si_search_keyword(2, v5, ECL_SYM("KEY",1267)); + if (!((v9)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L21; } + v10key = ECL_SYM("IDENTITY",426); goto L20; L21:; v10key = v9; L20:; - ecl_function_dispatch(cl_env_copy,VV[35])(2, v5, VV[13]) /* CHECK-KEYWORD */; + si_check_keyword(2, v5, VV[13]); value0 = L3generate_switch_body(6, v1, v6object, v3, v8test, v10key, VV[17]); return value0; } @@ -404,7 +394,7 @@ L20:; static cl_object LC10whichever(cl_object v1, cl_object v2env) { cl_object T0, T1, T2, T3; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -421,7 +411,7 @@ static cl_object LC10whichever(cl_object v1, cl_object v2env) cl_object v5; { cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC7__lambda107,env0,Cblock,1); + v6 = ecl_make_cclosure_va((cl_objectfn)LC7__g80,env0,Cblock); v5 = v6; } { @@ -432,8 +422,6 @@ static cl_object LC10whichever(cl_object v1, cl_object v2env) cl_object v8; v8 = v4possibilities; if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v8; } { @@ -445,21 +433,17 @@ L12:; if (!(ecl_endp(v7))) { goto L14; } goto L13; L14:; - v6 = ECL_CONS_CAR(v7); + v6 = _ecl_car(v7); { cl_object v10; - v10 = ECL_CONS_CDR(v7); + v10 = _ecl_cdr(v7); if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v10; } { cl_object v10; v10 = v9; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v10; } T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); @@ -475,17 +459,17 @@ L13:; L4:; { cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC8__lambda110,ECL_NIL,Cblock,1); + v5 = ecl_make_cfun((cl_objectfn_fixed)LC8__g83,ECL_NIL,Cblock,1); T0 = v5; } if (Null(cl_every(2, T0, v4possibilities))) { goto L30; } - T0 = CONS(ECL_SYM("VECTOR",900),v4possibilities); - T1 = cl_list(2, ECL_SYM("LOAD-TIME-VALUE",491), T0); + T0 = CONS(ECL_SYM("VECTOR",898),v4possibilities); + T1 = cl_list(2, ECL_SYM("LOAD-TIME-VALUE",489), T0); { cl_fixnum v5; v5 = ecl_length(v4possibilities); - T2 = cl_list(2, ECL_SYM("RANDOM",682), ecl_make_fixnum(v5)); - value0 = cl_list(3, ECL_SYM("SVREF",840), T1, T2); + T2 = cl_list(2, ECL_SYM("RANDOM",680), ecl_make_fixnum(v5)); + value0 = cl_list(3, ECL_SYM("SVREF",838), T1, T2); return value0; } L30:; @@ -495,20 +479,20 @@ L30:; { cl_fixnum v7length; v7length = ecl_length(v4possibilities); - T0 = cl_list(2, ECL_SYM("RANDOM",682), ecl_make_fixnum(v7length)); + T0 = cl_list(2, ECL_SYM("RANDOM",680), ecl_make_fixnum(v7length)); T1 = cl_list(2, v6random_number, T0); T2 = ecl_list1(T1); T3 = LC9expand(v4possibilities, ecl_make_fixnum(0), v6random_number); - value0 = cl_list(3, ECL_SYM("LET",479), T2, T3); + value0 = cl_list(3, ECL_SYM("LET",477), T2, T3); return value0; } } } } } -/* closure LAMBDA107 */ +/* closure G80 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__lambda107(cl_narg narg, cl_object v1p, ...) +static cl_object LC7__g80(cl_narg narg, cl_object v1p, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -526,11 +510,10 @@ static cl_object LC7__lambda107(cl_narg narg, cl_object v1p, ...) } } } -/* local function LAMBDA110 */ +/* local function G83 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__lambda110(cl_object v1p) +static cl_object LC8__g83(cl_object v1p) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -545,7 +528,6 @@ static cl_object LC8__lambda110(cl_object v1p) static cl_object LC9expand(cl_object v1possibilities, cl_object v2position, cl_object v3random_number) { cl_object T0, T1, T2, T3, T4; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -568,11 +550,11 @@ L1:; T0 = ecl_minus(ecl_make_fixnum(v4length),v5half); v7first_half = cl_butlast(2, v1possibilities, T0); T0 = ecl_plus(v2position,v5half); - T1 = cl_list(3, ECL_SYM("<",74), v3random_number, T0); + T1 = cl_list(3, ECL_SYM("<",72), v3random_number, T0); T2 = LC9expand(v7first_half, v2position, v3random_number); T4 = ecl_plus(v2position,v5half); T3 = LC9expand(v6second_half, T4, v3random_number); - value0 = cl_list(4, ECL_SYM("IF",948), T1, T2, T3); + value0 = cl_list(4, ECL_SYM("IF",946), T1, T2, T3); return value0; } } @@ -582,7 +564,7 @@ L1:; static cl_object LC12xor(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1, CLV2; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -609,7 +591,7 @@ static cl_object LC12xor(cl_object v1, cl_object v2) cl_object v7; { cl_object v8; - v8 = ecl_make_cclosure_va((cl_objectfn)LC11__lambda125,env1,Cblock,1); + v8 = ecl_make_cclosure_va((cl_objectfn)LC11__g98,env1,Cblock); v7 = v8; } { @@ -620,8 +602,6 @@ static cl_object LC12xor(cl_object v1, cl_object v2) cl_object v10; v10 = v3; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -633,21 +613,17 @@ L13:; if (!(ecl_endp(v9))) { goto L15; } goto L14; L15:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v12; - v12 = ECL_CONS_CDR(v9); + v12 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v12; } { cl_object v12; v12 = v11; if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T2 = v12; } T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); @@ -661,20 +637,20 @@ L14:; } } L5:; - T2 = cl_list(3, ECL_SYM("VALUES",897), ECL_CONS_CAR(CLV2), ECL_T); - T3 = cl_list(3, ECL_SYM("RETURN-FROM",727), ECL_CONS_CAR(CLV0), T2); + T2 = cl_list(3, ECL_SYM("VALUES",895), ECL_CONS_CAR(CLV2), ECL_T); + T3 = cl_list(3, ECL_SYM("RETURN-FROM",725), ECL_CONS_CAR(CLV0), T2); T4 = ecl_list1(T3); T5 = ecl_append(T1,T4); - T6 = cl_listX(3, ECL_SYM("BLOCK",139), ECL_CONS_CAR(CLV0), T5); - value0 = cl_list(3, ECL_SYM("LET",479), T0, T6); + T6 = cl_listX(3, ECL_SYM("BLOCK",137), ECL_CONS_CAR(CLV0), T5); + value0 = cl_list(3, ECL_SYM("LET",477), T0, T6); return value0; } } } } -/* closure LAMBDA125 */ +/* closure G98 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__lambda125(cl_narg narg, cl_object v1datum, ...) +static cl_object LC11__g98(cl_narg narg, cl_object v1datum, ...) { cl_object T0, T1, T2, T3; cl_object CLV0, CLV1, CLV2; @@ -690,11 +666,11 @@ static cl_object LC11__lambda125(cl_narg narg, cl_object v1datum, ...) if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); { TTL: - T0 = cl_list(3, ECL_SYM("SETF",752), ECL_CONS_CAR(CLV1), v1datum); - T1 = cl_list(3, ECL_SYM("RETURN-FROM",727), ECL_CONS_CAR(CLV0), VV[24]); - T2 = cl_list(3, ECL_SYM("SETF",752), ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV1)); - T3 = cl_list(4, ECL_SYM("IF",948), ECL_CONS_CAR(CLV2), T1, T2); - value0 = cl_list(3, ECL_SYM("IF",948), T0, T3); + T0 = cl_list(3, ECL_SYM("SETF",750), ECL_CONS_CAR(CLV1), v1datum); + T1 = cl_list(3, ECL_SYM("RETURN-FROM",725), ECL_CONS_CAR(CLV0), VV[24]); + T2 = cl_list(3, ECL_SYM("SETF",750), ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV1)); + T3 = cl_list(4, ECL_SYM("IF",946), ECL_CONS_CAR(CLV2), T1, T2); + value0 = cl_list(3, ECL_SYM("IF",946), T0, T3); return value0; } } @@ -704,7 +680,6 @@ static cl_object LC11__lambda125(cl_narg narg, cl_object v1datum, ...) static cl_object LC13nth_value_or(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -715,7 +690,7 @@ static cl_object LC13nth_value_or(cl_object v1, cl_object v2) cl_object v4nth_value; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -732,11 +707,11 @@ L3:; cl_object v6values; v6values = cl_gensym(1, VV[27]); T3 = ecl_car(v3); - T4 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",576), T3); + T4 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",574), T3); T5 = cl_list(2, v6values, T4); T6 = ecl_list1(T5); - T7 = cl_list(3, ECL_SYM("NTH",604), v5, v6values); - T8 = cl_list(2, ECL_SYM("VALUES-LIST",898), v6values); + T7 = cl_list(3, ECL_SYM("NTH",602), v5, v6values); + T8 = cl_list(2, ECL_SYM("VALUES-LIST",896), v6values); if (Null(ecl_cdr(v3))) { goto L12; } T10 = ecl_cdr(v3); T9 = cl_listX(3, VV[25], v5, T10); @@ -744,10 +719,10 @@ L3:; L12:; T9 = ECL_NIL; L11:; - T10 = cl_list(4, ECL_SYM("IF",948), T7, T8, T9); - T2 = cl_list(3, ECL_SYM("LET",479), T6, T10); + T10 = cl_list(4, ECL_SYM("IF",946), T7, T8, T9); + T2 = cl_list(3, ECL_SYM("LET",477), T6, T10); } - value0 = cl_list(3, ECL_SYM("LET",479), T1, T2); + value0 = cl_list(3, ECL_SYM("LET",477), T1, T2); return value0; } } @@ -758,7 +733,6 @@ L11:; static cl_object LC14multiple_value_prog2(cl_object v1, cl_object v2) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -770,7 +744,7 @@ static cl_object LC14multiple_value_prog2(cl_object v1, cl_object v2) cl_object v5second_form; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -779,7 +753,7 @@ L3:; v4first_form = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[32])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -787,8 +761,8 @@ L9:; v3 = ecl_cdr(v3); v5second_form = v6; } - T0 = cl_listX(3, ECL_SYM("MULTIPLE-VALUE-PROG1",577), v5second_form, v3); - value0 = cl_list(3, ECL_SYM("PROGN",673), v4first_form, T0); + T0 = cl_listX(3, ECL_SYM("MULTIPLE-VALUE-PROG1",575), v5second_form, v3); + value0 = cl_list(3, ECL_SYM("PROGN",671), v4first_form, T0); return value0; } } @@ -798,7 +772,7 @@ L9:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclCnSaUWKBItpDM_zzFycC71(cl_object flag) +ECL_DLLEXPORT void _eclCnSaUWKBItpDM_Hwg2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -813,48 +787,48 @@ ECL_DLLEXPORT void _eclCnSaUWKBItpDM_zzFycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/control-flow.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/control-flow.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclCnSaUWKBItpDM_zzFycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclCnSaUWKBItpDM_Hwg2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defun(VV[29]); /* EXTRACT-FUNCTION-NAME */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[31]); /* GENERATE-SWITCH-BODY */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[12], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[33]); /* SWITCH */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[12], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[36]); /* ESWITCH */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[14], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[37]); /* CSWITCH */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[17]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[20]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[38]); /* WHICHEVER */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[18], ECL_SYM("FUNCTION",398), VVtemp[21]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[23]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[24]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[39]); /* XOR */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[25]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[27]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[28]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[40]); /* NTH-VALUE-OR */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[25], ECL_SYM("FUNCTION",398), VVtemp[29]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[30], VVtemp[31]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[41]); /* MULTIPLE-VALUE-PROG2 */ - ecl_function_dispatch(cl_env_copy,VV[30])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[33]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[30]); /* GENERATE-SWITCH-BODY */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[31]); /* SWITCH */ + si_set_documentation(3, VV[12], ECL_SYM("FUNCTION",396), VVtemp[11]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[32]); /* ESWITCH */ + si_set_documentation(3, VV[14], ECL_SYM("FUNCTION",396), VVtemp[14]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[33]); /* CSWITCH */ + si_set_documentation(3, VV[16], ECL_SYM("FUNCTION",396), VVtemp[17]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[34]); /* WHICHEVER */ + si_set_documentation(3, VV[18], ECL_SYM("FUNCTION",396), VVtemp[21]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[22], VVtemp[23]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[24]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[35]); /* XOR */ + si_set_documentation(3, VV[20], ECL_SYM("FUNCTION",396), VVtemp[25]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[36]); /* NTH-VALUE-OR */ + si_set_documentation(3, VV[25], ECL_SYM("FUNCTION",396), VVtemp[29]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[31]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[32]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[37]); /* MULTIPLE-VALUE-PROG2 */ + si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[33]); } diff --git a/lib/alexandria/definitions.cxx b/lib/alexandria/definitions.cxx index 594806f..a981d1a 100644 --- a/lib/alexandria/definitions.cxx +++ b/lib/alexandria/definitions.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/definitions.lisp */ +/* Source: lib/alexandria/definitions.lisp */ #include #include "lib/alexandria/definitions.eclh" /* function definition for %REEVALUATE-CONSTANT */ @@ -9,7 +9,7 @@ static cl_object L5_reevaluate_constant(cl_object volatile v1name, cl_object volatile v2value, cl_object volatile v3test) { cl_object T0, T1, T2, T3, T4, T5, T6, T7; - cl_object volatile env0 = ECL_NIL; + cl_object volatile env0; cl_object volatile CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; @@ -42,44 +42,41 @@ L7:; { volatile cl_object env2 = env1; CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /* TAGBODY */ - { - ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1)); - if (__ecl_frs_push_result) { - if (cl_env_copy->values[0]==ecl_make_fixnum(0))goto L9; - if (cl_env_copy->values[0]==ecl_make_fixnum(1))goto L10; - ecl_internal_error("GO found an inexistent tag"); - } + if (ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1))) { + if (cl_env_copy->values[0]==ecl_make_fixnum(0))goto L9; + if (cl_env_copy->values[0]==ecl_make_fixnum(1))goto L10; + ecl_internal_error("GO found an inexistent tag"); } { cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC1__lambda8,env2,Cblock,0); + v5 = ecl_make_cclosure_va((cl_objectfn)LC1__g8,env2,Cblock); T0 = v5; } { cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC2__lambda9,ECL_NIL,Cblock,1); + v5 = ecl_make_cfun((cl_objectfn_fixed)LC2__g9,ECL_NIL,Cblock,1); T1 = v5; } - T2 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1306), ECL_SYM("IGNORE",430), ECL_SYM("FUNCTION",1270), T0, VV[3], T1) /* MAKE-RESTART */; + T2 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1278), ECL_SYM("IGNORE",428), ECL_SYM("FUNCTION",1244), T0, VV[3], T1) /* MAKE-RESTART */; { cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC3__lambda10,env2,Cblock,0); + v5 = ecl_make_cclosure_va((cl_objectfn)LC3__g10,env2,Cblock); T3 = v5; } { cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda11,ECL_NIL,Cblock,1); + v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__g11,ECL_NIL,Cblock,1); T4 = v5; } - T5 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1306), ECL_SYM("CONTINUE",252), ECL_SYM("FUNCTION",1270), T3, VV[3], T4) /* MAKE-RESTART */; + T5 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1278), ECL_SYM("CONTINUE",250), ECL_SYM("FUNCTION",1244), T3, VV[3], T4) /* MAKE-RESTART */; T6 = cl_list(2, T2, T5); - T7 = CONS(T6,ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",5))); - ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",5),T7); /* *RESTART-CLUSTERS* */ + T7 = CONS(T6,ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",4))); + ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",4),T7); /* *RESTART-CLUSTERS* */ { cl_object v5; T0 = cl_list(4, v1name, v4, v2value, v3test); - v5 = ecl_function_dispatch(cl_env_copy,VV[13])(4, VV[6], T0, ECL_SYM("SIMPLE-ERROR",772), ECL_SYM("ERROR",339)) /* COERCE-TO-CONDITION */; - T0 = ecl_car(ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",5))); + v5 = ecl_function_dispatch(cl_env_copy,VV[13])(4, VV[6], T0, ECL_SYM("SIMPLE-ERROR",770), ECL_SYM("ERROR",337)) /* COERCE-TO-CONDITION */; + T0 = ecl_car(ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",4))); T1 = CONS(v5,T0); T2 = CONS(T1,ecl_symbol_value(VV[7])); ecl_bds_bind(cl_env_copy,VV[7],T2); /* *CONDITION-RESTARTS* */ @@ -90,37 +87,23 @@ L7:; return value0; } L9:; - { - cl_object v5; - v5 = ECL_CONS_CAR(CLV0); - if (Null(v5)) { goto L19; } - ecl_function_dispatch(cl_env_copy,VV[14])(1, ECL_NIL) /* DM-TOO-MANY-ARGUMENTS */; -L19:; - value0 = v4; - cl_env_copy->nvalues = 1; - ecl_frs_pop(cl_env_copy); - return value0; - } + value0 = v4; + cl_env_copy->nvalues = 1; + ecl_frs_pop(cl_env_copy); + return value0; L10:; - { - cl_object v5; - v5 = ECL_CONS_CAR(CLV0); - if (Null(v5)) { goto L23; } - ecl_function_dispatch(cl_env_copy,VV[14])(1, ECL_NIL) /* DM-TOO-MANY-ARGUMENTS */; -L23:; - value0 = v2value; - cl_env_copy->nvalues = 1; - ecl_frs_pop(cl_env_copy); - return value0; - } + value0 = v2value; + cl_env_copy->nvalues = 1; + ecl_frs_pop(cl_env_copy); + return value0; } } } } } -/* closure LAMBDA8 */ +/* closure G8 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__lambda8(cl_narg narg, ...) +static cl_object LC1__g8(cl_narg narg, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -141,11 +124,10 @@ static cl_object LC1__lambda8(cl_narg narg, ...) } } } -/* local function LAMBDA9 */ +/* local function G9 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__lambda9(cl_object v1stream) +static cl_object LC2__g9(cl_object v1stream) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -155,9 +137,9 @@ static cl_object LC2__lambda9(cl_object v1stream) return value0; } } -/* closure LAMBDA10 */ +/* closure G10 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3__lambda10(cl_narg narg, ...) +static cl_object LC3__g10(cl_narg narg, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -178,11 +160,10 @@ static cl_object LC3__lambda10(cl_narg narg, ...) } } } -/* local function LAMBDA11 */ +/* local function G11 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__lambda11(cl_object v1stream) +static cl_object LC4__g11(cl_object v1stream) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -197,7 +178,6 @@ static cl_object LC4__lambda11(cl_object v1stream) static cl_object LC6define_constant(cl_object v1, cl_object v2) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -213,7 +193,7 @@ static cl_object LC6define_constant(cl_object v1, cl_object v2) cl_object v9documentation; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[17])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v10; @@ -222,7 +202,7 @@ L3:; v4name = v10; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[17])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v10; @@ -230,22 +210,22 @@ L9:; v3 = ecl_cdr(v3); v5initial_value = v10; } - v6 = ecl_function_dispatch(cl_env_copy,VV[18])(2, v3, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; - if (!((v6)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L16; } + v6 = si_search_keyword(2, v3, ECL_SYM("TEST",1321)); + if (!((v6)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L16; } v7test = VV[9]; goto L15; L16:; v7test = v6; L15:; - v8 = ecl_function_dispatch(cl_env_copy,VV[18])(2, v3, ECL_SYM("DOCUMENTATION",1250)) /* SEARCH-KEYWORD */; - if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L20; } + v8 = si_search_keyword(2, v3, ECL_SYM("DOCUMENTATION",1225)); + if (!((v8)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L20; } v9documentation = ECL_NIL; goto L19; L20:; v9documentation = v8; L19:; - ecl_function_dispatch(cl_env_copy,VV[19])(2, v3, VV[10]) /* CHECK-KEYWORD */; - T0 = cl_list(2, ECL_SYM("QUOTE",681), v4name); + si_check_keyword(2, v3, VV[10]); + T0 = cl_list(2, ECL_SYM("QUOTE",679), v4name); T1 = cl_list(4, VV[0], T0, v5initial_value, v7test); if (Null(v9documentation)) { goto L24; } T2 = ecl_list1(v9documentation); @@ -253,7 +233,7 @@ L19:; L24:; T2 = ECL_NIL; L23:; - value0 = cl_listX(4, ECL_SYM("DEFCONSTANT",279), v4name, T1, T2); + value0 = cl_listX(4, ECL_SYM("DEFCONSTANT",277), v4name, T1, T2); return value0; } } @@ -263,7 +243,7 @@ L23:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclEwTbx6vhJ21IM_CgEycC71(cl_object flag) +ECL_DLLEXPORT void _eclEwTbx6vhJ21IM_ftf2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -278,20 +258,20 @@ ECL_DLLEXPORT void _eclEwTbx6vhJ21IM_CgEycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/definitions.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/definitions.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclEwTbx6vhJ21IM_CgEycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclEwTbx6vhJ21IM_ftf2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defun(VV[11]); /* %REEVALUATE-CONSTANT */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[4], VVtemp[5]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[6]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[15]); /* DEFINE-CONSTANT */ - ecl_function_dispatch(cl_env_copy,VV[16])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[7]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[4], VVtemp[5]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[6]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[14]); /* DEFINE-CONSTANT */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[7]); } diff --git a/lib/alexandria/features.cxx b/lib/alexandria/features.cxx index 8e13cdf..1305795 100644 --- a/lib/alexandria/features.cxx +++ b/lib/alexandria/features.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/features.lisp */ +/* Source: lib/alexandria/features.lisp */ #include #include "lib/alexandria/features.eclh" /* function definition for FEATUREP */ @@ -9,90 +9,83 @@ static cl_object L1featurep(cl_object v1feature_expression) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - if (!(ECL_SYMBOLP(v1feature_expression))) { goto L1; } { cl_object v2; - cl_object v3; - cl_object v4; - v2 = ecl_symbol_value(ECL_SYM("*FEATURES*",36)); - v3 = v1feature_expression; - v4 = v2; - T0 = ecl_memql(v3,v4); - } - { - bool v2; - v2 = T0==ECL_NIL; - value0 = (v2)?ECL_NIL:ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } -L1:; - if (!(ECL_CONSP(v1feature_expression))) { goto L7; } - { - cl_object v3; - v3 = ecl_car(v1feature_expression); - if (ECL_SYMBOLP(v3)) { goto L11; } + v2 = v1feature_expression; + if (!(ECL_SYMBOLP(v2))) { goto L2; } + T0 = ecl_memql(v1feature_expression,ecl_symbol_value(ECL_SYM("*FEATURES*",34))); + { + bool v3; + v3 = T0==ECL_NIL; + value0 = (v3)?ECL_NIL:ECL_T; + cl_env_copy->nvalues = 1; + return value0; + } +L2:; + if (!(ECL_CONSP(v2))) { goto L5; } { cl_object v4; - v4 = si_do_check_type(v3, ECL_SYM("SYMBOL",842), ECL_NIL, VV[1]); + v4 = ecl_car(v1feature_expression); + if (ECL_SYMBOLP(v4)) { goto L9; } { cl_object v5; - v5 = v1feature_expression; - if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - T0 = v5; + v5 = si_do_check_type(v4, ECL_SYM("SYMBOL",840), ECL_NIL, VV[1]); + { + cl_object v6; + v6 = v1feature_expression; + if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6); + T0 = v6; + } + (ECL_CONS_CAR(T0)=v5,T0); } - (ECL_CONS_CAR(T0)=v4,T0); +L9:; } -L11:; - } - { - cl_object v3; - T0 = ecl_car(v1feature_expression); - v3 = cl_identity(T0); - if (Null(cl_stringE(2, v3, VV[2]))) { goto L19; } - T0 = ecl_fdefinition(VV[0]); - T1 = ecl_cdr(v1feature_expression); - value0 = cl_every(2, T0, T1); - return value0; -L19:; - if (Null(cl_stringE(2, v3, VV[3]))) { goto L22; } - T0 = ecl_fdefinition(VV[0]); - T1 = ecl_cdr(v1feature_expression); - value0 = cl_some(2, T0, T1); - return value0; -L22:; - if (Null(cl_stringE(2, v3, VV[4]))) { goto L25; } - goto L29; -L28:; - si_assert_failure(1, VV[5]); -L29:; { - cl_fixnum v4; - v4 = ecl_length(v1feature_expression); - if ((2)==(v4)) { goto L32; } + cl_object v4; + T0 = ecl_car(v1feature_expression); + v4 = cl_identity(T0); + if (Null(cl_stringE(2, v4, VV[2]))) { goto L17; } + T0 = ecl_fdefinition(VV[0]); + T1 = ecl_cdr(v1feature_expression); + value0 = cl_every(2, T0, T1); + return value0; +L17:; + if (Null(cl_stringE(2, v4, VV[3]))) { goto L20; } + T0 = ecl_fdefinition(VV[0]); + T1 = ecl_cdr(v1feature_expression); + value0 = cl_some(2, T0, T1); + return value0; +L20:; + if (Null(cl_stringE(2, v4, VV[4]))) { goto L23; } + goto L27; +L26:; + si_assert_failure(1, VV[5]); +L27:; + { + cl_fixnum v5; + v5 = ecl_length(v1feature_expression); + if ((2)==(v5)) { goto L30; } + } + goto L26; +L30:; + T0 = ecl_cadr(v1feature_expression); + T1 = L1featurep(T0); + value0 = Null(T1)?ECL_T:ECL_NIL; + cl_env_copy->nvalues = 1; + return value0; +L23:; + value0 = cl_error(3, VV[6], v4, ECL_SYM("STRING=",822)); + return value0; } - goto L28; -L32:; - T0 = ecl_cadr(v1feature_expression); - T1 = L1featurep(T0); - value0 = Null(T1)?ECL_T:ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L25:; - value0 = cl_error(3, VV[6], v3, ECL_SYM("STRING=",824)); +L5:; + value0 = si_etypecase_error(v2, VV[7]); return value0; } -L7:; - value0 = si_etypecase_error(v1feature_expression, VV[7]); - return value0; } } @@ -100,7 +93,7 @@ L7:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclq3qz1Rgh1vqFM_kFGycC71(cl_object flag) +ECL_DLLEXPORT void _eclq3qz1Rgh1vqFM_Fwg2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -115,17 +108,17 @@ ECL_DLLEXPORT void _eclq3qz1Rgh1vqFM_kFGycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/features.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/features.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclq3qz1Rgh1vqFM_kFGycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclq3qz1Rgh1vqFM_Fwg2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defun(VV[8]); /* FEATUREP */ - ecl_function_dispatch(cl_env_copy,VV[9])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); } diff --git a/lib/alexandria/functions.cxx b/lib/alexandria/functions.cxx index 6d59c39..a33638a 100644 --- a/lib/alexandria/functions.cxx +++ b/lib/alexandria/functions.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/functions.lisp */ +/* Source: lib/alexandria/functions.lisp */ #include #include "lib/alexandria/functions.eclh" /* function definition for ENSURE-FUNCTION */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L1ensure_function(cl_object v1function_designator) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -28,7 +27,6 @@ L1:; static cl_object LC3ensure_functionf_1(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -39,7 +37,7 @@ static cl_object LC3ensure_functionf_1(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -48,7 +46,7 @@ L3:; v4si___reference = v5; } if (Null(v3)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[26])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; { cl_object v6; /* VARS */ @@ -56,33 +54,31 @@ L8:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC2__lambda5,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC2__g5,ECL_NIL,Cblock,1); T0 = v12; } T1 = ECL_NIL; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L13; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; T2 = cl_listX(3, VV[0], v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; T6 = CONS(VV[2],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L13:; @@ -114,19 +110,28 @@ L22:; goto L21; L28:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, VV[0], v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L33; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L33; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, VV[0], v10, ECL_NIL); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L32; +L33:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, VV[0], v10, T3); +L32:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); T4 = CONS(VV[2],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -134,12 +139,11 @@ L28:; } } } -/* local function LAMBDA5 */ +/* local function G5 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__lambda5(cl_object v1si__v) +static cl_object LC2__g5(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -155,7 +159,6 @@ static cl_object LC2__lambda5(cl_object v1si__v) static cl_object LC5ensure_functionf(cl_object v1, cl_object v2) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -168,7 +171,7 @@ static cl_object LC5ensure_functionf(cl_object v1, cl_object v2) cl_object v4; { cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda22,ECL_NIL,Cblock,1); + v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__g22,ECL_NIL,Cblock,1); v4 = v5; } { @@ -179,8 +182,6 @@ static cl_object LC5ensure_functionf(cl_object v1, cl_object v2) cl_object v7; v7 = v3; if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v7; } { @@ -192,21 +193,17 @@ L10:; if (!(ecl_endp(v6))) { goto L12; } goto L11; L12:; - v5 = ECL_CONS_CAR(v6); + v5 = _ecl_car(v6); { cl_object v9; - v9 = ECL_CONS_CDR(v6); + v9 = _ecl_cdr(v6); if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v9; } { cl_object v9; v9 = v8; if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v9; } T2 = ecl_function_dispatch(cl_env_copy,v4)(1, v5); @@ -220,17 +217,16 @@ L11:; } } L2:; - value0 = CONS(ECL_SYM("PROGN",673),T0); + value0 = CONS(ECL_SYM("PROGN",671),T0); cl_env_copy->nvalues = 1; return value0; } } } -/* local function LAMBDA22 */ +/* local function G22 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__lambda22(cl_object v1x) +static cl_object LC4__g22(cl_object v1x) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -245,7 +241,7 @@ static cl_object LC4__lambda22(cl_object v1x) static cl_object L8disjoin(cl_narg narg, cl_object v1predicate, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -276,8 +272,6 @@ L1:; cl_object v8; v8 = v2more_predicates; if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v8; } { @@ -294,16 +288,12 @@ L14:; cl_object v10; v10 = ECL_CONS_CDR(v7); if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v10; } { cl_object v10; v10 = v9; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v10; } T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); @@ -322,7 +312,7 @@ L4:; CLV1 = env1 = CONS(v4,env1); /* MORE-PREDICATES */ { cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC7__lambda35,env1,Cblock,0); + v5 = ecl_make_cclosure_va((cl_objectfn)LC7__g35,env1,Cblock); value0 = v5; cl_env_copy->nvalues = 1; return value0; @@ -330,9 +320,9 @@ L4:; } } } -/* closure LAMBDA35 */ +/* closure G35 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC7__lambda35(cl_narg narg, ...) +static cl_object LC7__g35(cl_narg narg, ...) { cl_object T0; cl_object CLV0, CLV1, CLV2; @@ -353,7 +343,7 @@ static cl_object LC7__lambda35(cl_narg narg, ...) if ((value0)!=ECL_NIL) { goto L2; } { cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC6__lambda36,env0,Cblock,1); + v2 = ecl_make_cclosure_va((cl_objectfn)LC6__g36,env0,Cblock); T0 = v2; } value0 = cl_some(2, T0, ECL_CONS_CAR(CLV1)); @@ -364,9 +354,9 @@ L2:; } } } -/* closure LAMBDA36 */ +/* closure G36 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC6__lambda36(cl_narg narg, cl_object v1p, ...) +static cl_object LC6__g36(cl_narg narg, cl_object v1p, ...) { cl_object T0; cl_object CLV0, CLV1, CLV2; @@ -383,9 +373,7 @@ static cl_object LC6__lambda36(cl_narg narg, cl_object v1p, ...) TTL: T0 = cl_functionp(v1p); if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("FUNCTION",398),v1p); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("FUNCTION",396),v1p); value0 = cl_apply(2, v1p, ECL_CONS_CAR(CLV2)); return value0; } @@ -395,7 +383,7 @@ static cl_object LC6__lambda36(cl_narg narg, cl_object v1p, ...) /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L10conjoin(cl_narg narg, cl_object v1predicate, ...) { - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -416,16 +404,16 @@ static cl_object L10conjoin(cl_narg narg, cl_object v1predicate, ...) L1:; { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC9__lambda37,env0,Cblock,0); + v3 = ecl_make_cclosure_va((cl_objectfn)LC9__g37,env0,Cblock); value0 = v3; cl_env_copy->nvalues = 1; return value0; } } } -/* closure LAMBDA37 */ +/* closure G37 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC9__lambda37(cl_narg narg, ...) +static cl_object LC9__g37(cl_narg narg, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -483,7 +471,6 @@ L2:; static cl_object L13compose(cl_narg narg, cl_object v1function, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); @@ -494,18 +481,18 @@ static cl_object L13compose(cl_narg narg, cl_object v1function, ...) ecl_va_end(args); { cl_object v3; - v3 = ecl_make_cfun((cl_objectfn_fixed)LC12__lambda42,ECL_NIL,Cblock,2); + v3 = ecl_make_cfun((cl_objectfn_fixed)LC12__g42,ECL_NIL,Cblock,2); T0 = v3; } value0 = cl_reduce(4, T0, v2more_functions, VV[7], v1function); return value0; } } -/* local function LAMBDA42 */ +/* local function G42 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC12__lambda42(cl_object v1f, cl_object v2g) +static cl_object LC12__g42(cl_object v1f, cl_object v2g) { - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -532,7 +519,7 @@ L4:; CLV1 = env1 = CONS(v4,env1); /* G */ { cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC11__lambda47,env1,Cblock,0); + v5 = ecl_make_cclosure_va((cl_objectfn)LC11__g47,env1,Cblock); value0 = v5; cl_env_copy->nvalues = 1; return value0; @@ -540,9 +527,9 @@ L4:; } } } -/* closure LAMBDA47 */ +/* closure G47 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC11__lambda47(cl_narg narg, ...) +static cl_object LC11__g47(cl_narg narg, ...) { cl_object T0; cl_object CLV0, CLV1; @@ -564,12 +551,11 @@ static cl_object LC11__lambda47(cl_narg narg, ...) } } } -/* local function LAMBDA51 */ +/* local function COMPOSE */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15__lambda51(cl_object v1, cl_object v2) +static cl_object LC15compose(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -579,16 +565,16 @@ static cl_object LC15__lambda51(cl_object v1, cl_object v2) cl_object v3; cl_object v4function; T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } v3 = ecl_cddr(v1); goto L1; L2:; v3 = ecl_cdr(v1); L1:; if (!(v3==ECL_NIL)) { goto L6; } - ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L6:; { cl_object v5; @@ -603,7 +589,7 @@ L6:; { cl_fixnum v7; v7 = ecl_length(v5args); - v6funs = ecl_function_dispatch(cl_env_copy,VV[31])(2, ecl_make_fixnum(v7), VV[9]) /* MAKE-GENSYM-LIST */; + v6funs = ecl_function_dispatch(cl_env_copy,VV[28])(2, ecl_make_fixnum(v7), VV[9]) /* MAKE-GENSYM-LIST */; } { cl_object v7f; @@ -613,8 +599,6 @@ L6:; cl_object v9; v9 = v6funs; if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v9; } { @@ -631,33 +615,27 @@ L22:; if (!(ecl_endp(v8))) { goto L24; } goto L23; L24:; - v7f = ECL_CONS_CAR(v8); + v7f = _ecl_car(v8); { cl_object v13; - v13 = ECL_CONS_CDR(v8); + v13 = _ecl_cdr(v8); if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = v13; } if (!(ecl_endp(v10))) { goto L32; } goto L23; L32:; - v9arg = ECL_CONS_CAR(v10); + v9arg = _ecl_car(v10); { cl_object v13; - v13 = ECL_CONS_CDR(v10); + v13 = _ecl_cdr(v10); if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v10 = v13; } { cl_object v13; v13 = v12; if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v13; } T2 = cl_list(2, VV[0], v9arg); @@ -673,8 +651,8 @@ L23:; } L13:; T1 = LC14compose_1(v6funs); - T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[11], VV[12], T1); - value0 = cl_list(4, ECL_SYM("LET",479), T0, VV[10], T2); + T2 = cl_list(4, ECL_SYM("LAMBDA",452), VV[11], VV[12], T1); + value0 = cl_list(4, ECL_SYM("LET",477), T0, VV[10], T2); return value0; } } @@ -685,7 +663,6 @@ L13:; static cl_object LC14compose_1(cl_object v1funs) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -695,11 +672,11 @@ static cl_object LC14compose_1(cl_object v1funs) T0 = ecl_car(v1funs); T2 = ecl_cdr(v1funs); T1 = LC14compose_1(T2); - value0 = cl_list(3, ECL_SYM("FUNCALL",396), T0, T1); + value0 = cl_list(3, ECL_SYM("FUNCALL",394), T0, T1); return value0; L1:; T0 = ecl_car(v1funs); - value0 = cl_list(3, ECL_SYM("APPLY",91), T0, VV[8]); + value0 = cl_list(3, ECL_SYM("APPLY",89), T0, VV[8]); return value0; } } @@ -708,7 +685,6 @@ L1:; static cl_object L18multiple_value_compose(cl_narg narg, cl_object v1function, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); @@ -719,18 +695,18 @@ static cl_object L18multiple_value_compose(cl_narg narg, cl_object v1function, . ecl_va_end(args); { cl_object v3; - v3 = ecl_make_cfun((cl_objectfn_fixed)LC17__lambda61,ECL_NIL,Cblock,2); + v3 = ecl_make_cfun((cl_objectfn_fixed)LC17__g60,ECL_NIL,Cblock,2); T0 = v3; } value0 = cl_reduce(4, T0, v2more_functions, VV[7], v1function); return value0; } } -/* local function LAMBDA61 */ +/* local function G60 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC17__lambda61(cl_object v1f, cl_object v2g) +static cl_object LC17__g60(cl_object v1f, cl_object v2g) { - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -757,7 +733,7 @@ L4:; CLV1 = env1 = CONS(v4,env1); /* G */ { cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC16__lambda66,env1,Cblock,0); + v5 = ecl_make_cclosure_va((cl_objectfn)LC16__g65,env1,Cblock); value0 = v5; cl_env_copy->nvalues = 1; return value0; @@ -765,9 +741,9 @@ L4:; } } } -/* closure LAMBDA66 */ +/* closure G65 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC16__lambda66(cl_narg narg, ...) +static cl_object LC16__g65(cl_narg narg, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -792,9 +768,7 @@ static cl_object LC16__lambda66(cl_narg narg, ...) cl_object v3; v3 = ECL_CONS_CAR(CLV0); cl_env_copy->values[0] = cl_apply(2, ECL_CONS_CAR(CLV1), v1arguments); - ecl_stack_frame_push_values(v2); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0;cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); + ecl_stack_frame_push_values(v2);cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); value0 = cl_env_copy->values[0]; } } @@ -804,12 +778,11 @@ static cl_object LC16__lambda66(cl_narg narg, ...) } } } -/* local function LAMBDA72 */ +/* local function MULTIPLE-VALUE-COMPOSE */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC20__lambda72(cl_object v1, cl_object v2) +static cl_object LC20multiple_value_compose(cl_object v1, cl_object v2) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -819,16 +792,16 @@ static cl_object LC20__lambda72(cl_object v1, cl_object v2) cl_object v3; cl_object v4function; T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } v3 = ecl_cddr(v1); goto L1; L2:; v3 = ecl_cdr(v1); L1:; if (!(v3==ECL_NIL)) { goto L6; } - ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L6:; { cl_object v5; @@ -843,11 +816,11 @@ L6:; { cl_fixnum v7; v7 = ecl_length(v5args); - v6funs = ecl_function_dispatch(cl_env_copy,VV[31])(2, ecl_make_fixnum(v7), VV[14]) /* MAKE-GENSYM-LIST */; + v6funs = ecl_function_dispatch(cl_env_copy,VV[28])(2, ecl_make_fixnum(v7), VV[14]) /* MAKE-GENSYM-LIST */; } { cl_object v7; - v7 = (ECL_SYM("LIST",483)->symbol.gfdef); + v7 = (ECL_SYM("LIST",481)->symbol.gfdef); { cl_object v8; cl_object v9; @@ -856,8 +829,6 @@ L6:; cl_object v10; v10 = v6funs; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -874,33 +845,27 @@ L23:; if (!(ecl_endp(v9))) { goto L25; } goto L24; L25:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v14; - v14 = ECL_CONS_CDR(v9); + v14 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v14; } if (!(ecl_endp(v11))) { goto L33; } goto L24; L33:; - v10 = ECL_CONS_CAR(v11); + v10 = _ecl_car(v11); { cl_object v14; - v14 = ECL_CONS_CDR(v11); + v14 = _ecl_cdr(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v14; } T2 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); @@ -916,8 +881,8 @@ L24:; } L13:; T1 = LC19compose_1(v6funs); - T2 = cl_list(4, ECL_SYM("LAMBDA",454), VV[11], VV[12], T1); - value0 = cl_list(4, ECL_SYM("LET",479), T0, VV[10], T2); + T2 = cl_list(4, ECL_SYM("LAMBDA",452), VV[11], VV[12], T1); + value0 = cl_list(4, ECL_SYM("LET",477), T0, VV[10], T2); return value0; } } @@ -928,7 +893,6 @@ L13:; static cl_object LC19compose_1(cl_object v1funs) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -938,11 +902,11 @@ static cl_object LC19compose_1(cl_object v1funs) T0 = ecl_car(v1funs); T2 = ecl_cdr(v1funs); T1 = LC19compose_1(T2); - value0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",575), T0, T1); + value0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",573), T0, T1); return value0; L1:; T0 = ecl_car(v1funs); - value0 = cl_list(3, ECL_SYM("APPLY",91), T0, VV[8]); + value0 = cl_list(3, ECL_SYM("APPLY",89), T0, VV[8]); return value0; } } @@ -951,7 +915,7 @@ L1:; static cl_object L22curry(cl_narg narg, cl_object v1function, ...) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -974,7 +938,7 @@ L1:; CLV1 = env1 = CONS(T0,env1); /* FN */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC21__lambda86,env1,Cblock,0); + v3 = ecl_make_cclosure_va((cl_objectfn)LC21__g84,env1,Cblock); value0 = v3; cl_env_copy->nvalues = 1; return value0; @@ -982,9 +946,9 @@ L1:; } } } -/* closure LAMBDA86 */ +/* closure G84 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC21__lambda86(cl_narg narg, ...) +static cl_object LC21__g84(cl_narg narg, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -1010,12 +974,8 @@ static cl_object LC21__lambda86(cl_narg narg, ...) v3 = ECL_CONS_CAR(CLV1); cl_env_copy->values[0] = cl_values_list(ECL_CONS_CAR(CLV0)); ecl_stack_frame_push_values(v2); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; cl_env_copy->values[0] = cl_values_list(v1more); - ecl_stack_frame_push_values(v2); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0;cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); + ecl_stack_frame_push_values(v2);cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); value0 = cl_env_copy->values[0]; } } @@ -1025,12 +985,11 @@ static cl_object LC21__lambda86(cl_narg narg, ...) } } } -/* local function LAMBDA92 */ +/* local function CURRY */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC23__lambda92(cl_object v1, cl_object v2) +static cl_object LC23curry(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1040,16 +999,16 @@ static cl_object LC23__lambda92(cl_object v1, cl_object v2) cl_object v3; cl_object v4function; T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } v3 = ecl_cddr(v1); goto L1; L2:; v3 = ecl_cdr(v1); L1:; if (!(v3==ECL_NIL)) { goto L6; } - ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L6:; { cl_object v5; @@ -1063,14 +1022,14 @@ L6:; { cl_fixnum v7; v7 = ecl_length(v3); - v5 = ecl_function_dispatch(cl_env_copy,VV[31])(2, ecl_make_fixnum(v7), VV[16]) /* MAKE-GENSYM-LIST */; + v5 = ecl_function_dispatch(cl_env_copy,VV[28])(2, ecl_make_fixnum(v7), VV[16]) /* MAKE-GENSYM-LIST */; } v6 = cl_gensym(1, VV[17]); T0 = cl_list(2, VV[0], v4function); T1 = cl_list(2, v6, T0); { cl_object v7; - v7 = (ECL_SYM("LIST",483)->symbol.gfdef); + v7 = (ECL_SYM("LIST",481)->symbol.gfdef); { cl_object v8; cl_object v9; @@ -1079,8 +1038,6 @@ L6:; cl_object v10; v10 = v5; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -1091,8 +1048,6 @@ L6:; cl_object v12; v12 = v3; if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v12; } { @@ -1104,33 +1059,27 @@ L25:; if (!(ecl_endp(v9))) { goto L27; } goto L26; L27:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v14; - v14 = ECL_CONS_CDR(v9); + v14 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v14; } if (!(ecl_endp(v11))) { goto L35; } goto L26; L35:; - v10 = ECL_CONS_CAR(v11); + v10 = _ecl_car(v11); { cl_object v14; - v14 = ECL_CONS_CDR(v11); + v14 = _ecl_cdr(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T3 = v14; } T4 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); @@ -1147,9 +1096,9 @@ L26:; L13:; T3 = CONS(T1,T2); T4 = ecl_append(v5,VV[19]); - T5 = cl_listX(3, ECL_SYM("APPLY",91), v6, T4); - T6 = cl_list(3, ECL_SYM("LAMBDA",454), VV[18], T5); - value0 = cl_list(4, ECL_SYM("LET",479), T3, VV[10], T6); + T5 = cl_listX(3, ECL_SYM("APPLY",89), v6, T4); + T6 = cl_list(3, ECL_SYM("LAMBDA",452), VV[18], T5); + value0 = cl_list(4, ECL_SYM("LET",477), T3, VV[10], T6); return value0; } } @@ -1160,7 +1109,7 @@ L13:; static cl_object L25rcurry(cl_narg narg, cl_object v1function, ...) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1183,7 +1132,7 @@ L1:; CLV1 = env1 = CONS(T0,env1); /* FN */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC24__lambda108,env1,Cblock,0); + v3 = ecl_make_cclosure_va((cl_objectfn)LC24__g105,env1,Cblock); value0 = v3; cl_env_copy->nvalues = 1; return value0; @@ -1191,9 +1140,9 @@ L1:; } } } -/* closure LAMBDA108 */ +/* closure G105 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC24__lambda108(cl_narg narg, ...) +static cl_object LC24__g105(cl_narg narg, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -1219,12 +1168,8 @@ static cl_object LC24__lambda108(cl_narg narg, ...) v3 = ECL_CONS_CAR(CLV1); cl_env_copy->values[0] = cl_values_list(v1more); ecl_stack_frame_push_values(v2); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; cl_env_copy->values[0] = cl_values_list(ECL_CONS_CAR(CLV0)); - ecl_stack_frame_push_values(v2); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0;cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); + ecl_stack_frame_push_values(v2);cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); value0 = cl_env_copy->values[0]; } } @@ -1239,7 +1184,6 @@ static cl_object LC24__lambda108(cl_narg narg, ...) static cl_object LC26named_lambda(cl_object v1, cl_object v2) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1251,7 +1195,7 @@ static cl_object LC26named_lambda(cl_object v1, cl_object v2) cl_object v5lambda_list; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -1260,7 +1204,7 @@ L3:; v4name = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[25])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -1270,8 +1214,8 @@ L9:; } T0 = cl_listX(3, v4name, v5lambda_list, v3); T1 = ecl_list1(T0); - T2 = cl_list(2, ECL_SYM("FUNCTION",398), v4name); - value0 = cl_list(3, ECL_SYM("LABELS",453), T1, T2); + T2 = cl_list(2, ECL_SYM("FUNCTION",396), v4name); + value0 = cl_list(3, ECL_SYM("LABELS",451), T1, T2); return value0; } } @@ -1281,7 +1225,7 @@ L9:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclNfUD6Zhj9JNJM_QVGycC71(cl_object flag) +ECL_DLLEXPORT void _eclNfUD6Zhj9JNJM_UCh2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1296,88 +1240,84 @@ ECL_DLLEXPORT void _eclNfUD6Zhj9JNJM_QVGycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/functions.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/functions.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclNfUD6Zhj9JNJM_QVGycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclNfUD6Zhj9JNJM_UCh2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[2]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[3], VVtemp[4]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[5]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[2]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[3], VVtemp[4]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[5]) /* ANNOTATE */; ecl_cmp_defun(VV[22]); /* ENSURE-FUNCTION */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[6]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[7]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[24]); /* ENSURE-FUNCTIONF/1 */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[13]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[27]); /* ENSURE-FUNCTIONF */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[17]) /* ANNOTATE */; - ecl_cmp_defun(VV[28]); /* DISJOIN */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[18]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[19], VVtemp[20]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[17]) /* ANNOTATE */; - ecl_cmp_defun(VV[29]); /* CONJOIN */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[21]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[23]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[24]) /* ANNOTATE */; - ecl_cmp_defun(VV[30]); /* COMPOSE */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[25]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[6]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[7], VVtemp[8]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[9]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[23]); /* ENSURE-FUNCTIONF/1 */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[12]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[24]); /* ENSURE-FUNCTIONF */ + si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[13]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[25]); /* DISJOIN */ + si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[17]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[26]); /* CONJOIN */ + si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[20]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; + ecl_cmp_defun(VV[27]); /* COMPOSE */ + si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[24]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC15__lambda51,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC15compose,ECL_NIL,Cblock,2); T0 = v1; } - si_put_sysprop(VV[6], ECL_SYM("COMPILER-MACRO",240), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + si_put_sysprop(VV[6], ECL_SYM("COMPILER-MACRO",238), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[28], VVtemp[29]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[24]) /* ANNOTATE */; - ecl_cmp_defun(VV[32]); /* MULTIPLE-VALUE-COMPOSE */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[30]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; + ecl_cmp_defun(VV[29]); /* MULTIPLE-VALUE-COMPOSE */ + si_set_documentation(3, VV[13], ECL_SYM("FUNCTION",396), VVtemp[29]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC20__lambda72,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC20multiple_value_compose,ECL_NIL,Cblock,2); T0 = v1; } - si_put_sysprop(VV[13], ECL_SYM("COMPILER-MACRO",240), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + si_put_sysprop(VV[13], ECL_SYM("COMPILER-MACRO",238), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[31]) /* ANNOTATE */; } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; - ecl_cmp_defun(VV[33]); /* CURRY */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[15], ECL_SYM("FUNCTION",398), VVtemp[36]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[32], VVtemp[33]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[34]) /* ANNOTATE */; + ecl_cmp_defun(VV[30]); /* CURRY */ + si_set_documentation(3, VV[15], ECL_SYM("FUNCTION",396), VVtemp[35]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC23__lambda92,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC23curry,ECL_NIL,Cblock,2); T0 = v1; } - si_put_sysprop(VV[15], ECL_SYM("COMPILER-MACRO",240), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[37], VVtemp[38]) /* ANNOTATE */; + si_put_sysprop(VV[15], ECL_SYM("COMPILER-MACRO",238), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[36], VVtemp[37]) /* ANNOTATE */; } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[40]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; - ecl_cmp_defun(VV[34]); /* RCURRY */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[41]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LOCATION",1862), VVtemp[42], VVtemp[43]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[44]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[35]); /* NAMED-LAMBDA */ - ecl_function_dispatch(cl_env_copy,VV[23])(3, VV[21], ECL_SYM("FUNCTION",398), VVtemp[45]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[38], VVtemp[39]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[34]) /* ANNOTATE */; + ecl_cmp_defun(VV[31]); /* RCURRY */ + si_set_documentation(3, VV[20], ECL_SYM("FUNCTION",396), VVtemp[40]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[41], VVtemp[42]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[43]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[32]); /* NAMED-LAMBDA */ + si_set_documentation(3, VV[21], ECL_SYM("FUNCTION",396), VVtemp[44]); } diff --git a/lib/alexandria/hash-tables.cxx b/lib/alexandria/hash-tables.cxx index 5e4017f..5c105ea 100644 --- a/lib/alexandria/hash-tables.cxx +++ b/lib/alexandria/hash-tables.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/hash-tables.lisp */ +/* Source: lib/alexandria/hash-tables.lisp */ #include #include "lib/alexandria/hash-tables.eclh" /* function definition for COPY-HASH-TABLE */ @@ -9,7 +9,7 @@ static cl_object L2copy_hash_table(cl_narg narg, cl_object v1table, ...) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -34,7 +34,7 @@ static cl_object L2copy_hash_table(cl_narg narg, cl_object v1table, ...) } value0 = ECL_CONS_CAR(CLV0); if ((value0)!=ECL_NIL) { goto L4; } - ECL_CONS_CAR(CLV0) = ECL_SYM("IDENTITY",428); + ECL_CONS_CAR(CLV0) = ECL_SYM("IDENTITY",426); goto L2; L4:; ECL_CONS_CAR(CLV0) = value0; @@ -74,11 +74,11 @@ L24:; L22:; { cl_object env1 = env0; - T0 = cl_make_hash_table(8, ECL_SYM("TEST",1350), v2test, ECL_SYM("SIZE",1342), v3size, ECL_SYM("REHASH-SIZE",1331), v4rehash_size, ECL_SYM("REHASH-THRESHOLD",1332), v5rehash_threshold); + T0 = cl_make_hash_table(8, ECL_SYM("TEST",1321), v2test, ECL_SYM("SIZE",1313), v3size, ECL_SYM("REHASH-SIZE",1302), v4rehash_size, ECL_SYM("REHASH-THRESHOLD",1303), v5rehash_threshold); CLV1 = env1 = CONS(T0,env1); /* COPY */ { cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC1__lambda5,env1,Cblock,2); + v6 = ecl_make_cclosure_va((cl_objectfn)LC1__g5,env1,Cblock); T0 = v6; } cl_maphash(T0, v1table); @@ -88,9 +88,9 @@ L22:; } } } -/* closure LAMBDA5 */ +/* closure G5 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__lambda5(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC1__g5(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object T0; cl_object CLV0, CLV1; @@ -116,7 +116,7 @@ static cl_object LC1__lambda5(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L4maphash_keys(cl_object v1function, cl_object v2table) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -126,16 +126,16 @@ static cl_object L4maphash_keys(cl_object v1function, cl_object v2table) CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC3__lambda9,env0,Cblock,2); + v3 = ecl_make_cclosure_va((cl_objectfn)LC3__g9,env0,Cblock); T0 = v3; } value0 = cl_maphash(T0, v2table); return value0; } } -/* closure LAMBDA9 */ +/* closure G9 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3__lambda9(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC3__g9(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -158,7 +158,7 @@ static cl_object LC3__lambda9(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L6maphash_values(cl_object v1function, cl_object v2table) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -168,16 +168,16 @@ static cl_object L6maphash_values(cl_object v1function, cl_object v2table) CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC5__lambda10,env0,Cblock,2); + v3 = ecl_make_cclosure_va((cl_objectfn)LC5__g10,env0,Cblock); T0 = v3; } value0 = cl_maphash(T0, v2table); return value0; } } -/* closure LAMBDA10 */ +/* closure G10 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5__lambda10(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC5__g10(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -200,7 +200,7 @@ static cl_object LC5__lambda10(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L9hash_table_keys(cl_object v1table) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -216,13 +216,13 @@ static cl_object L9hash_table_keys(cl_object v1table) cl_object env2 = env1; { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC7__lambda13,env2,Cblock,1); + v3 = ecl_make_cclosure_va((cl_objectfn)LC7__g13,env2,Cblock); v2 = v3; } CLV1 = env2 = CONS(v2,env2); /* FUNCTION */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC8__lambda15,env2,Cblock,2); + v3 = ecl_make_cclosure_va((cl_objectfn)LC8__g15,env2,Cblock); T0 = v3; } cl_maphash(T0, v1table); @@ -233,9 +233,9 @@ static cl_object L9hash_table_keys(cl_object v1table) } } } -/* closure LAMBDA13 */ +/* closure G13 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__lambda13(cl_narg narg, cl_object v1k, ...) +static cl_object LC7__g13(cl_narg narg, cl_object v1k, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -255,9 +255,9 @@ static cl_object LC7__lambda13(cl_narg narg, cl_object v1k, ...) } } } -/* closure LAMBDA15 */ +/* closure G15 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__lambda15(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC8__g15(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -281,7 +281,7 @@ static cl_object LC8__lambda15(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L12hash_table_values(cl_object v1table) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -297,13 +297,13 @@ static cl_object L12hash_table_values(cl_object v1table) cl_object env2 = env1; { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC10__lambda18,env2,Cblock,1); + v3 = ecl_make_cclosure_va((cl_objectfn)LC10__g18,env2,Cblock); v2 = v3; } CLV1 = env2 = CONS(v2,env2); /* FUNCTION */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC11__lambda20,env2,Cblock,2); + v3 = ecl_make_cclosure_va((cl_objectfn)LC11__g20,env2,Cblock); T0 = v3; } cl_maphash(T0, v1table); @@ -314,9 +314,9 @@ static cl_object L12hash_table_values(cl_object v1table) } } } -/* closure LAMBDA18 */ +/* closure G18 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10__lambda18(cl_narg narg, cl_object v1v, ...) +static cl_object LC10__g18(cl_narg narg, cl_object v1v, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -336,9 +336,9 @@ static cl_object LC10__lambda18(cl_narg narg, cl_object v1v, ...) } } } -/* closure LAMBDA20 */ +/* closure G20 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__lambda20(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC11__g20(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -362,7 +362,7 @@ static cl_object LC11__lambda20(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L14hash_table_alist(cl_object v1table) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -375,7 +375,7 @@ static cl_object L14hash_table_alist(cl_object v1table) CLV0 = env1 = CONS(ECL_NIL,env1); /* ALIST */ { cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC13__lambda21,env1,Cblock,2); + v2 = ecl_make_cclosure_va((cl_objectfn)LC13__g21,env1,Cblock); T0 = v2; } cl_maphash(T0, v1table); @@ -385,9 +385,9 @@ static cl_object L14hash_table_alist(cl_object v1table) } } } -/* closure LAMBDA21 */ +/* closure G21 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13__lambda21(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC13__g21(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object T0; cl_object CLV0; @@ -414,7 +414,7 @@ static cl_object LC13__lambda21(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L16hash_table_plist(cl_object v1table) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -427,7 +427,7 @@ static cl_object L16hash_table_plist(cl_object v1table) CLV0 = env1 = CONS(ECL_NIL,env1); /* PLIST */ { cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC15__lambda23,env1,Cblock,2); + v2 = ecl_make_cclosure_va((cl_objectfn)LC15__g23,env1,Cblock); T0 = v2; } cl_maphash(T0, v1table); @@ -437,9 +437,9 @@ static cl_object L16hash_table_plist(cl_object v1table) } } } -/* closure LAMBDA23 */ +/* closure G23 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15__lambda23(cl_narg narg, cl_object v1k, cl_object v2v, ...) +static cl_object LC15__g23(cl_narg narg, cl_object v1k, cl_object v2v, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -464,7 +464,6 @@ static cl_object LC15__lambda23(cl_narg narg, cl_object v1k, cl_object v2v, ...) static cl_object L17alist_hash_table(cl_narg narg, cl_object v1alist, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -476,7 +475,7 @@ static cl_object L17alist_hash_table(cl_narg narg, cl_object v1alist, ...) ecl_va_end(args); { cl_object v3table; - T0 = (ECL_SYM("MAKE-HASH-TABLE",530)->symbol.gfdef); + T0 = (ECL_SYM("MAKE-HASH-TABLE",528)->symbol.gfdef); v3table = cl_apply(2, T0, v2hash_table_initargs); { cl_object v4; @@ -507,7 +506,6 @@ L14:; static cl_object L18plist_hash_table(cl_narg narg, cl_object v1plist, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -519,7 +517,7 @@ static cl_object L18plist_hash_table(cl_narg narg, cl_object v1plist, ...) ecl_va_end(args); { cl_object v3table; - T0 = (ECL_SYM("MAKE-HASH-TABLE",530)->symbol.gfdef); + T0 = (ECL_SYM("MAKE-HASH-TABLE",528)->symbol.gfdef); v3table = cl_apply(2, T0, v2hash_table_initargs); { cl_object v4tail; @@ -546,7 +544,6 @@ L12:; static cl_object LC19ensure_gethash(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -559,7 +556,7 @@ static cl_object LC19ensure_gethash(cl_object v1, cl_object v2) cl_object v6default; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v7; @@ -568,7 +565,7 @@ L3:; v4key = v7; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[29])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v7; @@ -588,14 +585,14 @@ L15:; v6default = ECL_NIL; L14:; if (Null(v3)) { goto L20; } - ecl_function_dispatch(cl_env_copy,VV[30])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L20:; - T0 = cl_list(3, ECL_SYM("GETHASH",415), v4key, v5hash_table); - T1 = cl_list(3, ECL_SYM("GETHASH",415), v4key, v5hash_table); - T2 = cl_list(3, ECL_SYM("SETF",752), T1, v6default); - T3 = cl_list(3, ECL_SYM("VALUES",897), T2, ECL_NIL); - T4 = cl_list(4, ECL_SYM("IF",948), VV[11], VV[12], T3); - value0 = cl_list(4, ECL_SYM("MULTIPLE-VALUE-BIND",574), VV[10], T0, T4); + T0 = cl_list(3, ECL_SYM("GETHASH",413), v4key, v5hash_table); + T1 = cl_list(3, ECL_SYM("GETHASH",413), v4key, v5hash_table); + T2 = cl_list(3, ECL_SYM("SETF",750), T1, v6default); + T3 = cl_list(3, ECL_SYM("VALUES",895), T2, ECL_NIL); + T4 = cl_list(4, ECL_SYM("IF",946), VV[11], VV[12], T3); + value0 = cl_list(4, ECL_SYM("MULTIPLE-VALUE-BIND",572), VV[10], T0, T4); return value0; } } @@ -605,7 +602,7 @@ L20:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecl7ZmCSEYoe0NCM_eTFycC71(cl_object flag) +ECL_DLLEXPORT void _ecl7ZmCSEYoe0NCM_yPg2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -620,57 +617,55 @@ ECL_DLLEXPORT void _ecl7ZmCSEYoe0NCM_eTFycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/hash-tables.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/hash-tables.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl7ZmCSEYoe0NCM_eTFycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl7ZmCSEYoe0NCM_yPg2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defun(VV[13]); /* COPY-HASH-TABLE */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[5]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[20]); /* MAPHASH-KEYS */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[9]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[1], ECL_SYM("INLINE",436), VVtemp[10]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[11]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[21]); /* MAPHASH-VALUES */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[2], ECL_SYM("INLINE",436), VVtemp[15]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[22]); /* HASH-TABLE-KEYS */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[23]); /* HASH-TABLE-VALUES */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[22]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[23], VVtemp[24]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[24]); /* HASH-TABLE-ALIST */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[25]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[27]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[25]); /* HASH-TABLE-PLIST */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[28]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[31]) /* ANNOTATE */; - ecl_cmp_defun(VV[26]); /* ALIST-HASH-TABLE */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[7], ECL_SYM("FUNCTION",398), VVtemp[32]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[35]) /* ANNOTATE */; - ecl_cmp_defun(VV[27]); /* PLIST-HASH-TABLE */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[36]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[37], VVtemp[38]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[39]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[28]); /* ENSURE-GETHASH */ - ecl_function_dispatch(cl_env_copy,VV[14])(3, VV[9], ECL_SYM("FUNCTION",398), VVtemp[40]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[5]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[19]); /* MAPHASH-KEYS */ + si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[9]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[10]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[20]); /* MAPHASH-VALUES */ + si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[13]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[21]); /* HASH-TABLE-KEYS */ + si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[17]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[22]); /* HASH-TABLE-VALUES */ + si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[20]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[23]); /* HASH-TABLE-ALIST */ + si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[23]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[24]); /* HASH-TABLE-PLIST */ + si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[26]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defun(VV[25]); /* ALIST-HASH-TABLE */ + si_set_documentation(3, VV[7], ECL_SYM("FUNCTION",396), VVtemp[30]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defun(VV[26]); /* PLIST-HASH-TABLE */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[34]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[35], VVtemp[36]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[37]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[27]); /* ENSURE-GETHASH */ + si_set_documentation(3, VV[9], ECL_SYM("FUNCTION",396), VVtemp[38]); } diff --git a/lib/alexandria/io.cxx b/lib/alexandria/io.cxx index 1def85f..cd093eb 100644 --- a/lib/alexandria/io.cxx +++ b/lib/alexandria/io.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/io.lisp */ +/* Source: lib/alexandria/io.lisp */ #include #include "lib/alexandria/io.eclh" /* local function WITH-OPEN-FILE* */ @@ -9,7 +9,6 @@ static cl_object LC1with_open_file_(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -33,7 +32,7 @@ static cl_object LC1with_open_file_(cl_object v1, cl_object v2) cl_object v17external_format; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v18; @@ -43,7 +42,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v18; @@ -52,7 +51,7 @@ L10:; v6stream = v18; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v18; @@ -60,42 +59,42 @@ L16:; v5 = ecl_cdr(v5); v7filespec = v18; } - v8 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("DIRECTION",1246)) /* SEARCH-KEYWORD */; - if (!((v8)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L23; } + v8 = si_search_keyword(2, v5, ECL_SYM("DIRECTION",1221)); + if (!((v8)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L23; } v9direction = ECL_NIL; goto L22; L23:; v9direction = v8; L22:; - v10 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("ELEMENT-TYPE",1252)) /* SEARCH-KEYWORD */; - if (!((v10)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L27; } + v10 = si_search_keyword(2, v5, ECL_SYM("ELEMENT-TYPE",1227)); + if (!((v10)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L27; } v11element_type = ECL_NIL; goto L26; L27:; v11element_type = v10; L26:; - v12 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("IF-EXISTS",1276)) /* SEARCH-KEYWORD */; - if (!((v12)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L31; } + v12 = si_search_keyword(2, v5, ECL_SYM("IF-EXISTS",1249)); + if (!((v12)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L31; } v13if_exists = ECL_NIL; goto L30; L31:; v13if_exists = v12; L30:; - v14 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("IF-DOES-NOT-EXIST",1274)) /* SEARCH-KEYWORD */; - if (!((v14)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L35; } + v14 = si_search_keyword(2, v5, ECL_SYM("IF-DOES-NOT-EXIST",1247)); + if (!((v14)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L35; } v15if_does_not_exist = ECL_NIL; goto L34; L35:; v15if_does_not_exist = v14; L34:; - v16 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("EXTERNAL-FORMAT",1264)) /* SEARCH-KEYWORD */; - if (!((v16)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L39; } + v16 = si_search_keyword(2, v5, ECL_SYM("EXTERNAL-FORMAT",1239)); + if (!((v16)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L39; } v17external_format = ECL_NIL; goto L38; L39:; v17external_format = v16; L38:; - ecl_function_dispatch(cl_env_copy,VV[37])(2, v5, VV[1]) /* CHECK-KEYWORD */; + si_check_keyword(2, v5, VV[1]); { cl_object v18; cl_object v19; @@ -113,21 +112,21 @@ L38:; T3 = cl_list(2, v21, v15if_does_not_exist); T4 = cl_list(2, v22, v17external_format); T5 = cl_list(5, T0, T1, T2, T3, T4); - T7 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("DIRECTION",1246), v18); - T8 = cl_list(3, ECL_SYM("WHEN",907), v18, T7); - T9 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("ELEMENT-TYPE",1252), v19); - T10 = cl_list(3, ECL_SYM("WHEN",907), v19, T9); - T11 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("IF-EXISTS",1276), v20); - T12 = cl_list(3, ECL_SYM("WHEN",907), v20, T11); - T13 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("IF-DOES-NOT-EXIST",1274), v21); - T14 = cl_list(3, ECL_SYM("WHEN",907), v21, T13); - T15 = cl_list(3, ECL_SYM("LIST",483), ECL_SYM("EXTERNAL-FORMAT",1264), v22); - T16 = cl_list(3, ECL_SYM("WHEN",907), v22, T15); - T17 = cl_list(6, ECL_SYM("APPEND",90), T8, T10, T12, T14, T16); - T18 = cl_list(4, ECL_SYM("APPLY",91), VV[7], v7filespec, T17); + T7 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("DIRECTION",1221), v18); + T8 = cl_list(3, ECL_SYM("WHEN",905), v18, T7); + T9 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("ELEMENT-TYPE",1227), v19); + T10 = cl_list(3, ECL_SYM("WHEN",905), v19, T9); + T11 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("IF-EXISTS",1249), v20); + T12 = cl_list(3, ECL_SYM("WHEN",905), v20, T11); + T13 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("IF-DOES-NOT-EXIST",1247), v21); + T14 = cl_list(3, ECL_SYM("WHEN",905), v21, T13); + T15 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("EXTERNAL-FORMAT",1239), v22); + T16 = cl_list(3, ECL_SYM("WHEN",905), v22, T15); + T17 = cl_list(6, ECL_SYM("APPEND",88), T8, T10, T12, T14, T16); + T18 = cl_list(4, ECL_SYM("APPLY",89), VV[7], v7filespec, T17); T19 = cl_list(2, v6stream, T18); - T6 = cl_listX(3, ECL_SYM("WITH-OPEN-STREAM",914), T19, v3); - value0 = cl_list(3, ECL_SYM("LET",479), T5, T6); + T6 = cl_listX(3, ECL_SYM("WITH-OPEN-STREAM",912), T19, v3); + value0 = cl_list(3, ECL_SYM("LET",477), T5, T6); return value0; } } @@ -138,7 +137,6 @@ L38:; static cl_object LC2with_input_from_file(cl_object v1, cl_object v2) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -154,7 +152,7 @@ static cl_object LC2with_input_from_file(cl_object v1, cl_object v2) cl_object v9direction_p; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v10; @@ -164,7 +162,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v10; @@ -173,7 +171,7 @@ L10:; v6stream_name = v10; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v10; @@ -181,17 +179,17 @@ L16:; v5 = ecl_cdr(v5); v7file_name = v10; } - v8 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("DIRECTION",1246)) /* SEARCH-KEYWORD */; + v8 = si_search_keyword(2, v5, ECL_SYM("DIRECTION",1221)); { bool v10; - v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",2037)); + v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",1943)); v9direction_p = (v10)?ECL_NIL:ECL_T; } - ecl_function_dispatch(cl_env_copy,VV[37])(3, v5, VV[9], ECL_T) /* CHECK-KEYWORD */; + si_check_keyword(3, v5, VV[9], ECL_T); if (Null(v9direction_p)) { goto L24; } cl_error(1, VV[10]); L24:; - T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286), v5); + T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259), v5); value0 = cl_listX(3, VV[0], T0, v3); return value0; } @@ -202,7 +200,6 @@ L24:; static cl_object LC3with_output_to_file(cl_object v1, cl_object v2) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -218,7 +215,7 @@ static cl_object LC3with_output_to_file(cl_object v1, cl_object v2) cl_object v9direction_p; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v10; @@ -228,7 +225,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v10; @@ -237,7 +234,7 @@ L10:; v6stream_name = v10; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[35])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v10; @@ -245,17 +242,17 @@ L16:; v5 = ecl_cdr(v5); v7file_name = v10; } - v8 = ecl_function_dispatch(cl_env_copy,VV[36])(2, v5, ECL_SYM("DIRECTION",1246)) /* SEARCH-KEYWORD */; + v8 = si_search_keyword(2, v5, ECL_SYM("DIRECTION",1221)); { bool v10; - v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",2037)); + v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",1943)); v9direction_p = (v10)?ECL_NIL:ECL_T; } - ecl_function_dispatch(cl_env_copy,VV[37])(3, v5, VV[9], ECL_T) /* CHECK-KEYWORD */; + si_check_keyword(3, v5, VV[9], ECL_T); if (Null(v9direction_p)) { goto L24; } cl_error(1, VV[12]); L24:; - T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316), v5); + T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287), v5); value0 = cl_listX(3, VV[0], T0, v3); return value0; } @@ -266,7 +263,6 @@ L24:; static cl_object L4read_file_into_string(volatile cl_narg narg, cl_object volatile v1pathname, ...) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object volatile env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; ecl_cs_check(cl_env_copy,value0); @@ -288,33 +284,33 @@ static cl_object L4read_file_into_string(volatile cl_narg narg, cl_object volati } { volatile cl_object v4file_stream; - T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); - if (Null(ECL_SYM("INPUT",1286))) { goto L5; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286)); + T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); + if (Null(ECL_SYM("INPUT",1259))) { goto L5; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259)); goto L4; L5:; T1 = ECL_NIL; L4:; goto L8; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), ECL_NIL); + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), ECL_NIL); goto L7; L8:; T2 = ECL_NIL; L7:; goto L11; - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), ECL_NIL); + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), ECL_NIL); goto L10; L11:; T3 = ECL_NIL; L10:; goto L14; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); goto L13; L14:; T4 = ECL_NIL; L13:; if (Null(v3external_format)) { goto L17; } - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), v3external_format); + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), v3external_format); goto L16; L17:; T5 = ECL_NIL; @@ -325,48 +321,31 @@ L16:; volatile bool unwinding = FALSE; cl_index v5=ECL_STACK_INDEX(cl_env_copy),v6; ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { + if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; } else { - ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",57),ECL_NIL); /* *PRINT-PRETTY* */ + ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",55),ECL_NIL); /* *PRINT-PRETTY* */ { - volatile cl_object v7datum; + cl_object v7datum; v7datum = cl_make_string_output_stream(0); { - volatile bool unwinding = FALSE; - cl_index v8=ECL_STACK_INDEX(cl_env_copy),v9; - ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { + cl_object v8buffer; + v8buffer = si_make_pure_array(ECL_SYM("CHARACTER",222), v2buffer_size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); { - cl_object v10buffer; - v10buffer = si_make_pure_array(ECL_SYM("CHARACTER",224), v2buffer_size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - { - cl_object v11bytes_read; - v11bytes_read = ECL_NIL; + cl_object v9bytes_read; + v9bytes_read = ECL_NIL; +L24:; + v9bytes_read = cl_read_sequence(2, v8buffer, v4file_stream); + cl_write_sequence(6, v8buffer, v7datum, ECL_SYM("START",1315), ecl_make_fixnum(0), ECL_SYM("END",1228), v9bytes_read); + if (ecl_number_equalp(v9bytes_read,v2buffer_size)) { goto L29; } + goto L25; +L29:; + goto L24; L25:; - v11bytes_read = cl_read_sequence(2, v10buffer, v4file_stream); - cl_write_sequence(6, v10buffer, v7datum, ECL_SYM("START",1344), ecl_make_fixnum(0), ECL_SYM("END",1253), v11bytes_read); - if (ecl_number_equalp(v11bytes_read,v2buffer_size)) { goto L30; } - goto L26; -L30:; - goto L25; -L26:; - } - } - cl_env_copy->values[0] = cl_get_output_stream_string(v7datum); } - ecl_frs_pop(cl_env_copy); - v9=ecl_stack_push_values(cl_env_copy); - cl_close(1, v7datum); - ecl_stack_pop_values(cl_env_copy,v9); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v8); - ecl_bds_unwind1(cl_env_copy); } + cl_env_copy->values[0] = cl_get_output_stream_string(v7datum); + ecl_bds_unwind1(cl_env_copy); } } ecl_frs_pop(cl_env_copy); @@ -385,7 +364,6 @@ L26:; static cl_object L5write_string_into_file(volatile cl_narg narg, cl_object volatile v1string, cl_object volatile v2pathname, ...) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object volatile env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; ecl_cs_check(cl_env_copy,value0); @@ -400,7 +378,7 @@ static cl_object L5write_string_into_file(volatile cl_narg narg, cl_object volat cl_parse_key(args,3,L5write_string_into_filekeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[3])) { - v3if_exists = ECL_SYM("ERROR",1257); + v3if_exists = ECL_SYM("ERROR",1232); } else { v3if_exists = keyvars[0]; } @@ -409,33 +387,33 @@ static cl_object L5write_string_into_file(volatile cl_narg narg, cl_object volat } { volatile cl_object v6file_stream; - T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); - if (Null(ECL_SYM("OUTPUT",1316))) { goto L5; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316)); + T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); + if (Null(ECL_SYM("OUTPUT",1287))) { goto L5; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287)); goto L4; L5:; T1 = ECL_NIL; L4:; goto L8; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), ECL_NIL); + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), ECL_NIL); goto L7; L8:; T2 = ECL_NIL; L7:; if (Null(v3if_exists)) { goto L11; } - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), v3if_exists); + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), v3if_exists); goto L10; L11:; T3 = ECL_NIL; L10:; if (Null(v4if_does_not_exist)) { goto L14; } - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), v4if_does_not_exist); + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), v4if_does_not_exist); goto L13; L14:; T4 = ECL_NIL; L13:; if (Null(v5external_format)) { goto L17; } - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), v5external_format); + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), v5external_format); goto L16; L17:; T5 = ECL_NIL; @@ -446,8 +424,7 @@ L16:; volatile bool unwinding = FALSE; cl_index v7=ECL_STACK_INDEX(cl_env_copy),v8; ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { + if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; } else { cl_env_copy->values[0] = cl_write_sequence(2, v1string, v6file_stream); @@ -468,7 +445,6 @@ L16:; static cl_object L6read_file_into_byte_vector(cl_object volatile v1pathname) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object volatile env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; ecl_cs_check(cl_env_copy,value0); @@ -476,31 +452,31 @@ static cl_object L6read_file_into_byte_vector(cl_object volatile v1pathname) TTL: { volatile cl_object v2stream; - T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); - if (Null(ECL_SYM("INPUT",1286))) { goto L4; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286)); + T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); + if (Null(ECL_SYM("INPUT",1259))) { goto L4; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259)); goto L3; L4:; T1 = ECL_NIL; L3:; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), VV[16]); + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), VV[16]); goto L6; T2 = ECL_NIL; L6:; goto L10; - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), ECL_NIL); + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), ECL_NIL); goto L9; L10:; T3 = ECL_NIL; L9:; goto L13; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); goto L12; L13:; T4 = ECL_NIL; L12:; goto L16; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); goto L15; L16:; T5 = ECL_NIL; @@ -511,8 +487,7 @@ L15:; volatile bool unwinding = FALSE; cl_index v3=ECL_STACK_INDEX(cl_env_copy),v4; ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { + if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; } else { { @@ -520,14 +495,14 @@ L15:; v5length = cl_file_length(v2stream); goto L22; L21:; - si_assert_failure(1, ECL_SYM("LENGTH",478)); + si_assert_failure(1, ECL_SYM("LENGTH",476)); L22:; if ((v5length)!=ECL_NIL) { goto L25; } goto L21; L25:; { cl_object v6result; - v6result = si_make_pure_array(ECL_SYM("BYTE8",1365), v5length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + v6result = si_make_pure_array(ECL_SYM("BYTE8",1335), v5length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); cl_read_sequence(2, v6result, v2stream); cl_env_copy->values[0] = v6result; cl_env_copy->nvalues = 1; @@ -550,7 +525,6 @@ L25:; static cl_object L7write_byte_vector_into_file(volatile cl_narg narg, cl_object volatile v1bytes, cl_object volatile v2pathname, ...) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object volatile env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; ecl_cs_check(cl_env_copy,value0); @@ -564,7 +538,7 @@ static cl_object L7write_byte_vector_into_file(volatile cl_narg narg, cl_object cl_parse_key(args,2,L7write_byte_vector_into_filekeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[2])) { - v3if_exists = ECL_SYM("ERROR",1257); + v3if_exists = ECL_SYM("ERROR",1232); } else { v3if_exists = keyvars[0]; } @@ -579,31 +553,31 @@ L4:; } { volatile cl_object v5stream; - T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); - if (Null(ECL_SYM("OUTPUT",1316))) { goto L10; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316)); + T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); + if (Null(ECL_SYM("OUTPUT",1287))) { goto L10; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287)); goto L9; L10:; T1 = ECL_NIL; L9:; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), VV[16]); + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), VV[16]); goto L12; T2 = ECL_NIL; L12:; if (Null(v3if_exists)) { goto L16; } - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), v3if_exists); + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), v3if_exists); goto L15; L16:; T3 = ECL_NIL; L15:; if (Null(v4if_does_not_exist)) { goto L19; } - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), v4if_does_not_exist); + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), v4if_does_not_exist); goto L18; L19:; T4 = ECL_NIL; L18:; goto L22; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); goto L21; L22:; T5 = ECL_NIL; @@ -614,8 +588,7 @@ L21:; volatile bool unwinding = FALSE; cl_index v6=ECL_STACK_INDEX(cl_env_copy),v7; ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { + if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; } else { cl_env_copy->values[0] = cl_write_sequence(2, v1bytes, v5stream); @@ -636,7 +609,6 @@ L21:; static cl_object L8copy_file(volatile cl_narg narg, cl_object volatile v1from, cl_object volatile v2to, ...) { cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object volatile env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; ecl_cs_check(cl_env_copy,value0); @@ -651,7 +623,7 @@ static cl_object L8copy_file(volatile cl_narg narg, cl_object volatile v1from, c cl_parse_key(args,3,L8copy_filekeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[3])) { - v3if_to_exists = ECL_SYM("SUPERSEDE",1348); + v3if_to_exists = ECL_SYM("SUPERSEDE",1319); } else { v3if_to_exists = keyvars[0]; } @@ -664,33 +636,33 @@ static cl_object L8copy_file(volatile cl_narg narg, cl_object volatile v1from, c } { volatile cl_object v6input; - T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); - if (Null(ECL_SYM("INPUT",1286))) { goto L6; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("INPUT",1286)); + T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); + if (Null(ECL_SYM("INPUT",1259))) { goto L6; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259)); goto L5; L6:; T1 = ECL_NIL; L5:; if (Null(v4element_type)) { goto L9; } - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), v4element_type); + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), v4element_type); goto L8; L9:; T2 = ECL_NIL; L8:; goto L12; - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), ECL_NIL); + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), ECL_NIL); goto L11; L12:; T3 = ECL_NIL; L11:; goto L15; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); goto L14; L15:; T4 = ECL_NIL; L14:; goto L18; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); goto L17; L18:; T5 = ECL_NIL; @@ -701,39 +673,38 @@ L17:; volatile bool unwinding = FALSE; cl_index v7=ECL_STACK_INDEX(cl_env_copy),v8; ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { + if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; } else { { volatile cl_object v9output; - T0 = (ECL_SYM("OPEN",613)->symbol.gfdef); - if (Null(ECL_SYM("OUTPUT",1316))) { goto L24; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1246), ECL_SYM("OUTPUT",1316)); + T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); + if (Null(ECL_SYM("OUTPUT",1287))) { goto L24; } + T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287)); goto L23; L24:; T1 = ECL_NIL; L23:; if (Null(v4element_type)) { goto L27; } - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1252), v4element_type); + T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), v4element_type); goto L26; L27:; T2 = ECL_NIL; L26:; if (Null(v3if_to_exists)) { goto L30; } - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1276), v3if_to_exists); + T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), v3if_to_exists); goto L29; L30:; T3 = ECL_NIL; L29:; goto L33; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1274), ECL_NIL); + T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); goto L32; L33:; T4 = ECL_NIL; L32:; goto L36; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1264), ECL_NIL); + T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); goto L35; L36:; T5 = ECL_NIL; @@ -744,11 +715,10 @@ L35:; volatile bool unwinding = FALSE; cl_index v10=ECL_STACK_INDEX(cl_env_copy),v11; ecl_frame_ptr next_fr; - ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG); - if (__ecl_frs_push_result) { + if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; } else { - cl_env_copy->values[0] = L9copy_stream(6, v6input, v9output, ECL_SYM("ELEMENT-TYPE",1252), v4element_type, VV[21], v5finish_output); + cl_env_copy->values[0] = L9copy_stream(6, v6input, v9output, ECL_SYM("ELEMENT-TYPE",1227), v4element_type, VV[21], v5finish_output); } ecl_frs_pop(cl_env_copy); v11=ecl_stack_push_values(cl_env_copy); @@ -775,7 +745,6 @@ L35:; static cl_object L9copy_stream(cl_narg narg, cl_object v1input, cl_object v2output, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -823,7 +792,7 @@ static cl_object L9copy_stream(cl_narg narg, cl_object v1input, cl_object v2outp v10 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L11; } v10 = v9; - if (ecl_greatereq(v10,ecl_make_fixnum(0))) { goto L7; } + if (ecl_number_compare(v10,ecl_make_fixnum(0))>=0) { goto L7; } goto L8; L11:; goto L8; @@ -841,7 +810,7 @@ L7:; v10 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L23; } v10 = v9; - if (ecl_greatereq(v10,ecl_make_fixnum(0))) { goto L18; } + if (ecl_number_compare(v10,ecl_make_fixnum(0))>=0) { goto L18; } goto L19; L23:; goto L19; @@ -858,7 +827,7 @@ L18:; v10 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L34; } v10 = v9; - if (ecl_greatereq(v10,ecl_make_fixnum(1))) { goto L30; } + if (ecl_number_compare(v10,ecl_make_fixnum(1))>=0) { goto L30; } goto L31; L34:; goto L31; @@ -868,7 +837,7 @@ L31:; L30:; } if (Null(v7end)) { goto L39; } - if (!(ecl_lower(v7end,v6start))) { goto L39; } + if (!(ecl_number_compare(v7end,v6start)<0)) { goto L39; } cl_error(2, VV[29], VV[22]); L39:; { @@ -878,7 +847,7 @@ L39:; v10input_position = ecl_make_fixnum(0); if (ecl_zerop(v6start)) { goto L44; } L46:; - if (ecl_lower(v10input_position,v6start)) { goto L48; } + if (ecl_number_compare(v10input_position,v6start)<0) { goto L48; } goto L47; L48:; { @@ -887,8 +856,8 @@ L48:; cl_fixnum v12; v12 = ecl_length(v5buffer); T0 = ecl_minus(v6start,v10input_position); - T1 = ((ecl_float_nan_p(T0) || ecl_lowereq(ecl_make_fixnum(v12),T0))?ecl_make_fixnum(v12):T0); - v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1253), T1)); + T1 = (ecl_number_compare(ecl_make_fixnum(v12),T0)<=0?ecl_make_fixnum(v12):T0); + v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1228), T1)); } if (!((v11n)==0)) { goto L52; } cl_error(3, VV[30], VV[22], v6start); @@ -907,7 +876,7 @@ L58:; L61:; L64:; if (v7end==ECL_NIL) { goto L66; } - if (ecl_lower(v10input_position,v7end)) { goto L66; } + if (ecl_number_compare(v10input_position,v7end)<0) { goto L66; } goto L65; L66:; { @@ -917,13 +886,13 @@ L66:; cl_fixnum v12; v12 = ecl_length(v5buffer); T1 = ecl_minus(v7end,v10input_position); - T0 = ((ecl_float_nan_p(T1) || ecl_lowereq(ecl_make_fixnum(v12),T1))?ecl_make_fixnum(v12):T1); + T0 = (ecl_number_compare(ecl_make_fixnum(v12),T1)<=0?ecl_make_fixnum(v12):T1); goto L71; } L72:; T0 = ECL_NIL; L71:; - v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1253), T0)); + v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1228), T0)); if (!((v11n)==0)) { goto L74; } if (Null(v7end)) { goto L76; } cl_error(3, VV[32], VV[22], v7end); @@ -932,7 +901,7 @@ L76:; goto L63; L74:; v10input_position = ecl_plus(v10input_position,ecl_make_fixnum(v11n)); - cl_write_sequence(4, v5buffer, v2output, ECL_SYM("END",1253), ecl_make_fixnum(v11n)); + cl_write_sequence(4, v5buffer, v2output, ECL_SYM("END",1228), ecl_make_fixnum(v11n)); v9output_position = ecl_plus(v9output_position,ecl_make_fixnum(v11n)); } goto L64; @@ -952,7 +921,7 @@ L83:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecliPHAkciDuw0AM_cYHycC71(cl_object flag) +ECL_DLLEXPORT void _ecliPHAkciDuw0AM_tih2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -967,48 +936,48 @@ ECL_DLLEXPORT void _ecliPHAkciDuw0AM_cYHycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/io.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/io.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecliPHAkciDuw0AM_cYHycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecliPHAkciDuw0AM_tih2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; ecl_cmp_defmacro(VV[33]); /* WITH-OPEN-FILE* */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[38]); /* WITH-INPUT-FROM-FILE */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[8]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[39]); /* WITH-OUTPUT-TO-FILE */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[11], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[40]); /* READ-FILE-INTO-STRING */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[43]); /* WRITE-STRING-INTO-FILE */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[14], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* READ-FILE-INTO-BYTE-VECTOR */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[15], ECL_SYM("FUNCTION",398), VVtemp[23]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defun(VV[48]); /* WRITE-BYTE-VECTOR-INTO-FILE */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[17], ECL_SYM("FUNCTION",398), VVtemp[27]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[28], VVtemp[29]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[30]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* COPY-FILE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defun(VV[53]); /* COPY-STREAM */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[22], ECL_SYM("FUNCTION",398), VVtemp[34]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[34]); /* WITH-INPUT-FROM-FILE */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[8]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[35]); /* WITH-OUTPUT-TO-FILE */ + si_set_documentation(3, VV[11], ECL_SYM("FUNCTION",396), VVtemp[11]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defun(VV[36]); /* READ-FILE-INTO-STRING */ + si_set_documentation(3, VV[13], ECL_SYM("FUNCTION",396), VVtemp[15]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[39]); /* WRITE-STRING-INTO-FILE */ + si_set_documentation(3, VV[14], ECL_SYM("FUNCTION",396), VVtemp[19]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[22]) /* ANNOTATE */; + ecl_cmp_defun(VV[43]); /* READ-FILE-INTO-BYTE-VECTOR */ + si_set_documentation(3, VV[15], ECL_SYM("FUNCTION",396), VVtemp[23]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[24], VVtemp[25]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[26]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* WRITE-BYTE-VECTOR-INTO-FILE */ + si_set_documentation(3, VV[17], ECL_SYM("FUNCTION",396), VVtemp[27]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[28], VVtemp[29]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[30]) /* ANNOTATE */; + ecl_cmp_defun(VV[45]); /* COPY-FILE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* COPY-STREAM */ + si_set_documentation(3, VV[22], ECL_SYM("FUNCTION",396), VVtemp[34]); } diff --git a/lib/alexandria/lists.cxx b/lib/alexandria/lists.cxx index a622b99..f6c6402 100644 --- a/lib/alexandria/lists.cxx +++ b/lib/alexandria/lists.cxx @@ -1,14 +1,13 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/lists.lisp */ +/* Source: lib/alexandria/lists.lisp */ #include #include "lib/alexandria/lists.eclh" /* function definition for SAFE-ENDP */ /* optimize speed 3, debug 0, space 0, safety 3 */ static cl_object L1safe_endp(cl_object v1x) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -24,7 +23,6 @@ static cl_object L1safe_endp(cl_object v1x) static cl_object L2alist_plist(cl_object v1alist) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -62,7 +60,6 @@ L16:; static cl_object L3plist_alist(cl_object v1plist) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -95,7 +92,6 @@ L11:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L4racons(cl_object v1key, cl_object v2value, cl_object v3ralist) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -110,7 +106,6 @@ static cl_object L4racons(cl_object v1key, cl_object v2value, cl_object v3ralist static cl_object L5assoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -123,7 +118,7 @@ static cl_object L5assoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, cl_parse_key(args,1,L5assoc_valuekeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[1])) { - v3test = ECL_SYM("EQL",336); + v3test = ECL_SYM("EQL",334); } else { v3test = keyvars[0]; } @@ -142,8 +137,6 @@ L5:; cl_object v8; v8 = v5; if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v8; } v7 = ECL_CONS_CAR(v6); @@ -154,8 +147,6 @@ L5:; cl_object v9; v9 = v7; if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v9; } v8 = ECL_CONS_CAR(T0); @@ -181,102 +172,77 @@ L2:; } } } -/* local function LAMBDA30 */ +/* local function ASSOC-VALUE */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6__lambda30(cl_object v1, cl_object v2env) +static cl_object LC6assoc_value(cl_narg narg, cl_object v1env, cl_object v2place, cl_object v3key, ...) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<3)) FEwrong_num_arguments_anonym(); { -TTL: + cl_object v4test; + ecl_va_list args; ecl_va_start(args,v3key,narg,3); { - cl_object v3; - cl_object v4place; - cl_object v5key; - cl_object v6; - cl_object v7test; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; -L3:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4place = v8; - } - if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; -L9:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5key = v8; + cl_object keyvars[2]; + cl_parse_key(args,1,LC6assoc_valuekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v4test = VV[5]; + } else { + v4test = keyvars[0]; } - v6 = ecl_function_dispatch(cl_env_copy,VV[63])(2, v3, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; - if (!((v6)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L16; } - v7test = VV[5]; - goto L15; -L16:; - v7test = v6; -L15:; - ecl_function_dispatch(cl_env_copy,VV[64])(2, v3, VV[6]) /* CHECK-KEYWORD */; + } + { + cl_object v6; /* TEMPORARY-VARIABLES */ + cl_object v7; /* INITFORMS */ + cl_object v8; /* NEWVALS */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v2place, v1env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + if (Null(ecl_cdr(v8))) { goto L3; } + cl_error(2, VV[6], VV[4]); +L3:; { - cl_object v9; /* TEMPORARY-VARIABLES */ - cl_object v10; /* INITFORMS */ - cl_object v11; /* NEWVALS */ - cl_object v12; /* SETTER */ - cl_object v13; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4place, v2env) /* GET-SETF-EXPANSION */; - { - v9 = value0; - v10 = cl_env_copy->values[1]; - v11 = cl_env_copy->values[2]; - v12 = cl_env_copy->values[3]; - v13 = cl_env_copy->values[4]; - } - if (Null(ecl_cdr(v11))) { goto L20; } - cl_error(2, VV[7], VV[4]); -L20:; - { - cl_object v14; - cl_object v15; - cl_object v16; - cl_object v17; - cl_object v18; - v14 = cl_gensym(1, VV[8]); - v15 = cl_gensym(1, VV[9]); - v16 = cl_gensym(1, VV[10]); - v17 = cl_gensym(1, VV[11]); - v18 = cl_gensym(1, VV[12]); - T0 = cl_list(4, v17, v15, v16, v18); - T1 = ecl_append(v9,T0); - T2 = cl_list(5, ECL_SYM("ASSOC",116), v15, v17, ECL_SYM("TEST",1350), v16); - T3 = cl_list(4, v13, v5key, v7test, T2); - T4 = ecl_append(v10,T3); - T5 = ecl_list1(v14); - T6 = cl_list(2, ECL_SYM("CDR",200), v18); - T7 = cl_list(3, ECL_SYM("SETF",752), T6, v14); - T8 = cl_list(2, v18, T7); - T9 = ecl_car(v11); - T10 = cl_list(4, ECL_SYM("ACONS",81), v5key, v14, v17); - T11 = cl_list(3, ECL_SYM("SETF",752), T9, T10); - T12 = cl_list(5, ECL_SYM("LET",479), v11, T11, v12, v14); - T13 = cl_list(2, ECL_T, T12); - T14 = cl_list(3, ECL_SYM("COND",249), T8, T13); - T15 = cl_list(2, ECL_SYM("CDR",200), v18); - cl_env_copy->nvalues = 5; - cl_env_copy->values[4] = T15; - cl_env_copy->values[3] = T14; - cl_env_copy->values[2] = T5; - cl_env_copy->values[1] = T4; - cl_env_copy->values[0] = T1; - return cl_env_copy->values[0]; - } + cl_object v11; + cl_object v12; + cl_object v13; + cl_object v14; + cl_object v15; + v11 = cl_gensym(1, VV[7]); + v12 = cl_gensym(1, VV[8]); + v13 = cl_gensym(1, VV[9]); + v14 = cl_gensym(1, VV[10]); + v15 = cl_gensym(1, VV[11]); + T0 = cl_list(4, v14, v12, v13, v15); + T1 = ecl_append(v6,T0); + T2 = cl_list(5, ECL_SYM("ASSOC",114), v12, v14, ECL_SYM("TEST",1321), v13); + T3 = cl_list(4, v10, v3key, v4test, T2); + T4 = ecl_append(v7,T3); + T5 = ecl_list1(v11); + T6 = cl_list(2, ECL_SYM("CDR",198), v15); + T7 = cl_list(3, ECL_SYM("SETF",750), T6, v11); + T8 = cl_list(2, v15, T7); + T9 = ecl_car(v8); + T10 = cl_list(4, ECL_SYM("ACONS",79), v3key, v11, v14); + T11 = cl_list(3, ECL_SYM("SETF",750), T9, T10); + T12 = cl_list(5, ECL_SYM("LET",477), v8, T11, v9, v11); + T13 = cl_list(2, ECL_T, T12); + T14 = cl_list(3, ECL_SYM("COND",247), T8, T13); + T15 = cl_list(2, ECL_SYM("CDR",198), v15); + cl_env_copy->nvalues = 5; + cl_env_copy->values[4] = T15; + cl_env_copy->values[3] = T14; + cl_env_copy->values[2] = T5; + cl_env_copy->values[1] = T4; + cl_env_copy->values[0] = T1; + return cl_env_copy->values[0]; } } } @@ -286,7 +252,6 @@ L20:; static cl_object L7rassoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -299,14 +264,14 @@ static cl_object L7rassoc_value(cl_narg narg, cl_object v1alist, cl_object v2key cl_parse_key(args,1,L7rassoc_valuekeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[1])) { - v3test = ECL_SYM("EQL",336); + v3test = ECL_SYM("EQL",334); } else { v3test = keyvars[0]; } } { cl_object v4entry; - v4entry = cl_rassoc(4, v2key, v1alist, ECL_SYM("TEST",1350), v3test); + v4entry = cl_rassoc(4, v2key, v1alist, ECL_SYM("TEST",1321), v3test); T0 = ecl_car(v4entry); cl_env_copy->nvalues = 2; cl_env_copy->values[1] = v4entry; @@ -315,102 +280,77 @@ static cl_object L7rassoc_value(cl_narg narg, cl_object v1alist, cl_object v2key } } } -/* local function LAMBDA41 */ +/* local function RASSOC-VALUE */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__lambda41(cl_object v1, cl_object v2env) +static cl_object LC8rassoc_value(cl_narg narg, cl_object v1env, cl_object v2place, cl_object v3key, ...) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); + if (ecl_unlikely(narg<3)) FEwrong_num_arguments_anonym(); { -TTL: + cl_object v4test; + ecl_va_list args; ecl_va_start(args,v3key,narg,3); { - cl_object v3; - cl_object v4place; - cl_object v5key; - cl_object v6; - cl_object v7test; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; -L3:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4place = v8; - } - if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; -L9:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5key = v8; + cl_object keyvars[2]; + cl_parse_key(args,1,LC8rassoc_valuekeys,keyvars,NULL,FALSE); + ecl_va_end(args); + if (Null(keyvars[1])) { + v4test = VV[5]; + } else { + v4test = keyvars[0]; } - v6 = ecl_function_dispatch(cl_env_copy,VV[63])(2, v3, ECL_SYM("TEST",1350)) /* SEARCH-KEYWORD */; - if (!((v6)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L16; } - v7test = VV[5]; - goto L15; -L16:; - v7test = v6; -L15:; - ecl_function_dispatch(cl_env_copy,VV[64])(2, v3, VV[6]) /* CHECK-KEYWORD */; + } + { + cl_object v6; /* TEMPORARY-VARIABLES */ + cl_object v7; /* INITFORMS */ + cl_object v8; /* NEWVALS */ + cl_object v9; /* SETTER */ + cl_object v10; /* GETTER */ + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v2place, v1env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; + if (Null(ecl_cdr(v8))) { goto L3; } + cl_error(2, VV[6], VV[12]); +L3:; { - cl_object v9; /* TEMPORARY-VARIABLES */ - cl_object v10; /* INITFORMS */ - cl_object v11; /* NEWVALS */ - cl_object v12; /* SETTER */ - cl_object v13; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4place, v2env) /* GET-SETF-EXPANSION */; - { - v9 = value0; - v10 = cl_env_copy->values[1]; - v11 = cl_env_copy->values[2]; - v12 = cl_env_copy->values[3]; - v13 = cl_env_copy->values[4]; - } - if (Null(ecl_cdr(v11))) { goto L20; } - cl_error(2, VV[7], VV[13]); -L20:; - { - cl_object v14; - cl_object v15; - cl_object v16; - cl_object v17; - cl_object v18; - v14 = cl_gensym(1, VV[8]); - v15 = cl_gensym(1, VV[9]); - v16 = cl_gensym(1, VV[10]); - v17 = cl_gensym(1, VV[11]); - v18 = cl_gensym(1, VV[12]); - T0 = cl_list(4, v17, v15, v16, v18); - T1 = ecl_append(v9,T0); - T2 = cl_list(5, ECL_SYM("RASSOC",685), v15, v17, ECL_SYM("TEST",1350), v16); - T3 = cl_list(4, v13, v5key, v7test, T2); - T4 = ecl_append(v10,T3); - T5 = ecl_list1(v14); - T6 = cl_list(2, ECL_SYM("CAR",182), v18); - T7 = cl_list(3, ECL_SYM("SETF",752), T6, v14); - T8 = cl_list(2, v18, T7); - T9 = ecl_car(v11); - T10 = cl_list(4, VV[3], v5key, v14, v17); - T11 = cl_list(3, ECL_SYM("SETF",752), T9, T10); - T12 = cl_list(5, ECL_SYM("LET",479), v11, T11, v12, v14); - T13 = cl_list(2, ECL_T, T12); - T14 = cl_list(3, ECL_SYM("COND",249), T8, T13); - T15 = cl_list(2, ECL_SYM("CAR",182), v18); - cl_env_copy->nvalues = 5; - cl_env_copy->values[4] = T15; - cl_env_copy->values[3] = T14; - cl_env_copy->values[2] = T5; - cl_env_copy->values[1] = T4; - cl_env_copy->values[0] = T1; - return cl_env_copy->values[0]; - } + cl_object v11; + cl_object v12; + cl_object v13; + cl_object v14; + cl_object v15; + v11 = cl_gensym(1, VV[7]); + v12 = cl_gensym(1, VV[8]); + v13 = cl_gensym(1, VV[9]); + v14 = cl_gensym(1, VV[10]); + v15 = cl_gensym(1, VV[11]); + T0 = cl_list(4, v14, v12, v13, v15); + T1 = ecl_append(v6,T0); + T2 = cl_list(5, ECL_SYM("RASSOC",683), v12, v14, ECL_SYM("TEST",1321), v13); + T3 = cl_list(4, v10, v3key, v4test, T2); + T4 = ecl_append(v7,T3); + T5 = ecl_list1(v11); + T6 = cl_list(2, ECL_SYM("CAR",180), v15); + T7 = cl_list(3, ECL_SYM("SETF",750), T6, v11); + T8 = cl_list(2, v15, T7); + T9 = ecl_car(v8); + T10 = cl_list(4, VV[3], v3key, v11, v14); + T11 = cl_list(3, ECL_SYM("SETF",750), T9, T10); + T12 = cl_list(5, ECL_SYM("LET",477), v8, T11, v9, v11); + T13 = cl_list(2, ECL_T, T12); + T14 = cl_list(3, ECL_SYM("COND",247), T8, T13); + T15 = cl_list(2, ECL_SYM("CAR",180), v15); + cl_env_copy->nvalues = 5; + cl_env_copy->values[4] = T15; + cl_env_copy->values[3] = T14; + cl_env_copy->values[2] = T5; + cl_env_copy->values[1] = T4; + cl_env_copy->values[0] = T1; + return cl_env_copy->values[0]; } } } @@ -419,13 +359,12 @@ L20:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L9malformed_plist(cl_object v1plist) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - value0 = cl_error(2, VV[15], v1plist); + value0 = cl_error(2, VV[14], v1plist); return value0; } } @@ -434,7 +373,6 @@ static cl_object L9malformed_plist(cl_object v1plist) static cl_object LC10doplist(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -450,7 +388,7 @@ static cl_object LC10doplist(cl_object v1, cl_object v2) cl_object v9values; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v10; @@ -460,7 +398,7 @@ L3:; } v5 = v4; if (!(v5==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L10:; { cl_object v10; @@ -469,7 +407,7 @@ L10:; v6key = v10; } if (!(v5==ECL_NIL)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L16:; { cl_object v10; @@ -478,7 +416,7 @@ L16:; v7val = v10; } if (!(v5==ECL_NIL)) { goto L22; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L22:; { cl_object v10; @@ -498,15 +436,15 @@ L28:; v9values = ECL_NIL; L27:; if (Null(v5)) { goto L33; } - ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L33:; { cl_object v11; /* FORMS */ cl_object v12; /* DECLARATIONS */ - value0 = ecl_function_dispatch(cl_env_copy,VV[68])(1, v3) /* PARSE-BODY */; + value0 = ecl_function_dispatch(cl_env_copy,VV[62])(1, v3) /* PARSE-BODY */; + v11 = value0; { const int v13 = cl_env_copy->nvalues; - v11 = value0; cl_object v14; v14 = (v13<=1)? ECL_NIL : cl_env_copy->values[1]; v12 = v14; @@ -515,46 +453,46 @@ L33:; cl_object v13; cl_object v14; cl_object v15; - v13 = cl_gensym(1, VV[17]); - v14 = cl_gensym(1, VV[18]); - v15 = cl_gensym(1, VV[19]); + v13 = cl_gensym(1, VV[16]); + v14 = cl_gensym(1, VV[17]); + v15 = cl_gensym(1, VV[18]); T0 = cl_list(2, v6key, v7val); - T1 = cl_list(3, ECL_SYM("IGNORABLE",429), v6key, v7val); - T2 = cl_list(2, ECL_SYM("DECLARE",276), T1); - T3 = cl_list(2, ECL_SYM("RETURN",726), v9values); - T4 = cl_list(4, ECL_SYM("LET",479), T0, T2, T3); + T1 = cl_list(3, ECL_SYM("IGNORABLE",427), v6key, v7val); + T2 = cl_list(2, ECL_SYM("DECLARE",274), T1); + T3 = cl_list(2, ECL_SYM("RETURN",724), v9values); + T4 = cl_list(4, ECL_SYM("LET",477), T0, T2, T3); T5 = cl_list(3, v15, ECL_NIL, T4); T6 = ecl_list1(T5); T7 = cl_list(2, v13, v8plist); - T8 = cl_list(2, ECL_SYM("POP",645), v13); + T8 = cl_list(2, ECL_SYM("POP",643), v13); T9 = ecl_list1(v15); - T10 = cl_list(4, ECL_SYM("IF",948), v13, T8, T9); + T10 = cl_list(4, ECL_SYM("IF",946), v13, T8, T9); T11 = cl_list(2, v6key, T10); - T12 = cl_list(2, ECL_SYM("POP",645), v13); - T13 = cl_list(2, ECL_SYM("QUOTE",681), v8plist); - T14 = cl_list(2, VV[14], T13); - T15 = cl_list(4, ECL_SYM("IF",948), v13, T12, T14); + T12 = cl_list(2, ECL_SYM("POP",643), v13); + T13 = cl_list(2, ECL_SYM("QUOTE",679), v8plist); + T14 = cl_list(2, VV[13], T13); + T15 = cl_list(4, ECL_SYM("IF",946), v13, T12, T14); T16 = cl_list(2, v7val, T15); T17 = cl_list(3, T7, T11, T16); - T18 = cl_list(3, ECL_SYM("IGNORABLE",429), v6key, v7val); - T19 = cl_list(2, ECL_SYM("DECLARE",276), T18); - T20 = cl_list(2, ECL_SYM("POP",645), v13); + T18 = cl_list(3, ECL_SYM("IGNORABLE",427), v6key, v7val); + T19 = cl_list(2, ECL_SYM("DECLARE",274), T18); + T20 = cl_list(2, ECL_SYM("POP",643), v13); T21 = ecl_list1(v15); - T22 = cl_list(4, ECL_SYM("IF",948), v13, T20, T21); - T23 = cl_list(2, ECL_SYM("POP",645), v13); - T24 = cl_list(2, ECL_SYM("QUOTE",681), v8plist); - T25 = cl_list(2, VV[14], T24); - T26 = cl_list(4, ECL_SYM("IF",948), v13, T23, T25); - T27 = cl_list(5, ECL_SYM("SETF",752), v6key, T22, v7val, T26); - T28 = cl_list(2, ECL_SYM("GO",416), v14); + T22 = cl_list(4, ECL_SYM("IF",946), v13, T20, T21); + T23 = cl_list(2, ECL_SYM("POP",643), v13); + T24 = cl_list(2, ECL_SYM("QUOTE",679), v8plist); + T25 = cl_list(2, VV[13], T24); + T26 = cl_list(4, ECL_SYM("IF",946), v13, T23, T25); + T27 = cl_list(5, ECL_SYM("SETF",750), v6key, T22, v7val, T26); + T28 = cl_list(2, ECL_SYM("GO",414), v14); T29 = cl_list(2, T27, T28); T30 = ecl_append(v11,T29); - T31 = cl_listX(3, ECL_SYM("TAGBODY",852), v14, T30); + T31 = cl_listX(3, ECL_SYM("TAGBODY",850), v14, T30); T32 = ecl_list1(T31); T33 = ecl_append(v12,T32); - T34 = cl_listX(4, ECL_SYM("LET*",480), T17, T19, T33); - T35 = cl_list(3, ECL_SYM("FLET",375), T6, T34); - value0 = cl_list(3, ECL_SYM("BLOCK",139), ECL_NIL, T35); + T34 = cl_listX(4, ECL_SYM("LET*",478), T17, T19, T33); + T35 = cl_list(3, ECL_SYM("FLET",373), T6, T34); + value0 = cl_list(3, ECL_SYM("BLOCK",137), ECL_NIL, T35); return value0; } } @@ -566,7 +504,6 @@ L33:; static cl_object LC12appendf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -577,7 +514,7 @@ static cl_object LC12appendf(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -591,33 +528,31 @@ L3:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC11__lambda72,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC11__g54,ECL_NIL,Cblock,1); T0 = v12; } T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("APPEND",90), v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("APPEND",88), v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L11:; @@ -649,19 +584,28 @@ L20:; goto L19; L26:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("APPEND",90), v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L31; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, ECL_SYM("APPEND",88), v10, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L30; +L31:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("APPEND",88), v10, T3); +L30:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -669,12 +613,11 @@ L26:; } } } -/* local function LAMBDA72 */ +/* local function G54 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__lambda72(cl_object v1si__v) +static cl_object LC11__g54(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -690,7 +633,6 @@ static cl_object LC11__lambda72(cl_object v1si__v) static cl_object LC14nconcf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -701,7 +643,7 @@ static cl_object LC14nconcf(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -715,33 +657,31 @@ L3:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC13__lambda83,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC13__g65,ECL_NIL,Cblock,1); T0 = v12; } T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("NCONC",583), v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("NCONC",581), v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L11:; @@ -773,19 +713,28 @@ L20:; goto L19; L26:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("NCONC",583), v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L31; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, ECL_SYM("NCONC",581), v10, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L30; +L31:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("NCONC",581), v10, T3); +L30:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -793,12 +742,11 @@ L26:; } } } -/* local function LAMBDA83 */ +/* local function G65 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13__lambda83(cl_object v1si__v) +static cl_object LC13__g65(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -814,7 +762,6 @@ static cl_object LC13__lambda83(cl_object v1si__v) static cl_object LC16unionf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -826,7 +773,7 @@ static cl_object LC16unionf(cl_object v1, cl_object v2si__env) cl_object v5list; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -835,7 +782,7 @@ L3:; v4si___reference = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -849,33 +796,31 @@ L9:; cl_object v9; /* STORES */ cl_object v10; /* SETTER */ cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; { cl_object v12si__all_vars; { cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC15__lambda95,ECL_NIL,Cblock,1); + v13 = ecl_make_cfun((cl_objectfn_fixed)LC15__g77,ECL_NIL,Cblock,1); T0 = v13; } T1 = CONS(v5list,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("UNION",884), v11, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("UNION",882), v11, T1); T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); value0 = cl_subst(3, T2, T3, T8); return value0; L17:; @@ -907,19 +852,28 @@ L26:; goto L25; L32:; T0 = ecl_car(v9); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("UNION",884), v11, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L37; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(4, ECL_SYM("UNION",882), v11, v5list, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L36; +L37:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("UNION",882), v11, T3); +L36:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T2,T3); T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v7); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); return value0; } } @@ -927,12 +881,11 @@ L32:; } } } -/* local function LAMBDA95 */ +/* local function G77 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15__lambda95(cl_object v1si__v) +static cl_object LC15__g77(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -948,7 +901,6 @@ static cl_object LC15__lambda95(cl_object v1si__v) static cl_object LC18nunionf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -960,7 +912,7 @@ static cl_object LC18nunionf(cl_object v1, cl_object v2si__env) cl_object v5list; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -969,7 +921,7 @@ L3:; v4si___reference = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -983,33 +935,31 @@ L9:; cl_object v9; /* STORES */ cl_object v10; /* SETTER */ cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; { cl_object v12si__all_vars; { cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC17__lambda107,ECL_NIL,Cblock,1); + v13 = ecl_make_cfun((cl_objectfn_fixed)LC17__g89,ECL_NIL,Cblock,1); T0 = v13; } T1 = CONS(v5list,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("NUNION",611), v11, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("NUNION",609), v11, T1); T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); value0 = cl_subst(3, T2, T3, T8); return value0; L17:; @@ -1041,19 +991,28 @@ L26:; goto L25; L32:; T0 = ecl_car(v9); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("NUNION",611), v11, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L37; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(4, ECL_SYM("NUNION",609), v11, v5list, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L36; +L37:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("NUNION",609), v11, T3); +L36:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T2,T3); T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v7); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); return value0; } } @@ -1061,12 +1020,11 @@ L32:; } } } -/* local function LAMBDA107 */ +/* local function G89 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC17__lambda107(cl_object v1si__v) +static cl_object LC17__g89(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1082,7 +1040,6 @@ static cl_object LC17__lambda107(cl_object v1si__v) static cl_object LC20reversef(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1093,7 +1050,7 @@ static cl_object LC20reversef(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -1102,7 +1059,7 @@ L3:; v4si___reference = v5; } if (Null(v3)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; { cl_object v6; /* VARS */ @@ -1110,33 +1067,31 @@ L8:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC19__lambda118,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC19__g100,ECL_NIL,Cblock,1); T0 = v12; } T1 = ECL_NIL; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L13; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("REVERSE",729), v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("REVERSE",727), v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L13:; @@ -1168,19 +1123,28 @@ L22:; goto L21; L28:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("REVERSE",729), v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L33; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L33; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, ECL_SYM("REVERSE",727), v10, ECL_NIL); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L32; +L33:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("REVERSE",727), v10, T3); +L32:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -1188,12 +1152,11 @@ L28:; } } } -/* local function LAMBDA118 */ +/* local function G100 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19__lambda118(cl_object v1si__v) +static cl_object LC19__g100(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1209,7 +1172,6 @@ static cl_object LC19__lambda118(cl_object v1si__v) static cl_object LC22nreversef(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1220,7 +1182,7 @@ static cl_object LC22nreversef(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -1229,7 +1191,7 @@ L3:; v4si___reference = v5; } if (Null(v3)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; { cl_object v6; /* VARS */ @@ -1237,33 +1199,31 @@ L8:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC21__lambda129,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC21__g111,ECL_NIL,Cblock,1); T0 = v12; } T1 = ECL_NIL; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L13; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("NREVERSE",591), v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("NREVERSE",589), v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L13:; @@ -1295,19 +1255,28 @@ L22:; goto L21; L28:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("NREVERSE",591), v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L33; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L33; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, ECL_SYM("NREVERSE",589), v10, ECL_NIL); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L32; +L33:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("NREVERSE",589), v10, T3); +L32:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -1315,12 +1284,11 @@ L28:; } } } -/* local function LAMBDA129 */ +/* local function G111 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC21__lambda129(cl_object v1si__v) +static cl_object LC21__g111(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1335,7 +1303,6 @@ static cl_object LC21__lambda129(cl_object v1si__v) /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L23circular_list(cl_narg narg, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1358,7 +1325,6 @@ static cl_object L23circular_list(cl_narg narg, ...) static cl_object L24circular_list_p(cl_object v1object) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1410,46 +1376,33 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L26circular_tree_p(cl_object volatile v1object) { - cl_object volatile env0 = ECL_NIL; - volatile struct ecl_cclosure aux_closure; - cl_object volatile CLV0; + volatile cl_object lex0[1]; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object volatile value0; ecl_cs_check(cl_env_copy,value0); { TTL: { - env0 = ECL_NIL; - CLV0 = env0 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env0); /* CIRCULAR-TREE-P */ - { - ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV0)); - if (__ecl_frs_push_result!=0) { - value0 = cl_env_copy->values[0]; - ecl_frs_pop(cl_env_copy); - return value0; - } else { - value0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC25circularp(2, v1object, ECL_NIL)); - ecl_frs_pop(cl_env_copy); - return value0;} - } + lex0[0] = ECL_NEW_FRAME_ID(cl_env_copy); /* CIRCULAR-TREE-P */ + if (ecl_frs_push(cl_env_copy,lex0[0])!=0) { + value0 = cl_env_copy->values[0]; + ecl_frs_pop(cl_env_copy); + return value0; + } else { + value0 = LC25circularp(lex0, v1object, ECL_NIL); + ecl_frs_pop(cl_env_copy); + return value0;} } } } -/* closure CIRCULARP */ +/* local function CIRCULARP */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC25circularp(cl_narg narg, cl_object v1object, cl_object v2seen, ...) +static cl_object LC25circularp(volatile cl_object *lex0, cl_object v1object, cl_object v2seen) { cl_object T0, T1; - volatile struct ecl_cclosure aux_closure; - cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; cl_object value0; ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* CIRCULAR-TREE-P */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); { TTL: if (!(ECL_CONSP(v1object))) { goto L2; } @@ -1465,47 +1418,41 @@ static cl_object LC25circularp(cl_narg narg, cl_object v1object, cl_object v2see goto L9; L8:; if ((v4fast)==(v5slow)) { goto L13; } - { - cl_object v6; - cl_object v7; - v6 = v5slow; - v7 = v2seen; - if (Null(ecl_memql(v6,v7))) { goto L11; } - goto L12; - } + if (Null(ecl_memql(v5slow,v2seen))) { goto L11; } + goto L12; L13:; L12:; cl_env_copy->values[0] = ECL_T; cl_env_copy->nvalues = 1; - cl_return_from(ECL_CONS_CAR(CLV0),VV[29]); + cl_return_from(lex0[0],ECL_NIL); L11:; - if (!(ECL_CONSP(v4fast))) { goto L20; } + if (!(ECL_CONSP(v4fast))) { goto L18; } T0 = ecl_cdr(v5slow); - if (ECL_CONSP(T0)) { goto L18; } - goto L19; -L20:; -L19:; + if (ECL_CONSP(T0)) { goto L16; } + goto L17; +L18:; +L17:; { cl_object v6tail; v6tail = v1object; - goto L25; -L24:; + goto L23; +L22:; { cl_object v7elt; v7elt = ecl_car(v6tail); T0 = CONS(v1object,v2seen); - (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC25circularp(2, v7elt, T0)); + LC25circularp(lex0, v7elt, T0); } v6tail = ecl_cdr(v6tail); -L25:; - if (!(ECL_CONSP(v6tail))) { goto L31; } - goto L24; -L31:; +L23:; + if (!(ECL_CONSP(v6tail))) { goto L29; } + goto L22; +L29:; value0 = ECL_NIL; cl_env_copy->nvalues = 1; return value0; } -L18:; +L16:; v4fast = ecl_cddr(v4fast); v5slow = ecl_cdr(v5slow); L9:; @@ -1519,14 +1466,12 @@ L2:; cl_env_copy->nvalues = 1; return value0; } - } } /* function definition for PROPER-LIST-P */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L27proper_list_p(cl_object v1object) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1585,20 +1530,19 @@ L3:; return value0; } } -/* local function LAMBDA161 */ +/* local function PROPER-LIST */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC28__lambda161(cl_object v1) +static cl_object LC28proper_list(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = VV[32]; + value0 = VV[31]; cl_env_copy->nvalues = 1; return value0; } @@ -1607,13 +1551,12 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L29circular_list_error(cl_object v1list) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1list, ECL_SYM("EXPECTED-TYPE",1260), VV[34]); + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1list, ECL_SYM("EXPECTED-TYPE",1235), VV[33]); return value0; } } @@ -1622,7 +1565,6 @@ static cl_object L29circular_list_error(cl_object v1list) static cl_object L30proper_list_length(cl_object v1list) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1670,9 +1612,7 @@ L15:; bool v8; v8 = ECL_FIXNUMP(v7); if (ecl_unlikely(!(v8))) - FEwrong_type_argument(ECL_SYM("FIXNUM",374),v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("FIXNUM",372),v7); } v6n = ecl_fixnum(v7); } @@ -1689,7 +1629,6 @@ L8:; static cl_object L31lastcar(cl_object v1list) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1741,7 +1680,6 @@ L7:; static cl_object L32_setf_lastcar_(cl_object v1object, cl_object v2list) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1768,8 +1706,6 @@ L6:; cl_object v8; v8 = ecl_cdr(v4last); if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v8; } (ECL_CONS_CAR(T0)=v7,T0); @@ -1790,8 +1726,6 @@ L9:; cl_object v8; v8 = v5fast; if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v8; } (ECL_CONS_CAR(T0)=v7,T0); @@ -1818,7 +1752,6 @@ L7:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L33make_circular_list(cl_narg narg, cl_object v1length, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1834,27 +1767,26 @@ static cl_object L33make_circular_list(cl_narg narg, cl_object v1length, ...) } { cl_object v3cycle; - v3cycle = cl_make_list(3, v1length, ECL_SYM("INITIAL-ELEMENT",1283), v2initial_element); + v3cycle = cl_make_list(3, v1length, ECL_SYM("INITIAL-ELEMENT",1256), v2initial_element); value0 = ecl_nconc(v3cycle,v3cycle); cl_env_copy->nvalues = 1; return value0; } } } -/* local function LAMBDA193 */ +/* local function CIRCULAR-LIST */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC34__lambda193(cl_object v1) +static cl_object LC34circular_list(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[67])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = VV[39]; + value0 = VV[38]; cl_env_copy->nvalues = 1; return value0; } @@ -1863,7 +1795,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L35ensure_car(cl_object v1thing) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1883,7 +1814,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L36ensure_cons(cl_object v1cons) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1903,7 +1833,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L37ensure_list(cl_object v1list) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1924,7 +1853,6 @@ L1:; static cl_object L38remove_from_plist(cl_narg narg, cl_object v1plist, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1938,7 +1866,12 @@ static cl_object L38remove_from_plist(cl_narg narg, cl_object v1plist, ...) cl_object v3; cl_object v4key; cl_object v5rest; - v3 = v1plist; + { + cl_object v6; + v6 = v1plist; + if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6); + v3 = v6; + } v4key = ECL_NIL; v5rest = ECL_NIL; { @@ -1946,10 +1879,10 @@ static cl_object L38remove_from_plist(cl_narg narg, cl_object v1plist, ...) cl_object v7; v6 = ecl_list1(ECL_NIL); v7 = v6; -L6:; - if (!(ECL_ATOM(v3))) { goto L8; } - goto L7; L8:; + if (!(ECL_ATOM(v3))) { goto L10; } + goto L9; +L10:; { cl_object v8; v8 = v3; @@ -1957,29 +1890,24 @@ L8:; v8 = ecl_cdr(v8); v5rest = v8; } - v3 = ecl_cddr(v3); - goto L21; -L20:; - si_assert_failure(5, ECL_SYM("REST",721), ECL_NIL, ECL_NIL, VV[44], v1plist); -L21:; - if ((v5rest)!=ECL_NIL) { goto L24; } - goto L20; -L24:; { cl_object v8; - cl_object v9; - cl_object v10; - v8 = (ECL_SYM("EQ",335)->symbol.gfdef); - v9 = v4key; - v10 = v2keys; - if ((si_memq(v9,v10))!=ECL_NIL) { goto L26; } + v8 = ecl_cddr(v3); + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + v3 = v8; } + goto L25; +L24:; + si_assert_failure(5, ECL_SYM("REST",719), ECL_NIL, ECL_NIL, VV[43], v1plist); +L25:; + if ((v5rest)!=ECL_NIL) { goto L28; } + goto L24; +L28:; + if ((si_memq(v4key,v2keys))!=ECL_NIL) { goto L30; } { cl_object v8; v8 = v7; if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v8; } v7 = ecl_list1(v4key); @@ -1988,16 +1916,14 @@ L24:; cl_object v8; v8 = v7; if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v8; } T1 = ecl_car(v5rest); v7 = ecl_list1(T1); (ECL_CONS_CDR(T0)=v7,T0); -L26:; - goto L6; -L7:; +L30:; + goto L8; +L9:; value0 = ecl_cdr(v6); cl_env_copy->nvalues = 1; return value0; @@ -2010,7 +1936,6 @@ L7:; static cl_object L39delete_from_plist(cl_narg narg, cl_object v1plist, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2030,13 +1955,18 @@ static cl_object L39delete_from_plist(cl_narg narg, cl_object v1plist, ...) cl_object v5; cl_object v6key; cl_object v7rest; - v5 = v1plist; + { + cl_object v8; + v8 = v1plist; + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + v5 = v8; + } v6key = ECL_NIL; v7rest = ECL_NIL; -L6:; - if (!(ECL_ATOM(v5))) { goto L8; } - goto L7; L8:; + if (!(ECL_ATOM(v5))) { goto L10; } + goto L9; +L10:; { cl_object v8; v8 = v5; @@ -2044,27 +1974,24 @@ L8:; v8 = ecl_cdr(v8); v7rest = v8; } - v5 = ecl_cddr(v5); - goto L22; -L21:; - si_assert_failure(5, ECL_SYM("REST",721), ECL_NIL, ECL_NIL, VV[44], v1plist); -L22:; - if ((v7rest)!=ECL_NIL) { goto L25; } - goto L21; -L25:; { cl_object v8; - cl_object v9; - cl_object v10; - v8 = (ECL_SYM("EQ",335)->symbol.gfdef); - v9 = v6key; - v10 = v2keys; - if (Null(si_memq(v9,v10))) { goto L27; } + v8 = ecl_cddr(v5); + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); + v5 = v8; } + goto L26; +L25:; + si_assert_failure(5, ECL_SYM("REST",719), ECL_NIL, ECL_NIL, VV[43], v1plist); +L26:; + if ((v7rest)!=ECL_NIL) { goto L29; } + goto L25; +L29:; + if (Null(si_memq(v6key,v2keys))) { goto L31; } { cl_object v8next; v8next = ecl_cdr(v7rest); - if (Null(v4tail)) { goto L33; } + if (Null(v4tail)) { goto L34; } { cl_object v9; v9 = v8next; @@ -2072,22 +1999,20 @@ L25:; cl_object v10; v10 = v4tail; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v10; } (ECL_CONS_CDR(T0)=v9,T0); - goto L19; + goto L23; } -L33:; +L34:; v3head = v8next; - goto L19; + goto L23; } -L27:; +L31:; v4tail = v7rest; -L19:; - goto L6; -L7:; +L23:; + goto L8; +L9:; value0 = v3head; cl_env_copy->nvalues = 1; return value0; @@ -2101,7 +2026,6 @@ L7:; static cl_object LC41remove_from_plistf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2112,7 +2036,7 @@ static cl_object LC41remove_from_plistf(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -2126,33 +2050,31 @@ L3:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC40__lambda237,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC40__g187,ECL_NIL,Cblock,1); T0 = v12; } T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[43], v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[42], v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L11:; @@ -2184,19 +2106,28 @@ L20:; goto L19; L26:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, VV[43], v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L31; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, VV[42], v10, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L30; +L31:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, VV[42], v10, T3); +L30:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -2204,12 +2135,11 @@ L26:; } } } -/* local function LAMBDA237 */ +/* local function G187 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC40__lambda237(cl_object v1si__v) +static cl_object LC40__g187(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2225,7 +2155,6 @@ static cl_object LC40__lambda237(cl_object v1si__v) static cl_object LC43delete_from_plistf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2236,7 +2165,7 @@ static cl_object LC43delete_from_plistf(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -2250,33 +2179,31 @@ L3:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC42__lambda248,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC42__g198,ECL_NIL,Cblock,1); T0 = v12; } T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[45], v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, VV[44], v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[21],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T6 = CONS(VV[20],T5); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L11:; @@ -2308,19 +2235,28 @@ L20:; goto L19; L26:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, VV[45], v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L31; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, VV[44], v10, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L30; +L31:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, VV[44], v10, T3); +L30:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); - T4 = CONS(VV[21],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T4 = CONS(VV[20],T3); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -2328,12 +2264,11 @@ L26:; } } } -/* local function LAMBDA248 */ +/* local function G198 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC42__lambda248(cl_object v1si__v) +static cl_object LC42__g198(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2349,7 +2284,6 @@ static cl_object LC42__lambda248(cl_object v1si__v) static cl_object L44sans(cl_narg narg, cl_object v1plist, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2359,7 +2293,7 @@ static cl_object L44sans(cl_narg narg, cl_object v1plist, ...) ecl_va_list args; ecl_va_start(args,v1plist,narg,1); v2keys = cl_grab_rest_args(args); ecl_va_end(args); - T0 = ecl_fdefinition(VV[43]); + T0 = ecl_fdefinition(VV[42]); value0 = cl_apply(3, T0, v1plist, v2keys); return value0; } @@ -2369,7 +2303,6 @@ static cl_object L44sans(cl_narg narg, cl_object v1plist, ...) static cl_object L45mappend(cl_narg narg, cl_object v1function, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2383,7 +2316,7 @@ static cl_object L45mappend(cl_narg narg, cl_object v1function, ...) cl_object v3; cl_object v4results; cl_object v5; - T0 = (ECL_SYM("MAPCAR",547)->symbol.gfdef); + T0 = (ECL_SYM("MAPCAR",545)->symbol.gfdef); v3 = cl_apply(3, T0, v1function, v2lists); v4results = ECL_NIL; v5 = v3; @@ -2396,13 +2329,11 @@ L7:; if (!(ecl_endp(v5))) { goto L9; } goto L8; L9:; - v4results = ECL_CONS_CAR(v5); + v4results = _ecl_car(v5); { cl_object v8; - v8 = ECL_CONS_CDR(v5); + v8 = _ecl_cdr(v5); if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5 = v8; } { @@ -2412,8 +2343,6 @@ L9:; cl_object v9; v9 = v7; if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v9; } (ECL_CONS_CDR(T0)=v8,T0); @@ -2435,7 +2364,6 @@ L8:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L46setp(cl_narg narg, cl_object v1object, ...) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2449,12 +2377,12 @@ static cl_object L46setp(cl_narg narg, cl_object v1object, ...) cl_parse_key(args,2,L46setpkeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[2])) { - v2test = (ECL_SYM("EQL",336)->symbol.gfdef); + v2test = (ECL_SYM("EQL",334)->symbol.gfdef); } else { v2test = keyvars[0]; } if (Null(keyvars[3])) { - v3key = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + v3key = (ECL_SYM("IDENTITY",426)->symbol.gfdef); } else { v3key = keyvars[1]; } @@ -2486,8 +2414,6 @@ L20:; cl_object v11; v11 = v8; if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v11; } v10 = ECL_CONS_CAR(v9); @@ -2532,7 +2458,6 @@ L4:; static cl_object L47set_equal(cl_narg narg, cl_object v1list1, cl_object v2list2, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2547,7 +2472,7 @@ static cl_object L47set_equal(cl_narg narg, cl_object v1list1, cl_object v2list2 cl_parse_key(args,2,L47set_equalkeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[2])) { - v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + v3test = (ECL_SYM("EQL",334)->symbol.gfdef); } else { v3test = keyvars[0]; } @@ -2566,8 +2491,6 @@ static cl_object L47set_equal(cl_narg narg, cl_object v1list1, cl_object v2list2 cl_object v10; v10 = v1list1; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -2579,21 +2502,17 @@ L11:; if (!(ecl_endp(v9))) { goto L13; } goto L12; L13:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v12; - v12 = ECL_CONS_CDR(v9); + v12 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v12; } { cl_object v12; v12 = v11; if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v12; } T1 = ecl_function_dispatch(cl_env_copy,v4key)(1, v8); @@ -2617,8 +2536,6 @@ L2:; cl_object v10; v10 = v2list2; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -2630,21 +2547,17 @@ L38:; if (!(ecl_endp(v9))) { goto L40; } goto L39; L40:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v12; - v12 = ECL_CONS_CDR(v9); + v12 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v12; } { cl_object v12; v12 = v11; if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v12; } T1 = ecl_function_dispatch(cl_env_copy,v4key)(1, v8); @@ -2679,8 +2592,6 @@ L72:; cl_object v13; v13 = v10; if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v13; } v12 = ECL_CONS_CAR(v11); @@ -2729,8 +2640,6 @@ L102:; cl_object v13; v13 = v10; if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v13; } v12 = ECL_CONS_CAR(v11); @@ -2776,7 +2685,6 @@ L57:; static cl_object L51map_product(cl_narg narg, cl_object v1function, cl_object v2list, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2786,7 +2694,7 @@ static cl_object L51map_product(cl_narg narg, cl_object v1function, cl_object v2 ecl_va_list args; ecl_va_start(args,v2list,narg,2); v3more_lists = cl_grab_rest_args(args); ecl_va_end(args); - T0 = ecl_function_dispatch(cl_env_copy,VV[99])(1, v1function) /* ENSURE-FUNCTION */; + T0 = ecl_function_dispatch(cl_env_copy,VV[93])(1, v1function) /* ENSURE-FUNCTION */; T1 = CONS(v2list,v3more_lists); value0 = LC50_map_product(T0, T1); return value0; @@ -2797,7 +2705,7 @@ static cl_object L51map_product(cl_narg narg, cl_object v1function, cl_object v2 static cl_object LC50_map_product(cl_object v1f, cl_object v2lists) { cl_object T0, T1; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -2821,8 +2729,6 @@ static cl_object LC50_map_product(cl_object v1f, cl_object v2lists) cl_object v7; v7 = v4; if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v7; } { @@ -2834,21 +2740,17 @@ L11:; if (!(ecl_endp(v6))) { goto L13; } goto L12; L13:; - v5 = ECL_CONS_CAR(v6); + v5 = _ecl_car(v6); { cl_object v9; - v9 = ECL_CONS_CDR(v6); + v9 = _ecl_cdr(v6); if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = v9; } { cl_object v9; v9 = v8; if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v9; } T1 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v5); @@ -2864,7 +2766,7 @@ L12:; L3:; { cl_object v9; - v9 = ecl_make_cclosure_va((cl_objectfn)LC49__lambda338,env1,Cblock,1); + v9 = ecl_make_cclosure_va((cl_objectfn)LC49__g270,env1,Cblock); T0 = v9; } value0 = L45mappend(2, T0, v4); @@ -2872,9 +2774,9 @@ L3:; } } } -/* closure LAMBDA338 */ +/* closure G270 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC49__lambda338(cl_narg narg, cl_object v1x, ...) +static cl_object LC49__g270(cl_narg narg, cl_object v1x, ...) { cl_object T0; cl_object CLV0, CLV1, CLV2, CLV3; @@ -2892,12 +2794,12 @@ static cl_object LC49__lambda338(cl_narg narg, cl_object v1x, ...) { cl_object v2; cl_object env1 = env0; - v2 = ecl_function_dispatch(cl_env_copy,VV[99])(1, ECL_CONS_CAR(CLV0)) /* ENSURE-FUNCTION */; + v2 = ecl_function_dispatch(cl_env_copy,VV[93])(1, ECL_CONS_CAR(CLV0)) /* ENSURE-FUNCTION */; CLV2 = env1 = CONS(v2,env1); CLV3 = env1 = CONS(v1x,env1); { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC48__lambda343,env1,Cblock,0); + v3 = ecl_make_cclosure_va((cl_objectfn)LC48__g275,env1,Cblock); T0 = v3; } } @@ -2906,9 +2808,9 @@ static cl_object LC49__lambda338(cl_narg narg, cl_object v1x, ...) } } } -/* closure LAMBDA343 */ +/* closure G275 */ /* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC48__lambda343(cl_narg narg, ...) +static cl_object LC48__g275(cl_narg narg, ...) { cl_object CLV0, CLV1, CLV2, CLV3; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -2935,7 +2837,6 @@ static cl_object LC48__lambda343(cl_narg narg, ...) static cl_object L53flatten(cl_object v1tree) { volatile cl_object lex0[1]; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2952,7 +2853,6 @@ static cl_object L53flatten(cl_object v1tree) static cl_object LC52traverse(volatile cl_object *lex0, cl_object v1subtree) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2980,7 +2880,7 @@ L1:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecli7UuzzMOVz39M_TlGycC71(cl_object flag) +ECL_DLLEXPORT void _ecli7UuzzMOVz39M_hCh2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -2995,201 +2895,193 @@ ECL_DLLEXPORT void _ecli7UuzzMOVz39M_TlGycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/lists.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/lists.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecli7UuzzMOVz39M_TlGycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecli7UuzzMOVz39M_hCh2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[54]); /* SAFE-ENDP */ - si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[5]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[55]); /* ALIST-PLIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[9]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[12]) /* ANNOTATE */; - ecl_cmp_defun(VV[57]); /* PLIST-ALIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[13]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[14]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[17]) /* ANNOTATE */; - ecl_cmp_defun(VV[58]); /* RACONS */ - si_put_sysprop(VV[3], ECL_SYM("INLINE",436), VVtemp[18]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[53]); /* SAFE-ENDP */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; + ecl_cmp_defun(VV[54]); /* ALIST-PLIST */ + si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[8]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[11]) /* ANNOTATE */; + ecl_cmp_defun(VV[55]); /* PLIST-ALIST */ + si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[12]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[13]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[56]); /* RACONS */ { cl_object T0; - cl_object volatile env0 = ECL_NIL; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[19]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; - ecl_cmp_defun(VV[59]); /* ASSOC-VALUE */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[23]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[4], ECL_SYM("INLINE",436), VVtemp[24]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[17]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defun(VV[57]); /* ASSOC-VALUE */ + si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[21]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC6__lambda30,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun_va((cl_objectfn)LC6assoc_value,ECL_NIL,Cblock); T0 = v1; } si_do_define_setf_method(VV[4], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[25]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[26], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; - ecl_cmp_defun(VV[60]); /* RASSOC-VALUE */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[27]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[13], ECL_SYM("INLINE",436), VVtemp[28]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[22]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[23], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; + ecl_cmp_defun(VV[58]); /* RASSOC-VALUE */ + si_set_documentation(3, VV[12], ECL_SYM("FUNCTION",396), VVtemp[24]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC8__lambda41,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun_va((cl_objectfn)LC8rassoc_value,ECL_NIL,Cblock); T0 = v1; } - si_do_define_setf_method(VV[13], T0); + si_do_define_setf_method(VV[12], T0); } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[12]) /* ANNOTATE */; - ecl_cmp_defun(VV[65]); /* MALFORMED-PLIST */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[66]); /* DOPLIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[34]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[35], VVtemp[36]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[37]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[69]); /* APPENDF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[38]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[40]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[37]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[70]); /* NCONCF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[22], ECL_SYM("FUNCTION",398), VVtemp[41]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[42], VVtemp[43]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[44]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[71]); /* UNIONF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[23], ECL_SYM("FUNCTION",398), VVtemp[45]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LOCATION",1862), VVtemp[46], VVtemp[47]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[44]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[72]); /* NUNIONF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[24], ECL_SYM("FUNCTION",398), VVtemp[48]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[49], VVtemp[50]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[51]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[73]); /* REVERSEF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[25], ECL_SYM("FUNCTION",398), VVtemp[52]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[53], VVtemp[54]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[51]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[74]); /* NREVERSEF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[26], ECL_SYM("FUNCTION",398), VVtemp[55]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LOCATION",1862), VVtemp[56], VVtemp[57]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[27], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[58]) /* ANNOTATE */; - ecl_cmp_defun(VV[75]); /* CIRCULAR-LIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[27], ECL_SYM("FUNCTION",398), VVtemp[59]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; - ecl_cmp_defun(VV[76]); /* CIRCULAR-LIST-P */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[63]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LOCATION",1862), VVtemp[64], VVtemp[65]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; - ecl_cmp_defun(VV[77]); /* CIRCULAR-TREE-P */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[29], ECL_SYM("FUNCTION",398), VVtemp[66]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[30], ECL_SYM("LOCATION",1862), VVtemp[67], VVtemp[68]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[30], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; - ecl_cmp_defun(VV[78]); /* PROPER-LIST-P */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[30], ECL_SYM("FUNCTION",398), VVtemp[69]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[11]) /* ANNOTATE */; + ecl_cmp_defun(VV[60]); /* MALFORMED-PLIST */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[61]); /* DOPLIST */ + si_set_documentation(3, VV[15], ECL_SYM("FUNCTION",396), VVtemp[30]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[63]); /* APPENDF */ + si_set_documentation(3, VV[19], ECL_SYM("FUNCTION",396), VVtemp[34]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[35], VVtemp[36]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[64]); /* NCONCF */ + si_set_documentation(3, VV[21], ECL_SYM("FUNCTION",396), VVtemp[37]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[38], VVtemp[39]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[65]); /* UNIONF */ + si_set_documentation(3, VV[22], ECL_SYM("FUNCTION",396), VVtemp[41]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[43]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[66]); /* NUNIONF */ + si_set_documentation(3, VV[23], ECL_SYM("FUNCTION",396), VVtemp[44]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LOCATION",1777), VVtemp[45], VVtemp[46]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[47]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[67]); /* REVERSEF */ + si_set_documentation(3, VV[24], ECL_SYM("FUNCTION",396), VVtemp[48]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[49], VVtemp[50]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[47]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[68]); /* NREVERSEF */ + si_set_documentation(3, VV[25], ECL_SYM("FUNCTION",396), VVtemp[51]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[53]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[54]) /* ANNOTATE */; + ecl_cmp_defun(VV[69]); /* CIRCULAR-LIST */ + si_set_documentation(3, VV[26], ECL_SYM("FUNCTION",396), VVtemp[55]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LOCATION",1777), VVtemp[56], VVtemp[57]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; + ecl_cmp_defun(VV[70]); /* CIRCULAR-LIST-P */ + si_set_documentation(3, VV[27], ECL_SYM("FUNCTION",396), VVtemp[59]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[60], VVtemp[61]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; + ecl_cmp_defun(VV[71]); /* CIRCULAR-TREE-P */ + si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[62]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[29], ECL_SYM("LOCATION",1777), VVtemp[63], VVtemp[64]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[29], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; + ecl_cmp_defun(VV[72]); /* PROPER-LIST-P */ + si_set_documentation(3, VV[29], ECL_SYM("FUNCTION",396), VVtemp[65]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[31], ECL_SYM("TYPE",871), VVtemp[70]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[30], ECL_SYM("TYPE",869), VVtemp[66]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC28__lambda161,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC28proper_list,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[31], VVtemp[71], T0); + si_do_deftype(3, VV[30], VVtemp[67], T0); } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LOCATION",1862), VVtemp[72], VVtemp[73]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; - ecl_cmp_defun(VV[79]); /* CIRCULAR-LIST-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[35], ECL_SYM("LOCATION",1862), VVtemp[75], VVtemp[76]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[35], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; - ecl_cmp_defun(VV[80]); /* PROPER-LIST-LENGTH */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[35], ECL_SYM("FUNCTION",398), VVtemp[77]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LOCATION",1862), VVtemp[78], VVtemp[76]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; - ecl_cmp_defun(VV[81]); /* LASTCAR */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[36], ECL_SYM("FUNCTION",398), VVtemp[79]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[80], ECL_SYM("LOCATION",1862), VVtemp[81], VVtemp[76]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[80], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[82]) /* ANNOTATE */; - ecl_cmp_defun(VV[82]); /* (SETF LASTCAR) */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[37], ECL_SYM("FUNCTION",398), VVtemp[83]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LOCATION",1862), VVtemp[84], VVtemp[85]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[86]) /* ANNOTATE */; - ecl_cmp_defun(VV[83]); /* MAKE-CIRCULAR-LIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[38], ECL_SYM("FUNCTION",398), VVtemp[87]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LOCATION",1777), VVtemp[68], VVtemp[69]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; + ecl_cmp_defun(VV[73]); /* CIRCULAR-LIST-ERROR */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LOCATION",1777), VVtemp[71], VVtemp[72]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; + ecl_cmp_defun(VV[74]); /* PROPER-LIST-LENGTH */ + si_set_documentation(3, VV[34], ECL_SYM("FUNCTION",396), VVtemp[73]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LOCATION",1777), VVtemp[74], VVtemp[72]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; + ecl_cmp_defun(VV[75]); /* LASTCAR */ + si_set_documentation(3, VV[35], ECL_SYM("FUNCTION",396), VVtemp[75]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[76], ECL_SYM("LOCATION",1777), VVtemp[77], VVtemp[72]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[76], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[78]) /* ANNOTATE */; + ecl_cmp_defun(VV[76]); /* (SETF LASTCAR) */ + si_set_documentation(3, VV[36], ECL_SYM("FUNCTION",396), VVtemp[79]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LOCATION",1777), VVtemp[80], VVtemp[81]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[82]) /* ANNOTATE */; + ecl_cmp_defun(VV[77]); /* MAKE-CIRCULAR-LIST */ + si_set_documentation(3, VV[37], ECL_SYM("FUNCTION",396), VVtemp[83]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[27], ECL_SYM("TYPE",871), VVtemp[88]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[26], ECL_SYM("TYPE",869), VVtemp[84]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC34__lambda193,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC34circular_list,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[27], VVtemp[89], T0); + si_do_deftype(3, VV[26], VVtemp[85], T0); } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[90], VVtemp[91]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[92]) /* ANNOTATE */; - ecl_cmp_defun(VV[85]); /* ENSURE-CAR */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[40], ECL_SYM("FUNCTION",398), VVtemp[93]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LOCATION",1862), VVtemp[94], VVtemp[95]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[96]) /* ANNOTATE */; - ecl_cmp_defun(VV[86]); /* ENSURE-CONS */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[41], ECL_SYM("FUNCTION",398), VVtemp[97]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[98], VVtemp[99]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[74]) /* ANNOTATE */; - ecl_cmp_defun(VV[87]); /* ENSURE-LIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[42], ECL_SYM("FUNCTION",398), VVtemp[100]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LOCATION",1862), VVtemp[101], VVtemp[102]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[103]) /* ANNOTATE */; - ecl_cmp_defun(VV[88]); /* REMOVE-FROM-PLIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[43], ECL_SYM("FUNCTION",398), VVtemp[104]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LOCATION",1862), VVtemp[105], VVtemp[106]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[103]) /* ANNOTATE */; - ecl_cmp_defun(VV[89]); /* DELETE-FROM-PLIST */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[45], ECL_SYM("FUNCTION",398), VVtemp[107]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[46], ECL_SYM("LOCATION",1862), VVtemp[108], VVtemp[109]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[46], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[110]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[90]); /* REMOVE-FROM-PLISTF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[46], ECL_SYM("FUNCTION",398), VVtemp[111]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[47], ECL_SYM("LOCATION",1862), VVtemp[112], VVtemp[113]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[47], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[110]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[91]); /* DELETE-FROM-PLISTF */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[47], ECL_SYM("FUNCTION",398), VVtemp[114]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[115]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LOCATION",1862), VVtemp[116], VVtemp[117]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[103]) /* ANNOTATE */; - ecl_cmp_defun(VV[92]); /* SANS */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[48], ECL_SYM("FUNCTION",398), VVtemp[118]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[48], ECL_SYM("INLINE",436), VVtemp[119]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LOCATION",1862), VVtemp[120], VVtemp[121]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[122]) /* ANNOTATE */; - ecl_cmp_defun(VV[93]); /* MAPPEND */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[49], ECL_SYM("FUNCTION",398), VVtemp[123]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LOCATION",1862), VVtemp[124], VVtemp[125]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[126]) /* ANNOTATE */; - ecl_cmp_defun(VV[94]); /* SETP */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[50], ECL_SYM("FUNCTION",398), VVtemp[127]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LOCATION",1862), VVtemp[128], VVtemp[129]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[130]) /* ANNOTATE */; - ecl_cmp_defun(VV[97]); /* SET-EQUAL */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[51], ECL_SYM("FUNCTION",398), VVtemp[131]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[52], ECL_SYM("LOCATION",1862), VVtemp[132], VVtemp[133]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[52], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[134]) /* ANNOTATE */; - ecl_cmp_defun(VV[98]); /* MAP-PRODUCT */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[52], ECL_SYM("FUNCTION",398), VVtemp[135]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[53], ECL_SYM("LOCATION",1862), VVtemp[136], VVtemp[137]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[53], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[138]) /* ANNOTATE */; - ecl_cmp_defun(VV[100]); /* FLATTEN */ - ecl_function_dispatch(cl_env_copy,VV[56])(3, VV[53], ECL_SYM("FUNCTION",398), VVtemp[139]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LOCATION",1777), VVtemp[86], VVtemp[87]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[88]) /* ANNOTATE */; + ecl_cmp_defun(VV[79]); /* ENSURE-CAR */ + si_set_documentation(3, VV[39], ECL_SYM("FUNCTION",396), VVtemp[89]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LOCATION",1777), VVtemp[90], VVtemp[91]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[92]) /* ANNOTATE */; + ecl_cmp_defun(VV[80]); /* ENSURE-CONS */ + si_set_documentation(3, VV[40], ECL_SYM("FUNCTION",396), VVtemp[93]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[94], VVtemp[95]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; + ecl_cmp_defun(VV[81]); /* ENSURE-LIST */ + si_set_documentation(3, VV[41], ECL_SYM("FUNCTION",396), VVtemp[96]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LOCATION",1777), VVtemp[97], VVtemp[98]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[99]) /* ANNOTATE */; + ecl_cmp_defun(VV[82]); /* REMOVE-FROM-PLIST */ + si_set_documentation(3, VV[42], ECL_SYM("FUNCTION",396), VVtemp[100]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LOCATION",1777), VVtemp[101], VVtemp[102]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[99]) /* ANNOTATE */; + ecl_cmp_defun(VV[83]); /* DELETE-FROM-PLIST */ + si_set_documentation(3, VV[44], ECL_SYM("FUNCTION",396), VVtemp[103]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[45], ECL_SYM("LOCATION",1777), VVtemp[104], VVtemp[105]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[45], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[106]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[84]); /* REMOVE-FROM-PLISTF */ + si_set_documentation(3, VV[45], ECL_SYM("FUNCTION",396), VVtemp[107]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[46], ECL_SYM("LOCATION",1777), VVtemp[108], VVtemp[109]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[46], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[106]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[85]); /* DELETE-FROM-PLISTF */ + si_set_documentation(3, VV[46], ECL_SYM("FUNCTION",396), VVtemp[110]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[111]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[47], ECL_SYM("LOCATION",1777), VVtemp[112], VVtemp[113]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[47], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[99]) /* ANNOTATE */; + ecl_cmp_defun(VV[86]); /* SANS */ + si_set_documentation(3, VV[47], ECL_SYM("FUNCTION",396), VVtemp[114]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LOCATION",1777), VVtemp[115], VVtemp[116]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[117]) /* ANNOTATE */; + ecl_cmp_defun(VV[87]); /* MAPPEND */ + si_set_documentation(3, VV[48], ECL_SYM("FUNCTION",396), VVtemp[118]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LOCATION",1777), VVtemp[119], VVtemp[120]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[121]) /* ANNOTATE */; + ecl_cmp_defun(VV[88]); /* SETP */ + si_set_documentation(3, VV[49], ECL_SYM("FUNCTION",396), VVtemp[122]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LOCATION",1777), VVtemp[123], VVtemp[124]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[125]) /* ANNOTATE */; + ecl_cmp_defun(VV[91]); /* SET-EQUAL */ + si_set_documentation(3, VV[50], ECL_SYM("FUNCTION",396), VVtemp[126]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LOCATION",1777), VVtemp[127], VVtemp[128]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[129]) /* ANNOTATE */; + ecl_cmp_defun(VV[92]); /* MAP-PRODUCT */ + si_set_documentation(3, VV[51], ECL_SYM("FUNCTION",396), VVtemp[130]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[52], ECL_SYM("LOCATION",1777), VVtemp[131], VVtemp[132]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[52], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[133]) /* ANNOTATE */; + ecl_cmp_defun(VV[94]); /* FLATTEN */ + si_set_documentation(3, VV[52], ECL_SYM("FUNCTION",396), VVtemp[134]); } diff --git a/lib/alexandria/macros.cxx b/lib/alexandria/macros.cxx index af4271c..026b471 100644 --- a/lib/alexandria/macros.cxx +++ b/lib/alexandria/macros.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/macros.lisp */ +/* Source: lib/alexandria/macros.lisp */ #include #include "lib/alexandria/macros.eclh" /* local function WITH-GENSYMS */ @@ -9,7 +9,6 @@ static cl_object LC2with_gensyms(cl_object v1, cl_object v2) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -20,7 +19,7 @@ static cl_object LC2with_gensyms(cl_object v1, cl_object v2) cl_object v4names; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -32,7 +31,7 @@ L3:; cl_object v5; { cl_object v6; - v6 = ecl_make_cfun((cl_objectfn_fixed)LC1__lambda16,ECL_NIL,Cblock,1); + v6 = ecl_make_cfun((cl_objectfn_fixed)LC1__g16,ECL_NIL,Cblock,1); v5 = v6; } { @@ -43,8 +42,6 @@ L3:; cl_object v8; v8 = v4names; if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v8; } { @@ -56,21 +53,17 @@ L16:; if (!(ecl_endp(v7))) { goto L18; } goto L17; L18:; - v6 = ECL_CONS_CAR(v7); + v6 = _ecl_car(v7); { cl_object v10; - v10 = ECL_CONS_CDR(v7); + v10 = _ecl_cdr(v7); if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v10; } { cl_object v10; v10 = v9; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v10; } T2 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); @@ -84,17 +77,16 @@ L17:; } } L8:; - value0 = cl_listX(3, ECL_SYM("LET",479), T0, v3); + value0 = cl_listX(3, ECL_SYM("LET",477), T0, v3); return value0; } } } -/* local function LAMBDA16 */ +/* local function G16 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__lambda16(cl_object v1name) +static cl_object LC1__g16(cl_object v1name) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -123,14 +115,14 @@ L2:; L4:; value0 = si_etypecase_error(v1name, VV[2]); L1:; + v3 = value0; { const int v5 = cl_env_copy->nvalues; - v3 = value0; cl_object v6; v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1]; v4 = v6; } - T0 = cl_list(2, ECL_SYM("GENSYM",402), v4); + T0 = cl_list(2, ECL_SYM("GENSYM",400), v4); value0 = cl_list(2, v3, T0); return value0; } @@ -140,7 +132,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC3with_unique_names(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -151,7 +142,7 @@ static cl_object LC3with_unique_names(cl_object v1, cl_object v2) cl_object v4names; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -169,7 +160,6 @@ L3:; static cl_object LC8once_only(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -180,7 +170,7 @@ static cl_object LC8once_only(cl_object v1, cl_object v2) cl_object v4specs; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -194,13 +184,13 @@ L3:; { cl_fixnum v7; v7 = ecl_length(v4specs); - v5 = ecl_function_dispatch(cl_env_copy,VV[48])(2, ecl_make_fixnum(v7), VV[5]) /* MAKE-GENSYM-LIST */; + v5 = ecl_function_dispatch(cl_env_copy,VV[45])(2, ecl_make_fixnum(v7), VV[5]) /* MAKE-GENSYM-LIST */; } { cl_object v7; { cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda53,ECL_NIL,Cblock,1); + v8 = ecl_make_cfun((cl_objectfn_fixed)LC4__g53,ECL_NIL,Cblock,1); v7 = v8; } { @@ -211,8 +201,6 @@ L3:; cl_object v10; v10 = v4specs; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -224,21 +212,17 @@ L17:; if (!(ecl_endp(v9))) { goto L19; } goto L18; L19:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v12; - v12 = ECL_CONS_CDR(v9); + v12 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v12; } { cl_object v12; v12 = v11; if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v12; } T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); @@ -256,7 +240,7 @@ L9:; cl_object v7; { cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC5__lambda68,ECL_NIL,Cblock,2); + v8 = ecl_make_cfun((cl_objectfn_fixed)LC5__g68,ECL_NIL,Cblock,2); v7 = v8; } { @@ -267,8 +251,6 @@ L9:; cl_object v10; v10 = v5; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -279,8 +261,6 @@ L9:; cl_object v12; v12 = v6; if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v12; } { @@ -292,33 +272,27 @@ L47:; if (!(ecl_endp(v9))) { goto L49; } goto L48; L49:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v14; - v14 = ECL_CONS_CDR(v9); + v14 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v14; } if (!(ecl_endp(v11))) { goto L57; } goto L48; L57:; - v10 = ECL_CONS_CAR(v11); + v10 = _ecl_car(v11); { cl_object v14; - v14 = ECL_CONS_CDR(v11); + v14 = _ecl_cdr(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T1 = v14; } T2 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); @@ -337,7 +311,7 @@ L35:; cl_object v7; { cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC6__lambda80,ECL_NIL,Cblock,2); + v8 = ecl_make_cfun((cl_objectfn_fixed)LC6__g80,ECL_NIL,Cblock,2); v7 = v8; } { @@ -348,8 +322,6 @@ L35:; cl_object v10; v10 = v5; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -360,8 +332,6 @@ L35:; cl_object v12; v12 = v6; if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v12; } { @@ -373,33 +343,27 @@ L85:; if (!(ecl_endp(v9))) { goto L87; } goto L86; L87:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v14; - v14 = ECL_CONS_CDR(v9); + v14 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v14; } if (!(ecl_endp(v11))) { goto L95; } goto L86; L95:; - v10 = ECL_CONS_CAR(v11); + v10 = _ecl_car(v11); { cl_object v14; - v14 = ECL_CONS_CDR(v11); + v14 = _ecl_cdr(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T2 = v14; } T3 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); @@ -414,12 +378,12 @@ L86:; } } L73:; - T2 = CONS(ECL_SYM("LIST",483),T1); + T2 = CONS(ECL_SYM("LIST",481),T1); { cl_object v7; { cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC7__lambda92,ECL_NIL,Cblock,2); + v8 = ecl_make_cfun((cl_objectfn_fixed)LC7__g92,ECL_NIL,Cblock,2); v7 = v8; } { @@ -430,8 +394,6 @@ L73:; cl_object v10; v10 = v6; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -442,8 +404,6 @@ L73:; cl_object v12; v12 = v5; if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v12; } { @@ -455,33 +415,27 @@ L123:; if (!(ecl_endp(v9))) { goto L125; } goto L124; L125:; - v8 = ECL_CONS_CAR(v9); + v8 = _ecl_car(v9); { cl_object v14; - v14 = ECL_CONS_CDR(v9); + v14 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v14; } if (!(ecl_endp(v11))) { goto L133; } goto L124; L133:; - v10 = ECL_CONS_CAR(v11); + v10 = _ecl_car(v11); { cl_object v14; - v14 = ECL_CONS_CDR(v11); + v14 = _ecl_cdr(v11); if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v11 = v14; } { cl_object v14; v14 = v13; if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T4 = v14; } T5 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); @@ -496,19 +450,18 @@ L124:; } } L111:; - T4 = cl_listX(3, ECL_SYM("LET",479), T3, v3); - T5 = cl_list(4, ECL_SYM("LIST",483), VV[7], T2, T4); - value0 = cl_list(3, ECL_SYM("LET",479), T0, T5); + T4 = cl_listX(3, ECL_SYM("LET",477), T3, v3); + T5 = cl_list(4, ECL_SYM("LIST",481), VV[7], T2, T4); + value0 = cl_list(3, ECL_SYM("LET",477), T0, T5); return value0; } } } } -/* local function LAMBDA53 */ +/* local function G53 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__lambda53(cl_object v1spec) +static cl_object LC4__g53(cl_object v1spec) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -521,7 +474,7 @@ static cl_object LC4__lambda53(cl_object v1spec) cl_object v4form; v2 = v1spec; if (!(v2==ECL_NIL)) { goto L5; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1spec); L5:; { cl_object v5; @@ -530,7 +483,7 @@ L5:; v3name = v5; } if (!(v2==ECL_NIL)) { goto L11; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1spec); L11:; { cl_object v5; @@ -539,7 +492,7 @@ L11:; v4form = v5; } if (Null(v2)) { goto L16; } - ecl_function_dispatch(cl_env_copy,VV[49])(1, v1spec) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1spec); L16:; value0 = CONS(v3name,v4form); cl_env_copy->nvalues = 1; @@ -555,12 +508,11 @@ L18:; return value0; } } -/* local function LAMBDA68 */ +/* local function G68 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5__lambda68(cl_object v1g, cl_object v2n) +static cl_object LC5__g68(cl_object v1g, cl_object v2n) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -568,33 +520,31 @@ static cl_object LC5__lambda68(cl_object v1g, cl_object v2n) TTL: T0 = ecl_car(v2n); T1 = cl_string(T0); - T2 = cl_list(2, ECL_SYM("GENSYM",402), T1); + T2 = cl_list(2, ECL_SYM("GENSYM",400), T1); value0 = cl_list(2, v1g, T2); return value0; } } -/* local function LAMBDA80 */ +/* local function G80 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6__lambda80(cl_object v1g, cl_object v2n) +static cl_object LC6__g80(cl_object v1g, cl_object v2n) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: T0 = ecl_cdr(v2n); - value0 = cl_list(3, ECL_SYM("LIST",483), v1g, T0); + value0 = cl_list(3, ECL_SYM("LIST",481), v1g, T0); return value0; } } -/* local function LAMBDA92 */ +/* local function G92 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__lambda92(cl_object v1n, cl_object v2g) +static cl_object LC7__g92(cl_object v1n, cl_object v2g) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -610,7 +560,6 @@ static cl_object LC7__lambda92(cl_object v1n, cl_object v2g) static cl_object L9parse_body(cl_narg narg, cl_object v1body, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -656,14 +605,7 @@ L13:; { cl_object v8; v8 = v7; - { - bool v9; - v9 = ECL_LISTP(v8); - if (ecl_unlikely(!(v9))) - FEwrong_type_argument(VV[10],v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); } if (Null(v7)) { goto L24; } { @@ -680,21 +622,14 @@ L12:; L8:; if (!(ECL_LISTP(v6current))) { goto L30; } T0 = ecl_car(v6current); - if (!((T0)==(ECL_SYM("DECLARE",276)))) { goto L30; } + if (!((T0)==(ECL_SYM("DECLARE",274)))) { goto L30; } { cl_object v7; v7 = v1body; { cl_object v8; v8 = v7; - { - bool v9; - v9 = ECL_LISTP(v8); - if (ecl_unlikely(!(v9))) - FEwrong_type_argument(VV[10],v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); } if (Null(v7)) { goto L40; } { @@ -724,7 +659,6 @@ static cl_object L13parse_ordinary_lambda_list(cl_narg narg, cl_object v1lambda_ { cl_object T0, T1, T2, T3; volatile cl_object lex0[2]; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -772,7 +706,7 @@ static cl_object L13parse_ordinary_lambda_list(cl_narg narg, cl_object v1lambda_ cl_object v12keys; cl_object v13keyp; cl_object v14aux; - v6state = ECL_SYM("REQUIRED",1010); + v6state = ECL_SYM("REQUIRED",1008); v7allow_other_keys = ECL_NIL; v8auxp = ECL_NIL; v9required = ECL_NIL; @@ -792,22 +726,22 @@ L17:; { cl_object v17; v17 = v16elt; - if (!((v17)==(ECL_SYM("&OPTIONAL",13)))) { goto L24; } - if (!((v6state)==(ECL_SYM("REQUIRED",1010)))) { goto L26; } + if (!((v17)==(ECL_SYM("&OPTIONAL",11)))) { goto L24; } + if (!((v6state)==(ECL_SYM("REQUIRED",1008)))) { goto L26; } v6state = v16elt; goto L22; L26:; LC10fail(lex0, v16elt); goto L22; L24:; - if (!((v17)==(ECL_SYM("&REST",14)))) { goto L29; } - if (!((v6state)==(ECL_SYM("REQUIRED",1010)))) { goto L36; } + if (!((v17)==(ECL_SYM("&REST",12)))) { goto L29; } + if (!(ecl_eql(v6state,ECL_SYM("REQUIRED",1008)))) { goto L36; } goto L33; goto L34; L36:; goto L34; L34:; - if (!((v6state)==(ECL_SYM("&OPTIONAL",13)))) { goto L31; } + if (!((v6state)==(ECL_SYM("&OPTIONAL",11)))) { goto L31; } goto L32; L33:; L32:; @@ -817,20 +751,20 @@ L31:; LC10fail(lex0, v16elt); goto L22; L29:; - if (!((v17)==(ECL_SYM("&KEY",12)))) { goto L40; } - if (!((v6state)==(ECL_SYM("REQUIRED",1010)))) { goto L48; } + if (!((v17)==(ECL_SYM("&KEY",10)))) { goto L40; } + if (!(ecl_eql(v6state,ECL_SYM("REQUIRED",1008)))) { goto L48; } goto L45; goto L46; L48:; goto L46; L46:; - if (!((v6state)==(ECL_SYM("&OPTIONAL",13)))) { goto L52; } + if (!((v6state)==(ECL_SYM("&OPTIONAL",11)))) { goto L52; } goto L45; goto L50; L52:; goto L50; L50:; - if (!((v6state)==(VV[18]))) { goto L43; } + if (!(ecl_eql(v6state,VV[17]))) { goto L43; } goto L44; L45:; L44:; @@ -842,8 +776,8 @@ L42:; v13keyp = ECL_T; goto L22; L40:; - if (!((v17)==(ECL_SYM("&ALLOW-OTHER-KEYS",8)))) { goto L57; } - if (!((v6state)==(ECL_SYM("&KEY",12)))) { goto L59; } + if (!((v17)==(ECL_SYM("&ALLOW-OTHER-KEYS",6)))) { goto L57; } + if (!((v6state)==(ECL_SYM("&KEY",10)))) { goto L59; } v7allow_other_keys = ECL_T; v6state = v16elt; goto L22; @@ -851,46 +785,46 @@ L59:; LC10fail(lex0, v16elt); goto L22; L57:; - if (!((v17)==(ECL_SYM("&AUX",9)))) { goto L64; } - if (!((v6state)==(ECL_SYM("&REST",14)))) { goto L66; } + if (!((v17)==(ECL_SYM("&AUX",7)))) { goto L64; } + if (!((v6state)==(ECL_SYM("&REST",12)))) { goto L66; } LC10fail(lex0, v16elt); goto L22; L66:; if (Null(v8auxp)) { goto L68; } - ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[20], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[19], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; goto L22; L68:; v8auxp = ECL_T; v6state = v16elt; goto L22; L64:; - if (!((v16elt)==(ECL_SYM("&WHOLE",15)))) { goto L78; } + if (!((v16elt)==(ECL_SYM("&WHOLE",13)))) { goto L78; } goto L75; goto L76; L78:; goto L76; L76:; - if (!((v16elt)==(ECL_SYM("&ENVIRONMENT",11)))) { goto L82; } + if (!((v16elt)==(ECL_SYM("&ENVIRONMENT",9)))) { goto L82; } goto L75; goto L80; L82:; goto L80; L80:; - if (!((v16elt)==(ECL_SYM("&BODY",10)))) { goto L73; } + if (!((v16elt)==(ECL_SYM("&BODY",8)))) { goto L73; } goto L74; L75:; L74:; - ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[24], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[23], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; L73:; { cl_object v18; v18 = v6state; - if (!((v18)==(ECL_SYM("REQUIRED",1010)))) { goto L86; } - LC11check_variable(2, lex0, v16elt, VV[25]); + if (!(ecl_eql(v18,ECL_SYM("REQUIRED",1008)))) { goto L86; } + LC11check_variable(2, lex0, v16elt, VV[24]); v9required = CONS(v16elt,v9required); goto L22; L86:; - if (!((v18)==(ECL_SYM("&OPTIONAL",13)))) { goto L90; } + if (!((v18)==(ECL_SYM("&OPTIONAL",11)))) { goto L90; } if (!(ECL_CONSP(v16elt))) { goto L93; } { cl_object v19; @@ -899,7 +833,7 @@ L86:; v19 = v16elt; v20 = v19; if (!(v20==ECL_NIL)) { goto L98; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v19) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v19); L98:; { cl_object v22; @@ -907,31 +841,31 @@ L98:; v20 = ecl_cdr(v20); v21name = v22; } - LC11check_variable(2, lex0, v21name, VV[26]); + LC11check_variable(2, lex0, v21name, VV[25]); if (Null(ecl_cdr(v20))) { goto L104; } - LC12check_spec(lex0, v20, VV[27]); + LC12check_spec(lex0, v20, VV[26]); goto L92; L104:; if (Null(v3normalize_optional)) { goto L92; } - v16elt = ecl_append(v16elt,VV[28]); + v16elt = ecl_append(v16elt,VV[27]); goto L92; } L93:; - LC11check_variable(2, lex0, v16elt, VV[26]); + LC11check_variable(2, lex0, v16elt, VV[25]); if (Null(v3normalize_optional)) { goto L92; } - v16elt = CONS(v16elt,VV[29]); + v16elt = CONS(v16elt,VV[28]); L92:; - T0 = ecl_function_dispatch(cl_env_copy,VV[60])(1, v16elt) /* ENSURE-LIST */; + T0 = ecl_function_dispatch(cl_env_copy,VV[56])(1, v16elt) /* ENSURE-LIST */; v10optional = CONS(T0,v10optional); goto L22; L90:; - if (!((v18)==(ECL_SYM("&REST",14)))) { goto L112; } - LC11check_variable(2, lex0, v16elt, VV[30]); + if (!((v18)==(ECL_SYM("&REST",12)))) { goto L112; } + LC11check_variable(2, lex0, v16elt, VV[29]); v11rest = v16elt; - v6state = VV[18]; + v6state = VV[17]; goto L22; L112:; - if (!((v18)==(ECL_SYM("&KEY",12)))) { goto L118; } + if (!((v18)==(ECL_SYM("&KEY",10)))) { goto L118; } if (!(ECL_CONSP(v16elt))) { goto L121; } { cl_object v19; @@ -941,7 +875,7 @@ L112:; v19 = v16elt; v20 = v19; if (!(v20==ECL_NIL)) { goto L126; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v19) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v19); L126:; { cl_object v23; @@ -957,7 +891,7 @@ L126:; cl_object v25var; v23 = v21var_or_kv; if (!(v23==ECL_NIL)) { goto L137; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v21var_or_kv) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v21var_or_kv); L137:; { cl_object v26; @@ -966,7 +900,7 @@ L137:; v24keyword = v26; } if (!(v23==ECL_NIL)) { goto L143; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v21var_or_kv) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v21var_or_kv); L143:; { cl_object v26; @@ -975,34 +909,34 @@ L143:; v25var = v26; } if (Null(v23)) { goto L148; } - ecl_function_dispatch(cl_env_copy,VV[49])(1, v21var_or_kv) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v21var_or_kv); L148:; if (ECL_SYMBOLP(v24keyword)) { goto L150; } - ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[31], v24keyword, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[30], v24keyword, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; L150:; - LC11check_variable(2, lex0, v25var, VV[32]); + LC11check_variable(2, lex0, v25var, VV[31]); goto L132; } L133:; - LC11check_variable(2, lex0, v21var_or_kv, VV[32]); + LC11check_variable(2, lex0, v21var_or_kv, VV[31]); if (Null(v4normalize_keyword)) { goto L132; } - T0 = ecl_function_dispatch(cl_env_copy,VV[61])(1, v21var_or_kv) /* MAKE-KEYWORD */; + T0 = ecl_function_dispatch(cl_env_copy,VV[57])(1, v21var_or_kv) /* MAKE-KEYWORD */; v21var_or_kv = cl_list(2, T0, v21var_or_kv); L132:; if (Null(ecl_cdr(v22tail))) { goto L156; } - LC12check_spec(lex0, v22tail, VV[33]); + LC12check_spec(lex0, v22tail, VV[32]); goto L155; L156:; if (Null(v4normalize_keyword)) { goto L155; } - v22tail = ecl_append(v22tail,VV[28]); + v22tail = ecl_append(v22tail,VV[27]); L155:; v16elt = CONS(v21var_or_kv,v22tail); goto L120; } L121:; - LC11check_variable(2, lex0, v16elt, VV[32]); + LC11check_variable(2, lex0, v16elt, VV[31]); if (Null(v4normalize_keyword)) { goto L163; } - T0 = ecl_function_dispatch(cl_env_copy,VV[61])(1, v16elt) /* MAKE-KEYWORD */; + T0 = ecl_function_dispatch(cl_env_copy,VV[57])(1, v16elt) /* MAKE-KEYWORD */; T1 = cl_list(2, T0, v16elt); v16elt = cl_list(3, T1, ECL_NIL, ECL_NIL); goto L162; @@ -1012,7 +946,7 @@ L120:; v12keys = CONS(v16elt,v12keys); goto L22; L118:; - if (!((v18)==(ECL_SYM("&AUX",9)))) { goto L166; } + if (!((v18)==(ECL_SYM("&AUX",7)))) { goto L166; } if (!(ECL_CONSP(v16elt))) { goto L169; } { cl_object v19; @@ -1020,7 +954,7 @@ L118:; cl_object v21init; v19 = v16elt; if (!(v19==ECL_NIL)) { goto L173; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v16elt) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v16elt); L173:; { cl_object v22; @@ -1040,15 +974,15 @@ L179:; v21init = ECL_NIL; L178:; if (Null(v19)) { goto L184; } - ecl_function_dispatch(cl_env_copy,VV[49])(1, v16elt) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v16elt); L184:; - LC11check_variable(2, lex0, v20var, VV[34]); + LC11check_variable(2, lex0, v20var, VV[33]); goto L168; } L169:; - LC11check_variable(2, lex0, v16elt, VV[34]); + LC11check_variable(2, lex0, v16elt, VV[33]); if (Null(v5normalize_auxilary)) { goto L189; } - T0 = VV[28]; + T0 = VV[27]; goto L188; L189:; T0 = ECL_NIL; @@ -1058,7 +992,7 @@ L168:; v14aux = CONS(v16elt,v14aux); goto L22; L166:; - ecl_function_dispatch(cl_env_copy,VV[59])(2, VV[35], lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + ecl_function_dispatch(cl_env_copy,VV[55])(2, VV[34], lex0[0]) /* SIMPLE-PROGRAM-ERROR */; } } L22:; @@ -1089,7 +1023,6 @@ L194:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC12check_spec(volatile cl_object *lex0, cl_object v1spec, cl_object v2what) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1101,7 +1034,7 @@ static cl_object LC12check_spec(volatile cl_object *lex0, cl_object v1spec, cl_o cl_object v5suppliedp; v3 = v1spec; if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1spec); L3:; { cl_object v6; @@ -1110,7 +1043,7 @@ L3:; v4init = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1spec) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1spec); L9:; { cl_object v6; @@ -1119,7 +1052,7 @@ L9:; v5suppliedp = v6; } if (Null(v3)) { goto L14; } - ecl_function_dispatch(cl_env_copy,VV[49])(1, v1spec) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1spec); L14:; value0 = LC11check_variable(3, lex0, v5suppliedp, v2what, ECL_NIL); return value0; @@ -1131,7 +1064,6 @@ L14:; static cl_object LC11check_variable(cl_narg narg, volatile cl_object *lex0, cl_object v1elt, cl_object v2what, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1168,7 +1100,7 @@ L6:; L5:; goto L3; L3:; - value0 = ecl_function_dispatch(cl_env_copy,VV[59])(4, VV[13], v2what, v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + value0 = ecl_function_dispatch(cl_env_copy,VV[55])(4, VV[12], v2what, v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; return value0; L2:; value0 = ECL_NIL; @@ -1180,13 +1112,12 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC10fail(volatile cl_object *lex0, cl_object v1elt) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[59])(3, VV[12], v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; + value0 = ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[11], v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; return value0; } } @@ -1195,7 +1126,7 @@ static cl_object LC10fail(volatile cl_object *lex0, cl_object v1elt) static cl_object L15expand_destructuring_case(cl_object v1key, cl_object v2clauses, cl_object v3case) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1204,20 +1135,20 @@ static cl_object L15expand_destructuring_case(cl_object v1key, cl_object v2claus TTL: { cl_object v4; - v4 = cl_gensym(1, VV[37]); + v4 = cl_gensym(1, VV[36]); T0 = cl_list(2, v4, v1key); T1 = ecl_list1(T0); { cl_object env1 = env0; env1 = ECL_NIL; CLV0 = env1 = CONS(v4,env1); /* KEY */ - T3 = cl_list(3, ECL_SYM("TYPEP",877), ECL_CONS_CAR(CLV0), VV[38]); - T4 = cl_list(2, ECL_SYM("CAR",182), ECL_CONS_CAR(CLV0)); + T3 = cl_list(3, ECL_SYM("TYPEP",875), ECL_CONS_CAR(CLV0), VV[37]); + T4 = cl_list(2, ECL_SYM("CAR",180), ECL_CONS_CAR(CLV0)); { cl_object v5; { cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC14__lambda196,env1,Cblock,1); + v6 = ecl_make_cclosure_va((cl_objectfn)LC14__g169,env1,Cblock); v5 = v6; } { @@ -1228,8 +1159,6 @@ static cl_object L15expand_destructuring_case(cl_object v1key, cl_object v2claus cl_object v8; v8 = v2clauses; if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v8; } { @@ -1241,21 +1170,17 @@ L11:; if (!(ecl_endp(v7))) { goto L13; } goto L12; L13:; - v6 = ECL_CONS_CAR(v7); + v6 = _ecl_car(v7); { cl_object v10; - v10 = ECL_CONS_CDR(v7); + v10 = _ecl_cdr(v7); if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = v10; } { cl_object v10; v10 = v9; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T6 = v10; } T7 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); @@ -1270,18 +1195,18 @@ L12:; } L3:; T6 = cl_listX(3, v3case, T4, T5); - T7 = cl_list(2, ECL_SYM("QUOTE",681), v3case); - T8 = cl_list(4, ECL_SYM("ERROR",339), VV[39], T7, ECL_CONS_CAR(CLV0)); - T2 = cl_list(4, ECL_SYM("IF",948), T3, T6, T8); + T7 = cl_list(2, ECL_SYM("QUOTE",679), v3case); + T8 = cl_list(4, ECL_SYM("ERROR",337), VV[38], T7, ECL_CONS_CAR(CLV0)); + T2 = cl_list(4, ECL_SYM("IF",946), T3, T6, T8); } - value0 = cl_list(3, ECL_SYM("LET",479), T1, T2); + value0 = cl_list(3, ECL_SYM("LET",477), T1, T2); return value0; } } } -/* closure LAMBDA196 */ +/* closure G169 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14__lambda196(cl_narg narg, cl_object v1clause, ...) +static cl_object LC14__g169(cl_narg narg, cl_object v1clause, ...) { cl_object T0, T1; cl_object CLV0; @@ -1302,7 +1227,7 @@ static cl_object LC14__lambda196(cl_narg narg, cl_object v1clause, ...) cl_object v5keys; v2 = v1clause; if (!(v2==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1clause) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1clause); L3:; { cl_object v6; @@ -1312,7 +1237,7 @@ L3:; } v4 = v3; if (!(v4==ECL_NIL)) { goto L10; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1clause) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1clause); L10:; { cl_object v6; @@ -1320,8 +1245,8 @@ L10:; v4 = ecl_cdr(v4); v5keys = v6; } - T0 = cl_list(2, ECL_SYM("CDR",200), ECL_CONS_CAR(CLV0)); - T1 = cl_listX(4, ECL_SYM("DESTRUCTURING-BIND",302), v4, T0, v2); + T0 = cl_list(2, ECL_SYM("CDR",198), ECL_CONS_CAR(CLV0)); + T1 = cl_listX(4, ECL_SYM("DESTRUCTURING-BIND",300), v4, T0, v2); value0 = cl_list(2, v5keys, T1); return value0; } @@ -1332,7 +1257,6 @@ L10:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC16destructuring_case(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1343,7 +1267,7 @@ static cl_object LC16destructuring_case(cl_object v1, cl_object v2) cl_object v4keyform; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -1351,7 +1275,7 @@ L3:; v3 = ecl_cdr(v3); v4keyform = v5; } - value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CASE",183)); + value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CASE",181)); return value0; } } @@ -1360,7 +1284,6 @@ L3:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC17destructuring_ccase(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1371,7 +1294,7 @@ static cl_object LC17destructuring_ccase(cl_object v1, cl_object v2) cl_object v4keyform; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -1379,7 +1302,7 @@ L3:; v3 = ecl_cdr(v3); v4keyform = v5; } - value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CCASE",185)); + value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CCASE",183)); return value0; } } @@ -1388,7 +1311,6 @@ L3:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object LC18destructuring_ecase(cl_object v1, cl_object v2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1399,7 +1321,7 @@ static cl_object LC18destructuring_ecase(cl_object v1, cl_object v2) cl_object v4keyform; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[45])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -1407,7 +1329,7 @@ L3:; v3 = ecl_cdr(v3); v4keyform = v5; } - value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("ECASE",323)); + value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("ECASE",321)); return value0; } } @@ -1417,7 +1339,7 @@ L3:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecl4KRmknIfrdJJM_OjFycC71(cl_object flag) +ECL_DLLEXPORT void _ecl4KRmknIfrdJJM_8gg2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1432,66 +1354,66 @@ ECL_DLLEXPORT void _ecl4KRmknIfrdJJM_OjFycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/macros.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/macros.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4KRmknIfrdJJM_OjFycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4KRmknIfrdJJM_8gg2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[43]); /* WITH-GENSYMS */ - ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[4]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[46]); /* WITH-UNIQUE-NAMES */ - ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[7]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LOCATION",1862), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[4], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[47]); /* ONCE-ONLY */ - ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[4], ECL_SYM("FUNCTION",398), VVtemp[11]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[50]); /* PARSE-BODY */ - ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[53]); /* PARSE-ORDINARY-LAMBDA-LIST */ - ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[11], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[22]) /* ANNOTATE */; - ecl_cmp_defun(VV[62]); /* EXPAND-DESTRUCTURING-CASE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[23], VVtemp[24]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[63]); /* DESTRUCTURING-CASE */ - ecl_function_dispatch(cl_env_copy,VV[44])(3, VV[40], ECL_SYM("FUNCTION",398), VVtemp[26]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[64]); /* DESTRUCTURING-CCASE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[29], VVtemp[30]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[65]); /* DESTRUCTURING-ECASE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[42]); /* WITH-GENSYMS */ + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[43]); /* WITH-UNIQUE-NAMES */ + si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[7]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[44]); /* ONCE-ONLY */ + si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[11]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; + ecl_cmp_defun(VV[46]); /* PARSE-BODY */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[15]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* PARSE-ORDINARY-LAMBDA-LIST */ + si_set_documentation(3, VV[10], ECL_SYM("FUNCTION",396), VVtemp[19]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[22]) /* ANNOTATE */; + ecl_cmp_defun(VV[58]); /* EXPAND-DESTRUCTURING-CASE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LOCATION",1777), VVtemp[23], VVtemp[24]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[59]); /* DESTRUCTURING-CASE */ + si_set_documentation(3, VV[39], ECL_SYM("FUNCTION",396), VVtemp[26]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[60]); /* DESTRUCTURING-CCASE */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[29], VVtemp[30]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[61]); /* DESTRUCTURING-ECASE */ { cl_object v1; v1 = VVtemp[31]; - goto L51; -L50:; + goto L54; +L53:; { cl_object v2name; v2name = ecl_car(v1); { cl_object v3; - v3 = (cl_env_copy->function=(ECL_SYM("DOCUMENTATION",314)->symbol.gfdef))->cfun.entry(2, VV[40], ECL_SYM("FUNCTION",398)) /* DOCUMENTATION */; - (cl_env_copy->function=ECL_CONS_CAR(VV[66]))->cfun.entry(3, v3, v2name, ECL_SYM("FUNCTION",398)) /* (SETF DOCUMENTATION) */; + v3 = (cl_env_copy->function=(ECL_SYM("DOCUMENTATION",312)->symbol.gfdef))->cfun.entry(2, VV[39], ECL_SYM("FUNCTION",396)) /* DOCUMENTATION */; + (cl_env_copy->function=ECL_CONS_CAR(VV[62]))->cfun.entry(3, v3, v2name, ECL_SYM("FUNCTION",396)) /* (SETF DOCUMENTATION) */; } } v1 = ecl_cdr(v1); -L51:; - if (Null(v1)) { goto L59; } - goto L50; -L59:; +L54:; + if (Null(v1)) { goto L62; } + goto L53; +L62:; } } diff --git a/lib/alexandria/numbers.cxx b/lib/alexandria/numbers.cxx index f7b9393..57fc2b1 100644 --- a/lib/alexandria/numbers.cxx +++ b/lib/alexandria/numbers.cxx @@ -1,25 +1,24 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/numbers.lisp */ +/* Source: lib/alexandria/numbers.lisp */ #include #include "lib/alexandria/numbers.eclh" /* function definition for CLAMP */ /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L1clamp(cl_object v1number, cl_object v2min, cl_object v3max) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - if (!(ecl_lower(v1number,v2min))) { goto L1; } + if (!(ecl_number_compare(v1number,v2min)<0)) { goto L1; } value0 = v2min; cl_env_copy->nvalues = 1; return value0; L1:; - if (!(ecl_greater(v1number,v3max))) { goto L3; } + if (!(ecl_number_compare(v1number,v3max)>0)) { goto L3; } value0 = v3max; cl_env_copy->nvalues = 1; return value0; @@ -35,7 +34,6 @@ static cl_object L4gaussian_random(cl_narg narg, ...) { cl_object T0, T1; volatile cl_object lex0[2]; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -62,9 +60,9 @@ static cl_object L4gaussian_random(cl_narg narg, ...) cl_object v2; /* G1 */ cl_object v3; /* G2 */ value0 = LC2gauss(); + v2 = value0; { const int v4 = cl_env_copy->nvalues; - v2 = value0; cl_object v5; v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1]; v3 = v5; @@ -83,7 +81,6 @@ static cl_object L4gaussian_random(cl_narg narg, ...) static cl_object LC3guard(volatile cl_object *lex0, cl_object v1x) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -111,9 +108,9 @@ L11:; cl_object v3; /* X1 */ cl_object v4; /* X2 */ value0 = LC2gauss(); + v3 = value0; { const int v5 = cl_env_copy->nvalues; - v3 = value0; cl_object v6; v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1]; v4 = v6; @@ -172,7 +169,6 @@ L1:; static cl_object LC2gauss() { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -195,7 +191,7 @@ L4:; T0 = ecl_expt(v1x1,ecl_make_fixnum(2)); T1 = ecl_expt(v2x2,ecl_make_fixnum(2)); v3w = ecl_plus(T0,T1); - if (!(ecl_lower(v3w,VV[3]))) { goto L11; } + if (!(ecl_number_compare(v3w,VV[3])<0)) { goto L11; } { cl_object v4v; T0 = cl_log(1, v3w); @@ -221,7 +217,6 @@ L11:; static cl_object L5iota(cl_narg narg, cl_object v1n, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -238,45 +233,39 @@ static cl_object L5iota(cl_narg narg, cl_object v1n, ...) v2start = ecl_make_fixnum(0); } else { v2start = keyvars[0]; - { - bool v4; - v4 = ecl_numberp(v2start); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v2start); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } } if (Null(keyvars[3])) { v3step = ecl_make_fixnum(1); } else { v3step = keyvars[1]; - { - bool v4; - v4 = ecl_numberp(v3step); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v3step); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } } } { cl_object v4; v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L9; } + if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L7; } v4 = v1n; - T0 = ecl_make_bool(ecl_greatereq(v4,ecl_make_fixnum(0))); - goto L6; -L9:; + T0 = ecl_make_bool(ecl_number_compare(v4,ecl_make_fixnum(0))>=0); + goto L4; +L7:; T0 = ECL_NIL; - goto L6; + goto L4; } -L6:; +L4:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[6],v1n); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + { + bool v4; + v4 = ecl_numberp(v2start); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("NUMBER",606),v2start); + } + { + bool v4; + v4 = ecl_numberp(v3step); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("NUMBER",606),v3step); + } { cl_object v4; cl_object v5i; @@ -299,8 +288,6 @@ L17:; cl_object v8; v8 = v7; if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v8; } v7 = ecl_list1(v5i); @@ -325,7 +312,6 @@ L18:; static cl_object L6map_iota(cl_narg narg, cl_object v1function, cl_object v2n, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -342,45 +328,39 @@ static cl_object L6map_iota(cl_narg narg, cl_object v1function, cl_object v2n, . v3start = ecl_make_fixnum(0); } else { v3start = keyvars[0]; - { - bool v5; - v5 = ecl_numberp(v3start); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v3start); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } } if (Null(keyvars[3])) { v4step = ecl_make_fixnum(1); } else { v4step = keyvars[1]; - { - bool v5; - v5 = ecl_numberp(v4step); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v4step); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } } } { cl_object v5; v5 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L9; } + if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L7; } v5 = v2n; - T0 = ecl_make_bool(ecl_greatereq(v5,ecl_make_fixnum(0))); - goto L6; -L9:; + T0 = ecl_make_bool(ecl_number_compare(v5,ecl_make_fixnum(0))>=0); + goto L4; +L7:; T0 = ECL_NIL; - goto L6; + goto L4; } -L6:; +L4:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[6],v2n); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + { + bool v5; + v5 = ecl_numberp(v3start); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(ECL_SYM("NUMBER",606),v3start); + } + { + bool v5; + v5 = ecl_numberp(v4step); + if (ecl_unlikely(!(v5))) + FEwrong_type_argument(ECL_SYM("NUMBER",606),v4step); + } { cl_object v5; cl_object v6i; @@ -414,7 +394,6 @@ L17:; static cl_object L7lerp(cl_object v1v, cl_object v2a, cl_object v3b) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -432,13 +411,12 @@ static cl_object L7lerp(cl_object v1v, cl_object v2a, cl_object v3b) static cl_object L8mean(cl_object v1sample) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - T0 = (ECL_SYM("+",16)->symbol.gfdef); + T0 = (ECL_SYM("+",14)->symbol.gfdef); T1 = cl_reduce(2, T0, v1sample); { cl_fixnum v2; @@ -454,7 +432,6 @@ static cl_object L8mean(cl_object v1sample) static cl_object L9median(cl_object v1sample) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -464,8 +441,8 @@ static cl_object L9median(cl_object v1sample) cl_object v2vector; cl_fixnum v3length; cl_object v4middle; - T0 = ecl_function_dispatch(cl_env_copy,VV[43])(2, ECL_SYM("VECTOR",900), v1sample) /* COPY-SEQUENCE */; - T1 = (ECL_SYM("<",74)->symbol.gfdef); + T0 = ecl_function_dispatch(cl_env_copy,VV[42])(2, ECL_SYM("VECTOR",898), v1sample) /* COPY-SEQUENCE */; + T1 = (ECL_SYM("<",72)->symbol.gfdef); v2vector = cl_sort(2, T0, T1); v3length = ecl_length(v2vector); v4middle = ecl_truncate2(ecl_make_fixnum(v3length),ecl_make_fixnum(2)); @@ -481,8 +458,6 @@ static cl_object L9median(cl_object v1sample) v7 = v4middle; if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = ecl_fixnum(v7); } value0 = ecl_aref_unsafe(T0,v6); @@ -502,8 +477,6 @@ L5:; v9 = v4middle; if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = ecl_fixnum(v9); } T0 = ecl_aref_unsafe(T1,v8); @@ -520,8 +493,6 @@ L5:; v9 = ecl_one_minus(v4middle); if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v8 = ecl_fixnum(v9); } T1 = ecl_aref_unsafe(T2,v8); @@ -539,7 +510,7 @@ L5:; static cl_object L11variance(cl_narg narg, cl_object v1sample, ...) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -560,7 +531,7 @@ static cl_object L11variance(cl_narg narg, cl_object v1sample, ...) } { cl_object env1 = env0; - T1 = (ECL_SYM("+",16)->symbol.gfdef); + T1 = (ECL_SYM("+",14)->symbol.gfdef); T2 = cl_reduce(2, T1, v1sample); { cl_fixnum v3; @@ -571,7 +542,7 @@ static cl_object L11variance(cl_narg narg, cl_object v1sample, ...) CLV0 = env1 = CONS(T0,env1); /* MEAN */ { cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC10__lambda32,env1,Cblock,2); + v3 = ecl_make_cclosure_va((cl_objectfn)LC10__g32,env1,Cblock); T0 = v3; } T1 = cl_reduce(4, T0, v1sample, VV[12], ecl_make_fixnum(0)); @@ -595,9 +566,9 @@ L5:; } } } -/* closure LAMBDA32 */ +/* closure G32 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10__lambda32(cl_narg narg, cl_object v1a, cl_object v2b, ...) +static cl_object LC10__g32(cl_narg narg, cl_object v1a, cl_object v2b, ...) { cl_object T0, T1; cl_object CLV0; @@ -624,7 +595,7 @@ static cl_object LC10__lambda32(cl_narg narg, cl_object v1a, cl_object v2b, ...) static cl_object L13standard_deviation(cl_narg narg, cl_object v1sample, ...) { cl_object T0, T1, T2, T3; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -648,17 +619,17 @@ static cl_object L13standard_deviation(cl_narg narg, cl_object v1sample, ...) cl_object v4; cl_object v5biased; v3 = cl_list(2, VV[14], v2biased); - v4 = ecl_function_dispatch(cl_env_copy,VV[46])(2, v3, VV[14]) /* SEARCH-KEYWORD */; - if (!((v4)==(ECL_SYM("MISSING-KEYWORD",2037)))) { goto L6; } + v4 = si_search_keyword(2, v3, VV[14]); + if (!((v4)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L6; } v5biased = ECL_T; goto L5; L6:; v5biased = v4; L5:; - ecl_function_dispatch(cl_env_copy,VV[47])(2, v3, VV[15]) /* CHECK-KEYWORD */; + si_check_keyword(2, v3, VV[15]); { cl_object env1 = env0; - T2 = (ECL_SYM("+",16)->symbol.gfdef); + T2 = (ECL_SYM("+",14)->symbol.gfdef); T3 = cl_reduce(2, T2, v1sample); { cl_fixnum v6; @@ -669,7 +640,7 @@ L5:; CLV0 = env1 = CONS(T1,env1); /* MEAN */ { cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC12__lambda40,env1,Cblock,2); + v6 = ecl_make_cclosure_va((cl_objectfn)LC12__g38,env1,Cblock); T1 = v6; } T2 = cl_reduce(4, T1, v1sample, VV[12], ecl_make_fixnum(0)); @@ -678,12 +649,12 @@ L5:; v6 = ecl_length(v1sample); { cl_fixnum v7; - if (Null(v5biased)) { goto L15; } + if (Null(v5biased)) { goto L13; } v7 = 0; - goto L14; -L15:; + goto L12; +L13:; v7 = 1; -L14:; +L12:; T3 = ecl_minus(ecl_make_fixnum(v6),ecl_make_fixnum(v7)); T0 = ecl_divide(T2,T3); } @@ -695,9 +666,9 @@ L14:; return value0; } } -/* closure LAMBDA40 */ +/* closure G38 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12__lambda40(cl_narg narg, cl_object v1a, cl_object v2b, ...) +static cl_object LC12__g38(cl_narg narg, cl_object v1a, cl_object v2b, ...) { cl_object T0, T1; cl_object CLV0; @@ -724,7 +695,6 @@ static cl_object LC12__lambda40(cl_narg narg, cl_object v1a, cl_object v2b, ...) static cl_object LC15maxf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -735,7 +705,7 @@ static cl_object LC15maxf(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[49])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -749,33 +719,31 @@ L3:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC14__lambda46,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC14__g44,ECL_NIL,Cblock,1); T0 = v12; } T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("MAX",553), v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("MAX",551), v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; T6 = CONS(VV[17],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L11:; @@ -807,19 +775,28 @@ L20:; goto L19; L26:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("MAX",553), v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L31; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, ECL_SYM("MAX",551), v10, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L30; +L31:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("MAX",551), v10, T3); +L30:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); T4 = CONS(VV[17],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -827,12 +804,11 @@ L26:; } } } -/* local function LAMBDA46 */ +/* local function G44 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14__lambda46(cl_object v1si__v) +static cl_object LC14__g44(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -848,7 +824,6 @@ static cl_object LC14__lambda46(cl_object v1si__v) static cl_object LC17minf(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -859,7 +834,7 @@ static cl_object LC17minf(cl_object v1, cl_object v2si__env) cl_object v4si___reference; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[49])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v5; @@ -873,33 +848,31 @@ L3:; cl_object v8; /* STORES */ cl_object v9; /* SETTER */ cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v6 = value0; + v7 = cl_env_copy->values[1]; + v8 = cl_env_copy->values[2]; + v9 = cl_env_copy->values[3]; + v10 = cl_env_copy->values[4]; { cl_object v11si__all_vars; { cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC16__lambda57,ECL_NIL,Cblock,1); + v12 = ecl_make_cfun((cl_objectfn_fixed)LC16__g55,ECL_NIL,Cblock,1); T0 = v12; } T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("MIN",559), v10, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("MIN",557), v10, T1); T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; T6 = CONS(VV[17],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v11si__all_vars, T7, v9); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); value0 = cl_subst(3, T2, T3, T8); return value0; L11:; @@ -931,19 +904,28 @@ L20:; goto L19; L26:; T0 = ecl_car(v8); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("MIN",559), v10, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L31; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(3, ECL_SYM("MIN",557), v10, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L30; +L31:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("MIN",557), v10, T3); +L30:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v11si__all_vars,v14si__let_list); + v14si__let_list = CONS(T2,T3); T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v6); T4 = CONS(VV[17],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v9); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); return value0; } } @@ -951,12 +933,11 @@ L26:; } } } -/* local function LAMBDA57 */ +/* local function G55 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC16__lambda57(cl_object v1si__v) +static cl_object LC16__g55(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -971,7 +952,6 @@ static cl_object LC16__lambda57(cl_object v1si__v) /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L21_multiply_range(cl_object v1i, cl_object v2j) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -991,7 +971,6 @@ L1:; static cl_object LC20multiply_range(cl_object v1j, cl_object v2k) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1015,8 +994,6 @@ L5:; L2:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[22],v1j); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { cl_fixnum v3; v3 = 0; @@ -1035,8 +1012,6 @@ L16:; L13:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[22],v2k); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { cl_object v3; cl_object v4f; @@ -1064,8 +1039,6 @@ L31:; L28:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[24],v6); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5m = ecl_fixnum(v6); } goto L40; @@ -1077,16 +1050,14 @@ L39:; cl_object v7; v7 = ecl_make_fixnum(0); v7 = v6; - T0 = ecl_make_bool(ecl_greatereq(v7,ecl_make_fixnum(0))); + T0 = ecl_make_bool(ecl_number_compare(v7,ecl_make_fixnum(0))>=0); goto L46; T0 = ECL_NIL; goto L46; } L46:; if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",887),v6); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",885),v6); v4f = v6; } { @@ -1110,8 +1081,6 @@ L59:; L56:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[24],v6); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v5m = ecl_fixnum(v6); } L40:; @@ -1129,7 +1098,6 @@ L66:; static cl_object LC19bisect_big(cl_object v1j, cl_object v2k) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1140,7 +1108,7 @@ static cl_object LC19bisect_big(cl_object v1j, cl_object v2k) v3 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v1j)||ECL_BIGNUMP(v1j))) { goto L5; } v3 = v1j; - T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); goto L2; L5:; T0 = ECL_NIL; @@ -1149,14 +1117,12 @@ L5:; L2:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[23],v1j); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { cl_object v3; v3 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v2k)||ECL_BIGNUMP(v2k))) { goto L13; } v3 = v2k; - T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); goto L10; L13:; T0 = ECL_NIL; @@ -1165,8 +1131,6 @@ L13:; L10:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[23],v2k); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; if (!(ecl_number_equalp(v1j,v2k))) { goto L17; } value0 = v1j; cl_env_copy->nvalues = 1; @@ -1177,7 +1141,7 @@ L17:; T0 = ecl_minus(v2k,v1j); T1 = ecl_truncate2(T0,ecl_make_fixnum(2)); v3middle = ecl_plus(v1j,T1); - if (!(ecl_lowereq(v3middle,ecl_make_fixnum(2305843009213693951)))) { goto L21; } + if (!(ecl_number_compare(v3middle,ecl_make_fixnum(2305843009213693951))<=0)) { goto L21; } T0 = LC18bisect(v1j, v3middle); goto L20; L21:; @@ -1196,7 +1160,6 @@ L20:; static cl_object LC18bisect(cl_object v1j, cl_object v2k) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1220,8 +1183,6 @@ L5:; L2:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[22],v1j); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; { cl_fixnum v3; v3 = 0; @@ -1240,10 +1201,8 @@ L16:; L13:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[22],v2k); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = ecl_minus(v2k,v1j); - if (!(ecl_lower(T0,ecl_make_fixnum(8)))) { goto L23; } + if (!(ecl_number_compare(T0,ecl_make_fixnum(8))<0)) { goto L23; } value0 = LC20multiply_range(v1j, v2k); return value0; L23:; @@ -1265,13 +1224,12 @@ L23:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L22_factorial(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - if (!(ecl_lower(v1n,ecl_make_fixnum(2)))) { goto L1; } + if (!(ecl_number_compare(v1n,ecl_make_fixnum(2))<0)) { goto L1; } value0 = ecl_make_fixnum(1); cl_env_copy->nvalues = 1; return value0; @@ -1284,7 +1242,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L23factorial(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1298,7 +1255,7 @@ static cl_object L23factorial(cl_object v1n) v3 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))) { goto L7; } v3 = v2; - if (ecl_greatereq(v3,ecl_make_fixnum(0))) { goto L3; } + if (ecl_number_compare(v3,ecl_make_fixnum(0))>=0) { goto L3; } goto L4; L7:; goto L4; @@ -1316,7 +1273,6 @@ L3:; static cl_object L24binomial_coefficient(cl_object v1n, cl_object v2k) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1330,7 +1286,7 @@ static cl_object L24binomial_coefficient(cl_object v1n, cl_object v2k) v4 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L7; } v4 = v3; - if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L3; } + if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L3; } goto L4; L7:; goto L4; @@ -1347,7 +1303,7 @@ L3:; v4 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L18; } v4 = v3; - if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L14; } + if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L14; } goto L15; L18:; goto L15; @@ -1360,7 +1316,7 @@ L14:; L24:; si_assert_failure(1, VV[30]); L25:; - if (ecl_greatereq(v1n,v2k)) { goto L28; } + if (ecl_number_compare(v1n,v2k)>=0) { goto L28; } goto L24; L28:; if (ecl_zerop(v2k)) { goto L32; } @@ -1375,7 +1331,7 @@ L30:; { cl_object v3n_k; v3n_k = ecl_minus(v1n,v2k); - if (!(ecl_lower(v2k,v3n_k))) { goto L35; } + if (!(ecl_number_compare(v2k,v3n_k)<0)) { goto L35; } { cl_object v4; v4 = v3n_k; @@ -1406,7 +1362,6 @@ L43:; static cl_object L25subfactorial(cl_object v1n) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1420,7 +1375,7 @@ static cl_object L25subfactorial(cl_object v1n) v3 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))) { goto L7; } v3 = v2; - if (ecl_greatereq(v3,ecl_make_fixnum(0))) { goto L3; } + if (ecl_number_compare(v3,ecl_make_fixnum(0))>=0) { goto L3; } goto L4; L7:; goto L4; @@ -1470,7 +1425,6 @@ L25:; static cl_object L26count_permutations(cl_narg narg, cl_object v1n, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1497,7 +1451,7 @@ static cl_object L26count_permutations(cl_narg narg, cl_object v1n, ...) v4 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L8; } v4 = v3; - if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L4; } + if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L4; } goto L5; L8:; goto L5; @@ -1514,7 +1468,7 @@ L4:; v4 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L19; } v4 = v3; - if (ecl_greatereq(v4,ecl_make_fixnum(0))) { goto L15; } + if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L15; } goto L16; L19:; goto L16; @@ -1527,7 +1481,7 @@ L15:; L25:; si_assert_failure(1, VV[30]); L26:; - if (ecl_greatereq(v1n,v2k)) { goto L29; } + if (ecl_number_compare(v1n,v2k)>=0) { goto L29; } goto L25; L29:; T0 = ecl_minus(v1n,v2k); @@ -1541,7 +1495,7 @@ L29:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclGV3xc4hVq7NJM_aLIycC71(cl_object flag) +ECL_DLLEXPORT void _eclGV3xc4hVq7NJM_NFi2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1556,101 +1510,92 @@ ECL_DLLEXPORT void _eclGV3xc4hVq7NJM_aLIycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/numbers.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/numbers.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclGV3xc4hVq7NJM_aLIycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclGV3xc4hVq7NJM_NFi2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; ecl_cmp_defun(VV[33]); /* CLAMP */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[6]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[7], VVtemp[8]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; - ecl_cmp_defun(VV[35]); /* GAUSSIAN-RANDOM */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[1], ECL_SYM("FUNCTION",398), VVtemp[10]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[11]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[36]); /* IOTA */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[5], ECL_SYM("INLINE",436), VVtemp[16]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[17]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[20]) /* ANNOTATE */; - ecl_cmp_defun(VV[39]); /* MAP-IOTA */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[7], ECL_SYM("FUNCTION",398), VVtemp[21]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[7], ECL_SYM("INLINE",436), VVtemp[22]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[23]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defun(VV[40]); /* LERP */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[27]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[8], ECL_SYM("INLINE",436), VVtemp[28]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[29]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[30], VVtemp[31]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; - ecl_cmp_defun(VV[41]); /* MEAN */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[9], ECL_SYM("FUNCTION",398), VVtemp[33]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[9], ECL_SYM("INLINE",436), VVtemp[34]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[35]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[36], VVtemp[37]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[32]) /* ANNOTATE */; - ecl_cmp_defun(VV[42]); /* MEDIAN */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[10], ECL_SYM("FUNCTION",398), VVtemp[38]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[10], ECL_SYM("INLINE",436), VVtemp[39]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[40]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[11], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* VARIANCE */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[11], ECL_SYM("FUNCTION",398), VVtemp[44]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[11], ECL_SYM("INLINE",436), VVtemp[45]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[46]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[47], VVtemp[48]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[45]); /* STANDARD-DEVIATION */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[13], ECL_SYM("FUNCTION",398), VVtemp[49]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[13], ECL_SYM("INLINE",436), VVtemp[50]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[51], VVtemp[52]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[53]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[48]); /* MAXF */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[16], ECL_SYM("FUNCTION",398), VVtemp[54]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LOCATION",1862), VVtemp[55], VVtemp[56]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[18], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[53]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[50]); /* MINF */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[18], ECL_SYM("FUNCTION",398), VVtemp[57]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[34]); /* GAUSSIAN-RANDOM */ + si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[9]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[10]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[13]) /* ANNOTATE */; + ecl_cmp_defun(VV[35]); /* IOTA */ + si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[14]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[15]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[16], VVtemp[17]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[18]) /* ANNOTATE */; + ecl_cmp_defun(VV[38]); /* MAP-IOTA */ + si_set_documentation(3, VV[7], ECL_SYM("FUNCTION",396), VVtemp[19]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[20]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; + ecl_cmp_defun(VV[39]); /* LERP */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[24]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[25]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; + ecl_cmp_defun(VV[40]); /* MEAN */ + si_set_documentation(3, VV[9], ECL_SYM("FUNCTION",396), VVtemp[29]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[30]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; + ecl_cmp_defun(VV[41]); /* MEDIAN */ + si_set_documentation(3, VV[10], ECL_SYM("FUNCTION",396), VVtemp[33]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[34]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LOCATION",1777), VVtemp[35], VVtemp[36]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[37]) /* ANNOTATE */; + ecl_cmp_defun(VV[43]); /* VARIANCE */ + si_set_documentation(3, VV[11], ECL_SYM("FUNCTION",396), VVtemp[38]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[39]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[40], VVtemp[41]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[37]) /* ANNOTATE */; + ecl_cmp_defun(VV[44]); /* STANDARD-DEVIATION */ + si_set_documentation(3, VV[13], ECL_SYM("FUNCTION",396), VVtemp[42]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[43], VVtemp[44]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[45]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[45]); /* MAXF */ + si_set_documentation(3, VV[16], ECL_SYM("FUNCTION",396), VVtemp[46]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LOCATION",1777), VVtemp[47], VVtemp[48]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[45]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[46]); /* MINF */ + si_set_documentation(3, VV[18], ECL_SYM("FUNCTION",396), VVtemp[49]); si_Xmake_constant(VV[19], ecl_make_fixnum(8)); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[19], ECL_SYM("LOCATION",1862), VVtemp[58], VVtemp[59]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LOCATION",1777), VVtemp[50], VVtemp[51]) /* ANNOTATE */; si_Xmake_constant(VV[20], ecl_make_fixnum(13)); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LOCATION",1862), VVtemp[62], VVtemp[63]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[21], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[64]) /* ANNOTATE */; - ecl_cmp_defun(VV[51]); /* %MULTIPLY-RANGE */ - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[65]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[66], VVtemp[67]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[68]) /* ANNOTATE */; - ecl_cmp_defun(VV[52]); /* %FACTORIAL */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[69], VVtemp[70]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[68]) /* ANNOTATE */; - ecl_cmp_defun(VV[53]); /* FACTORIAL */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[26], ECL_SYM("FUNCTION",398), VVtemp[71]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[26], ECL_SYM("INLINE",436), VVtemp[72]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[73], VVtemp[74]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[75]) /* ANNOTATE */; - ecl_cmp_defun(VV[54]); /* BINOMIAL-COEFFICIENT */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[76]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LOCATION",1862), VVtemp[77], VVtemp[78]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[68]) /* ANNOTATE */; - ecl_cmp_defun(VV[55]); /* SUBFACTORIAL */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[31], ECL_SYM("FUNCTION",398), VVtemp[79]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LOCATION",1862), VVtemp[80], VVtemp[81]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[82]) /* ANNOTATE */; - ecl_cmp_defun(VV[56]); /* COUNT-PERMUTATIONS */ - ecl_function_dispatch(cl_env_copy,VV[34])(3, VV[32], ECL_SYM("FUNCTION",398), VVtemp[83]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[53]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[54], VVtemp[55]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[56]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* %MULTIPLY-RANGE */ + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[57]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[58], VVtemp[59]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[60]) /* ANNOTATE */; + ecl_cmp_defun(VV[48]); /* %FACTORIAL */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[61], VVtemp[62]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[60]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* FACTORIAL */ + si_set_documentation(3, VV[26], ECL_SYM("FUNCTION",396), VVtemp[63]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[64], VVtemp[65]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[66]) /* ANNOTATE */; + ecl_cmp_defun(VV[50]); /* BINOMIAL-COEFFICIENT */ + si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[67]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LOCATION",1777), VVtemp[68], VVtemp[69]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[60]) /* ANNOTATE */; + ecl_cmp_defun(VV[51]); /* SUBFACTORIAL */ + si_set_documentation(3, VV[31], ECL_SYM("FUNCTION",396), VVtemp[70]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LOCATION",1777), VVtemp[71], VVtemp[72]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[73]) /* ANNOTATE */; + ecl_cmp_defun(VV[52]); /* COUNT-PERMUTATIONS */ + si_set_documentation(3, VV[32], ECL_SYM("FUNCTION",396), VVtemp[74]); } diff --git a/lib/alexandria/package.cxx b/lib/alexandria/package.cxx index 095f252..9af397c 100644 --- a/lib/alexandria/package.cxx +++ b/lib/alexandria/package.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/package.lisp */ +/* Source: lib/alexandria/package.lisp */ #include #include "lib/alexandria/package.eclh" @@ -9,7 +9,7 @@ #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclFO5a0GhkppGJM_GREycC71(cl_object flag) +ECL_DLLEXPORT void _eclFO5a0GhkppGJM_ftf2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -24,13 +24,13 @@ ECL_DLLEXPORT void _eclFO5a0GhkppGJM_GREycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/package.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/package.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclFO5a0GhkppGJM_GREycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclFO5a0GhkppGJM_ftf2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[0])(12, VVtemp[0], VVtemp[1], ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; + ecl_function_dispatch(cl_env_copy,VV[0])(10, VVtemp[0], VVtemp[1], ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; } diff --git a/lib/alexandria/sequences.cxx b/lib/alexandria/sequences.cxx index 88b53e9..d486aa4 100644 --- a/lib/alexandria/sequences.cxx +++ b/lib/alexandria/sequences.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/sequences.lisp */ +/* Source: lib/alexandria/sequences.lisp */ #include #include "lib/alexandria/sequences.eclh" /* function definition for SEQUENCE-OF-LENGTH-P */ @@ -9,7 +9,6 @@ static cl_object L1sequence_of_length_p(cl_object v1sequence, cl_object v2length) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -33,8 +32,6 @@ L5:; L2:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[1],v2length); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; if (!(v1sequence==ECL_NIL)) { goto L12; } value0 = ecl_make_bool((ecl_to_fixnum(v2length))==0); cl_env_copy->nvalues = 1; @@ -96,7 +93,6 @@ L25:; static cl_object L2rotate_tail_to_head(cl_object v1sequence, cl_object v2n) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -107,7 +103,7 @@ static cl_object L2rotate_tail_to_head(cl_object v1sequence, cl_object v2n) v3 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L5; } v3 = v2n; - T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); goto L2; L5:; T0 = ECL_NIL; @@ -116,12 +112,10 @@ L5:; L2:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[4],v2n); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; if (!(ECL_LISTP(v1sequence))) { goto L9; } { cl_object v3m; - T0 = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; + T0 = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; v3m = (ecl_floor2(v2n,T0),cl_env_copy->values[1]); T0 = ecl_cdr(v1sequence); if (!(T0==ECL_NIL)) { goto L12; } @@ -142,8 +136,6 @@ L12:; cl_object v7; v7 = v4tail; if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v7; } (ECL_CONS_CDR(T0)=v6,T0); @@ -162,7 +154,7 @@ L9:; v7m = (ecl_floor2(v2n,ecl_make_fixnum(v6len)),cl_env_copy->values[1]); T0 = ecl_minus(ecl_make_fixnum(v6len),v7m); v8tail = cl_subseq(2, v1sequence, T0); - cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1345), v7m, ECL_SYM("START2",1346), ecl_make_fixnum(0)); + cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1316), v7m, ECL_SYM("START2",1317), ecl_make_fixnum(0)); cl_replace(2, v1sequence, v8tail); value0 = v1sequence; cl_env_copy->nvalues = 1; @@ -175,7 +167,6 @@ L9:; static cl_object L3rotate_head_to_tail(cl_object v1sequence, cl_object v2n) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -186,7 +177,7 @@ static cl_object L3rotate_head_to_tail(cl_object v1sequence, cl_object v2n) v3 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L5; } v3 = v2n; - T0 = ecl_make_bool(ecl_greatereq(v3,ecl_make_fixnum(1))); + T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); goto L2; L5:; T0 = ECL_NIL; @@ -195,13 +186,11 @@ L5:; L2:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[4],v2n); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; if (!(ECL_LISTP(v1sequence))) { goto L9; } { cl_object v3m; T0 = ecl_one_minus(v2n); - T1 = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; + T1 = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; v3m = (ecl_floor2(T0,T1),cl_env_copy->values[1]); T0 = ecl_cdr(v1sequence); if (!(T0==ECL_NIL)) { goto L12; } @@ -221,8 +210,6 @@ L12:; cl_object v7; v7 = v4headtail; if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v7; } (ECL_CONS_CDR(T0)=v6,T0); @@ -240,9 +227,9 @@ L9:; v6len = ecl_length(v1sequence); v7m = (ecl_floor2(v2n,ecl_make_fixnum(v6len)),cl_env_copy->values[1]); v8head = cl_subseq(3, v1sequence, ecl_make_fixnum(0), v7m); - cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1345), ecl_make_fixnum(0), ECL_SYM("START2",1346), v7m); + cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1316), ecl_make_fixnum(0), ECL_SYM("START2",1317), v7m); T0 = ecl_minus(ecl_make_fixnum(v6len),v7m); - cl_replace(4, v1sequence, v8head, ECL_SYM("START1",1345), T0); + cl_replace(4, v1sequence, v8head, ECL_SYM("START1",1316), T0); value0 = v1sequence; cl_env_copy->nvalues = 1; return value0; @@ -254,7 +241,6 @@ L9:; static cl_object L4rotate(cl_narg narg, cl_object v1sequence, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -292,7 +278,6 @@ L4:; static cl_object L5shuffle(cl_narg narg, cl_object v1sequence, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -309,35 +294,43 @@ static cl_object L5shuffle(cl_narg narg, cl_object v1sequence, ...) v2start = ecl_make_fixnum(0); } else { v2start = keyvars[0]; - { - bool v4; - v4 = ECL_FIXNUMP(v2start); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("FIXNUM",374),v2start); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } } v3end = keyvars[1]; } - if (!(ECL_LISTP(v1sequence))) { goto L4; } + { + bool v4; + v4 = ECL_FIXNUMP(v2start); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("FIXNUM",372),v2start); + } + value0 = ecl_make_bool(ECL_FIXNUMP(v3end)); + if ((value0)!=ECL_NIL) { goto L6; } + T0 = ecl_make_bool(v3end==ECL_NIL); + goto L4; +L6:; + T0 = value0; + goto L4; +L4:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[8],v3end); + if (!(ECL_LISTP(v1sequence))) { goto L9; } { cl_object v4end; cl_object v5n; value0 = v3end; - if ((value0)!=ECL_NIL) { goto L8; } - v4end = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; - goto L6; -L8:; + if ((value0)!=ECL_NIL) { goto L13; } + v4end = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; + goto L11; +L13:; v4end = value0; - goto L6; -L6:; + goto L11; +L11:; v5n = ecl_minus(v4end,v2start); { cl_object v6tail; v6tail = ecl_nthcdr(ecl_to_fixnum(v2start),v1sequence); - goto L14; -L13:; + goto L19; +L18:; { cl_object v7; T0 = cl_random(1, v5n); @@ -352,8 +345,6 @@ L13:; cl_object v10; v10 = v6tail; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v10; } (ECL_CONS_CAR(T0)=v8,T0); @@ -361,8 +352,6 @@ L13:; cl_object v10; v10 = v7; if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v10; } (ECL_CONS_CAR(T0)=v9,T0); @@ -371,25 +360,25 @@ L13:; } v5n = ecl_minus(v5n,ecl_make_fixnum(1)); v6tail = ecl_cdr(v6tail); -L14:; - if (ecl_zerop(v5n)) { goto L34; } - goto L13; -L34:; - goto L3; +L19:; + if (ecl_zerop(v5n)) { goto L39; } + goto L18; +L39:; + goto L8; } } -L4:; - if (!(ECL_VECTORP(v1sequence))) { goto L36; } +L9:; + if (!(ECL_VECTORP(v1sequence))) { goto L41; } { cl_object v7end; value0 = v3end; - if ((value0)!=ECL_NIL) { goto L40; } + if ((value0)!=ECL_NIL) { goto L45; } v7end = ecl_make_fixnum(ecl_length(v1sequence)); - goto L38; -L40:; + goto L43; +L45:; v7end = value0; - goto L38; -L38:; + goto L43; +L43:; { cl_object v8i; cl_object v9; @@ -397,20 +386,15 @@ L38:; { cl_object v10; v10 = v7end; - { - bool v11; - v11 = ecl_numberp(v10); - if (ecl_unlikely(!(v11))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + T0 = cl_realp(v10); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v10); v9 = v10; } -L46:; - if (!(ecl_greatereq(v8i,v9))) { goto L48; } - goto L47; -L48:; +L51:; + if (!(ecl_number_compare(v8i,v9)>=0)) { goto L53; } + goto L52; +L53:; { cl_object v10; T0 = ecl_minus(v7end,v8i); @@ -429,8 +413,6 @@ L48:; v14 = v10; if (ecl_unlikely((ecl_fixnum(v14))>=(v12)->vector.dim)) FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v14)),(v12)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v13 = ecl_fixnum(v14); } v11 = ecl_aref_unsafe(T0,v13); @@ -449,8 +431,6 @@ L48:; v15 = v8i; if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v14 = ecl_fixnum(v15); } v12 = ecl_aref_unsafe(T0,v14); @@ -467,8 +447,6 @@ L48:; v15 = v8i; if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v14 = ecl_fixnum(v15); } ecl_aset_unsafe(T0,v14,v11); @@ -485,8 +463,6 @@ L48:; v15 = v10; if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v14 = ecl_fixnum(v15); } ecl_aset_unsafe(T0,v14,v12); @@ -496,37 +472,44 @@ L48:; } } v8i = ecl_one_plus(v8i); - goto L46; -L47:; - goto L3; + goto L51; +L52:; + goto L8; } } -L36:; - if (ECL_CONSP(v1sequence)) { goto L81; } - if (v1sequence==ECL_NIL) { goto L81; } - if (!(ECL_VECTORP(v1sequence))) { goto L79; } - goto L80; -L81:; -L80:; +L41:; + if (ECL_CONSP(v1sequence)) { goto L86; } + if (v1sequence==ECL_NIL) { goto L86; } + if (!(ECL_VECTORP(v1sequence))) { goto L84; } + goto L85; +L86:; +L85:; { cl_object v10end; value0 = v3end; - if ((value0)!=ECL_NIL) { goto L86; } + if ((value0)!=ECL_NIL) { goto L91; } v10end = ecl_make_fixnum(ecl_length(v1sequence)); - goto L84; -L86:; + goto L89; +L91:; v10end = value0; - goto L84; -L84:; + goto L89; +L89:; { cl_object v11; cl_object v12i; v11 = ecl_minus(v10end,ecl_make_fixnum(1)); - v12i = v11; -L90:; - if (!(ecl_lower(v12i,v2start))) { goto L92; } - goto L91; -L92:; + { + cl_object v13; + v13 = v11; + T0 = cl_realp(v13); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v13); + v12i = v13; + } +L97:; + if (!(ecl_number_compare(v12i,v2start)<0)) { goto L99; } + goto L98; +L99:; { cl_object v13; T0 = ecl_minus(v10end,v12i); @@ -534,24 +517,24 @@ L92:; v13 = ecl_plus(v12i,T1); { cl_object v14; - v14 = ecl_elt(v1sequence,ecl_to_size(v13)); + v14 = ecl_elt(v1sequence,ecl_fixnum(v13)); { cl_object v15; - v15 = ecl_elt(v1sequence,ecl_to_size(v12i)); + v15 = ecl_elt(v1sequence,ecl_fixnum(v12i)); ecl_elt_set(v1sequence,ecl_to_size(v12i),v14); ecl_elt_set(v1sequence,ecl_to_size(v13),v15); } } } v12i = ecl_one_minus(v12i); - goto L90; -L91:; - goto L3; + goto L97; +L98:; + goto L8; } } -L79:; - si_etypecase_error(v1sequence, VV[8]); -L3:; +L84:; + si_etypecase_error(v1sequence, VV[9]); +L8:; value0 = v1sequence; cl_env_copy->nvalues = 1; return value0; @@ -562,7 +545,6 @@ L3:; static cl_object L6random_elt(cl_narg narg, cl_object v1sequence, ...) { cl_object T0, T1, T2, T3, T4, T5, T6, T7; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -579,66 +561,72 @@ static cl_object L6random_elt(cl_narg narg, cl_object v1sequence, ...) v2start = ecl_make_fixnum(0); } else { v2start = keyvars[0]; - { - bool v4; - v4 = ECL_FIXNUMP(v2start); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("FIXNUM",374),v2start); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } } v3end = keyvars[1]; } if (ecl_unlikely(!(ECL_LISTP(v1sequence) || ECL_VECTORP(v1sequence)))) FEtype_error_sequence(v1sequence); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + { + bool v4; + v4 = ECL_FIXNUMP(v2start); + if (ecl_unlikely(!(v4))) + FEwrong_type_argument(ECL_SYM("FIXNUM",372),v2start); + } + value0 = ecl_make_bool(ECL_FIXNUMP(v3end)); + if ((value0)!=ECL_NIL) { goto L7; } + T0 = ecl_make_bool(v3end==ECL_NIL); + goto L5; +L7:; + T0 = value0; + goto L5; +L5:; + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(VV[8],v3end); { cl_object v4size; cl_object v5end2; - if (!(ECL_LISTP(v1sequence))) { goto L5; } - v4size = ecl_function_dispatch(cl_env_copy,VV[50])(1, v1sequence) /* PROPER-LIST-LENGTH */; - goto L4; -L5:; + if (!(ECL_LISTP(v1sequence))) { goto L10; } + v4size = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; + goto L9; +L10:; v4size = ecl_make_fixnum(ecl_length(v1sequence)); -L4:; +L9:; value0 = v3end; - if ((value0)!=ECL_NIL) { goto L9; } + if ((value0)!=ECL_NIL) { goto L14; } v5end2 = v4size; - goto L7; -L9:; + goto L12; +L14:; v5end2 = value0; - goto L7; -L7:; - if (!(ecl_zerop(v4size))) { goto L11; } - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[11]); + goto L12; +L12:; + if (!(ecl_zerop(v4size))) { goto L16; } + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[11]); return value0; -L11:; - if (!((0)<=(ecl_to_fixnum(v2start)))) { goto L16; } - if (!(ecl_lower(v2start,v5end2))) { goto L16; } - if (ecl_lowereq(v5end2,v4size)) { goto L13; } - goto L14; L16:; - goto L14; -L14:; + if (!((0)<=(ecl_to_fixnum(v2start)))) { goto L21; } + if (!(ecl_number_compare(v2start,v5end2)<0)) { goto L21; } + if (ecl_number_compare(v5end2,v4size)<=0) { goto L18; } + goto L19; +L21:; + goto L19; +L19:; T0 = CONS(v2start,v3end); T1 = ecl_list1(v5end2); - T2 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), T1); + T2 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), T1); T3 = ecl_list1(v2start); - T4 = cl_list(3, ECL_SYM("INTEGER",439), T3, v4size); - T5 = cl_list(3, ECL_SYM("OR",616), ECL_SYM("NULL",607), T4); - T6 = cl_list(3, ECL_SYM("CONS",253), T2, T5); + T4 = cl_list(3, ECL_SYM("INTEGER",437), T3, v4size); + T5 = cl_list(3, ECL_SYM("OR",614), ECL_SYM("NULL",605), T4); + T6 = cl_list(3, ECL_SYM("CONS",251), T2, T5); T7 = cl_list(3, v2start, v3end, v4size); - value0 = cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",775), ECL_SYM("DATUM",1242), T0, ECL_SYM("EXPECTED-TYPE",1260), T6, ECL_SYM("FORMAT-CONTROL",1269), VV[12], ECL_SYM("FORMAT-ARGUMENTS",1268), T7); + value0 = cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",773), ECL_SYM("DATUM",1217), T0, ECL_SYM("EXPECTED-TYPE",1235), T6, ECL_SYM("FORMAT-CONTROL",1243), VV[12], ECL_SYM("FORMAT-ARGUMENTS",1242), T7); return value0; -L13:; +L18:; { cl_object v6index; T0 = ecl_minus(v5end2,v2start); T1 = cl_random(1, T0); v6index = ecl_plus(v2start,T1); - value0 = ecl_elt(v1sequence,ecl_to_size(v6index)); + value0 = ecl_elt(v1sequence,ecl_fixnum(v6index)); cl_env_copy->nvalues = 1; return value0; } @@ -650,7 +638,6 @@ L13:; static cl_object L7remove_swapped_arguments(cl_narg narg, cl_object v1sequence, cl_object v2item, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -660,7 +647,7 @@ static cl_object L7remove_swapped_arguments(cl_narg narg, cl_object v1sequence, ecl_va_list args; ecl_va_start(args,v2item,narg,2); v3keyword_arguments = cl_grab_rest_args(args); ecl_va_end(args); - T0 = (ECL_SYM("REMOVE",712)->symbol.gfdef); + T0 = (ECL_SYM("REMOVE",710)->symbol.gfdef); value0 = cl_apply(4, T0, v2item, v1sequence, v3keyword_arguments); return value0; } @@ -670,7 +657,6 @@ static cl_object L7remove_swapped_arguments(cl_narg narg, cl_object v1sequence, static cl_object LC9removef(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -682,7 +668,7 @@ static cl_object LC9removef(cl_object v1, cl_object v2si__env) cl_object v5item; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -691,7 +677,7 @@ L3:; v4si___reference = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -705,33 +691,31 @@ L9:; cl_object v9; /* STORES */ cl_object v10; /* SETTER */ cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; { cl_object v12si__all_vars; { cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC8__lambda59,ECL_NIL,Cblock,1); + v13 = ecl_make_cfun((cl_objectfn_fixed)LC8__g62,ECL_NIL,Cblock,1); T0 = v13; } T1 = CONS(v5item,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; T2 = cl_listX(3, VV[13], v11, T1); T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; T6 = CONS(VV[15],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); value0 = cl_subst(3, T2, T3, T8); return value0; L17:; @@ -763,19 +747,28 @@ L26:; goto L25; L32:; T0 = ecl_car(v9); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, VV[13], v11, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L37; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(4, VV[13], v11, v5item, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L36; +L37:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, VV[13], v11, T3); +L36:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T2,T3); T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v7); T4 = CONS(VV[15],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); return value0; } } @@ -783,12 +776,11 @@ L32:; } } } -/* local function LAMBDA59 */ +/* local function G62 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__lambda59(cl_object v1si__v) +static cl_object LC8__g62(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -804,7 +796,6 @@ static cl_object LC8__lambda59(cl_object v1si__v) static cl_object L10delete_swapped_arguments(cl_narg narg, cl_object v1sequence, cl_object v2item, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -814,7 +805,7 @@ static cl_object L10delete_swapped_arguments(cl_narg narg, cl_object v1sequence, ecl_va_list args; ecl_va_start(args,v2item,narg,2); v3keyword_arguments = cl_grab_rest_args(args); ecl_va_end(args); - T0 = (ECL_SYM("DELETE",293)->symbol.gfdef); + T0 = (ECL_SYM("DELETE",291)->symbol.gfdef); value0 = cl_apply(4, T0, v2item, v1sequence, v3keyword_arguments); return value0; } @@ -824,7 +815,6 @@ static cl_object L10delete_swapped_arguments(cl_narg narg, cl_object v1sequence, static cl_object LC12deletef(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -836,7 +826,7 @@ static cl_object LC12deletef(cl_object v1, cl_object v2si__env) cl_object v5item; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -845,7 +835,7 @@ L3:; v4si___reference = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -859,33 +849,31 @@ L9:; cl_object v9; /* STORES */ cl_object v10; /* SETTER */ cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; { cl_object v12si__all_vars; { cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC11__lambda71,ECL_NIL,Cblock,1); + v13 = ecl_make_cfun((cl_objectfn_fixed)LC11__g74,ECL_NIL,Cblock,1); T0 = v13; } T1 = CONS(v5item,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; T2 = cl_listX(3, VV[16], v11, T1); T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; T6 = CONS(VV[15],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); value0 = cl_subst(3, T2, T3, T8); return value0; L17:; @@ -917,19 +905,28 @@ L26:; goto L25; L32:; T0 = ecl_car(v9); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, VV[16], v11, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L37; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(4, VV[16], v11, v5item, v3); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L36; +L37:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, VV[16], v11, T3); +L36:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T2,T3); T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v7); T4 = CONS(VV[15],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); return value0; } } @@ -937,12 +934,11 @@ L32:; } } } -/* local function LAMBDA71 */ +/* local function G74 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__lambda71(cl_object v1si__v) +static cl_object LC11__g74(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -953,18 +949,17 @@ static cl_object LC11__lambda71(cl_object v1si__v) return value0; } } -/* local function LAMBDA79 */ +/* local function PROPER-SEQUENCE */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13__lambda79(cl_object v1) +static cl_object LC13proper_sequence(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[62])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; value0 = VV[19]; cl_env_copy->nvalues = 1; @@ -975,7 +970,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L14emptyp(cl_object v1sequence) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1009,7 +1003,6 @@ L3:; static cl_object L15length_(cl_narg narg, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1030,14 +1023,7 @@ L1:; { cl_object v5; v5 = v4; - { - bool v6; - v6 = ECL_LISTP(v5); - if (ecl_unlikely(!(v6))) - FEwrong_type_argument(VV[24],v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5); } if (Null(v4)) { goto L9; } { @@ -1075,8 +1061,6 @@ L23:; L20:; if (ecl_unlikely(!((T0)!=ECL_NIL))) FEwrong_type_argument(VV[1],v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v3current = ecl_fixnum(v4); } { @@ -1093,56 +1077,7 @@ L32:; cl_env_copy->nvalues = 1; return value0; L38:; - { - cl_fixnum v6length; - v6length = v3current; - if (!(v5el==ECL_NIL)) { goto L43; } - if ((v6length)==0) { goto L37; } - goto L41; -L43:; - if (!(ECL_CONSP(v5el))) { goto L45; } - { - cl_object v7n; - v7n = ecl_make_integer((v6length)-1); - if (ecl_minusp(v7n)) { goto L48; } - { - cl_object v8tail; - v8tail = ecl_nthcdr(ecl_to_size(v7n),v5el); - if (Null(v8tail)) { goto L52; } - T0 = ecl_cdr(v8tail); - if (T0==ECL_NIL) { goto L37; } - goto L41; -L52:; - goto L41; - } -L48:; - goto L41; - } -L45:; - if (!(ECL_VECTORP(v5el))) { goto L54; } - { - cl_fixnum v9; - v9 = ecl_length(v5el); - if ((v6length)==(v9)) { goto L37; } - goto L41; - } -L54:; - if (ECL_CONSP(v5el)) { goto L58; } - if (v5el==ECL_NIL) { goto L58; } - if (!(ECL_VECTORP(v5el))) { goto L56; } - goto L57; -L58:; -L57:; - { - cl_fixnum v10; - v10 = ecl_length(v5el); - if ((v6length)==(v10)) { goto L37; } - goto L41; - } -L56:; - if ((si_etypecase_error(v5el, VV[2]))!=ECL_NIL) { goto L37; } - } -L41:; + if ((L1sequence_of_length_p(v5el, ecl_make_fixnum(v3current)))!=ECL_NIL) { goto L37; } value0 = ECL_NIL; cl_env_copy->nvalues = 1; return value0; @@ -1150,9 +1085,9 @@ L37:; } v4 = ecl_cdr(v4); L33:; - if (Null(v4)) { goto L63; } + if (Null(v4)) { goto L44; } goto L32; -L63:; +L44:; } } value0 = ECL_T; @@ -1160,12 +1095,11 @@ L63:; return value0; } } -/* local function LAMBDA104 */ +/* local function LENGTH= */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC16__lambda104(cl_object v1, cl_object v2) +static cl_object LC16length_(cl_object v1, cl_object v2) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1175,16 +1109,16 @@ static cl_object LC16__lambda104(cl_object v1, cl_object v2) cl_object v3; cl_object v4length; T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } v3 = ecl_cddr(v1); goto L1; L2:; v3 = ecl_cdr(v1); L1:; if (!(v3==ECL_NIL)) { goto L6; } - ecl_function_dispatch(cl_env_copy,VV[59])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L6:; { cl_object v5; @@ -1207,8 +1141,8 @@ L11:; { cl_object v6; cl_object v7; - v6 = cl_gensym(1, VV[25]); - v7 = cl_gensym(1, VV[26]); + v6 = cl_gensym(1, VV[24]); + v7 = cl_gensym(1, VV[25]); T0 = ecl_list1(v6); if ((v5optimizedp)!=ECL_NIL) { goto L17; } T2 = cl_list(2, v7, v4length); @@ -1219,10 +1153,10 @@ L17:; L16:; T2 = CONS(T0,T1); if ((v5optimizedp)!=ECL_NIL) { goto L20; } - T4 = cl_list(2, ECL_SYM("INTEGERP",442), v7); - T5 = cl_list(2, ECL_SYM("LENGTH",478), v7); - T6 = cl_list(3, ECL_SYM("SETF",752), v7, T5); - T7 = cl_list(3, ECL_SYM("UNLESS",885), T4, T6); + T4 = cl_list(2, ECL_SYM("INTEGERP",440), v7); + T5 = cl_list(2, ECL_SYM("LENGTH",476), v7); + T6 = cl_list(3, ECL_SYM("SETF",750), v7, T5); + T7 = cl_list(3, ECL_SYM("UNLESS",883), T4, T6); T3 = ecl_list1(T7); goto L19; L20:; @@ -1236,8 +1170,6 @@ L19:; cl_object v10; v10 = v3; if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v10; } { @@ -1249,32 +1181,28 @@ L29:; if (!(ecl_endp(v9))) { goto L31; } goto L30; L31:; - v8sequence = ECL_CONS_CAR(v9); + v8sequence = _ecl_car(v9); { cl_object v12; - v12 = ECL_CONS_CDR(v9); + v12 = _ecl_cdr(v9); if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v9 = v12; } { cl_object v12; v12 = v11; if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T5 = v12; } - T6 = cl_list(3, ECL_SYM("SETF",752), v6, v8sequence); - T7 = cl_list(2, ECL_SYM("INTEGERP",442), v6); + T6 = cl_list(3, ECL_SYM("SETF",750), v6, v8sequence); + T7 = cl_list(2, ECL_SYM("INTEGERP",440), v6); if (Null(v5optimizedp)) { goto L45; } T8 = v4length; goto L44; L45:; T8 = v7; L44:; - T9 = cl_list(3, ECL_SYM("=",76), v6, T8); + T9 = cl_list(3, ECL_SYM("=",74), v6, T8); if (Null(v5optimizedp)) { goto L48; } T10 = v4length; goto L47; @@ -1282,8 +1210,8 @@ L48:; T10 = v7; L47:; T11 = cl_list(3, VV[0], v6, T10); - T12 = cl_list(4, ECL_SYM("IF",948), T7, T9, T11); - T13 = cl_list(3, ECL_SYM("PROGN",673), T6, T12); + T12 = cl_list(4, ECL_SYM("IF",946), T7, T9, T11); + T13 = cl_list(3, ECL_SYM("PROGN",671), T6, T12); v11 = ecl_list1(T13); (ECL_CONS_CDR(T5)=v11,T5); goto L29; @@ -1293,11 +1221,11 @@ L30:; } } L22:; - T5 = CONS(ECL_SYM("AND",89),T4); + T5 = CONS(ECL_SYM("AND",87),T4); T6 = ecl_list1(T5); T7 = ecl_append(T3,T6); - T8 = cl_listX(3, ECL_SYM("LET",479), T2, T7); - value0 = cl_list(3, ECL_SYM("LOCALLY",492), VV[27], T8); + T8 = cl_listX(3, ECL_SYM("LET",477), T2, T7); + value0 = cl_list(3, ECL_SYM("LOCALLY",490), VV[26], T8); return value0; } } @@ -1308,7 +1236,6 @@ L22:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L17copy_sequence(cl_object v1type, cl_object v2sequence) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1327,7 +1254,6 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L18first_elt(cl_object v1sequence) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1348,7 +1274,7 @@ L1:; cl_env_copy->nvalues = 1; return value0; L3:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[11]); + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[11]); return value0; } } @@ -1357,7 +1283,6 @@ L3:; static cl_object L19_setf_first_elt_(cl_object v1object, cl_object v2sequence) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1371,8 +1296,6 @@ static cl_object L19_setf_first_elt_(cl_object v1object, cl_object v2sequence) cl_object v4; v4 = v2sequence; if (ecl_unlikely(ECL_ATOM(v4))) FEtype_error_cons(v4); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v4; } (ECL_CONS_CAR(T0)=v3,T0); @@ -1391,7 +1314,7 @@ L1:; cl_env_copy->nvalues = 1; return value0; L8:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v2sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[11]); + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v2sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[11]); return value0; } } @@ -1400,7 +1323,6 @@ L8:; static cl_object L20last_elt(cl_object v1sequence) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1410,18 +1332,18 @@ static cl_object L20last_elt(cl_object v1sequence) cl_object v2len; v2len = ecl_make_fixnum(0); if (!(ECL_CONSP(v1sequence))) { goto L2; } - value0 = ecl_function_dispatch(cl_env_copy,VV[69])(1, v1sequence) /* LASTCAR */; + value0 = ecl_function_dispatch(cl_env_copy,VV[65])(1, v1sequence) /* LASTCAR */; return value0; L2:; if (!(ECL_VECTORP(v1sequence))) { goto L4; } v2len = ecl_make_fixnum(ecl_length(v1sequence)); if (!((ecl_to_fixnum(v2len))>0)) { goto L4; } T0 = ecl_one_minus(v2len); - value0 = ecl_elt(v1sequence,ecl_to_size(T0)); + value0 = ecl_elt(v1sequence,ecl_fixnum(T0)); cl_env_copy->nvalues = 1; return value0; L4:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v1sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[32]); + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[31]); return value0; } } @@ -1431,7 +1353,6 @@ L4:; static cl_object L21_setf_last_elt_(cl_object v1object, cl_object v2sequence) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1441,7 +1362,7 @@ static cl_object L21_setf_last_elt_(cl_object v1object, cl_object v2sequence) cl_object v3len; v3len = ecl_make_fixnum(0); if (!(ECL_CONSP(v2sequence))) { goto L2; } - value0 = (cl_env_copy->function=ecl_fdefinition(VV[71]))->cfun.entry(2, v1object, v2sequence) /* (SETF LASTCAR) */; + value0 = (cl_env_copy->function=ecl_fdefinition(VV[67]))->cfun.entry(2, v1object, v2sequence) /* (SETF LASTCAR) */; return value0; L2:; if (!(ECL_VECTORP(v2sequence))) { goto L4; } @@ -1452,7 +1373,7 @@ L2:; cl_env_copy->nvalues = 1; return value0; L4:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",872), ECL_SYM("DATUM",1242), v2sequence, ECL_SYM("EXPECTED-TYPE",1260), VV[32]); + value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v2sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[31]); return value0; } } @@ -1461,8 +1382,7 @@ L4:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L22starts_with_subseq(cl_narg narg, cl_object v1prefix, cl_object v2sequence, ...) { - cl_object T0; - cl_object env0 = ECL_NIL; + cl_object T0, T1, T2; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1477,7 +1397,7 @@ static cl_object L22starts_with_subseq(cl_narg narg, cl_object v1prefix, cl_obje ecl_va_end(args); v4return_suffix = keyvars[0]; } - v3args = ecl_function_dispatch(cl_env_copy,VV[73])(2, v3args, VV[35]) /* REMOVE-FROM-PLIST */; + v3args = ecl_function_dispatch(cl_env_copy,VV[69])(2, v3args, VV[34]) /* REMOVE-FROM-PLIST */; { cl_fixnum v5; cl_fixnum v6; @@ -1486,24 +1406,20 @@ static cl_object L22starts_with_subseq(cl_narg narg, cl_object v1prefix, cl_obje if (!((v6)<=(v5))) { goto L5; } { cl_object v7mismatch; - T0 = (ECL_SYM("MISMATCH",561)->symbol.gfdef); + T0 = (ECL_SYM("MISMATCH",559)->symbol.gfdef); v7mismatch = cl_apply(4, T0, v1prefix, v2sequence, v3args); if (Null(v7mismatch)) { goto L9; } - if (!(ecl_lower(v7mismatch,ecl_make_fixnum(v6)))) { goto L11; } + if (!(ecl_number_compare(v7mismatch,ecl_make_fixnum(v6))<0)) { goto L11; } cl_env_copy->nvalues = 2; cl_env_copy->values[1] = ECL_NIL; cl_env_copy->values[0] = ECL_NIL; return cl_env_copy->values[0]; L11:; if (Null(v4return_suffix)) { goto L14; } - { - cl_object v8; - cl_object v9; - v8 = ecl_minus(ecl_make_fixnum(v5),v7mismatch); - v9 = cl_array_element_type(v2sequence); - T0 = si_make_pure_array(v9, v8, ECL_NIL, ECL_NIL, v2sequence, ecl_make_fixnum(v6)); - goto L13; - } + T1 = cl_array_element_type(v2sequence); + T2 = ecl_minus(ecl_make_fixnum(v5),v7mismatch); + T0 = si_make_pure_array(T1, T2, ECL_NIL, ECL_NIL, v2sequence, ecl_make_fixnum(v6)); + goto L13; L14:; T0 = ECL_NIL; L13:; @@ -1512,16 +1428,13 @@ L13:; cl_env_copy->values[0] = ECL_T; return cl_env_copy->values[0]; L9:; - if (Null(v4return_suffix)) { goto L19; } - { - cl_object v8; - v8 = cl_array_element_type(v2sequence); - T0 = si_make_vector(v8, ecl_make_fixnum(0), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - goto L18; - } -L19:; + if (Null(v4return_suffix)) { goto L17; } + T1 = cl_array_element_type(v2sequence); + T0 = si_make_vector(T1, ecl_make_fixnum(0), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + goto L16; +L17:; T0 = ECL_NIL; -L18:; +L16:; cl_env_copy->nvalues = 2; cl_env_copy->values[1] = T0; cl_env_copy->values[0] = ECL_T; @@ -1540,7 +1453,6 @@ L5:; static cl_object L23ends_with_subseq(cl_narg narg, cl_object v1suffix, cl_object v2sequence, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1553,7 +1465,7 @@ static cl_object L23ends_with_subseq(cl_narg narg, cl_object v1suffix, cl_object cl_parse_key(args,1,L23ends_with_subseqkeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[1])) { - v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + v3test = (ECL_SYM("EQL",334)->symbol.gfdef); } else { v3test = keyvars[0]; } @@ -1573,34 +1485,41 @@ L4:; cl_object v7sequence_index; cl_object v8; v6 = ecl_minus(ecl_make_fixnum(v4),ecl_make_fixnum(v5)); - v7sequence_index = v6; + { + cl_object v9; + v9 = v6; + T0 = cl_realp(v9); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v9); + v7sequence_index = v9; + } v8 = ecl_make_fixnum(v4); { cl_object v9suffix_index; cl_object v10; v9suffix_index = ecl_make_fixnum(0); v10 = ecl_make_fixnum(v5); - if (!(ecl_greatereq(v7sequence_index,v8))) { goto L13; } - goto L12; -L13:; -L11:; - if (!(ecl_greatereq(v9suffix_index,v10))) { goto L15; } - goto L12; + if (!(ecl_number_compare(v7sequence_index,v8)>=0)) { goto L15; } + goto L14; L15:; - T0 = ecl_elt(v2sequence,ecl_to_size(v7sequence_index)); - T1 = ecl_elt(v1suffix,ecl_to_size(v9suffix_index)); - if ((ecl_function_dispatch(cl_env_copy,v3test)(2, T0, T1))!=ECL_NIL) { goto L17; } +L13:; + if (!(ecl_number_compare(v9suffix_index,v10)>=0)) { goto L17; } + goto L14; +L17:; + T0 = ecl_elt(v2sequence,ecl_fixnum(v7sequence_index)); + T1 = ecl_elt(v1suffix,ecl_fixnum(v9suffix_index)); + if ((ecl_function_dispatch(cl_env_copy,v3test)(2, T0, T1))!=ECL_NIL) { goto L19; } value0 = ECL_NIL; cl_env_copy->nvalues = 1; return value0; -L17:; +L19:; v7sequence_index = ecl_one_plus(v7sequence_index); - if (!(ecl_greatereq(v7sequence_index,v8))) { goto L21; } - goto L12; -L21:; + if (!(ecl_number_compare(v7sequence_index,v8)>=0)) { goto L23; } + goto L14; +L23:; v9suffix_index = ecl_one_plus(v9suffix_index); - goto L11; -L12:; + goto L13; +L14:; value0 = ECL_T; cl_env_copy->nvalues = 1; return value0; @@ -1614,7 +1533,6 @@ L12:; static cl_object L24starts_with(cl_narg narg, cl_object v1object, cl_object v2sequence, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1628,12 +1546,12 @@ static cl_object L24starts_with(cl_narg narg, cl_object v1object, cl_object v2se cl_parse_key(args,2,L24starts_withkeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[2])) { - v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + v3test = (ECL_SYM("EQL",334)->symbol.gfdef); } else { v3test = keyvars[0]; } if (Null(keyvars[3])) { - v4key = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + v4key = (ECL_SYM("IDENTITY",426)->symbol.gfdef); } else { v4key = keyvars[1]; } @@ -1674,7 +1592,6 @@ L4:; static cl_object L25ends_with(cl_narg narg, cl_object v1object, cl_object v2sequence, ...) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1688,18 +1605,18 @@ static cl_object L25ends_with(cl_narg narg, cl_object v1object, cl_object v2sequ cl_parse_key(args,2,L25ends_withkeys,keyvars,NULL,FALSE); ecl_va_end(args); if (Null(keyvars[2])) { - v3test = (ECL_SYM("EQL",336)->symbol.gfdef); + v3test = (ECL_SYM("EQL",334)->symbol.gfdef); } else { v3test = keyvars[0]; } if (Null(keyvars[3])) { - v4key = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + v4key = (ECL_SYM("IDENTITY",426)->symbol.gfdef); } else { v4key = keyvars[1]; } } if (!(ECL_CONSP(v2sequence))) { goto L5; } - T1 = ecl_function_dispatch(cl_env_copy,VV[69])(1, v2sequence) /* LASTCAR */; + T1 = ecl_function_dispatch(cl_env_copy,VV[65])(1, v2sequence) /* LASTCAR */; goto L4; L5:; if (ECL_CONSP(v2sequence)) { goto L9; } @@ -1713,7 +1630,7 @@ L8:; v5len = ecl_length(v2sequence); if (!((v5len)>0)) { goto L13; } T2 = ecl_make_integer((v5len)-1); - T1 = ecl_elt(v2sequence,ecl_to_size(T2)); + T1 = ecl_elt(v2sequence,ecl_fixnum(T2)); goto L4; L13:; value0 = ECL_NIL; @@ -1736,7 +1653,6 @@ static cl_object L30map_combinations(cl_narg narg, cl_object v1function, cl_obje { cl_object T0; volatile cl_object lex0[5]; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1787,7 +1703,7 @@ L10:; L8:; T0 = cl_subseq(3, lex0[0], ecl_make_fixnum(0), v7length); lex0[3] = T0; /* COMBINATION */ - T0 = ecl_function_dispatch(cl_env_copy,VV[85])(1, v1function) /* ENSURE-FUNCTION */; + T0 = ecl_function_dispatch(cl_env_copy,VV[81])(1, v1function) /* ENSURE-FUNCTION */; lex0[4] = T0; /* FUNCTION */ if (!(ecl_number_equalp(v7length,v6size))) { goto L12; } ecl_function_dispatch(cl_env_copy,lex0[4])(1, lex0[3]); @@ -1811,7 +1727,7 @@ L19:; LC29combine(lex0, v7length, v3start); goto L2; L18:; - si_etypecase_error(lex0[0], VV[8]); + si_etypecase_error(lex0[0], VV[9]); } L2:; value0 = lex0[0]; @@ -1824,7 +1740,6 @@ L2:; static cl_object LC26call(volatile cl_object *lex0) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1845,7 +1760,6 @@ L1:; static cl_object LC27combine_list(volatile cl_object *lex0, cl_object v1c_tail, cl_object v2o_tail) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1867,8 +1781,6 @@ L5:; cl_object v5; v5 = v1c_tail; if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v5; } (ECL_CONS_CAR(T0)=v4,T0); @@ -1892,7 +1804,6 @@ L17:; static cl_object LC28combine(volatile cl_object *lex0, cl_object v1count, cl_object v2start) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1908,31 +1819,21 @@ L1:; { cl_object v5; v5 = v2start; - { - bool v6; - v6 = ecl_numberp(v5); - if (ecl_unlikely(!(v6))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + T0 = cl_realp(v5); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v5); v3i = v5; } { cl_object v5; v5 = lex0[2]; - { - bool v6; - v6 = ecl_numberp(v5); - if (ecl_unlikely(!(v6))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + T0 = cl_realp(v5); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v5); v4 = v5; } L9:; - if (!(ecl_greatereq(v3i,v4))) { goto L11; } + if (!(ecl_number_compare(v3i,v4)>=0)) { goto L11; } goto L10; L11:; { @@ -1949,8 +1850,6 @@ L11:; v8 = v5j; if (ecl_unlikely((ecl_fixnum(v8))>=(v6)->vector.dim)) FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(ecl_fixnum(v8)),(v6)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v7 = ecl_fixnum(v8); } T1 = ecl_aref_unsafe(lex0[0],ecl_fixnum(v3i)); @@ -1974,7 +1873,6 @@ L10:; static cl_object LC29combine(volatile cl_object *lex0, cl_object v1count, cl_object v2start) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1990,37 +1888,27 @@ L1:; { cl_object v5; v5 = v2start; - { - bool v6; - v6 = ecl_numberp(v5); - if (ecl_unlikely(!(v6))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + T0 = cl_realp(v5); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v5); v3i = v5; } { cl_object v5; v5 = lex0[2]; - { - bool v6; - v6 = ecl_numberp(v5); - if (ecl_unlikely(!(v6))) - FEwrong_type_argument(ECL_SYM("NUMBER",608),v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; - } + T0 = cl_realp(v5); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v5); v4 = v5; } L9:; - if (!(ecl_greatereq(v3i,v4))) { goto L11; } + if (!(ecl_number_compare(v3i,v4)>=0)) { goto L11; } goto L10; L11:; { cl_object v5j; v5j = ecl_minus(v1count,ecl_make_fixnum(1)); - T0 = ecl_elt(lex0[0],ecl_to_size(v3i)); + T0 = ecl_elt(lex0[0],ecl_fixnum(v3i)); ecl_elt_set(lex0[3],ecl_to_size(v5j),T0); T0 = ecl_plus(v3i,ecl_make_fixnum(1)); LC29combine(lex0, v5j, T0); @@ -2039,7 +1927,7 @@ L10:; static cl_object L34map_permutations(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) { cl_object T0; - cl_object env0 = ECL_NIL; + cl_object env0; volatile struct ecl_cclosure aux_closure; cl_object CLV0, CLV1, CLV2, CLV3; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -2103,8 +1991,8 @@ L11:; CLV3 = env2 = CONS(T0,env2); /* PERMUTATION */ { cl_object v8; - v8 = ecl_make_cclosure_va((cl_objectfn)LC33permute_combination,env2,Cblock,1); - value0 = L30map_combinations(10, v8, v2sequence, ECL_SYM("START",1344), v3start, ECL_SYM("END",1253), v6end, ECL_SYM("LENGTH",1295), ECL_CONS_CAR(CLV2), VV[41], ECL_NIL); + v8 = ecl_make_cclosure_va((cl_objectfn)LC33permute_combination,env2,Cblock); + value0 = L30map_combinations(10, v8, v2sequence, ECL_SYM("START",1315), v3start, ECL_SYM("END",1228), v6end, ECL_SYM("LENGTH",1268), ECL_CONS_CAR(CLV2), VV[40], ECL_NIL); return value0; } } @@ -2170,16 +2058,23 @@ L2:; cl_object v4i; cl_object v5; v4i = ecl_make_fixnum(0); - v5 = v3n_1; -L9:; - if (!(ecl_greater(v4i,v5))) { goto L11; } - goto L10; + { + cl_object v6; + v6 = v3n_1; + T0 = cl_realp(v6); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v6); + v5 = v6; + } L11:; + if (!(ecl_number_compare(v4i,v5)>0)) { goto L13; } + goto L12; +L13:; (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC31permute(2, v1seq, v3n_1)); - if (!(ecl_evenp(v3n_1))) { goto L15; } + if (!(ecl_evenp(v3n_1))) { goto L17; } { cl_object v6; - v6 = ecl_elt(v1seq,ecl_to_size(v3n_1)); + v6 = ecl_elt(v1seq,ecl_fixnum(v3n_1)); { cl_object v7; v7 = ecl_elt(v1seq,0); @@ -2187,22 +2082,22 @@ L11:; ecl_elt_set(v1seq,ecl_to_size(v3n_1),v7); } } - goto L13; -L15:; + goto L15; +L17:; { cl_object v6; - v6 = ecl_elt(v1seq,ecl_to_size(v3n_1)); + v6 = ecl_elt(v1seq,ecl_fixnum(v3n_1)); { cl_object v7; - v7 = ecl_elt(v1seq,ecl_to_size(v4i)); + v7 = ecl_elt(v1seq,ecl_fixnum(v4i)); ecl_elt_set(v1seq,ecl_to_size(v4i),v6); ecl_elt_set(v1seq,ecl_to_size(v3n_1),v7); } } -L13:; +L15:; v4i = ecl_one_plus(v4i); - goto L9; -L10:; + goto L11; +L12:; value0 = ECL_NIL; cl_env_copy->nvalues = 1; return value0; @@ -2243,7 +2138,6 @@ static cl_object L36map_derangements(cl_narg narg, cl_object v1function, cl_obje { cl_object T0, T1; volatile cl_object lex0[7]; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2283,9 +2177,9 @@ L1:; lex0[4] = T0; /* SIZE */ T0 = cl_subseq(3, lex0[1], ecl_make_fixnum(0), lex0[4]); lex0[5] = T0; /* DERANGEMENT */ - T1 = si_make_pure_array(ECL_SYM("BIT",125), lex0[4], ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - T0 = si_fill_array_with_elt(T1, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); - lex0[6] = T0; /* MASK */ + T0 = si_make_pure_array(ECL_SYM("BIT",123), lex0[4], ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + T1 = si_fill_array_with_elt(T0, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); + lex0[6] = T1; /* MASK */ LC35derange(lex0, lex0[2], lex0[4]); value0 = lex0[1]; cl_env_copy->nvalues = 1; @@ -2298,7 +2192,6 @@ L1:; static cl_object LC35derange(volatile cl_object *lex0, cl_object v1place, cl_object v2n) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2318,16 +2211,23 @@ L1:; cl_object v3i; cl_object v4; v3i = ecl_make_fixnum(0); - v4 = lex0[4]; -L8:; - if (!(ecl_greatereq(v3i,v4))) { goto L10; } - goto L9; + { + cl_object v5; + v5 = lex0[4]; + T0 = cl_realp(v5); + if (ecl_unlikely(!((T0)!=ECL_NIL))) + FEwrong_type_argument(ECL_SYM("REAL",703),v5); + v4 = v5; + } L10:; + if (!(ecl_number_compare(v3i,v4)>=0)) { goto L12; } + goto L11; +L12:; T0 = ecl_plus(v3i,lex0[2]); - if (ecl_number_equalp(v1place,T0)) { goto L12; } + if (ecl_number_equalp(v1place,T0)) { goto L14; } T0 = cl_bit(2, lex0[6], v3i); - if (!((ecl_to_fixnum(T0))==0)) { goto L12; } - T0 = ecl_elt(lex0[1],ecl_to_size(v1place)); + if (!((ecl_to_fixnum(T0))==0)) { goto L14; } + T0 = ecl_elt(lex0[1],ecl_fixnum(v1place)); ecl_elt_set(lex0[5],ecl_to_size(v3i),T0); { cl_object v5; @@ -2340,8 +2240,6 @@ L10:; v7 = v3i; if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = ecl_fixnum(v7); } ecl_aset_unsafe(T0,v6,ecl_make_fixnum(1)); @@ -2361,28 +2259,25 @@ L10:; v7 = v3i; if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; v6 = ecl_fixnum(v7); } ecl_aset_unsafe(T0,v6,ecl_make_fixnum(0)); } } -L12:; +L14:; v3i = ecl_one_plus(v3i); - goto L8; -L9:; + goto L10; +L11:; value0 = ECL_NIL; cl_env_copy->nvalues = 1; return value0; } } } -/* local function LAMBDA235 */ +/* local function G181 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC38__lambda235() +static cl_object LC38__g181() { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -2390,24 +2285,23 @@ static cl_object LC38__lambda235() TTL: { cl_object v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC37__lambda236,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC37__g182,ECL_NIL,Cblock,2); value0 = v1; cl_env_copy->nvalues = 1; return value0; } } } -/* local function LAMBDA236 */ +/* local function G182 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC37__lambda236(cl_object v1condition, cl_object v2stream) +static cl_object LC37__g182(cl_object v1condition, cl_object v2stream) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: - value0 = cl_format(3, v2stream, VV[44], VV[45]); + value0 = cl_format(3, v2stream, VV[43], VV[44]); return value0; } } @@ -2416,7 +2310,7 @@ static cl_object LC37__lambda236(cl_object v1condition, cl_object v2stream) static cl_object L41extremum(cl_narg narg, cl_object v1sequence, cl_object v2predicate, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0, CLV1; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -2442,14 +2336,14 @@ static cl_object L41extremum(cl_narg narg, cl_object v1sequence, cl_object v2pre { cl_object v6real_end; cl_object env1 = env0; - T0 = ecl_function_dispatch(cl_env_copy,VV[85])(1, v2predicate) /* ENSURE-FUNCTION */; + T0 = ecl_function_dispatch(cl_env_copy,VV[81])(1, v2predicate) /* ENSURE-FUNCTION */; env1 = ECL_NIL; CLV0 = env1 = CONS(T0,env1); /* PRED-FUN */ if (Null(v3key)) { goto L3; } - if ((v3key)==(ECL_SYM("IDENTITY",428))) { goto L3; } - T1 = (ECL_SYM("IDENTITY",428)->symbol.gfdef); + if ((v3key)==(ECL_SYM("IDENTITY",426))) { goto L3; } + T1 = (ECL_SYM("IDENTITY",426)->symbol.gfdef); if ((v3key)==(T1)) { goto L3; } - T0 = ecl_function_dispatch(cl_env_copy,VV[85])(1, v3key) /* ENSURE-FUNCTION */; + T0 = ecl_function_dispatch(cl_env_copy,VV[81])(1, v3key) /* ENSURE-FUNCTION */; goto L2; L3:; T0 = ECL_NIL; @@ -2463,19 +2357,19 @@ L10:; v6real_end = value0; goto L8; L8:; - if (!(ecl_greater(v6real_end,v4start))) { goto L12; } + if (!(ecl_number_compare(v6real_end,v4start)>0)) { goto L12; } if (Null(ECL_CONS_CAR(CLV1))) { goto L14; } { cl_object v7; - v7 = ecl_make_cclosure_va((cl_objectfn)LC39reduce_keys,env1,Cblock,2); - value0 = cl_reduce(6, v7, v1sequence, ECL_SYM("START",1344), v4start, ECL_SYM("END",1253), v6real_end); + v7 = ecl_make_cclosure_va((cl_objectfn)LC39reduce_keys,env1,Cblock); + value0 = cl_reduce(6, v7, v1sequence, ECL_SYM("START",1315), v4start, ECL_SYM("END",1228), v6real_end); return value0; } L14:; { cl_object v8; - v8 = ecl_make_cclosure_va((cl_objectfn)LC40reduce_elts,env1,Cblock,2); - value0 = cl_reduce(6, v8, v1sequence, ECL_SYM("START",1344), v4start, ECL_SYM("END",1253), v6real_end); + v8 = ecl_make_cclosure_va((cl_objectfn)LC40reduce_elts,env1,Cblock); + value0 = cl_reduce(6, v8, v1sequence, ECL_SYM("START",1315), v4start, ECL_SYM("END",1228), v6real_end); return value0; } L12:; @@ -2487,7 +2381,7 @@ L16:; { cl_fixnum v9; v9 = ecl_length(v1sequence); - value0 = cl_error(6, VV[46], ecl_make_fixnum(v9), ECL_SYM("START",1344), v4start, ECL_SYM("END",1253), v5end); + value0 = cl_error(6, VV[45], ecl_make_fixnum(v9), ECL_SYM("START",1315), v4start, ECL_SYM("END",1228), v5end); return value0; } } @@ -2555,7 +2449,7 @@ L1:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecl4y48pVyvO59HM_y7IycC71(cl_object flag) +ECL_DLLEXPORT void _ecl4y48pVyvO59HM_R0i2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -2570,152 +2464,145 @@ ECL_DLLEXPORT void _ecl4y48pVyvO59HM_y7IycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/sequences.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/sequences.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4y48pVyvO59HM_y7IycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4y48pVyvO59HM_R0i2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* SEQUENCE-OF-LENGTH-P */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[6]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[7], VVtemp[8]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* ROTATE-TAIL-TO-HEAD */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; - ecl_cmp_defun(VV[51]); /* ROTATE-HEAD-TO-TAIL */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[52]); /* ROTATE */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[15]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[53]); /* SHUFFLE */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[7], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[10], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[56]); /* RANDOM-ELT */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[10], ECL_SYM("FUNCTION",398), VVtemp[22]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[23]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LOCATION",1862), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[13], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defun(VV[57]); /* REMOVE/SWAPPED-ARGUMENTS */ - si_put_sysprop(VV[13], ECL_SYM("INLINE",436), VVtemp[27]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[28], VVtemp[29]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[30]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[58]); /* REMOVEF */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[14], ECL_SYM("FUNCTION",398), VVtemp[31]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[32]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defun(VV[60]); /* DELETE/SWAPPED-ARGUMENTS */ - si_put_sysprop(VV[16], ECL_SYM("INLINE",436), VVtemp[35]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[36], VVtemp[37]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[30]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[61]); /* DELETEF */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[17], ECL_SYM("FUNCTION",398), VVtemp[38]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + ecl_cmp_defun(VV[46]); /* SEQUENCE-OF-LENGTH-P */ + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[47]); /* ROTATE-TAIL-TO-HEAD */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[49]); /* ROTATE-HEAD-TO-TAIL */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[13]) /* ANNOTATE */; + ecl_cmp_defun(VV[50]); /* ROTATE */ + si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[14]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[17]) /* ANNOTATE */; + ecl_cmp_defun(VV[51]); /* SHUFFLE */ + si_set_documentation(3, VV[7], ECL_SYM("FUNCTION",396), VVtemp[18]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[19], VVtemp[20]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[17]) /* ANNOTATE */; + ecl_cmp_defun(VV[54]); /* RANDOM-ELT */ + si_set_documentation(3, VV[10], ECL_SYM("FUNCTION",396), VVtemp[21]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[22]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[23], VVtemp[24]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defun(VV[55]); /* REMOVE/SWAPPED-ARGUMENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[26], VVtemp[27]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[56]); /* REMOVEF */ + si_set_documentation(3, VV[14], ECL_SYM("FUNCTION",396), VVtemp[29]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[30]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; + ecl_cmp_defun(VV[57]); /* DELETE/SWAPPED-ARGUMENTS */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[33], VVtemp[34]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[58]); /* DELETEF */ + si_set_documentation(3, VV[17], ECL_SYM("FUNCTION",396), VVtemp[35]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[18], ECL_SYM("TYPE",871), VVtemp[39]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[18], ECL_SYM("TYPE",869), VVtemp[36]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC13__lambda79,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC13proper_sequence,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[18], VVtemp[40], T0); + si_do_deftype(3, VV[18], VVtemp[37], T0); } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LOCATION",1862), VVtemp[41], VVtemp[42]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[20], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[63]); /* EMPTYP */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[20], ECL_SYM("FUNCTION",398), VVtemp[44]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[45], VVtemp[46]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[47]) /* ANNOTATE */; - ecl_cmp_defun(VV[64]); /* LENGTH= */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[22], ECL_SYM("FUNCTION",398), VVtemp[48]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[38], VVtemp[39]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; + ecl_cmp_defun(VV[59]); /* EMPTYP */ + si_set_documentation(3, VV[20], ECL_SYM("FUNCTION",396), VVtemp[41]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[43]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[44]) /* ANNOTATE */; + ecl_cmp_defun(VV[60]); /* LENGTH= */ + si_set_documentation(3, VV[22], ECL_SYM("FUNCTION",396), VVtemp[45]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC16__lambda104,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC16length_,ECL_NIL,Cblock,2); T0 = v1; } - si_put_sysprop(VV[22], ECL_SYM("COMPILER-MACRO",240), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[22], ECL_SYM("LOCATION",1862), VVtemp[49], VVtemp[50]) /* ANNOTATE */; + si_put_sysprop(VV[22], ECL_SYM("COMPILER-MACRO",238), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[46], VVtemp[47]) /* ANNOTATE */; } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LOCATION",1862), VVtemp[51], VVtemp[52]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[28], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[53]) /* ANNOTATE */; - ecl_cmp_defun(VV[65]); /* COPY-SEQUENCE */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[28], ECL_SYM("FUNCTION",398), VVtemp[54]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[28], ECL_SYM("INLINE",436), VVtemp[55]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LOCATION",1862), VVtemp[56], VVtemp[57]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[29], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[66]); /* FIRST-ELT */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[29], ECL_SYM("FUNCTION",398), VVtemp[58]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[59], ECL_SYM("LOCATION",1862), VVtemp[60], VVtemp[61]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[59], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; - ecl_cmp_defun(VV[67]); /* (SETF FIRST-ELT) */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[30], ECL_SYM("FUNCTION",398), VVtemp[63]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LOCATION",1862), VVtemp[64], VVtemp[65]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[68]); /* LAST-ELT */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[31], ECL_SYM("FUNCTION",398), VVtemp[66]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[67], ECL_SYM("LOCATION",1862), VVtemp[68], VVtemp[69]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VVtemp[67], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[62]) /* ANNOTATE */; - ecl_cmp_defun(VV[70]); /* (SETF LAST-ELT) */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[33], ECL_SYM("FUNCTION",398), VVtemp[70]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LOCATION",1862), VVtemp[71], VVtemp[72]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[73]) /* ANNOTATE */; - ecl_cmp_defun(VV[72]); /* STARTS-WITH-SUBSEQ */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[34], ECL_SYM("FUNCTION",398), VVtemp[74]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LOCATION",1862), VVtemp[75], VVtemp[76]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[36], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[77]) /* ANNOTATE */; - ecl_cmp_defun(VV[74]); /* ENDS-WITH-SUBSEQ */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[36], ECL_SYM("FUNCTION",398), VVtemp[78]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[37], ECL_SYM("LOCATION",1862), VVtemp[79], VVtemp[80]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[37], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[81]) /* ANNOTATE */; - ecl_cmp_defun(VV[76]); /* STARTS-WITH */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[37], ECL_SYM("FUNCTION",398), VVtemp[82]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LOCATION",1862), VVtemp[83], VVtemp[84]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[38], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[81]) /* ANNOTATE */; - ecl_cmp_defun(VV[79]); /* ENDS-WITH */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[38], ECL_SYM("FUNCTION",398), VVtemp[85]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[39], ECL_SYM("LOCATION",1862), VVtemp[86], VVtemp[87]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[39], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[88]) /* ANNOTATE */; - ecl_cmp_defun(VV[80]); /* MAP-COMBINATIONS */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[39], ECL_SYM("FUNCTION",398), VVtemp[89]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[90], VVtemp[91]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[88]) /* ANNOTATE */; - ecl_cmp_defun(VV[86]); /* MAP-PERMUTATIONS */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[40], ECL_SYM("FUNCTION",398), VVtemp[92]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[93], VVtemp[94]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[95]) /* ANNOTATE */; - ecl_cmp_defun(VV[87]); /* MAP-DERANGEMENTS */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[42], ECL_SYM("FUNCTION",398), VVtemp[96]) /* SET-DOCUMENTATION */; - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[97]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LOCATION",1777), VVtemp[48], VVtemp[49]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; + ecl_cmp_defun(VV[61]); /* COPY-SEQUENCE */ + si_set_documentation(3, VV[27], ECL_SYM("FUNCTION",396), VVtemp[51]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[53]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; + ecl_cmp_defun(VV[62]); /* FIRST-ELT */ + si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[54]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[55], ECL_SYM("LOCATION",1777), VVtemp[56], VVtemp[57]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[55], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; + ecl_cmp_defun(VV[63]); /* (SETF FIRST-ELT) */ + si_set_documentation(3, VV[29], ECL_SYM("FUNCTION",396), VVtemp[59]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[30], ECL_SYM("LOCATION",1777), VVtemp[60], VVtemp[61]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[30], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; + ecl_cmp_defun(VV[64]); /* LAST-ELT */ + si_set_documentation(3, VV[30], ECL_SYM("FUNCTION",396), VVtemp[62]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[63], ECL_SYM("LOCATION",1777), VVtemp[64], VVtemp[65]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[63], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; + ecl_cmp_defun(VV[66]); /* (SETF LAST-ELT) */ + si_set_documentation(3, VV[32], ECL_SYM("FUNCTION",396), VVtemp[66]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LOCATION",1777), VVtemp[67], VVtemp[68]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[69]) /* ANNOTATE */; + ecl_cmp_defun(VV[68]); /* STARTS-WITH-SUBSEQ */ + si_set_documentation(3, VV[33], ECL_SYM("FUNCTION",396), VVtemp[70]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LOCATION",1777), VVtemp[71], VVtemp[72]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[73]) /* ANNOTATE */; + ecl_cmp_defun(VV[70]); /* ENDS-WITH-SUBSEQ */ + si_set_documentation(3, VV[35], ECL_SYM("FUNCTION",396), VVtemp[74]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[36], ECL_SYM("LOCATION",1777), VVtemp[75], VVtemp[76]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[36], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[77]) /* ANNOTATE */; + ecl_cmp_defun(VV[72]); /* STARTS-WITH */ + si_set_documentation(3, VV[36], ECL_SYM("FUNCTION",396), VVtemp[78]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LOCATION",1777), VVtemp[79], VVtemp[80]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[77]) /* ANNOTATE */; + ecl_cmp_defun(VV[75]); /* ENDS-WITH */ + si_set_documentation(3, VV[37], ECL_SYM("FUNCTION",396), VVtemp[81]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[38], ECL_SYM("LOCATION",1777), VVtemp[82], VVtemp[83]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[38], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[84]) /* ANNOTATE */; + ecl_cmp_defun(VV[76]); /* MAP-COMBINATIONS */ + si_set_documentation(3, VV[38], ECL_SYM("FUNCTION",396), VVtemp[85]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LOCATION",1777), VVtemp[86], VVtemp[87]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[84]) /* ANNOTATE */; + ecl_cmp_defun(VV[82]); /* MAP-PERMUTATIONS */ + si_set_documentation(3, VV[39], ECL_SYM("FUNCTION",396), VVtemp[88]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[89], VVtemp[90]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[91]) /* ANNOTATE */; + ecl_cmp_defun(VV[83]); /* MAP-DERANGEMENTS */ + si_set_documentation(3, VV[41], ECL_SYM("FUNCTION",396), VVtemp[92]); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[93]) /* MAPC */; { cl_object T0, T1, T2; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LOCATION",1862), VVtemp[98], VVtemp[99]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LOCATION",1777), VVtemp[94], VVtemp[95]) /* ANNOTATE */; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC38__lambda235,ECL_NIL,Cblock,0); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC38__g181,ECL_NIL,Cblock,0); T0 = v1; } - T1 = cl_listX(3, ECL_SYM("INITFUNCTION",999), T0, VVtemp[101]); + T1 = cl_listX(3, ECL_SYM("INITFUNCTION",997), T0, VVtemp[97]); T2 = ecl_list1(T1); - clos_load_defclass(VV[43], VVtemp[100], T2, ECL_NIL); + clos_load_defclass(VV[42], VVtemp[96], T2, ECL_NIL); } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LOCATION",1862), VVtemp[102], VVtemp[103]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[45], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[104]) /* ANNOTATE */; - ecl_cmp_defun(VV[91]); /* EXTREMUM */ - ecl_function_dispatch(cl_env_copy,VV[48])(3, VV[45], ECL_SYM("FUNCTION",398), VVtemp[105]) /* SET-DOCUMENTATION */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LOCATION",1777), VVtemp[98], VVtemp[99]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[100]) /* ANNOTATE */; + ecl_cmp_defun(VV[87]); /* EXTREMUM */ + si_set_documentation(3, VV[44], ECL_SYM("FUNCTION",396), VVtemp[101]); } diff --git a/lib/alexandria/strings.cxx b/lib/alexandria/strings.cxx index db38415..b314996 100644 --- a/lib/alexandria/strings.cxx +++ b/lib/alexandria/strings.cxx @@ -1,21 +1,20 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/strings.lisp */ +/* Source: lib/alexandria/strings.lisp */ #include #include "lib/alexandria/strings.eclh" -/* local function LAMBDA2 */ +/* local function STRING-DESIGNATOR */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__lambda2(cl_object v1) +static cl_object LC1string_designator(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[3])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; value0 = VV[1]; cl_env_copy->nvalues = 1; @@ -27,7 +26,7 @@ L1:; #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclOk91d7g9HuD9M_CxEycC71(cl_object flag) +ECL_DLLEXPORT void _eclOk91d7g9HuD9M_m9g2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -42,22 +41,21 @@ ECL_DLLEXPORT void _eclOk91d7g9HuD9M_CxEycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/strings.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/strings.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclOk91d7g9HuD9M_CxEycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclOk91d7g9HuD9M_m9g2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[2])(3, VV[0], ECL_SYM("TYPE",871), VVtemp[1]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("TYPE",869), VVtemp[1]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC1__lambda2,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC1string_designator,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[0], VVtemp[2], T0); diff --git a/lib/alexandria/symbols.cxx b/lib/alexandria/symbols.cxx index 586d712..5476529 100644 --- a/lib/alexandria/symbols.cxx +++ b/lib/alexandria/symbols.cxx @@ -1,7 +1,7 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/symbols.lisp */ +/* Source: lib/alexandria/symbols.lisp */ #include #include "lib/alexandria/symbols.eclh" /* function definition for ENSURE-SYMBOL */ @@ -9,7 +9,6 @@ static cl_object L1ensure_symbol(cl_narg narg, cl_object v1name, ...) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -21,7 +20,7 @@ static cl_object L1ensure_symbol(cl_narg narg, cl_object v1name, ...) { int i = 1; if (i >= narg) { - v2package = ecl_symbol_value(ECL_SYM("*PACKAGE*",45)); + v2package = ecl_symbol_value(ECL_SYM("*PACKAGE*",43)); } else { i++; v2package = va_arg(args,cl_object); @@ -38,7 +37,6 @@ static cl_object L1ensure_symbol(cl_narg narg, cl_object v1name, ...) static cl_object L2maybe_intern(cl_object v1name, cl_object v2package) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -46,7 +44,7 @@ static cl_object L2maybe_intern(cl_object v1name, cl_object v2package) TTL: if (Null(v2package)) { goto L2; } if (!((ECL_T)==(v2package))) { goto L5; } - T0 = ecl_symbol_value(ECL_SYM("*PACKAGE*",45)); + T0 = ecl_symbol_value(ECL_SYM("*PACKAGE*",43)); goto L4; L5:; T0 = v2package; @@ -65,7 +63,6 @@ L1:; static cl_object L3format_symbol(cl_narg narg, cl_object v1package, cl_object v2control, ...) { cl_object T0, T1, T2; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -77,13 +74,13 @@ static cl_object L3format_symbol(cl_narg narg, cl_object v1package, cl_object v2 ecl_va_end(args); { cl_object v4; - v4 = ecl_symbol_value(ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1798)); + v4 = ecl_symbol_value(ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1732)); { cl_object v6, v7; cl_index v5; - v6 = ECL_CONS_CAR(v4); - v7 = ECL_CONS_CDR(v4); + v6 = _ecl_car(v4); + v7 = _ecl_cdr(v4); v5 = ecl_progv(cl_env_copy, v6, v7); - T1 = (ECL_SYM("FORMAT",389)->symbol.gfdef); + T1 = (ECL_SYM("FORMAT",387)->symbol.gfdef); T2 = cl_string(v2control); T0 = cl_apply(4, T1, ECL_NIL, T2, v3arguments); ecl_bds_unwind(cl_env_copy,v5); @@ -98,7 +95,6 @@ static cl_object L3format_symbol(cl_narg narg, cl_object v1package, cl_object v2 static cl_object L4make_keyword(cl_object v1name) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -114,7 +110,6 @@ static cl_object L4make_keyword(cl_object v1name) static cl_object L5make_gensym(cl_object v1name) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -125,7 +120,7 @@ static cl_object L5make_gensym(cl_object v1name) v2 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v1name)||ECL_BIGNUMP(v1name))) { goto L2; } v2 = v1name; - if (!(ecl_greatereq(v2,ecl_make_fixnum(0)))) { goto L2; } + if (!(ecl_number_compare(v2,ecl_make_fixnum(0))>=0)) { goto L2; } } T0 = v1name; goto L1; @@ -141,7 +136,6 @@ L1:; static cl_object L6make_gensym_list(cl_narg narg, cl_object v1length, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -167,7 +161,7 @@ static cl_object L6make_gensym_list(cl_narg narg, cl_object v1length, ...) v4 = ecl_make_fixnum(0); if (!(ECL_FIXNUMP(v2x)||ECL_BIGNUMP(v2x))) { goto L3; } v4 = v2x; - if (!(ecl_greatereq(v4,ecl_make_fixnum(0)))) { goto L3; } + if (!(ecl_number_compare(v4,ecl_make_fixnum(0))>=0)) { goto L3; } } v3g = v2x; goto L2; @@ -181,9 +175,7 @@ L2:; v5 = v1length; T0 = cl_realp(v5); if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",705),v5); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; + FEwrong_type_argument(ECL_SYM("REAL",703),v5); v4 = v5; } { @@ -201,8 +193,6 @@ L16:; cl_object v7; v7 = v6; if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); - value0 = ECL_NIL; - cl_env_copy->nvalues = 0; T0 = v7; } T1 = cl_gensym(1, v3g); @@ -223,7 +213,6 @@ L15:; static cl_object L8symbolicate(cl_narg narg, ...) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -235,14 +224,14 @@ static cl_object L8symbolicate(cl_narg narg, ...) { cl_object v2length; cl_object v3name; - T0 = (ECL_SYM("+",16)->symbol.gfdef); + T0 = (ECL_SYM("+",14)->symbol.gfdef); { cl_object v4; - v4 = ecl_make_cfun((cl_objectfn_fixed)LC7__lambda15,ECL_NIL,Cblock,1); + v4 = ecl_make_cfun((cl_objectfn_fixed)LC7__g15,ECL_NIL,Cblock,1); T1 = v4; } - v2length = cl_reduce(4, T0, v1things, ECL_SYM("KEY",1294), T1); - v3name = si_make_pure_array(ECL_SYM("CHARACTER",224), v2length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); + v2length = cl_reduce(4, T0, v1things, ECL_SYM("KEY",1267), T1); + v3name = si_make_pure_array(ECL_SYM("CHARACTER",222), v2length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); { cl_object v4index; v4index = ecl_make_fixnum(0); @@ -259,7 +248,7 @@ L8:; cl_fixnum v8len; v7x = cl_string(v6thing); v8len = ecl_length(v7x); - cl_replace(4, v3name, v7x, ECL_SYM("START1",1345), v4index); + cl_replace(4, v3name, v7x, ECL_SYM("START1",1316), v4index); v4index = ecl_plus(v4index,ecl_make_fixnum(v8len)); } } @@ -276,12 +265,11 @@ L20:; } } } -/* local function LAMBDA15 */ +/* local function G15 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__lambda15(cl_object v1x) +static cl_object LC7__g15(cl_object v1x) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -298,7 +286,7 @@ static cl_object LC7__lambda15(cl_object v1x) #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _ecljVTgFlYFBNMEM_qiFycC71(cl_object flag) +ECL_DLLEXPORT void _ecljVTgFlYFBNMEM_6gg2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -313,44 +301,42 @@ ECL_DLLEXPORT void _ecljVTgFlYFBNMEM_qiFycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/symbols.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/symbols.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecljVTgFlYFBNMEM_qiFycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecljVTgFlYFBNMEM_6gg2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LOCATION",1862), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[0], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[4]) /* ANNOTATE */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; ecl_cmp_defun(VV[9]); /* ENSURE-SYMBOL */ - ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[0], ECL_SYM("FUNCTION",398), VVtemp[5]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[0], ECL_SYM("INLINE",436), VVtemp[6]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LOCATION",1862), VVtemp[7], VVtemp[8]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[1], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[9]) /* ANNOTATE */; - ecl_cmp_defun(VV[11]); /* MAYBE-INTERN */ - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[10]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LOCATION",1862), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[2], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[13]) /* ANNOTATE */; - ecl_cmp_defun(VV[12]); /* FORMAT-SYMBOL */ - ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[2], ECL_SYM("FUNCTION",398), VVtemp[14]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[2], ECL_SYM("INLINE",436), VVtemp[15]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LOCATION",1862), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[3], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[13]); /* MAKE-KEYWORD */ - ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[3], ECL_SYM("FUNCTION",398), VVtemp[19]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[5], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[14]); /* MAKE-GENSYM */ - ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[5], ECL_SYM("FUNCTION",398), VVtemp[22]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[23], VVtemp[24]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defun(VV[15]); /* MAKE-GENSYM-LIST */ - ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[6], ECL_SYM("FUNCTION",398), VVtemp[26]) /* SET-DOCUMENTATION */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defun(VV[16]); /* SYMBOLICATE */ - ecl_function_dispatch(cl_env_copy,VV[10])(3, VV[8], ECL_SYM("FUNCTION",398), VVtemp[30]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; + ecl_cmp_defun(VV[10]); /* MAYBE-INTERN */ + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[9]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[12]) /* ANNOTATE */; + ecl_cmp_defun(VV[11]); /* FORMAT-SYMBOL */ + si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[13]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[12]); /* MAKE-KEYWORD */ + si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[17]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[13]); /* MAKE-GENSYM */ + si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[20]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; + ecl_cmp_defun(VV[14]); /* MAKE-GENSYM-LIST */ + si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[24]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[27]) /* ANNOTATE */; + ecl_cmp_defun(VV[15]); /* SYMBOLICATE */ + si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[28]); } diff --git a/lib/alexandria/types.cxx b/lib/alexandria/types.cxx index 40a7ca4..8e239bd 100644 --- a/lib/alexandria/types.cxx +++ b/lib/alexandria/types.cxx @@ -1,15 +1,14 @@ -/* Compiler: ECL 24.5.10 */ -/* Date: 2024/7/24 06:55 (yyyy/mm/dd) */ +/* Compiler: ECL 16.1.2 */ +/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ /* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: /home/packer/ws/github/kisp/asgl/lib/alexandria/types.lisp */ +/* Source: lib/alexandria/types.lisp */ #include #include "lib/alexandria/types.eclh" -/* local function LAMBDA2 */ +/* local function ARRAY-INDEX */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__lambda2(cl_object v1) +static cl_object LC1array_index(cl_object v1) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -31,19 +30,18 @@ L3:; v3length = ecl_make_fixnum(2305843009213693950); L2:; if (Null(v2)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; T0 = ecl_list1(v3length); - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), T0); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), T0); return value0; } } } -/* local function LAMBDA6 */ +/* local function ARRAY-LENGTH */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__lambda6(cl_object v1) +static cl_object LC2array_length(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -65,78 +63,74 @@ L3:; v3length = ecl_make_fixnum(2305843009213693950); L2:; if (Null(v2)) { goto L8; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L8:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), v3length); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), v3length); return value0; } } } -/* local function LAMBDA37 */ +/* local function NEGATIVE-FIXNUM */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3__lambda37(cl_object v1) +static cl_object LC3negative_fixnum(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(-1)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(-1)); return value0; } } -/* local function LAMBDA40 */ +/* local function NON-POSITIVE-FIXNUM */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__lambda40(cl_object v1) +static cl_object LC4non_positive_fixnum(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(0)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(0)); return value0; } } -/* local function LAMBDA43 */ +/* local function NON-NEGATIVE-FIXNUM */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5__lambda43(cl_object v1) +static cl_object LC5non_negative_fixnum(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), ecl_make_fixnum(2305843009213693951)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), ecl_make_fixnum(2305843009213693951)); return value0; } } -/* local function LAMBDA46 */ +/* local function POSITIVE-FIXNUM */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6__lambda46(cl_object v1) +static cl_object LC6positive_fixnum(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(1), ecl_make_fixnum(2305843009213693951)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(1), ecl_make_fixnum(2305843009213693951)); return value0; } } @@ -144,14 +138,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L7negative_fixnum_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -164,14 +157,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L8non_positive_fixnum_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -184,14 +176,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L9non_negative_fixnum_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -204,14 +195,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L10positive_fixnum_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -220,71 +210,67 @@ L2:; return value0; } } -/* local function LAMBDA49 */ +/* local function NEGATIVE-INTEGER */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__lambda49(cl_object v1) +static cl_object LC11negative_integer(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ECL_SYM("*",20), ecl_make_fixnum(-1)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ECL_SYM("*",18), ecl_make_fixnum(-1)); return value0; } } -/* local function LAMBDA52 */ +/* local function NON-POSITIVE-INTEGER */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12__lambda52(cl_object v1) +static cl_object LC12non_positive_integer(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ECL_SYM("*",20), ecl_make_fixnum(0)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ECL_SYM("*",18), ecl_make_fixnum(0)); return value0; } } -/* local function LAMBDA55 */ +/* local function NON-NEGATIVE-INTEGER */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13__lambda55(cl_object v1) +static cl_object LC13non_negative_integer(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(0), ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA58 */ +/* local function POSITIVE-INTEGER */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14__lambda58(cl_object v1) +static cl_object LC14positive_integer(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",439), ecl_make_fixnum(1), ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(1), ECL_SYM("*",18)); return value0; } } @@ -292,14 +278,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L15negative_integer_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -312,14 +297,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L16non_positive_integer_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -332,14 +316,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L17non_negative_integer_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -352,14 +335,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L18positive_integer_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -368,71 +350,67 @@ L2:; return value0; } } -/* local function LAMBDA61 */ +/* local function NEGATIVE-RATIONAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19__lambda61(cl_object v1) +static cl_object LC19negative_rational(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",689), ECL_SYM("*",20), VV[19]); + value0 = cl_list(3, ECL_SYM("RATIONAL",687), ECL_SYM("*",18), VV[19]); return value0; } } -/* local function LAMBDA64 */ +/* local function NON-POSITIVE-RATIONAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC20__lambda64(cl_object v1) +static cl_object LC20non_positive_rational(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",689), ECL_SYM("*",20), ecl_make_fixnum(0)); + value0 = cl_list(3, ECL_SYM("RATIONAL",687), ECL_SYM("*",18), ecl_make_fixnum(0)); return value0; } } -/* local function LAMBDA67 */ +/* local function NON-NEGATIVE-RATIONAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC21__lambda67(cl_object v1) +static cl_object LC21non_negative_rational(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",689), ecl_make_fixnum(0), ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("RATIONAL",687), ecl_make_fixnum(0), ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA70 */ +/* local function POSITIVE-RATIONAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC22__lambda70(cl_object v1) +static cl_object LC22positive_rational(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",689), VV[19], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("RATIONAL",687), VV[19], ECL_SYM("*",18)); return value0; } } @@ -440,14 +418,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L23negative_rational_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -460,14 +437,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L24non_positive_rational_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -480,14 +456,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L25non_negative_rational_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -500,14 +475,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L26positive_rational_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -516,71 +490,67 @@ L2:; return value0; } } -/* local function LAMBDA73 */ +/* local function NEGATIVE-REAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC27__lambda73(cl_object v1) +static cl_object LC27negative_real(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("REAL",705), ECL_SYM("*",20), VV[19]); + value0 = cl_list(3, ECL_SYM("REAL",703), ECL_SYM("*",18), VV[19]); return value0; } } -/* local function LAMBDA76 */ +/* local function NON-POSITIVE-REAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC28__lambda76(cl_object v1) +static cl_object LC28non_positive_real(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("REAL",705), ECL_SYM("*",20), ecl_make_fixnum(0)); + value0 = cl_list(3, ECL_SYM("REAL",703), ECL_SYM("*",18), ecl_make_fixnum(0)); return value0; } } -/* local function LAMBDA79 */ +/* local function NON-NEGATIVE-REAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC29__lambda79(cl_object v1) +static cl_object LC29non_negative_real(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("REAL",705), ecl_make_fixnum(0), ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("REAL",703), ecl_make_fixnum(0), ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA82 */ +/* local function POSITIVE-REAL */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC30__lambda82(cl_object v1) +static cl_object LC30positive_real(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("REAL",705), VV[19], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("REAL",703), VV[19], ECL_SYM("*",18)); return value0; } } @@ -588,14 +558,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L31negative_real_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -608,14 +577,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L32non_positive_real_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,ecl_make_fixnum(0))); + value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -628,14 +596,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L33non_negative_real_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -648,14 +615,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L34positive_real_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(ecl_make_fixnum(0),v1n)); + value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -664,71 +630,67 @@ L2:; return value0; } } -/* local function LAMBDA85 */ +/* local function NEGATIVE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC35__lambda85(cl_object v1) +static cl_object LC35negative_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",376), ECL_SYM("*",20), VV[36]); + value0 = cl_list(3, ECL_SYM("FLOAT",374), ECL_SYM("*",18), VV[36]); return value0; } } -/* local function LAMBDA88 */ +/* local function NON-POSITIVE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC36__lambda88(cl_object v1) +static cl_object LC36non_positive_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",376), ECL_SYM("*",20), cl_core.singlefloat_zero); + value0 = cl_list(3, ECL_SYM("FLOAT",374), ECL_SYM("*",18), cl_core.singlefloat_zero); return value0; } } -/* local function LAMBDA91 */ +/* local function NON-NEGATIVE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC37__lambda91(cl_object v1) +static cl_object LC37non_negative_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",376), cl_core.singlefloat_zero, ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("FLOAT",374), cl_core.singlefloat_zero, ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA94 */ +/* local function POSITIVE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC38__lambda94(cl_object v1) +static cl_object LC38positive_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",376), VV[36], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("FLOAT",374), VV[36], ECL_SYM("*",18)); return value0; } } @@ -736,14 +698,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L39negative_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,cl_core.singlefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -756,14 +717,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L40non_positive_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.singlefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -776,14 +736,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L41non_negative_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(cl_core.singlefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -796,14 +755,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L42positive_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(cl_core.singlefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -812,71 +770,67 @@ L2:; return value0; } } -/* local function LAMBDA97 */ +/* local function NEGATIVE-SHORT-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC43__lambda97(cl_object v1) +static cl_object LC43negative_short_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), ECL_SYM("*",20), VV[36]); + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), ECL_SYM("*",18), VV[36]); return value0; } } -/* local function LAMBDA100 */ +/* local function NON-POSITIVE-SHORT-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC44__lambda100(cl_object v1) +static cl_object LC44non_positive_short_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), ECL_SYM("*",20), cl_core.singlefloat_zero); + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), ECL_SYM("*",18), cl_core.singlefloat_zero); return value0; } } -/* local function LAMBDA103 */ +/* local function NON-NEGATIVE-SHORT-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC45__lambda103(cl_object v1) +static cl_object LC45non_negative_short_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), cl_core.singlefloat_zero, ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), cl_core.singlefloat_zero, ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA106 */ +/* local function POSITIVE-SHORT-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC46__lambda106(cl_object v1) +static cl_object LC46positive_short_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",758), VV[36], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), VV[36], ECL_SYM("*",18)); return value0; } } @@ -884,14 +838,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L47negative_short_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,cl_core.singlefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -904,14 +857,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L48non_positive_short_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.singlefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -924,14 +876,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L49non_negative_short_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(cl_core.singlefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -944,14 +895,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L50positive_short_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(cl_core.singlefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -960,71 +910,67 @@ L2:; return value0; } } -/* local function LAMBDA109 */ +/* local function NEGATIVE-SINGLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC51__lambda109(cl_object v1) +static cl_object LC51negative_single_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), ECL_SYM("*",20), VV[36]); + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), ECL_SYM("*",18), VV[36]); return value0; } } -/* local function LAMBDA112 */ +/* local function NON-POSITIVE-SINGLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC52__lambda112(cl_object v1) +static cl_object LC52non_positive_single_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), ECL_SYM("*",20), cl_core.singlefloat_zero); + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), ECL_SYM("*",18), cl_core.singlefloat_zero); return value0; } } -/* local function LAMBDA115 */ +/* local function NON-NEGATIVE-SINGLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC53__lambda115(cl_object v1) +static cl_object LC53non_negative_single_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), cl_core.singlefloat_zero, ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), cl_core.singlefloat_zero, ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA118 */ +/* local function POSITIVE-SINGLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC54__lambda118(cl_object v1) +static cl_object LC54positive_single_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",780), VV[36], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), VV[36], ECL_SYM("*",18)); return value0; } } @@ -1032,14 +978,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L55negative_single_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,cl_core.singlefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1052,14 +997,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L56non_positive_single_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.singlefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1072,14 +1016,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L57non_negative_single_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(cl_core.singlefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1092,14 +1035,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L58positive_single_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(cl_core.singlefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1108,71 +1050,67 @@ L2:; return value0; } } -/* local function LAMBDA121 */ +/* local function NEGATIVE-DOUBLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC59__lambda121(cl_object v1) +static cl_object LC59negative_double_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), ECL_SYM("*",20), VV[61]); + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), ECL_SYM("*",18), VV[61]); return value0; } } -/* local function LAMBDA124 */ +/* local function NON-POSITIVE-DOUBLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC60__lambda124(cl_object v1) +static cl_object LC60non_positive_double_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), ECL_SYM("*",20), cl_core.doublefloat_zero); + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), ECL_SYM("*",18), cl_core.doublefloat_zero); return value0; } } -/* local function LAMBDA127 */ +/* local function NON-NEGATIVE-DOUBLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC61__lambda127(cl_object v1) +static cl_object LC61non_negative_double_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), cl_core.doublefloat_zero, ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), cl_core.doublefloat_zero, ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA130 */ +/* local function POSITIVE-DOUBLE-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC62__lambda130(cl_object v1) +static cl_object LC62positive_double_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",317), VV[61], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), VV[61], ECL_SYM("*",18)); return value0; } } @@ -1180,14 +1118,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L63negative_double_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,cl_core.doublefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.doublefloat_zero)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1200,14 +1137,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L64non_positive_double_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.doublefloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.doublefloat_zero)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1220,14 +1156,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L65non_negative_double_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(cl_core.doublefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.doublefloat_zero,v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1240,14 +1175,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L66positive_double_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(cl_core.doublefloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.doublefloat_zero,v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1256,71 +1190,67 @@ L2:; return value0; } } -/* local function LAMBDA133 */ +/* local function NEGATIVE-LONG-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC67__lambda133(cl_object v1) +static cl_object LC67negative_long_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), ECL_SYM("*",20), VV[70]); + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), ECL_SYM("*",18), VV[70]); return value0; } } -/* local function LAMBDA136 */ +/* local function NON-POSITIVE-LONG-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC68__lambda136(cl_object v1) +static cl_object LC68non_positive_long_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), ECL_SYM("*",20), cl_core.longfloat_zero); + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), ECL_SYM("*",18), cl_core.longfloat_zero); return value0; } } -/* local function LAMBDA139 */ +/* local function NON-NEGATIVE-LONG-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC69__lambda139(cl_object v1) +static cl_object LC69non_negative_long_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), cl_core.longfloat_zero, ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), cl_core.longfloat_zero, ECL_SYM("*",18)); return value0; } } -/* local function LAMBDA142 */ +/* local function POSITIVE-LONG-FLOAT */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC70__lambda142(cl_object v1) +static cl_object LC70positive_long_float(cl_object v1) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (Null(v1)) { goto L1; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",510), VV[70], ECL_SYM("*",20)); + value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), VV[70], ECL_SYM("*",18)); return value0; } } @@ -1328,14 +1258,13 @@ L1:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L71negative_long_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(v1n,cl_core.longfloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.longfloat_zero)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1348,14 +1277,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L72non_positive_long_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(v1n,cl_core.longfloat_zero)); + value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.longfloat_zero)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1368,14 +1296,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L73non_negative_long_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lowereq(cl_core.longfloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.longfloat_zero,v1n)<=0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1388,14 +1315,13 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L74positive_long_float_p(cl_object v1n) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); { TTL: if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_lower(cl_core.longfloat_zero,v1n)); + value0 = ecl_make_bool(ecl_number_compare(cl_core.longfloat_zero,v1n)<0); cl_env_copy->nvalues = 1; return value0; L2:; @@ -1408,7 +1334,7 @@ L2:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L76of_type(cl_object v1type) { - cl_object env0 = ECL_NIL; + cl_object env0; cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1418,16 +1344,16 @@ static cl_object L76of_type(cl_object v1type) CLV0 = env0 = CONS(v1type,env0); /* TYPE */ { cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC75__lambda143,env0,Cblock,1); + v2 = ecl_make_cclosure_va((cl_objectfn)LC75__g105,env0,Cblock); value0 = v2; cl_env_copy->nvalues = 1; return value0; } } } -/* closure LAMBDA143 */ +/* closure G105 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC75__lambda143(cl_narg narg, cl_object v1thing, ...) +static cl_object LC75__g105(cl_narg narg, cl_object v1thing, ...) { cl_object CLV0; const cl_env_ptr cl_env_copy = ecl_process_env(); @@ -1445,12 +1371,11 @@ static cl_object LC75__lambda143(cl_narg narg, cl_object v1thing, ...) } } } -/* local function LAMBDA146 */ +/* local function OF-TYPE */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC77__lambda146(cl_object v1, cl_object v2env) +static cl_object LC77of_type(cl_object v1, cl_object v2env) { cl_object T0, T1; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1460,16 +1385,16 @@ static cl_object LC77__lambda146(cl_object v1, cl_object v2env) cl_object v3; cl_object v4type; T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",396)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",398)))) { goto L2; } + if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } v3 = ecl_cddr(v1); goto L1; L2:; v3 = ecl_cdr(v1); L1:; if (!(v3==ECL_NIL)) { goto L6; } - ecl_function_dispatch(cl_env_copy,VV[122])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L6:; { cl_object v5; @@ -1478,15 +1403,15 @@ L6:; v4type = v5; } if (Null(v3)) { goto L11; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L11:; if (Null(cl_constantp(2, v4type, v2env))) { goto L13; } { cl_object v5thing; v5thing = cl_gensym(1, VV[79]); T0 = ecl_list1(v5thing); - T1 = cl_list(3, ECL_SYM("TYPEP",877), v5thing, v4type); - value0 = cl_list(3, ECL_SYM("LAMBDA",454), T0, T1); + T1 = cl_list(3, ECL_SYM("TYPEP",875), v5thing, v4type); + value0 = cl_list(3, ECL_SYM("LAMBDA",452), T0, T1); return value0; } L13:; @@ -1500,7 +1425,6 @@ L13:; /* optimize speed 3, debug 0, space 0, safety 2 */ static cl_object L78type_(cl_object v1type1, cl_object v2type2) { - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1510,10 +1434,8 @@ static cl_object L78type_(cl_object v1type1, cl_object v2type2) cl_object v4; /* SUB */ cl_object v5; /* OK */ value0 = cl_subtypep(2, v1type1, v2type2); - { - v4 = value0; - v5 = cl_env_copy->values[1]; - } + v4 = value0; + v5 = cl_env_copy->values[1]; if (Null(v5)) { goto L2; } if (Null(v4)) { goto L2; } value0 = cl_subtypep(2, v2type2, v1type1); @@ -1528,9 +1450,7 @@ L5:; { cl_object v7; /* OK */ value0 = cl_subtypep(2, v2type2, v1type1); - { - v7 = cl_env_copy->values[1]; - } + v7 = cl_env_copy->values[1]; cl_env_copy->nvalues = 2; cl_env_copy->values[1] = v7; cl_env_copy->values[0] = ECL_NIL; @@ -1544,7 +1464,6 @@ L5:; static cl_object LC80coercef(cl_object v1, cl_object v2si__env) { cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1556,7 +1475,7 @@ static cl_object LC80coercef(cl_object v1, cl_object v2si__env) cl_object v5type_spec; v3 = ecl_cdr(v1); if (!(v3==ECL_NIL)) { goto L3; } - ecl_function_dispatch(cl_env_copy,VV[122])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L3:; { cl_object v6; @@ -1565,7 +1484,7 @@ L3:; v4si___reference = v6; } if (!(v3==ECL_NIL)) { goto L9; } - ecl_function_dispatch(cl_env_copy,VV[122])(1, v1) /* DM-TOO-FEW-ARGUMENTS */; + si_dm_too_few_arguments(v1); L9:; { cl_object v6; @@ -1574,7 +1493,7 @@ L9:; v5type_spec = v6; } if (Null(v3)) { goto L14; } - ecl_function_dispatch(cl_env_copy,VV[84])(1, v1) /* DM-TOO-MANY-ARGUMENTS */; + si_dm_too_many_arguments(v1); L14:; { cl_object v7; /* VARS */ @@ -1582,33 +1501,31 @@ L14:; cl_object v9; /* STORES */ cl_object v10; /* SETTER */ cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",412)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - { - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - } + value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; + v7 = value0; + v8 = cl_env_copy->values[1]; + v9 = cl_env_copy->values[2]; + v10 = cl_env_copy->values[3]; + v11 = cl_env_copy->values[4]; { cl_object v12si__all_vars; { cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC79__lambda154,ECL_NIL,Cblock,1); + v13 = ecl_make_cfun((cl_objectfn_fixed)LC79__g115,ECL_NIL,Cblock,1); T0 = v13; } T1 = CONS(v5type_spec,ECL_NIL); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; + v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; if (!(ECL_SYMBOLP(v11))) { goto L19; } - T0 = (ECL_SYM("CAR",182)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("COERCE",233), v11, T1); + T0 = (ECL_SYM("CAR",180)->symbol.gfdef); + T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; + T2 = cl_listX(3, ECL_SYM("COERCE",231), v11, T1); T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; + T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; T6 = CONS(VV[82],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",276), T6); - T8 = cl_list(4, ECL_SYM("LET*",480), v12si__all_vars, T7, v10); + T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); + T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); value0 = cl_subst(3, T2, T3, T8); return value0; L19:; @@ -1640,19 +1557,28 @@ L28:; goto L27; L34:; T0 = ecl_car(v9); - T1 = (ECL_SYM("CAR",182)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = cl_listX(3, ECL_SYM("COERCE",233), v11, T2); - T4 = cl_list(2, T0, T3); - T5 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T4,T5); + if (!(ECL_LISTP(v4si___reference))) { goto L39; } + T2 = ecl_car(v4si___reference); + if (!((T2)==(ECL_SYM("THE",856)))) { goto L39; } + T2 = ecl_cadr(v4si___reference); + T3 = cl_listX(4, ECL_SYM("COERCE",231), v11, v5type_spec, ECL_NIL); + T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); + goto L38; +L39:; + T2 = (ECL_SYM("CAR",180)->symbol.gfdef); + T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; + T1 = cl_listX(3, ECL_SYM("COERCE",231), v11, T3); +L38:; + T2 = cl_list(2, T0, T1); + T3 = ecl_append(v12si__all_vars,v15si__let_list); + v15si__let_list = CONS(T2,T3); T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",373)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",547)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; + T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); + T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; T3 = ecl_append(T2,v7); T4 = CONS(VV[82],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",276), T4); - value0 = cl_list(4, ECL_SYM("LET*",480), T0, T5, v10); + T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); + value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); return value0; } } @@ -1660,12 +1586,11 @@ L34:; } } } -/* local function LAMBDA154 */ +/* local function G115 */ /* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC79__lambda154(cl_object v1si__v) +static cl_object LC79__g115(cl_object v1si__v) { cl_object T0; - cl_object env0 = ECL_NIL; const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; ecl_cs_check(cl_env_copy,value0); @@ -1681,7 +1606,7 @@ static cl_object LC79__lambda154(cl_object v1si__v) #ifdef __cplusplus extern "C" #endif -ECL_DLLEXPORT void _eclYKIWc8zWYNLAM_M2HycC71(cl_object flag) +ECL_DLLEXPORT void _eclYKIWc8zWYNLAM_kSh2dC71(cl_object flag) { const cl_env_ptr cl_env_copy = ecl_process_env(); cl_object value0; @@ -1696,469 +1621,428 @@ ECL_DLLEXPORT void _eclYKIWc8zWYNLAM_M2HycC71(cl_object flag) flag->cblock.data_text = compiler_data_text; flag->cblock.cfuns_size = compiler_cfuns_size; flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = ecl_make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/types.lisp",-1); + flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/types.lisp"); return;} #ifdef ECL_DYNAMIC_VV VV = Cblock->cblock.data; #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclYKIWc8zWYNLAM_M2HycC71@"; + Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclYKIWc8zWYNLAM_kSh2dC71@"; VVtemp = Cblock->cblock.temp_data; ECL_DEFINE_SETF_FUNCTIONS si_select_package(VVtemp[0]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[0], ECL_SYM("TYPE",871), VVtemp[1]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[0], ECL_SYM("TYPE",869), VVtemp[1]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC1__lambda2,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC1array_index,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[0], VVtemp[2], T0); } { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[1], ECL_SYM("TYPE",871), VVtemp[3]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[1], ECL_SYM("TYPE",869), VVtemp[3]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC2__lambda6,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC2array_length,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[1], VVtemp[4], T0); } { cl_object T0; - cl_object volatile env0 = ECL_NIL; - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[2], ECL_SYM("TYPE",871), VVtemp[5]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[2], ECL_SYM("TYPE",869), VVtemp[5]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC3__lambda37,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC3negative_fixnum,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[2], VVtemp[6], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[3], ECL_SYM("TYPE",871), VVtemp[7]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[3], ECL_SYM("TYPE",869), VVtemp[7]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC4__lambda40,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC4non_positive_fixnum,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[3], VVtemp[8], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[4], ECL_SYM("TYPE",871), VVtemp[9]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[4], ECL_SYM("TYPE",869), VVtemp[9]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC5__lambda43,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC5non_negative_fixnum,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[4], VVtemp[10], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[5], ECL_SYM("TYPE",871), VVtemp[11]) /* SET-DOCUMENTATION */; + si_set_documentation(3, VV[5], ECL_SYM("TYPE",869), VVtemp[11]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC6__lambda46,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC6positive_fixnum,ECL_NIL,Cblock,1); T0 = v1; } si_do_deftype(3, VV[5], VVtemp[12], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[13]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LOCATION",1862), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[6], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[85]); /* NEGATIVE-FIXNUM-P */ - si_put_sysprop(VV[6], ECL_SYM("INLINE",436), VVtemp[17]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LOCATION",1862), VVtemp[18], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[7], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[86]); /* NON-POSITIVE-FIXNUM-P */ - si_put_sysprop(VV[7], ECL_SYM("INLINE",436), VVtemp[19]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LOCATION",1862), VVtemp[20], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[8], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[87]); /* NON-NEGATIVE-FIXNUM-P */ - si_put_sysprop(VV[8], ECL_SYM("INLINE",436), VVtemp[21]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LOCATION",1862), VVtemp[22], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[9], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[88]); /* POSITIVE-FIXNUM-P */ - si_put_sysprop(VV[9], ECL_SYM("INLINE",436), VVtemp[23]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[10], ECL_SYM("TYPE",871), VVtemp[24]) /* SET-DOCUMENTATION */; + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[13]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[83]); /* NEGATIVE-FIXNUM-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[17], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[84]); /* NON-POSITIVE-FIXNUM-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[85]); /* NON-NEGATIVE-FIXNUM-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[19], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[86]); /* POSITIVE-FIXNUM-P */ + si_set_documentation(3, VV[10], ECL_SYM("TYPE",869), VVtemp[20]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC11__lambda49,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC11negative_integer,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[10], VVtemp[25], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[11], ECL_SYM("TYPE",871), VVtemp[26]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[10], VVtemp[21], T0); + si_set_documentation(3, VV[11], ECL_SYM("TYPE",869), VVtemp[22]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC12__lambda52,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC12non_positive_integer,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[11], VVtemp[27], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[12], ECL_SYM("TYPE",871), VVtemp[28]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[11], VVtemp[23], T0); + si_set_documentation(3, VV[12], ECL_SYM("TYPE",869), VVtemp[24]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC13__lambda55,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC13non_negative_integer,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[12], VVtemp[29], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[13], ECL_SYM("TYPE",871), VVtemp[30]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[12], VVtemp[25], T0); + si_set_documentation(3, VV[13], ECL_SYM("TYPE",869), VVtemp[26]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC14__lambda58,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC14positive_integer,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[13], VVtemp[31], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[32]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LOCATION",1862), VVtemp[33], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[14], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[89]); /* NEGATIVE-INTEGER-P */ - si_put_sysprop(VV[14], ECL_SYM("INLINE",436), VVtemp[34]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LOCATION",1862), VVtemp[35], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[15], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[90]); /* NON-POSITIVE-INTEGER-P */ - si_put_sysprop(VV[15], ECL_SYM("INLINE",436), VVtemp[36]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LOCATION",1862), VVtemp[37], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[16], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[91]); /* NON-NEGATIVE-INTEGER-P */ - si_put_sysprop(VV[16], ECL_SYM("INLINE",436), VVtemp[38]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LOCATION",1862), VVtemp[39], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[17], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[92]); /* POSITIVE-INTEGER-P */ - si_put_sysprop(VV[17], ECL_SYM("INLINE",436), VVtemp[40]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[18], ECL_SYM("TYPE",871), VVtemp[41]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[13], VVtemp[27], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[28]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[29], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[87]); /* NEGATIVE-INTEGER-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[88]); /* NON-POSITIVE-INTEGER-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[89]); /* NON-NEGATIVE-INTEGER-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[32], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[90]); /* POSITIVE-INTEGER-P */ + si_set_documentation(3, VV[18], ECL_SYM("TYPE",869), VVtemp[33]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC19__lambda61,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC19negative_rational,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[18], VVtemp[42], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[20], ECL_SYM("TYPE",871), VVtemp[41]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[18], VVtemp[34], T0); + si_set_documentation(3, VV[20], ECL_SYM("TYPE",869), VVtemp[33]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC20__lambda64,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC20non_positive_rational,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[20], VVtemp[43], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[21], ECL_SYM("TYPE",871), VVtemp[44]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[20], VVtemp[35], T0); + si_set_documentation(3, VV[21], ECL_SYM("TYPE",869), VVtemp[36]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC21__lambda67,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC21non_negative_rational,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[21], VVtemp[45], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[22], ECL_SYM("TYPE",871), VVtemp[44]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[21], VVtemp[37], T0); + si_set_documentation(3, VV[22], ECL_SYM("TYPE",869), VVtemp[36]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC22__lambda70,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC22positive_rational,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[22], VVtemp[46], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[47]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LOCATION",1862), VVtemp[48], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[23], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[93]); /* NEGATIVE-RATIONAL-P */ - si_put_sysprop(VV[23], ECL_SYM("INLINE",436), VVtemp[49]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LOCATION",1862), VVtemp[50], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[24], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[94]); /* NON-POSITIVE-RATIONAL-P */ - si_put_sysprop(VV[24], ECL_SYM("INLINE",436), VVtemp[51]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LOCATION",1862), VVtemp[52], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[25], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[95]); /* NON-NEGATIVE-RATIONAL-P */ - si_put_sysprop(VV[25], ECL_SYM("INLINE",436), VVtemp[53]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LOCATION",1862), VVtemp[54], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[26], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[96]); /* POSITIVE-RATIONAL-P */ - si_put_sysprop(VV[26], ECL_SYM("INLINE",436), VVtemp[55]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[27], ECL_SYM("TYPE",871), VVtemp[56]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[22], VVtemp[38], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[39]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[40], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[91]); /* NEGATIVE-RATIONAL-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LOCATION",1777), VVtemp[41], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[92]); /* NON-POSITIVE-RATIONAL-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[93]); /* NON-NEGATIVE-RATIONAL-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[43], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[94]); /* POSITIVE-RATIONAL-P */ + si_set_documentation(3, VV[27], ECL_SYM("TYPE",869), VVtemp[44]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC27__lambda73,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC27negative_real,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[27], VVtemp[57], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[28], ECL_SYM("TYPE",871), VVtemp[56]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[27], VVtemp[45], T0); + si_set_documentation(3, VV[28], ECL_SYM("TYPE",869), VVtemp[44]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC28__lambda76,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC28non_positive_real,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[28], VVtemp[58], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[29], ECL_SYM("TYPE",871), VVtemp[59]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[28], VVtemp[46], T0); + si_set_documentation(3, VV[29], ECL_SYM("TYPE",869), VVtemp[47]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC29__lambda79,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC29non_negative_real,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[29], VVtemp[60], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[30], ECL_SYM("TYPE",871), VVtemp[59]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[29], VVtemp[48], T0); + si_set_documentation(3, VV[30], ECL_SYM("TYPE",869), VVtemp[47]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC30__lambda82,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC30positive_real,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[30], VVtemp[61], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[62]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LOCATION",1862), VVtemp[63], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[31], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[97]); /* NEGATIVE-REAL-P */ - si_put_sysprop(VV[31], ECL_SYM("INLINE",436), VVtemp[64]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LOCATION",1862), VVtemp[65], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[32], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[98]); /* NON-POSITIVE-REAL-P */ - si_put_sysprop(VV[32], ECL_SYM("INLINE",436), VVtemp[66]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LOCATION",1862), VVtemp[67], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[33], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[99]); /* NON-NEGATIVE-REAL-P */ - si_put_sysprop(VV[33], ECL_SYM("INLINE",436), VVtemp[68]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LOCATION",1862), VVtemp[69], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[34], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[100]); /* POSITIVE-REAL-P */ - si_put_sysprop(VV[34], ECL_SYM("INLINE",436), VVtemp[70]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[35], ECL_SYM("TYPE",871), VVtemp[71]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[30], VVtemp[49], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[50]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LOCATION",1777), VVtemp[51], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[95]); /* NEGATIVE-REAL-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[96]); /* NON-POSITIVE-REAL-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LOCATION",1777), VVtemp[53], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[97]); /* NON-NEGATIVE-REAL-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LOCATION",1777), VVtemp[54], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[98]); /* POSITIVE-REAL-P */ + si_set_documentation(3, VV[35], ECL_SYM("TYPE",869), VVtemp[55]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC35__lambda85,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC35negative_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[35], VVtemp[72], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[37], ECL_SYM("TYPE",871), VVtemp[71]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[35], VVtemp[56], T0); + si_set_documentation(3, VV[37], ECL_SYM("TYPE",869), VVtemp[55]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC36__lambda88,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC36non_positive_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[37], VVtemp[73], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[38], ECL_SYM("TYPE",871), VVtemp[74]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[37], VVtemp[57], T0); + si_set_documentation(3, VV[38], ECL_SYM("TYPE",869), VVtemp[58]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC37__lambda91,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC37non_negative_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[38], VVtemp[75], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[39], ECL_SYM("TYPE",871), VVtemp[74]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[38], VVtemp[59], T0); + si_set_documentation(3, VV[39], ECL_SYM("TYPE",869), VVtemp[58]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC38__lambda94,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC38positive_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[39], VVtemp[76], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[77]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LOCATION",1862), VVtemp[78], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[40], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[101]); /* NEGATIVE-FLOAT-P */ - si_put_sysprop(VV[40], ECL_SYM("INLINE",436), VVtemp[79]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LOCATION",1862), VVtemp[80], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[41], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[102]); /* NON-POSITIVE-FLOAT-P */ - si_put_sysprop(VV[41], ECL_SYM("INLINE",436), VVtemp[81]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LOCATION",1862), VVtemp[82], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[42], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[103]); /* NON-NEGATIVE-FLOAT-P */ - si_put_sysprop(VV[42], ECL_SYM("INLINE",436), VVtemp[83]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LOCATION",1862), VVtemp[84], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[43], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[104]); /* POSITIVE-FLOAT-P */ - si_put_sysprop(VV[43], ECL_SYM("INLINE",436), VVtemp[85]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[44], ECL_SYM("TYPE",871), VVtemp[86]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[39], VVtemp[60], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[61]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LOCATION",1777), VVtemp[62], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[99]); /* NEGATIVE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[63], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[100]); /* NON-POSITIVE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LOCATION",1777), VVtemp[64], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[101]); /* NON-NEGATIVE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[43], ECL_SYM("LOCATION",1777), VVtemp[65], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[43], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[102]); /* POSITIVE-FLOAT-P */ + si_set_documentation(3, VV[44], ECL_SYM("TYPE",869), VVtemp[66]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC43__lambda97,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC43negative_short_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[44], VVtemp[87], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[45], ECL_SYM("TYPE",871), VVtemp[86]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[44], VVtemp[67], T0); + si_set_documentation(3, VV[45], ECL_SYM("TYPE",869), VVtemp[66]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC44__lambda100,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC44non_positive_short_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[45], VVtemp[88], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[46], ECL_SYM("TYPE",871), VVtemp[89]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[45], VVtemp[68], T0); + si_set_documentation(3, VV[46], ECL_SYM("TYPE",869), VVtemp[69]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC45__lambda103,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC45non_negative_short_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[46], VVtemp[90], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[47], ECL_SYM("TYPE",871), VVtemp[89]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[46], VVtemp[70], T0); + si_set_documentation(3, VV[47], ECL_SYM("TYPE",869), VVtemp[69]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC46__lambda106,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC46positive_short_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[47], VVtemp[91], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[92]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LOCATION",1862), VVtemp[93], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[48], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[105]); /* NEGATIVE-SHORT-FLOAT-P */ - si_put_sysprop(VV[48], ECL_SYM("INLINE",436), VVtemp[94]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LOCATION",1862), VVtemp[95], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[49], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[106]); /* NON-POSITIVE-SHORT-FLOAT-P */ - si_put_sysprop(VV[49], ECL_SYM("INLINE",436), VVtemp[96]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LOCATION",1862), VVtemp[97], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[50], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[107]); /* NON-NEGATIVE-SHORT-FLOAT-P */ - si_put_sysprop(VV[50], ECL_SYM("INLINE",436), VVtemp[98]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LOCATION",1862), VVtemp[99], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[51], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[108]); /* POSITIVE-SHORT-FLOAT-P */ - si_put_sysprop(VV[51], ECL_SYM("INLINE",436), VVtemp[100]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[52], ECL_SYM("TYPE",871), VVtemp[101]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[47], VVtemp[71], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[72]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LOCATION",1777), VVtemp[73], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[103]); /* NEGATIVE-SHORT-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LOCATION",1777), VVtemp[74], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[104]); /* NON-POSITIVE-SHORT-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LOCATION",1777), VVtemp[75], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[105]); /* NON-NEGATIVE-SHORT-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LOCATION",1777), VVtemp[76], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[106]); /* POSITIVE-SHORT-FLOAT-P */ + si_set_documentation(3, VV[52], ECL_SYM("TYPE",869), VVtemp[77]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC51__lambda109,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC51negative_single_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[52], VVtemp[102], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[53], ECL_SYM("TYPE",871), VVtemp[101]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[52], VVtemp[78], T0); + si_set_documentation(3, VV[53], ECL_SYM("TYPE",869), VVtemp[77]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC52__lambda112,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC52non_positive_single_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[53], VVtemp[103], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[54], ECL_SYM("TYPE",871), VVtemp[104]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[53], VVtemp[79], T0); + si_set_documentation(3, VV[54], ECL_SYM("TYPE",869), VVtemp[80]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC53__lambda115,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC53non_negative_single_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[54], VVtemp[105], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[55], ECL_SYM("TYPE",871), VVtemp[104]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[54], VVtemp[81], T0); + si_set_documentation(3, VV[55], ECL_SYM("TYPE",869), VVtemp[80]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC54__lambda118,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC54positive_single_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[55], VVtemp[106], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[107]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[56], ECL_SYM("LOCATION",1862), VVtemp[108], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[56], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[109]); /* NEGATIVE-SINGLE-FLOAT-P */ - si_put_sysprop(VV[56], ECL_SYM("INLINE",436), VVtemp[109]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[57], ECL_SYM("LOCATION",1862), VVtemp[110], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[57], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[110]); /* NON-POSITIVE-SINGLE-FLOAT-P */ - si_put_sysprop(VV[57], ECL_SYM("INLINE",436), VVtemp[111]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[58], ECL_SYM("LOCATION",1862), VVtemp[112], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[58], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[111]); /* NON-NEGATIVE-SINGLE-FLOAT-P */ - si_put_sysprop(VV[58], ECL_SYM("INLINE",436), VVtemp[113]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[59], ECL_SYM("LOCATION",1862), VVtemp[114], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[59], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[112]); /* POSITIVE-SINGLE-FLOAT-P */ - si_put_sysprop(VV[59], ECL_SYM("INLINE",436), VVtemp[115]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[60], ECL_SYM("TYPE",871), VVtemp[116]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[55], VVtemp[82], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[83]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[56], ECL_SYM("LOCATION",1777), VVtemp[84], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[56], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[107]); /* NEGATIVE-SINGLE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[57], ECL_SYM("LOCATION",1777), VVtemp[85], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[57], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[108]); /* NON-POSITIVE-SINGLE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[58], ECL_SYM("LOCATION",1777), VVtemp[86], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[58], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[109]); /* NON-NEGATIVE-SINGLE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[59], ECL_SYM("LOCATION",1777), VVtemp[87], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[59], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[110]); /* POSITIVE-SINGLE-FLOAT-P */ + si_set_documentation(3, VV[60], ECL_SYM("TYPE",869), VVtemp[88]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC59__lambda121,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC59negative_double_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[60], VVtemp[117], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[62], ECL_SYM("TYPE",871), VVtemp[116]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[60], VVtemp[89], T0); + si_set_documentation(3, VV[62], ECL_SYM("TYPE",869), VVtemp[88]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC60__lambda124,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC60non_positive_double_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[62], VVtemp[118], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[63], ECL_SYM("TYPE",871), VVtemp[119]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[62], VVtemp[90], T0); + si_set_documentation(3, VV[63], ECL_SYM("TYPE",869), VVtemp[91]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC61__lambda127,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC61non_negative_double_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[63], VVtemp[120], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[64], ECL_SYM("TYPE",871), VVtemp[119]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[63], VVtemp[92], T0); + si_set_documentation(3, VV[64], ECL_SYM("TYPE",869), VVtemp[91]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC62__lambda130,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC62positive_double_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[64], VVtemp[121], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[122]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[65], ECL_SYM("LOCATION",1862), VVtemp[123], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[65], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[113]); /* NEGATIVE-DOUBLE-FLOAT-P */ - si_put_sysprop(VV[65], ECL_SYM("INLINE",436), VVtemp[124]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[66], ECL_SYM("LOCATION",1862), VVtemp[125], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[66], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[114]); /* NON-POSITIVE-DOUBLE-FLOAT-P */ - si_put_sysprop(VV[66], ECL_SYM("INLINE",436), VVtemp[126]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[67], ECL_SYM("LOCATION",1862), VVtemp[127], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[67], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[115]); /* NON-NEGATIVE-DOUBLE-FLOAT-P */ - si_put_sysprop(VV[67], ECL_SYM("INLINE",436), VVtemp[128]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[68], ECL_SYM("LOCATION",1862), VVtemp[129], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[68], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[116]); /* POSITIVE-DOUBLE-FLOAT-P */ - si_put_sysprop(VV[68], ECL_SYM("INLINE",436), VVtemp[130]); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[69], ECL_SYM("TYPE",871), VVtemp[131]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[64], VVtemp[93], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[94]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[65], ECL_SYM("LOCATION",1777), VVtemp[95], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[65], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[111]); /* NEGATIVE-DOUBLE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[66], ECL_SYM("LOCATION",1777), VVtemp[96], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[66], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[112]); /* NON-POSITIVE-DOUBLE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[67], ECL_SYM("LOCATION",1777), VVtemp[97], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[67], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[113]); /* NON-NEGATIVE-DOUBLE-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[68], ECL_SYM("LOCATION",1777), VVtemp[98], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[68], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[114]); /* POSITIVE-DOUBLE-FLOAT-P */ + si_set_documentation(3, VV[69], ECL_SYM("TYPE",869), VVtemp[99]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC67__lambda133,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC67negative_long_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[69], VVtemp[132], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[71], ECL_SYM("TYPE",871), VVtemp[131]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[69], VVtemp[100], T0); + si_set_documentation(3, VV[71], ECL_SYM("TYPE",869), VVtemp[99]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC68__lambda136,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC68non_positive_long_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[71], VVtemp[133], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[72], ECL_SYM("TYPE",871), VVtemp[134]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[71], VVtemp[101], T0); + si_set_documentation(3, VV[72], ECL_SYM("TYPE",869), VVtemp[102]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC69__lambda139,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC69non_negative_long_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[72], VVtemp[135], T0); - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[73], ECL_SYM("TYPE",871), VVtemp[134]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[72], VVtemp[103], T0); + si_set_documentation(3, VV[73], ECL_SYM("TYPE",869), VVtemp[102]); { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC70__lambda142,ECL_NIL,Cblock,1); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC70positive_long_float,ECL_NIL,Cblock,1); T0 = v1; } - si_do_deftype(3, VV[73], VVtemp[136], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[137]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[74], ECL_SYM("LOCATION",1862), VVtemp[138], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[74], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[117]); /* NEGATIVE-LONG-FLOAT-P */ - si_put_sysprop(VV[74], ECL_SYM("INLINE",436), VVtemp[139]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[75], ECL_SYM("LOCATION",1862), VVtemp[140], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[75], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[118]); /* NON-POSITIVE-LONG-FLOAT-P */ - si_put_sysprop(VV[75], ECL_SYM("INLINE",436), VVtemp[141]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[76], ECL_SYM("LOCATION",1862), VVtemp[142], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[76], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[119]); /* NON-NEGATIVE-LONG-FLOAT-P */ - si_put_sysprop(VV[76], ECL_SYM("INLINE",436), VVtemp[143]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[77], ECL_SYM("LOCATION",1862), VVtemp[144], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[77], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[120]); /* POSITIVE-LONG-FLOAT-P */ - si_put_sysprop(VV[77], ECL_SYM("INLINE",436), VVtemp[145]); - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[78], ECL_SYM("LOCATION",1862), VVtemp[146], VVtemp[147]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[78], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[148]) /* ANNOTATE */; - ecl_cmp_defun(VV[121]); /* OF-TYPE */ - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[78], ECL_SYM("FUNCTION",398), VVtemp[149]) /* SET-DOCUMENTATION */; + si_do_deftype(3, VV[73], VVtemp[104], T0); + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[105]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[74], ECL_SYM("LOCATION",1777), VVtemp[106], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[74], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[115]); /* NEGATIVE-LONG-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[75], ECL_SYM("LOCATION",1777), VVtemp[107], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[75], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[116]); /* NON-POSITIVE-LONG-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[76], ECL_SYM("LOCATION",1777), VVtemp[108], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[76], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[117]); /* NON-NEGATIVE-LONG-FLOAT-P */ + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[77], ECL_SYM("LOCATION",1777), VVtemp[109], VVtemp[15]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[77], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; + ecl_cmp_defun(VV[118]); /* POSITIVE-LONG-FLOAT-P */ + } + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[78], ECL_SYM("LOCATION",1777), VVtemp[110], VVtemp[111]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[78], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[112]) /* ANNOTATE */; + ecl_cmp_defun(VV[119]); /* OF-TYPE */ + si_set_documentation(3, VV[78], ECL_SYM("FUNCTION",396), VVtemp[113]); { cl_object T0; - cl_object volatile env0 = ECL_NIL; { cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC77__lambda146,ECL_NIL,Cblock,2); + v1 = ecl_make_cfun((cl_objectfn_fixed)LC77of_type,ECL_NIL,Cblock,2); T0 = v1; } - si_put_sysprop(VV[78], ECL_SYM("COMPILER-MACRO",240), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[78], ECL_SYM("LOCATION",1862), VVtemp[150], VVtemp[151]) /* ANNOTATE */; - } - (cl_env_copy->function=(ECL_SYM("MAPC",545)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",668), VVtemp[152]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[80], ECL_SYM("LOCATION",1862), VVtemp[153], VVtemp[154]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[80], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[155]) /* ANNOTATE */; - ecl_cmp_defun(VV[123]); /* TYPE= */ - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[80], ECL_SYM("FUNCTION",398), VVtemp[156]) /* SET-DOCUMENTATION */; - si_put_sysprop(VV[80], ECL_SYM("INLINE",436), VVtemp[157]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[81], ECL_SYM("LOCATION",1862), VVtemp[158], VVtemp[159]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1856))(4, VV[81], ECL_SYM("LAMBDA-LIST",1000), ECL_NIL, VVtemp[160]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[124]); /* COERCEF */ - ecl_function_dispatch(cl_env_copy,VV[83])(3, VV[81], ECL_SYM("FUNCTION",398), VVtemp[161]) /* SET-DOCUMENTATION */; + si_put_sysprop(VV[78], ECL_SYM("COMPILER-MACRO",238), T0); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[78], ECL_SYM("LOCATION",1777), VVtemp[114], VVtemp[115]) /* ANNOTATE */; + } + (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[116]) /* MAPC */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[80], ECL_SYM("LOCATION",1777), VVtemp[117], VVtemp[118]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[80], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[119]) /* ANNOTATE */; + ecl_cmp_defun(VV[120]); /* TYPE= */ + si_set_documentation(3, VV[80], ECL_SYM("FUNCTION",396), VVtemp[120]); + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[81], ECL_SYM("LOCATION",1777), VVtemp[121], VVtemp[122]) /* ANNOTATE */; + ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[81], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[123]) /* ANNOTATE */; + ecl_cmp_defmacro(VV[121]); /* COERCEF */ + si_set_documentation(3, VV[81], ECL_SYM("FUNCTION",396), VVtemp[124]); } From c07d86baaea310b7400445a80c5229154cac1395 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:15:52 +0200 Subject: [PATCH 33/57] ch --- common/asgl-config/asgl-config.cxx | 217 -- common/early/apx.cxx | 234 --- common/early/cover.cxx | 71 - common/early/graph-input.cxx | 423 ---- common/early/graph.cxx | 1361 ------------ common/early/package.cxx | 36 - common/early/utils.cxx | 569 ----- lib/alexandria/arrays.cxx | 108 - lib/alexandria/binding.cxx | 323 --- lib/alexandria/conditions.cxx | 376 ---- lib/alexandria/control-flow.cxx | 834 -------- lib/alexandria/definitions.cxx | 277 --- lib/alexandria/features.cxx | 124 -- lib/alexandria/functions.cxx | 1323 ------------ lib/alexandria/hash-tables.cxx | 671 ------ lib/alexandria/io.cxx | 983 --------- lib/alexandria/lists.cxx | 3087 ---------------------------- lib/alexandria/macros.cxx | 1419 ------------- lib/alexandria/numbers.cxx | 1601 --------------- lib/alexandria/package.cxx | 36 - lib/alexandria/sequences.cxx | 2608 ----------------------- lib/alexandria/strings.cxx | 63 - lib/alexandria/symbols.cxx | 342 --- lib/alexandria/types.cxx | 2048 ------------------ 24 files changed, 19134 deletions(-) delete mode 100644 common/asgl-config/asgl-config.cxx delete mode 100644 common/early/apx.cxx delete mode 100644 common/early/cover.cxx delete mode 100644 common/early/graph-input.cxx delete mode 100644 common/early/graph.cxx delete mode 100644 common/early/package.cxx delete mode 100644 common/early/utils.cxx delete mode 100644 lib/alexandria/arrays.cxx delete mode 100644 lib/alexandria/binding.cxx delete mode 100644 lib/alexandria/conditions.cxx delete mode 100644 lib/alexandria/control-flow.cxx delete mode 100644 lib/alexandria/definitions.cxx delete mode 100644 lib/alexandria/features.cxx delete mode 100644 lib/alexandria/functions.cxx delete mode 100644 lib/alexandria/hash-tables.cxx delete mode 100644 lib/alexandria/io.cxx delete mode 100644 lib/alexandria/lists.cxx delete mode 100644 lib/alexandria/macros.cxx delete mode 100644 lib/alexandria/numbers.cxx delete mode 100644 lib/alexandria/package.cxx delete mode 100644 lib/alexandria/sequences.cxx delete mode 100644 lib/alexandria/strings.cxx delete mode 100644 lib/alexandria/symbols.cxx delete mode 100644 lib/alexandria/types.cxx diff --git a/common/asgl-config/asgl-config.cxx b/common/asgl-config/asgl-config.cxx deleted file mode 100644 index 2d8035f..0000000 --- a/common/asgl-config/asgl-config.cxx +++ /dev/null @@ -1,217 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/asgl-config/asgl-config.lisp */ -#include -#include "common/asgl-config/asgl-config.eclh" -/* function definition for HAVE-GECODE-GIST-HH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1have_gecode_gist_hh() -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v1; - { - int v2; - { -int res; -#ifdef HAVE_GECODE_GIST_HH -res = 0; -#else -res = 1; -#endif -v2= res; -} - v1 = (cl_fixnum)(v2); - } - value0 = ecl_make_bool((v1)==0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ENABLE-COVER */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L2enable_cover() -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v1; - { - int v2; - { -int res; -#ifdef ENABLE_COVER -res = 0; -#else -res = 1; -#endif -v2= res; -} - v1 = (cl_fixnum)(v2); - } - value0 = ecl_make_bool((v1)==0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ENABLE-TIMING */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L3enable_timing() -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v1; - { - int v2; - { -int res; -#ifdef ENABLE_TIMING -res = 0; -#else -res = 1; -#endif -v2= res; -} - v1 = (cl_fixnum)(v2); - } - value0 = ecl_make_bool((v1)==0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ENABLE-LOGGING */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4enable_logging() -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v1; - { - int v2; - { -int res; -#ifdef ENABLE_LOGGING -res = 0; -#else -res = 1; -#endif -v2= res; -} - v1 = (cl_fixnum)(v2); - } - value0 = ecl_make_bool((v1)==0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ENABLE-FOBJ-LEAK-CHECKS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5enable_fobj_leak_checks() -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v1; - { - int v2; - { -int res; -#ifdef ENABLE_FOBJ_LEAK_CHECKS -res = 0; -#else -res = 1; -#endif -v2= res; -} - v1 = (cl_fixnum)(v2); - } - value0 = ecl_make_bool((v1)==0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} - -#include "common/asgl-config/asgl-config.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclXWUiJ5qKAXSIM_7re2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/asgl-config/asgl-config.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclXWUiJ5qKAXSIM_7re2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[10])(10, VVtemp[0], ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[11]); /* HAVE-GECODE-GIST-HH */ - if (Null(L1have_gecode_gist_hh())) { goto L10; } - cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[1],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); -L10:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[4], VVtemp[5]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[12]); /* ENABLE-COVER */ - if (Null(L2enable_cover())) { goto L19; } - cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[3],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); -L19:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[13]); /* ENABLE-TIMING */ - if (Null(L3enable_timing())) { goto L28; } - cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[5],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); -L28:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[14]); /* ENABLE-LOGGING */ - if (Null(L4enable_logging())) { goto L37; } - cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[7],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); -L37:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[15]); /* ENABLE-FOBJ-LEAK-CHECKS */ - if (Null(L5enable_fobj_leak_checks())) { goto L46; } - cl_set(ECL_SYM("*FEATURES*",34),CONS(VV[9],ecl_symbol_value(ECL_SYM("*FEATURES*",34)))); -L46:; -} diff --git a/common/early/apx.cxx b/common/early/apx.cxx deleted file mode 100644 index 629a8ba..0000000 --- a/common/early/apx.cxx +++ /dev/null @@ -1,234 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/early/apx.lisp */ -#include -#include "common/early/apx.eclh" -/* function definition for HASH-TABLE2VECTOR */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L1hash_table2vector(cl_object v1hash, cl_object v2vector) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4k; - cl_object v5v; - v3 = ECL_NIL; - v4k = ECL_NIL; - v5v = ECL_NIL; - { - cl_object v6; - v6 = si_hash_table_iterator(v1hash); -L5:; - { - cl_object v8; - cl_object v9; - cl_object v10; - value0 = ecl_function_dispatch(cl_env_copy,v6)(0); - v8 = value0; - { - const int v11 = cl_env_copy->nvalues; - cl_object v12; - v12 = (v11<=1)? ECL_NIL : cl_env_copy->values[1]; - v9 = v12; - v12 = (v11<=2)? ECL_NIL : cl_env_copy->values[2]; - v10 = v12; - } - if (Null(v8)) { goto L10; } - v5v = v10; - v4k = v9; -L10:; - v3 = v8; - if ((v3)!=ECL_NIL) { goto L7; } - } - goto L6; -L7:; - { - cl_object v7; - v7 = v2vector; - T0 = v7; - { - cl_fixnum v8; - { - cl_object v9; - v9 = v5v; - if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - v8 = ecl_fixnum(v9); - } - ecl_aset_unsafe(T0,v8,v4k); - } - } - goto L5; -L6:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* local function WITH-APX-READTABLE */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC2with_apx_readtable(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4 = v5; - } - if (Null(v4)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - value0 = cl_listX(4, ECL_SYM("LET",477), VV[2], VV[3], v3); - return value0; - } - } -} -/* function definition for READ-APX-FILE */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L4read_apx_file(cl_object v1pathname) -{ - cl_object T0, T1, T2; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - if ((cl_probe_file(v1pathname))!=ECL_NIL) { goto L1; } - cl_error(2, VV[5], v1pathname); -L1:; - { - cl_object v3; /* BUFFER */ - cl_object v4; /* SIZE */ - T0 = cl_merge_pathnames(1, v1pathname); - T1 = cl_namestring(T0); - T2 = si_coerce_to_vector(T1, ECL_SYM("BASE-CHAR",120), ECL_SYM("*",18), ECL_NIL); - { - void* v5; - long v6; - { -long msize = 99; - -v5= slurp_file(T2, &msize); -v6= msize; -} - cl_env_copy->values[0] = ecl_make_pointer(v5); - cl_env_copy->values[1] = ecl_make_long(v6);cl_env_copy->nvalues=2; - value0 = cl_env_copy->values[0]; - } - v3 = value0; - v4 = cl_env_copy->values[1]; - { - cl_fixnum v5arg_count; - { - int v6; - { v6= count_args((char*)ecl_to_pointer(v3), ecl_to_long(v4)); } - v5arg_count = (cl_fixnum)(v6); - } - { - cl_object v6; - cl_object v7; - cl_object v8; - cl_object v9hash; - cl_object env1 = env0; - v6 = si_make_pure_array(ECL_T, ecl_make_fixnum(v5arg_count), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - T0 = (ECL_SYM("EQUAL",335)->symbol.gfdef); - v7 = cl_make_hash_table(2, ECL_SYM("TEST",1321), T0); - v8 = si_make_pure_array(ECL_T, ecl_make_fixnum(v5arg_count), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - v9hash = v7; - env1 = ECL_NIL; - CLV0 = env1 = CONS(v8,env1); /* GRAPH */ - { - cl_object v10; - v10 = ecl_make_cclosure_va((cl_objectfn)LC3__g31,env1,Cblock); - T0 = v10; - } - { ragel_apx_parse((char*)ecl_to_pointer(v3), ecl_to_long(v4), v9hash, T0); } - L1hash_table2vector(v9hash, v6); - cl_env_copy->nvalues = 3; - cl_env_copy->values[2] = v9hash; - cl_env_copy->values[1] = v6; - cl_env_copy->values[0] = ECL_CONS_CAR(CLV0); - return cl_env_copy->values[0]; - } - } - } - } -} -/* closure G31 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC3__g31(cl_narg narg, cl_object v1from, cl_object v2to, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV0 = env0; /* GRAPH */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[9])(3, ECL_CONS_CAR(CLV0), v1from, v2to) /* ADD-EDGE */; - return value0; - } - } -} - -#include "common/early/apx.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclqMFRzztbaOQJM_adf2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/apx.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclqMFRzztbaOQJM_adf2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[6]); /* HASH-TABLE2VECTOR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[7]); /* WITH-APX-READTABLE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[8]); /* READ-APX-FILE */ -} diff --git a/common/early/cover.cxx b/common/early/cover.cxx deleted file mode 100644 index 2a2fcc3..0000000 --- a/common/early/cover.cxx +++ /dev/null @@ -1,71 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/early/cover.lisp */ -#include -#include "common/early/cover.eclh" -/* local function ANNOTATE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1annotate(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4t_or_nil; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4t_or_nil = v5; - } - if (Null(v3)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} - -#include "common/early/cover.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclO8FY5RRFEZrGM_M7f2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/cover.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclO8FY5RRFEZrGM_M7f2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[1])(10, VVtemp[0], ECL_NIL, ECL_NIL, VVtemp[1], VVtemp[2], ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[4], VVtemp[5]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[6]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[2]); /* ANNOTATE */ -} diff --git a/common/early/graph-input.cxx b/common/early/graph-input.cxx deleted file mode 100644 index ec5a0af..0000000 --- a/common/early/graph-input.cxx +++ /dev/null @@ -1,423 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/early/graph-input.lisp */ -#include -#include "common/early/graph-input.eclh" -/* local function G0 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC1__g0(cl_object v1input) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[2])(1, v1input) /* READ-APX-FILE */; - return value0; - } -} -/* local function G1 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC2__g1(cl_object v1input) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[2])(1, v1input) /* READ-APX-FILE */; - return value0; - } -} -/* local function G20 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC3__g20(cl_object v1input) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v2items; - { - cl_object v3; - cl_object v4; - cl_object v5i; - v3 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* ORDER */; - { - cl_object v6; - v6 = v3; - T0 = cl_realp(v6); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v6); - v4 = v6; - } - v5i = ecl_make_fixnum(0); - { - cl_object v6; - cl_object v7; - v6 = ecl_list1(ECL_NIL); - v7 = v6; -L9:; - if (!(ecl_number_compare(v5i,v4)>=0)) { goto L11; } - goto L10; -L11:; - { - cl_object v8; - v8 = v7; - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - T0 = v8; - } - v7 = ecl_list1(v5i); - (ECL_CONS_CDR(T0)=v7,T0); - v5i = ecl_one_plus(v5i); - goto L9; -L10:; - v2items = _ecl_cdr(v6); - goto L1; - } - } -L1:; - T0 = ecl_function_dispatch(cl_env_copy,VV[3])(1, v1input) /* ORDER */; - T1 = cl_make_array(3, T0, ECL_SYM("INITIAL-CONTENTS",1257), v2items); - { - cl_object v3hash; - v3hash = cl_make_hash_table(0); - { - cl_object v4; - v4 = v2items; - goto L28; -L27:; - { - cl_object v5item; - v5item = ECL_CONS_CAR(v4); - si_hash_set(v5item, v3hash, v5item); - } - v4 = ECL_CONS_CDR(v4); -L28:; - if (Null(v4)) { goto L35; } - goto L27; -L35:; - } - T2 = v3hash; - } - cl_env_copy->nvalues = 3; - cl_env_copy->values[2] = T2; - cl_env_copy->values[1] = T1; - cl_env_copy->values[0] = v1input; - return cl_env_copy->values[0]; - } - } -} -/* local function G104 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC4__g104(cl_object v1input) -{ - cl_object T0, T1, T2, T3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v2; - cl_fixnum v3order; - v2 = v1input; - { - cl_object v4; - if (!(v2==ECL_NIL)) { goto L4; } - si_dm_too_few_arguments(v1input); -L4:; - { - cl_object v5; - v5 = ECL_CONS_CAR(v2); - v2 = ECL_CONS_CDR(v2); - v4 = v5; - } - { - bool v5; - v5 = ECL_FIXNUMP(v4); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(ECL_SYM("FIXNUM",372),v4); - } - v3order = ecl_fixnum(v4); - } - { - cl_object v4; - cl_object v5; - cl_object v6; - v4 = ecl_make_integer((v3order)-1); - T0 = ecl_expt(ecl_make_fixnum(2),ecl_make_fixnum(v3order)); - v5 = ecl_one_minus(T0); - T0 = si_make_pure_array(ECL_T, ecl_make_fixnum(v3order), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - v6 = si_fill_array_with_elt(T0, ECL_NIL, ecl_make_fixnum(0), ECL_NIL); - { - cl_object v7i; - v7i = ecl_make_fixnum(0); - { - cl_object v8; - cl_object v9position; - T0 = ecl_make_integer((v3order)-1); - v8 = ecl_times(ecl_make_fixnum(v3order),T0); - { - cl_object v10; - v10 = v8; - T0 = cl_realp(v10); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v10); - v9position = v10; - } - { - cl_object v10row; - v10row = ECL_NIL; - if (!(ecl_number_compare(v7i,ecl_make_fixnum(v3order))>=0)) { goto L22; } - goto L21; -L22:; -L20:; - { - cl_object v11; - cl_object v12; - { - cl_object v13; - v13 = ecl_make_fixnum(v3order); - { - cl_object v14; - v14 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L32; } - v14 = v13; - T0 = ecl_make_bool(ecl_number_compare(v14,ecl_make_fixnum(0))>=0); - goto L29; -L32:; - T0 = ECL_NIL; - goto L29; - } -L29:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",885),v13); - v11 = v13; - } - { - cl_object v13; - v13 = v9position; - { - cl_object v14; - v14 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v13)||ECL_BIGNUMP(v13))) { goto L42; } - v14 = v13; - T0 = ecl_make_bool(ecl_number_compare(v14,ecl_make_fixnum(0))>=0); - goto L39; -L42:; - T0 = ECL_NIL; - goto L39; - } -L39:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",885),v13); - v12 = v13; - } - T0 = cl_ash(ecl_make_fixnum(-1), v11); - T1 = ecl_boole(ECL_BOOLXOR,(T0),ecl_make_fixnum(-1)); - T2 = ecl_negate(v12); - T3 = cl_ash(v2, T2); - v10row = ecl_boole(ECL_BOOLAND,(T1),(T3)); - } - { - cl_object v11; - v11 = ecl_make_bool(ecl_zerop(v10row)); - if (Null(v11)) { goto L48; } - goto L46; -L48:; - if (!(ecl_eql(v10row,v5))) { goto L50; } - { - cl_fixnum v12j; - v12j = 0; - goto L54; -L53:; - { - cl_object v13; - cl_object v14; - v13 = ecl_minus(v4,ecl_make_fixnum(v12j)); - { - cl_object v15; - v15 = v6; - T1 = v15; - { - cl_fixnum v16; - { - cl_object v17; - v17 = v13; - if (ecl_unlikely((ecl_fixnum(v17))>=(v15)->vector.dim)) - FEwrong_index(ECL_NIL,v15,-1,ecl_make_fixnum(ecl_fixnum(v17)),(v15)->vector.dim); - v16 = ecl_fixnum(v17); - } - T0 = ecl_aref_unsafe(T1,v16); - } - } - v14 = CONS(v7i,T0); - { - cl_object v15; - v15 = v6; - T0 = v15; - { - cl_fixnum v16; - { - cl_object v17; - v17 = v13; - if (ecl_unlikely((ecl_fixnum(v17))>=(v15)->vector.dim)) - FEwrong_index(ECL_NIL,v15,-1,ecl_make_fixnum(ecl_fixnum(v17)),(v15)->vector.dim); - v16 = ecl_fixnum(v17); - } - ecl_aset_unsafe(T0,v16,v14); - } - } - } - v12j = (v12j)+1; -L54:; - if (!((v12j)<(v3order))) { goto L72; } - goto L53; -L72:; - goto L46; - } -L50:; - { - cl_fixnum v13j; - v13j = 0; - goto L76; -L75:; - if (Null(cl_logbitp(ecl_make_fixnum(v13j), v10row))) { goto L78; } - { - cl_object v14; - cl_object v15; - v14 = ecl_minus(v4,ecl_make_fixnum(v13j)); - { - cl_object v16; - v16 = v6; - T1 = v16; - { - cl_fixnum v17; - { - cl_object v18; - v18 = v14; - if (ecl_unlikely((ecl_fixnum(v18))>=(v16)->vector.dim)) - FEwrong_index(ECL_NIL,v16,-1,ecl_make_fixnum(ecl_fixnum(v18)),(v16)->vector.dim); - v17 = ecl_fixnum(v18); - } - T0 = ecl_aref_unsafe(T1,v17); - } - } - v15 = CONS(v7i,T0); - { - cl_object v16; - v16 = v6; - T0 = v16; - { - cl_fixnum v17; - { - cl_object v18; - v18 = v14; - if (ecl_unlikely((ecl_fixnum(v18))>=(v16)->vector.dim)) - FEwrong_index(ECL_NIL,v16,-1,ecl_make_fixnum(ecl_fixnum(v18)),(v16)->vector.dim); - v17 = ecl_fixnum(v18); - } - ecl_aset_unsafe(T0,v17,v15); - } - } - } -L78:; - v13j = (v13j)+1; -L76:; - if (!((v13j)<(v3order))) { goto L95; } - goto L75; -L95:; - } - } -L46:; - v7i = ecl_one_plus(v7i); - if (!(ecl_number_compare(v7i,ecl_make_fixnum(v3order))>=0)) { goto L99; } - goto L21; -L99:; - v9position = ecl_minus(v9position,ecl_make_fixnum(v3order)); - goto L20; -L21:; - } - } - } - value0 = ecl_function_dispatch(cl_env_copy,VV[0])(1, v6) /* READ-GRAPH-INPUT */; - return value0; - } - } - } -} - -#include "common/early/graph-input.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclkTNz1HtborJCM_WNf2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph-input.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclkTNz1HtborJCM_WNf2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - (cl_env_copy->function=(ECL_SYM("ENSURE-GENERIC-FUNCTION",942)->symbol.gfdef))->cfun.entry(5, VV[0], VV[1], ECL_T, ECL_SYM("LAMBDA-LIST",998), VVtemp[4]) /* ENSURE-GENERIC-FUNCTION */; - { - cl_object T0; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC1__g0,ECL_NIL,Cblock,1); - T0 = v1; - } - clos_install_method(6, VV[0], ECL_NIL, VVtemp[7], VVtemp[4], T0, ECL_T); - } - { - cl_object T0; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC2__g1,ECL_NIL,Cblock,1); - T0 = v1; - } - clos_install_method(6, VV[0], ECL_NIL, VVtemp[10], VVtemp[4], T0, ECL_T); - } - { - cl_object T0; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC3__g20,ECL_NIL,Cblock,1); - T0 = v1; - } - clos_install_method(6, VV[0], ECL_NIL, VVtemp[13], VVtemp[4], T0, ECL_T); - } - { - cl_object T0; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC4__g104,ECL_NIL,Cblock,1); - T0 = v1; - } - clos_install_method(6, VV[0], ECL_NIL, VVtemp[16], VVtemp[4], T0, ECL_T); - } -} diff --git a/common/early/graph.cxx b/common/early/graph.cxx deleted file mode 100644 index 83315da..0000000 --- a/common/early/graph.cxx +++ /dev/null @@ -1,1361 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/early/graph.lisp */ -#include -#include "common/early/graph.eclh" -/* function definition for %%ORDER */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L1__order(cl_object v1graph) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v1graph) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v1graph); - value0 = ecl_make_fixnum(ecl_length(v1graph)); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for %%PARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L2__parents(cl_object v1graph, cl_object v2node) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v1graph) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v1graph); - { - bool v3; - v3 = ECL_FIXNUMP(v2node); - if (ecl_unlikely(!(v3))) - FEwrong_type_argument(VV[1],v2node); - } - { - cl_object v3; - v3 = v1graph; - T0 = v3; - { - cl_fixnum v4; - { - cl_fixnum v5; - v5 = ecl_fixnum(v2node); - if (ecl_unlikely((v5)>=(v3)->vector.dim)) - FEwrong_index(ECL_NIL,v3,-1,ecl_make_fixnum(v5),(v3)->vector.dim); - v4 = v5; - } - value0 = ecl_aref_unsafe(T0,v4); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* function definition for (SETF %%PARENTS) */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L3_setf___parents_(cl_object v1value, cl_object v2graph, cl_object v3node) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v2graph) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v2graph); - { - bool v4; - v4 = ECL_FIXNUMP(v3node); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(VV[1],v3node); - } - { - cl_object v4; - v4 = v2graph; - T0 = v4; - { - cl_fixnum v5; - { - cl_fixnum v6; - v6 = ecl_fixnum(v3node); - if (ecl_unlikely((v6)>=(v4)->vector.dim)) - FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); - v5 = v6; - } - value0 = ecl_aset_unsafe(T0,v5,v1value); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* local function DO-%%PARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC4do___parents(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6node; - cl_object v7parents; - cl_object v8return; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4 = v9; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v6node = v9; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v7parents = v9; - } - if (Null(v5)) { goto L22; } - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v8return = v9; - goto L21; - } -L22:; - v8return = ECL_NIL; -L21:; - if (Null(v5)) { goto L27; } - si_dm_too_many_arguments(v1); -L27:; - T0 = cl_list(3, v6node, v7parents, v8return); - T1 = ecl_append(v3,VV[6]); - value0 = cl_listX(3, ECL_SYM("DOLIST",313), T0, T1); - return value0; - } - } -} -/* function definition for %%PARENTS-ADD */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L5__parents_add(cl_object v1node, cl_object v2parents) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - bool v3; - v3 = ECL_FIXNUMP(v1node); - if (ecl_unlikely(!(v3))) - FEwrong_type_argument(VV[1],v1node); - } - value0 = CONS(v1node,v2parents); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function %%PUSH-PARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC6__push_parents(cl_object v1, cl_object v2env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4obj; - cl_object v5place; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4obj = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v5place = v6; - } - if (Null(v3)) { goto L14; } - si_dm_too_many_arguments(v1); -L14:; - { - cl_object v7; /* DUMMIES */ - cl_object v8; /* VALS */ - cl_object v9; /* NEWVAL */ - cl_object v10; /* SETTER */ - cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v5place, v2env) /* GET-SETF-EXPANSION */; - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - { - cl_object v12g; - v12g = cl_gensym(0); - T0 = cl_list(2, v12g, v4obj); - { - cl_object v13; - v13 = (ECL_SYM("LIST",481)->symbol.gfdef); - { - cl_object v14; - cl_object v15; - v14 = ECL_NIL; - { - cl_object v16; - v16 = v7; - if (ecl_unlikely(!ECL_LISTP(v16))) FEtype_error_list(v16); - v15 = v16; - } - { - cl_object v16; - cl_object v17; - v16 = ECL_NIL; - { - cl_object v18; - v18 = v8; - if (ecl_unlikely(!ECL_LISTP(v18))) FEtype_error_list(v18); - v17 = v18; - } - { - cl_object v18; - cl_object v19; - v18 = ecl_list1(ECL_NIL); - v19 = v18; -L30:; - if (!(v15==ECL_NIL)) { goto L32; } - goto L31; -L32:; - v14 = ECL_CONS_CAR(v15); - { - cl_object v20; - v20 = ECL_CONS_CDR(v15); - if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20); - v15 = v20; - } - if (!(v17==ECL_NIL)) { goto L40; } - goto L31; -L40:; - v16 = ECL_CONS_CAR(v17); - { - cl_object v20; - v20 = ECL_CONS_CDR(v17); - if (ecl_unlikely(!ECL_LISTP(v20))) FEtype_error_list(v20); - v17 = v20; - } - { - cl_object v20; - v20 = v19; - if (ecl_unlikely(ECL_ATOM(v20))) FEtype_error_cons(v20); - T2 = v20; - } - T3 = ecl_function_dispatch(cl_env_copy,v13)(2, v14, v16); - v19 = ecl_list1(T3); - (ECL_CONS_CDR(T2)=v19,T2); - goto L30; -L31:; - T1 = _ecl_cdr(v18); - goto L18; - } - } - } - } -L18:; - T2 = _ecl_car(v9); - T3 = cl_list(3, VV[7], v12g, v11); - T4 = cl_list(2, T2, T3); - T5 = _ecl_cdr(v9); - T6 = CONS(T4,T5); - T7 = ecl_append(T1,T6); - T8 = CONS(T0,T7); - value0 = cl_list(3, ECL_SYM("LET*",478), T8, v10); - return value0; - } - } - } - } -} -/* function definition for ORDER */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L7order(cl_object v1graph) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v2graph; - { - cl_object v3; - v3 = v1graph; - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v3) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v3); - v2graph = v3; - } - value0 = ecl_make_fixnum(ecl_length(v2graph)); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for SIZE */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L8size(cl_object v1graph) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = (ECL_SYM("+",14)->symbol.gfdef); - T1 = (ECL_SYM("LENGTH",476)->symbol.gfdef); - value0 = cl_reduce(4, T0, v1graph, ECL_SYM("KEY",1267), T1); - return value0; - } -} -/* function definition for INDEGREES */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L9indegrees(cl_object v1graph) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = (ECL_SYM("LENGTH",476)->symbol.gfdef); - value0 = cl_map(3, ECL_SYM("VECTOR",898), T0, v1graph); - return value0; - } -} -/* local function DO-EDGES */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC10do_edges(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6from; - cl_object v7to; - cl_object v8graph; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4 = v9; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v6from = v9; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v7to = v9; - } - if (!(v5==ECL_NIL)) { goto L22; } - si_dm_too_few_arguments(v1); -L22:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v8graph = v9; - } - if (Null(v5)) { goto L27; } - si_dm_too_many_arguments(v1); -L27:; - T0 = cl_list(2, v6from, v7to); - T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); - value0 = cl_list(3, VV[14], T1, v8graph); - return value0; - } - } -} -/* local function DO-PARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC11do_parents(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6node; - cl_object v7parents; - cl_object v8graph; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4 = v9; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v6node = v9; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v7parents = v9; - } - if (!(v5==ECL_NIL)) { goto L22; } - si_dm_too_few_arguments(v1); -L22:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v8graph = v9; - } - if (Null(v5)) { goto L27; } - si_dm_too_many_arguments(v1); -L27:; - T0 = cl_list(2, v6node, v7parents); - T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); - value0 = cl_list(3, VV[16], T1, v8graph); - return value0; - } - } -} -/* local function DO-PARENTS-GRANDPARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC12do_parents_grandparents(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6node; - cl_object v7parents_grandparents; - cl_object v8graph; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4 = v9; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v6node = v9; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v7parents_grandparents = v9; - } - if (!(v5==ECL_NIL)) { goto L22; } - si_dm_too_few_arguments(v1); -L22:; - { - cl_object v9; - v9 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v8graph = v9; - } - if (Null(v5)) { goto L27; } - si_dm_too_many_arguments(v1); -L27:; - T0 = cl_list(2, v6node, v7parents_grandparents); - T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); - value0 = cl_list(3, VV[18], T1, v8graph); - return value0; - } - } -} -/* function definition for OUTDEGREES */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L14outdegrees(cl_object v1graph) -{ - cl_object T0, T1, T2; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object env1 = env0; - T0 = L7order(v1graph); - T1 = si_make_pure_array(ECL_T, T0, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - T2 = si_fill_array_with_elt(T1, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); - env1 = ECL_NIL; - CLV0 = env1 = CONS(T2,env1); /* VECTOR */ - { - cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC13__g84,env1,Cblock); - T0 = v2; - } - L19map_edges(T0, v1graph); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G84 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC13__g84(cl_narg narg, cl_object v1from, cl_object v2to, ...) -{ - cl_object T0, T1; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV0 = env0; /* VECTOR */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v3; - { - cl_object v4; - v4 = ECL_CONS_CAR(CLV0); - T1 = v4; - { - cl_fixnum v5; - { - cl_object v6; - v6 = v1from; - if (ecl_unlikely((ecl_fixnum(v6))>=(v4)->vector.dim)) - FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(ecl_fixnum(v6)),(v4)->vector.dim); - v5 = ecl_fixnum(v6); - } - T0 = ecl_aref_unsafe(T1,v5); - } - } - v3 = ecl_plus(T0,ecl_make_fixnum(1)); - { - cl_object v4; - v4 = ECL_CONS_CAR(CLV0); - T0 = v4; - { - cl_fixnum v5; - { - cl_object v6; - v6 = v1from; - if (ecl_unlikely((ecl_fixnum(v6))>=(v4)->vector.dim)) - FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(ecl_fixnum(v6)),(v4)->vector.dim); - v5 = ecl_fixnum(v6); - } - value0 = ecl_aset_unsafe(T0,v5,v3); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } - } -} -/* function definition for ADD-EDGE */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L15add_edge(cl_object v1graph, cl_object v2from, cl_object v3to) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v4; - { - cl_object v5; - cl_fixnum v6node; - { - cl_object v7graph; - cl_fixnum v8node; - { - cl_object v9; - v9 = v1graph; - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v9) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v9); - v7graph = v9; - } - { - cl_object v9; - v9 = v3to; - { - bool v10; - v10 = ECL_FIXNUMP(v9); - if (ecl_unlikely(!(v10))) - FEwrong_type_argument(VV[1],v9); - } - v8node = ecl_fixnum(v9); - } - { - cl_object v9; - v9 = v7graph; - T0 = v9; - { - cl_fixnum v10; - { - cl_fixnum v11; - v11 = v8node; - if (ecl_unlikely((v11)>=(v9)->vector.dim)) - FEwrong_index(ECL_NIL,v9,-1,ecl_make_fixnum(v11),(v9)->vector.dim); - v10 = v11; - } - v5 = ecl_aref_unsafe(T0,v10); - } - } - } - { - cl_object v7; - v7 = v2from; - { - bool v8; - v8 = ECL_FIXNUMP(v7); - if (ecl_unlikely(!(v8))) - FEwrong_type_argument(VV[1],v7); - } - v6node = ecl_fixnum(v7); - } - v4 = CONS(ecl_make_fixnum(v6node),v5); - } - { - cl_object v5graph; - cl_fixnum v6node; - { - cl_object v7; - v7 = v1graph; - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v7) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v7); - v5graph = v7; - } - { - cl_object v7; - v7 = v3to; - { - bool v8; - v8 = ECL_FIXNUMP(v7); - if (ecl_unlikely(!(v8))) - FEwrong_type_argument(VV[1],v7); - } - v6node = ecl_fixnum(v7); - } - { - cl_object v7; - v7 = v5graph; - T0 = v7; - { - cl_fixnum v8; - { - cl_fixnum v9; - v9 = v6node; - if (ecl_unlikely((v9)>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(v9),(v7)->vector.dim); - v8 = v9; - } - value0 = ecl_aset_unsafe(T0,v8,v4); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } - } -} -/* function definition for MAKE-GRAPH-FROM-ADJ */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L16make_graph_from_adj(cl_object v1adj) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_fixnum v2order; - cl_object v3graph; - v2order = ecl_array_dimension(v1adj,0); - v3graph = si_make_pure_array(ECL_T, ecl_make_fixnum(v2order), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - { - cl_object v4i; - v4i = ecl_make_fixnum(0); - goto L6; -L5:; - { - cl_object v5j; - v5j = ecl_make_fixnum(0); - goto L11; -L10:; - { - cl_object v6; - v6 = v1adj; - T1 = v6; - { - cl_fixnum v7; - { - cl_fixnum v8dim6; - cl_fixnum v9dim7; - cl_fixnum v10; - v8dim6 = (v6)->array.dims[0]; - v9dim7 = (v6)->array.dims[1]; - v10 = 0; - if (ecl_unlikely((v6)->array.rank != (2))) - FEwrong_dimensions(v6,2); - { - cl_fixnum v11; - v11 = ecl_fixnum(v4i); - if (ecl_unlikely((v11)>=(v8dim6))) - FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v11),v8dim6); - v10 = (v10)+(v11); - } - v10 = (v10)*(v9dim7); - { - cl_fixnum v11; - v11 = ecl_fixnum(v5j); - if (ecl_unlikely((v11)>=(v9dim7))) - FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(v11),v9dim7); - v10 = (v10)+(v11); - } - v7 = v10; - } - T0 = ecl_aref_unsafe(T1,v7); - } - } - if (!((ecl_make_fixnum(1))==(T0))) { goto L13; } - L15add_edge(v3graph, v4i, v5j); -L13:; - v5j = ecl_one_plus(v5j); -L11:; - if (!(ecl_number_compare(v5j,ecl_make_fixnum(v2order))<0)) { goto L35; } - goto L10; -L35:; - } - v4i = ecl_one_plus(v4i); -L6:; - if (!(ecl_number_compare(v4i,ecl_make_fixnum(v2order))<0)) { goto L39; } - goto L5; -L39:; - } - value0 = v3graph; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MAP-NODES */ -/* optimize speed 3, debug 0, space 0, safety 0 */ -static cl_object L17map_nodes(cl_object v1fn, cl_object v2graph) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; -TTL: - { - cl_fixnum v3; - v3 = (v2graph)->vector.fillp; - { - cl_fixnum v4node; - v4node = 0; - goto L4; -L3:; - ecl_function_dispatch(cl_env_copy,v1fn)(1, ecl_make_fixnum(v4node)); - v4node = (v4node)+1; -L4:; - if (!((v4node)<(v3))) { goto L9; } - goto L3; -L9:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function DO-NODES */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC18do_nodes(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6node; - cl_object v7graph; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v8; - v8 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4 = v8; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v8; - v8 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v6node = v8; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v8; - v8 = ECL_CONS_CAR(v5); - v5 = ECL_CONS_CDR(v5); - v7graph = v8; - } - if (Null(v5)) { goto L21; } - si_dm_too_many_arguments(v1); -L21:; - T0 = ecl_list1(v6node); - T1 = cl_listX(3, ECL_SYM("LAMBDA",452), T0, v3); - value0 = cl_list(3, VV[22], T1, v7graph); - return value0; - } - } -} -/* function definition for MAP-EDGES */ -/* optimize speed 3, debug 0, space 0, safety 0 */ -static cl_object L19map_edges(cl_object v1fn, cl_object v2graph) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; -TTL: - { - cl_fixnum v3; - v3 = (v2graph)->vector.fillp; - { - cl_fixnum v4i; - v4i = 0; - goto L4; -L3:; - { - cl_object v5; - v5 = ecl_aref_unsafe(v2graph,v4i); - goto L10; -L9:; - { - cl_object v6j; - v6j = _ecl_car(v5); - ecl_function_dispatch(cl_env_copy,v1fn)(2, v6j, ecl_make_fixnum(v4i)); - } - v5 = _ecl_cdr(v5); -L10:; - if (Null(v5)) { goto L17; } - goto L9; -L17:; - } - v4i = (v4i)+1; -L4:; - if (!((v4i)<(v3))) { goto L21; } - goto L3; -L21:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MAP-PARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L21map_parents(cl_object v1fn, cl_object v2graph) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1fn,env0); /* FN */ - CLV1 = env0 = CONS(v2graph,env0); /* GRAPH */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC20__g158,env0,Cblock); - T0 = v3; - } - value0 = L17map_nodes(T0, ECL_CONS_CAR(CLV1)); - return value0; - } -} -/* closure G158 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC20__g158(cl_narg narg, cl_object v1node, ...) -{ - cl_object T0, T1; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* GRAPH */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v2graph; - cl_fixnum v3node; - { - cl_object v4; - v4 = ECL_CONS_CAR(CLV1); - T1 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v4) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T1)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v4); - v2graph = v4; - } - { - cl_object v4; - v4 = v1node; - { - bool v5; - v5 = ECL_FIXNUMP(v4); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(VV[1],v4); - } - v3node = ecl_fixnum(v4); - } - { - cl_object v4; - v4 = v2graph; - T1 = v4; - { - cl_fixnum v5; - { - cl_fixnum v6; - v6 = v3node; - if (ecl_unlikely((v6)>=(v4)->vector.dim)) - FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); - v5 = v6; - } - T0 = ecl_aref_unsafe(T1,v5); - } - } - } - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, v1node, T0); - return value0; - } - } -} -/* function definition for MAP-PARENTS-GRANDPARENTS */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L24map_parents_grandparents(cl_object v1fn, cl_object v2graph) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1fn,env0); /* FN */ - CLV1 = env0 = CONS(v2graph,env0); /* GRAPH */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC23__g161,env0,Cblock); - T0 = v3; - } - value0 = L21map_parents(T0, ECL_CONS_CAR(CLV1)); - return value0; - } -} -/* closure G161 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC23__g161(cl_narg narg, cl_object v1node, cl_object v2parents, ...) -{ - cl_object T0, T1, T2; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* GRAPH */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v3; - v3 = (ECL_SYM("CONS",251)->symbol.gfdef); - { - cl_object v4; - cl_object v5; - v4 = ECL_NIL; - { - cl_object v6; - v6 = v2parents; - if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6); - v5 = v6; - } - { - cl_object v6; - cl_object v7; - cl_object v8; - { - cl_object v9; - { - cl_object v10; - v10 = ecl_make_cclosure_va((cl_objectfn)LC22__g178,env0,Cblock); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ECL_NIL; - { - cl_object v12; - v12 = v2parents; - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v11 = v12; - } - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L15:; - if (!(v11==ECL_NIL)) { goto L17; } - goto L16; -L17:; - v10 = ECL_CONS_CAR(v11); - { - cl_object v14; - v14 = ECL_CONS_CDR(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T1 = v14; - } - T2 = ecl_function_dispatch(cl_env_copy,v9)(1, v10); - v13 = ecl_list1(T2); - (ECL_CONS_CDR(T1)=v13,T1); - goto L15; -L16:; - v6 = _ecl_cdr(v12); - goto L7; - } - } - } -L7:; - v7 = ECL_NIL; - { - cl_object v9; - v9 = v6; - if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - v8 = v9; - } - { - cl_object v9; - cl_object v10; - v9 = ecl_list1(ECL_NIL); - v10 = v9; -L39:; - if (!(v5==ECL_NIL)) { goto L41; } - goto L40; -L41:; - v4 = ECL_CONS_CAR(v5); - { - cl_object v11; - v11 = ECL_CONS_CDR(v5); - if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); - v5 = v11; - } - if (!(v8==ECL_NIL)) { goto L49; } - goto L40; -L49:; - v7 = ECL_CONS_CAR(v8); - { - cl_object v11; - v11 = ECL_CONS_CDR(v8); - if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); - v8 = v11; - } - { - cl_object v11; - v11 = v10; - if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); - T1 = v11; - } - T2 = ecl_function_dispatch(cl_env_copy,v3)(2, v4, v7); - v10 = ecl_list1(T2); - (ECL_CONS_CDR(T1)=v10,T1); - goto L39; -L40:; - T0 = _ecl_cdr(v9); - goto L1; - } - } - } - } -L1:; - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, v1node, T0); - return value0; - } - } -} -/* closure G178 */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC22__g178(cl_narg narg, cl_object v1parent, ...) -{ - cl_object T0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* GRAPH */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v2graph; - cl_fixnum v3node; - { - cl_object v4; - v4 = ECL_CONS_CAR(CLV1); - T0 = ecl_function_dispatch(cl_env_copy,VV[25])(1, v4) /* SIMPLE-ARRAY-P */; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[0],v4); - v2graph = v4; - } - { - cl_object v4; - v4 = v1parent; - { - bool v5; - v5 = ECL_FIXNUMP(v4); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(VV[1],v4); - } - v3node = ecl_fixnum(v4); - } - { - cl_object v4; - v4 = v2graph; - T0 = v4; - { - cl_fixnum v5; - { - cl_fixnum v6; - v6 = v3node; - if (ecl_unlikely((v6)>=(v4)->vector.dim)) - FEwrong_index(ECL_NIL,v4,-1,ecl_make_fixnum(v6),(v4)->vector.dim); - v5 = v6; - } - value0 = ecl_aref_unsafe(T0,v5); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } - } -} - -#include "common/early/graph.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclLTqb7ItxYx5DM_hNf2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/graph.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclLTqb7ItxYx5DM_hNf2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - si_do_deftype(3, VV[0], VVtemp[2], ECL_SYM("SIMPLE-ARRAY",763)); - si_do_deftype(3, VV[1], VVtemp[3], ECL_SYM("FIXNUM",372)); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[4]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[24]); /* %%ORDER */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[26]); /* %%PARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[11], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[27]); /* (SETF %%PARENTS) */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[17]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[28]); /* DO-%%PARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; - ecl_cmp_defun(VV[29]); /* %%PARENTS-ADD */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[30]); /* %%PUSH-PARENTS */ - si_do_deftype(3, VV[9], VVtemp[24], ECL_SYM("SIMPLE-ARRAY",763)); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[31]); /* ORDER */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[32]); /* SIZE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[29], VVtemp[30]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[33]); /* INDEGREES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[34]); /* DO-EDGES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[34], VVtemp[35]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[36]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[35]); /* DO-PARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[37], VVtemp[38]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[39]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[36]); /* DO-PARENTS-GRANDPARENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LOCATION",1777), VVtemp[40], VVtemp[41]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[37]); /* OUTDEGREES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[43]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[44]) /* ANNOTATE */; - ecl_cmp_defun(VV[38]); /* ADD-EDGE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[45], VVtemp[46]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[47]) /* ANNOTATE */; - ecl_cmp_defun(VV[39]); /* MAKE-GRAPH-FROM-ADJ */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[48], VVtemp[49]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; - ecl_cmp_defun(VV[40]); /* MAP-NODES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[51], VVtemp[52]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[53]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[41]); /* DO-NODES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[54], VVtemp[55]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; - ecl_cmp_defun(VV[42]); /* MAP-EDGES */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[56], VVtemp[57]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; - ecl_cmp_defun(VV[43]); /* MAP-PARENTS */ - si_set_documentation(3, VV[16], ECL_SYM("FUNCTION",396), VVtemp[58]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LOCATION",1777), VVtemp[59], VVtemp[60]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* MAP-PARENTS-GRANDPARENTS */ - si_set_documentation(3, VV[18], ECL_SYM("FUNCTION",396), VVtemp[61]); -} diff --git a/common/early/package.cxx b/common/early/package.cxx deleted file mode 100644 index 960a194..0000000 --- a/common/early/package.cxx +++ /dev/null @@ -1,36 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/early/package.lisp */ -#include -#include "common/early/package.eclh" - -#include "common/early/package.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclhQzNQYq3zy1HM_J7f2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/package.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclhQzNQYq3zy1HM_J7f2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[0])(10, VVtemp[0], ECL_NIL, ECL_NIL, VVtemp[1], ECL_NIL, ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; -} diff --git a/common/early/utils.cxx b/common/early/utils.cxx deleted file mode 100644 index 761a445..0000000 --- a/common/early/utils.cxx +++ /dev/null @@ -1,569 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: common/early/utils.lisp */ -#include -#include "common/early/utils.eclh" -/* function definition for COMPONENT-PRESENT-P */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L1component_present_p(cl_object v1value) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - if (Null(v1value)) { goto L2; } - { - bool v2; - v2 = ecl_eql(v1value,ECL_SYM("UNSPECIFIC",1324)); - value0 = (v2)?ECL_NIL:ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for DIRECTORY-PATHNAME-P */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L2directory_pathname_p(cl_object v1pathspec) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = cl_pathname_name(1, v1pathspec); - if ((L1component_present_p(T0))!=ECL_NIL) { goto L2; } - T0 = cl_pathname_type(1, v1pathspec); - if ((L1component_present_p(T0))!=ECL_NIL) { goto L2; } - value0 = v1pathspec; - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for ASGL-HOME */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L3asgl_home() -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v1var; - value0 = si_getenv(VV[3]); - if ((value0)!=ECL_NIL) { goto L3; } - v1var = ECL_NIL; - goto L1; -L3:; - v1var = value0; - goto L1; -L1:; - if ((v1var)!=ECL_NIL) { goto L5; } - cl_error(1, VV[4]); -L5:; - { - cl_object v2home; - v2home = cl_probe_file(v1var); - if (Null(v2home)) { goto L11; } - if ((L2directory_pathname_p(v2home))!=ECL_NIL) { goto L8; } - goto L9; -L11:; - goto L9; -L9:; - T0 = si_getenv(VV[3]); - cl_error(2, VV[5], T0); -L8:; - value0 = v2home; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* local function AIF */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC4aif(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4test; - cl_object v5then; - cl_object v6else; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v7; - v7 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4test = v7; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v7; - v7 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v5then = v7; - } - if (Null(v3)) { goto L15; } - { - cl_object v7; - v7 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v6else = v7; - goto L14; - } -L15:; - v6else = ECL_NIL; -L14:; - if (Null(v3)) { goto L20; } - si_dm_too_many_arguments(v1); -L20:; - T0 = cl_list(2, VV[7], v4test); - T1 = ecl_list1(T0); - T2 = cl_list(4, ECL_SYM("IF",946), VV[7], v5then, v6else); - value0 = cl_list(3, ECL_SYM("LET",477), T1, T2); - return value0; - } - } -} -/* local function WITH-TIMING */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC5with_timing(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4form; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4form = v5; - } - if (Null(v3)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - value0 = v4form; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function LOG* */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC6log_(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4level; - v3 = ECL_CONS_CDR(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ECL_CONS_CAR(v3); - v3 = ECL_CONS_CDR(v3); - v4level = v5; - } - { - cl_object v5; - v5 = v4level; - { - cl_object v6; - v6 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v5)||ECL_BIGNUMP(v5))) { goto L14; } - v6 = v5; - if (ecl_number_compare(v6,ecl_make_fixnum(0))>=0) { goto L10; } - goto L11; -L14:; - goto L11; - } -L11:; - v4level = si_do_check_type(v5, VV[13], ECL_NIL, VV[14]); -L10:; - } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for PRINT-ERROR-LOG */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L7print_error_log(cl_object v1eout, cl_object v2e) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - cl_format(2, v1eout, VV[16]); - cl_format(3, v1eout, VV[17], v2e); - cl_format(2, v1eout, VV[18]); - { - cl_object v3x; - T0 = si_ihs_top(); - v3x = ecl_minus(T0,ecl_make_fixnum(2)); -L6:; - if (!(ecl_number_compare(v3x,ecl_make_fixnum(1))<0)) { goto L8; } - goto L7; -L8:; - T0 = si_ihs_fun(v3x); - cl_format(3, v1eout, VV[17], T0); - cl_format(2, v1eout, VV[19]); - { - cl_object v4env; - T0 = si_ihs_env(v3x); - v4env = ecl_function_dispatch(cl_env_copy,VV[42])(1, T0) /* DECODE-IHS-ENV */; - { - cl_object v5; - v5 = v4env; - goto L18; -L17:; - { - cl_object v6ip; - v6ip = ECL_CONS_CAR(v5); - T0 = _ecl_car(v6ip); - T1 = _ecl_cdr(v6ip); - cl_format(4, v1eout, VV[20], T0, T1); - } - v5 = ECL_CONS_CDR(v5); -L18:; - if (Null(v5)) { goto L25; } - goto L17; -L25:; - } - } - cl_format(2, v1eout, VV[21]); - v3x = ecl_one_minus(v3x); - goto L6; -L7:; - } - value0 = cl_format(2, v1eout, VV[21]); - return value0; - } -} -/* function definition for REQUIRES-COMPILE-P */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L9requires_compile_p(cl_object v1source_file) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v2fasl_file; - T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",235)->symbol.gfdef))->cfun.entry(1, v1source_file) /* COMPILE-FILE-PATHNAME */; - v2fasl_file = cl_probe_file(T0); - value0 = Null(v2fasl_file)?ECL_T:ECL_NIL; - if ((value0)!=ECL_NIL) { goto L3; } - value0 = LC8file_newer_p(v1source_file, v2fasl_file); - return value0; -L3:; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function FILE-NEWER-P */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object LC8file_newer_p(cl_object v1new_file, cl_object v2old_file) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = cl_file_write_date(v1new_file); - T1 = cl_file_write_date(v2old_file); - value0 = ecl_make_bool(ecl_number_compare(T0,T1)>0); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for COMPILE-FILE-IF-NEEDED */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L10compile_file_if_needed(cl_object v1filename, cl_object v2loadp) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - if (Null(L9requires_compile_p(v1filename))) { goto L1; } - (cl_env_copy->function=(ECL_SYM("COMPILE-FILE",234)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE */; -L1:; - if (Null(v2loadp)) { goto L3; } - T0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",235)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; - cl_load(1, T0); -L3:; - value0 = (cl_env_copy->function=(ECL_SYM("COMPILE-FILE-PATHNAME",235)->symbol.gfdef))->cfun.entry(1, v1filename) /* COMPILE-FILE-PATHNAME */; - return value0; - } -} -/* function definition for MEAN */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L11mean(cl_object v1sequence) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - T0 = (ECL_SYM("+",14)->symbol.gfdef); - T1 = cl_reduce(2, T0, v1sequence); - { - cl_fixnum v2; - v2 = ecl_length(v1sequence); - value0 = ecl_divide(T1,ecl_make_fixnum(v2)); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MEDIAN */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L12median(cl_object v1sequence) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - value0 = L13percentile(v1sequence, ecl_make_fixnum(50)); - return value0; - } -} -/* function definition for PERCENTILE */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L13percentile(cl_object v1sequence, cl_object v2percent) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3sorted_vect; - cl_fixnum v4n; - cl_object v5k; - cl_object v6floor_k; - T0 = ecl_copy_seq(v1sequence); - T1 = (ECL_SYM("<",72)->symbol.gfdef); - T2 = cl_sort(2, T0, T1); - v3sorted_vect = si_coerce_to_vector(T2, ECL_T, ECL_SYM("*",18), ECL_T); - v4n = (v3sorted_vect)->vector.fillp; - T0 = ecl_divide(v2percent,ecl_make_fixnum(100)); - v5k = ecl_times(ecl_make_fixnum(v4n),T0); - v6floor_k = ecl_floor1(v5k); - if (!(ecl_number_equalp(v5k,v6floor_k))) { goto L6; } - { - cl_object v7; - v7 = v3sorted_vect; - T1 = v7; - { - cl_fixnum v8; - { - cl_object v9; - v9 = v5k; - if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - v8 = ecl_fixnum(v9); - } - T0 = ecl_aref_unsafe(T1,v8); - } - } - { - cl_object v7; - v7 = v3sorted_vect; - T2 = v7; - { - cl_fixnum v8; - { - cl_object v9; - v9 = ecl_one_minus(v5k); - if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - v8 = ecl_fixnum(v9); - } - T1 = ecl_aref_unsafe(T2,v8); - } - } - T2 = ecl_plus(T0,T1); - value0 = ecl_divide(T2,ecl_make_fixnum(2)); - cl_env_copy->nvalues = 1; - return value0; -L6:; - { - cl_object v7; - v7 = v3sorted_vect; - T0 = v7; - { - cl_fixnum v8; - { - cl_object v9; - v9 = v6floor_k; - if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - v8 = ecl_fixnum(v9); - } - value0 = ecl_aref_unsafe(T0,v8); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* function definition for SUMMARY */ -/* optimize speed 3, debug 0, space 0, safety 1 */ -static cl_object L14summary(cl_object v1sequence) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_fixnum v2; - v2 = ecl_length(v1sequence); - if (!((v2)<(1000))) { goto L1; } - } - T0 = (ECL_SYM("MIN",557)->symbol.gfdef); - T1 = cl_reduce(2, T0, v1sequence); - T2 = L13percentile(v1sequence, ecl_make_fixnum(25)); - T3 = cl_format(3, ECL_NIL, VV[30], T2); - T4 = L12median(v1sequence); - T5 = cl_format(3, ECL_NIL, VV[30], T4); - T6 = L11mean(v1sequence); - T7 = cl_format(3, ECL_NIL, VV[30], T6); - T8 = L13percentile(v1sequence, ecl_make_fixnum(75)); - T9 = cl_format(3, ECL_NIL, VV[30], T8); - T10 = (ECL_SYM("MAX",551)->symbol.gfdef); - T11 = cl_reduce(2, T10, v1sequence); - value0 = cl_list(12, VV[28], T1, VV[29], T3, VV[31], T5, VV[32], T7, VV[33], T9, VV[34], T11); - return value0; -L1:; - T0 = (ECL_SYM("MIN",557)->symbol.gfdef); - T1 = cl_reduce(2, T0, v1sequence); - T2 = L11mean(v1sequence); - T3 = cl_format(3, ECL_NIL, VV[30], T2); - T4 = (ECL_SYM("MAX",551)->symbol.gfdef); - T5 = cl_reduce(2, T4, v1sequence); - value0 = cl_list(6, VV[28], T1, VV[32], T3, VV[34], T5); - return value0; - } -} - -#include "common/early/utils.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclb840kDV4LgEAM_N7f2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/common/early/utils.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclb840kDV4LgEAM_N7f2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[35]); /* COMPONENT-PRESENT-P */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[36]); /* DIRECTORY-PATHNAME-P */ - si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[9]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, ECL_NIL) /* ANNOTATE */; - ecl_cmp_defun(VV[37]); /* ASGL-HOME */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[38]); /* AIF */ - si_Xmake_special(VV[8]); - if (ecl_boundp(cl_env_copy,VV[8])) { goto L30; } - cl_set(VV[8],ECL_NIL); -L30:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[17], VVtemp[18]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[19]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[39]); /* WITH-TIMING */ - si_Xmake_special(VV[10]); - if (ecl_boundp(cl_env_copy,VV[10])) { goto L43; } - cl_set(VV[10],ECL_NIL); -L43:; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - si_do_deftype(3, VV[11], VVtemp[22], VVtemp[23]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[40]); /* LOG* */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defun(VV[41]); /* PRINT-ERROR-LOG */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[31]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[32]) /* ANNOTATE */; - ecl_cmp_defun(VV[43]); /* REQUIRES-COMPILE-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[35]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* COMPILE-FILE-IF-NEEDED */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LOCATION",1777), VVtemp[36], VVtemp[37]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[38]) /* ANNOTATE */; - ecl_cmp_defun(VV[45]); /* MEAN */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[39], VVtemp[40]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[38]) /* ANNOTATE */; - ecl_cmp_defun(VV[46]); /* MEDIAN */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[41], VVtemp[42]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* PERCENTILE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LOCATION",1777), VVtemp[44], VVtemp[45]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[38]) /* ANNOTATE */; - ecl_cmp_defun(VV[48]); /* SUMMARY */ -} diff --git a/lib/alexandria/arrays.cxx b/lib/alexandria/arrays.cxx deleted file mode 100644 index 4b5bfe7..0000000 --- a/lib/alexandria/arrays.cxx +++ /dev/null @@ -1,108 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/arrays.lisp */ -#include -#include "lib/alexandria/arrays.eclh" -/* function definition for COPY-ARRAY */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1copy_array(cl_narg narg, cl_object v1array, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2element_type; - cl_object v3fill_pointer; - cl_object v4adjustable; - ecl_va_list args; ecl_va_start(args,v1array,narg,1); - { - cl_object keyvars[6]; - cl_parse_key(args,3,L1copy_arraykeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[3])) { - v2element_type = cl_array_element_type(v1array); - } else { - v2element_type = keyvars[0]; - } - if (Null(keyvars[4])) { - if (!((ECL_ARRAYP(v1array)?(void)0:FEtype_error_array(v1array),ECL_ARRAY_HAS_FILL_POINTER_P(v1array)))) { goto L4; } - v3fill_pointer = cl_fill_pointer(v1array); - goto L2; -L4:; - v3fill_pointer = ECL_NIL; - goto L2; -L2:; - } else { - v3fill_pointer = keyvars[1]; - } - if (Null(keyvars[5])) { - v4adjustable = ecl_make_bool((ECL_ARRAYP(v1array)? (void)0: FEtype_error_array(v1array),ECL_ADJUSTABLE_ARRAY_P(v1array))); - } else { - v4adjustable = keyvars[2]; - } - } - { - cl_object v5dimensions; - cl_object v6new_array; - v5dimensions = cl_array_dimensions(v1array); - v6new_array = si_make_pure_array(v2element_type, v5dimensions, v4adjustable, v3fill_pointer, ECL_NIL, ecl_make_fixnum(0)); - { - cl_fixnum v7; - v7 = ecl_fixnum(cl_array_total_size(v1array)); - { - cl_fixnum v8i; - v8i = 0; - goto L13; -L12:; - T0 = ecl_aref(v1array,v8i); - ecl_aset(v6new_array,v8i,T0); - v8i = (v8i)+1; -L13:; - if (!((v8i)<(v7))) { goto L18; } - goto L12; -L18:; - } - } - value0 = v6new_array; - cl_env_copy->nvalues = 1; - return value0; - } - } -} - -#include "lib/alexandria/arrays.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecl6zVmPLti1MIGM_syh2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/arrays.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl6zVmPLti1MIGM_syh2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defun(VV[1]); /* COPY-ARRAY */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); -} diff --git a/lib/alexandria/binding.cxx b/lib/alexandria/binding.cxx deleted file mode 100644 index 5db590c..0000000 --- a/lib/alexandria/binding.cxx +++ /dev/null @@ -1,323 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/binding.lisp */ -#include -#include "lib/alexandria/binding.eclh" -/* local function IF-LET */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1if_let(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4bindings; - cl_object v5; - cl_object v6then_form; - cl_object v7else_form; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4bindings = v8; - } - v5 = v3; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v8; - v8 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6then_form = v8; - } - if (Null(v5)) { goto L16; } - { - cl_object v8; - v8 = ecl_car(v5); - v5 = ecl_cdr(v5); - v7else_form = v8; - goto L15; - } -L16:; - v7else_form = ECL_NIL; -L15:; - if (Null(v5)) { goto L21; } - si_dm_too_many_arguments(v1); -L21:; - { - cl_object v8binding_list; - cl_object v9variables; - if (!(ECL_CONSP(v4bindings))) { goto L24; } - T0 = ecl_car(v4bindings); - if (!(ECL_SYMBOLP(T0))) { goto L24; } - v8binding_list = ecl_list1(v4bindings); - goto L23; -L24:; - v8binding_list = v4bindings; -L23:; - { - cl_object v10; - v10 = (ECL_SYM("CAR",180)->symbol.gfdef); - { - cl_object v11; - cl_object v12; - v11 = ECL_NIL; - { - cl_object v13; - v13 = v8binding_list; - if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); - v12 = v13; - } - { - cl_object v13; - cl_object v14; - v13 = ecl_list1(ECL_NIL); - v14 = v13; -L35:; - if (!(ecl_endp(v12))) { goto L37; } - goto L36; -L37:; - v11 = _ecl_car(v12); - { - cl_object v15; - v15 = _ecl_cdr(v12); - if (ecl_unlikely(!ECL_LISTP(v15))) FEtype_error_list(v15); - v12 = v15; - } - { - cl_object v15; - v15 = v14; - if (ecl_unlikely(ECL_ATOM(v15))) FEtype_error_cons(v15); - T0 = v15; - } - T1 = ecl_function_dispatch(cl_env_copy,v10)(1, v11); - v14 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v14,T0); - goto L35; -L36:; - v9variables = ecl_cdr(v13); - goto L27; - } - } - } -L27:; - T0 = CONS(ECL_SYM("AND",87),v9variables); - T1 = cl_list(4, ECL_SYM("IF",946), T0, v6then_form, v7else_form); - value0 = cl_list(3, ECL_SYM("LET",477), v8binding_list, T1); - return value0; - } - } - } -} -/* local function WHEN-LET */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2when_let(cl_object v1, cl_object v2) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4bindings; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4bindings = v5; - } - { - cl_object v5binding_list; - cl_object v6variables; - if (!(ECL_CONSP(v4bindings))) { goto L9; } - T0 = ecl_car(v4bindings); - if (!(ECL_SYMBOLP(T0))) { goto L9; } - v5binding_list = ecl_list1(v4bindings); - goto L8; -L9:; - v5binding_list = v4bindings; -L8:; - { - cl_object v7; - v7 = (ECL_SYM("CAR",180)->symbol.gfdef); - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v5binding_list; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ecl_list1(ECL_NIL); - v11 = v10; -L20:; - if (!(ecl_endp(v9))) { goto L22; } - goto L21; -L22:; - v8 = _ecl_car(v9); - { - cl_object v12; - v12 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v9 = v12; - } - { - cl_object v12; - v12 = v11; - if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - T0 = v12; - } - T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); - v11 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v11,T0); - goto L20; -L21:; - v6variables = ecl_cdr(v10); - goto L12; - } - } - } -L12:; - T0 = CONS(ECL_SYM("AND",87),v6variables); - T1 = cl_listX(3, ECL_SYM("WHEN",905), T0, v3); - value0 = cl_list(3, ECL_SYM("LET",477), v5binding_list, T1); - return value0; - } - } - } -} -/* local function WHEN-LET* */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4when_let_(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4bindings; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4bindings = v5; - } - { - cl_object v5binding_list; - if (!(ECL_CONSP(v4bindings))) { goto L9; } - T0 = ecl_car(v4bindings); - if (!(ECL_SYMBOLP(T0))) { goto L9; } - v5binding_list = ecl_list1(v4bindings); - goto L8; -L9:; - v5binding_list = v4bindings; -L8:; - T0 = ecl_car(v5binding_list); - T1 = ecl_list1(T0); - T2 = ecl_caar(v5binding_list); - T4 = ecl_cdr(v5binding_list); - T3 = LC3bind(T4, v3); - T4 = cl_listX(3, ECL_SYM("WHEN",905), T2, T3); - value0 = cl_list(3, ECL_SYM("LET",477), T1, T4); - return value0; - } - } - } -} -/* local function BIND */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3bind(cl_object v1bindings, cl_object v2forms) -{ - cl_object T0, T1, T2, T3, T4, T5; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1bindings)) { goto L1; } - T0 = ecl_car(v1bindings); - T1 = ecl_list1(T0); - T2 = ecl_caar(v1bindings); - T4 = ecl_cdr(v1bindings); - T3 = LC3bind(T4, v2forms); - T4 = cl_listX(3, ECL_SYM("WHEN",905), T2, T3); - T5 = cl_list(3, ECL_SYM("LET",477), T1, T4); - value0 = ecl_list1(T5); - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = v2forms; - cl_env_copy->nvalues = 1; - return value0; - } -} - -#include "lib/alexandria/binding.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclam0zuatJiYACM_r9g2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/binding.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclam0zuatJiYACM_r9g2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[3]); /* IF-LET */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[4]); /* WHEN-LET */ - si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[8]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[5]); /* WHEN-LET* */ - si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[11]); -} diff --git a/lib/alexandria/conditions.cxx b/lib/alexandria/conditions.cxx deleted file mode 100644 index ae27b0f..0000000 --- a/lib/alexandria/conditions.cxx +++ /dev/null @@ -1,376 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/conditions.lisp */ -#include -#include "lib/alexandria/conditions.eclh" -/* function definition for REQUIRED-ARGUMENT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1required_argument(cl_narg narg, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg>1)) FEwrong_num_arguments_anonym(); - { - cl_object v1name; - va_list args; va_start(args,narg); - { - int i = 0; - if (i >= narg) { - v1name = ECL_NIL; - } else { - i++; - v1name = va_arg(args,cl_object); - } - } - va_end(args); - value0 = cl_error(2, VV[1], v1name); - return value0; - } -} -/* function definition for SIMPLE-STYLE-WARNING */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L2simple_style_warning(cl_narg narg, cl_object v1message, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2args; - ecl_va_list args; ecl_va_start(args,v1message,narg,1); - v2args = cl_grab_rest_args(args); - ecl_va_end(args); - value0 = (cl_env_copy->function=(ECL_SYM("WARN",903)->symbol.gfdef))->cfun.entry(5, VV[2], ECL_SYM("FORMAT-CONTROL",1243), v1message, ECL_SYM("FORMAT-ARGUMENTS",1242), v2args) /* WARN */; - return value0; - } -} -/* function definition for SIMPLE-READER-ERROR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L3simple_reader_error(cl_narg narg, cl_object v1stream, cl_object v2message, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3args; - ecl_va_list args; ecl_va_start(args,v2message,narg,2); - v3args = cl_grab_rest_args(args); - ecl_va_end(args); - value0 = cl_error(7, VV[3], ECL_SYM("STREAM",1318), v1stream, ECL_SYM("FORMAT-CONTROL",1243), v2message, ECL_SYM("FORMAT-ARGUMENTS",1242), v3args); - return value0; - } -} -/* function definition for SIMPLE-PARSE-ERROR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4simple_parse_error(cl_narg narg, cl_object v1message, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2args; - ecl_va_list args; ecl_va_start(args,v1message,narg,1); - v2args = cl_grab_rest_args(args); - ecl_va_end(args); - value0 = cl_error(5, VV[4], ECL_SYM("FORMAT-CONTROL",1243), v1message, ECL_SYM("FORMAT-ARGUMENTS",1242), v2args); - return value0; - } -} -/* function definition for SIMPLE-PROGRAM-ERROR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5simple_program_error(cl_narg narg, cl_object v1message, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2args; - ecl_va_list args; ecl_va_start(args,v1message,narg,1); - v2args = cl_grab_rest_args(args); - ecl_va_end(args); - value0 = cl_error(5, VV[5], ECL_SYM("FORMAT-CONTROL",1243), v1message, ECL_SYM("FORMAT-ARGUMENTS",1242), v2args); - return value0; - } -} -/* local function IGNORE-SOME-CONDITIONS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6ignore_some_conditions(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v5; - } - T0 = CONS(ECL_SYM("PROGN",671),v3); - { - cl_object v5condition; - cl_object v6; - v5condition = ECL_NIL; - { - cl_object v7; - v7 = v4; - if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); - v6 = v7; - } - { - cl_object v7; - cl_object v8; - v7 = ecl_list1(ECL_NIL); - v8 = v7; -L15:; - if (!(ecl_endp(v6))) { goto L17; } - goto L16; -L17:; - v5condition = _ecl_car(v6); - { - cl_object v9; - v9 = _ecl_cdr(v6); - if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - v6 = v9; - } - { - cl_object v9; - v9 = v8; - if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - T2 = v9; - } - T3 = CONS(v5condition,VV[7]); - v8 = ecl_list1(T3); - (ECL_CONS_CDR(T2)=v8,T2); - goto L15; -L16:; - T1 = ecl_cdr(v7); - goto L8; - } - } -L8:; - value0 = cl_listX(3, ECL_SYM("HANDLER-CASE",416), T0, T1); - return value0; - } - } -} -/* local function UNWIND-PROTECT-CASE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7unwind_protect_case(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6abort_flag; - cl_object v7protected_form; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v8; - } - v5 = v4; - if (Null(v5)) { goto L10; } - { - cl_object v8; - v8 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6abort_flag = v8; - goto L9; - } -L10:; - v6abort_flag = ECL_NIL; -L9:; - if (!(v3==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v8; - v8 = ecl_car(v3); - v3 = ecl_cdr(v3); - v7protected_form = v8; - } - if (Null(v5)) { goto L21; } - si_dm_too_many_arguments(v1); -L21:; - { - cl_object v8; - v8 = v6abort_flag; - if (ECL_SYMBOLP(v8)) { goto L25; } - v6abort_flag = si_do_check_type(v8, VV[9], ECL_NIL, VV[10]); -L25:; - } - { - cl_object v8gflag; - v8gflag = cl_gensym(1, VV[11]); - T0 = cl_list(2, v8gflag, ECL_T); - T1 = ecl_list1(T0); - T2 = cl_list(3, ECL_SYM("SETF",750), v8gflag, ECL_NIL); - T3 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-PROG1",575), v7protected_form, T2); - if (Null(v6abort_flag)) { goto L31; } - T5 = cl_list(2, v6abort_flag, v8gflag); - T4 = ecl_list1(T5); - goto L29; -L31:; - T4 = ECL_NIL; - goto L29; -L29:; - { - cl_object v9cleanup_kind; - cl_object v10forms; - cl_object v11; - v9cleanup_kind = ECL_NIL; - v10forms = ECL_NIL; - { - cl_object v12; - v12 = v3; - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v11 = v12; - } - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L41:; - if (!(ecl_endp(v11))) { goto L43; } - goto L42; -L43:; - { - cl_object v14; - v14 = _ecl_car(v11); - v9cleanup_kind = ecl_car(v14); - v14 = ecl_cdr(v14); - v10forms = v14; - } - { - cl_object v14; - v14 = _ecl_cdr(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T6 = v14; - } - if (!(ecl_eql(v9cleanup_kind,VV[12]))) { goto L62; } - T8 = cl_list(2, ECL_SYM("NOT",584), v8gflag); - T7 = cl_listX(3, ECL_SYM("WHEN",905), T8, v10forms); - goto L61; -L62:; - if (!(ecl_eql(v9cleanup_kind,ECL_SYM("ABORT",1198)))) { goto L64; } - T7 = cl_listX(3, ECL_SYM("WHEN",905), v8gflag, v10forms); - goto L61; -L64:; - if (!(ecl_eql(v9cleanup_kind,VV[13]))) { goto L66; } - T7 = CONS(ECL_SYM("PROGN",671),v10forms); - goto L61; -L66:; - T7 = si_ecase_error(v9cleanup_kind, VV[14]); -L61:; - v13 = ecl_list1(T7); - (ECL_CONS_CDR(T6)=v13,T6); - goto L41; -L42:; - T5 = ecl_cdr(v12); - goto L33; - } - } -L33:; - T6 = cl_listX(3, ECL_SYM("LET",477), T4, T5); - T7 = cl_list(3, ECL_SYM("UNWIND-PROTECT",888), T3, T6); - value0 = cl_list(3, ECL_SYM("LET",477), T1, T7); - return value0; - } - } - } -} - -#include "lib/alexandria/conditions.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecl0sKp2nr5Zar9M_0Qg2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/conditions.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl0sKp2nr5Zar9M_0Qg2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defun(VV[15]); /* REQUIRED-ARGUMENT */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - clos_load_defclass(VV[2], VVtemp[7], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[16]); /* SIMPLE-STYLE-WARNING */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - clos_load_defclass(VV[3], VVtemp[13], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[17]); /* SIMPLE-READER-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[17], VVtemp[18]) /* ANNOTATE */; - clos_load_defclass(VV[4], VVtemp[19], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[18]); /* SIMPLE-PARSE-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[22], VVtemp[23]) /* ANNOTATE */; - clos_load_defclass(VV[5], VVtemp[24], ECL_NIL, ECL_NIL); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defun(VV[19]); /* SIMPLE-PROGRAM-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[20]); /* IGNORE-SOME-CONDITIONS */ - si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[30]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[21]); /* UNWIND-PROTECT-CASE */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[34]); -} diff --git a/lib/alexandria/control-flow.cxx b/lib/alexandria/control-flow.cxx deleted file mode 100644 index 0bff75b..0000000 --- a/lib/alexandria/control-flow.cxx +++ /dev/null @@ -1,834 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/control-flow.lisp */ -#include -#include "lib/alexandria/control-flow.eclh" -/* function definition for EXTRACT-FUNCTION-NAME */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1extract_function_name(cl_object v1spec) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_CONSP(v1spec))) { goto L1; } - { - cl_object v2; - v2 = ecl_car(v1spec); - if (!((v2)==(ECL_SYM("QUOTE",679)))) { goto L8; } - goto L5; - goto L6; -L8:; - goto L6; -L6:; - if (!((v2)==(ECL_SYM("FUNCTION",396)))) { goto L1; } - goto L2; -L5:; - } -L2:; - value0 = ecl_cadr(v1spec); - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = v1spec; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for GENERATE-SWITCH-BODY */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L3generate_switch_body(cl_narg narg, cl_object v1whole, cl_object v2object, cl_object v3clauses, cl_object v4test, cl_object v5key, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7; - cl_object env0; - cl_object CLV0, CLV1, CLV2, CLV3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<5)) FEwrong_num_arguments_anonym(); - if (ecl_unlikely(narg>6)) FEwrong_num_arguments_anonym(); - { - va_list args; va_start(args,v5key); - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1whole,env0); /* WHOLE */ - CLV1 = env0 = CONS(v4test,env0); /* TEST */ - { - int i = 5; - if (i >= narg) { - CLV2 = env0 = CONS(ECL_NIL,env0); /* DEFAULT */ - } else { - i++; - CLV2 = env0 = CONS(va_arg(args,cl_object),env0); /* DEFAULT */ - } - } - va_end(args); - { - cl_object env1 = env0; - T0 = cl_gensym(1, VV[4]); - CLV3 = env1 = CONS(T0,env1); /* VALUE */ - ECL_CONS_CAR(CLV1) = L1extract_function_name(ECL_CONS_CAR(CLV1)); - v5key = L1extract_function_name(v5key); - if (!(ECL_CONSP(ECL_CONS_CAR(CLV2)))) { goto L5; } - { - cl_object v6; - v6 = ecl_car(ECL_CONS_CAR(CLV2)); - if (!((v6)==(ECL_SYM("ERROR",337)))) { goto L12; } - goto L9; - goto L10; -L12:; - goto L10; -L10:; - if (!((v6)==(ECL_SYM("CERROR",202)))) { goto L5; } - goto L6; -L9:; - } -L6:; - T0 = ECL_CONS_CAR(CLV2); - T1 = cl_list(2, ECL_SYM("QUOTE",679), ECL_CONS_CAR(CLV1)); - T2 = cl_list(3, VV[7], ECL_CONS_CAR(CLV3), T1); - ECL_CONS_CAR(CLV2) = ecl_append(T0,T2); -L5:; - T0 = cl_list(2, v5key, v2object); - T1 = cl_list(2, ECL_CONS_CAR(CLV3), T0); - T2 = ecl_list1(T1); - { - cl_object v6; - { - cl_object v7; - v7 = ecl_make_cclosure_va((cl_objectfn)LC2__g10,env1,Cblock); - v6 = v7; - } - { - cl_object v7; - cl_object v8; - v7 = ECL_NIL; - { - cl_object v9; - v9 = v3clauses; - if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - v8 = v9; - } - { - cl_object v9; - cl_object v10; - v9 = ecl_list1(ECL_NIL); - v10 = v9; -L24:; - if (!(ecl_endp(v8))) { goto L26; } - goto L25; -L26:; - v7 = _ecl_car(v8); - { - cl_object v11; - v11 = _ecl_cdr(v8); - if (ecl_unlikely(!ECL_LISTP(v11))) FEtype_error_list(v11); - v8 = v11; - } - { - cl_object v11; - v11 = v10; - if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); - T4 = v11; - } - T5 = ecl_function_dispatch(cl_env_copy,v6)(1, v7); - v10 = ecl_list1(T5); - (ECL_CONS_CDR(T4)=v10,T4); - goto L24; -L25:; - T3 = ecl_cdr(v9); - goto L16; - } - } - } -L16:; - T4 = cl_list(2, ECL_T, ECL_CONS_CAR(CLV2)); - T5 = ecl_list1(T4); - T6 = ecl_append(T3,T5); - T7 = CONS(ECL_SYM("COND",247),T6); - value0 = cl_list(3, ECL_SYM("LET",477), T2, T7); - return value0; - } - } -} -/* closure G10 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__g10(cl_narg narg, cl_object v1clause, ...) -{ - cl_object T0; - cl_object CLV0, CLV1, CLV2, CLV3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV3 = env0; /* VALUE */ - CLV2 = _ecl_cdr(CLV3); - CLV1 = _ecl_cdr(CLV2); - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v2; - v2 = ecl_car(v1clause); - if (!(ecl_eql(v2,ECL_T))) { goto L7; } - goto L4; - goto L5; -L7:; - goto L5; -L5:; - if (!((v2)==(ECL_SYM("OTHERWISE",615)))) { goto L1; } - goto L2; -L4:; - } -L2:; - if (Null(ECL_CONS_CAR(CLV2))) { goto L10; } - cl_error(2, VV[10], ECL_CONS_CAR(CLV0)); -L10:; - T0 = ecl_cdr(v1clause); - ECL_CONS_CAR(CLV2) = CONS(ECL_SYM("PROGN",671),T0); - value0 = VV[11]; - cl_env_copy->nvalues = 1; - return value0; -L1:; - { - cl_object v2; - cl_object v3key_form; - v2 = v1clause; - if (!(v2==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1clause); -L16:; - { - cl_object v4; - v4 = ecl_car(v2); - v2 = ecl_cdr(v2); - v3key_form = v4; - } - T0 = cl_list(3, ECL_CONS_CAR(CLV1), ECL_CONS_CAR(CLV3), v3key_form); - value0 = CONS(T0,v2); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* local function SWITCH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4switch(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6object; - cl_object v7; - cl_object v8test; - cl_object v9; - cl_object v10key; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v11; - v11 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v11; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v11; - v11 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6object = v11; - } - v7 = si_search_keyword(2, v5, ECL_SYM("TEST",1321)); - if (!((v7)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L17; } - v8test = ECL_SYM("EQL",334); - goto L16; -L17:; - v8test = v7; -L16:; - v9 = si_search_keyword(2, v5, ECL_SYM("KEY",1267)); - if (!((v9)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L21; } - v10key = ECL_SYM("IDENTITY",426); - goto L20; -L21:; - v10key = v9; -L20:; - si_check_keyword(2, v5, VV[13]); - value0 = L3generate_switch_body(5, v1, v6object, v3, v8test, v10key); - return value0; - } - } -} -/* local function ESWITCH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5eswitch(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6object; - cl_object v7; - cl_object v8test; - cl_object v9; - cl_object v10key; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v11; - v11 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v11; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v11; - v11 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6object = v11; - } - v7 = si_search_keyword(2, v5, ECL_SYM("TEST",1321)); - if (!((v7)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L17; } - v8test = ECL_SYM("EQL",334); - goto L16; -L17:; - v8test = v7; -L16:; - v9 = si_search_keyword(2, v5, ECL_SYM("KEY",1267)); - if (!((v9)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L21; } - v10key = ECL_SYM("IDENTITY",426); - goto L20; -L21:; - v10key = v9; -L20:; - si_check_keyword(2, v5, VV[13]); - value0 = L3generate_switch_body(6, v1, v6object, v3, v8test, v10key, VV[15]); - return value0; - } - } -} -/* local function CSWITCH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6cswitch(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6object; - cl_object v7; - cl_object v8test; - cl_object v9; - cl_object v10key; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v11; - v11 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v11; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v11; - v11 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6object = v11; - } - v7 = si_search_keyword(2, v5, ECL_SYM("TEST",1321)); - if (!((v7)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L17; } - v8test = ECL_SYM("EQL",334); - goto L16; -L17:; - v8test = v7; -L16:; - v9 = si_search_keyword(2, v5, ECL_SYM("KEY",1267)); - if (!((v9)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L21; } - v10key = ECL_SYM("IDENTITY",426); - goto L20; -L21:; - v10key = v9; -L20:; - si_check_keyword(2, v5, VV[13]); - value0 = L3generate_switch_body(6, v1, v6object, v3, v8test, v10key, VV[17]); - return value0; - } - } -} -/* local function WHICHEVER */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10whichever(cl_object v1, cl_object v2env) -{ - cl_object T0, T1, T2, T3; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v2env,env0); /* ENV */ - { - cl_object v3; - cl_object v4possibilities; - v3 = ecl_cdr(v1); - v4possibilities = v3; - { - cl_object v5; - { - cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC7__g80,env0,Cblock); - v5 = v6; - } - { - cl_object v6; - cl_object v7; - v6 = ECL_NIL; - { - cl_object v8; - v8 = v4possibilities; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ecl_list1(ECL_NIL); - v9 = v8; -L12:; - if (!(ecl_endp(v7))) { goto L14; } - goto L13; -L14:; - v6 = _ecl_car(v7); - { - cl_object v10; - v10 = _ecl_cdr(v7); - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v7 = v10; - } - { - cl_object v10; - v10 = v9; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T0 = v10; - } - T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); - v9 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v9,T0); - goto L12; -L13:; - v4possibilities = ecl_cdr(v8); - goto L4; - } - } - } -L4:; - { - cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC8__g83,ECL_NIL,Cblock,1); - T0 = v5; - } - if (Null(cl_every(2, T0, v4possibilities))) { goto L30; } - T0 = CONS(ECL_SYM("VECTOR",898),v4possibilities); - T1 = cl_list(2, ECL_SYM("LOAD-TIME-VALUE",489), T0); - { - cl_fixnum v5; - v5 = ecl_length(v4possibilities); - T2 = cl_list(2, ECL_SYM("RANDOM",680), ecl_make_fixnum(v5)); - value0 = cl_list(3, ECL_SYM("SVREF",838), T1, T2); - return value0; - } -L30:; - { - cl_object v6random_number; - v6random_number = cl_gensym(1, VV[19]); - { - cl_fixnum v7length; - v7length = ecl_length(v4possibilities); - T0 = cl_list(2, ECL_SYM("RANDOM",680), ecl_make_fixnum(v7length)); - T1 = cl_list(2, v6random_number, T0); - T2 = ecl_list1(T1); - T3 = LC9expand(v4possibilities, ecl_make_fixnum(0), v6random_number); - value0 = cl_list(3, ECL_SYM("LET",477), T2, T3); - return value0; - } - } - } - } -} -/* closure G80 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__g80(cl_narg narg, cl_object v1p, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* ENV */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = cl_macroexpand(2, v1p, ECL_CONS_CAR(CLV0)); - return value0; - } - } -} -/* local function G83 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__g83(cl_object v1p) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_constantp(1, v1p); - return value0; - } -} -/* local function EXPAND */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC9expand(cl_object v1possibilities, cl_object v2position, cl_object v3random_number) -{ - cl_object T0, T1, T2, T3, T4; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = ecl_cdr(v1possibilities); - if (!(T0==ECL_NIL)) { goto L1; } - value0 = ecl_car(v1possibilities); - cl_env_copy->nvalues = 1; - return value0; -L1:; - { - cl_fixnum v4length; - cl_object v5half; - cl_object v6second_half; - cl_object v7first_half; - v4length = ecl_length(v1possibilities); - v5half = ecl_truncate2(ecl_make_fixnum(v4length),ecl_make_fixnum(2)); - v6second_half = ecl_nthcdr(ecl_to_size(v5half),v1possibilities); - T0 = ecl_minus(ecl_make_fixnum(v4length),v5half); - v7first_half = cl_butlast(2, v1possibilities, T0); - T0 = ecl_plus(v2position,v5half); - T1 = cl_list(3, ECL_SYM("<",72), v3random_number, T0); - T2 = LC9expand(v7first_half, v2position, v3random_number); - T4 = ecl_plus(v2position,v5half); - T3 = LC9expand(v6second_half, T4, v3random_number); - value0 = cl_list(4, ECL_SYM("IF",946), T1, T2, T3); - return value0; - } - } -} -/* local function XOR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12xor(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - cl_object env0; - cl_object CLV0, CLV1, CLV2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - v3 = ecl_cdr(v1); - { - cl_object v4; - cl_object v5; - cl_object v6; - cl_object env1 = env0; - v4 = cl_gensym(1, VV[21]); - v5 = cl_gensym(1, VV[22]); - v6 = cl_gensym(1, VV[23]); - env1 = ECL_NIL; - CLV0 = env1 = CONS(v4,env1); /* XOR */ - CLV1 = env1 = CONS(v5,env1); /* TMP */ - CLV2 = env1 = CONS(v6,env1); /* TRUE */ - T0 = cl_list(2, ECL_CONS_CAR(CLV1), ECL_CONS_CAR(CLV2)); - { - cl_object v7; - { - cl_object v8; - v8 = ecl_make_cclosure_va((cl_objectfn)LC11__g98,env1,Cblock); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v3; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ecl_list1(ECL_NIL); - v11 = v10; -L13:; - if (!(ecl_endp(v9))) { goto L15; } - goto L14; -L15:; - v8 = _ecl_car(v9); - { - cl_object v12; - v12 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v9 = v12; - } - { - cl_object v12; - v12 = v11; - if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - T2 = v12; - } - T3 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); - v11 = ecl_list1(T3); - (ECL_CONS_CDR(T2)=v11,T2); - goto L13; -L14:; - T1 = ecl_cdr(v10); - goto L5; - } - } - } -L5:; - T2 = cl_list(3, ECL_SYM("VALUES",895), ECL_CONS_CAR(CLV2), ECL_T); - T3 = cl_list(3, ECL_SYM("RETURN-FROM",725), ECL_CONS_CAR(CLV0), T2); - T4 = ecl_list1(T3); - T5 = ecl_append(T1,T4); - T6 = cl_listX(3, ECL_SYM("BLOCK",137), ECL_CONS_CAR(CLV0), T5); - value0 = cl_list(3, ECL_SYM("LET",477), T0, T6); - return value0; - } - } - } -} -/* closure G98 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__g98(cl_narg narg, cl_object v1datum, ...) -{ - cl_object T0, T1, T2, T3; - cl_object CLV0, CLV1, CLV2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV2 = env0; /* TRUE */ - CLV1 = _ecl_cdr(CLV2); - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = cl_list(3, ECL_SYM("SETF",750), ECL_CONS_CAR(CLV1), v1datum); - T1 = cl_list(3, ECL_SYM("RETURN-FROM",725), ECL_CONS_CAR(CLV0), VV[24]); - T2 = cl_list(3, ECL_SYM("SETF",750), ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV1)); - T3 = cl_list(4, ECL_SYM("IF",946), ECL_CONS_CAR(CLV2), T1, T2); - value0 = cl_list(3, ECL_SYM("IF",946), T0, T3); - return value0; - } - } -} -/* local function NTH-VALUE-OR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13nth_value_or(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4nth_value; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4nth_value = v5; - } - { - cl_object v5; - v5 = cl_gensym(1, VV[26]); - T0 = cl_list(2, v5, v4nth_value); - T1 = ecl_list1(T0); - { - cl_object v6values; - v6values = cl_gensym(1, VV[27]); - T3 = ecl_car(v3); - T4 = cl_list(2, ECL_SYM("MULTIPLE-VALUE-LIST",574), T3); - T5 = cl_list(2, v6values, T4); - T6 = ecl_list1(T5); - T7 = cl_list(3, ECL_SYM("NTH",602), v5, v6values); - T8 = cl_list(2, ECL_SYM("VALUES-LIST",896), v6values); - if (Null(ecl_cdr(v3))) { goto L12; } - T10 = ecl_cdr(v3); - T9 = cl_listX(3, VV[25], v5, T10); - goto L11; -L12:; - T9 = ECL_NIL; -L11:; - T10 = cl_list(4, ECL_SYM("IF",946), T7, T8, T9); - T2 = cl_list(3, ECL_SYM("LET",477), T6, T10); - } - value0 = cl_list(3, ECL_SYM("LET",477), T1, T2); - return value0; - } - } - } -} -/* local function MULTIPLE-VALUE-PROG2 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14multiple_value_prog2(cl_object v1, cl_object v2) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4first_form; - cl_object v5second_form; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4first_form = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5second_form = v6; - } - T0 = cl_listX(3, ECL_SYM("MULTIPLE-VALUE-PROG1",575), v5second_form, v3); - value0 = cl_list(3, ECL_SYM("PROGN",671), v4first_form, T0); - return value0; - } - } -} - -#include "lib/alexandria/control-flow.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclCnSaUWKBItpDM_Hwg2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/control-flow.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclCnSaUWKBItpDM_Hwg2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defun(VV[29]); /* EXTRACT-FUNCTION-NAME */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[30]); /* GENERATE-SWITCH-BODY */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[31]); /* SWITCH */ - si_set_documentation(3, VV[12], ECL_SYM("FUNCTION",396), VVtemp[11]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[32]); /* ESWITCH */ - si_set_documentation(3, VV[14], ECL_SYM("FUNCTION",396), VVtemp[14]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[33]); /* CSWITCH */ - si_set_documentation(3, VV[16], ECL_SYM("FUNCTION",396), VVtemp[17]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[34]); /* WHICHEVER */ - si_set_documentation(3, VV[18], ECL_SYM("FUNCTION",396), VVtemp[21]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[22], VVtemp[23]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[24]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[35]); /* XOR */ - si_set_documentation(3, VV[20], ECL_SYM("FUNCTION",396), VVtemp[25]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[26], VVtemp[27]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[36]); /* NTH-VALUE-OR */ - si_set_documentation(3, VV[25], ECL_SYM("FUNCTION",396), VVtemp[29]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[31]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[32]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[37]); /* MULTIPLE-VALUE-PROG2 */ - si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[33]); -} diff --git a/lib/alexandria/definitions.cxx b/lib/alexandria/definitions.cxx deleted file mode 100644 index a981d1a..0000000 --- a/lib/alexandria/definitions.cxx +++ /dev/null @@ -1,277 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/definitions.lisp */ -#include -#include "lib/alexandria/definitions.eclh" -/* function definition for %REEVALUATE-CONSTANT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5_reevaluate_constant(cl_object volatile v1name, cl_object volatile v2value, cl_object volatile v3test) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7; - cl_object volatile env0; - cl_object volatile CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (ecl_boundp(cl_env_copy,v1name)) { goto L1; } - value0 = v2value; - cl_env_copy->nvalues = 1; - return value0; -L1:; - { - volatile cl_object v4; - v4 = cl_symbol_value(v1name); - if ((cl_constantp(1, v1name))!=ECL_NIL) { goto L4; } - cl_cerror(4, VV[1], VV[2], v1name, v4); - value0 = v2value; - cl_env_copy->nvalues = 1; - return value0; -L4:; - if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v4, v2value))) { goto L7; } - value0 = v4; - cl_env_copy->nvalues = 1; - return value0; -L7:; - { - volatile cl_object env1 = env0; - env1 = ECL_NIL; - CLV0 = env1 = CONS(ECL_NIL,env1); - { - volatile cl_object env2 = env1; - CLV1 = env2 = CONS(ECL_NEW_FRAME_ID(cl_env_copy),env2); /* TAGBODY */ - if (ecl_frs_push(cl_env_copy,ECL_CONS_CAR(CLV1))) { - if (cl_env_copy->values[0]==ecl_make_fixnum(0))goto L9; - if (cl_env_copy->values[0]==ecl_make_fixnum(1))goto L10; - ecl_internal_error("GO found an inexistent tag"); - } - { - cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC1__g8,env2,Cblock); - T0 = v5; - } - { - cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC2__g9,ECL_NIL,Cblock,1); - T1 = v5; - } - T2 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1278), ECL_SYM("IGNORE",428), ECL_SYM("FUNCTION",1244), T0, VV[3], T1) /* MAKE-RESTART */; - { - cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC3__g10,env2,Cblock); - T3 = v5; - } - { - cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__g11,ECL_NIL,Cblock,1); - T4 = v5; - } - T5 = ecl_function_dispatch(cl_env_copy,VV[12])(6, ECL_SYM("NAME",1278), ECL_SYM("CONTINUE",250), ECL_SYM("FUNCTION",1244), T3, VV[3], T4) /* MAKE-RESTART */; - T6 = cl_list(2, T2, T5); - T7 = CONS(T6,ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",4))); - ecl_bds_bind(cl_env_copy,ECL_SYM("*RESTART-CLUSTERS*",4),T7); /* *RESTART-CLUSTERS* */ - { - cl_object v5; - T0 = cl_list(4, v1name, v4, v2value, v3test); - v5 = ecl_function_dispatch(cl_env_copy,VV[13])(4, VV[6], T0, ECL_SYM("SIMPLE-ERROR",770), ECL_SYM("ERROR",337)) /* COERCE-TO-CONDITION */; - T0 = ecl_car(ecl_symbol_value(ECL_SYM("*RESTART-CLUSTERS*",4))); - T1 = CONS(v5,T0); - T2 = CONS(T1,ecl_symbol_value(VV[7])); - ecl_bds_bind(cl_env_copy,VV[7],T2); /* *CONDITION-RESTARTS* */ - value0 = cl_error(1, v5); - ecl_frs_pop(cl_env_copy); - ecl_bds_unwind1(cl_env_copy); - ecl_bds_unwind1(cl_env_copy); - return value0; - } -L9:; - value0 = v4; - cl_env_copy->nvalues = 1; - ecl_frs_pop(cl_env_copy); - return value0; -L10:; - value0 = v2value; - cl_env_copy->nvalues = 1; - ecl_frs_pop(cl_env_copy); - return value0; - } - } - } - } -} -/* closure G8 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__g8(cl_narg narg, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* TAGBODY */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1si__temp; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1si__temp = cl_grab_rest_args(args); - ecl_va_end(args); - ECL_CONS_CAR(CLV0) = v1si__temp; - cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(0)); - } - } -} -/* local function G9 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__g9(cl_object v1stream) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_write_string(2, VV[4], v1stream); - return value0; - } -} -/* closure G10 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3__g10(cl_narg narg, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* TAGBODY */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1si__temp; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1si__temp = cl_grab_rest_args(args); - ecl_va_end(args); - ECL_CONS_CAR(CLV0) = v1si__temp; - cl_go(ECL_CONS_CAR(CLV1),ecl_make_fixnum(1)); - } - } -} -/* local function G11 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__g11(cl_object v1stream) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_write_string(2, VV[5], v1stream); - return value0; - } -} -/* local function DEFINE-CONSTANT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6define_constant(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4name; - cl_object v5initial_value; - cl_object v6; - cl_object v7test; - cl_object v8; - cl_object v9documentation; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v10; - v10 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4name = v10; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v10; - v10 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5initial_value = v10; - } - v6 = si_search_keyword(2, v3, ECL_SYM("TEST",1321)); - if (!((v6)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L16; } - v7test = VV[9]; - goto L15; -L16:; - v7test = v6; -L15:; - v8 = si_search_keyword(2, v3, ECL_SYM("DOCUMENTATION",1225)); - if (!((v8)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L20; } - v9documentation = ECL_NIL; - goto L19; -L20:; - v9documentation = v8; -L19:; - si_check_keyword(2, v3, VV[10]); - T0 = cl_list(2, ECL_SYM("QUOTE",679), v4name); - T1 = cl_list(4, VV[0], T0, v5initial_value, v7test); - if (Null(v9documentation)) { goto L24; } - T2 = ecl_list1(v9documentation); - goto L23; -L24:; - T2 = ECL_NIL; -L23:; - value0 = cl_listX(4, ECL_SYM("DEFCONSTANT",277), v4name, T1, T2); - return value0; - } - } -} - -#include "lib/alexandria/definitions.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclEwTbx6vhJ21IM_ftf2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/definitions.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclEwTbx6vhJ21IM_ftf2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defun(VV[11]); /* %REEVALUATE-CONSTANT */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[4], VVtemp[5]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[6]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[14]); /* DEFINE-CONSTANT */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[7]); -} diff --git a/lib/alexandria/features.cxx b/lib/alexandria/features.cxx deleted file mode 100644 index 1305795..0000000 --- a/lib/alexandria/features.cxx +++ /dev/null @@ -1,124 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/features.lisp */ -#include -#include "lib/alexandria/features.eclh" -/* function definition for FEATUREP */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1featurep(cl_object v1feature_expression) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - v2 = v1feature_expression; - if (!(ECL_SYMBOLP(v2))) { goto L2; } - T0 = ecl_memql(v1feature_expression,ecl_symbol_value(ECL_SYM("*FEATURES*",34))); - { - bool v3; - v3 = T0==ECL_NIL; - value0 = (v3)?ECL_NIL:ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } -L2:; - if (!(ECL_CONSP(v2))) { goto L5; } - { - cl_object v4; - v4 = ecl_car(v1feature_expression); - if (ECL_SYMBOLP(v4)) { goto L9; } - { - cl_object v5; - v5 = si_do_check_type(v4, ECL_SYM("SYMBOL",840), ECL_NIL, VV[1]); - { - cl_object v6; - v6 = v1feature_expression; - if (ecl_unlikely(ECL_ATOM(v6))) FEtype_error_cons(v6); - T0 = v6; - } - (ECL_CONS_CAR(T0)=v5,T0); - } -L9:; - } - { - cl_object v4; - T0 = ecl_car(v1feature_expression); - v4 = cl_identity(T0); - if (Null(cl_stringE(2, v4, VV[2]))) { goto L17; } - T0 = ecl_fdefinition(VV[0]); - T1 = ecl_cdr(v1feature_expression); - value0 = cl_every(2, T0, T1); - return value0; -L17:; - if (Null(cl_stringE(2, v4, VV[3]))) { goto L20; } - T0 = ecl_fdefinition(VV[0]); - T1 = ecl_cdr(v1feature_expression); - value0 = cl_some(2, T0, T1); - return value0; -L20:; - if (Null(cl_stringE(2, v4, VV[4]))) { goto L23; } - goto L27; -L26:; - si_assert_failure(1, VV[5]); -L27:; - { - cl_fixnum v5; - v5 = ecl_length(v1feature_expression); - if ((2)==(v5)) { goto L30; } - } - goto L26; -L30:; - T0 = ecl_cadr(v1feature_expression); - T1 = L1featurep(T0); - value0 = Null(T1)?ECL_T:ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L23:; - value0 = cl_error(3, VV[6], v4, ECL_SYM("STRING=",822)); - return value0; - } -L5:; - value0 = si_etypecase_error(v2, VV[7]); - return value0; - } - } -} - -#include "lib/alexandria/features.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclq3qz1Rgh1vqFM_Fwg2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/features.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclq3qz1Rgh1vqFM_Fwg2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defun(VV[8]); /* FEATUREP */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); -} diff --git a/lib/alexandria/functions.cxx b/lib/alexandria/functions.cxx deleted file mode 100644 index a33638a..0000000 --- a/lib/alexandria/functions.cxx +++ /dev/null @@ -1,1323 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/functions.lisp */ -#include -#include "lib/alexandria/functions.eclh" -/* function definition for ENSURE-FUNCTION */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1ensure_function(cl_object v1function_designator) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_functionp(v1function_designator))) { goto L1; } - value0 = v1function_designator; - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = cl_fdefinition(v1function_designator); - return value0; - } -} -/* local function ENSURE-FUNCTIONF/1 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3ensure_functionf_1(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - if (Null(v3)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC2__g5,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = ECL_NIL; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L13; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[0], v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[2],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L13:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L22; -L21:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L22:; - if (v12si__d==ECL_NIL) { goto L28; } - goto L21; -L28:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L33; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L33; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, VV[0], v10, ECL_NIL); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L32; -L33:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, VV[0], v10, T3); -L32:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[2],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G5 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2__g5(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function ENSURE-FUNCTIONF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5ensure_functionf(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - v3 = ecl_cdr(v1); - { - cl_object v4; - { - cl_object v5; - v5 = ecl_make_cfun((cl_objectfn_fixed)LC4__g22,ECL_NIL,Cblock,1); - v4 = v5; - } - { - cl_object v5; - cl_object v6; - v5 = ECL_NIL; - { - cl_object v7; - v7 = v3; - if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); - v6 = v7; - } - { - cl_object v7; - cl_object v8; - v7 = ecl_list1(ECL_NIL); - v8 = v7; -L10:; - if (!(ecl_endp(v6))) { goto L12; } - goto L11; -L12:; - v5 = _ecl_car(v6); - { - cl_object v9; - v9 = _ecl_cdr(v6); - if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - v6 = v9; - } - { - cl_object v9; - v9 = v8; - if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - T1 = v9; - } - T2 = ecl_function_dispatch(cl_env_copy,v4)(1, v5); - v8 = ecl_list1(T2); - (ECL_CONS_CDR(T1)=v8,T1); - goto L10; -L11:; - T0 = ecl_cdr(v7); - goto L2; - } - } - } -L2:; - value0 = CONS(ECL_SYM("PROGN",671),T0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function G22 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__g22(cl_object v1x) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_list(2, VV[1], v1x); - return value0; - } -} -/* function definition for DISJOIN */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object L8disjoin(cl_narg narg, cl_object v1predicate, ...) -{ - cl_object T0, T1; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2more_predicates; - ecl_va_list args; ecl_va_start(args,v1predicate,narg,1); - v2more_predicates = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3; - cl_object v4; - cl_object env1 = env0; - if (Null(cl_functionp(v1predicate))) { goto L2; } - v3 = v1predicate; - goto L1; -L2:; - v3 = cl_fdefinition(v1predicate); -L1:; - { - cl_object v5; - v5 = (VV[0]->symbol.gfdef); - { - cl_object v6; - cl_object v7; - v6 = ECL_NIL; - { - cl_object v8; - v8 = v2more_predicates; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ecl_list1(ECL_NIL); - v9 = v8; -L12:; - if (!(v7==ECL_NIL)) { goto L14; } - goto L13; -L14:; - v6 = ECL_CONS_CAR(v7); - { - cl_object v10; - v10 = ECL_CONS_CDR(v7); - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v7 = v10; - } - { - cl_object v10; - v10 = v9; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T0 = v10; - } - T1 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); - v9 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v9,T0); - goto L12; -L13:; - v4 = _ecl_cdr(v8); - goto L4; - } - } - } -L4:; - env1 = ECL_NIL; - CLV0 = env1 = CONS(v3,env1); /* PREDICATE */ - CLV1 = env1 = CONS(v4,env1); /* MORE-PREDICATES */ - { - cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC7__g35,env1,Cblock); - value0 = v5; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* closure G35 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC7__g35(cl_narg narg, ...) -{ - cl_object T0; - cl_object CLV0, CLV1, CLV2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* MORE-PREDICATES */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1arguments; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1arguments = cl_grab_rest_args(args); - CLV2 = env0 = CONS(v1arguments,env0); /* ARGUMENTS */ - ecl_va_end(args); - value0 = cl_apply(2, ECL_CONS_CAR(CLV0), ECL_CONS_CAR(CLV2)); - if ((value0)!=ECL_NIL) { goto L2; } - { - cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC6__g36,env0,Cblock); - T0 = v2; - } - value0 = cl_some(2, T0, ECL_CONS_CAR(CLV1)); - return value0; -L2:; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G36 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC6__g36(cl_narg narg, cl_object v1p, ...) -{ - cl_object T0; - cl_object CLV0, CLV1, CLV2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV2 = env0; /* ARGUMENTS */ - CLV1 = _ecl_cdr(CLV2); - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = cl_functionp(v1p); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("FUNCTION",396),v1p); - value0 = cl_apply(2, v1p, ECL_CONS_CAR(CLV2)); - return value0; - } - } -} -/* function definition for CONJOIN */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L10conjoin(cl_narg narg, cl_object v1predicate, ...) -{ - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2more_predicates; - ecl_va_list args; ecl_va_start(args,v1predicate,narg,1); - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1predicate,env0); /* PREDICATE */ - v2more_predicates = cl_grab_rest_args(args); - CLV1 = env0 = CONS(v2more_predicates,env0); /* MORE-PREDICATES */ - ecl_va_end(args); - if (!(ECL_CONS_CAR(CLV1)==ECL_NIL)) { goto L1; } - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; -L1:; - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC9__g37,env0,Cblock); - value0 = v3; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G37 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC9__g37(cl_narg narg, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* MORE-PREDICATES */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1arguments; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1arguments = cl_grab_rest_args(args); - ecl_va_end(args); - if (Null(cl_apply(2, ECL_CONS_CAR(CLV0), v1arguments))) { goto L2; } - { - cl_object v2; - cl_object v3; - cl_object v4tail; - cl_object v5head; - v2 = ecl_cdr(ECL_CONS_CAR(CLV1)); - v3 = ecl_car(ECL_CONS_CAR(CLV1)); - v4tail = v2; - v5head = v3; - goto L10; -L9:; - if ((cl_apply(2, v5head, v1arguments))!=ECL_NIL) { goto L12; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L12:; - { - cl_object v6; - v6 = ecl_cdr(v4tail); - v5head = ecl_car(v4tail); - v4tail = v6; - } -L10:; - if (Null(v4tail)) { goto L17; } - goto L9; -L17:; - value0 = cl_apply(2, v5head, v1arguments); - return value0; - } -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for COMPOSE */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object L13compose(cl_narg narg, cl_object v1function, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2more_functions; - ecl_va_list args; ecl_va_start(args,v1function,narg,1); - v2more_functions = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3; - v3 = ecl_make_cfun((cl_objectfn_fixed)LC12__g42,ECL_NIL,Cblock,2); - T0 = v3; - } - value0 = cl_reduce(4, T0, v2more_functions, VV[7], v1function); - return value0; - } -} -/* local function G42 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC12__g42(cl_object v1f, cl_object v2g) -{ - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object env1 = env0; - if (Null(cl_functionp(v1f))) { goto L2; } - v3 = v1f; - goto L1; -L2:; - v3 = cl_fdefinition(v1f); -L1:; - if (Null(cl_functionp(v2g))) { goto L5; } - v4 = v2g; - goto L4; -L5:; - v4 = cl_fdefinition(v2g); -L4:; - env1 = ECL_NIL; - CLV0 = env1 = CONS(v3,env1); /* F */ - CLV1 = env1 = CONS(v4,env1); /* G */ - { - cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC11__g47,env1,Cblock); - value0 = v5; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* closure G47 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC11__g47(cl_narg narg, ...) -{ - cl_object T0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* G */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1arguments; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1arguments = cl_grab_rest_args(args); - ecl_va_end(args); - T0 = cl_apply(2, ECL_CONS_CAR(CLV1), v1arguments); - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, T0); - return value0; - } - } -} -/* local function COMPOSE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15compose(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4function; - T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } - T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } - v3 = ecl_cddr(v1); - goto L1; -L2:; - v3 = ecl_cdr(v1); -L1:; - if (!(v3==ECL_NIL)) { goto L6; } - si_dm_too_few_arguments(v1); -L6:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4function = v5; - } - { - cl_object v5args; - cl_object v6funs; - v5args = CONS(v4function,v3); - { - cl_fixnum v7; - v7 = ecl_length(v5args); - v6funs = ecl_function_dispatch(cl_env_copy,VV[28])(2, ecl_make_fixnum(v7), VV[9]) /* MAKE-GENSYM-LIST */; - } - { - cl_object v7f; - cl_object v8; - v7f = ECL_NIL; - { - cl_object v9; - v9 = v6funs; - if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - v8 = v9; - } - { - cl_object v9arg; - cl_object v10; - v9arg = ECL_NIL; - v10 = v5args; - { - cl_object v11; - cl_object v12; - v11 = ecl_list1(ECL_NIL); - v12 = v11; -L22:; - if (!(ecl_endp(v8))) { goto L24; } - goto L23; -L24:; - v7f = _ecl_car(v8); - { - cl_object v13; - v13 = _ecl_cdr(v8); - if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); - v8 = v13; - } - if (!(ecl_endp(v10))) { goto L32; } - goto L23; -L32:; - v9arg = _ecl_car(v10); - { - cl_object v13; - v13 = _ecl_cdr(v10); - if (ecl_unlikely(!ECL_LISTP(v13))) FEtype_error_list(v13); - v10 = v13; - } - { - cl_object v13; - v13 = v12; - if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); - T1 = v13; - } - T2 = cl_list(2, VV[0], v9arg); - T3 = cl_list(2, v7f, T2); - v12 = ecl_list1(T3); - (ECL_CONS_CDR(T1)=v12,T1); - goto L22; -L23:; - T0 = ecl_cdr(v11); - goto L13; - } - } - } -L13:; - T1 = LC14compose_1(v6funs); - T2 = cl_list(4, ECL_SYM("LAMBDA",452), VV[11], VV[12], T1); - value0 = cl_list(4, ECL_SYM("LET",477), T0, VV[10], T2); - return value0; - } - } - } -} -/* local function COMPOSE-1 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14compose_1(cl_object v1funs) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(ecl_cdr(v1funs))) { goto L1; } - T0 = ecl_car(v1funs); - T2 = ecl_cdr(v1funs); - T1 = LC14compose_1(T2); - value0 = cl_list(3, ECL_SYM("FUNCALL",394), T0, T1); - return value0; -L1:; - T0 = ecl_car(v1funs); - value0 = cl_list(3, ECL_SYM("APPLY",89), T0, VV[8]); - return value0; - } -} -/* function definition for MULTIPLE-VALUE-COMPOSE */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object L18multiple_value_compose(cl_narg narg, cl_object v1function, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2more_functions; - ecl_va_list args; ecl_va_start(args,v1function,narg,1); - v2more_functions = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3; - v3 = ecl_make_cfun((cl_objectfn_fixed)LC17__g60,ECL_NIL,Cblock,2); - T0 = v3; - } - value0 = cl_reduce(4, T0, v2more_functions, VV[7], v1function); - return value0; - } -} -/* local function G60 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC17__g60(cl_object v1f, cl_object v2g) -{ - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object env1 = env0; - if (Null(cl_functionp(v1f))) { goto L2; } - v3 = v1f; - goto L1; -L2:; - v3 = cl_fdefinition(v1f); -L1:; - if (Null(cl_functionp(v2g))) { goto L5; } - v4 = v2g; - goto L4; -L5:; - v4 = cl_fdefinition(v2g); -L4:; - env1 = ECL_NIL; - CLV0 = env1 = CONS(v3,env1); /* F */ - CLV1 = env1 = CONS(v4,env1); /* G */ - { - cl_object v5; - v5 = ecl_make_cclosure_va((cl_objectfn)LC16__g65,env1,Cblock); - value0 = v5; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* closure G65 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC16__g65(cl_narg narg, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* G */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1arguments; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1arguments = cl_grab_rest_args(args); - ecl_va_end(args); - { - struct ecl_stack_frame _ecl_inner_frame_aux; - cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0); - { - cl_object v2; - v2 = _ecl_inner_frame; - { - cl_object v3; - v3 = ECL_CONS_CAR(CLV0); - cl_env_copy->values[0] = cl_apply(2, ECL_CONS_CAR(CLV1), v1arguments); - ecl_stack_frame_push_values(v2);cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); - value0 = cl_env_copy->values[0]; - } - } - ecl_stack_frame_close(_ecl_inner_frame); - } - return value0; - } - } -} -/* local function MULTIPLE-VALUE-COMPOSE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC20multiple_value_compose(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4function; - T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } - T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } - v3 = ecl_cddr(v1); - goto L1; -L2:; - v3 = ecl_cdr(v1); -L1:; - if (!(v3==ECL_NIL)) { goto L6; } - si_dm_too_few_arguments(v1); -L6:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4function = v5; - } - { - cl_object v5args; - cl_object v6funs; - v5args = CONS(v4function,v3); - { - cl_fixnum v7; - v7 = ecl_length(v5args); - v6funs = ecl_function_dispatch(cl_env_copy,VV[28])(2, ecl_make_fixnum(v7), VV[14]) /* MAKE-GENSYM-LIST */; - } - { - cl_object v7; - v7 = (ECL_SYM("LIST",481)->symbol.gfdef); - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v6funs; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ECL_NIL; - v11 = v5args; - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L23:; - if (!(ecl_endp(v9))) { goto L25; } - goto L24; -L25:; - v8 = _ecl_car(v9); - { - cl_object v14; - v14 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v9 = v14; - } - if (!(ecl_endp(v11))) { goto L33; } - goto L24; -L33:; - v10 = _ecl_car(v11); - { - cl_object v14; - v14 = _ecl_cdr(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T1 = v14; - } - T2 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); - v13 = ecl_list1(T2); - (ECL_CONS_CDR(T1)=v13,T1); - goto L23; -L24:; - T0 = ecl_cdr(v12); - goto L13; - } - } - } - } -L13:; - T1 = LC19compose_1(v6funs); - T2 = cl_list(4, ECL_SYM("LAMBDA",452), VV[11], VV[12], T1); - value0 = cl_list(4, ECL_SYM("LET",477), T0, VV[10], T2); - return value0; - } - } - } -} -/* local function COMPOSE-1 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19compose_1(cl_object v1funs) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(ecl_cdr(v1funs))) { goto L1; } - T0 = ecl_car(v1funs); - T2 = ecl_cdr(v1funs); - T1 = LC19compose_1(T2); - value0 = cl_list(3, ECL_SYM("MULTIPLE-VALUE-CALL",573), T0, T1); - return value0; -L1:; - T0 = ecl_car(v1funs); - value0 = cl_list(3, ECL_SYM("APPLY",89), T0, VV[8]); - return value0; - } -} -/* function definition for CURRY */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object L22curry(cl_narg narg, cl_object v1function, ...) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2arguments; - ecl_va_list args; ecl_va_start(args,v1function,narg,1); - v2arguments = cl_grab_rest_args(args); - env0 = ECL_NIL; - CLV0 = env0 = CONS(v2arguments,env0); /* ARGUMENTS */ - ecl_va_end(args); - { - cl_object env1 = env0; - if (Null(cl_functionp(v1function))) { goto L2; } - T0 = v1function; - goto L1; -L2:; - T0 = cl_fdefinition(v1function); -L1:; - CLV1 = env1 = CONS(T0,env1); /* FN */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC21__g84,env1,Cblock); - value0 = v3; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* closure G84 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC21__g84(cl_narg narg, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* FN */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1more; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1more = cl_grab_rest_args(args); - ecl_va_end(args); - { - struct ecl_stack_frame _ecl_inner_frame_aux; - cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0); - { - cl_object v2; - v2 = _ecl_inner_frame; - { - cl_object v3; - v3 = ECL_CONS_CAR(CLV1); - cl_env_copy->values[0] = cl_values_list(ECL_CONS_CAR(CLV0)); - ecl_stack_frame_push_values(v2); - cl_env_copy->values[0] = cl_values_list(v1more); - ecl_stack_frame_push_values(v2);cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); - value0 = cl_env_copy->values[0]; - } - } - ecl_stack_frame_close(_ecl_inner_frame); - } - return value0; - } - } -} -/* local function CURRY */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC23curry(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4function; - T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } - T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } - v3 = ecl_cddr(v1); - goto L1; -L2:; - v3 = ecl_cdr(v1); -L1:; - if (!(v3==ECL_NIL)) { goto L6; } - si_dm_too_few_arguments(v1); -L6:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4function = v5; - } - { - cl_object v5; - cl_object v6; - { - cl_fixnum v7; - v7 = ecl_length(v3); - v5 = ecl_function_dispatch(cl_env_copy,VV[28])(2, ecl_make_fixnum(v7), VV[16]) /* MAKE-GENSYM-LIST */; - } - v6 = cl_gensym(1, VV[17]); - T0 = cl_list(2, VV[0], v4function); - T1 = cl_list(2, v6, T0); - { - cl_object v7; - v7 = (ECL_SYM("LIST",481)->symbol.gfdef); - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v5; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ECL_NIL; - { - cl_object v12; - v12 = v3; - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v11 = v12; - } - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L25:; - if (!(ecl_endp(v9))) { goto L27; } - goto L26; -L27:; - v8 = _ecl_car(v9); - { - cl_object v14; - v14 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v9 = v14; - } - if (!(ecl_endp(v11))) { goto L35; } - goto L26; -L35:; - v10 = _ecl_car(v11); - { - cl_object v14; - v14 = _ecl_cdr(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T3 = v14; - } - T4 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); - v13 = ecl_list1(T4); - (ECL_CONS_CDR(T3)=v13,T3); - goto L25; -L26:; - T2 = ecl_cdr(v12); - goto L13; - } - } - } - } -L13:; - T3 = CONS(T1,T2); - T4 = ecl_append(v5,VV[19]); - T5 = cl_listX(3, ECL_SYM("APPLY",89), v6, T4); - T6 = cl_list(3, ECL_SYM("LAMBDA",452), VV[18], T5); - value0 = cl_list(4, ECL_SYM("LET",477), T3, VV[10], T6); - return value0; - } - } - } -} -/* function definition for RCURRY */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object L25rcurry(cl_narg narg, cl_object v1function, ...) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2arguments; - ecl_va_list args; ecl_va_start(args,v1function,narg,1); - v2arguments = cl_grab_rest_args(args); - env0 = ECL_NIL; - CLV0 = env0 = CONS(v2arguments,env0); /* ARGUMENTS */ - ecl_va_end(args); - { - cl_object env1 = env0; - if (Null(cl_functionp(v1function))) { goto L2; } - T0 = v1function; - goto L1; -L2:; - T0 = cl_fdefinition(v1function); -L1:; - CLV1 = env1 = CONS(T0,env1); /* FN */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC24__g105,env1,Cblock); - value0 = v3; - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* closure G105 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC24__g105(cl_narg narg, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV1 = env0; /* FN */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1more; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1more = cl_grab_rest_args(args); - ecl_va_end(args); - { - struct ecl_stack_frame _ecl_inner_frame_aux; - cl_object _ecl_inner_frame = ecl_stack_frame_open(cl_env_copy,(cl_object)&_ecl_inner_frame_aux,0); - { - cl_object v2; - v2 = _ecl_inner_frame; - { - cl_object v3; - v3 = ECL_CONS_CAR(CLV1); - cl_env_copy->values[0] = cl_values_list(v1more); - ecl_stack_frame_push_values(v2); - cl_env_copy->values[0] = cl_values_list(ECL_CONS_CAR(CLV0)); - ecl_stack_frame_push_values(v2);cl_env_copy->values[0]=ecl_apply_from_stack_frame(v2,v3); - value0 = cl_env_copy->values[0]; - } - } - ecl_stack_frame_close(_ecl_inner_frame); - } - return value0; - } - } -} -/* local function NAMED-LAMBDA */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC26named_lambda(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4name; - cl_object v5lambda_list; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4name = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5lambda_list = v6; - } - T0 = cl_listX(3, v4name, v5lambda_list, v3); - T1 = ecl_list1(T0); - T2 = cl_list(2, ECL_SYM("FUNCTION",396), v4name); - value0 = cl_list(3, ECL_SYM("LABELS",451), T1, T2); - return value0; - } - } -} - -#include "lib/alexandria/functions.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclNfUD6Zhj9JNJM_UCh2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/functions.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclNfUD6Zhj9JNJM_UCh2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[2]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[3], VVtemp[4]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[5]) /* ANNOTATE */; - ecl_cmp_defun(VV[22]); /* ENSURE-FUNCTION */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[6]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[7], VVtemp[8]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[9]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[23]); /* ENSURE-FUNCTIONF/1 */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[12]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[24]); /* ENSURE-FUNCTIONF */ - si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[13]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[25]); /* DISJOIN */ - si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[17]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[26]); /* CONJOIN */ - si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[20]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; - ecl_cmp_defun(VV[27]); /* COMPOSE */ - si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[24]); - { - cl_object T0; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC15compose,ECL_NIL,Cblock,2); - T0 = v1; - } - si_put_sysprop(VV[6], ECL_SYM("COMPILER-MACRO",238), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; - ecl_cmp_defun(VV[29]); /* MULTIPLE-VALUE-COMPOSE */ - si_set_documentation(3, VV[13], ECL_SYM("FUNCTION",396), VVtemp[29]); - { - cl_object T0; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC20multiple_value_compose,ECL_NIL,Cblock,2); - T0 = v1; - } - si_put_sysprop(VV[13], ECL_SYM("COMPILER-MACRO",238), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[31]) /* ANNOTATE */; - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[32], VVtemp[33]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[34]) /* ANNOTATE */; - ecl_cmp_defun(VV[30]); /* CURRY */ - si_set_documentation(3, VV[15], ECL_SYM("FUNCTION",396), VVtemp[35]); - { - cl_object T0; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC23curry,ECL_NIL,Cblock,2); - T0 = v1; - } - si_put_sysprop(VV[15], ECL_SYM("COMPILER-MACRO",238), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[36], VVtemp[37]) /* ANNOTATE */; - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[38], VVtemp[39]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[34]) /* ANNOTATE */; - ecl_cmp_defun(VV[31]); /* RCURRY */ - si_set_documentation(3, VV[20], ECL_SYM("FUNCTION",396), VVtemp[40]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[41], VVtemp[42]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[43]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[32]); /* NAMED-LAMBDA */ - si_set_documentation(3, VV[21], ECL_SYM("FUNCTION",396), VVtemp[44]); -} diff --git a/lib/alexandria/hash-tables.cxx b/lib/alexandria/hash-tables.cxx deleted file mode 100644 index 5c105ea..0000000 --- a/lib/alexandria/hash-tables.cxx +++ /dev/null @@ -1,671 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/hash-tables.lisp */ -#include -#include "lib/alexandria/hash-tables.eclh" -/* function definition for COPY-HASH-TABLE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L2copy_hash_table(cl_narg narg, cl_object v1table, ...) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2test; - cl_object v3size; - cl_object v4rehash_size; - cl_object v5rehash_threshold; - ecl_va_list args; ecl_va_start(args,v1table,narg,1); - { - cl_object keyvars[10]; - cl_parse_key(args,5,L2copy_hash_tablekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - env0 = ECL_NIL; - CLV0 = env0 = CONS(keyvars[0],env0); /* KEY */ - v2test = keyvars[1]; - v3size = keyvars[2]; - v4rehash_size = keyvars[3]; - v5rehash_threshold = keyvars[4]; - } - value0 = ECL_CONS_CAR(CLV0); - if ((value0)!=ECL_NIL) { goto L4; } - ECL_CONS_CAR(CLV0) = ECL_SYM("IDENTITY",426); - goto L2; -L4:; - ECL_CONS_CAR(CLV0) = value0; - goto L2; -L2:; - value0 = v2test; - if ((value0)!=ECL_NIL) { goto L9; } - v2test = cl_hash_table_test(v1table); - goto L7; -L9:; - v2test = value0; - goto L7; -L7:; - value0 = v3size; - if ((value0)!=ECL_NIL) { goto L14; } - v3size = cl_hash_table_size(v1table); - goto L12; -L14:; - v3size = value0; - goto L12; -L12:; - value0 = v4rehash_size; - if ((value0)!=ECL_NIL) { goto L19; } - v4rehash_size = cl_hash_table_rehash_size(v1table); - goto L17; -L19:; - v4rehash_size = value0; - goto L17; -L17:; - value0 = v5rehash_threshold; - if ((value0)!=ECL_NIL) { goto L24; } - v5rehash_threshold = cl_hash_table_rehash_threshold(v1table); - goto L22; -L24:; - v5rehash_threshold = value0; - goto L22; -L22:; - { - cl_object env1 = env0; - T0 = cl_make_hash_table(8, ECL_SYM("TEST",1321), v2test, ECL_SYM("SIZE",1313), v3size, ECL_SYM("REHASH-SIZE",1302), v4rehash_size, ECL_SYM("REHASH-THRESHOLD",1303), v5rehash_threshold); - CLV1 = env1 = CONS(T0,env1); /* COPY */ - { - cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC1__g5,env1,Cblock); - T0 = v6; - } - cl_maphash(T0, v1table); - value0 = ECL_CONS_CAR(CLV1); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G5 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__g5(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object T0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* COPY */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v2v); - value0 = si_hash_set(v1k, ECL_CONS_CAR(CLV1), T0); - return value0; - } - } -} -/* function definition for MAPHASH-KEYS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4maphash_keys(cl_object v1function, cl_object v2table) -{ - cl_object T0; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC3__g9,env0,Cblock); - T0 = v3; - } - value0 = cl_maphash(T0, v2table); - return value0; - } -} -/* closure G9 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3__g9(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* FUNCTION */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v1k); - return value0; - } - } -} -/* function definition for MAPHASH-VALUES */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L6maphash_values(cl_object v1function, cl_object v2table) -{ - cl_object T0; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC5__g10,env0,Cblock); - T0 = v3; - } - value0 = cl_maphash(T0, v2table); - return value0; - } -} -/* closure G10 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5__g10(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* FUNCTION */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v2v); - return value0; - } - } -} -/* function definition for HASH-TABLE-KEYS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L9hash_table_keys(cl_object v1table) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object env1 = env0; - env1 = ECL_NIL; - CLV0 = env1 = CONS(ECL_NIL,env1); /* KEYS */ - { - cl_object v2; - cl_object env2 = env1; - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC7__g13,env2,Cblock); - v2 = v3; - } - CLV1 = env2 = CONS(v2,env2); /* FUNCTION */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC8__g15,env2,Cblock); - T0 = v3; - } - cl_maphash(T0, v1table); - } - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G13 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__g13(cl_narg narg, cl_object v1k, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* KEYS */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - ECL_CONS_CAR(CLV0) = CONS(v1k,ECL_CONS_CAR(CLV0)); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G15 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__g15(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* FUNCTION */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v1k); - return value0; - } - } -} -/* function definition for HASH-TABLE-VALUES */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L12hash_table_values(cl_object v1table) -{ - cl_object T0; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object env1 = env0; - env1 = ECL_NIL; - CLV0 = env1 = CONS(ECL_NIL,env1); /* VALUES */ - { - cl_object v2; - cl_object env2 = env1; - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC10__g18,env2,Cblock); - v2 = v3; - } - CLV1 = env2 = CONS(v2,env2); /* FUNCTION */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC11__g20,env2,Cblock); - T0 = v3; - } - cl_maphash(T0, v1table); - } - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G18 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10__g18(cl_narg narg, cl_object v1v, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* VALUES */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - ECL_CONS_CAR(CLV0) = CONS(v1v,ECL_CONS_CAR(CLV0)); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G20 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__g20(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* FUNCTION */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v2v); - return value0; - } - } -} -/* function definition for HASH-TABLE-ALIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L14hash_table_alist(cl_object v1table) -{ - cl_object T0; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object env1 = env0; - env1 = ECL_NIL; - CLV0 = env1 = CONS(ECL_NIL,env1); /* ALIST */ - { - cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC13__g21,env1,Cblock); - T0 = v2; - } - cl_maphash(T0, v1table); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G21 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13__g21(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object T0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* ALIST */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = CONS(v1k,v2v); - ECL_CONS_CAR(CLV0) = CONS(T0,ECL_CONS_CAR(CLV0)); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for HASH-TABLE-PLIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L16hash_table_plist(cl_object v1table) -{ - cl_object T0; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object env1 = env0; - env1 = ECL_NIL; - CLV0 = env1 = CONS(ECL_NIL,env1); /* PLIST */ - { - cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC15__g23,env1,Cblock); - T0 = v2; - } - cl_maphash(T0, v1table); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G23 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15__g23(cl_narg narg, cl_object v1k, cl_object v2v, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* PLIST */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - ECL_CONS_CAR(CLV0) = cl_listX(3, v1k, v2v, ECL_CONS_CAR(CLV0)); - value0 = ECL_CONS_CAR(CLV0); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ALIST-HASH-TABLE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L17alist_hash_table(cl_narg narg, cl_object v1alist, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2hash_table_initargs; - ecl_va_list args; ecl_va_start(args,v1alist,narg,1); - v2hash_table_initargs = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3table; - T0 = (ECL_SYM("MAKE-HASH-TABLE",528)->symbol.gfdef); - v3table = cl_apply(2, T0, v2hash_table_initargs); - { - cl_object v4; - v4 = v1alist; - goto L7; -L6:; - { - cl_object v5cons; - v5cons = ecl_car(v4); - T0 = ecl_car(v5cons); - T1 = ecl_cdr(v5cons); - si_hash_set(T0, v3table, T1); - } - v4 = ecl_cdr(v4); -L7:; - if (Null(v4)) { goto L14; } - goto L6; -L14:; - } - value0 = v3table; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for PLIST-HASH-TABLE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L18plist_hash_table(cl_narg narg, cl_object v1plist, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2hash_table_initargs; - ecl_va_list args; ecl_va_start(args,v1plist,narg,1); - v2hash_table_initargs = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3table; - T0 = (ECL_SYM("MAKE-HASH-TABLE",528)->symbol.gfdef); - v3table = cl_apply(2, T0, v2hash_table_initargs); - { - cl_object v4tail; - v4tail = v1plist; - goto L7; -L6:; - T0 = ecl_car(v4tail); - T1 = ecl_cadr(v4tail); - si_hash_set(T0, v3table, T1); - v4tail = ecl_cddr(v4tail); -L7:; - if (Null(v4tail)) { goto L12; } - goto L6; -L12:; - } - value0 = v3table; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function ENSURE-GETHASH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19ensure_gethash(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4key; - cl_object v5hash_table; - cl_object v6default; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v7; - v7 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4key = v7; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v7; - v7 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5hash_table = v7; - } - if (Null(v3)) { goto L15; } - { - cl_object v7; - v7 = ecl_car(v3); - v3 = ecl_cdr(v3); - v6default = v7; - goto L14; - } -L15:; - v6default = ECL_NIL; -L14:; - if (Null(v3)) { goto L20; } - si_dm_too_many_arguments(v1); -L20:; - T0 = cl_list(3, ECL_SYM("GETHASH",413), v4key, v5hash_table); - T1 = cl_list(3, ECL_SYM("GETHASH",413), v4key, v5hash_table); - T2 = cl_list(3, ECL_SYM("SETF",750), T1, v6default); - T3 = cl_list(3, ECL_SYM("VALUES",895), T2, ECL_NIL); - T4 = cl_list(4, ECL_SYM("IF",946), VV[11], VV[12], T3); - value0 = cl_list(4, ECL_SYM("MULTIPLE-VALUE-BIND",572), VV[10], T0, T4); - return value0; - } - } -} - -#include "lib/alexandria/hash-tables.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecl7ZmCSEYoe0NCM_yPg2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/hash-tables.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl7ZmCSEYoe0NCM_yPg2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defun(VV[13]); /* COPY-HASH-TABLE */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[5]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[19]); /* MAPHASH-KEYS */ - si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[9]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[10]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[20]); /* MAPHASH-VALUES */ - si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[13]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[21]); /* HASH-TABLE-KEYS */ - si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[17]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[22]); /* HASH-TABLE-VALUES */ - si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[20]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[23]); /* HASH-TABLE-ALIST */ - si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[23]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[24]); /* HASH-TABLE-PLIST */ - si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[26]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defun(VV[25]); /* ALIST-HASH-TABLE */ - si_set_documentation(3, VV[7], ECL_SYM("FUNCTION",396), VVtemp[30]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defun(VV[26]); /* PLIST-HASH-TABLE */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[34]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[35], VVtemp[36]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[37]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[27]); /* ENSURE-GETHASH */ - si_set_documentation(3, VV[9], ECL_SYM("FUNCTION",396), VVtemp[38]); -} diff --git a/lib/alexandria/io.cxx b/lib/alexandria/io.cxx deleted file mode 100644 index cd093eb..0000000 --- a/lib/alexandria/io.cxx +++ /dev/null @@ -1,983 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/io.lisp */ -#include -#include "lib/alexandria/io.eclh" -/* local function WITH-OPEN-FILE* */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1with_open_file_(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6stream; - cl_object v7filespec; - cl_object v8; - cl_object v9direction; - cl_object v10; - cl_object v11element_type; - cl_object v12; - cl_object v13if_exists; - cl_object v14; - cl_object v15if_does_not_exist; - cl_object v16; - cl_object v17external_format; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v18; - v18 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v18; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v18; - v18 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6stream = v18; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v18; - v18 = ecl_car(v5); - v5 = ecl_cdr(v5); - v7filespec = v18; - } - v8 = si_search_keyword(2, v5, ECL_SYM("DIRECTION",1221)); - if (!((v8)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L23; } - v9direction = ECL_NIL; - goto L22; -L23:; - v9direction = v8; -L22:; - v10 = si_search_keyword(2, v5, ECL_SYM("ELEMENT-TYPE",1227)); - if (!((v10)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L27; } - v11element_type = ECL_NIL; - goto L26; -L27:; - v11element_type = v10; -L26:; - v12 = si_search_keyword(2, v5, ECL_SYM("IF-EXISTS",1249)); - if (!((v12)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L31; } - v13if_exists = ECL_NIL; - goto L30; -L31:; - v13if_exists = v12; -L30:; - v14 = si_search_keyword(2, v5, ECL_SYM("IF-DOES-NOT-EXIST",1247)); - if (!((v14)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L35; } - v15if_does_not_exist = ECL_NIL; - goto L34; -L35:; - v15if_does_not_exist = v14; -L34:; - v16 = si_search_keyword(2, v5, ECL_SYM("EXTERNAL-FORMAT",1239)); - if (!((v16)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L39; } - v17external_format = ECL_NIL; - goto L38; -L39:; - v17external_format = v16; -L38:; - si_check_keyword(2, v5, VV[1]); - { - cl_object v18; - cl_object v19; - cl_object v20; - cl_object v21; - cl_object v22; - v18 = cl_gensym(1, VV[2]); - v19 = cl_gensym(1, VV[3]); - v20 = cl_gensym(1, VV[4]); - v21 = cl_gensym(1, VV[5]); - v22 = cl_gensym(1, VV[6]); - T0 = cl_list(2, v18, v9direction); - T1 = cl_list(2, v19, v11element_type); - T2 = cl_list(2, v20, v13if_exists); - T3 = cl_list(2, v21, v15if_does_not_exist); - T4 = cl_list(2, v22, v17external_format); - T5 = cl_list(5, T0, T1, T2, T3, T4); - T7 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("DIRECTION",1221), v18); - T8 = cl_list(3, ECL_SYM("WHEN",905), v18, T7); - T9 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("ELEMENT-TYPE",1227), v19); - T10 = cl_list(3, ECL_SYM("WHEN",905), v19, T9); - T11 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("IF-EXISTS",1249), v20); - T12 = cl_list(3, ECL_SYM("WHEN",905), v20, T11); - T13 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("IF-DOES-NOT-EXIST",1247), v21); - T14 = cl_list(3, ECL_SYM("WHEN",905), v21, T13); - T15 = cl_list(3, ECL_SYM("LIST",481), ECL_SYM("EXTERNAL-FORMAT",1239), v22); - T16 = cl_list(3, ECL_SYM("WHEN",905), v22, T15); - T17 = cl_list(6, ECL_SYM("APPEND",88), T8, T10, T12, T14, T16); - T18 = cl_list(4, ECL_SYM("APPLY",89), VV[7], v7filespec, T17); - T19 = cl_list(2, v6stream, T18); - T6 = cl_listX(3, ECL_SYM("WITH-OPEN-STREAM",912), T19, v3); - value0 = cl_list(3, ECL_SYM("LET",477), T5, T6); - return value0; - } - } - } -} -/* local function WITH-INPUT-FROM-FILE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2with_input_from_file(cl_object v1, cl_object v2) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6stream_name; - cl_object v7file_name; - cl_object v8; - cl_object v9direction_p; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v10; - v10 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v10; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6stream_name = v10; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v7file_name = v10; - } - v8 = si_search_keyword(2, v5, ECL_SYM("DIRECTION",1221)); - { - bool v10; - v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",1943)); - v9direction_p = (v10)?ECL_NIL:ECL_T; - } - si_check_keyword(3, v5, VV[9], ECL_T); - if (Null(v9direction_p)) { goto L24; } - cl_error(1, VV[10]); -L24:; - T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259), v5); - value0 = cl_listX(3, VV[0], T0, v3); - return value0; - } - } -} -/* local function WITH-OUTPUT-TO-FILE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3with_output_to_file(cl_object v1, cl_object v2) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6stream_name; - cl_object v7file_name; - cl_object v8; - cl_object v9direction_p; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v10; - v10 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v10; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6stream_name = v10; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v7file_name = v10; - } - v8 = si_search_keyword(2, v5, ECL_SYM("DIRECTION",1221)); - { - bool v10; - v10 = (v8)==(ECL_SYM("MISSING-KEYWORD",1943)); - v9direction_p = (v10)?ECL_NIL:ECL_T; - } - si_check_keyword(3, v5, VV[9], ECL_T); - if (Null(v9direction_p)) { goto L24; } - cl_error(1, VV[12]); -L24:; - T0 = cl_listX(5, v6stream_name, v7file_name, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287), v5); - value0 = cl_listX(3, VV[0], T0, v3); - return value0; - } - } -} -/* function definition for READ-FILE-INTO-STRING */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4read_file_into_string(volatile cl_narg narg, cl_object volatile v1pathname, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object volatile v2buffer_size; - cl_object volatile v3external_format; - ecl_va_list args; ecl_va_start(args,v1pathname,narg,1); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L4read_file_into_stringkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v2buffer_size = ecl_make_fixnum(4096); - } else { - v2buffer_size = keyvars[0]; - } - v3external_format = keyvars[1]; - } - { - volatile cl_object v4file_stream; - T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); - if (Null(ECL_SYM("INPUT",1259))) { goto L5; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259)); - goto L4; -L5:; - T1 = ECL_NIL; -L4:; - goto L8; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), ECL_NIL); - goto L7; -L8:; - T2 = ECL_NIL; -L7:; - goto L11; - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), ECL_NIL); - goto L10; -L11:; - T3 = ECL_NIL; -L10:; - goto L14; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); - goto L13; -L14:; - T4 = ECL_NIL; -L13:; - if (Null(v3external_format)) { goto L17; } - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), v3external_format); - goto L16; -L17:; - T5 = ECL_NIL; -L16:; - T6 = cl_append(5, T1, T2, T3, T4, T5); - v4file_stream = cl_apply(3, T0, v1pathname, T6); - { - volatile bool unwinding = FALSE; - cl_index v5=ECL_STACK_INDEX(cl_env_copy),v6; - ecl_frame_ptr next_fr; - if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { - ecl_bds_bind(cl_env_copy,ECL_SYM("*PRINT-PRETTY*",55),ECL_NIL); /* *PRINT-PRETTY* */ - { - cl_object v7datum; - v7datum = cl_make_string_output_stream(0); - { - cl_object v8buffer; - v8buffer = si_make_pure_array(ECL_SYM("CHARACTER",222), v2buffer_size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - { - cl_object v9bytes_read; - v9bytes_read = ECL_NIL; -L24:; - v9bytes_read = cl_read_sequence(2, v8buffer, v4file_stream); - cl_write_sequence(6, v8buffer, v7datum, ECL_SYM("START",1315), ecl_make_fixnum(0), ECL_SYM("END",1228), v9bytes_read); - if (ecl_number_equalp(v9bytes_read,v2buffer_size)) { goto L29; } - goto L25; -L29:; - goto L24; -L25:; - } - } - cl_env_copy->values[0] = cl_get_output_stream_string(v7datum); - ecl_bds_unwind1(cl_env_copy); - } - } - ecl_frs_pop(cl_env_copy); - v6=ecl_stack_push_values(cl_env_copy); - cl_close(1, v4file_stream); - ecl_stack_pop_values(cl_env_copy,v6); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v5); - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for WRITE-STRING-INTO-FILE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5write_string_into_file(volatile cl_narg narg, cl_object volatile v1string, cl_object volatile v2pathname, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object volatile v3if_exists; - cl_object volatile v4if_does_not_exist; - cl_object volatile v5external_format; - ecl_va_list args; ecl_va_start(args,v2pathname,narg,2); - { - cl_object keyvars[6]; - cl_parse_key(args,3,L5write_string_into_filekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[3])) { - v3if_exists = ECL_SYM("ERROR",1232); - } else { - v3if_exists = keyvars[0]; - } - v4if_does_not_exist = keyvars[1]; - v5external_format = keyvars[2]; - } - { - volatile cl_object v6file_stream; - T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); - if (Null(ECL_SYM("OUTPUT",1287))) { goto L5; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287)); - goto L4; -L5:; - T1 = ECL_NIL; -L4:; - goto L8; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), ECL_NIL); - goto L7; -L8:; - T2 = ECL_NIL; -L7:; - if (Null(v3if_exists)) { goto L11; } - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), v3if_exists); - goto L10; -L11:; - T3 = ECL_NIL; -L10:; - if (Null(v4if_does_not_exist)) { goto L14; } - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), v4if_does_not_exist); - goto L13; -L14:; - T4 = ECL_NIL; -L13:; - if (Null(v5external_format)) { goto L17; } - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), v5external_format); - goto L16; -L17:; - T5 = ECL_NIL; -L16:; - T6 = cl_append(5, T1, T2, T3, T4, T5); - v6file_stream = cl_apply(3, T0, v2pathname, T6); - { - volatile bool unwinding = FALSE; - cl_index v7=ECL_STACK_INDEX(cl_env_copy),v8; - ecl_frame_ptr next_fr; - if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { - cl_env_copy->values[0] = cl_write_sequence(2, v1string, v6file_stream); - } - ecl_frs_pop(cl_env_copy); - v8=ecl_stack_push_values(cl_env_copy); - cl_close(1, v6file_stream); - ecl_stack_pop_values(cl_env_copy,v8); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v7); - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for READ-FILE-INTO-BYTE-VECTOR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L6read_file_into_byte_vector(cl_object volatile v1pathname) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - volatile cl_object v2stream; - T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); - if (Null(ECL_SYM("INPUT",1259))) { goto L4; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259)); - goto L3; -L4:; - T1 = ECL_NIL; -L3:; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), VV[16]); - goto L6; - T2 = ECL_NIL; -L6:; - goto L10; - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), ECL_NIL); - goto L9; -L10:; - T3 = ECL_NIL; -L9:; - goto L13; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); - goto L12; -L13:; - T4 = ECL_NIL; -L12:; - goto L16; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); - goto L15; -L16:; - T5 = ECL_NIL; -L15:; - T6 = cl_append(5, T1, T2, T3, T4, T5); - v2stream = cl_apply(3, T0, v1pathname, T6); - { - volatile bool unwinding = FALSE; - cl_index v3=ECL_STACK_INDEX(cl_env_copy),v4; - ecl_frame_ptr next_fr; - if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { - { - cl_object v5length; - v5length = cl_file_length(v2stream); - goto L22; -L21:; - si_assert_failure(1, ECL_SYM("LENGTH",476)); -L22:; - if ((v5length)!=ECL_NIL) { goto L25; } - goto L21; -L25:; - { - cl_object v6result; - v6result = si_make_pure_array(ECL_SYM("BYTE8",1335), v5length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - cl_read_sequence(2, v6result, v2stream); - cl_env_copy->values[0] = v6result; - cl_env_copy->nvalues = 1; - } - } - } - ecl_frs_pop(cl_env_copy); - v4=ecl_stack_push_values(cl_env_copy); - cl_close(1, v2stream); - ecl_stack_pop_values(cl_env_copy,v4); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v3); - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for WRITE-BYTE-VECTOR-INTO-FILE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L7write_byte_vector_into_file(volatile cl_narg narg, cl_object volatile v1bytes, cl_object volatile v2pathname, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object volatile v3if_exists; - cl_object volatile v4if_does_not_exist; - ecl_va_list args; ecl_va_start(args,v2pathname,narg,2); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L7write_byte_vector_into_filekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v3if_exists = ECL_SYM("ERROR",1232); - } else { - v3if_exists = keyvars[0]; - } - v4if_does_not_exist = keyvars[1]; - } - { - cl_object v5; - v5 = v1bytes; - if ((cl_typep(2, v5, VV[18]))!=ECL_NIL) { goto L4; } - v1bytes = si_do_check_type(v5, VV[18], ECL_NIL, VV[19]); -L4:; - } - { - volatile cl_object v5stream; - T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); - if (Null(ECL_SYM("OUTPUT",1287))) { goto L10; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287)); - goto L9; -L10:; - T1 = ECL_NIL; -L9:; - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), VV[16]); - goto L12; - T2 = ECL_NIL; -L12:; - if (Null(v3if_exists)) { goto L16; } - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), v3if_exists); - goto L15; -L16:; - T3 = ECL_NIL; -L15:; - if (Null(v4if_does_not_exist)) { goto L19; } - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), v4if_does_not_exist); - goto L18; -L19:; - T4 = ECL_NIL; -L18:; - goto L22; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); - goto L21; -L22:; - T5 = ECL_NIL; -L21:; - T6 = cl_append(5, T1, T2, T3, T4, T5); - v5stream = cl_apply(3, T0, v2pathname, T6); - { - volatile bool unwinding = FALSE; - cl_index v6=ECL_STACK_INDEX(cl_env_copy),v7; - ecl_frame_ptr next_fr; - if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { - cl_env_copy->values[0] = cl_write_sequence(2, v1bytes, v5stream); - } - ecl_frs_pop(cl_env_copy); - v7=ecl_stack_push_values(cl_env_copy); - cl_close(1, v5stream); - ecl_stack_pop_values(cl_env_copy,v7); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v6); - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for COPY-FILE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L8copy_file(volatile cl_narg narg, cl_object volatile v1from, cl_object volatile v2to, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object volatile v3if_to_exists; - cl_object volatile v4element_type; - cl_object volatile v5finish_output; - ecl_va_list args; ecl_va_start(args,v2to,narg,2); - { - cl_object keyvars[6]; - cl_parse_key(args,3,L8copy_filekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[3])) { - v3if_to_exists = ECL_SYM("SUPERSEDE",1319); - } else { - v3if_to_exists = keyvars[0]; - } - if (Null(keyvars[4])) { - v4element_type = VV[16]; - } else { - v4element_type = keyvars[1]; - } - v5finish_output = keyvars[2]; - } - { - volatile cl_object v6input; - T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); - if (Null(ECL_SYM("INPUT",1259))) { goto L6; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("INPUT",1259)); - goto L5; -L6:; - T1 = ECL_NIL; -L5:; - if (Null(v4element_type)) { goto L9; } - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), v4element_type); - goto L8; -L9:; - T2 = ECL_NIL; -L8:; - goto L12; - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), ECL_NIL); - goto L11; -L12:; - T3 = ECL_NIL; -L11:; - goto L15; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); - goto L14; -L15:; - T4 = ECL_NIL; -L14:; - goto L18; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); - goto L17; -L18:; - T5 = ECL_NIL; -L17:; - T6 = cl_append(5, T1, T2, T3, T4, T5); - v6input = cl_apply(3, T0, v1from, T6); - { - volatile bool unwinding = FALSE; - cl_index v7=ECL_STACK_INDEX(cl_env_copy),v8; - ecl_frame_ptr next_fr; - if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { - { - volatile cl_object v9output; - T0 = (ECL_SYM("OPEN",611)->symbol.gfdef); - if (Null(ECL_SYM("OUTPUT",1287))) { goto L24; } - T1 = cl_list(2, ECL_SYM("DIRECTION",1221), ECL_SYM("OUTPUT",1287)); - goto L23; -L24:; - T1 = ECL_NIL; -L23:; - if (Null(v4element_type)) { goto L27; } - T2 = cl_list(2, ECL_SYM("ELEMENT-TYPE",1227), v4element_type); - goto L26; -L27:; - T2 = ECL_NIL; -L26:; - if (Null(v3if_to_exists)) { goto L30; } - T3 = cl_list(2, ECL_SYM("IF-EXISTS",1249), v3if_to_exists); - goto L29; -L30:; - T3 = ECL_NIL; -L29:; - goto L33; - T4 = cl_list(2, ECL_SYM("IF-DOES-NOT-EXIST",1247), ECL_NIL); - goto L32; -L33:; - T4 = ECL_NIL; -L32:; - goto L36; - T5 = cl_list(2, ECL_SYM("EXTERNAL-FORMAT",1239), ECL_NIL); - goto L35; -L36:; - T5 = ECL_NIL; -L35:; - T6 = cl_append(5, T1, T2, T3, T4, T5); - v9output = cl_apply(3, T0, v2to, T6); - { - volatile bool unwinding = FALSE; - cl_index v10=ECL_STACK_INDEX(cl_env_copy),v11; - ecl_frame_ptr next_fr; - if (ecl_frs_push(cl_env_copy,ECL_PROTECT_TAG)) { - unwinding = TRUE; next_fr=cl_env_copy->nlj_fr; - } else { - cl_env_copy->values[0] = L9copy_stream(6, v6input, v9output, ECL_SYM("ELEMENT-TYPE",1227), v4element_type, VV[21], v5finish_output); - } - ecl_frs_pop(cl_env_copy); - v11=ecl_stack_push_values(cl_env_copy); - cl_close(1, v9output); - ecl_stack_pop_values(cl_env_copy,v11); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v10); - } - } - } - ecl_frs_pop(cl_env_copy); - v8=ecl_stack_push_values(cl_env_copy); - cl_close(1, v6input); - ecl_stack_pop_values(cl_env_copy,v8); - if (unwinding) ecl_unwind(cl_env_copy,next_fr); - ECL_STACK_SET_INDEX(cl_env_copy,v7); - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for COPY-STREAM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L9copy_stream(cl_narg narg, cl_object v1input, cl_object v2output, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3element_type; - cl_object v4buffer_size; - cl_object v5buffer; - cl_object v6start; - cl_object v7end; - cl_object v8finish_output; - ecl_va_list args; ecl_va_start(args,v2output,narg,2); - { - cl_object keyvars[12]; - cl_parse_key(args,6,L9copy_streamkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[6])) { - v3element_type = cl_stream_element_type(v1input); - } else { - v3element_type = keyvars[0]; - } - if (Null(keyvars[7])) { - v4buffer_size = ecl_make_fixnum(4096); - } else { - v4buffer_size = keyvars[1]; - } - if (Null(keyvars[8])) { - v5buffer = si_make_pure_array(v3element_type, v4buffer_size, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - } else { - v5buffer = keyvars[2]; - } - if (Null(keyvars[9])) { - v6start = ecl_make_fixnum(0); - } else { - v6start = keyvars[3]; - } - v7end = keyvars[4]; - v8finish_output = keyvars[5]; - } - { - cl_object v9; - v9 = v6start; - { - cl_object v10; - v10 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L11; } - v10 = v9; - if (ecl_number_compare(v10,ecl_make_fixnum(0))>=0) { goto L7; } - goto L8; -L11:; - goto L8; - } -L8:; - v6start = si_do_check_type(v9, VV[23], ECL_NIL, VV[24]); -L7:; - } - { - cl_object v9; - v9 = v7end; - if (v9==ECL_NIL) { goto L18; } - { - cl_object v10; - v10 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L23; } - v10 = v9; - if (ecl_number_compare(v10,ecl_make_fixnum(0))>=0) { goto L18; } - goto L19; -L23:; - goto L19; - } -L19:; - v7end = si_do_check_type(v9, VV[25], ECL_NIL, VV[26]); -L18:; - } - { - cl_object v9; - v9 = v4buffer_size; - { - cl_object v10; - v10 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v9)||ECL_BIGNUMP(v9))) { goto L34; } - v10 = v9; - if (ecl_number_compare(v10,ecl_make_fixnum(1))>=0) { goto L30; } - goto L31; -L34:; - goto L31; - } -L31:; - v4buffer_size = si_do_check_type(v9, VV[27], ECL_NIL, VV[28]); -L30:; - } - if (Null(v7end)) { goto L39; } - if (!(ecl_number_compare(v7end,v6start)<0)) { goto L39; } - cl_error(2, VV[29], VV[22]); -L39:; - { - cl_object v9output_position; - cl_object v10input_position; - v9output_position = ecl_make_fixnum(0); - v10input_position = ecl_make_fixnum(0); - if (ecl_zerop(v6start)) { goto L44; } -L46:; - if (ecl_number_compare(v10input_position,v6start)<0) { goto L48; } - goto L47; -L48:; - { - cl_fixnum v11n; - { - cl_fixnum v12; - v12 = ecl_length(v5buffer); - T0 = ecl_minus(v6start,v10input_position); - T1 = (ecl_number_compare(ecl_make_fixnum(v12),T0)<=0?ecl_make_fixnum(v12):T0); - v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1228), T1)); - } - if (!((v11n)==0)) { goto L52; } - cl_error(3, VV[30], VV[22], v6start); -L52:; - v10input_position = ecl_plus(v10input_position,ecl_make_fixnum(v11n)); - } - goto L46; -L47:; -L44:; - goto L58; -L57:; - si_assert_failure(1, VV[31]); -L58:; - if (ecl_number_equalp(v10input_position,v6start)) { goto L61; } - goto L57; -L61:; -L64:; - if (v7end==ECL_NIL) { goto L66; } - if (ecl_number_compare(v10input_position,v7end)<0) { goto L66; } - goto L65; -L66:; - { - cl_fixnum v11n; - if (Null(v7end)) { goto L72; } - { - cl_fixnum v12; - v12 = ecl_length(v5buffer); - T1 = ecl_minus(v7end,v10input_position); - T0 = (ecl_number_compare(ecl_make_fixnum(v12),T1)<=0?ecl_make_fixnum(v12):T1); - goto L71; - } -L72:; - T0 = ECL_NIL; -L71:; - v11n = ecl_fixnum(cl_read_sequence(4, v5buffer, v1input, ECL_SYM("END",1228), T0)); - if (!((v11n)==0)) { goto L74; } - if (Null(v7end)) { goto L76; } - cl_error(3, VV[32], VV[22], v7end); - goto L74; -L76:; - goto L63; -L74:; - v10input_position = ecl_plus(v10input_position,ecl_make_fixnum(v11n)); - cl_write_sequence(4, v5buffer, v2output, ECL_SYM("END",1228), ecl_make_fixnum(v11n)); - v9output_position = ecl_plus(v9output_position,ecl_make_fixnum(v11n)); - } - goto L64; -L65:; -L63:; - if (Null(v8finish_output)) { goto L83; } - cl_finish_output(1, v2output); -L83:; - value0 = v9output_position; - cl_env_copy->nvalues = 1; - return value0; - } - } -} - -#include "lib/alexandria/io.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecliPHAkciDuw0AM_tih2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/io.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecliPHAkciDuw0AM_tih2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[33]); /* WITH-OPEN-FILE* */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[34]); /* WITH-INPUT-FROM-FILE */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[8]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[35]); /* WITH-OUTPUT-TO-FILE */ - si_set_documentation(3, VV[11], ECL_SYM("FUNCTION",396), VVtemp[11]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[36]); /* READ-FILE-INTO-STRING */ - si_set_documentation(3, VV[13], ECL_SYM("FUNCTION",396), VVtemp[15]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[39]); /* WRITE-STRING-INTO-FILE */ - si_set_documentation(3, VV[14], ECL_SYM("FUNCTION",396), VVtemp[19]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[22]) /* ANNOTATE */; - ecl_cmp_defun(VV[43]); /* READ-FILE-INTO-BYTE-VECTOR */ - si_set_documentation(3, VV[15], ECL_SYM("FUNCTION",396), VVtemp[23]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[24], VVtemp[25]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[26]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* WRITE-BYTE-VECTOR-INTO-FILE */ - si_set_documentation(3, VV[17], ECL_SYM("FUNCTION",396), VVtemp[27]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[28], VVtemp[29]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[30]) /* ANNOTATE */; - ecl_cmp_defun(VV[45]); /* COPY-FILE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* COPY-STREAM */ - si_set_documentation(3, VV[22], ECL_SYM("FUNCTION",396), VVtemp[34]); -} diff --git a/lib/alexandria/lists.cxx b/lib/alexandria/lists.cxx deleted file mode 100644 index f6c6402..0000000 --- a/lib/alexandria/lists.cxx +++ /dev/null @@ -1,3087 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/lists.lisp */ -#include -#include "lib/alexandria/lists.eclh" -/* function definition for SAFE-ENDP */ -/* optimize speed 3, debug 0, space 0, safety 3 */ -static cl_object L1safe_endp(cl_object v1x) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = ecl_make_bool(ecl_endp(v1x)); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for ALIST-PLIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L2alist_plist(cl_object v1alist) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2plist; - v2plist = ECL_NIL; - { - cl_object v3; - v3 = v1alist; - goto L6; -L5:; - { - cl_object v4pair; - v4pair = ecl_car(v3); - T0 = ecl_car(v4pair); - v2plist = CONS(T0,v2plist); - T0 = ecl_cdr(v4pair); - v2plist = CONS(T0,v2plist); - } - v3 = ecl_cdr(v3); -L6:; - if (Null(v3)) { goto L16; } - goto L5; -L16:; - } - value0 = cl_nreverse(v2plist); - return value0; - } - } -} -/* function definition for PLIST-ALIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L3plist_alist(cl_object v1plist) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2alist; - v2alist = ECL_NIL; - { - cl_object v3tail; - v3tail = v1plist; - goto L5; -L4:; - T0 = ecl_car(v3tail); - T1 = ecl_cadr(v3tail); - T2 = CONS(T0,T1); - v2alist = CONS(T2,v2alist); - v3tail = ecl_cddr(v3tail); -L5:; - if (ecl_endp(v3tail)) { goto L11; } - goto L4; -L11:; - value0 = cl_nreverse(v2alist); - return value0; - } - } - } -} -/* function definition for RACONS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4racons(cl_object v1key, cl_object v2value, cl_object v3ralist) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_acons(v2value, v1key, v3ralist); - return value0; - } -} -/* function definition for ASSOC-VALUE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5assoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3test; - ecl_va_list args; ecl_va_start(args,v2key,narg,2); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L5assoc_valuekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v3test = ECL_SYM("EQL",334); - } else { - v3test = keyvars[0]; - } - } - { - cl_object v4entry; - { - cl_object v5; - v5 = v1alist; - goto L6; -L5:; - { - cl_object v6; - cl_object v7; - { - cl_object v8; - v8 = v5; - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - v6 = v8; - } - v7 = ECL_CONS_CAR(v6); - if (Null(v7)) { goto L8; } - { - cl_object v8; - { - cl_object v9; - v9 = v7; - if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - T0 = v9; - } - v8 = ECL_CONS_CAR(T0); - if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v2key, v8))) { goto L8; } - v4entry = v7; - goto L2; - } - } -L8:; - v5 = ECL_CONS_CDR(v5); -L6:; - if (v5==ECL_NIL) { goto L21; } - goto L5; -L21:; - v4entry = ECL_NIL; - } -L2:; - T0 = ecl_cdr(v4entry); - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = v4entry; - cl_env_copy->values[0] = T0; - return cl_env_copy->values[0]; - } - } -} -/* local function ASSOC-VALUE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6assoc_value(cl_narg narg, cl_object v1env, cl_object v2place, cl_object v3key, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<3)) FEwrong_num_arguments_anonym(); - { - cl_object v4test; - ecl_va_list args; ecl_va_start(args,v3key,narg,3); - { - cl_object keyvars[2]; - cl_parse_key(args,1,LC6assoc_valuekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v4test = VV[5]; - } else { - v4test = keyvars[0]; - } - } - { - cl_object v6; /* TEMPORARY-VARIABLES */ - cl_object v7; /* INITFORMS */ - cl_object v8; /* NEWVALS */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v2place, v1env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - if (Null(ecl_cdr(v8))) { goto L3; } - cl_error(2, VV[6], VV[4]); -L3:; - { - cl_object v11; - cl_object v12; - cl_object v13; - cl_object v14; - cl_object v15; - v11 = cl_gensym(1, VV[7]); - v12 = cl_gensym(1, VV[8]); - v13 = cl_gensym(1, VV[9]); - v14 = cl_gensym(1, VV[10]); - v15 = cl_gensym(1, VV[11]); - T0 = cl_list(4, v14, v12, v13, v15); - T1 = ecl_append(v6,T0); - T2 = cl_list(5, ECL_SYM("ASSOC",114), v12, v14, ECL_SYM("TEST",1321), v13); - T3 = cl_list(4, v10, v3key, v4test, T2); - T4 = ecl_append(v7,T3); - T5 = ecl_list1(v11); - T6 = cl_list(2, ECL_SYM("CDR",198), v15); - T7 = cl_list(3, ECL_SYM("SETF",750), T6, v11); - T8 = cl_list(2, v15, T7); - T9 = ecl_car(v8); - T10 = cl_list(4, ECL_SYM("ACONS",79), v3key, v11, v14); - T11 = cl_list(3, ECL_SYM("SETF",750), T9, T10); - T12 = cl_list(5, ECL_SYM("LET",477), v8, T11, v9, v11); - T13 = cl_list(2, ECL_T, T12); - T14 = cl_list(3, ECL_SYM("COND",247), T8, T13); - T15 = cl_list(2, ECL_SYM("CDR",198), v15); - cl_env_copy->nvalues = 5; - cl_env_copy->values[4] = T15; - cl_env_copy->values[3] = T14; - cl_env_copy->values[2] = T5; - cl_env_copy->values[1] = T4; - cl_env_copy->values[0] = T1; - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for RASSOC-VALUE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L7rassoc_value(cl_narg narg, cl_object v1alist, cl_object v2key, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3test; - ecl_va_list args; ecl_va_start(args,v2key,narg,2); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L7rassoc_valuekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v3test = ECL_SYM("EQL",334); - } else { - v3test = keyvars[0]; - } - } - { - cl_object v4entry; - v4entry = cl_rassoc(4, v2key, v1alist, ECL_SYM("TEST",1321), v3test); - T0 = ecl_car(v4entry); - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = v4entry; - cl_env_copy->values[0] = T0; - return cl_env_copy->values[0]; - } - } -} -/* local function RASSOC-VALUE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8rassoc_value(cl_narg narg, cl_object v1env, cl_object v2place, cl_object v3key, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<3)) FEwrong_num_arguments_anonym(); - { - cl_object v4test; - ecl_va_list args; ecl_va_start(args,v3key,narg,3); - { - cl_object keyvars[2]; - cl_parse_key(args,1,LC8rassoc_valuekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v4test = VV[5]; - } else { - v4test = keyvars[0]; - } - } - { - cl_object v6; /* TEMPORARY-VARIABLES */ - cl_object v7; /* INITFORMS */ - cl_object v8; /* NEWVALS */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v2place, v1env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - if (Null(ecl_cdr(v8))) { goto L3; } - cl_error(2, VV[6], VV[12]); -L3:; - { - cl_object v11; - cl_object v12; - cl_object v13; - cl_object v14; - cl_object v15; - v11 = cl_gensym(1, VV[7]); - v12 = cl_gensym(1, VV[8]); - v13 = cl_gensym(1, VV[9]); - v14 = cl_gensym(1, VV[10]); - v15 = cl_gensym(1, VV[11]); - T0 = cl_list(4, v14, v12, v13, v15); - T1 = ecl_append(v6,T0); - T2 = cl_list(5, ECL_SYM("RASSOC",683), v12, v14, ECL_SYM("TEST",1321), v13); - T3 = cl_list(4, v10, v3key, v4test, T2); - T4 = ecl_append(v7,T3); - T5 = ecl_list1(v11); - T6 = cl_list(2, ECL_SYM("CAR",180), v15); - T7 = cl_list(3, ECL_SYM("SETF",750), T6, v11); - T8 = cl_list(2, v15, T7); - T9 = ecl_car(v8); - T10 = cl_list(4, VV[3], v3key, v11, v14); - T11 = cl_list(3, ECL_SYM("SETF",750), T9, T10); - T12 = cl_list(5, ECL_SYM("LET",477), v8, T11, v9, v11); - T13 = cl_list(2, ECL_T, T12); - T14 = cl_list(3, ECL_SYM("COND",247), T8, T13); - T15 = cl_list(2, ECL_SYM("CAR",180), v15); - cl_env_copy->nvalues = 5; - cl_env_copy->values[4] = T15; - cl_env_copy->values[3] = T14; - cl_env_copy->values[2] = T5; - cl_env_copy->values[1] = T4; - cl_env_copy->values[0] = T1; - return cl_env_copy->values[0]; - } - } - } -} -/* function definition for MALFORMED-PLIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L9malformed_plist(cl_object v1plist) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_error(2, VV[14], v1plist); - return value0; - } -} -/* local function DOPLIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10doplist(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4; - cl_object v5; - cl_object v6key; - cl_object v7val; - cl_object v8plist; - cl_object v9values; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v10; - v10 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4 = v10; - } - v5 = v4; - if (!(v5==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1); -L10:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v6key = v10; - } - if (!(v5==ECL_NIL)) { goto L16; } - si_dm_too_few_arguments(v1); -L16:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v7val = v10; - } - if (!(v5==ECL_NIL)) { goto L22; } - si_dm_too_few_arguments(v1); -L22:; - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v8plist = v10; - } - if (Null(v5)) { goto L28; } - { - cl_object v10; - v10 = ecl_car(v5); - v5 = ecl_cdr(v5); - v9values = v10; - goto L27; - } -L28:; - v9values = ECL_NIL; -L27:; - if (Null(v5)) { goto L33; } - si_dm_too_many_arguments(v1); -L33:; - { - cl_object v11; /* FORMS */ - cl_object v12; /* DECLARATIONS */ - value0 = ecl_function_dispatch(cl_env_copy,VV[62])(1, v3) /* PARSE-BODY */; - v11 = value0; - { - const int v13 = cl_env_copy->nvalues; - cl_object v14; - v14 = (v13<=1)? ECL_NIL : cl_env_copy->values[1]; - v12 = v14; - } - { - cl_object v13; - cl_object v14; - cl_object v15; - v13 = cl_gensym(1, VV[16]); - v14 = cl_gensym(1, VV[17]); - v15 = cl_gensym(1, VV[18]); - T0 = cl_list(2, v6key, v7val); - T1 = cl_list(3, ECL_SYM("IGNORABLE",427), v6key, v7val); - T2 = cl_list(2, ECL_SYM("DECLARE",274), T1); - T3 = cl_list(2, ECL_SYM("RETURN",724), v9values); - T4 = cl_list(4, ECL_SYM("LET",477), T0, T2, T3); - T5 = cl_list(3, v15, ECL_NIL, T4); - T6 = ecl_list1(T5); - T7 = cl_list(2, v13, v8plist); - T8 = cl_list(2, ECL_SYM("POP",643), v13); - T9 = ecl_list1(v15); - T10 = cl_list(4, ECL_SYM("IF",946), v13, T8, T9); - T11 = cl_list(2, v6key, T10); - T12 = cl_list(2, ECL_SYM("POP",643), v13); - T13 = cl_list(2, ECL_SYM("QUOTE",679), v8plist); - T14 = cl_list(2, VV[13], T13); - T15 = cl_list(4, ECL_SYM("IF",946), v13, T12, T14); - T16 = cl_list(2, v7val, T15); - T17 = cl_list(3, T7, T11, T16); - T18 = cl_list(3, ECL_SYM("IGNORABLE",427), v6key, v7val); - T19 = cl_list(2, ECL_SYM("DECLARE",274), T18); - T20 = cl_list(2, ECL_SYM("POP",643), v13); - T21 = ecl_list1(v15); - T22 = cl_list(4, ECL_SYM("IF",946), v13, T20, T21); - T23 = cl_list(2, ECL_SYM("POP",643), v13); - T24 = cl_list(2, ECL_SYM("QUOTE",679), v8plist); - T25 = cl_list(2, VV[13], T24); - T26 = cl_list(4, ECL_SYM("IF",946), v13, T23, T25); - T27 = cl_list(5, ECL_SYM("SETF",750), v6key, T22, v7val, T26); - T28 = cl_list(2, ECL_SYM("GO",414), v14); - T29 = cl_list(2, T27, T28); - T30 = ecl_append(v11,T29); - T31 = cl_listX(3, ECL_SYM("TAGBODY",850), v14, T30); - T32 = ecl_list1(T31); - T33 = ecl_append(v12,T32); - T34 = cl_listX(4, ECL_SYM("LET*",478), T17, T19, T33); - T35 = cl_list(3, ECL_SYM("FLET",373), T6, T34); - value0 = cl_list(3, ECL_SYM("BLOCK",137), ECL_NIL, T35); - return value0; - } - } - } - } -} -/* local function APPENDF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12appendf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC11__g54,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("APPEND",88), v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L11:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L20; -L19:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L20:; - if (v12si__d==ECL_NIL) { goto L26; } - goto L19; -L26:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L31; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, ECL_SYM("APPEND",88), v10, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L30; -L31:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("APPEND",88), v10, T3); -L30:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G54 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__g54(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function NCONCF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14nconcf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC13__g65,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("NCONC",581), v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L11:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L20; -L19:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L20:; - if (v12si__d==ECL_NIL) { goto L26; } - goto L19; -L26:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L31; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, ECL_SYM("NCONC",581), v10, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L30; -L31:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("NCONC",581), v10, T3); -L30:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G65 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13__g65(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function UNIONF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC16unionf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - cl_object v5list; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5list = v6; - } - { - cl_object v7; /* VARS */ - cl_object v8; /* VALS */ - cl_object v9; /* STORES */ - cl_object v10; /* SETTER */ - cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - { - cl_object v12si__all_vars; - { - cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC15__g77,ECL_NIL,Cblock,1); - T0 = v13; - } - T1 = CONS(v5list,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("UNION",882), v11, T1); - T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L17:; - { - cl_object v13si__d; - cl_object v14si__v; - cl_object v15si__let_list; - v13si__d = v7; - v14si__v = v8; - v15si__let_list = ECL_NIL; - goto L26; -L25:; - { - cl_object v16; - v16 = ecl_cdr(v13si__d); - { - cl_object v17; - v17 = ecl_cdr(v14si__v); - T0 = ecl_car(v13si__d); - T1 = ecl_car(v14si__v); - T2 = cl_list(2, T0, T1); - v15si__let_list = CONS(T2,v15si__let_list); - v14si__v = v17; - v13si__d = v16; - } - } -L26:; - if (v13si__d==ECL_NIL) { goto L32; } - goto L25; -L32:; - T0 = ecl_car(v9); - if (!(ECL_LISTP(v4si___reference))) { goto L37; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(4, ECL_SYM("UNION",882), v11, v5list, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L36; -L37:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("UNION",882), v11, T3); -L36:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v7); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); - return value0; - } - } - } - } - } -} -/* local function G77 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15__g77(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function NUNIONF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC18nunionf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - cl_object v5list; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5list = v6; - } - { - cl_object v7; /* VARS */ - cl_object v8; /* VALS */ - cl_object v9; /* STORES */ - cl_object v10; /* SETTER */ - cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - { - cl_object v12si__all_vars; - { - cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC17__g89,ECL_NIL,Cblock,1); - T0 = v13; - } - T1 = CONS(v5list,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("NUNION",609), v11, T1); - T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L17:; - { - cl_object v13si__d; - cl_object v14si__v; - cl_object v15si__let_list; - v13si__d = v7; - v14si__v = v8; - v15si__let_list = ECL_NIL; - goto L26; -L25:; - { - cl_object v16; - v16 = ecl_cdr(v13si__d); - { - cl_object v17; - v17 = ecl_cdr(v14si__v); - T0 = ecl_car(v13si__d); - T1 = ecl_car(v14si__v); - T2 = cl_list(2, T0, T1); - v15si__let_list = CONS(T2,v15si__let_list); - v14si__v = v17; - v13si__d = v16; - } - } -L26:; - if (v13si__d==ECL_NIL) { goto L32; } - goto L25; -L32:; - T0 = ecl_car(v9); - if (!(ECL_LISTP(v4si___reference))) { goto L37; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(4, ECL_SYM("NUNION",609), v11, v5list, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L36; -L37:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("NUNION",609), v11, T3); -L36:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v7); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); - return value0; - } - } - } - } - } -} -/* local function G89 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC17__g89(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function REVERSEF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC20reversef(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - if (Null(v3)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC19__g100,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = ECL_NIL; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L13; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("REVERSE",727), v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L13:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L22; -L21:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L22:; - if (v12si__d==ECL_NIL) { goto L28; } - goto L21; -L28:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L33; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L33; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, ECL_SYM("REVERSE",727), v10, ECL_NIL); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L32; -L33:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("REVERSE",727), v10, T3); -L32:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G100 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19__g100(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function NREVERSEF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC22nreversef(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - if (Null(v3)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC21__g111,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = ECL_NIL; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L13; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("NREVERSE",589), v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L13:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L22; -L21:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L22:; - if (v12si__d==ECL_NIL) { goto L28; } - goto L21; -L28:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L33; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L33; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, ECL_SYM("NREVERSE",589), v10, ECL_NIL); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L32; -L33:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("NREVERSE",589), v10, T3); -L32:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G111 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC21__g111(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* function definition for CIRCULAR-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L23circular_list(cl_narg narg, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - cl_object v1elements; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1elements = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v2cycle; - v2cycle = cl_copy_list(v1elements); - value0 = ecl_nconc(v2cycle,v2cycle); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for CIRCULAR-LIST-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L24circular_list_p(cl_object v1object) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LISTP(v1object))) { goto L2; } - { - cl_object v2; - cl_object v3fast; - cl_object v4slow; - T0 = ecl_car(v1object); - T1 = ecl_cdr(v1object); - v2 = CONS(T0,T1); - v3fast = v1object; - v4slow = v2; - goto L9; -L8:; - if (!(ECL_CONSP(v3fast))) { goto L14; } - T0 = ecl_cdr(v3fast); - if (ECL_LISTP(T0)) { goto L11; } - goto L12; -L14:; - goto L12; -L12:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L11:; - if (!((v3fast)==(v4slow))) { goto L16; } - value0 = ECL_T; - cl_env_copy->nvalues = 1; - return value0; -L16:; - v3fast = ecl_cddr(v3fast); - v4slow = ecl_cdr(v4slow); -L9:; - goto L8; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for CIRCULAR-TREE-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L26circular_tree_p(cl_object volatile v1object) -{ - volatile cl_object lex0[1]; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object volatile value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - lex0[0] = ECL_NEW_FRAME_ID(cl_env_copy); /* CIRCULAR-TREE-P */ - if (ecl_frs_push(cl_env_copy,lex0[0])!=0) { - value0 = cl_env_copy->values[0]; - ecl_frs_pop(cl_env_copy); - return value0; - } else { - value0 = LC25circularp(lex0, v1object, ECL_NIL); - ecl_frs_pop(cl_env_copy); - return value0;} - } - } -} -/* local function CIRCULARP */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC25circularp(volatile cl_object *lex0, cl_object v1object, cl_object v2seen) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_CONSP(v1object))) { goto L2; } - { - cl_object v3; - cl_object v4fast; - cl_object v5slow; - T0 = ecl_car(v1object); - T1 = ecl_cdr(v1object); - v3 = CONS(T0,T1); - v4fast = v3; - v5slow = v1object; - goto L9; -L8:; - if ((v4fast)==(v5slow)) { goto L13; } - if (Null(ecl_memql(v5slow,v2seen))) { goto L11; } - goto L12; -L13:; -L12:; - cl_env_copy->values[0] = ECL_T; - cl_env_copy->nvalues = 1; - cl_return_from(lex0[0],ECL_NIL); -L11:; - if (!(ECL_CONSP(v4fast))) { goto L18; } - T0 = ecl_cdr(v5slow); - if (ECL_CONSP(T0)) { goto L16; } - goto L17; -L18:; -L17:; - { - cl_object v6tail; - v6tail = v1object; - goto L23; -L22:; - { - cl_object v7elt; - v7elt = ecl_car(v6tail); - T0 = CONS(v1object,v2seen); - LC25circularp(lex0, v7elt, T0); - } - v6tail = ecl_cdr(v6tail); -L23:; - if (!(ECL_CONSP(v6tail))) { goto L29; } - goto L22; -L29:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L16:; - v4fast = ecl_cddr(v4fast); - v5slow = ecl_cdr(v5slow); -L9:; - goto L8; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for PROPER-LIST-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L27proper_list_p(cl_object v1object) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if ((v1object)!=ECL_NIL) { goto L1; } - value0 = ECL_T; - cl_env_copy->nvalues = 1; - return value0; -L1:; - if (!(ECL_CONSP(v1object))) { goto L3; } - { - cl_object v2; - cl_object v3fast; - cl_object v4slow; - T0 = ecl_car(v1object); - T1 = ecl_cdr(v1object); - v2 = CONS(T0,T1); - v3fast = v1object; - v4slow = v2; - goto L10; -L9:; - if (!(ECL_LISTP(v3fast))) { goto L15; } - T0 = ecl_cdr(v3fast); - if (ECL_CONSP(T0)) { goto L12; } - goto L13; -L15:; - goto L13; -L13:; - if (!(ECL_LISTP(v3fast))) { goto L18; } - T0 = ecl_cdr(v3fast); - value0 = Null(T0)?ECL_T:ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L18:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L12:; - if (!((v3fast)==(v4slow))) { goto L20; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L20:; - v3fast = ecl_cddr(v3fast); - v4slow = ecl_cdr(v4slow); -L10:; - goto L9; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L3:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function PROPER-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC28proper_list(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = VV[31]; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for CIRCULAR-LIST-ERROR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L29circular_list_error(cl_object v1list) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1list, ECL_SYM("EXPECTED-TYPE",1235), VV[33]); - return value0; - } -} -/* function definition for PROPER-LIST-LENGTH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L30proper_list_length(cl_object v1list) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - cl_object v3last; - cl_object v4fast; - cl_object v5slow; - cl_fixnum v6n; - T0 = ecl_car(v1list); - T1 = ecl_cdr(v1list); - v2 = CONS(T0,T1); - v3last = v1list; - v4fast = v1list; - v5slow = v2; - v6n = 1; - goto L8; -L7:; - if (!(ecl_endp(v4fast))) { goto L10; } - value0 = ecl_make_integer((v6n)-1); - cl_env_copy->nvalues = 1; - return value0; -L10:; - { - cl_object v7; - v7 = ecl_cdr(v4fast); - if (!(ecl_endp(v7))) { goto L12; } - } - value0 = ecl_make_fixnum(v6n); - cl_env_copy->nvalues = 1; - return value0; -L12:; - if (!((v4fast)==(v5slow))) { goto L15; } - L29circular_list_error(v1list); -L15:; - v3last = v4fast; - v4fast = ecl_cddr(v4fast); - v5slow = ecl_cdr(v5slow); - { - cl_object v7; - v7 = ecl_plus(ecl_make_fixnum(v6n),ecl_make_fixnum(2)); - { - bool v8; - v8 = ECL_FIXNUMP(v7); - if (ecl_unlikely(!(v8))) - FEwrong_type_argument(ECL_SYM("FIXNUM",372),v7); - } - v6n = ecl_fixnum(v7); - } -L8:; - goto L7; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for LASTCAR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L31lastcar(cl_object v1list) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - cl_object v3last; - cl_object v4fast; - cl_object v5slow; - T0 = ecl_car(v1list); - T1 = ecl_cdr(v1list); - v2 = CONS(T0,T1); - v3last = v1list; - v4fast = v1list; - v5slow = v2; - goto L7; -L6:; - if (!(ecl_endp(v4fast))) { goto L9; } - value0 = ecl_cadr(v3last); - cl_env_copy->nvalues = 1; - return value0; -L9:; - { - cl_object v6; - v6 = ecl_cdr(v4fast); - if (!(ecl_endp(v6))) { goto L11; } - } - value0 = ecl_car(v4fast); - cl_env_copy->nvalues = 1; - return value0; -L11:; - if (!((v4fast)==(v5slow))) { goto L14; } - L29circular_list_error(v1list); -L14:; - v3last = v4fast; - v4fast = ecl_cddr(v4fast); - v5slow = ecl_cdr(v5slow); -L7:; - goto L6; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for (SETF LASTCAR) */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L32_setf_lastcar_(cl_object v1object, cl_object v2list) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4last; - cl_object v5fast; - cl_object v6slow; - T0 = ecl_car(v2list); - T1 = ecl_cdr(v2list); - v3 = CONS(T0,T1); - v4last = v2list; - v5fast = v2list; - v6slow = v3; - goto L7; -L6:; - if (!(ecl_endp(v5fast))) { goto L9; } - { - cl_object v7; - v7 = v1object; - { - cl_object v8; - v8 = ecl_cdr(v4last); - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - T0 = v8; - } - (ECL_CONS_CAR(T0)=v7,T0); - value0 = v7; - cl_env_copy->nvalues = 1; - return value0; - } -L9:; - { - cl_object v7; - v7 = ecl_cdr(v5fast); - if (!(ecl_endp(v7))) { goto L16; } - } - { - cl_object v7; - v7 = v1object; - { - cl_object v8; - v8 = v5fast; - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - T0 = v8; - } - (ECL_CONS_CAR(T0)=v7,T0); - value0 = v7; - cl_env_copy->nvalues = 1; - return value0; - } -L16:; - if (!((v5fast)==(v6slow))) { goto L24; } - L29circular_list_error(v2list); -L24:; - v4last = v5fast; - v5fast = ecl_cddr(v5fast); - v6slow = ecl_cdr(v6slow); -L7:; - goto L6; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MAKE-CIRCULAR-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L33make_circular_list(cl_narg narg, cl_object v1length, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2initial_element; - ecl_va_list args; ecl_va_start(args,v1length,narg,1); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L33make_circular_listkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - v2initial_element = keyvars[0]; - } - { - cl_object v3cycle; - v3cycle = cl_make_list(3, v1length, ECL_SYM("INITIAL-ELEMENT",1256), v2initial_element); - value0 = ecl_nconc(v3cycle,v3cycle); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function CIRCULAR-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC34circular_list(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = VV[38]; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for ENSURE-CAR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L35ensure_car(cl_object v1thing) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_CONSP(v1thing))) { goto L1; } - value0 = ecl_car(v1thing); - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = v1thing; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for ENSURE-CONS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L36ensure_cons(cl_object v1cons) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_CONSP(v1cons))) { goto L1; } - value0 = v1cons; - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = CONS(v1cons,ECL_NIL); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for ENSURE-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L37ensure_list(cl_object v1list) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LISTP(v1list))) { goto L1; } - value0 = v1list; - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = ecl_list1(v1list); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for REMOVE-FROM-PLIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L38remove_from_plist(cl_narg narg, cl_object v1plist, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2keys; - ecl_va_list args; ecl_va_start(args,v1plist,narg,1); - v2keys = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3; - cl_object v4key; - cl_object v5rest; - { - cl_object v6; - v6 = v1plist; - if (ecl_unlikely(!ECL_LISTP(v6))) FEtype_error_list(v6); - v3 = v6; - } - v4key = ECL_NIL; - v5rest = ECL_NIL; - { - cl_object v6; - cl_object v7; - v6 = ecl_list1(ECL_NIL); - v7 = v6; -L8:; - if (!(ECL_ATOM(v3))) { goto L10; } - goto L9; -L10:; - { - cl_object v8; - v8 = v3; - v4key = ecl_car(v8); - v8 = ecl_cdr(v8); - v5rest = v8; - } - { - cl_object v8; - v8 = ecl_cddr(v3); - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v3 = v8; - } - goto L25; -L24:; - si_assert_failure(5, ECL_SYM("REST",719), ECL_NIL, ECL_NIL, VV[43], v1plist); -L25:; - if ((v5rest)!=ECL_NIL) { goto L28; } - goto L24; -L28:; - if ((si_memq(v4key,v2keys))!=ECL_NIL) { goto L30; } - { - cl_object v8; - v8 = v7; - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - T0 = v8; - } - v7 = ecl_list1(v4key); - (ECL_CONS_CDR(T0)=v7,T0); - { - cl_object v8; - v8 = v7; - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - T0 = v8; - } - T1 = ecl_car(v5rest); - v7 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v7,T0); -L30:; - goto L8; -L9:; - value0 = ecl_cdr(v6); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* function definition for DELETE-FROM-PLIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L39delete_from_plist(cl_narg narg, cl_object v1plist, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2keys; - ecl_va_list args; ecl_va_start(args,v1plist,narg,1); - v2keys = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3head; - v3head = v1plist; - { - cl_object v4tail; - v4tail = ECL_NIL; - { - cl_object v5; - cl_object v6key; - cl_object v7rest; - { - cl_object v8; - v8 = v1plist; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v5 = v8; - } - v6key = ECL_NIL; - v7rest = ECL_NIL; -L8:; - if (!(ECL_ATOM(v5))) { goto L10; } - goto L9; -L10:; - { - cl_object v8; - v8 = v5; - v6key = ecl_car(v8); - v8 = ecl_cdr(v8); - v7rest = v8; - } - { - cl_object v8; - v8 = ecl_cddr(v5); - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v5 = v8; - } - goto L26; -L25:; - si_assert_failure(5, ECL_SYM("REST",719), ECL_NIL, ECL_NIL, VV[43], v1plist); -L26:; - if ((v7rest)!=ECL_NIL) { goto L29; } - goto L25; -L29:; - if (Null(si_memq(v6key,v2keys))) { goto L31; } - { - cl_object v8next; - v8next = ecl_cdr(v7rest); - if (Null(v4tail)) { goto L34; } - { - cl_object v9; - v9 = v8next; - { - cl_object v10; - v10 = v4tail; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T0 = v10; - } - (ECL_CONS_CDR(T0)=v9,T0); - goto L23; - } -L34:; - v3head = v8next; - goto L23; - } -L31:; - v4tail = v7rest; -L23:; - goto L8; -L9:; - value0 = v3head; - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* local function REMOVE-FROM-PLISTF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC41remove_from_plistf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC40__g187,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[42], v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L11:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L20; -L19:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L20:; - if (v12si__d==ECL_NIL) { goto L26; } - goto L19; -L26:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L31; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, VV[42], v10, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L30; -L31:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, VV[42], v10, T3); -L30:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G187 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC40__g187(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function DELETE-FROM-PLISTF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC43delete_from_plistf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC42__g198,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[44], v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[20],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L11:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L20; -L19:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L20:; - if (v12si__d==ECL_NIL) { goto L26; } - goto L19; -L26:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L31; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, VV[44], v10, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L30; -L31:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, VV[44], v10, T3); -L30:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[20],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G198 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC42__g198(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* function definition for SANS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L44sans(cl_narg narg, cl_object v1plist, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2keys; - ecl_va_list args; ecl_va_start(args,v1plist,narg,1); - v2keys = cl_grab_rest_args(args); - ecl_va_end(args); - T0 = ecl_fdefinition(VV[42]); - value0 = cl_apply(3, T0, v1plist, v2keys); - return value0; - } -} -/* function definition for MAPPEND */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L45mappend(cl_narg narg, cl_object v1function, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2lists; - ecl_va_list args; ecl_va_start(args,v1function,narg,1); - v2lists = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v3; - cl_object v4results; - cl_object v5; - T0 = (ECL_SYM("MAPCAR",545)->symbol.gfdef); - v3 = cl_apply(3, T0, v1function, v2lists); - v4results = ECL_NIL; - v5 = v3; - { - cl_object v6; - cl_object v7; - v6 = ecl_list1(ECL_NIL); - v7 = v6; -L7:; - if (!(ecl_endp(v5))) { goto L9; } - goto L8; -L9:; - v4results = _ecl_car(v5); - { - cl_object v8; - v8 = _ecl_cdr(v5); - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v5 = v8; - } - { - cl_object v8; - v8 = cl_copy_list(v4results); - { - cl_object v9; - v9 = v7; - if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - T0 = v9; - } - (ECL_CONS_CDR(T0)=v8,T0); - if (Null(v8)) { goto L17; } - } - T0 = ecl_cdr(v7); - v7 = ecl_last(T0,1); -L17:; - goto L7; -L8:; - value0 = ecl_cdr(v6); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* function definition for SETP */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L46setp(cl_narg narg, cl_object v1object, ...) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2test; - cl_object v3key; - ecl_va_list args; ecl_va_start(args,v1object,narg,1); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L46setpkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v2test = (ECL_SYM("EQL",334)->symbol.gfdef); - } else { - v2test = keyvars[0]; - } - if (Null(keyvars[3])) { - v3key = (ECL_SYM("IDENTITY",426)->symbol.gfdef); - } else { - v3key = keyvars[1]; - } - } - if (!(ECL_LISTP(v1object))) { goto L4; } - { - cl_object v4seen; - v4seen = ECL_NIL; - { - cl_object v5; - v5 = v1object; - goto L10; -L9:; - { - cl_object v6elt; - v6elt = ecl_car(v5); - { - cl_object v7key; - v7key = ecl_function_dispatch(cl_env_copy,v3key)(1, v6elt); - { - cl_object v8; - v8 = v4seen; - goto L21; -L20:; - { - cl_object v9; - cl_object v10; - { - cl_object v11; - v11 = v8; - if (ecl_unlikely(ECL_ATOM(v11))) FEtype_error_cons(v11); - v9 = v11; - } - v10 = ECL_CONS_CAR(v9); - if (Null(ecl_function_dispatch(cl_env_copy,v2test)(2, v7key, v10))) { goto L23; } - if (Null(v9)) { goto L16; } - goto L17; - } -L23:; - v8 = ECL_CONS_CDR(v8); -L21:; - if (v8==ECL_NIL) { goto L31; } - goto L20; -L31:; - goto L16; - } -L17:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L16:; - v4seen = CONS(v7key,v4seen); - } - } - v5 = ecl_cdr(v5); -L10:; - if (Null(v5)) { goto L36; } - goto L9; -L36:; - value0 = ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } - } -L4:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for SET-EQUAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L47set_equal(cl_narg narg, cl_object v1list1, cl_object v2list2, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3test; - cl_object v4key; - cl_object v5keyp; - ecl_va_list args; ecl_va_start(args,v2list2,narg,2); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L47set_equalkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v3test = (ECL_SYM("EQL",334)->symbol.gfdef); - } else { - v3test = keyvars[0]; - } - v4key = keyvars[1]; - v5keyp = keyvars[3]; - } - { - cl_object v6; - cl_object v7; - if (Null(v5keyp)) { goto L3; } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v1list1; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ecl_list1(ECL_NIL); - v11 = v10; -L11:; - if (!(ecl_endp(v9))) { goto L13; } - goto L12; -L13:; - v8 = _ecl_car(v9); - { - cl_object v12; - v12 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v9 = v12; - } - { - cl_object v12; - v12 = v11; - if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - T0 = v12; - } - T1 = ecl_function_dispatch(cl_env_copy,v4key)(1, v8); - v11 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v11,T0); - goto L11; -L12:; - v6 = ecl_cdr(v10); - goto L2; - } - } -L3:; - v6 = v1list1; -L2:; - if (Null(v5keyp)) { goto L30; } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v2list2; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ecl_list1(ECL_NIL); - v11 = v10; -L38:; - if (!(ecl_endp(v9))) { goto L40; } - goto L39; -L40:; - v8 = _ecl_car(v9); - { - cl_object v12; - v12 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v9 = v12; - } - { - cl_object v12; - v12 = v11; - if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - T0 = v12; - } - T1 = ecl_function_dispatch(cl_env_copy,v4key)(1, v8); - v11 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v11,T0); - goto L38; -L39:; - v7 = ecl_cdr(v10); - goto L29; - } - } -L30:; - v7 = v2list2; -L29:; - { - cl_object v8; - v8 = v6; - goto L62; -L61:; - { - cl_object v9elt; - v9elt = ecl_car(v8); - { - cl_object v10; - v10 = v7; - goto L73; -L72:; - { - cl_object v11; - cl_object v12; - { - cl_object v13; - v13 = v10; - if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); - v11 = v13; - } - v12 = ECL_CONS_CAR(v11); - if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v9elt, v12))) { goto L75; } - value0 = v11; - goto L69; - } -L75:; - v10 = ECL_CONS_CDR(v10); -L73:; - if (v10==ECL_NIL) { goto L83; } - goto L72; -L83:; - value0 = ECL_NIL; - } -L69:; - if ((value0)!=ECL_NIL) { goto L68; } - goto L57; -L68:; - goto L66; -L66:; - } - v8 = ecl_cdr(v8); -L62:; - if (Null(v8)) { goto L87; } - goto L61; -L87:; - } - { - cl_object v8; - v8 = v7; - goto L92; -L91:; - { - cl_object v9elt; - v9elt = ecl_car(v8); - { - cl_object v10; - v10 = v6; - goto L103; -L102:; - { - cl_object v11; - cl_object v12; - { - cl_object v13; - v13 = v10; - if (ecl_unlikely(ECL_ATOM(v13))) FEtype_error_cons(v13); - v11 = v13; - } - v12 = ECL_CONS_CAR(v11); - if (Null(ecl_function_dispatch(cl_env_copy,v3test)(2, v9elt, v12))) { goto L105; } - value0 = v11; - goto L99; - } -L105:; - v10 = ECL_CONS_CDR(v10); -L103:; - if (v10==ECL_NIL) { goto L113; } - goto L102; -L113:; - value0 = ECL_NIL; - } -L99:; - if ((value0)!=ECL_NIL) { goto L98; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L98:; - goto L96; -L96:; - } - v8 = ecl_cdr(v8); -L92:; - if (Null(v8)) { goto L117; } - goto L91; -L117:; - value0 = ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } -L57:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MAP-PRODUCT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L51map_product(cl_narg narg, cl_object v1function, cl_object v2list, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3more_lists; - ecl_va_list args; ecl_va_start(args,v2list,narg,2); - v3more_lists = cl_grab_rest_args(args); - ecl_va_end(args); - T0 = ecl_function_dispatch(cl_env_copy,VV[93])(1, v1function) /* ENSURE-FUNCTION */; - T1 = CONS(v2list,v3more_lists); - value0 = LC50_map_product(T0, T1); - return value0; - } -} -/* local function %MAP-PRODUCT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC50_map_product(cl_object v1f, cl_object v2lists) -{ - cl_object T0, T1; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1f,env0); /* F */ - { - cl_object v3; - cl_object v4; - cl_object env1 = env0; - v3 = ecl_cdr(v2lists); - v4 = ecl_car(v2lists); - CLV1 = env1 = CONS(v3,env1); /* MORE */ - if ((ECL_CONS_CAR(CLV1))!=ECL_NIL) { goto L3; } - { - cl_object v5; - cl_object v6; - v5 = ECL_NIL; - { - cl_object v7; - v7 = v4; - if (ecl_unlikely(!ECL_LISTP(v7))) FEtype_error_list(v7); - v6 = v7; - } - { - cl_object v7; - cl_object v8; - v7 = ecl_list1(ECL_NIL); - v8 = v7; -L11:; - if (!(ecl_endp(v6))) { goto L13; } - goto L12; -L13:; - v5 = _ecl_car(v6); - { - cl_object v9; - v9 = _ecl_cdr(v6); - if (ecl_unlikely(!ECL_LISTP(v9))) FEtype_error_list(v9); - v6 = v9; - } - { - cl_object v9; - v9 = v8; - if (ecl_unlikely(ECL_ATOM(v9))) FEtype_error_cons(v9); - T0 = v9; - } - T1 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, v5); - v8 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v8,T0); - goto L11; -L12:; - value0 = ecl_cdr(v7); - cl_env_copy->nvalues = 1; - return value0; - } - } -L3:; - { - cl_object v9; - v9 = ecl_make_cclosure_va((cl_objectfn)LC49__g270,env1,Cblock); - T0 = v9; - } - value0 = L45mappend(2, T0, v4); - return value0; - } - } -} -/* closure G270 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC49__g270(cl_narg narg, cl_object v1x, ...) -{ - cl_object T0; - cl_object CLV0, CLV1, CLV2, CLV3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* MORE */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v2; - cl_object env1 = env0; - v2 = ecl_function_dispatch(cl_env_copy,VV[93])(1, ECL_CONS_CAR(CLV0)) /* ENSURE-FUNCTION */; - CLV2 = env1 = CONS(v2,env1); - CLV3 = env1 = CONS(v1x,env1); - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC48__g275,env1,Cblock); - T0 = v3; - } - } - value0 = LC50_map_product(T0, ECL_CONS_CAR(CLV1)); - return value0; - } - } -} -/* closure G275 */ -/* optimize speed 3, debug 1, space 0, safety 1 */ -static cl_object LC48__g275(cl_narg narg, ...) -{ - cl_object CLV0, CLV1, CLV2, CLV3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - /* Scanning closure data ... */ - CLV3 = env0; - CLV2 = _ecl_cdr(CLV3); - CLV1 = _ecl_cdr(CLV2); - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - { - cl_object v1more; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1more = cl_grab_rest_args(args); - ecl_va_end(args); - value0 = cl_apply(3, ECL_CONS_CAR(CLV2), ECL_CONS_CAR(CLV3), v1more); - return value0; - } - } -} -/* function definition for FLATTEN */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L53flatten(cl_object v1tree) -{ - volatile cl_object lex0[1]; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - lex0[0] = ECL_NIL; /* LIST */ - LC52traverse(lex0, v1tree); - value0 = cl_nreverse(lex0[0]); - return value0; - } -} -/* local function TRAVERSE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC52traverse(volatile cl_object *lex0, cl_object v1subtree) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1subtree)) { goto L1; } - if (!(ECL_CONSP(v1subtree))) { goto L3; } - T0 = ecl_car(v1subtree); - LC52traverse(lex0, T0); - v1subtree = ecl_cdr(v1subtree); - goto TTL; -L3:; - lex0[0] = CONS(v1subtree,lex0[0]); - value0 = lex0[0]; - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} - -#include "lib/alexandria/lists.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecli7UuzzMOVz39M_hCh2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/lists.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecli7UuzzMOVz39M_hCh2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[53]); /* SAFE-ENDP */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[7]) /* ANNOTATE */; - ecl_cmp_defun(VV[54]); /* ALIST-PLIST */ - si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[8]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[11]) /* ANNOTATE */; - ecl_cmp_defun(VV[55]); /* PLIST-ALIST */ - si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[12]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[13]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[56]); /* RACONS */ - { - cl_object T0; - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[17]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; - ecl_cmp_defun(VV[57]); /* ASSOC-VALUE */ - si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[21]); - { - cl_object volatile v1; - v1 = ecl_make_cfun_va((cl_objectfn)LC6assoc_value,ECL_NIL,Cblock); - T0 = v1; - } - si_do_define_setf_method(VV[4], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[22]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LOCATION",1777), VVtemp[23], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[12], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[20]) /* ANNOTATE */; - ecl_cmp_defun(VV[58]); /* RASSOC-VALUE */ - si_set_documentation(3, VV[12], ECL_SYM("FUNCTION",396), VVtemp[24]); - { - cl_object volatile v1; - v1 = ecl_make_cfun_va((cl_objectfn)LC8rassoc_value,ECL_NIL,Cblock); - T0 = v1; - } - si_do_define_setf_method(VV[12], T0); - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[11]) /* ANNOTATE */; - ecl_cmp_defun(VV[60]); /* MALFORMED-PLIST */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[29]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[61]); /* DOPLIST */ - si_set_documentation(3, VV[15], ECL_SYM("FUNCTION",396), VVtemp[30]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[63]); /* APPENDF */ - si_set_documentation(3, VV[19], ECL_SYM("FUNCTION",396), VVtemp[34]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[35], VVtemp[36]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[33]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[64]); /* NCONCF */ - si_set_documentation(3, VV[21], ECL_SYM("FUNCTION",396), VVtemp[37]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[38], VVtemp[39]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[65]); /* UNIONF */ - si_set_documentation(3, VV[22], ECL_SYM("FUNCTION",396), VVtemp[41]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[43]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[66]); /* NUNIONF */ - si_set_documentation(3, VV[23], ECL_SYM("FUNCTION",396), VVtemp[44]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LOCATION",1777), VVtemp[45], VVtemp[46]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[47]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[67]); /* REVERSEF */ - si_set_documentation(3, VV[24], ECL_SYM("FUNCTION",396), VVtemp[48]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[49], VVtemp[50]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[47]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[68]); /* NREVERSEF */ - si_set_documentation(3, VV[25], ECL_SYM("FUNCTION",396), VVtemp[51]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[53]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[54]) /* ANNOTATE */; - ecl_cmp_defun(VV[69]); /* CIRCULAR-LIST */ - si_set_documentation(3, VV[26], ECL_SYM("FUNCTION",396), VVtemp[55]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LOCATION",1777), VVtemp[56], VVtemp[57]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; - ecl_cmp_defun(VV[70]); /* CIRCULAR-LIST-P */ - si_set_documentation(3, VV[27], ECL_SYM("FUNCTION",396), VVtemp[59]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[60], VVtemp[61]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; - ecl_cmp_defun(VV[71]); /* CIRCULAR-TREE-P */ - si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[62]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[29], ECL_SYM("LOCATION",1777), VVtemp[63], VVtemp[64]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[29], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; - ecl_cmp_defun(VV[72]); /* PROPER-LIST-P */ - si_set_documentation(3, VV[29], ECL_SYM("FUNCTION",396), VVtemp[65]); - { - cl_object T0; - si_set_documentation(3, VV[30], ECL_SYM("TYPE",869), VVtemp[66]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC28proper_list,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[30], VVtemp[67], T0); - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LOCATION",1777), VVtemp[68], VVtemp[69]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; - ecl_cmp_defun(VV[73]); /* CIRCULAR-LIST-ERROR */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LOCATION",1777), VVtemp[71], VVtemp[72]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; - ecl_cmp_defun(VV[74]); /* PROPER-LIST-LENGTH */ - si_set_documentation(3, VV[34], ECL_SYM("FUNCTION",396), VVtemp[73]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LOCATION",1777), VVtemp[74], VVtemp[72]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; - ecl_cmp_defun(VV[75]); /* LASTCAR */ - si_set_documentation(3, VV[35], ECL_SYM("FUNCTION",396), VVtemp[75]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[76], ECL_SYM("LOCATION",1777), VVtemp[77], VVtemp[72]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[76], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[78]) /* ANNOTATE */; - ecl_cmp_defun(VV[76]); /* (SETF LASTCAR) */ - si_set_documentation(3, VV[36], ECL_SYM("FUNCTION",396), VVtemp[79]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LOCATION",1777), VVtemp[80], VVtemp[81]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[82]) /* ANNOTATE */; - ecl_cmp_defun(VV[77]); /* MAKE-CIRCULAR-LIST */ - si_set_documentation(3, VV[37], ECL_SYM("FUNCTION",396), VVtemp[83]); - { - cl_object T0; - si_set_documentation(3, VV[26], ECL_SYM("TYPE",869), VVtemp[84]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC34circular_list,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[26], VVtemp[85], T0); - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LOCATION",1777), VVtemp[86], VVtemp[87]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[88]) /* ANNOTATE */; - ecl_cmp_defun(VV[79]); /* ENSURE-CAR */ - si_set_documentation(3, VV[39], ECL_SYM("FUNCTION",396), VVtemp[89]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LOCATION",1777), VVtemp[90], VVtemp[91]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[92]) /* ANNOTATE */; - ecl_cmp_defun(VV[80]); /* ENSURE-CONS */ - si_set_documentation(3, VV[40], ECL_SYM("FUNCTION",396), VVtemp[93]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[94], VVtemp[95]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[70]) /* ANNOTATE */; - ecl_cmp_defun(VV[81]); /* ENSURE-LIST */ - si_set_documentation(3, VV[41], ECL_SYM("FUNCTION",396), VVtemp[96]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LOCATION",1777), VVtemp[97], VVtemp[98]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[99]) /* ANNOTATE */; - ecl_cmp_defun(VV[82]); /* REMOVE-FROM-PLIST */ - si_set_documentation(3, VV[42], ECL_SYM("FUNCTION",396), VVtemp[100]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LOCATION",1777), VVtemp[101], VVtemp[102]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[99]) /* ANNOTATE */; - ecl_cmp_defun(VV[83]); /* DELETE-FROM-PLIST */ - si_set_documentation(3, VV[44], ECL_SYM("FUNCTION",396), VVtemp[103]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[45], ECL_SYM("LOCATION",1777), VVtemp[104], VVtemp[105]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[45], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[106]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[84]); /* REMOVE-FROM-PLISTF */ - si_set_documentation(3, VV[45], ECL_SYM("FUNCTION",396), VVtemp[107]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[46], ECL_SYM("LOCATION",1777), VVtemp[108], VVtemp[109]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[46], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[106]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[85]); /* DELETE-FROM-PLISTF */ - si_set_documentation(3, VV[46], ECL_SYM("FUNCTION",396), VVtemp[110]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[111]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[47], ECL_SYM("LOCATION",1777), VVtemp[112], VVtemp[113]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[47], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[99]) /* ANNOTATE */; - ecl_cmp_defun(VV[86]); /* SANS */ - si_set_documentation(3, VV[47], ECL_SYM("FUNCTION",396), VVtemp[114]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LOCATION",1777), VVtemp[115], VVtemp[116]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[117]) /* ANNOTATE */; - ecl_cmp_defun(VV[87]); /* MAPPEND */ - si_set_documentation(3, VV[48], ECL_SYM("FUNCTION",396), VVtemp[118]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LOCATION",1777), VVtemp[119], VVtemp[120]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[121]) /* ANNOTATE */; - ecl_cmp_defun(VV[88]); /* SETP */ - si_set_documentation(3, VV[49], ECL_SYM("FUNCTION",396), VVtemp[122]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LOCATION",1777), VVtemp[123], VVtemp[124]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[125]) /* ANNOTATE */; - ecl_cmp_defun(VV[91]); /* SET-EQUAL */ - si_set_documentation(3, VV[50], ECL_SYM("FUNCTION",396), VVtemp[126]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LOCATION",1777), VVtemp[127], VVtemp[128]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[129]) /* ANNOTATE */; - ecl_cmp_defun(VV[92]); /* MAP-PRODUCT */ - si_set_documentation(3, VV[51], ECL_SYM("FUNCTION",396), VVtemp[130]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[52], ECL_SYM("LOCATION",1777), VVtemp[131], VVtemp[132]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[52], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[133]) /* ANNOTATE */; - ecl_cmp_defun(VV[94]); /* FLATTEN */ - si_set_documentation(3, VV[52], ECL_SYM("FUNCTION",396), VVtemp[134]); -} diff --git a/lib/alexandria/macros.cxx b/lib/alexandria/macros.cxx deleted file mode 100644 index 026b471..0000000 --- a/lib/alexandria/macros.cxx +++ /dev/null @@ -1,1419 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/macros.lisp */ -#include -#include "lib/alexandria/macros.eclh" -/* local function WITH-GENSYMS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2with_gensyms(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4names; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4names = v5; - } - { - cl_object v5; - { - cl_object v6; - v6 = ecl_make_cfun((cl_objectfn_fixed)LC1__g16,ECL_NIL,Cblock,1); - v5 = v6; - } - { - cl_object v6; - cl_object v7; - v6 = ECL_NIL; - { - cl_object v8; - v8 = v4names; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ecl_list1(ECL_NIL); - v9 = v8; -L16:; - if (!(ecl_endp(v7))) { goto L18; } - goto L17; -L18:; - v6 = _ecl_car(v7); - { - cl_object v10; - v10 = _ecl_cdr(v7); - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v7 = v10; - } - { - cl_object v10; - v10 = v9; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T1 = v10; - } - T2 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); - v9 = ecl_list1(T2); - (ECL_CONS_CDR(T1)=v9,T1); - goto L16; -L17:; - T0 = ecl_cdr(v8); - goto L8; - } - } - } -L8:; - value0 = cl_listX(3, ECL_SYM("LET",477), T0, v3); - return value0; - } - } -} -/* local function G16 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1__g16(cl_object v1name) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; /* SYMBOL */ - cl_object v4; /* STRING */ - if (!(ECL_SYMBOLP(v1name))) { goto L2; } - T0 = ecl_symbol_name(v1name); - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = T0; - cl_env_copy->values[0] = v1name; - value0 = cl_env_copy->values[0]; - goto L1; -L2:; - if (Null(cl_typep(2, v1name, VV[1]))) { goto L4; } - T0 = ecl_car(v1name); - T1 = ecl_cadr(v1name); - T2 = cl_string(T1); - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = T2; - cl_env_copy->values[0] = T0; - value0 = cl_env_copy->values[0]; - goto L1; -L4:; - value0 = si_etypecase_error(v1name, VV[2]); -L1:; - v3 = value0; - { - const int v5 = cl_env_copy->nvalues; - cl_object v6; - v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1]; - v4 = v6; - } - T0 = cl_list(2, ECL_SYM("GENSYM",400), v4); - value0 = cl_list(2, v3, T0); - return value0; - } - } -} -/* local function WITH-UNIQUE-NAMES */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3with_unique_names(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4names; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4names = v5; - } - value0 = cl_listX(3, VV[0], v4names, v3); - return value0; - } - } -} -/* local function ONCE-ONLY */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8once_only(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4specs; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4specs = v5; - } - { - cl_object v5; - cl_object v6; - { - cl_fixnum v7; - v7 = ecl_length(v4specs); - v5 = ecl_function_dispatch(cl_env_copy,VV[45])(2, ecl_make_fixnum(v7), VV[5]) /* MAKE-GENSYM-LIST */; - } - { - cl_object v7; - { - cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC4__g53,ECL_NIL,Cblock,1); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v4specs; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ecl_list1(ECL_NIL); - v11 = v10; -L17:; - if (!(ecl_endp(v9))) { goto L19; } - goto L18; -L19:; - v8 = _ecl_car(v9); - { - cl_object v12; - v12 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v9 = v12; - } - { - cl_object v12; - v12 = v11; - if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - T0 = v12; - } - T1 = ecl_function_dispatch(cl_env_copy,v7)(1, v8); - v11 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v11,T0); - goto L17; -L18:; - v6 = ecl_cdr(v10); - goto L9; - } - } - } -L9:; - { - cl_object v7; - { - cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC5__g68,ECL_NIL,Cblock,2); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v5; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ECL_NIL; - { - cl_object v12; - v12 = v6; - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v11 = v12; - } - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L47:; - if (!(ecl_endp(v9))) { goto L49; } - goto L48; -L49:; - v8 = _ecl_car(v9); - { - cl_object v14; - v14 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v9 = v14; - } - if (!(ecl_endp(v11))) { goto L57; } - goto L48; -L57:; - v10 = _ecl_car(v11); - { - cl_object v14; - v14 = _ecl_cdr(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T1 = v14; - } - T2 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); - v13 = ecl_list1(T2); - (ECL_CONS_CDR(T1)=v13,T1); - goto L47; -L48:; - T0 = ecl_cdr(v12); - goto L35; - } - } - } - } -L35:; - { - cl_object v7; - { - cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC6__g80,ECL_NIL,Cblock,2); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v5; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ECL_NIL; - { - cl_object v12; - v12 = v6; - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v11 = v12; - } - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L85:; - if (!(ecl_endp(v9))) { goto L87; } - goto L86; -L87:; - v8 = _ecl_car(v9); - { - cl_object v14; - v14 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v9 = v14; - } - if (!(ecl_endp(v11))) { goto L95; } - goto L86; -L95:; - v10 = _ecl_car(v11); - { - cl_object v14; - v14 = _ecl_cdr(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T2 = v14; - } - T3 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); - v13 = ecl_list1(T3); - (ECL_CONS_CDR(T2)=v13,T2); - goto L85; -L86:; - T1 = ecl_cdr(v12); - goto L73; - } - } - } - } -L73:; - T2 = CONS(ECL_SYM("LIST",481),T1); - { - cl_object v7; - { - cl_object v8; - v8 = ecl_make_cfun((cl_objectfn_fixed)LC7__g92,ECL_NIL,Cblock,2); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ECL_NIL; - { - cl_object v10; - v10 = v6; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ECL_NIL; - { - cl_object v12; - v12 = v5; - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v11 = v12; - } - { - cl_object v12; - cl_object v13; - v12 = ecl_list1(ECL_NIL); - v13 = v12; -L123:; - if (!(ecl_endp(v9))) { goto L125; } - goto L124; -L125:; - v8 = _ecl_car(v9); - { - cl_object v14; - v14 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v9 = v14; - } - if (!(ecl_endp(v11))) { goto L133; } - goto L124; -L133:; - v10 = _ecl_car(v11); - { - cl_object v14; - v14 = _ecl_cdr(v11); - if (ecl_unlikely(!ECL_LISTP(v14))) FEtype_error_list(v14); - v11 = v14; - } - { - cl_object v14; - v14 = v13; - if (ecl_unlikely(ECL_ATOM(v14))) FEtype_error_cons(v14); - T4 = v14; - } - T5 = ecl_function_dispatch(cl_env_copy,v7)(2, v8, v10); - v13 = ecl_list1(T5); - (ECL_CONS_CDR(T4)=v13,T4); - goto L123; -L124:; - T3 = ecl_cdr(v12); - goto L111; - } - } - } - } -L111:; - T4 = cl_listX(3, ECL_SYM("LET",477), T3, v3); - T5 = cl_list(4, ECL_SYM("LIST",481), VV[7], T2, T4); - value0 = cl_list(3, ECL_SYM("LET",477), T0, T5); - return value0; - } - } - } -} -/* local function G53 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4__g53(cl_object v1spec) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LISTP(v1spec))) { goto L1; } - { - cl_object v2; - cl_object v3name; - cl_object v4form; - v2 = v1spec; - if (!(v2==ECL_NIL)) { goto L5; } - si_dm_too_few_arguments(v1spec); -L5:; - { - cl_object v5; - v5 = ecl_car(v2); - v2 = ecl_cdr(v2); - v3name = v5; - } - if (!(v2==ECL_NIL)) { goto L11; } - si_dm_too_few_arguments(v1spec); -L11:; - { - cl_object v5; - v5 = ecl_car(v2); - v2 = ecl_cdr(v2); - v4form = v5; - } - if (Null(v2)) { goto L16; } - si_dm_too_many_arguments(v1spec); -L16:; - value0 = CONS(v3name,v4form); - cl_env_copy->nvalues = 1; - return value0; - } -L1:; - if (!(ECL_SYMBOLP(v1spec))) { goto L18; } - value0 = CONS(v1spec,v1spec); - cl_env_copy->nvalues = 1; - return value0; -L18:; - value0 = si_etypecase_error(v1spec, VV[6]); - return value0; - } -} -/* local function G68 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5__g68(cl_object v1g, cl_object v2n) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = ecl_car(v2n); - T1 = cl_string(T0); - T2 = cl_list(2, ECL_SYM("GENSYM",400), T1); - value0 = cl_list(2, v1g, T2); - return value0; - } -} -/* local function G80 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6__g80(cl_object v1g, cl_object v2n) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = ecl_cdr(v2n); - value0 = cl_list(3, ECL_SYM("LIST",481), v1g, T0); - return value0; - } -} -/* local function G92 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__g92(cl_object v1n, cl_object v2g) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = ecl_car(v1n); - value0 = cl_list(2, T0, v2g); - return value0; - } -} -/* function definition for PARSE-BODY */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L9parse_body(cl_narg narg, cl_object v1body, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2documentation; - cl_object v3whole; - ecl_va_list args; ecl_va_start(args,v1body,narg,1); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L9parse_bodykeys,keyvars,NULL,FALSE); - ecl_va_end(args); - v2documentation = keyvars[0]; - v3whole = keyvars[1]; - } - { - cl_object v4doc; - cl_object v5decls; - cl_object v6current; - v4doc = ECL_NIL; - v5decls = ECL_NIL; - v6current = ECL_NIL; -L5:; - v6current = ecl_car(v1body); - if (Null(v2documentation)) { goto L8; } - if (!(ECL_STRINGP(v6current))) { goto L8; } - if (Null(ecl_cdr(v1body))) { goto L8; } - if (Null(v4doc)) { goto L13; } - value0 = v3whole; - if ((value0)!=ECL_NIL) { goto L17; } - T0 = v1body; - goto L15; -L17:; - T0 = value0; - goto L15; -L15:; - cl_error(2, VV[9], T0); - goto L12; -L13:; - { - cl_object v7; - v7 = v1body; - { - cl_object v8; - v8 = v7; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - } - if (Null(v7)) { goto L24; } - { - cl_object v8; - v8 = ECL_CONS_CDR(v7); - v1body = v8; - v7 = ECL_CONS_CAR(v7); - } -L24:; - v4doc = v7; - } -L12:; - goto L5; -L8:; - if (!(ECL_LISTP(v6current))) { goto L30; } - T0 = ecl_car(v6current); - if (!((T0)==(ECL_SYM("DECLARE",274)))) { goto L30; } - { - cl_object v7; - v7 = v1body; - { - cl_object v8; - v8 = v7; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - } - if (Null(v7)) { goto L40; } - { - cl_object v8; - v8 = ECL_CONS_CDR(v7); - v1body = v8; - v7 = ECL_CONS_CAR(v7); - } -L40:; - T0 = v7; - } - v5decls = CONS(T0,v5decls); - goto L5; -L30:; - T0 = cl_nreverse(v5decls); - cl_env_copy->nvalues = 3; - cl_env_copy->values[2] = v4doc; - cl_env_copy->values[1] = T0; - cl_env_copy->values[0] = v1body; - return cl_env_copy->values[0]; - } - } -} -/* function definition for PARSE-ORDINARY-LAMBDA-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L13parse_ordinary_lambda_list(cl_narg narg, cl_object v1lambda_list, ...) -{ - cl_object T0, T1, T2, T3; - volatile cl_object lex0[2]; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2normalize; - cl_object v3normalize_optional; - cl_object v4normalize_keyword; - cl_object v5normalize_auxilary; - ecl_va_list args; ecl_va_start(args,v1lambda_list,narg,1); - lex0[0] = v1lambda_list; /* LAMBDA-LIST */ - { - cl_object keyvars[10]; - cl_parse_key(args,5,L13parse_ordinary_lambda_listkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[5])) { - v2normalize = ECL_T; - } else { - v2normalize = keyvars[0]; - } - lex0[1] = keyvars[1]; /* ALLOW-SPECIALIZERS */ - if (Null(keyvars[7])) { - v3normalize_optional = v2normalize; - } else { - v3normalize_optional = keyvars[2]; - } - if (Null(keyvars[8])) { - v4normalize_keyword = v2normalize; - } else { - v4normalize_keyword = keyvars[3]; - } - if (Null(keyvars[9])) { - v5normalize_auxilary = v2normalize; - } else { - v5normalize_auxilary = keyvars[4]; - } - } - { - cl_object v6state; - cl_object v7allow_other_keys; - cl_object v8auxp; - cl_object v9required; - cl_object v10optional; - cl_object v11rest; - cl_object v12keys; - cl_object v13keyp; - cl_object v14aux; - v6state = ECL_SYM("REQUIRED",1008); - v7allow_other_keys = ECL_NIL; - v8auxp = ECL_NIL; - v9required = ECL_NIL; - v10optional = ECL_NIL; - v11rest = ECL_NIL; - v12keys = ECL_NIL; - v13keyp = ECL_NIL; - v14aux = ECL_NIL; - { - cl_object v15; - v15 = lex0[0]; - goto L18; -L17:; - { - cl_object v16elt; - v16elt = ecl_car(v15); - { - cl_object v17; - v17 = v16elt; - if (!((v17)==(ECL_SYM("&OPTIONAL",11)))) { goto L24; } - if (!((v6state)==(ECL_SYM("REQUIRED",1008)))) { goto L26; } - v6state = v16elt; - goto L22; -L26:; - LC10fail(lex0, v16elt); - goto L22; -L24:; - if (!((v17)==(ECL_SYM("&REST",12)))) { goto L29; } - if (!(ecl_eql(v6state,ECL_SYM("REQUIRED",1008)))) { goto L36; } - goto L33; - goto L34; -L36:; - goto L34; -L34:; - if (!((v6state)==(ECL_SYM("&OPTIONAL",11)))) { goto L31; } - goto L32; -L33:; -L32:; - v6state = v16elt; - goto L22; -L31:; - LC10fail(lex0, v16elt); - goto L22; -L29:; - if (!((v17)==(ECL_SYM("&KEY",10)))) { goto L40; } - if (!(ecl_eql(v6state,ECL_SYM("REQUIRED",1008)))) { goto L48; } - goto L45; - goto L46; -L48:; - goto L46; -L46:; - if (!((v6state)==(ECL_SYM("&OPTIONAL",11)))) { goto L52; } - goto L45; - goto L50; -L52:; - goto L50; -L50:; - if (!(ecl_eql(v6state,VV[17]))) { goto L43; } - goto L44; -L45:; -L44:; - v6state = v16elt; - goto L42; -L43:; - LC10fail(lex0, v16elt); -L42:; - v13keyp = ECL_T; - goto L22; -L40:; - if (!((v17)==(ECL_SYM("&ALLOW-OTHER-KEYS",6)))) { goto L57; } - if (!((v6state)==(ECL_SYM("&KEY",10)))) { goto L59; } - v7allow_other_keys = ECL_T; - v6state = v16elt; - goto L22; -L59:; - LC10fail(lex0, v16elt); - goto L22; -L57:; - if (!((v17)==(ECL_SYM("&AUX",7)))) { goto L64; } - if (!((v6state)==(ECL_SYM("&REST",12)))) { goto L66; } - LC10fail(lex0, v16elt); - goto L22; -L66:; - if (Null(v8auxp)) { goto L68; } - ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[19], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; - goto L22; -L68:; - v8auxp = ECL_T; - v6state = v16elt; - goto L22; -L64:; - if (!((v16elt)==(ECL_SYM("&WHOLE",13)))) { goto L78; } - goto L75; - goto L76; -L78:; - goto L76; -L76:; - if (!((v16elt)==(ECL_SYM("&ENVIRONMENT",9)))) { goto L82; } - goto L75; - goto L80; -L82:; - goto L80; -L80:; - if (!((v16elt)==(ECL_SYM("&BODY",8)))) { goto L73; } - goto L74; -L75:; -L74:; - ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[23], v16elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; -L73:; - { - cl_object v18; - v18 = v6state; - if (!(ecl_eql(v18,ECL_SYM("REQUIRED",1008)))) { goto L86; } - LC11check_variable(2, lex0, v16elt, VV[24]); - v9required = CONS(v16elt,v9required); - goto L22; -L86:; - if (!((v18)==(ECL_SYM("&OPTIONAL",11)))) { goto L90; } - if (!(ECL_CONSP(v16elt))) { goto L93; } - { - cl_object v19; - cl_object v20; - cl_object v21name; - v19 = v16elt; - v20 = v19; - if (!(v20==ECL_NIL)) { goto L98; } - si_dm_too_few_arguments(v19); -L98:; - { - cl_object v22; - v22 = ecl_car(v20); - v20 = ecl_cdr(v20); - v21name = v22; - } - LC11check_variable(2, lex0, v21name, VV[25]); - if (Null(ecl_cdr(v20))) { goto L104; } - LC12check_spec(lex0, v20, VV[26]); - goto L92; -L104:; - if (Null(v3normalize_optional)) { goto L92; } - v16elt = ecl_append(v16elt,VV[27]); - goto L92; - } -L93:; - LC11check_variable(2, lex0, v16elt, VV[25]); - if (Null(v3normalize_optional)) { goto L92; } - v16elt = CONS(v16elt,VV[28]); -L92:; - T0 = ecl_function_dispatch(cl_env_copy,VV[56])(1, v16elt) /* ENSURE-LIST */; - v10optional = CONS(T0,v10optional); - goto L22; -L90:; - if (!((v18)==(ECL_SYM("&REST",12)))) { goto L112; } - LC11check_variable(2, lex0, v16elt, VV[29]); - v11rest = v16elt; - v6state = VV[17]; - goto L22; -L112:; - if (!((v18)==(ECL_SYM("&KEY",10)))) { goto L118; } - if (!(ECL_CONSP(v16elt))) { goto L121; } - { - cl_object v19; - cl_object v20; - cl_object v21var_or_kv; - cl_object v22tail; - v19 = v16elt; - v20 = v19; - if (!(v20==ECL_NIL)) { goto L126; } - si_dm_too_few_arguments(v19); -L126:; - { - cl_object v23; - v23 = ecl_car(v20); - v20 = ecl_cdr(v20); - v21var_or_kv = v23; - } - v22tail = v20; - if (!(ECL_CONSP(v21var_or_kv))) { goto L133; } - { - cl_object v23; - cl_object v24keyword; - cl_object v25var; - v23 = v21var_or_kv; - if (!(v23==ECL_NIL)) { goto L137; } - si_dm_too_few_arguments(v21var_or_kv); -L137:; - { - cl_object v26; - v26 = ecl_car(v23); - v23 = ecl_cdr(v23); - v24keyword = v26; - } - if (!(v23==ECL_NIL)) { goto L143; } - si_dm_too_few_arguments(v21var_or_kv); -L143:; - { - cl_object v26; - v26 = ecl_car(v23); - v23 = ecl_cdr(v23); - v25var = v26; - } - if (Null(v23)) { goto L148; } - si_dm_too_many_arguments(v21var_or_kv); -L148:; - if (ECL_SYMBOLP(v24keyword)) { goto L150; } - ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[30], v24keyword, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; -L150:; - LC11check_variable(2, lex0, v25var, VV[31]); - goto L132; - } -L133:; - LC11check_variable(2, lex0, v21var_or_kv, VV[31]); - if (Null(v4normalize_keyword)) { goto L132; } - T0 = ecl_function_dispatch(cl_env_copy,VV[57])(1, v21var_or_kv) /* MAKE-KEYWORD */; - v21var_or_kv = cl_list(2, T0, v21var_or_kv); -L132:; - if (Null(ecl_cdr(v22tail))) { goto L156; } - LC12check_spec(lex0, v22tail, VV[32]); - goto L155; -L156:; - if (Null(v4normalize_keyword)) { goto L155; } - v22tail = ecl_append(v22tail,VV[27]); -L155:; - v16elt = CONS(v21var_or_kv,v22tail); - goto L120; - } -L121:; - LC11check_variable(2, lex0, v16elt, VV[31]); - if (Null(v4normalize_keyword)) { goto L163; } - T0 = ecl_function_dispatch(cl_env_copy,VV[57])(1, v16elt) /* MAKE-KEYWORD */; - T1 = cl_list(2, T0, v16elt); - v16elt = cl_list(3, T1, ECL_NIL, ECL_NIL); - goto L162; -L163:; -L162:; -L120:; - v12keys = CONS(v16elt,v12keys); - goto L22; -L118:; - if (!((v18)==(ECL_SYM("&AUX",7)))) { goto L166; } - if (!(ECL_CONSP(v16elt))) { goto L169; } - { - cl_object v19; - cl_object v20var; - cl_object v21init; - v19 = v16elt; - if (!(v19==ECL_NIL)) { goto L173; } - si_dm_too_few_arguments(v16elt); -L173:; - { - cl_object v22; - v22 = ecl_car(v19); - v19 = ecl_cdr(v19); - v20var = v22; - } - if (Null(v19)) { goto L179; } - { - cl_object v22; - v22 = ecl_car(v19); - v19 = ecl_cdr(v19); - v21init = v22; - goto L178; - } -L179:; - v21init = ECL_NIL; -L178:; - if (Null(v19)) { goto L184; } - si_dm_too_many_arguments(v16elt); -L184:; - LC11check_variable(2, lex0, v20var, VV[33]); - goto L168; - } -L169:; - LC11check_variable(2, lex0, v16elt, VV[33]); - if (Null(v5normalize_auxilary)) { goto L189; } - T0 = VV[27]; - goto L188; -L189:; - T0 = ECL_NIL; -L188:; - v16elt = CONS(v16elt,T0); -L168:; - v14aux = CONS(v16elt,v14aux); - goto L22; -L166:; - ecl_function_dispatch(cl_env_copy,VV[55])(2, VV[34], lex0[0]) /* SIMPLE-PROGRAM-ERROR */; - } - } -L22:; - } - v15 = ecl_cdr(v15); -L18:; - if (Null(v15)) { goto L194; } - goto L17; -L194:; - } - T0 = cl_nreverse(v9required); - T1 = cl_nreverse(v10optional); - T2 = cl_nreverse(v12keys); - T3 = cl_nreverse(v14aux); - cl_env_copy->nvalues = 7; - cl_env_copy->values[6] = v13keyp; - cl_env_copy->values[5] = T3; - cl_env_copy->values[4] = v7allow_other_keys; - cl_env_copy->values[3] = T2; - cl_env_copy->values[2] = v11rest; - cl_env_copy->values[1] = T1; - cl_env_copy->values[0] = T0; - return cl_env_copy->values[0]; - } - } -} -/* local function CHECK-SPEC */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12check_spec(volatile cl_object *lex0, cl_object v1spec, cl_object v2what) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4init; - cl_object v5suppliedp; - v3 = v1spec; - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1spec); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4init = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1spec); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5suppliedp = v6; - } - if (Null(v3)) { goto L14; } - si_dm_too_many_arguments(v1spec); -L14:; - value0 = LC11check_variable(3, lex0, v5suppliedp, v2what, ECL_NIL); - return value0; - } - } -} -/* local function CHECK-VARIABLE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11check_variable(cl_narg narg, volatile cl_object *lex0, cl_object v1elt, cl_object v2what, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - if (ecl_unlikely(narg>3)) FEwrong_num_arguments_anonym(); - { - cl_object v3allow_specializers; - va_list args; va_start(args,v2what); - { - int i = 2; - if (i >= narg) { - v3allow_specializers = lex0[1]; - } else { - i++; - v3allow_specializers = va_arg(args,cl_object); - } - } - va_end(args); - if (ECL_SYMBOLP(v1elt)) { goto L7; } - if (Null(v3allow_specializers)) { goto L5; } - if (!(ECL_CONSP(v1elt))) { goto L5; } - { - cl_fixnum v4; - v4 = ecl_length(v1elt); - if (!((2)==(v4))) { goto L5; } - } - T0 = ecl_car(v1elt); - if (!(ECL_SYMBOLP(T0))) { goto L5; } - goto L6; -L7:; -L6:; - if (Null(cl_constantp(1, v1elt))) { goto L2; } - goto L3; -L5:; - goto L3; -L3:; - value0 = ecl_function_dispatch(cl_env_copy,VV[55])(4, VV[12], v2what, v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function FAIL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10fail(volatile cl_object *lex0, cl_object v1elt) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = ecl_function_dispatch(cl_env_copy,VV[55])(3, VV[11], v1elt, lex0[0]) /* SIMPLE-PROGRAM-ERROR */; - return value0; - } -} -/* function definition for EXPAND-DESTRUCTURING-CASE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L15expand_destructuring_case(cl_object v1key, cl_object v2clauses, cl_object v3case) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v4; - v4 = cl_gensym(1, VV[36]); - T0 = cl_list(2, v4, v1key); - T1 = ecl_list1(T0); - { - cl_object env1 = env0; - env1 = ECL_NIL; - CLV0 = env1 = CONS(v4,env1); /* KEY */ - T3 = cl_list(3, ECL_SYM("TYPEP",875), ECL_CONS_CAR(CLV0), VV[37]); - T4 = cl_list(2, ECL_SYM("CAR",180), ECL_CONS_CAR(CLV0)); - { - cl_object v5; - { - cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC14__g169,env1,Cblock); - v5 = v6; - } - { - cl_object v6; - cl_object v7; - v6 = ECL_NIL; - { - cl_object v8; - v8 = v2clauses; - if (ecl_unlikely(!ECL_LISTP(v8))) FEtype_error_list(v8); - v7 = v8; - } - { - cl_object v8; - cl_object v9; - v8 = ecl_list1(ECL_NIL); - v9 = v8; -L11:; - if (!(ecl_endp(v7))) { goto L13; } - goto L12; -L13:; - v6 = _ecl_car(v7); - { - cl_object v10; - v10 = _ecl_cdr(v7); - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v7 = v10; - } - { - cl_object v10; - v10 = v9; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T6 = v10; - } - T7 = ecl_function_dispatch(cl_env_copy,v5)(1, v6); - v9 = ecl_list1(T7); - (ECL_CONS_CDR(T6)=v9,T6); - goto L11; -L12:; - T5 = ecl_cdr(v8); - goto L3; - } - } - } -L3:; - T6 = cl_listX(3, v3case, T4, T5); - T7 = cl_list(2, ECL_SYM("QUOTE",679), v3case); - T8 = cl_list(4, ECL_SYM("ERROR",337), VV[38], T7, ECL_CONS_CAR(CLV0)); - T2 = cl_list(4, ECL_SYM("IF",946), T3, T6, T8); - } - value0 = cl_list(3, ECL_SYM("LET",477), T1, T2); - return value0; - } - } -} -/* closure G169 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14__g169(cl_narg narg, cl_object v1clause, ...) -{ - cl_object T0, T1; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* KEY */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v2; - cl_object v3; - cl_object v4; - cl_object v5keys; - v2 = v1clause; - if (!(v2==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1clause); -L3:; - { - cl_object v6; - v6 = ecl_car(v2); - v2 = ecl_cdr(v2); - v3 = v6; - } - v4 = v3; - if (!(v4==ECL_NIL)) { goto L10; } - si_dm_too_few_arguments(v1clause); -L10:; - { - cl_object v6; - v6 = ecl_car(v4); - v4 = ecl_cdr(v4); - v5keys = v6; - } - T0 = cl_list(2, ECL_SYM("CDR",198), ECL_CONS_CAR(CLV0)); - T1 = cl_listX(4, ECL_SYM("DESTRUCTURING-BIND",300), v4, T0, v2); - value0 = cl_list(2, v5keys, T1); - return value0; - } - } - } -} -/* local function DESTRUCTURING-CASE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC16destructuring_case(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4keyform; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4keyform = v5; - } - value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CASE",181)); - return value0; - } - } -} -/* local function DESTRUCTURING-CCASE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC17destructuring_ccase(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4keyform; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4keyform = v5; - } - value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("CCASE",183)); - return value0; - } - } -} -/* local function DESTRUCTURING-ECASE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC18destructuring_ecase(cl_object v1, cl_object v2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4keyform; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4keyform = v5; - } - value0 = L15expand_destructuring_case(v4keyform, v3, ECL_SYM("ECASE",321)); - return value0; - } - } -} - -#include "lib/alexandria/macros.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecl4KRmknIfrdJJM_8gg2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/macros.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4KRmknIfrdJJM_8gg2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[1], VVtemp[2]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[42]); /* WITH-GENSYMS */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[4]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[5], VVtemp[6]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[3]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[43]); /* WITH-UNIQUE-NAMES */ - si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[7]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LOCATION",1777), VVtemp[8], VVtemp[9]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[4], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[10]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[44]); /* ONCE-ONLY */ - si_set_documentation(3, VV[4], ECL_SYM("FUNCTION",396), VVtemp[11]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[12], VVtemp[13]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[14]) /* ANNOTATE */; - ecl_cmp_defun(VV[46]); /* PARSE-BODY */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[15]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* PARSE-ORDINARY-LAMBDA-LIST */ - si_set_documentation(3, VV[10], ECL_SYM("FUNCTION",396), VVtemp[19]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LOCATION",1777), VVtemp[20], VVtemp[21]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[22]) /* ANNOTATE */; - ecl_cmp_defun(VV[58]); /* EXPAND-DESTRUCTURING-CASE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LOCATION",1777), VVtemp[23], VVtemp[24]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[59]); /* DESTRUCTURING-CASE */ - si_set_documentation(3, VV[39], ECL_SYM("FUNCTION",396), VVtemp[26]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LOCATION",1777), VVtemp[27], VVtemp[28]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[60]); /* DESTRUCTURING-CCASE */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[29], VVtemp[30]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[61]); /* DESTRUCTURING-ECASE */ - { - cl_object v1; - v1 = VVtemp[31]; - goto L54; -L53:; - { - cl_object v2name; - v2name = ecl_car(v1); - { - cl_object v3; - v3 = (cl_env_copy->function=(ECL_SYM("DOCUMENTATION",312)->symbol.gfdef))->cfun.entry(2, VV[39], ECL_SYM("FUNCTION",396)) /* DOCUMENTATION */; - (cl_env_copy->function=ECL_CONS_CAR(VV[62]))->cfun.entry(3, v3, v2name, ECL_SYM("FUNCTION",396)) /* (SETF DOCUMENTATION) */; - } - } - v1 = ecl_cdr(v1); -L54:; - if (Null(v1)) { goto L62; } - goto L53; -L62:; - } -} diff --git a/lib/alexandria/numbers.cxx b/lib/alexandria/numbers.cxx deleted file mode 100644 index 57fc2b1..0000000 --- a/lib/alexandria/numbers.cxx +++ /dev/null @@ -1,1601 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/numbers.lisp */ -#include -#include "lib/alexandria/numbers.eclh" -/* function definition for CLAMP */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1clamp(cl_object v1number, cl_object v2min, cl_object v3max) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ecl_number_compare(v1number,v2min)<0)) { goto L1; } - value0 = v2min; - cl_env_copy->nvalues = 1; - return value0; -L1:; - if (!(ecl_number_compare(v1number,v3max)>0)) { goto L3; } - value0 = v3max; - cl_env_copy->nvalues = 1; - return value0; -L3:; - value0 = v1number; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for GAUSSIAN-RANDOM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4gaussian_random(cl_narg narg, ...) -{ - cl_object T0, T1; - volatile cl_object lex0[2]; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); - { - va_list args; va_start(args,narg); - { - int i = 0; - if (i >= narg) { - lex0[0] = ECL_NIL; /* MIN */ - } else { - i++; - lex0[0] = va_arg(args,cl_object); /* MIN */ - } - if (i >= narg) { - lex0[1] = ECL_NIL; /* MAX */ - } else { - i++; - lex0[1] = va_arg(args,cl_object); /* MAX */ - } - } - va_end(args); - { - cl_object v2; /* G1 */ - cl_object v3; /* G2 */ - value0 = LC2gauss(); - v2 = value0; - { - const int v4 = cl_env_copy->nvalues; - cl_object v5; - v5 = (v4<=1)? ECL_NIL : cl_env_copy->values[1]; - v3 = v5; - } - T0 = LC3guard(lex0, v2); - T1 = LC3guard(lex0, v3); - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = T1; - cl_env_copy->values[0] = T0; - return cl_env_copy->values[0]; - } - } -} -/* local function GUARD */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3guard(volatile cl_object *lex0, cl_object v1x) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = lex0[0]; - if ((value0)!=ECL_NIL) { goto L5; } - T0 = v1x; - goto L3; -L5:; - T0 = value0; - goto L3; -L3:; - value0 = lex0[1]; - if ((value0)!=ECL_NIL) { goto L9; } - T1 = v1x; - goto L7; -L9:; - T1 = value0; - goto L7; -L7:; - if ((cl_LE(3, T0, v1x, T1))!=ECL_NIL) { goto L1; } -L11:; - { - cl_object v3; /* X1 */ - cl_object v4; /* X2 */ - value0 = LC2gauss(); - v3 = value0; - { - const int v5 = cl_env_copy->nvalues; - cl_object v6; - v6 = (v5<=1)? ECL_NIL : cl_env_copy->values[1]; - v4 = v6; - } - value0 = lex0[0]; - if ((value0)!=ECL_NIL) { goto L19; } - T0 = v3; - goto L17; -L19:; - T0 = value0; - goto L17; -L17:; - value0 = lex0[1]; - if ((value0)!=ECL_NIL) { goto L23; } - T1 = v3; - goto L21; -L23:; - T1 = value0; - goto L21; -L21:; - if (Null(cl_LE(3, T0, v3, T1))) { goto L15; } - v1x = v3; - goto L12; -L15:; - value0 = lex0[0]; - if ((value0)!=ECL_NIL) { goto L31; } - T0 = v4; - goto L29; -L31:; - T0 = value0; - goto L29; -L29:; - value0 = lex0[1]; - if ((value0)!=ECL_NIL) { goto L35; } - T1 = v4; - goto L33; -L35:; - T1 = value0; - goto L33; -L33:; - if (Null(cl_LE(3, T0, v4, T1))) { goto L27; } - v1x = v4; - goto L12; -L27:; - goto L11; - } -L12:; -L1:; - value0 = v1x; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function GAUSS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2gauss() -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v1x1; - v1x1 = ECL_NIL; - { - cl_object v2x2; - v2x2 = ECL_NIL; - { - cl_object v3w; - v3w = ECL_NIL; -L4:; - T0 = cl_random(1, VV[2]); - v1x1 = ecl_minus(T0,VV[3]); - T0 = cl_random(1, VV[2]); - v2x2 = ecl_minus(T0,VV[3]); - T0 = ecl_expt(v1x1,ecl_make_fixnum(2)); - T1 = ecl_expt(v2x2,ecl_make_fixnum(2)); - v3w = ecl_plus(T0,T1); - if (!(ecl_number_compare(v3w,VV[3])<0)) { goto L11; } - { - cl_object v4v; - T0 = cl_log(1, v3w); - T1 = ecl_times(VV[4],T0); - T2 = ecl_divide(T1,v3w); - v4v = ecl_sqrt(T2); - T0 = ecl_times(v1x1,v4v); - T1 = ecl_times(v2x2,v4v); - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = T1; - cl_env_copy->values[0] = T0; - return cl_env_copy->values[0]; - } -L11:; - goto L4; - } - } - } - } -} -/* function definition for IOTA */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5iota(cl_narg narg, cl_object v1n, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2start; - cl_object v3step; - ecl_va_list args; ecl_va_start(args,v1n,narg,1); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L5iotakeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v2start = ecl_make_fixnum(0); - } else { - v2start = keyvars[0]; - } - if (Null(keyvars[3])) { - v3step = ecl_make_fixnum(1); - } else { - v3step = keyvars[1]; - } - } - { - cl_object v4; - v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L7; } - v4 = v1n; - T0 = ecl_make_bool(ecl_number_compare(v4,ecl_make_fixnum(0))>=0); - goto L4; -L7:; - T0 = ECL_NIL; - goto L4; - } -L4:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[6],v1n); - { - bool v4; - v4 = ecl_numberp(v2start); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("NUMBER",606),v2start); - } - { - bool v4; - v4 = ecl_numberp(v3step); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("NUMBER",606),v3step); - } - { - cl_object v4; - cl_object v5i; - v4 = v1n; - v5i = ECL_NIL; - { - cl_object v6; - cl_object v7; - v6 = ecl_list1(ECL_NIL); - v7 = v6; - v4 = ecl_minus(v4,ecl_make_fixnum(1)); - T0 = v4; - if (!(ecl_minusp(T0))) { goto L19; } - goto L18; -L19:; - T0 = ecl_plus(v2start,v3step); - v5i = ecl_minus(T0,v3step); -L17:; - { - cl_object v8; - v8 = v7; - if (ecl_unlikely(ECL_ATOM(v8))) FEtype_error_cons(v8); - T0 = v8; - } - v7 = ecl_list1(v5i); - (ECL_CONS_CDR(T0)=v7,T0); - v4 = ecl_minus(v4,ecl_make_fixnum(1)); - T0 = v4; - if (!(ecl_minusp(T0))) { goto L30; } - goto L18; -L30:; - v5i = ecl_plus(v5i,v3step); - goto L17; -L18:; - value0 = ecl_cdr(v6); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* function definition for MAP-IOTA */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L6map_iota(cl_narg narg, cl_object v1function, cl_object v2n, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3start; - cl_object v4step; - ecl_va_list args; ecl_va_start(args,v2n,narg,2); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L6map_iotakeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v3start = ecl_make_fixnum(0); - } else { - v3start = keyvars[0]; - } - if (Null(keyvars[3])) { - v4step = ecl_make_fixnum(1); - } else { - v4step = keyvars[1]; - } - } - { - cl_object v5; - v5 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L7; } - v5 = v2n; - T0 = ecl_make_bool(ecl_number_compare(v5,ecl_make_fixnum(0))>=0); - goto L4; -L7:; - T0 = ECL_NIL; - goto L4; - } -L4:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[6],v2n); - { - bool v5; - v5 = ecl_numberp(v3start); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(ECL_SYM("NUMBER",606),v3start); - } - { - bool v5; - v5 = ecl_numberp(v4step); - if (ecl_unlikely(!(v5))) - FEwrong_type_argument(ECL_SYM("NUMBER",606),v4step); - } - { - cl_object v5; - cl_object v6i; - v5 = v2n; - v6i = ECL_NIL; - v5 = ecl_minus(v5,ecl_make_fixnum(1)); - T0 = v5; - if (!(ecl_minusp(T0))) { goto L18; } - goto L17; -L18:; - T0 = ecl_minus(v4step,v4step); - v6i = ecl_plus(v3start,T0); -L16:; - ecl_function_dispatch(cl_env_copy,v1function)(1, v6i); - v5 = ecl_minus(v5,ecl_make_fixnum(1)); - T0 = v5; - if (!(ecl_minusp(T0))) { goto L25; } - goto L17; -L25:; - v6i = ecl_plus(v6i,v4step); - goto L16; -L17:; - } - value0 = v2n; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for LERP */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L7lerp(cl_object v1v, cl_object v2a, cl_object v3b) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = ecl_minus(v3b,v2a); - T1 = ecl_times(v1v,T0); - value0 = ecl_plus(v2a,T1); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for MEAN */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L8mean(cl_object v1sample) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = (ECL_SYM("+",14)->symbol.gfdef); - T1 = cl_reduce(2, T0, v1sample); - { - cl_fixnum v2; - v2 = ecl_length(v1sample); - value0 = ecl_divide(T1,ecl_make_fixnum(v2)); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MEDIAN */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L9median(cl_object v1sample) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2vector; - cl_fixnum v3length; - cl_object v4middle; - T0 = ecl_function_dispatch(cl_env_copy,VV[42])(2, ECL_SYM("VECTOR",898), v1sample) /* COPY-SEQUENCE */; - T1 = (ECL_SYM("<",72)->symbol.gfdef); - v2vector = cl_sort(2, T0, T1); - v3length = ecl_length(v2vector); - v4middle = ecl_truncate2(ecl_make_fixnum(v3length),ecl_make_fixnum(2)); - if (!(ecl_oddp(ecl_make_fixnum(v3length)))) { goto L5; } - { - cl_object v5; - v5 = v2vector; - T0 = v5; - { - cl_fixnum v6; - { - cl_object v7; - v7 = v4middle; - if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) - FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); - v6 = ecl_fixnum(v7); - } - value0 = ecl_aref_unsafe(T0,v6); - cl_env_copy->nvalues = 1; - return value0; - } - } -L5:; - { - cl_object v7; - v7 = v2vector; - T1 = v7; - { - cl_fixnum v8; - { - cl_object v9; - v9 = v4middle; - if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - v8 = ecl_fixnum(v9); - } - T0 = ecl_aref_unsafe(T1,v8); - } - } - { - cl_object v7; - v7 = v2vector; - T2 = v7; - { - cl_fixnum v8; - { - cl_object v9; - v9 = ecl_one_minus(v4middle); - if (ecl_unlikely((ecl_fixnum(v9))>=(v7)->vector.dim)) - FEwrong_index(ECL_NIL,v7,-1,ecl_make_fixnum(ecl_fixnum(v9)),(v7)->vector.dim); - v8 = ecl_fixnum(v9); - } - T1 = ecl_aref_unsafe(T2,v8); - } - } - T2 = ecl_plus(T0,T1); - value0 = ecl_divide(T2,ecl_make_fixnum(2)); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for VARIANCE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L11variance(cl_narg narg, cl_object v1sample, ...) -{ - cl_object T0, T1, T2; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2biased; - ecl_va_list args; ecl_va_start(args,v1sample,narg,1); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L11variancekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v2biased = ECL_T; - } else { - v2biased = keyvars[0]; - } - } - { - cl_object env1 = env0; - T1 = (ECL_SYM("+",14)->symbol.gfdef); - T2 = cl_reduce(2, T1, v1sample); - { - cl_fixnum v3; - v3 = ecl_length(v1sample); - T0 = ecl_divide(T2,ecl_make_fixnum(v3)); - } - env1 = ECL_NIL; - CLV0 = env1 = CONS(T0,env1); /* MEAN */ - { - cl_object v3; - v3 = ecl_make_cclosure_va((cl_objectfn)LC10__g32,env1,Cblock); - T0 = v3; - } - T1 = cl_reduce(4, T0, v1sample, VV[12], ecl_make_fixnum(0)); - { - cl_fixnum v3; - v3 = ecl_length(v1sample); - { - cl_fixnum v4; - if (Null(v2biased)) { goto L6; } - v4 = 0; - goto L5; -L6:; - v4 = 1; -L5:; - T2 = ecl_minus(ecl_make_fixnum(v3),ecl_make_fixnum(v4)); - value0 = ecl_divide(T1,T2); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* closure G32 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC10__g32(cl_narg narg, cl_object v1a, cl_object v2b, ...) -{ - cl_object T0, T1; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* MEAN */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = ecl_minus(v2b,ECL_CONS_CAR(CLV0)); - T1 = ecl_expt(T0,ecl_make_fixnum(2)); - value0 = ecl_plus(v1a,T1); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for STANDARD-DEVIATION */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L13standard_deviation(cl_narg narg, cl_object v1sample, ...) -{ - cl_object T0, T1, T2, T3; - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2biased; - ecl_va_list args; ecl_va_start(args,v1sample,narg,1); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L13standard_deviationkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v2biased = ECL_T; - } else { - v2biased = keyvars[0]; - } - } - { - cl_object v3; - cl_object v4; - cl_object v5biased; - v3 = cl_list(2, VV[14], v2biased); - v4 = si_search_keyword(2, v3, VV[14]); - if (!((v4)==(ECL_SYM("MISSING-KEYWORD",1943)))) { goto L6; } - v5biased = ECL_T; - goto L5; -L6:; - v5biased = v4; -L5:; - si_check_keyword(2, v3, VV[15]); - { - cl_object env1 = env0; - T2 = (ECL_SYM("+",14)->symbol.gfdef); - T3 = cl_reduce(2, T2, v1sample); - { - cl_fixnum v6; - v6 = ecl_length(v1sample); - T1 = ecl_divide(T3,ecl_make_fixnum(v6)); - } - env1 = ECL_NIL; - CLV0 = env1 = CONS(T1,env1); /* MEAN */ - { - cl_object v6; - v6 = ecl_make_cclosure_va((cl_objectfn)LC12__g38,env1,Cblock); - T1 = v6; - } - T2 = cl_reduce(4, T1, v1sample, VV[12], ecl_make_fixnum(0)); - { - cl_fixnum v6; - v6 = ecl_length(v1sample); - { - cl_fixnum v7; - if (Null(v5biased)) { goto L13; } - v7 = 0; - goto L12; -L13:; - v7 = 1; -L12:; - T3 = ecl_minus(ecl_make_fixnum(v6),ecl_make_fixnum(v7)); - T0 = ecl_divide(T2,T3); - } - } - } - } - value0 = ecl_sqrt(T0); - cl_env_copy->nvalues = 1; - return value0; - } -} -/* closure G38 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12__g38(cl_narg narg, cl_object v1a, cl_object v2b, ...) -{ - cl_object T0, T1; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* MEAN */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = ecl_minus(v2b,ECL_CONS_CAR(CLV0)); - T1 = ecl_expt(T0,ecl_make_fixnum(2)); - value0 = ecl_plus(v1a,T1); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function MAXF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC15maxf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC14__g44,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("MAX",551), v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[17],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L11:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L20; -L19:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L20:; - if (v12si__d==ECL_NIL) { goto L26; } - goto L19; -L26:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L31; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, ECL_SYM("MAX",551), v10, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L30; -L31:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("MAX",551), v10, T3); -L30:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[17],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G44 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14__g44(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function MINF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC17minf(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v5; - } - { - cl_object v6; /* VARS */ - cl_object v7; /* VALS */ - cl_object v8; /* STORES */ - cl_object v9; /* SETTER */ - cl_object v10; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v6 = value0; - v7 = cl_env_copy->values[1]; - v8 = cl_env_copy->values[2]; - v9 = cl_env_copy->values[3]; - v10 = cl_env_copy->values[4]; - { - cl_object v11si__all_vars; - { - cl_object v12; - v12 = ecl_make_cfun((cl_objectfn_fixed)LC16__g55,ECL_NIL,Cblock,1); - T0 = v12; - } - T1 = v3; - v11si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v10))) { goto L11; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v11si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("MIN",557), v10, T1); - T3 = ecl_car(v8); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v11si__all_vars) /* MAPCAR */; - T6 = CONS(VV[17],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v11si__all_vars, T7, v9); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L11:; - { - cl_object v12si__d; - cl_object v13si__v; - cl_object v14si__let_list; - v12si__d = v6; - v13si__v = v7; - v14si__let_list = ECL_NIL; - goto L20; -L19:; - { - cl_object v15; - v15 = ecl_cdr(v12si__d); - { - cl_object v16; - v16 = ecl_cdr(v13si__v); - T0 = ecl_car(v12si__d); - T1 = ecl_car(v13si__v); - T2 = cl_list(2, T0, T1); - v14si__let_list = CONS(T2,v14si__let_list); - v13si__v = v16; - v12si__d = v15; - } - } -L20:; - if (v12si__d==ECL_NIL) { goto L26; } - goto L19; -L26:; - T0 = ecl_car(v8); - if (!(ECL_LISTP(v4si___reference))) { goto L31; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L31; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(3, ECL_SYM("MIN",557), v10, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L30; -L31:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v11si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("MIN",557), v10, T3); -L30:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v11si__all_vars,v14si__let_list); - v14si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v14si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v11si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v6); - T4 = CONS(VV[17],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v9); - return value0; - } - } - } - } - } -} -/* local function G55 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC16__g55(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* function definition for %MULTIPLY-RANGE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L21_multiply_range(cl_object v1i, cl_object v2j) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1i))) { goto L1; } - if (!(ECL_FIXNUMP(v2j))) { goto L1; } - value0 = LC18bisect(v1i, v2j); - return value0; -L1:; - value0 = LC19bisect_big(v1i, v2j); - return value0; - } -} -/* local function MULTIPLY-RANGE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC20multiply_range(cl_object v1j, cl_object v2k) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v3; - v3 = 0; - if (!(ECL_FIXNUMP(v1j))) { goto L5; } - v3 = ecl_fixnum(v1j); - if (!((v3)<=(2305843009213693951))) { goto L10; } - T0 = ecl_make_bool((v3)>=(1)); - goto L2; -L10:; - T0 = ECL_NIL; - goto L2; -L5:; - T0 = ECL_NIL; - goto L2; - } -L2:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[22],v1j); - { - cl_fixnum v3; - v3 = 0; - if (!(ECL_FIXNUMP(v2k))) { goto L16; } - v3 = ecl_fixnum(v2k); - if (!((v3)<=(2305843009213693951))) { goto L21; } - T0 = ecl_make_bool((v3)>=(1)); - goto L13; -L21:; - T0 = ECL_NIL; - goto L13; -L16:; - T0 = ECL_NIL; - goto L13; - } -L13:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[22],v2k); - { - cl_object v3; - cl_object v4f; - cl_fixnum v5m; - v3 = ecl_make_integer((ecl_to_fixnum(v2k))-1); - v4f = v2k; - { - cl_object v6; - v6 = v3; - { - cl_fixnum v7; - v7 = 0; - if (!(ECL_FIXNUMP(v6))) { goto L31; } - v7 = ecl_fixnum(v6); - if (!((v7)<(2305843009213693951))) { goto L36; } - T0 = ecl_make_bool((v7)>=(0)); - goto L28; -L36:; - T0 = ECL_NIL; - goto L28; -L31:; - T0 = ECL_NIL; - goto L28; - } -L28:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[24],v6); - v5m = ecl_fixnum(v6); - } - goto L40; -L39:; - { - cl_object v6; - v6 = ecl_times(v4f,ecl_make_fixnum(v5m)); - { - cl_object v7; - v7 = ecl_make_fixnum(0); - v7 = v6; - T0 = ecl_make_bool(ecl_number_compare(v7,ecl_make_fixnum(0))>=0); - goto L46; - T0 = ECL_NIL; - goto L46; - } -L46:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("UNSIGNED-BYTE",885),v6); - v4f = v6; - } - { - cl_object v6; - v6 = ecl_make_integer((v5m)-1); - { - cl_fixnum v7; - v7 = 0; - if (!(ECL_FIXNUMP(v6))) { goto L59; } - v7 = ecl_fixnum(v6); - if (!((v7)<(2305843009213693951))) { goto L64; } - T0 = ecl_make_bool((v7)>=(0)); - goto L56; -L64:; - T0 = ECL_NIL; - goto L56; -L59:; - T0 = ECL_NIL; - goto L56; - } -L56:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[24],v6); - v5m = ecl_fixnum(v6); - } -L40:; - if ((v5m)<(ecl_to_fixnum(v1j))) { goto L66; } - goto L39; -L66:; - value0 = v4f; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function BISECT-BIG */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19bisect_big(cl_object v1j, cl_object v2k) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - v3 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v1j)||ECL_BIGNUMP(v1j))) { goto L5; } - v3 = v1j; - T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); - goto L2; -L5:; - T0 = ECL_NIL; - goto L2; - } -L2:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[23],v1j); - { - cl_object v3; - v3 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2k)||ECL_BIGNUMP(v2k))) { goto L13; } - v3 = v2k; - T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); - goto L10; -L13:; - T0 = ECL_NIL; - goto L10; - } -L10:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[23],v2k); - if (!(ecl_number_equalp(v1j,v2k))) { goto L17; } - value0 = v1j; - cl_env_copy->nvalues = 1; - return value0; -L17:; - { - cl_object v3middle; - T0 = ecl_minus(v2k,v1j); - T1 = ecl_truncate2(T0,ecl_make_fixnum(2)); - v3middle = ecl_plus(v1j,T1); - if (!(ecl_number_compare(v3middle,ecl_make_fixnum(2305843009213693951))<=0)) { goto L21; } - T0 = LC18bisect(v1j, v3middle); - goto L20; -L21:; - T0 = LC19bisect_big(v1j, v3middle); -L20:; - T2 = ecl_plus(v3middle,ecl_make_fixnum(1)); - T1 = LC19bisect_big(T2, v2k); - value0 = ecl_times(T0,T1); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function BISECT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC18bisect(cl_object v1j, cl_object v2k) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v3; - v3 = 0; - if (!(ECL_FIXNUMP(v1j))) { goto L5; } - v3 = ecl_fixnum(v1j); - if (!((v3)<=(2305843009213693951))) { goto L10; } - T0 = ecl_make_bool((v3)>=(1)); - goto L2; -L10:; - T0 = ECL_NIL; - goto L2; -L5:; - T0 = ECL_NIL; - goto L2; - } -L2:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[22],v1j); - { - cl_fixnum v3; - v3 = 0; - if (!(ECL_FIXNUMP(v2k))) { goto L16; } - v3 = ecl_fixnum(v2k); - if (!((v3)<=(2305843009213693951))) { goto L21; } - T0 = ecl_make_bool((v3)>=(1)); - goto L13; -L21:; - T0 = ECL_NIL; - goto L13; -L16:; - T0 = ECL_NIL; - goto L13; - } -L13:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[22],v2k); - T0 = ecl_minus(v2k,v1j); - if (!(ecl_number_compare(T0,ecl_make_fixnum(8))<0)) { goto L23; } - value0 = LC20multiply_range(v1j, v2k); - return value0; -L23:; - { - cl_object v3middle; - T0 = ecl_minus(v2k,v1j); - T1 = ecl_truncate2(T0,ecl_make_fixnum(2)); - v3middle = ecl_plus(v1j,T1); - T0 = LC18bisect(v1j, v3middle); - T2 = ecl_plus(v3middle,ecl_make_fixnum(1)); - T1 = LC18bisect(T2, v2k); - value0 = ecl_times(T0,T1); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for %FACTORIAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L22_factorial(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ecl_number_compare(v1n,ecl_make_fixnum(2))<0)) { goto L1; } - value0 = ecl_make_fixnum(1); - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = L21_multiply_range(ecl_make_fixnum(1), v1n); - return value0; - } -} -/* function definition for FACTORIAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L23factorial(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - v2 = v1n; - { - cl_object v3; - v3 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))) { goto L7; } - v3 = v2; - if (ecl_number_compare(v3,ecl_make_fixnum(0))>=0) { goto L3; } - goto L4; -L7:; - goto L4; - } -L4:; - v1n = si_do_check_type(v2, VV[6], ECL_NIL, VV[27]); -L3:; - } - value0 = L22_factorial(v1n); - return value0; - } -} -/* function definition for BINOMIAL-COEFFICIENT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L24binomial_coefficient(cl_object v1n, cl_object v2k) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - v3 = v1n; - { - cl_object v4; - v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L7; } - v4 = v3; - if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L3; } - goto L4; -L7:; - goto L4; - } -L4:; - v1n = si_do_check_type(v3, VV[6], ECL_NIL, VV[27]); -L3:; - } - { - cl_object v3; - v3 = v2k; - { - cl_object v4; - v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L18; } - v4 = v3; - if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L14; } - goto L15; -L18:; - goto L15; - } -L15:; - v2k = si_do_check_type(v3, VV[6], ECL_NIL, VV[29]); -L14:; - } - goto L25; -L24:; - si_assert_failure(1, VV[30]); -L25:; - if (ecl_number_compare(v1n,v2k)>=0) { goto L28; } - goto L24; -L28:; - if (ecl_zerop(v2k)) { goto L32; } - if (!(ecl_number_equalp(v1n,v2k))) { goto L30; } - goto L31; -L32:; -L31:; - value0 = ecl_make_fixnum(1); - cl_env_copy->nvalues = 1; - return value0; -L30:; - { - cl_object v3n_k; - v3n_k = ecl_minus(v1n,v2k); - if (!(ecl_number_compare(v2k,v3n_k)<0)) { goto L35; } - { - cl_object v4; - v4 = v3n_k; - { - cl_object v5; - v5 = v2k; - v2k = v4; - v3n_k = v5; - } - } -L35:; - if (!(ecl_number_equalp(ecl_make_fixnum(1),v3n_k))) { goto L43; } - value0 = v1n; - cl_env_copy->nvalues = 1; - return value0; -L43:; - T0 = ecl_plus(v2k,ecl_make_fixnum(1)); - T1 = L21_multiply_range(T0, v1n); - T2 = L22_factorial(v3n_k); - value0 = ecl_divide(T1,T2); - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for SUBFACTORIAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L25subfactorial(cl_object v1n) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - v2 = v1n; - { - cl_object v3; - v3 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2)||ECL_BIGNUMP(v2))) { goto L7; } - v3 = v2; - if (ecl_number_compare(v3,ecl_make_fixnum(0))>=0) { goto L3; } - goto L4; -L7:; - goto L4; - } -L4:; - v1n = si_do_check_type(v2, VV[6], ECL_NIL, VV[27]); -L3:; - } - if (!(ecl_zerop(v1n))) { goto L12; } - value0 = ecl_make_fixnum(1); - cl_env_copy->nvalues = 1; - return value0; -L12:; - { - cl_object v2x; - cl_object v3a; - cl_object v4b; - v2x = ecl_make_fixnum(1); - v3a = ecl_make_fixnum(0); - v4b = ecl_make_fixnum(1); - goto L19; -L18:; - { - cl_object v5; - v5 = ecl_one_plus(v2x); - { - cl_object v6; - T0 = ecl_plus(v3a,v4b); - v6 = ecl_times(v2x,T0); - v4b = v3a; - v3a = v6; - v2x = v5; - } - } -L19:; - if (ecl_number_equalp(v1n,v2x)) { goto L25; } - goto L18; -L25:; - value0 = v3a; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for COUNT-PERMUTATIONS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L26count_permutations(cl_narg narg, cl_object v1n, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); - { - cl_object v2k; - va_list args; va_start(args,v1n); - { - int i = 1; - if (i >= narg) { - v2k = v1n; - } else { - i++; - v2k = va_arg(args,cl_object); - } - } - va_end(args); - { - cl_object v3; - v3 = v1n; - { - cl_object v4; - v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L8; } - v4 = v3; - if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L4; } - goto L5; -L8:; - goto L5; - } -L5:; - v1n = si_do_check_type(v3, VV[6], ECL_NIL, VV[27]); -L4:; - } - { - cl_object v3; - v3 = v2k; - { - cl_object v4; - v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v3)||ECL_BIGNUMP(v3))) { goto L19; } - v4 = v3; - if (ecl_number_compare(v4,ecl_make_fixnum(0))>=0) { goto L15; } - goto L16; -L19:; - goto L16; - } -L16:; - v2k = si_do_check_type(v3, VV[6], ECL_NIL, VV[29]); -L15:; - } - goto L26; -L25:; - si_assert_failure(1, VV[30]); -L26:; - if (ecl_number_compare(v1n,v2k)>=0) { goto L29; } - goto L25; -L29:; - T0 = ecl_minus(v1n,v2k); - T1 = ecl_one_plus(T0); - value0 = L21_multiply_range(T1, v1n); - return value0; - } -} - -#include "lib/alexandria/numbers.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclGV3xc4hVq7NJM_NFi2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/numbers.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclGV3xc4hVq7NJM_NFi2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[33]); /* CLAMP */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[34]); /* GAUSSIAN-RANDOM */ - si_set_documentation(3, VV[1], ECL_SYM("FUNCTION",396), VVtemp[9]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[10]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[13]) /* ANNOTATE */; - ecl_cmp_defun(VV[35]); /* IOTA */ - si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[14]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[15]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[16], VVtemp[17]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[18]) /* ANNOTATE */; - ecl_cmp_defun(VV[38]); /* MAP-IOTA */ - si_set_documentation(3, VV[7], ECL_SYM("FUNCTION",396), VVtemp[19]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[20]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; - ecl_cmp_defun(VV[39]); /* LERP */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[24]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[25]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[26], VVtemp[27]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; - ecl_cmp_defun(VV[40]); /* MEAN */ - si_set_documentation(3, VV[9], ECL_SYM("FUNCTION",396), VVtemp[29]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[30]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; - ecl_cmp_defun(VV[41]); /* MEDIAN */ - si_set_documentation(3, VV[10], ECL_SYM("FUNCTION",396), VVtemp[33]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[34]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LOCATION",1777), VVtemp[35], VVtemp[36]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[11], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[37]) /* ANNOTATE */; - ecl_cmp_defun(VV[43]); /* VARIANCE */ - si_set_documentation(3, VV[11], ECL_SYM("FUNCTION",396), VVtemp[38]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[39]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[40], VVtemp[41]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[37]) /* ANNOTATE */; - ecl_cmp_defun(VV[44]); /* STANDARD-DEVIATION */ - si_set_documentation(3, VV[13], ECL_SYM("FUNCTION",396), VVtemp[42]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[43], VVtemp[44]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[45]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[45]); /* MAXF */ - si_set_documentation(3, VV[16], ECL_SYM("FUNCTION",396), VVtemp[46]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LOCATION",1777), VVtemp[47], VVtemp[48]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[18], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[45]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[46]); /* MINF */ - si_set_documentation(3, VV[18], ECL_SYM("FUNCTION",396), VVtemp[49]); - si_Xmake_constant(VV[19], ecl_make_fixnum(8)); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[19], ECL_SYM("LOCATION",1777), VVtemp[50], VVtemp[51]) /* ANNOTATE */; - si_Xmake_constant(VV[20], ecl_make_fixnum(13)); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[53]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LOCATION",1777), VVtemp[54], VVtemp[55]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[21], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[56]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* %MULTIPLY-RANGE */ - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[57]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[58], VVtemp[59]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[60]) /* ANNOTATE */; - ecl_cmp_defun(VV[48]); /* %FACTORIAL */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[61], VVtemp[62]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[60]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* FACTORIAL */ - si_set_documentation(3, VV[26], ECL_SYM("FUNCTION",396), VVtemp[63]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[64], VVtemp[65]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[66]) /* ANNOTATE */; - ecl_cmp_defun(VV[50]); /* BINOMIAL-COEFFICIENT */ - si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[67]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LOCATION",1777), VVtemp[68], VVtemp[69]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[60]) /* ANNOTATE */; - ecl_cmp_defun(VV[51]); /* SUBFACTORIAL */ - si_set_documentation(3, VV[31], ECL_SYM("FUNCTION",396), VVtemp[70]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LOCATION",1777), VVtemp[71], VVtemp[72]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[73]) /* ANNOTATE */; - ecl_cmp_defun(VV[52]); /* COUNT-PERMUTATIONS */ - si_set_documentation(3, VV[32], ECL_SYM("FUNCTION",396), VVtemp[74]); -} diff --git a/lib/alexandria/package.cxx b/lib/alexandria/package.cxx deleted file mode 100644 index 9af397c..0000000 --- a/lib/alexandria/package.cxx +++ /dev/null @@ -1,36 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/package.lisp */ -#include -#include "lib/alexandria/package.eclh" - -#include "lib/alexandria/package.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclFO5a0GhkppGJM_ftf2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/package.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclFO5a0GhkppGJM_ftf2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - ecl_function_dispatch(cl_env_copy,VV[0])(10, VVtemp[0], VVtemp[1], ECL_NIL, VVtemp[2], ECL_NIL, ECL_NIL, VVtemp[3], ECL_NIL, ECL_NIL, ECL_NIL) /* DODEFPACKAGE */; -} diff --git a/lib/alexandria/sequences.cxx b/lib/alexandria/sequences.cxx deleted file mode 100644 index d486aa4..0000000 --- a/lib/alexandria/sequences.cxx +++ /dev/null @@ -1,2608 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/sequences.lisp */ -#include -#include "lib/alexandria/sequences.eclh" -/* function definition for SEQUENCE-OF-LENGTH-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1sequence_of_length_p(cl_object v1sequence, cl_object v2length) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_fixnum v3; - v3 = 0; - if (!(ECL_FIXNUMP(v2length))) { goto L5; } - v3 = ecl_fixnum(v2length); - if (!((v3)<(2305843009213693950))) { goto L10; } - T0 = ecl_make_bool((v3)>=(0)); - goto L2; -L10:; - T0 = ECL_NIL; - goto L2; -L5:; - T0 = ECL_NIL; - goto L2; - } -L2:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[1],v2length); - if (!(v1sequence==ECL_NIL)) { goto L12; } - value0 = ecl_make_bool((ecl_to_fixnum(v2length))==0); - cl_env_copy->nvalues = 1; - return value0; -L12:; - if (!(ECL_CONSP(v1sequence))) { goto L14; } - { - cl_object v3n; - v3n = ecl_make_integer((ecl_to_fixnum(v2length))-1); - if (ecl_minusp(v3n)) { goto L17; } - { - cl_object v4tail; - v4tail = ecl_nthcdr(ecl_to_size(v3n),v1sequence); - if (Null(v4tail)) { goto L21; } - T0 = ecl_cdr(v4tail); - value0 = ecl_make_bool(T0==ECL_NIL); - cl_env_copy->nvalues = 1; - return value0; -L21:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L17:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L14:; - if (!(ECL_VECTORP(v1sequence))) { goto L23; } - { - cl_fixnum v5; - v5 = ecl_length(v1sequence); - value0 = ecl_make_bool((ecl_to_fixnum(v2length))==(v5)); - cl_env_copy->nvalues = 1; - return value0; - } -L23:; - if (ECL_CONSP(v1sequence)) { goto L27; } - if (v1sequence==ECL_NIL) { goto L27; } - if (!(ECL_VECTORP(v1sequence))) { goto L25; } - goto L26; -L27:; -L26:; - { - cl_fixnum v6; - v6 = ecl_length(v1sequence); - value0 = ecl_make_bool((ecl_to_fixnum(v2length))==(v6)); - cl_env_copy->nvalues = 1; - return value0; - } -L25:; - value0 = si_etypecase_error(v1sequence, VV[2]); - return value0; - } -} -/* function definition for ROTATE-TAIL-TO-HEAD */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L2rotate_tail_to_head(cl_object v1sequence, cl_object v2n) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - v3 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L5; } - v3 = v2n; - T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); - goto L2; -L5:; - T0 = ECL_NIL; - goto L2; - } -L2:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[4],v2n); - if (!(ECL_LISTP(v1sequence))) { goto L9; } - { - cl_object v3m; - T0 = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; - v3m = (ecl_floor2(v2n,T0),cl_env_copy->values[1]); - T0 = ecl_cdr(v1sequence); - if (!(T0==ECL_NIL)) { goto L12; } - value0 = v1sequence; - cl_env_copy->nvalues = 1; - return value0; -L12:; - { - cl_object v4tail; - cl_object v5last; - T0 = ecl_plus(v3m,ecl_make_fixnum(1)); - v4tail = cl_last(2, v1sequence, T0); - v5last = ecl_cdr(v4tail); - { - cl_object v6; - v6 = ECL_NIL; - { - cl_object v7; - v7 = v4tail; - if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); - T0 = v7; - } - (ECL_CONS_CDR(T0)=v6,T0); - } - value0 = ecl_nconc(v5last,v1sequence); - cl_env_copy->nvalues = 1; - return value0; - } - } -L9:; - { - cl_fixnum v6len; - cl_object v7m; - cl_object v8tail; - v6len = ecl_length(v1sequence); - v7m = (ecl_floor2(v2n,ecl_make_fixnum(v6len)),cl_env_copy->values[1]); - T0 = ecl_minus(ecl_make_fixnum(v6len),v7m); - v8tail = cl_subseq(2, v1sequence, T0); - cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1316), v7m, ECL_SYM("START2",1317), ecl_make_fixnum(0)); - cl_replace(2, v1sequence, v8tail); - value0 = v1sequence; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ROTATE-HEAD-TO-TAIL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L3rotate_head_to_tail(cl_object v1sequence, cl_object v2n) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - v3 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2n)||ECL_BIGNUMP(v2n))) { goto L5; } - v3 = v2n; - T0 = ecl_make_bool(ecl_number_compare(v3,ecl_make_fixnum(1))>=0); - goto L2; -L5:; - T0 = ECL_NIL; - goto L2; - } -L2:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[4],v2n); - if (!(ECL_LISTP(v1sequence))) { goto L9; } - { - cl_object v3m; - T0 = ecl_one_minus(v2n); - T1 = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; - v3m = (ecl_floor2(T0,T1),cl_env_copy->values[1]); - T0 = ecl_cdr(v1sequence); - if (!(T0==ECL_NIL)) { goto L12; } - value0 = v1sequence; - cl_env_copy->nvalues = 1; - return value0; -L12:; - { - cl_object v4headtail; - cl_object v5tail; - v4headtail = ecl_nthcdr(ecl_to_size(v3m),v1sequence); - v5tail = ecl_cdr(v4headtail); - { - cl_object v6; - v6 = ECL_NIL; - { - cl_object v7; - v7 = v4headtail; - if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); - T0 = v7; - } - (ECL_CONS_CDR(T0)=v6,T0); - } - value0 = ecl_nconc(v5tail,v1sequence); - cl_env_copy->nvalues = 1; - return value0; - } - } -L9:; - { - cl_fixnum v6len; - cl_object v7m; - cl_object v8head; - v6len = ecl_length(v1sequence); - v7m = (ecl_floor2(v2n,ecl_make_fixnum(v6len)),cl_env_copy->values[1]); - v8head = cl_subseq(3, v1sequence, ecl_make_fixnum(0), v7m); - cl_replace(6, v1sequence, v1sequence, ECL_SYM("START1",1316), ecl_make_fixnum(0), ECL_SYM("START2",1317), v7m); - T0 = ecl_minus(ecl_make_fixnum(v6len),v7m); - cl_replace(4, v1sequence, v8head, ECL_SYM("START1",1316), T0); - value0 = v1sequence; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for ROTATE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4rotate(cl_narg narg, cl_object v1sequence, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); - { - cl_object v2n; - va_list args; va_start(args,v1sequence); - { - int i = 1; - if (i >= narg) { - v2n = ecl_make_fixnum(1); - } else { - i++; - v2n = va_arg(args,cl_object); - } - } - va_end(args); - if (!(ecl_plusp(v2n))) { goto L2; } - value0 = L2rotate_tail_to_head(v1sequence, v2n); - return value0; -L2:; - if (!(ecl_minusp(v2n))) { goto L4; } - T0 = ecl_negate(v2n); - value0 = L3rotate_head_to_tail(v1sequence, T0); - return value0; -L4:; - value0 = v1sequence; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for SHUFFLE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5shuffle(cl_narg narg, cl_object v1sequence, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2start; - cl_object v3end; - ecl_va_list args; ecl_va_start(args,v1sequence,narg,1); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L5shufflekeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v2start = ecl_make_fixnum(0); - } else { - v2start = keyvars[0]; - } - v3end = keyvars[1]; - } - { - bool v4; - v4 = ECL_FIXNUMP(v2start); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("FIXNUM",372),v2start); - } - value0 = ecl_make_bool(ECL_FIXNUMP(v3end)); - if ((value0)!=ECL_NIL) { goto L6; } - T0 = ecl_make_bool(v3end==ECL_NIL); - goto L4; -L6:; - T0 = value0; - goto L4; -L4:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[8],v3end); - if (!(ECL_LISTP(v1sequence))) { goto L9; } - { - cl_object v4end; - cl_object v5n; - value0 = v3end; - if ((value0)!=ECL_NIL) { goto L13; } - v4end = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; - goto L11; -L13:; - v4end = value0; - goto L11; -L11:; - v5n = ecl_minus(v4end,v2start); - { - cl_object v6tail; - v6tail = ecl_nthcdr(ecl_to_fixnum(v2start),v1sequence); - goto L19; -L18:; - { - cl_object v7; - T0 = cl_random(1, v5n); - v7 = ecl_nthcdr(ecl_to_size(T0),v6tail); - { - cl_object v8; - v8 = ecl_car(v7); - { - cl_object v9; - v9 = ecl_car(v6tail); - { - cl_object v10; - v10 = v6tail; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T0 = v10; - } - (ECL_CONS_CAR(T0)=v8,T0); - { - cl_object v10; - v10 = v7; - if (ecl_unlikely(ECL_ATOM(v10))) FEtype_error_cons(v10); - T0 = v10; - } - (ECL_CONS_CAR(T0)=v9,T0); - } - } - } - v5n = ecl_minus(v5n,ecl_make_fixnum(1)); - v6tail = ecl_cdr(v6tail); -L19:; - if (ecl_zerop(v5n)) { goto L39; } - goto L18; -L39:; - goto L8; - } - } -L9:; - if (!(ECL_VECTORP(v1sequence))) { goto L41; } - { - cl_object v7end; - value0 = v3end; - if ((value0)!=ECL_NIL) { goto L45; } - v7end = ecl_make_fixnum(ecl_length(v1sequence)); - goto L43; -L45:; - v7end = value0; - goto L43; -L43:; - { - cl_object v8i; - cl_object v9; - v8i = v2start; - { - cl_object v10; - v10 = v7end; - T0 = cl_realp(v10); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v10); - v9 = v10; - } -L51:; - if (!(ecl_number_compare(v8i,v9)>=0)) { goto L53; } - goto L52; -L53:; - { - cl_object v10; - T0 = ecl_minus(v7end,v8i); - T1 = cl_random(1, T0); - v10 = ecl_plus(v8i,T1); - { - cl_object v11; - { - cl_object v12; - v12 = v1sequence; - T0 = v12; - { - cl_fixnum v13; - { - cl_object v14; - v14 = v10; - if (ecl_unlikely((ecl_fixnum(v14))>=(v12)->vector.dim)) - FEwrong_index(ECL_NIL,v12,-1,ecl_make_fixnum(ecl_fixnum(v14)),(v12)->vector.dim); - v13 = ecl_fixnum(v14); - } - v11 = ecl_aref_unsafe(T0,v13); - } - } - { - cl_object v12; - { - cl_object v13; - v13 = v1sequence; - T0 = v13; - { - cl_fixnum v14; - { - cl_object v15; - v15 = v8i; - if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) - FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); - v14 = ecl_fixnum(v15); - } - v12 = ecl_aref_unsafe(T0,v14); - } - } - { - cl_object v13; - v13 = v1sequence; - T0 = v13; - { - cl_fixnum v14; - { - cl_object v15; - v15 = v8i; - if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) - FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); - v14 = ecl_fixnum(v15); - } - ecl_aset_unsafe(T0,v14,v11); - } - } - { - cl_object v13; - v13 = v1sequence; - T0 = v13; - { - cl_fixnum v14; - { - cl_object v15; - v15 = v10; - if (ecl_unlikely((ecl_fixnum(v15))>=(v13)->vector.dim)) - FEwrong_index(ECL_NIL,v13,-1,ecl_make_fixnum(ecl_fixnum(v15)),(v13)->vector.dim); - v14 = ecl_fixnum(v15); - } - ecl_aset_unsafe(T0,v14,v12); - } - } - } - } - } - v8i = ecl_one_plus(v8i); - goto L51; -L52:; - goto L8; - } - } -L41:; - if (ECL_CONSP(v1sequence)) { goto L86; } - if (v1sequence==ECL_NIL) { goto L86; } - if (!(ECL_VECTORP(v1sequence))) { goto L84; } - goto L85; -L86:; -L85:; - { - cl_object v10end; - value0 = v3end; - if ((value0)!=ECL_NIL) { goto L91; } - v10end = ecl_make_fixnum(ecl_length(v1sequence)); - goto L89; -L91:; - v10end = value0; - goto L89; -L89:; - { - cl_object v11; - cl_object v12i; - v11 = ecl_minus(v10end,ecl_make_fixnum(1)); - { - cl_object v13; - v13 = v11; - T0 = cl_realp(v13); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v13); - v12i = v13; - } -L97:; - if (!(ecl_number_compare(v12i,v2start)<0)) { goto L99; } - goto L98; -L99:; - { - cl_object v13; - T0 = ecl_minus(v10end,v12i); - T1 = cl_random(1, T0); - v13 = ecl_plus(v12i,T1); - { - cl_object v14; - v14 = ecl_elt(v1sequence,ecl_fixnum(v13)); - { - cl_object v15; - v15 = ecl_elt(v1sequence,ecl_fixnum(v12i)); - ecl_elt_set(v1sequence,ecl_to_size(v12i),v14); - ecl_elt_set(v1sequence,ecl_to_size(v13),v15); - } - } - } - v12i = ecl_one_minus(v12i); - goto L97; -L98:; - goto L8; - } - } -L84:; - si_etypecase_error(v1sequence, VV[9]); -L8:; - value0 = v1sequence; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for RANDOM-ELT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L6random_elt(cl_narg narg, cl_object v1sequence, ...) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - { - cl_object v2start; - cl_object v3end; - ecl_va_list args; ecl_va_start(args,v1sequence,narg,1); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L6random_eltkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v2start = ecl_make_fixnum(0); - } else { - v2start = keyvars[0]; - } - v3end = keyvars[1]; - } - if (ecl_unlikely(!(ECL_LISTP(v1sequence) || ECL_VECTORP(v1sequence)))) - FEtype_error_sequence(v1sequence); - { - bool v4; - v4 = ECL_FIXNUMP(v2start); - if (ecl_unlikely(!(v4))) - FEwrong_type_argument(ECL_SYM("FIXNUM",372),v2start); - } - value0 = ecl_make_bool(ECL_FIXNUMP(v3end)); - if ((value0)!=ECL_NIL) { goto L7; } - T0 = ecl_make_bool(v3end==ECL_NIL); - goto L5; -L7:; - T0 = value0; - goto L5; -L5:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[8],v3end); - { - cl_object v4size; - cl_object v5end2; - if (!(ECL_LISTP(v1sequence))) { goto L10; } - v4size = ecl_function_dispatch(cl_env_copy,VV[48])(1, v1sequence) /* PROPER-LIST-LENGTH */; - goto L9; -L10:; - v4size = ecl_make_fixnum(ecl_length(v1sequence)); -L9:; - value0 = v3end; - if ((value0)!=ECL_NIL) { goto L14; } - v5end2 = v4size; - goto L12; -L14:; - v5end2 = value0; - goto L12; -L12:; - if (!(ecl_zerop(v4size))) { goto L16; } - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[11]); - return value0; -L16:; - if (!((0)<=(ecl_to_fixnum(v2start)))) { goto L21; } - if (!(ecl_number_compare(v2start,v5end2)<0)) { goto L21; } - if (ecl_number_compare(v5end2,v4size)<=0) { goto L18; } - goto L19; -L21:; - goto L19; -L19:; - T0 = CONS(v2start,v3end); - T1 = ecl_list1(v5end2); - T2 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), T1); - T3 = ecl_list1(v2start); - T4 = cl_list(3, ECL_SYM("INTEGER",437), T3, v4size); - T5 = cl_list(3, ECL_SYM("OR",614), ECL_SYM("NULL",605), T4); - T6 = cl_list(3, ECL_SYM("CONS",251), T2, T5); - T7 = cl_list(3, v2start, v3end, v4size); - value0 = cl_error(9, ECL_SYM("SIMPLE-TYPE-ERROR",773), ECL_SYM("DATUM",1217), T0, ECL_SYM("EXPECTED-TYPE",1235), T6, ECL_SYM("FORMAT-CONTROL",1243), VV[12], ECL_SYM("FORMAT-ARGUMENTS",1242), T7); - return value0; -L18:; - { - cl_object v6index; - T0 = ecl_minus(v5end2,v2start); - T1 = cl_random(1, T0); - v6index = ecl_plus(v2start,T1); - value0 = ecl_elt(v1sequence,ecl_fixnum(v6index)); - cl_env_copy->nvalues = 1; - return value0; - } - } - } -} -/* function definition for REMOVE/SWAPPED-ARGUMENTS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L7remove_swapped_arguments(cl_narg narg, cl_object v1sequence, cl_object v2item, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3keyword_arguments; - ecl_va_list args; ecl_va_start(args,v2item,narg,2); - v3keyword_arguments = cl_grab_rest_args(args); - ecl_va_end(args); - T0 = (ECL_SYM("REMOVE",710)->symbol.gfdef); - value0 = cl_apply(4, T0, v2item, v1sequence, v3keyword_arguments); - return value0; - } -} -/* local function REMOVEF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC9removef(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - cl_object v5item; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5item = v6; - } - { - cl_object v7; /* VARS */ - cl_object v8; /* VALS */ - cl_object v9; /* STORES */ - cl_object v10; /* SETTER */ - cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - { - cl_object v12si__all_vars; - { - cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC8__g62,ECL_NIL,Cblock,1); - T0 = v13; - } - T1 = CONS(v5item,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[13], v11, T1); - T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[15],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L17:; - { - cl_object v13si__d; - cl_object v14si__v; - cl_object v15si__let_list; - v13si__d = v7; - v14si__v = v8; - v15si__let_list = ECL_NIL; - goto L26; -L25:; - { - cl_object v16; - v16 = ecl_cdr(v13si__d); - { - cl_object v17; - v17 = ecl_cdr(v14si__v); - T0 = ecl_car(v13si__d); - T1 = ecl_car(v14si__v); - T2 = cl_list(2, T0, T1); - v15si__let_list = CONS(T2,v15si__let_list); - v14si__v = v17; - v13si__d = v16; - } - } -L26:; - if (v13si__d==ECL_NIL) { goto L32; } - goto L25; -L32:; - T0 = ecl_car(v9); - if (!(ECL_LISTP(v4si___reference))) { goto L37; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(4, VV[13], v11, v5item, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L36; -L37:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, VV[13], v11, T3); -L36:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v7); - T4 = CONS(VV[15],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); - return value0; - } - } - } - } - } -} -/* local function G62 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC8__g62(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* function definition for DELETE/SWAPPED-ARGUMENTS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L10delete_swapped_arguments(cl_narg narg, cl_object v1sequence, cl_object v2item, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3keyword_arguments; - ecl_va_list args; ecl_va_start(args,v2item,narg,2); - v3keyword_arguments = cl_grab_rest_args(args); - ecl_va_end(args); - T0 = (ECL_SYM("DELETE",291)->symbol.gfdef); - value0 = cl_apply(4, T0, v2item, v1sequence, v3keyword_arguments); - return value0; - } -} -/* local function DELETEF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12deletef(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - cl_object v5item; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5item = v6; - } - { - cl_object v7; /* VARS */ - cl_object v8; /* VALS */ - cl_object v9; /* STORES */ - cl_object v10; /* SETTER */ - cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - { - cl_object v12si__all_vars; - { - cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC11__g74,ECL_NIL,Cblock,1); - T0 = v13; - } - T1 = CONS(v5item,v3); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v11))) { goto L17; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, VV[16], v11, T1); - T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[15],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L17:; - { - cl_object v13si__d; - cl_object v14si__v; - cl_object v15si__let_list; - v13si__d = v7; - v14si__v = v8; - v15si__let_list = ECL_NIL; - goto L26; -L25:; - { - cl_object v16; - v16 = ecl_cdr(v13si__d); - { - cl_object v17; - v17 = ecl_cdr(v14si__v); - T0 = ecl_car(v13si__d); - T1 = ecl_car(v14si__v); - T2 = cl_list(2, T0, T1); - v15si__let_list = CONS(T2,v15si__let_list); - v14si__v = v17; - v13si__d = v16; - } - } -L26:; - if (v13si__d==ECL_NIL) { goto L32; } - goto L25; -L32:; - T0 = ecl_car(v9); - if (!(ECL_LISTP(v4si___reference))) { goto L37; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L37; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(4, VV[16], v11, v5item, v3); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L36; -L37:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, VV[16], v11, T3); -L36:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v7); - T4 = CONS(VV[15],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); - return value0; - } - } - } - } - } -} -/* local function G74 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11__g74(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} -/* local function PROPER-SEQUENCE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13proper_sequence(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = VV[19]; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for EMPTYP */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L14emptyp(cl_object v1sequence) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LISTP(v1sequence))) { goto L1; } - value0 = ecl_make_bool(v1sequence==ECL_NIL); - cl_env_copy->nvalues = 1; - return value0; -L1:; - if (ECL_CONSP(v1sequence)) { goto L5; } - if (v1sequence==ECL_NIL) { goto L5; } - if (!(ECL_VECTORP(v1sequence))) { goto L3; } - goto L4; -L5:; -L4:; - { - cl_fixnum v2; - v2 = ecl_length(v1sequence); - value0 = ecl_make_bool((v2)==0); - cl_env_copy->nvalues = 1; - return value0; - } -L3:; - value0 = si_etypecase_error(v1sequence, VV[21]); - return value0; - } -} -/* function definition for LENGTH= */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L15length_(cl_narg narg, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - cl_object v1sequences; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1sequences = cl_grab_rest_args(args); - ecl_va_end(args); - if ((ecl_cdr(v1sequences))!=ECL_NIL) { goto L1; } - cl_error(1, VV[23]); -L1:; - { - cl_object v2first; - cl_fixnum v3current; - { - cl_object v4; - v4 = v1sequences; - { - cl_object v5; - v5 = v4; - if (ecl_unlikely(!ECL_LISTP(v5))) FEtype_error_list(v5); - } - if (Null(v4)) { goto L9; } - { - cl_object v5; - v5 = ECL_CONS_CDR(v4); - v1sequences = v5; - v4 = ECL_CONS_CAR(v4); - } -L9:; - v2first = v4; - } - { - cl_object v4; - if (!(ECL_FIXNUMP(v2first)||ECL_BIGNUMP(v2first))) { goto L17; } - v4 = v2first; - goto L16; -L17:; - v4 = ecl_make_fixnum(ecl_length(v2first)); -L16:; - { - cl_fixnum v5; - v5 = 0; - if (!(ECL_FIXNUMP(v4))) { goto L23; } - v5 = ecl_fixnum(v4); - if (!((v5)<(2305843009213693950))) { goto L28; } - T0 = ecl_make_bool((v5)>=(0)); - goto L20; -L28:; - T0 = ECL_NIL; - goto L20; -L23:; - T0 = ECL_NIL; - goto L20; - } -L20:; - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(VV[1],v4); - v3current = ecl_fixnum(v4); - } - { - cl_object v4; - v4 = v1sequences; - goto L33; -L32:; - { - cl_object v5el; - v5el = ecl_car(v4); - if (!(ECL_FIXNUMP(v5el)||ECL_BIGNUMP(v5el))) { goto L38; } - if (ecl_number_equalp(v5el,ecl_make_fixnum(v3current))) { goto L37; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L38:; - if ((L1sequence_of_length_p(v5el, ecl_make_fixnum(v3current)))!=ECL_NIL) { goto L37; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L37:; - } - v4 = ecl_cdr(v4); -L33:; - if (Null(v4)) { goto L44; } - goto L32; -L44:; - } - } - value0 = ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function LENGTH= */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC16length_(cl_object v1, cl_object v2) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4length; - T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } - T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } - v3 = ecl_cddr(v1); - goto L1; -L2:; - v3 = ecl_cdr(v1); -L1:; - if (!(v3==ECL_NIL)) { goto L6; } - si_dm_too_few_arguments(v1); -L6:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4length = v5; - } - { - cl_fixnum v5; - v5 = ecl_length(v3); - if (!((v5)==0)) { goto L11; } - } - value0 = v1; - cl_env_copy->nvalues = 1; - return value0; -L11:; - { - cl_object v5optimizedp; - v5optimizedp = ecl_make_bool(ECL_FIXNUMP(v4length)||ECL_BIGNUMP(v4length)); - { - cl_object v6; - cl_object v7; - v6 = cl_gensym(1, VV[24]); - v7 = cl_gensym(1, VV[25]); - T0 = ecl_list1(v6); - if ((v5optimizedp)!=ECL_NIL) { goto L17; } - T2 = cl_list(2, v7, v4length); - T1 = ecl_list1(T2); - goto L16; -L17:; - T1 = ECL_NIL; -L16:; - T2 = CONS(T0,T1); - if ((v5optimizedp)!=ECL_NIL) { goto L20; } - T4 = cl_list(2, ECL_SYM("INTEGERP",440), v7); - T5 = cl_list(2, ECL_SYM("LENGTH",476), v7); - T6 = cl_list(3, ECL_SYM("SETF",750), v7, T5); - T7 = cl_list(3, ECL_SYM("UNLESS",883), T4, T6); - T3 = ecl_list1(T7); - goto L19; -L20:; - T3 = ECL_NIL; -L19:; - { - cl_object v8sequence; - cl_object v9; - v8sequence = ECL_NIL; - { - cl_object v10; - v10 = v3; - if (ecl_unlikely(!ECL_LISTP(v10))) FEtype_error_list(v10); - v9 = v10; - } - { - cl_object v10; - cl_object v11; - v10 = ecl_list1(ECL_NIL); - v11 = v10; -L29:; - if (!(ecl_endp(v9))) { goto L31; } - goto L30; -L31:; - v8sequence = _ecl_car(v9); - { - cl_object v12; - v12 = _ecl_cdr(v9); - if (ecl_unlikely(!ECL_LISTP(v12))) FEtype_error_list(v12); - v9 = v12; - } - { - cl_object v12; - v12 = v11; - if (ecl_unlikely(ECL_ATOM(v12))) FEtype_error_cons(v12); - T5 = v12; - } - T6 = cl_list(3, ECL_SYM("SETF",750), v6, v8sequence); - T7 = cl_list(2, ECL_SYM("INTEGERP",440), v6); - if (Null(v5optimizedp)) { goto L45; } - T8 = v4length; - goto L44; -L45:; - T8 = v7; -L44:; - T9 = cl_list(3, ECL_SYM("=",74), v6, T8); - if (Null(v5optimizedp)) { goto L48; } - T10 = v4length; - goto L47; -L48:; - T10 = v7; -L47:; - T11 = cl_list(3, VV[0], v6, T10); - T12 = cl_list(4, ECL_SYM("IF",946), T7, T9, T11); - T13 = cl_list(3, ECL_SYM("PROGN",671), T6, T12); - v11 = ecl_list1(T13); - (ECL_CONS_CDR(T5)=v11,T5); - goto L29; -L30:; - T4 = ecl_cdr(v10); - goto L22; - } - } -L22:; - T5 = CONS(ECL_SYM("AND",87),T4); - T6 = ecl_list1(T5); - T7 = ecl_append(T3,T6); - T8 = cl_listX(3, ECL_SYM("LET",477), T2, T7); - value0 = cl_list(3, ECL_SYM("LOCALLY",490), VV[26], T8); - return value0; - } - } - } - } -} -/* function definition for COPY-SEQUENCE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L17copy_sequence(cl_object v1type, cl_object v2sequence) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_typep(2, v2sequence, v1type))) { goto L1; } - value0 = ecl_copy_seq(v2sequence); - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = cl_coerce(v2sequence, v1type); - return value0; - } -} -/* function definition for FIRST-ELT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L18first_elt(cl_object v1sequence) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_CONSP(v1sequence))) { goto L1; } - value0 = ecl_car(v1sequence); - cl_env_copy->nvalues = 1; - return value0; -L1:; - if (!(ECL_VECTORP(v1sequence))) { goto L3; } - { - cl_fixnum v2; - v2 = ecl_length(v1sequence); - if (!((v2)>0)) { goto L3; } - } - value0 = ecl_elt(v1sequence,0); - cl_env_copy->nvalues = 1; - return value0; -L3:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[11]); - return value0; - } -} -/* function definition for (SETF FIRST-ELT) */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L19_setf_first_elt_(cl_object v1object, cl_object v2sequence) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_CONSP(v2sequence))) { goto L1; } - { - cl_object v3; - v3 = v1object; - { - cl_object v4; - v4 = v2sequence; - if (ecl_unlikely(ECL_ATOM(v4))) FEtype_error_cons(v4); - T0 = v4; - } - (ECL_CONS_CAR(T0)=v3,T0); - value0 = v3; - cl_env_copy->nvalues = 1; - return value0; - } -L1:; - if (!(ECL_VECTORP(v2sequence))) { goto L8; } - { - cl_fixnum v4; - v4 = ecl_length(v2sequence); - if (!((v4)>0)) { goto L8; } - } - value0 = ecl_elt_set(v2sequence,0,v1object); - cl_env_copy->nvalues = 1; - return value0; -L8:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v2sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[11]); - return value0; - } -} -/* function definition for LAST-ELT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L20last_elt(cl_object v1sequence) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2len; - v2len = ecl_make_fixnum(0); - if (!(ECL_CONSP(v1sequence))) { goto L2; } - value0 = ecl_function_dispatch(cl_env_copy,VV[65])(1, v1sequence) /* LASTCAR */; - return value0; -L2:; - if (!(ECL_VECTORP(v1sequence))) { goto L4; } - v2len = ecl_make_fixnum(ecl_length(v1sequence)); - if (!((ecl_to_fixnum(v2len))>0)) { goto L4; } - T0 = ecl_one_minus(v2len); - value0 = ecl_elt(v1sequence,ecl_fixnum(T0)); - cl_env_copy->nvalues = 1; - return value0; -L4:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v1sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[31]); - return value0; - } - } -} -/* function definition for (SETF LAST-ELT) */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L21_setf_last_elt_(cl_object v1object, cl_object v2sequence) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3len; - v3len = ecl_make_fixnum(0); - if (!(ECL_CONSP(v2sequence))) { goto L2; } - value0 = (cl_env_copy->function=ecl_fdefinition(VV[67]))->cfun.entry(2, v1object, v2sequence) /* (SETF LASTCAR) */; - return value0; -L2:; - if (!(ECL_VECTORP(v2sequence))) { goto L4; } - v3len = ecl_make_fixnum(ecl_length(v2sequence)); - if (!((ecl_to_fixnum(v3len))>0)) { goto L4; } - T0 = ecl_one_minus(v3len); - value0 = ecl_elt_set(v2sequence,ecl_to_size(T0),v1object); - cl_env_copy->nvalues = 1; - return value0; -L4:; - value0 = cl_error(5, ECL_SYM("TYPE-ERROR",870), ECL_SYM("DATUM",1217), v2sequence, ECL_SYM("EXPECTED-TYPE",1235), VV[31]); - return value0; - } - } -} -/* function definition for STARTS-WITH-SUBSEQ */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L22starts_with_subseq(cl_narg narg, cl_object v1prefix, cl_object v2sequence, ...) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3args; - cl_object v4return_suffix; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L22starts_with_subseqkeys,keyvars,(cl_object*)&v3args,TRUE); - ecl_va_end(args); - v4return_suffix = keyvars[0]; - } - v3args = ecl_function_dispatch(cl_env_copy,VV[69])(2, v3args, VV[34]) /* REMOVE-FROM-PLIST */; - { - cl_fixnum v5; - cl_fixnum v6; - v5 = ecl_length(v2sequence); - v6 = ecl_length(v1prefix); - if (!((v6)<=(v5))) { goto L5; } - { - cl_object v7mismatch; - T0 = (ECL_SYM("MISMATCH",559)->symbol.gfdef); - v7mismatch = cl_apply(4, T0, v1prefix, v2sequence, v3args); - if (Null(v7mismatch)) { goto L9; } - if (!(ecl_number_compare(v7mismatch,ecl_make_fixnum(v6))<0)) { goto L11; } - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = ECL_NIL; - cl_env_copy->values[0] = ECL_NIL; - return cl_env_copy->values[0]; -L11:; - if (Null(v4return_suffix)) { goto L14; } - T1 = cl_array_element_type(v2sequence); - T2 = ecl_minus(ecl_make_fixnum(v5),v7mismatch); - T0 = si_make_pure_array(T1, T2, ECL_NIL, ECL_NIL, v2sequence, ecl_make_fixnum(v6)); - goto L13; -L14:; - T0 = ECL_NIL; -L13:; - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = T0; - cl_env_copy->values[0] = ECL_T; - return cl_env_copy->values[0]; -L9:; - if (Null(v4return_suffix)) { goto L17; } - T1 = cl_array_element_type(v2sequence); - T0 = si_make_vector(T1, ecl_make_fixnum(0), ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - goto L16; -L17:; - T0 = ECL_NIL; -L16:; - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = T0; - cl_env_copy->values[0] = ECL_T; - return cl_env_copy->values[0]; - } -L5:; - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = ECL_NIL; - cl_env_copy->values[0] = ECL_NIL; - return cl_env_copy->values[0]; - } - } -} -/* function definition for ENDS-WITH-SUBSEQ */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L23ends_with_subseq(cl_narg narg, cl_object v1suffix, cl_object v2sequence, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3test; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - { - cl_object keyvars[2]; - cl_parse_key(args,1,L23ends_with_subseqkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[1])) { - v3test = (ECL_SYM("EQL",334)->symbol.gfdef); - } else { - v3test = keyvars[0]; - } - } - { - cl_fixnum v4; - cl_fixnum v5; - v4 = ecl_length(v2sequence); - v5 = ecl_length(v1suffix); - if (!((v4)<(v5))) { goto L4; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L4:; - { - cl_object v6; - cl_object v7sequence_index; - cl_object v8; - v6 = ecl_minus(ecl_make_fixnum(v4),ecl_make_fixnum(v5)); - { - cl_object v9; - v9 = v6; - T0 = cl_realp(v9); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v9); - v7sequence_index = v9; - } - v8 = ecl_make_fixnum(v4); - { - cl_object v9suffix_index; - cl_object v10; - v9suffix_index = ecl_make_fixnum(0); - v10 = ecl_make_fixnum(v5); - if (!(ecl_number_compare(v7sequence_index,v8)>=0)) { goto L15; } - goto L14; -L15:; -L13:; - if (!(ecl_number_compare(v9suffix_index,v10)>=0)) { goto L17; } - goto L14; -L17:; - T0 = ecl_elt(v2sequence,ecl_fixnum(v7sequence_index)); - T1 = ecl_elt(v1suffix,ecl_fixnum(v9suffix_index)); - if ((ecl_function_dispatch(cl_env_copy,v3test)(2, T0, T1))!=ECL_NIL) { goto L19; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L19:; - v7sequence_index = ecl_one_plus(v7sequence_index); - if (!(ecl_number_compare(v7sequence_index,v8)>=0)) { goto L23; } - goto L14; -L23:; - v9suffix_index = ecl_one_plus(v9suffix_index); - goto L13; -L14:; - value0 = ECL_T; - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* function definition for STARTS-WITH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L24starts_with(cl_narg narg, cl_object v1object, cl_object v2sequence, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3test; - cl_object v4key; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L24starts_withkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v3test = (ECL_SYM("EQL",334)->symbol.gfdef); - } else { - v3test = keyvars[0]; - } - if (Null(keyvars[3])) { - v4key = (ECL_SYM("IDENTITY",426)->symbol.gfdef); - } else { - v4key = keyvars[1]; - } - } - if (!(ECL_CONSP(v2sequence))) { goto L5; } - T1 = ecl_car(v2sequence); - goto L4; -L5:; - if (ECL_CONSP(v2sequence)) { goto L9; } - if (v2sequence==ECL_NIL) { goto L9; } - if (!(ECL_VECTORP(v2sequence))) { goto L7; } - goto L8; -L9:; -L8:; - { - cl_fixnum v5; - v5 = ecl_length(v2sequence); - if (!((v5)>0)) { goto L12; } - } - T1 = ecl_elt(v2sequence,0); - goto L4; -L12:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L7:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L4:; - T0 = ecl_function_dispatch(cl_env_copy,v4key)(1, T1); - value0 = ecl_function_dispatch(cl_env_copy,v3test)(2, T0, v1object); - return value0; - } -} -/* function definition for ENDS-WITH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L25ends_with(cl_narg narg, cl_object v1object, cl_object v2sequence, ...) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3test; - cl_object v4key; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - { - cl_object keyvars[4]; - cl_parse_key(args,2,L25ends_withkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[2])) { - v3test = (ECL_SYM("EQL",334)->symbol.gfdef); - } else { - v3test = keyvars[0]; - } - if (Null(keyvars[3])) { - v4key = (ECL_SYM("IDENTITY",426)->symbol.gfdef); - } else { - v4key = keyvars[1]; - } - } - if (!(ECL_CONSP(v2sequence))) { goto L5; } - T1 = ecl_function_dispatch(cl_env_copy,VV[65])(1, v2sequence) /* LASTCAR */; - goto L4; -L5:; - if (ECL_CONSP(v2sequence)) { goto L9; } - if (v2sequence==ECL_NIL) { goto L9; } - if (!(ECL_VECTORP(v2sequence))) { goto L7; } - goto L8; -L9:; -L8:; - { - cl_fixnum v5len; - v5len = ecl_length(v2sequence); - if (!((v5len)>0)) { goto L13; } - T2 = ecl_make_integer((v5len)-1); - T1 = ecl_elt(v2sequence,ecl_fixnum(T2)); - goto L4; -L13:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -L7:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L4:; - T0 = ecl_function_dispatch(cl_env_copy,v4key)(1, T1); - value0 = ecl_function_dispatch(cl_env_copy,v3test)(2, T0, v1object); - return value0; - } -} -/* function definition for MAP-COMBINATIONS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L30map_combinations(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) -{ - cl_object T0; - volatile cl_object lex0[5]; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3start; - cl_object v4end; - cl_object v5length; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - lex0[0] = v2sequence; /* SEQUENCE */ - { - cl_object keyvars[8]; - cl_parse_key(args,4,L30map_combinationskeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[4])) { - v3start = ecl_make_fixnum(0); - } else { - v3start = keyvars[0]; - } - v4end = keyvars[1]; - v5length = keyvars[2]; - if (Null(keyvars[7])) { - lex0[1] = ECL_T; /* COPY */ - } else { - lex0[1] = keyvars[3]; /* COPY */ - } - } - { - cl_object v6size; - cl_object v7length; - value0 = v4end; - if ((value0)!=ECL_NIL) { goto L5; } - T0 = ecl_make_fixnum(ecl_length(lex0[0])); - goto L3; -L5:; - T0 = value0; - goto L3; -L3:; - lex0[2] = T0; /* END */ - v6size = ecl_minus(lex0[2],v3start); - value0 = v5length; - if ((value0)!=ECL_NIL) { goto L10; } - v7length = v6size; - goto L8; -L10:; - v7length = value0; - goto L8; -L8:; - T0 = cl_subseq(3, lex0[0], ecl_make_fixnum(0), v7length); - lex0[3] = T0; /* COMBINATION */ - T0 = ecl_function_dispatch(cl_env_copy,VV[81])(1, v1function) /* ENSURE-FUNCTION */; - lex0[4] = T0; /* FUNCTION */ - if (!(ecl_number_equalp(v7length,v6size))) { goto L12; } - ecl_function_dispatch(cl_env_copy,lex0[4])(1, lex0[3]); - goto L2; -L12:; - if (!(ECL_LISTP(lex0[0]))) { goto L14; } - T0 = ecl_nthcdr(ecl_to_size(v3start),lex0[0]); - LC27combine_list(lex0, lex0[3], T0); - goto L2; -L14:; - if (!(ECL_VECTORP(lex0[0]))) { goto L16; } - LC28combine(lex0, v7length, v3start); - goto L2; -L16:; - if (ECL_CONSP(lex0[0])) { goto L20; } - if (lex0[0]==ECL_NIL) { goto L20; } - if (!(ECL_VECTORP(lex0[0]))) { goto L18; } - goto L19; -L20:; -L19:; - LC29combine(lex0, v7length, v3start); - goto L2; -L18:; - si_etypecase_error(lex0[0], VV[9]); - } -L2:; - value0 = lex0[0]; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function CALL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC26call(volatile cl_object *lex0) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(lex0[1])) { goto L2; } - T0 = ecl_copy_seq(lex0[3]); - goto L1; -L2:; - T0 = lex0[3]; -L1:; - value0 = ecl_function_dispatch(cl_env_copy,lex0[4])(1, T0); - return value0; - } -} -/* local function COMBINE-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC27combine_list(volatile cl_object *lex0, cl_object v1c_tail, cl_object v2o_tail) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if ((v1c_tail)!=ECL_NIL) { goto L1; } - value0 = LC26call(lex0); - return value0; -L1:; - { - cl_object v3tail; - v3tail = v2o_tail; - goto L6; -L5:; - { - cl_object v4; - v4 = ecl_car(v3tail); - { - cl_object v5; - v5 = v1c_tail; - if (ecl_unlikely(ECL_ATOM(v5))) FEtype_error_cons(v5); - T0 = v5; - } - (ECL_CONS_CAR(T0)=v4,T0); - } - T0 = ecl_cdr(v1c_tail); - T1 = ecl_cdr(v3tail); - LC27combine_list(lex0, T0, T1); - v3tail = ecl_cdr(v3tail); -L6:; - if (Null(v3tail)) { goto L17; } - goto L5; -L17:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function COMBINE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC28combine(volatile cl_object *lex0, cl_object v1count, cl_object v2start) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ecl_zerop(v1count))) { goto L1; } - value0 = LC26call(lex0); - return value0; -L1:; - { - cl_object v3i; - cl_object v4; - { - cl_object v5; - v5 = v2start; - T0 = cl_realp(v5); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v5); - v3i = v5; - } - { - cl_object v5; - v5 = lex0[2]; - T0 = cl_realp(v5); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v5); - v4 = v5; - } -L9:; - if (!(ecl_number_compare(v3i,v4)>=0)) { goto L11; } - goto L10; -L11:; - { - cl_object v5j; - v5j = ecl_minus(v1count,ecl_make_fixnum(1)); - { - cl_object v6; - v6 = lex0[3]; - T0 = v6; - { - cl_fixnum v7; - { - cl_object v8; - v8 = v5j; - if (ecl_unlikely((ecl_fixnum(v8))>=(v6)->vector.dim)) - FEwrong_index(ECL_NIL,v6,-1,ecl_make_fixnum(ecl_fixnum(v8)),(v6)->vector.dim); - v7 = ecl_fixnum(v8); - } - T1 = ecl_aref_unsafe(lex0[0],ecl_fixnum(v3i)); - ecl_aset_unsafe(T0,v7,T1); - } - } - T0 = ecl_plus(v3i,ecl_make_fixnum(1)); - LC28combine(lex0, v5j, T0); - } - v3i = ecl_one_plus(v3i); - goto L9; -L10:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function COMBINE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC29combine(volatile cl_object *lex0, cl_object v1count, cl_object v2start) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ecl_zerop(v1count))) { goto L1; } - value0 = LC26call(lex0); - return value0; -L1:; - { - cl_object v3i; - cl_object v4; - { - cl_object v5; - v5 = v2start; - T0 = cl_realp(v5); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v5); - v3i = v5; - } - { - cl_object v5; - v5 = lex0[2]; - T0 = cl_realp(v5); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v5); - v4 = v5; - } -L9:; - if (!(ecl_number_compare(v3i,v4)>=0)) { goto L11; } - goto L10; -L11:; - { - cl_object v5j; - v5j = ecl_minus(v1count,ecl_make_fixnum(1)); - T0 = ecl_elt(lex0[0],ecl_fixnum(v3i)); - ecl_elt_set(lex0[3],ecl_to_size(v5j),T0); - T0 = ecl_plus(v3i,ecl_make_fixnum(1)); - LC29combine(lex0, v5j, T0); - } - v3i = ecl_one_plus(v3i); - goto L9; -L10:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for MAP-PERMUTATIONS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L34map_permutations(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) -{ - cl_object T0; - cl_object env0; - volatile struct ecl_cclosure aux_closure; - cl_object CLV0, CLV1, CLV2, CLV3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3start; - cl_object v4end; - cl_object v5length; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1function,env0); /* FUNCTION */ - { - cl_object keyvars[8]; - cl_parse_key(args,4,L34map_permutationskeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[4])) { - v3start = ecl_make_fixnum(0); - } else { - v3start = keyvars[0]; - } - v4end = keyvars[1]; - v5length = keyvars[2]; - if (Null(keyvars[7])) { - CLV1 = env0 = CONS(ECL_T,env0); /* COPY */ - } else { - CLV1 = env0 = CONS(keyvars[3],env0); /* COPY */ - } - } - { - cl_object v6end; - cl_object v7size; - cl_object env1 = env0; - value0 = v4end; - if ((value0)!=ECL_NIL) { goto L4; } - v6end = ecl_make_fixnum(ecl_length(v2sequence)); - goto L2; -L4:; - v6end = value0; - goto L2; -L2:; - v7size = ecl_minus(v6end,v3start); - value0 = v5length; - if ((value0)!=ECL_NIL) { goto L9; } - T0 = v7size; - goto L7; -L9:; - T0 = value0; - goto L7; -L7:; - CLV2 = env1 = CONS(T0,env1); /* LENGTH */ - if (!(ecl_number_equalp(ECL_CONS_CAR(CLV2),v7size))) { goto L11; } - T0 = cl_subseq(3, v2sequence, v3start, v6end); - value0 = (aux_closure.env=env1,cl_env_copy->function=(cl_object)&aux_closure,LC32permute_sequence(1, T0)); - return value0; -L11:; - { - cl_object env2 = env1; - T0 = cl_subseq(3, v2sequence, ecl_make_fixnum(0), ECL_CONS_CAR(CLV2)); - CLV3 = env2 = CONS(T0,env2); /* PERMUTATION */ - { - cl_object v8; - v8 = ecl_make_cclosure_va((cl_objectfn)LC33permute_combination,env2,Cblock); - value0 = L30map_combinations(10, v8, v2sequence, ECL_SYM("START",1315), v3start, ECL_SYM("END",1228), v6end, ECL_SYM("LENGTH",1268), ECL_CONS_CAR(CLV2), VV[40], ECL_NIL); - return value0; - } - } - } - } -} -/* closure PERMUTE-SEQUENCE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC32permute_sequence(cl_narg narg, cl_object v1seq, ...) -{ - volatile struct ecl_cclosure aux_closure; - cl_object CLV0, CLV1, CLV2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV2 = env0; /* LENGTH */ - CLV1 = _ecl_cdr(CLV2); - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC31permute(2, v1seq, ECL_CONS_CAR(CLV2))); - return value0; - } - } -} -/* closure PERMUTE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC31permute(cl_narg narg, cl_object v1seq, cl_object v2n, ...) -{ - cl_object T0; - volatile struct ecl_cclosure aux_closure; - cl_object CLV0, CLV1, CLV2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV2 = env0; - CLV1 = _ecl_cdr(CLV2); /* COPY */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - { - cl_object v3n_1; - v3n_1 = ecl_minus(v2n,ecl_make_fixnum(1)); - if (!(ecl_zerop(v3n_1))) { goto L2; } - if (Null(ECL_CONS_CAR(CLV1))) { goto L5; } - T0 = ecl_copy_seq(v1seq); - goto L4; -L5:; - T0 = v1seq; -L4:; - value0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(1, T0); - return value0; -L2:; - { - cl_object v4i; - cl_object v5; - v4i = ecl_make_fixnum(0); - { - cl_object v6; - v6 = v3n_1; - T0 = cl_realp(v6); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v6); - v5 = v6; - } -L11:; - if (!(ecl_number_compare(v4i,v5)>0)) { goto L13; } - goto L12; -L13:; - (aux_closure.env=env0,cl_env_copy->function=(cl_object)&aux_closure,LC31permute(2, v1seq, v3n_1)); - if (!(ecl_evenp(v3n_1))) { goto L17; } - { - cl_object v6; - v6 = ecl_elt(v1seq,ecl_fixnum(v3n_1)); - { - cl_object v7; - v7 = ecl_elt(v1seq,0); - ecl_elt_set(v1seq,0,v6); - ecl_elt_set(v1seq,ecl_to_size(v3n_1),v7); - } - } - goto L15; -L17:; - { - cl_object v6; - v6 = ecl_elt(v1seq,ecl_fixnum(v3n_1)); - { - cl_object v7; - v7 = ecl_elt(v1seq,ecl_fixnum(v4i)); - ecl_elt_set(v1seq,ecl_to_size(v4i),v6); - ecl_elt_set(v1seq,ecl_to_size(v3n_1),v7); - } - } -L15:; - v4i = ecl_one_plus(v4i); - goto L11; -L12:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* closure PERMUTE-COMBINATION */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC33permute_combination(cl_narg narg, cl_object v1combination, ...) -{ - cl_object T0; - volatile struct ecl_cclosure aux_closure; - cl_object CLV0, CLV1, CLV2, CLV3; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV3 = env0; /* PERMUTATION */ - CLV2 = _ecl_cdr(CLV3); - CLV1 = _ecl_cdr(CLV2); - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = cl_replace(2, ECL_CONS_CAR(CLV3), v1combination); - value0 = (aux_closure.env=ecl_nthcdr(1,env0),cl_env_copy->function=(cl_object)&aux_closure,LC32permute_sequence(1, T0)); - return value0; - } - } -} -/* function definition for MAP-DERANGEMENTS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L36map_derangements(cl_narg narg, cl_object v1function, cl_object v2sequence, ...) -{ - cl_object T0, T1; - volatile cl_object lex0[7]; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3end; - ecl_va_list args; ecl_va_start(args,v2sequence,narg,2); - lex0[0] = v1function; /* FUNCTION */ - lex0[1] = v2sequence; /* SEQUENCE */ - { - cl_object keyvars[6]; - cl_parse_key(args,3,L36map_derangementskeys,keyvars,NULL,FALSE); - ecl_va_end(args); - if (Null(keyvars[3])) { - lex0[2] = ecl_make_fixnum(0); /* START */ - } else { - lex0[2] = keyvars[0]; /* START */ - } - v3end = keyvars[1]; - if (Null(keyvars[5])) { - lex0[3] = ECL_T; /* COPY */ - } else { - lex0[3] = keyvars[2]; /* COPY */ - } - } - { - cl_object v4end; - value0 = v3end; - if ((value0)!=ECL_NIL) { goto L3; } - v4end = ecl_make_fixnum(ecl_length(lex0[1])); - goto L1; -L3:; - v4end = value0; - goto L1; -L1:; - T0 = ecl_minus(v4end,lex0[2]); - lex0[4] = T0; /* SIZE */ - T0 = cl_subseq(3, lex0[1], ecl_make_fixnum(0), lex0[4]); - lex0[5] = T0; /* DERANGEMENT */ - T0 = si_make_pure_array(ECL_SYM("BIT",123), lex0[4], ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - T1 = si_fill_array_with_elt(T0, ecl_make_fixnum(0), ecl_make_fixnum(0), ECL_NIL); - lex0[6] = T1; /* MASK */ - LC35derange(lex0, lex0[2], lex0[4]); - value0 = lex0[1]; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function DERANGE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC35derange(volatile cl_object *lex0, cl_object v1place, cl_object v2n) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ecl_zerop(v2n))) { goto L1; } - if (Null(lex0[3])) { goto L4; } - T0 = ecl_copy_seq(lex0[5]); - goto L3; -L4:; - T0 = lex0[5]; -L3:; - value0 = ecl_function_dispatch(cl_env_copy,lex0[0])(1, T0); - return value0; -L1:; - { - cl_object v3i; - cl_object v4; - v3i = ecl_make_fixnum(0); - { - cl_object v5; - v5 = lex0[4]; - T0 = cl_realp(v5); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v5); - v4 = v5; - } -L10:; - if (!(ecl_number_compare(v3i,v4)>=0)) { goto L12; } - goto L11; -L12:; - T0 = ecl_plus(v3i,lex0[2]); - if (ecl_number_equalp(v1place,T0)) { goto L14; } - T0 = cl_bit(2, lex0[6], v3i); - if (!((ecl_to_fixnum(T0))==0)) { goto L14; } - T0 = ecl_elt(lex0[1],ecl_fixnum(v1place)); - ecl_elt_set(lex0[5],ecl_to_size(v3i),T0); - { - cl_object v5; - v5 = lex0[6]; - T0 = v5; - { - cl_fixnum v6; - { - cl_object v7; - v7 = v3i; - if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) - FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); - v6 = ecl_fixnum(v7); - } - ecl_aset_unsafe(T0,v6,ecl_make_fixnum(1)); - } - } - T0 = ecl_one_plus(v1place); - T1 = ecl_one_minus(v2n); - LC35derange(lex0, T0, T1); - { - cl_object v5; - v5 = lex0[6]; - T0 = v5; - { - cl_fixnum v6; - { - cl_object v7; - v7 = v3i; - if (ecl_unlikely((ecl_fixnum(v7))>=(v5)->vector.dim)) - FEwrong_index(ECL_NIL,v5,-1,ecl_make_fixnum(ecl_fixnum(v7)),(v5)->vector.dim); - v6 = ecl_fixnum(v7); - } - ecl_aset_unsafe(T0,v6,ecl_make_fixnum(0)); - } - } -L14:; - v3i = ecl_one_plus(v3i); - goto L10; -L11:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function G181 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC38__g181() -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC37__g182,ECL_NIL,Cblock,2); - value0 = v1; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* local function G182 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC37__g182(cl_object v1condition, cl_object v2stream) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - value0 = cl_format(3, v2stream, VV[43], VV[44]); - return value0; - } -} -/* function definition for EXTREMUM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L41extremum(cl_narg narg, cl_object v1sequence, cl_object v2predicate, ...) -{ - cl_object T0, T1; - cl_object env0; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3key; - cl_object v4start; - cl_object v5end; - ecl_va_list args; ecl_va_start(args,v2predicate,narg,2); - { - cl_object keyvars[6]; - cl_parse_key(args,3,L41extremumkeys,keyvars,NULL,FALSE); - ecl_va_end(args); - v3key = keyvars[0]; - if (Null(keyvars[4])) { - v4start = ecl_make_fixnum(0); - } else { - v4start = keyvars[1]; - } - v5end = keyvars[2]; - } - { - cl_object v6real_end; - cl_object env1 = env0; - T0 = ecl_function_dispatch(cl_env_copy,VV[81])(1, v2predicate) /* ENSURE-FUNCTION */; - env1 = ECL_NIL; - CLV0 = env1 = CONS(T0,env1); /* PRED-FUN */ - if (Null(v3key)) { goto L3; } - if ((v3key)==(ECL_SYM("IDENTITY",426))) { goto L3; } - T1 = (ECL_SYM("IDENTITY",426)->symbol.gfdef); - if ((v3key)==(T1)) { goto L3; } - T0 = ecl_function_dispatch(cl_env_copy,VV[81])(1, v3key) /* ENSURE-FUNCTION */; - goto L2; -L3:; - T0 = ECL_NIL; -L2:; - CLV1 = env1 = CONS(T0,env1); /* KEY-FUN */ - value0 = v5end; - if ((value0)!=ECL_NIL) { goto L10; } - v6real_end = ecl_make_fixnum(ecl_length(v1sequence)); - goto L8; -L10:; - v6real_end = value0; - goto L8; -L8:; - if (!(ecl_number_compare(v6real_end,v4start)>0)) { goto L12; } - if (Null(ECL_CONS_CAR(CLV1))) { goto L14; } - { - cl_object v7; - v7 = ecl_make_cclosure_va((cl_objectfn)LC39reduce_keys,env1,Cblock); - value0 = cl_reduce(6, v7, v1sequence, ECL_SYM("START",1315), v4start, ECL_SYM("END",1228), v6real_end); - return value0; - } -L14:; - { - cl_object v8; - v8 = ecl_make_cclosure_va((cl_objectfn)LC40reduce_elts,env1,Cblock); - value0 = cl_reduce(6, v8, v1sequence, ECL_SYM("START",1315), v4start, ECL_SYM("END",1228), v6real_end); - return value0; - } -L12:; - if (!(ecl_number_equalp(v6real_end,v4start))) { goto L16; } - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; -L16:; - { - cl_fixnum v9; - v9 = ecl_length(v1sequence); - value0 = cl_error(6, VV[45], ecl_make_fixnum(v9), ECL_SYM("START",1315), v4start, ECL_SYM("END",1228), v5end); - return value0; - } - } - } -} -/* closure REDUCE-KEYS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC39reduce_keys(cl_narg narg, cl_object v1a, cl_object v2b, ...) -{ - cl_object T0, T1; - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; /* KEY-FUN */ - CLV0 = _ecl_cdr(CLV1); - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - T0 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v1a); - T1 = ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV1))(1, v2b); - if (Null(ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, T0, T1))) { goto L1; } - value0 = v1a; - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = v2b; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure REDUCE-ELTS */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC40reduce_elts(cl_narg narg, cl_object v1a, cl_object v2b, ...) -{ - cl_object CLV0, CLV1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV1 = env0; - CLV0 = _ecl_cdr(CLV1); /* PRED-FUN */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=2)) FEwrong_num_arguments_anonym(); - { -TTL: - if (Null(ecl_function_dispatch(cl_env_copy,ECL_CONS_CAR(CLV0))(2, v1a, v2b))) { goto L1; } - value0 = v1a; - cl_env_copy->nvalues = 1; - return value0; -L1:; - value0 = v2b; - cl_env_copy->nvalues = 1; - return value0; - } - } -} - -#include "lib/alexandria/sequences.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecl4y48pVyvO59HM_R0i2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/sequences.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecl4y48pVyvO59HM_R0i2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[46]); /* SEQUENCE-OF-LENGTH-P */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[47]); /* ROTATE-TAIL-TO-HEAD */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[9], VVtemp[10]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[49]); /* ROTATE-HEAD-TO-TAIL */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[11], VVtemp[12]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[13]) /* ANNOTATE */; - ecl_cmp_defun(VV[50]); /* ROTATE */ - si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[14]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[15], VVtemp[16]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[17]) /* ANNOTATE */; - ecl_cmp_defun(VV[51]); /* SHUFFLE */ - si_set_documentation(3, VV[7], ECL_SYM("FUNCTION",396), VVtemp[18]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LOCATION",1777), VVtemp[19], VVtemp[20]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[10], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[17]) /* ANNOTATE */; - ecl_cmp_defun(VV[54]); /* RANDOM-ELT */ - si_set_documentation(3, VV[10], ECL_SYM("FUNCTION",396), VVtemp[21]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[22]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LOCATION",1777), VVtemp[23], VVtemp[24]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[13], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defun(VV[55]); /* REMOVE/SWAPPED-ARGUMENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[26], VVtemp[27]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[56]); /* REMOVEF */ - si_set_documentation(3, VV[14], ECL_SYM("FUNCTION",396), VVtemp[29]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[30]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[32]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[25]) /* ANNOTATE */; - ecl_cmp_defun(VV[57]); /* DELETE/SWAPPED-ARGUMENTS */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[33], VVtemp[34]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[28]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[58]); /* DELETEF */ - si_set_documentation(3, VV[17], ECL_SYM("FUNCTION",396), VVtemp[35]); - { - cl_object T0; - si_set_documentation(3, VV[18], ECL_SYM("TYPE",869), VVtemp[36]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC13proper_sequence,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[18], VVtemp[37], T0); - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LOCATION",1777), VVtemp[38], VVtemp[39]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[20], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; - ecl_cmp_defun(VV[59]); /* EMPTYP */ - si_set_documentation(3, VV[20], ECL_SYM("FUNCTION",396), VVtemp[41]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[43]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[44]) /* ANNOTATE */; - ecl_cmp_defun(VV[60]); /* LENGTH= */ - si_set_documentation(3, VV[22], ECL_SYM("FUNCTION",396), VVtemp[45]); - { - cl_object T0; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC16length_,ECL_NIL,Cblock,2); - T0 = v1; - } - si_put_sysprop(VV[22], ECL_SYM("COMPILER-MACRO",238), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[22], ECL_SYM("LOCATION",1777), VVtemp[46], VVtemp[47]) /* ANNOTATE */; - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LOCATION",1777), VVtemp[48], VVtemp[49]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[27], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[50]) /* ANNOTATE */; - ecl_cmp_defun(VV[61]); /* COPY-SEQUENCE */ - si_set_documentation(3, VV[27], ECL_SYM("FUNCTION",396), VVtemp[51]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[53]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[28], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; - ecl_cmp_defun(VV[62]); /* FIRST-ELT */ - si_set_documentation(3, VV[28], ECL_SYM("FUNCTION",396), VVtemp[54]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[55], ECL_SYM("LOCATION",1777), VVtemp[56], VVtemp[57]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[55], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; - ecl_cmp_defun(VV[63]); /* (SETF FIRST-ELT) */ - si_set_documentation(3, VV[29], ECL_SYM("FUNCTION",396), VVtemp[59]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[30], ECL_SYM("LOCATION",1777), VVtemp[60], VVtemp[61]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[30], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[40]) /* ANNOTATE */; - ecl_cmp_defun(VV[64]); /* LAST-ELT */ - si_set_documentation(3, VV[30], ECL_SYM("FUNCTION",396), VVtemp[62]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[63], ECL_SYM("LOCATION",1777), VVtemp[64], VVtemp[65]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VVtemp[63], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[58]) /* ANNOTATE */; - ecl_cmp_defun(VV[66]); /* (SETF LAST-ELT) */ - si_set_documentation(3, VV[32], ECL_SYM("FUNCTION",396), VVtemp[66]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LOCATION",1777), VVtemp[67], VVtemp[68]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[69]) /* ANNOTATE */; - ecl_cmp_defun(VV[68]); /* STARTS-WITH-SUBSEQ */ - si_set_documentation(3, VV[33], ECL_SYM("FUNCTION",396), VVtemp[70]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LOCATION",1777), VVtemp[71], VVtemp[72]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[35], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[73]) /* ANNOTATE */; - ecl_cmp_defun(VV[70]); /* ENDS-WITH-SUBSEQ */ - si_set_documentation(3, VV[35], ECL_SYM("FUNCTION",396), VVtemp[74]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[36], ECL_SYM("LOCATION",1777), VVtemp[75], VVtemp[76]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[36], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[77]) /* ANNOTATE */; - ecl_cmp_defun(VV[72]); /* STARTS-WITH */ - si_set_documentation(3, VV[36], ECL_SYM("FUNCTION",396), VVtemp[78]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LOCATION",1777), VVtemp[79], VVtemp[80]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[37], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[77]) /* ANNOTATE */; - ecl_cmp_defun(VV[75]); /* ENDS-WITH */ - si_set_documentation(3, VV[37], ECL_SYM("FUNCTION",396), VVtemp[81]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[38], ECL_SYM("LOCATION",1777), VVtemp[82], VVtemp[83]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[38], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[84]) /* ANNOTATE */; - ecl_cmp_defun(VV[76]); /* MAP-COMBINATIONS */ - si_set_documentation(3, VV[38], ECL_SYM("FUNCTION",396), VVtemp[85]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LOCATION",1777), VVtemp[86], VVtemp[87]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[39], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[84]) /* ANNOTATE */; - ecl_cmp_defun(VV[82]); /* MAP-PERMUTATIONS */ - si_set_documentation(3, VV[39], ECL_SYM("FUNCTION",396), VVtemp[88]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[89], VVtemp[90]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[91]) /* ANNOTATE */; - ecl_cmp_defun(VV[83]); /* MAP-DERANGEMENTS */ - si_set_documentation(3, VV[41], ECL_SYM("FUNCTION",396), VVtemp[92]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[93]) /* MAPC */; - { - cl_object T0, T1, T2; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LOCATION",1777), VVtemp[94], VVtemp[95]) /* ANNOTATE */; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC38__g181,ECL_NIL,Cblock,0); - T0 = v1; - } - T1 = cl_listX(3, ECL_SYM("INITFUNCTION",997), T0, VVtemp[97]); - T2 = ecl_list1(T1); - clos_load_defclass(VV[42], VVtemp[96], T2, ECL_NIL); - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LOCATION",1777), VVtemp[98], VVtemp[99]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[44], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[100]) /* ANNOTATE */; - ecl_cmp_defun(VV[87]); /* EXTREMUM */ - si_set_documentation(3, VV[44], ECL_SYM("FUNCTION",396), VVtemp[101]); -} diff --git a/lib/alexandria/strings.cxx b/lib/alexandria/strings.cxx deleted file mode 100644 index b314996..0000000 --- a/lib/alexandria/strings.cxx +++ /dev/null @@ -1,63 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/strings.lisp */ -#include -#include "lib/alexandria/strings.eclh" -/* local function STRING-DESIGNATOR */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1string_designator(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = VV[1]; - cl_env_copy->nvalues = 1; - return value0; - } -} - -#include "lib/alexandria/strings.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclOk91d7g9HuD9M_m9g2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/strings.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclOk91d7g9HuD9M_m9g2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - { - cl_object T0; - si_set_documentation(3, VV[0], ECL_SYM("TYPE",869), VVtemp[1]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC1string_designator,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[0], VVtemp[2], T0); - } -} diff --git a/lib/alexandria/symbols.cxx b/lib/alexandria/symbols.cxx deleted file mode 100644 index 5476529..0000000 --- a/lib/alexandria/symbols.cxx +++ /dev/null @@ -1,342 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/symbols.lisp */ -#include -#include "lib/alexandria/symbols.eclh" -/* function definition for ENSURE-SYMBOL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L1ensure_symbol(cl_narg narg, cl_object v1name, ...) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); - { - cl_object v2package; - va_list args; va_start(args,v1name); - { - int i = 1; - if (i >= narg) { - v2package = ecl_symbol_value(ECL_SYM("*PACKAGE*",43)); - } else { - i++; - v2package = va_arg(args,cl_object); - } - } - va_end(args); - T0 = cl_string(v1name); - value0 = cl_intern(2, T0, v2package); - return value0; - } -} -/* function definition for MAYBE-INTERN */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L2maybe_intern(cl_object v1name, cl_object v2package) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v2package)) { goto L2; } - if (!((ECL_T)==(v2package))) { goto L5; } - T0 = ecl_symbol_value(ECL_SYM("*PACKAGE*",43)); - goto L4; -L5:; - T0 = v2package; -L4:; - value0 = cl_intern(2, v1name, T0); - goto L1; -L2:; - value0 = cl_make_symbol(v1name); -L1:; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for FORMAT-SYMBOL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L3format_symbol(cl_narg narg, cl_object v1package, cl_object v2control, ...) -{ - cl_object T0, T1, T2; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<2)) FEwrong_num_arguments_anonym(); - { - cl_object v3arguments; - ecl_va_list args; ecl_va_start(args,v2control,narg,2); - v3arguments = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v4; - v4 = ecl_symbol_value(ECL_SYM("+IO-SYNTAX-PROGV-LIST+",1732)); - { - cl_object v6, v7; cl_index v5; - v6 = _ecl_car(v4); - v7 = _ecl_cdr(v4); - v5 = ecl_progv(cl_env_copy, v6, v7); - T1 = (ECL_SYM("FORMAT",387)->symbol.gfdef); - T2 = cl_string(v2control); - T0 = cl_apply(4, T1, ECL_NIL, T2, v3arguments); - ecl_bds_unwind(cl_env_copy,v5); - } - } - value0 = L2maybe_intern(T0, v1package); - return value0; - } -} -/* function definition for MAKE-KEYWORD */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L4make_keyword(cl_object v1name) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_string(v1name); - value0 = cl_intern(2, T0, VV[4]); - return value0; - } -} -/* function definition for MAKE-GENSYM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L5make_gensym(cl_object v1name) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - v2 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v1name)||ECL_BIGNUMP(v1name))) { goto L2; } - v2 = v1name; - if (!(ecl_number_compare(v2,ecl_make_fixnum(0))>=0)) { goto L2; } - } - T0 = v1name; - goto L1; -L2:; - T0 = cl_string(v1name); -L1:; - value0 = cl_gensym(1, T0); - return value0; - } -} -/* function definition for MAKE-GENSYM-LIST */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L6make_gensym_list(cl_narg narg, cl_object v1length, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - if (ecl_unlikely(narg<1)) FEwrong_num_arguments_anonym(); - if (ecl_unlikely(narg>2)) FEwrong_num_arguments_anonym(); - { - cl_object v2x; - va_list args; va_start(args,v1length); - { - int i = 1; - if (i >= narg) { - v2x = VV[7]; - } else { - i++; - v2x = va_arg(args,cl_object); - } - } - va_end(args); - { - cl_object v3g; - { - cl_object v4; - v4 = ecl_make_fixnum(0); - if (!(ECL_FIXNUMP(v2x)||ECL_BIGNUMP(v2x))) { goto L3; } - v4 = v2x; - if (!(ecl_number_compare(v4,ecl_make_fixnum(0))>=0)) { goto L3; } - } - v3g = v2x; - goto L2; -L3:; - v3g = cl_string(v2x); -L2:; - { - cl_object v4; - { - cl_object v5; - v5 = v1length; - T0 = cl_realp(v5); - if (ecl_unlikely(!((T0)!=ECL_NIL))) - FEwrong_type_argument(ECL_SYM("REAL",703),v5); - v4 = v5; - } - { - cl_object v5; - cl_object v6; - v5 = ecl_list1(ECL_NIL); - v6 = v5; -L14:; - v4 = ecl_minus(v4,ecl_make_fixnum(1)); - T0 = v4; - if (!(ecl_minusp(T0))) { goto L16; } - goto L15; -L16:; - { - cl_object v7; - v7 = v6; - if (ecl_unlikely(ECL_ATOM(v7))) FEtype_error_cons(v7); - T0 = v7; - } - T1 = cl_gensym(1, v3g); - v6 = ecl_list1(T1); - (ECL_CONS_CDR(T0)=v6,T0); - goto L14; -L15:; - value0 = ecl_cdr(v5); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* function definition for SYMBOLICATE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L8symbolicate(cl_narg narg, ...) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - cl_object v1things; - ecl_va_list args; ecl_va_start(args,narg,narg,0); - v1things = cl_grab_rest_args(args); - ecl_va_end(args); - { - cl_object v2length; - cl_object v3name; - T0 = (ECL_SYM("+",14)->symbol.gfdef); - { - cl_object v4; - v4 = ecl_make_cfun((cl_objectfn_fixed)LC7__g15,ECL_NIL,Cblock,1); - T1 = v4; - } - v2length = cl_reduce(4, T0, v1things, ECL_SYM("KEY",1267), T1); - v3name = si_make_pure_array(ECL_SYM("CHARACTER",222), v2length, ECL_NIL, ECL_NIL, ECL_NIL, ecl_make_fixnum(0)); - { - cl_object v4index; - v4index = ecl_make_fixnum(0); - { - cl_object v5; - v5 = v1things; - goto L9; -L8:; - { - cl_object v6thing; - v6thing = ecl_car(v5); - { - cl_object v7x; - cl_fixnum v8len; - v7x = cl_string(v6thing); - v8len = ecl_length(v7x); - cl_replace(4, v3name, v7x, ECL_SYM("START1",1316), v4index); - v4index = ecl_plus(v4index,ecl_make_fixnum(v8len)); - } - } - v5 = ecl_cdr(v5); -L9:; - if (Null(v5)) { goto L20; } - goto L8; -L20:; - value0 = cl_intern(1, v3name); - cl_env_copy->nvalues = 1; - return value0; - } - } - } - } -} -/* local function G15 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC7__g15(cl_object v1x) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_string(v1x); - value0 = ecl_make_fixnum(ecl_length(T0)); - cl_env_copy->nvalues = 1; - return value0; - } -} - -#include "lib/alexandria/symbols.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _ecljVTgFlYFBNMEM_6gg2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/symbols.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_ecljVTgFlYFBNMEM_6gg2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[1]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LOCATION",1777), VVtemp[2], VVtemp[3]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[0], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[4]) /* ANNOTATE */; - ecl_cmp_defun(VV[9]); /* ENSURE-SYMBOL */ - si_set_documentation(3, VV[0], ECL_SYM("FUNCTION",396), VVtemp[5]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LOCATION",1777), VVtemp[6], VVtemp[7]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[1], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[8]) /* ANNOTATE */; - ecl_cmp_defun(VV[10]); /* MAYBE-INTERN */ - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[9]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LOCATION",1777), VVtemp[10], VVtemp[11]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[2], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[12]) /* ANNOTATE */; - ecl_cmp_defun(VV[11]); /* FORMAT-SYMBOL */ - si_set_documentation(3, VV[2], ECL_SYM("FUNCTION",396), VVtemp[13]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[3], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[12]); /* MAKE-KEYWORD */ - si_set_documentation(3, VV[3], ECL_SYM("FUNCTION",396), VVtemp[17]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[19]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[5], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[13]); /* MAKE-GENSYM */ - si_set_documentation(3, VV[5], ECL_SYM("FUNCTION",396), VVtemp[20]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[21], VVtemp[22]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[23]) /* ANNOTATE */; - ecl_cmp_defun(VV[14]); /* MAKE-GENSYM-LIST */ - si_set_documentation(3, VV[6], ECL_SYM("FUNCTION",396), VVtemp[24]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[25], VVtemp[26]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[27]) /* ANNOTATE */; - ecl_cmp_defun(VV[15]); /* SYMBOLICATE */ - si_set_documentation(3, VV[8], ECL_SYM("FUNCTION",396), VVtemp[28]); -} diff --git a/lib/alexandria/types.cxx b/lib/alexandria/types.cxx deleted file mode 100644 index 8e239bd..0000000 --- a/lib/alexandria/types.cxx +++ /dev/null @@ -1,2048 +0,0 @@ -/* Compiler: ECL 16.1.2 */ -/* Date: 2024/7/24 08:12 (yyyy/mm/dd) */ -/* Machine: Linux 6.9.7-arch1-1 x86_64 */ -/* Source: lib/alexandria/types.lisp */ -#include -#include "lib/alexandria/types.eclh" -/* local function ARRAY-INDEX */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC1array_index(cl_object v1) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - cl_object v3length; - v2 = v1; - if (Null(v2)) { goto L3; } - { - cl_object v4; - v4 = ecl_car(v2); - v2 = ecl_cdr(v2); - v3length = v4; - goto L2; - } -L3:; - v3length = ecl_make_fixnum(2305843009213693950); -L2:; - if (Null(v2)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - T0 = ecl_list1(v3length); - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), T0); - return value0; - } - } -} -/* local function ARRAY-LENGTH */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC2array_length(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v2; - cl_object v3length; - v2 = v1; - if (Null(v2)) { goto L3; } - { - cl_object v4; - v4 = ecl_car(v2); - v2 = ecl_cdr(v2); - v3length = v4; - goto L2; - } -L3:; - v3length = ecl_make_fixnum(2305843009213693950); -L2:; - if (Null(v2)) { goto L8; } - si_dm_too_many_arguments(v1); -L8:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), v3length); - return value0; - } - } -} -/* local function NEGATIVE-FIXNUM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC3negative_fixnum(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(-1)); - return value0; - } -} -/* local function NON-POSITIVE-FIXNUM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC4non_positive_fixnum(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(-2305843009213693952), ecl_make_fixnum(0)); - return value0; - } -} -/* local function NON-NEGATIVE-FIXNUM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC5non_negative_fixnum(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), ecl_make_fixnum(2305843009213693951)); - return value0; - } -} -/* local function POSITIVE-FIXNUM */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC6positive_fixnum(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(1), ecl_make_fixnum(2305843009213693951)); - return value0; - } -} -/* function definition for NEGATIVE-FIXNUM-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L7negative_fixnum_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-FIXNUM-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L8non_positive_fixnum_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-FIXNUM-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L9non_negative_fixnum_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-FIXNUM-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L10positive_fixnum_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-INTEGER */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC11negative_integer(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ECL_SYM("*",18), ecl_make_fixnum(-1)); - return value0; - } -} -/* local function NON-POSITIVE-INTEGER */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC12non_positive_integer(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ECL_SYM("*",18), ecl_make_fixnum(0)); - return value0; - } -} -/* local function NON-NEGATIVE-INTEGER */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC13non_negative_integer(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(0), ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-INTEGER */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC14positive_integer(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("INTEGER",437), ecl_make_fixnum(1), ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-INTEGER-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L15negative_integer_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-INTEGER-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L16non_positive_integer_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-INTEGER-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L17non_negative_integer_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-INTEGER-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L18positive_integer_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_FIXNUMP(v1n)||ECL_BIGNUMP(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-RATIONAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC19negative_rational(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",687), ECL_SYM("*",18), VV[19]); - return value0; - } -} -/* local function NON-POSITIVE-RATIONAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC20non_positive_rational(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",687), ECL_SYM("*",18), ecl_make_fixnum(0)); - return value0; - } -} -/* local function NON-NEGATIVE-RATIONAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC21non_negative_rational(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",687), ecl_make_fixnum(0), ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-RATIONAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC22positive_rational(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("RATIONAL",687), VV[19], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-RATIONAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L23negative_rational_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-RATIONAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L24non_positive_rational_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-RATIONAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L25non_negative_rational_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-RATIONAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L26positive_rational_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_rationalp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-REAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC27negative_real(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("REAL",703), ECL_SYM("*",18), VV[19]); - return value0; - } -} -/* local function NON-POSITIVE-REAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC28non_positive_real(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("REAL",703), ECL_SYM("*",18), ecl_make_fixnum(0)); - return value0; - } -} -/* local function NON-NEGATIVE-REAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC29non_negative_real(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("REAL",703), ecl_make_fixnum(0), ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-REAL */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC30positive_real(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("REAL",703), VV[19], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-REAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L31negative_real_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-REAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L32non_positive_real_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,ecl_make_fixnum(0))<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-REAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L33non_negative_real_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-REAL-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L34positive_real_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(cl_realp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(ecl_make_fixnum(0),v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC35negative_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",374), ECL_SYM("*",18), VV[36]); - return value0; - } -} -/* local function NON-POSITIVE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC36non_positive_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",374), ECL_SYM("*",18), cl_core.singlefloat_zero); - return value0; - } -} -/* local function NON-NEGATIVE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC37non_negative_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",374), cl_core.singlefloat_zero, ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC38positive_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("FLOAT",374), VV[36], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L39negative_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L40non_positive_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L41non_negative_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L42positive_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(floatp(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-SHORT-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC43negative_short_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), ECL_SYM("*",18), VV[36]); - return value0; - } -} -/* local function NON-POSITIVE-SHORT-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC44non_positive_short_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), ECL_SYM("*",18), cl_core.singlefloat_zero); - return value0; - } -} -/* local function NON-NEGATIVE-SHORT-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC45non_negative_short_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), cl_core.singlefloat_zero, ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-SHORT-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC46positive_short_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SHORT-FLOAT",756), VV[36], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-SHORT-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L47negative_short_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-SHORT-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L48non_positive_short_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-SHORT-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L49non_negative_short_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-SHORT-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L50positive_short_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-SINGLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC51negative_single_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), ECL_SYM("*",18), VV[36]); - return value0; - } -} -/* local function NON-POSITIVE-SINGLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC52non_positive_single_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), ECL_SYM("*",18), cl_core.singlefloat_zero); - return value0; - } -} -/* local function NON-NEGATIVE-SINGLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC53non_negative_single_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), cl_core.singlefloat_zero, ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-SINGLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC54positive_single_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("SINGLE-FLOAT",778), VV[36], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-SINGLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L55negative_single_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-SINGLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L56non_positive_single_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.singlefloat_zero)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-SINGLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L57non_negative_single_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-SINGLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L58positive_single_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_SINGLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.singlefloat_zero,v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-DOUBLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC59negative_double_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), ECL_SYM("*",18), VV[61]); - return value0; - } -} -/* local function NON-POSITIVE-DOUBLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC60non_positive_double_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), ECL_SYM("*",18), cl_core.doublefloat_zero); - return value0; - } -} -/* local function NON-NEGATIVE-DOUBLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC61non_negative_double_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), cl_core.doublefloat_zero, ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-DOUBLE-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC62positive_double_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("DOUBLE-FLOAT",315), VV[61], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-DOUBLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L63negative_double_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.doublefloat_zero)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-DOUBLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L64non_positive_double_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.doublefloat_zero)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-DOUBLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L65non_negative_double_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.doublefloat_zero,v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-DOUBLE-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L66positive_double_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_DOUBLE_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.doublefloat_zero,v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* local function NEGATIVE-LONG-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC67negative_long_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), ECL_SYM("*",18), VV[70]); - return value0; - } -} -/* local function NON-POSITIVE-LONG-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC68non_positive_long_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), ECL_SYM("*",18), cl_core.longfloat_zero); - return value0; - } -} -/* local function NON-NEGATIVE-LONG-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC69non_negative_long_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), cl_core.longfloat_zero, ECL_SYM("*",18)); - return value0; - } -} -/* local function POSITIVE-LONG-FLOAT */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC70positive_long_float(cl_object v1) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (Null(v1)) { goto L1; } - si_dm_too_many_arguments(v1); -L1:; - value0 = cl_list(3, ECL_SYM("LONG-FLOAT",508), VV[70], ECL_SYM("*",18)); - return value0; - } -} -/* function definition for NEGATIVE-LONG-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L71negative_long_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.longfloat_zero)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-POSITIVE-LONG-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L72non_positive_long_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(v1n,cl_core.longfloat_zero)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for NON-NEGATIVE-LONG-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L73non_negative_long_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.longfloat_zero,v1n)<=0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for POSITIVE-LONG-FLOAT-P */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L74positive_long_float_p(cl_object v1n) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - if (!(ECL_LONG_FLOAT_P(v1n))) { goto L2; } - value0 = ecl_make_bool(ecl_number_compare(cl_core.longfloat_zero,v1n)<0); - cl_env_copy->nvalues = 1; - return value0; -L2:; - value0 = ECL_NIL; - cl_env_copy->nvalues = 1; - return value0; - } -} -/* function definition for OF-TYPE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L76of_type(cl_object v1type) -{ - cl_object env0; - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { - env0 = ECL_NIL; - CLV0 = env0 = CONS(v1type,env0); /* TYPE */ - { - cl_object v2; - v2 = ecl_make_cclosure_va((cl_objectfn)LC75__g105,env0,Cblock); - value0 = v2; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* closure G105 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC75__g105(cl_narg narg, cl_object v1thing, ...) -{ - cl_object CLV0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object env0 = cl_env_copy->function->cclosure.env; - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - /* Scanning closure data ... */ - CLV0 = env0; /* TYPE */ - { /* ... closure scanning finished */ - if (ecl_unlikely(narg!=1)) FEwrong_num_arguments_anonym(); - { -TTL: - value0 = cl_typep(2, v1thing, ECL_CONS_CAR(CLV0)); - return value0; - } - } -} -/* local function OF-TYPE */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC77of_type(cl_object v1, cl_object v2env) -{ - cl_object T0, T1; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4type; - T0 = ecl_car(v1); - if (!((T0)==(ECL_SYM("FUNCALL",394)))) { goto L2; } - T0 = ecl_caadr(v1); - if (!((T0)==(ECL_SYM("FUNCTION",396)))) { goto L2; } - v3 = ecl_cddr(v1); - goto L1; -L2:; - v3 = ecl_cdr(v1); -L1:; - if (!(v3==ECL_NIL)) { goto L6; } - si_dm_too_few_arguments(v1); -L6:; - { - cl_object v5; - v5 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4type = v5; - } - if (Null(v3)) { goto L11; } - si_dm_too_many_arguments(v1); -L11:; - if (Null(cl_constantp(2, v4type, v2env))) { goto L13; } - { - cl_object v5thing; - v5thing = cl_gensym(1, VV[79]); - T0 = ecl_list1(v5thing); - T1 = cl_list(3, ECL_SYM("TYPEP",875), v5thing, v4type); - value0 = cl_list(3, ECL_SYM("LAMBDA",452), T0, T1); - return value0; - } -L13:; - value0 = v1; - cl_env_copy->nvalues = 1; - return value0; - } - } -} -/* function definition for TYPE= */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object L78type_(cl_object v1type1, cl_object v2type2) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v4; /* SUB */ - cl_object v5; /* OK */ - value0 = cl_subtypep(2, v1type1, v2type2); - v4 = value0; - v5 = cl_env_copy->values[1]; - if (Null(v5)) { goto L2; } - if (Null(v4)) { goto L2; } - value0 = cl_subtypep(2, v2type2, v1type1); - return value0; -L2:; - if (Null(v5)) { goto L5; } - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = v5; - cl_env_copy->values[0] = ECL_NIL; - return cl_env_copy->values[0]; -L5:; - { - cl_object v7; /* OK */ - value0 = cl_subtypep(2, v2type2, v1type1); - v7 = cl_env_copy->values[1]; - cl_env_copy->nvalues = 2; - cl_env_copy->values[1] = v7; - cl_env_copy->values[0] = ECL_NIL; - return cl_env_copy->values[0]; - } - } - } -} -/* local function COERCEF */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC80coercef(cl_object v1, cl_object v2si__env) -{ - cl_object T0, T1, T2, T3, T4, T5, T6, T7, T8; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - { - cl_object v3; - cl_object v4si___reference; - cl_object v5type_spec; - v3 = ecl_cdr(v1); - if (!(v3==ECL_NIL)) { goto L3; } - si_dm_too_few_arguments(v1); -L3:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v4si___reference = v6; - } - if (!(v3==ECL_NIL)) { goto L9; } - si_dm_too_few_arguments(v1); -L9:; - { - cl_object v6; - v6 = ecl_car(v3); - v3 = ecl_cdr(v3); - v5type_spec = v6; - } - if (Null(v3)) { goto L14; } - si_dm_too_many_arguments(v1); -L14:; - { - cl_object v7; /* VARS */ - cl_object v8; /* VALS */ - cl_object v9; /* STORES */ - cl_object v10; /* SETTER */ - cl_object v11; /* GETTER */ - value0 = (cl_env_copy->function=(ECL_SYM("GET-SETF-EXPANSION",410)->symbol.gfdef))->cfun.entry(2, v4si___reference, v2si__env) /* GET-SETF-EXPANSION */; - v7 = value0; - v8 = cl_env_copy->values[1]; - v9 = cl_env_copy->values[2]; - v10 = cl_env_copy->values[3]; - v11 = cl_env_copy->values[4]; - { - cl_object v12si__all_vars; - { - cl_object v13; - v13 = ecl_make_cfun((cl_objectfn_fixed)LC79__g115,ECL_NIL,Cblock,1); - T0 = v13; - } - T1 = CONS(v5type_spec,ECL_NIL); - v12si__all_vars = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, T1) /* MAPCAR */; - if (!(ECL_SYMBOLP(v11))) { goto L19; } - T0 = (ECL_SYM("CAR",180)->symbol.gfdef); - T1 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T0, v12si__all_vars) /* MAPCAR */; - T2 = cl_listX(3, ECL_SYM("COERCE",231), v11, T1); - T3 = ecl_car(v9); - T4 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T5 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T4, v12si__all_vars) /* MAPCAR */; - T6 = CONS(VV[82],T5); - T7 = cl_list(2, ECL_SYM("DECLARE",274), T6); - T8 = cl_list(4, ECL_SYM("LET*",478), v12si__all_vars, T7, v10); - value0 = cl_subst(3, T2, T3, T8); - return value0; -L19:; - { - cl_object v13si__d; - cl_object v14si__v; - cl_object v15si__let_list; - v13si__d = v7; - v14si__v = v8; - v15si__let_list = ECL_NIL; - goto L28; -L27:; - { - cl_object v16; - v16 = ecl_cdr(v13si__d); - { - cl_object v17; - v17 = ecl_cdr(v14si__v); - T0 = ecl_car(v13si__d); - T1 = ecl_car(v14si__v); - T2 = cl_list(2, T0, T1); - v15si__let_list = CONS(T2,v15si__let_list); - v14si__v = v17; - v13si__d = v16; - } - } -L28:; - if (v13si__d==ECL_NIL) { goto L34; } - goto L27; -L34:; - T0 = ecl_car(v9); - if (!(ECL_LISTP(v4si___reference))) { goto L39; } - T2 = ecl_car(v4si___reference); - if (!((T2)==(ECL_SYM("THE",856)))) { goto L39; } - T2 = ecl_cadr(v4si___reference); - T3 = cl_listX(4, ECL_SYM("COERCE",231), v11, v5type_spec, ECL_NIL); - T1 = cl_list(3, ECL_SYM("THE",856), T2, T3); - goto L38; -L39:; - T2 = (ECL_SYM("CAR",180)->symbol.gfdef); - T3 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T2, v12si__all_vars) /* MAPCAR */; - T1 = cl_listX(3, ECL_SYM("COERCE",231), v11, T3); -L38:; - T2 = cl_list(2, T0, T1); - T3 = ecl_append(v12si__all_vars,v15si__let_list); - v15si__let_list = CONS(T2,T3); - T0 = cl_nreverse(v15si__let_list); - T1 = (ECL_SYM("FIRST",371)->symbol.gfdef); - T2 = (cl_env_copy->function=(ECL_SYM("MAPCAR",545)->symbol.gfdef))->cfun.entry(2, T1, v12si__all_vars) /* MAPCAR */; - T3 = ecl_append(T2,v7); - T4 = CONS(VV[82],T3); - T5 = cl_list(2, ECL_SYM("DECLARE",274), T4); - value0 = cl_list(4, ECL_SYM("LET*",478), T0, T5, v10); - return value0; - } - } - } - } - } -} -/* local function G115 */ -/* optimize speed 3, debug 0, space 0, safety 2 */ -static cl_object LC79__g115(cl_object v1si__v) -{ - cl_object T0; - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - ecl_cs_check(cl_env_copy,value0); - { -TTL: - T0 = cl_gensym(0); - value0 = cl_list(2, T0, v1si__v); - return value0; - } -} - -#include "lib/alexandria/types.data" -#ifdef __cplusplus -extern "C" -#endif -ECL_DLLEXPORT void _eclYKIWc8zWYNLAM_kSh2dC71(cl_object flag) -{ - const cl_env_ptr cl_env_copy = ecl_process_env(); - cl_object value0; - cl_object *VVtemp; - if (flag != OBJNULL){ - Cblock = flag; - #ifndef ECL_DYNAMIC_VV - flag->cblock.data = VV; - #endif - flag->cblock.data_size = VM; - flag->cblock.temp_data_size = VMtemp; - flag->cblock.data_text = compiler_data_text; - flag->cblock.cfuns_size = compiler_cfuns_size; - flag->cblock.cfuns = compiler_cfuns; - flag->cblock.source = make_constant_base_string("/home/packer/ws/github/kisp/asgl/lib/alexandria/types.lisp"); - return;} - #ifdef ECL_DYNAMIC_VV - VV = Cblock->cblock.data; - #endif - Cblock->cblock.data_text = (const cl_object *)"@EcLtAg:_eclYKIWc8zWYNLAM_kSh2dC71@"; - VVtemp = Cblock->cblock.temp_data; - ECL_DEFINE_SETF_FUNCTIONS - si_select_package(VVtemp[0]); - { - cl_object T0; - si_set_documentation(3, VV[0], ECL_SYM("TYPE",869), VVtemp[1]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC1array_index,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[0], VVtemp[2], T0); - } - { - cl_object T0; - si_set_documentation(3, VV[1], ECL_SYM("TYPE",869), VVtemp[3]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC2array_length,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[1], VVtemp[4], T0); - } - { - cl_object T0; - si_set_documentation(3, VV[2], ECL_SYM("TYPE",869), VVtemp[5]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC3negative_fixnum,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[2], VVtemp[6], T0); - si_set_documentation(3, VV[3], ECL_SYM("TYPE",869), VVtemp[7]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC4non_positive_fixnum,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[3], VVtemp[8], T0); - si_set_documentation(3, VV[4], ECL_SYM("TYPE",869), VVtemp[9]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC5non_negative_fixnum,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[4], VVtemp[10], T0); - si_set_documentation(3, VV[5], ECL_SYM("TYPE",869), VVtemp[11]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC6positive_fixnum,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[5], VVtemp[12], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[13]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LOCATION",1777), VVtemp[14], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[6], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[83]); /* NEGATIVE-FIXNUM-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LOCATION",1777), VVtemp[17], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[7], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[84]); /* NON-POSITIVE-FIXNUM-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LOCATION",1777), VVtemp[18], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[8], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[85]); /* NON-NEGATIVE-FIXNUM-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LOCATION",1777), VVtemp[19], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[9], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[86]); /* POSITIVE-FIXNUM-P */ - si_set_documentation(3, VV[10], ECL_SYM("TYPE",869), VVtemp[20]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC11negative_integer,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[10], VVtemp[21], T0); - si_set_documentation(3, VV[11], ECL_SYM("TYPE",869), VVtemp[22]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC12non_positive_integer,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[11], VVtemp[23], T0); - si_set_documentation(3, VV[12], ECL_SYM("TYPE",869), VVtemp[24]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC13non_negative_integer,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[12], VVtemp[25], T0); - si_set_documentation(3, VV[13], ECL_SYM("TYPE",869), VVtemp[26]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC14positive_integer,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[13], VVtemp[27], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[28]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LOCATION",1777), VVtemp[29], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[14], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[87]); /* NEGATIVE-INTEGER-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LOCATION",1777), VVtemp[30], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[15], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[88]); /* NON-POSITIVE-INTEGER-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LOCATION",1777), VVtemp[31], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[16], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[89]); /* NON-NEGATIVE-INTEGER-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LOCATION",1777), VVtemp[32], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[17], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[90]); /* POSITIVE-INTEGER-P */ - si_set_documentation(3, VV[18], ECL_SYM("TYPE",869), VVtemp[33]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC19negative_rational,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[18], VVtemp[34], T0); - si_set_documentation(3, VV[20], ECL_SYM("TYPE",869), VVtemp[33]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC20non_positive_rational,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[20], VVtemp[35], T0); - si_set_documentation(3, VV[21], ECL_SYM("TYPE",869), VVtemp[36]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC21non_negative_rational,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[21], VVtemp[37], T0); - si_set_documentation(3, VV[22], ECL_SYM("TYPE",869), VVtemp[36]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC22positive_rational,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[22], VVtemp[38], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[39]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LOCATION",1777), VVtemp[40], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[23], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[91]); /* NEGATIVE-RATIONAL-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LOCATION",1777), VVtemp[41], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[24], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[92]); /* NON-POSITIVE-RATIONAL-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LOCATION",1777), VVtemp[42], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[25], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[93]); /* NON-NEGATIVE-RATIONAL-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LOCATION",1777), VVtemp[43], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[26], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[94]); /* POSITIVE-RATIONAL-P */ - si_set_documentation(3, VV[27], ECL_SYM("TYPE",869), VVtemp[44]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC27negative_real,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[27], VVtemp[45], T0); - si_set_documentation(3, VV[28], ECL_SYM("TYPE",869), VVtemp[44]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC28non_positive_real,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[28], VVtemp[46], T0); - si_set_documentation(3, VV[29], ECL_SYM("TYPE",869), VVtemp[47]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC29non_negative_real,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[29], VVtemp[48], T0); - si_set_documentation(3, VV[30], ECL_SYM("TYPE",869), VVtemp[47]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC30positive_real,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[30], VVtemp[49], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[50]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LOCATION",1777), VVtemp[51], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[31], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[95]); /* NEGATIVE-REAL-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LOCATION",1777), VVtemp[52], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[32], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[96]); /* NON-POSITIVE-REAL-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LOCATION",1777), VVtemp[53], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[33], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[97]); /* NON-NEGATIVE-REAL-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LOCATION",1777), VVtemp[54], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[34], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[98]); /* POSITIVE-REAL-P */ - si_set_documentation(3, VV[35], ECL_SYM("TYPE",869), VVtemp[55]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC35negative_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[35], VVtemp[56], T0); - si_set_documentation(3, VV[37], ECL_SYM("TYPE",869), VVtemp[55]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC36non_positive_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[37], VVtemp[57], T0); - si_set_documentation(3, VV[38], ECL_SYM("TYPE",869), VVtemp[58]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC37non_negative_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[38], VVtemp[59], T0); - si_set_documentation(3, VV[39], ECL_SYM("TYPE",869), VVtemp[58]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC38positive_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[39], VVtemp[60], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[61]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LOCATION",1777), VVtemp[62], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[40], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[99]); /* NEGATIVE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LOCATION",1777), VVtemp[63], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[41], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[100]); /* NON-POSITIVE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LOCATION",1777), VVtemp[64], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[42], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[101]); /* NON-NEGATIVE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[43], ECL_SYM("LOCATION",1777), VVtemp[65], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[43], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[102]); /* POSITIVE-FLOAT-P */ - si_set_documentation(3, VV[44], ECL_SYM("TYPE",869), VVtemp[66]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC43negative_short_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[44], VVtemp[67], T0); - si_set_documentation(3, VV[45], ECL_SYM("TYPE",869), VVtemp[66]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC44non_positive_short_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[45], VVtemp[68], T0); - si_set_documentation(3, VV[46], ECL_SYM("TYPE",869), VVtemp[69]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC45non_negative_short_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[46], VVtemp[70], T0); - si_set_documentation(3, VV[47], ECL_SYM("TYPE",869), VVtemp[69]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC46positive_short_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[47], VVtemp[71], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[72]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LOCATION",1777), VVtemp[73], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[48], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[103]); /* NEGATIVE-SHORT-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LOCATION",1777), VVtemp[74], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[49], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[104]); /* NON-POSITIVE-SHORT-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LOCATION",1777), VVtemp[75], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[50], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[105]); /* NON-NEGATIVE-SHORT-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LOCATION",1777), VVtemp[76], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[51], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[106]); /* POSITIVE-SHORT-FLOAT-P */ - si_set_documentation(3, VV[52], ECL_SYM("TYPE",869), VVtemp[77]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC51negative_single_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[52], VVtemp[78], T0); - si_set_documentation(3, VV[53], ECL_SYM("TYPE",869), VVtemp[77]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC52non_positive_single_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[53], VVtemp[79], T0); - si_set_documentation(3, VV[54], ECL_SYM("TYPE",869), VVtemp[80]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC53non_negative_single_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[54], VVtemp[81], T0); - si_set_documentation(3, VV[55], ECL_SYM("TYPE",869), VVtemp[80]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC54positive_single_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[55], VVtemp[82], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[83]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[56], ECL_SYM("LOCATION",1777), VVtemp[84], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[56], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[107]); /* NEGATIVE-SINGLE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[57], ECL_SYM("LOCATION",1777), VVtemp[85], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[57], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[108]); /* NON-POSITIVE-SINGLE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[58], ECL_SYM("LOCATION",1777), VVtemp[86], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[58], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[109]); /* NON-NEGATIVE-SINGLE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[59], ECL_SYM("LOCATION",1777), VVtemp[87], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[59], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[110]); /* POSITIVE-SINGLE-FLOAT-P */ - si_set_documentation(3, VV[60], ECL_SYM("TYPE",869), VVtemp[88]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC59negative_double_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[60], VVtemp[89], T0); - si_set_documentation(3, VV[62], ECL_SYM("TYPE",869), VVtemp[88]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC60non_positive_double_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[62], VVtemp[90], T0); - si_set_documentation(3, VV[63], ECL_SYM("TYPE",869), VVtemp[91]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC61non_negative_double_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[63], VVtemp[92], T0); - si_set_documentation(3, VV[64], ECL_SYM("TYPE",869), VVtemp[91]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC62positive_double_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[64], VVtemp[93], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[94]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[65], ECL_SYM("LOCATION",1777), VVtemp[95], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[65], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[111]); /* NEGATIVE-DOUBLE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[66], ECL_SYM("LOCATION",1777), VVtemp[96], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[66], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[112]); /* NON-POSITIVE-DOUBLE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[67], ECL_SYM("LOCATION",1777), VVtemp[97], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[67], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[113]); /* NON-NEGATIVE-DOUBLE-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[68], ECL_SYM("LOCATION",1777), VVtemp[98], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[68], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[114]); /* POSITIVE-DOUBLE-FLOAT-P */ - si_set_documentation(3, VV[69], ECL_SYM("TYPE",869), VVtemp[99]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC67negative_long_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[69], VVtemp[100], T0); - si_set_documentation(3, VV[71], ECL_SYM("TYPE",869), VVtemp[99]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC68non_positive_long_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[71], VVtemp[101], T0); - si_set_documentation(3, VV[72], ECL_SYM("TYPE",869), VVtemp[102]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC69non_negative_long_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[72], VVtemp[103], T0); - si_set_documentation(3, VV[73], ECL_SYM("TYPE",869), VVtemp[102]); - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC70positive_long_float,ECL_NIL,Cblock,1); - T0 = v1; - } - si_do_deftype(3, VV[73], VVtemp[104], T0); - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[105]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[74], ECL_SYM("LOCATION",1777), VVtemp[106], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[74], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[115]); /* NEGATIVE-LONG-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[75], ECL_SYM("LOCATION",1777), VVtemp[107], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[75], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[116]); /* NON-POSITIVE-LONG-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[76], ECL_SYM("LOCATION",1777), VVtemp[108], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[76], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[117]); /* NON-NEGATIVE-LONG-FLOAT-P */ - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[77], ECL_SYM("LOCATION",1777), VVtemp[109], VVtemp[15]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[77], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[16]) /* ANNOTATE */; - ecl_cmp_defun(VV[118]); /* POSITIVE-LONG-FLOAT-P */ - } - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[78], ECL_SYM("LOCATION",1777), VVtemp[110], VVtemp[111]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[78], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[112]) /* ANNOTATE */; - ecl_cmp_defun(VV[119]); /* OF-TYPE */ - si_set_documentation(3, VV[78], ECL_SYM("FUNCTION",396), VVtemp[113]); - { - cl_object T0; - { - cl_object volatile v1; - v1 = ecl_make_cfun((cl_objectfn_fixed)LC77of_type,ECL_NIL,Cblock,2); - T0 = v1; - } - si_put_sysprop(VV[78], ECL_SYM("COMPILER-MACRO",238), T0); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[78], ECL_SYM("LOCATION",1777), VVtemp[114], VVtemp[115]) /* ANNOTATE */; - } - (cl_env_copy->function=(ECL_SYM("MAPC",543)->symbol.gfdef))->cfun.entry(2, ECL_SYM("PROCLAIM",666), VVtemp[116]) /* MAPC */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[80], ECL_SYM("LOCATION",1777), VVtemp[117], VVtemp[118]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[80], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[119]) /* ANNOTATE */; - ecl_cmp_defun(VV[120]); /* TYPE= */ - si_set_documentation(3, VV[80], ECL_SYM("FUNCTION",396), VVtemp[120]); - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[81], ECL_SYM("LOCATION",1777), VVtemp[121], VVtemp[122]) /* ANNOTATE */; - ecl_function_dispatch(cl_env_copy,ECL_SYM("ANNOTATE",1771))(4, VV[81], ECL_SYM("LAMBDA-LIST",998), ECL_NIL, VVtemp[123]) /* ANNOTATE */; - ecl_cmp_defmacro(VV[121]); /* COERCEF */ - si_set_documentation(3, VV[81], ECL_SYM("FUNCTION",396), VVtemp[124]); -} From 47f0fa5264a399c60a7043e21aced7455f508863 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:16:33 +0200 Subject: [PATCH 34/57] .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index e94452f..5d97109 100644 --- a/.gitignore +++ b/.gitignore @@ -4,6 +4,7 @@ lisp-scripts/compile-file-system-p.lisp tmp bin/asgl gecode +*.cxx *.o gr1/gr1 gr1/gr1.c From 4ed1c48fef27739b87fc2615bf21abeeea3e28ef Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:19:07 +0200 Subject: [PATCH 35/57] shell.nix --- shell.nix | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/shell.nix b/shell.nix index ececd02..0d6535b 100644 --- a/shell.nix +++ b/shell.nix @@ -5,6 +5,9 @@ let ecl_cpp = pkgs.callPackage ./ecl-cpp.nix { }; + pkgsForGecode = import (builtins.fetchTarball { + url = "https://github.com/NixOS/nixpkgs/archive/515b06ef2ae59b9813b3606888e1791ede8f9090.tar.gz"; + }) { }; in @@ -14,7 +17,7 @@ pkgs.mkShell { pkgs.autoconf pkgs.gmp ecl_cpp - pkgs.gecode + pkgsForGecode.gecode pkgs.ragel ]; shellHook = '' From c35fc684d40af2c6c434539e3be103f2be913d55 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:20:24 +0200 Subject: [PATCH 36/57] wip --- steps.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/steps.sh b/steps.sh index 9cfc2a7..d3d536d 100644 --- a/steps.sh +++ b/steps.sh @@ -5,7 +5,7 @@ echo hello autoconf configure.ac > configure chmod +x configure -./configure +./configure --without-gist ./scripts/generate-make-mk.sh From ec796a4a955291c5275327e3c217752dd9fe875a Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:22:57 +0200 Subject: [PATCH 37/57] wip --- steps.sh | 2 ++ 1 file changed, 2 insertions(+) diff --git a/steps.sh b/steps.sh index d3d536d..1a2b5ec 100644 --- a/steps.sh +++ b/steps.sh @@ -10,3 +10,5 @@ chmod +x configure ./scripts/generate-make-mk.sh make + +./bin/asgl From 3a086a69e35b697b172d1bbfd210878422a805ad Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:46:15 +0200 Subject: [PATCH 38/57] wip --- shell.nix | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/shell.nix b/shell.nix index 0d6535b..645a530 100644 --- a/shell.nix +++ b/shell.nix @@ -15,7 +15,7 @@ pkgs.mkShell { buildInputs = [ pkgs.which pkgs.autoconf - pkgs.gmp + # pkgs.gmp ecl_cpp pkgsForGecode.gecode pkgs.ragel From b6289419436acff5a9143953b09586d2ceab429a Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:47:43 +0200 Subject: [PATCH 39/57] shell.nix --- shell.nix | 1 - 1 file changed, 1 deletion(-) diff --git a/shell.nix b/shell.nix index 645a530..635c8c7 100644 --- a/shell.nix +++ b/shell.nix @@ -15,7 +15,6 @@ pkgs.mkShell { buildInputs = [ pkgs.which pkgs.autoconf - # pkgs.gmp ecl_cpp pkgsForGecode.gecode pkgs.ragel From 814548cd7870052776b99fe321658e11b07fbdf4 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:50:46 +0200 Subject: [PATCH 40/57] nix-build.sh --- nix-build.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nix-build.sh b/nix-build.sh index 29311eb..dce628b 100755 --- a/nix-build.sh +++ b/nix-build.sh @@ -4,7 +4,7 @@ set -euxo pipefail git add . -git commit -m wip || true +# git commit -m wip || true git clean -fxd From e4cdcf593de6da355fe4b5d98ab70f4f65ac9dfc Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 07:59:08 +0200 Subject: [PATCH 41/57] nix-build.sh --- nix-build.sh | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/nix-build.sh b/nix-build.sh index dce628b..2fe54ac 100755 --- a/nix-build.sh +++ b/nix-build.sh @@ -2,8 +2,7 @@ set -euxo pipefail -git add . - +# git add . # git commit -m wip || true git clean -fxd From 3ff2bae11533b73866caaad89843a28358ab2c6b Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 08:25:18 +0200 Subject: [PATCH 42/57] ch --- gecode.nix | 48 ++++++++++++++++++++++++++++++++++++++++++++++++ shell.nix | 8 ++------ 2 files changed, 50 insertions(+), 6 deletions(-) create mode 100644 gecode.nix diff --git a/gecode.nix b/gecode.nix new file mode 100644 index 0000000..a3c8eec --- /dev/null +++ b/gecode.nix @@ -0,0 +1,48 @@ +{ + lib, + stdenv, + fetchurl, + fetchpatch, + perl, +}: + +stdenv.mkDerivation rec { + pname = "gecode"; + version = "4.3.3"; + + src = fetchurl { + url = "https://github.com/Gecode/gecode/archive/refs/tags/release-${version}.tar.gz"; + sha256 = "sha256-EOmQqEtfBH/J4w7wtcFhrVuU7F0NWJO9Qfn4b0QHZaw="; + }; + + patches = [ + # (import ./fix-const-weights-clang-patch.nix fetchpatch) + ]; + + postPatch = '' + substituteInPlace gecode/flatzinc/lexer.yy.cpp \ + --replace "register " "" + ''; + + nativeBuildInputs = [ perl ]; + + preConfigure = "patchShebangs configure"; + + configureFlags = [ + "--disable-gist" + "--disable-qt" + "--disable-examples" + "--disable-flatzinc" + "--disable-float-vars" + ]; + + env.CXXFLAGS = lib.optionalString stdenv.cc.isClang "-std=c++14"; + + meta = with lib; { + license = licenses.mit; + homepage = "https://www.gecode.org"; + description = "Toolkit for developing constraint-based systems"; + platforms = platforms.all; + maintainers = [ maintainers.manveru ]; + }; +} diff --git a/shell.nix b/shell.nix index 635c8c7..2743cf7 100644 --- a/shell.nix +++ b/shell.nix @@ -3,12 +3,8 @@ }: let - ecl_cpp = pkgs.callPackage ./ecl-cpp.nix { }; - pkgsForGecode = import (builtins.fetchTarball { - url = "https://github.com/NixOS/nixpkgs/archive/515b06ef2ae59b9813b3606888e1791ede8f9090.tar.gz"; - }) { }; - + gecode = pkgs.callPackage ./gecode.nix { }; in pkgs.mkShell { @@ -16,7 +12,7 @@ pkgs.mkShell { pkgs.which pkgs.autoconf ecl_cpp - pkgsForGecode.gecode + gecode pkgs.ragel ]; shellHook = '' From 00e07f33e6f8fd14fbf3ccbdff8edde7208cbe91 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 08:39:16 +0200 Subject: [PATCH 43/57] gemset.nix --- gemset.nix | 117 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 gemset.nix diff --git a/gemset.nix b/gemset.nix new file mode 100644 index 0000000..738180f --- /dev/null +++ b/gemset.nix @@ -0,0 +1,117 @@ +{ + aruba = { + dependencies = ["childprocess" "cucumber" "rspec-expectations"]; + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "0hlq03shd7cl72n7nark8dm5gdrsjpcqkxd2qrkcjzd35nkqqlbw"; + type = "gem"; + }; + version = "0.6.2"; + }; + builder = { + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "14fii7ab8qszrvsvhz6z2z3i4dw0h41a62fjr2h1j8m41vbrmyv2"; + type = "gem"; + }; + version = "3.2.2"; + }; + childprocess = { + dependencies = ["ffi"]; + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "0cxzh17vjlmpqfcas4815x50dc1gzfwgbs51zzpd4chrl6ak4n4v"; + type = "gem"; + }; + version = "0.5.5"; + }; + cucumber = { + dependencies = ["builder" "diff-lcs" "gherkin" "multi_json" "multi_test"]; + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "170a0yclrc1i9m5wjgwzga3ipb5mbapiha8jcg0g2gjnmzvd77nr"; + type = "gem"; + }; + version = "1.3.19"; + }; + diff-lcs = { + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "1vf9civd41bnqi6brr5d9jifdw73j9khc6fkhfl1f8r9cpkdvlx1"; + type = "gem"; + }; + version = "1.2.5"; + }; + ffi = { + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "0ph098bv92rn5wl6rn2hwb4ng24v4187sz8pa0bpi9jfh50im879"; + type = "gem"; + }; + version = "1.9.8"; + }; + gherkin = { + dependencies = ["multi_json"]; + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "1mxfgw15pii1jmq00xxbyp77v71mh3bp99ndgwzfwkxvbcisha25"; + type = "gem"; + }; + version = "2.12.2"; + }; + multi_json = { + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "1mg3hp17ch8bkf3ndj40s50yjs0vrqbfh3aq5r02jkpjkh23wgxl"; + type = "gem"; + }; + version = "1.11.0"; + }; + multi_test = { + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "1sx356q81plr67hg16jfwz9hcqvnk03bd9n75pmdw8pfxjfy1yxd"; + type = "gem"; + }; + version = "0.1.2"; + }; + rspec-expectations = { + dependencies = ["diff-lcs" "rspec-support"]; + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "08ba5hprb3kf849yylkxm9dd9lfazh7gapiqxy5lapwqxbqpa3ky"; + type = "gem"; + }; + version = "3.2.0"; + }; + rspec-support = { + groups = ["default"]; + platforms = []; + source = { + remotes = ["https://rubygems.org"]; + sha256 = "194zry5195ls2hni7r9824vqb5d3qfg4jb15fgj8glfy0rvw3zxl"; + type = "gem"; + }; + version = "3.2.2"; + }; +} From 5ca401a56d2161f9fff3a8f28e1f266ff160726c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 08:46:13 +0200 Subject: [PATCH 44/57] shell.nix --- shell.nix | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/shell.nix b/shell.nix index 2743cf7..2a387ff 100644 --- a/shell.nix +++ b/shell.nix @@ -5,6 +5,11 @@ let ecl_cpp = pkgs.callPackage ./ecl-cpp.nix { }; gecode = pkgs.callPackage ./gecode.nix { }; + cucumber-aruba-from-gemfile = pkgs.bundlerEnv { + name = "cucumber-aruba-for-asgl"; + inherit (pkgs.ruby); + gemdir = ./.; + }; in pkgs.mkShell { @@ -14,6 +19,8 @@ pkgs.mkShell { ecl_cpp gecode pkgs.ragel + cucumber-aruba-from-gemfile + pkgs.ruby ]; shellHook = '' echo "Welcome to the development environment!" From 99a5938d8bbf05e201f61ebd3083a98632df9c72 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 08:50:57 +0200 Subject: [PATCH 45/57] ch --- nix-build.sh | 2 +- nix-test.sh | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) create mode 100755 nix-test.sh diff --git a/nix-build.sh b/nix-build.sh index 2fe54ac..f90b6a3 100755 --- a/nix-build.sh +++ b/nix-build.sh @@ -8,4 +8,4 @@ set -euxo pipefail git clean -fxd nix-shell \ - --pure --run 'bash steps.sh' + --pure --run 'bash steps.sh' diff --git a/nix-test.sh b/nix-test.sh new file mode 100755 index 0000000..3cc748f --- /dev/null +++ b/nix-test.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +set -euxo pipefail + +nix-shell \ + --pure --run 'cucumber features/syntax.feature' From 7d81649dedbc61bfde32959a291a5359cf2df8d5 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 08:52:15 +0200 Subject: [PATCH 46/57] shell.nix --- shell.nix | 3 +++ 1 file changed, 3 insertions(+) diff --git a/shell.nix b/shell.nix index 2a387ff..0ccda03 100644 --- a/shell.nix +++ b/shell.nix @@ -15,12 +15,15 @@ in pkgs.mkShell { buildInputs = [ pkgs.which + # For building pkgs.autoconf ecl_cpp gecode pkgs.ragel + # For tests cucumber-aruba-from-gemfile pkgs.ruby + pkgs.perl ]; shellHook = '' echo "Welcome to the development environment!" From 5ecba0b4bcf2b354cffc7eb097bfad460cf2b519 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 08:58:45 +0200 Subject: [PATCH 47/57] nix-test.sh --- nix-test.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/nix-test.sh b/nix-test.sh index 3cc748f..d3b879e 100755 --- a/nix-test.sh +++ b/nix-test.sh @@ -2,5 +2,7 @@ set -euxo pipefail +make data/iccma15_solutions data/iccma15_testcases + nix-shell \ - --pure --run 'cucumber features/syntax.feature' + --pure --run cucumber From 60e3b8da9a99943343a930824e8eff89fc5bc520 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Wed, 24 Jul 2024 11:33:38 +0200 Subject: [PATCH 48/57] nix-test.sh --- nix-test.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/nix-test.sh b/nix-test.sh index d3b879e..92f41d3 100755 --- a/nix-test.sh +++ b/nix-test.sh @@ -5,4 +5,4 @@ set -euxo pipefail make data/iccma15_solutions data/iccma15_testcases nix-shell \ - --pure --run cucumber + --pure --run 'ASGL_HOME=`pwd` make test' From b51ba252346cc5507b3ee29ca0b4c348eb47b1cb Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 18:03:17 +0100 Subject: [PATCH 49/57] Add .envrc --- .envrc | 1 + 1 file changed, 1 insertion(+) create mode 100644 .envrc diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..854a94b --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +export LC_ALL=C From 5c84a7a73bbe809eefa7c978d50fc3145dca24e2 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 18:24:05 +0100 Subject: [PATCH 50/57] Change .envrc --- .envrc | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.envrc b/.envrc index 854a94b..d36389a 100644 --- a/.envrc +++ b/.envrc @@ -1 +1,7 @@ +# https://github.com/NixOS/nixpkgs/tags +# 24.05 +export NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/63dacb46bf939521bdc93981b4cbb7ecb58427a0.tar.gz + +# use nix + export LC_ALL=C From ca75d22fc7a5edddf318f5ac17b18cc5dc25a39f Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 19:00:52 +0100 Subject: [PATCH 51/57] Add default.nix --- default.nix | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 default.nix diff --git a/default.nix b/default.nix new file mode 100644 index 0000000..c83c393 --- /dev/null +++ b/default.nix @@ -0,0 +1,54 @@ +{ pkgs ? import {} }: + +let + ecl = pkgs.callPackage ./ecl-cpp.nix { }; + gecode = pkgs.callPackage ./gecode.nix { }; +in + +pkgs.stdenv.mkDerivation rec { + pname = "asgl"; + version = "0.1.4"; + + src = ./.; + + nativeBuildInputs = [ + pkgs.autoconf + pkgs.automake + pkgs.makeWrapper + pkgs.gcc + pkgs.ragel + ]; + + buildInputs = [ + ecl + gecode + pkgs.gmp + pkgs.mpfr + pkgs.libffi + pkgs.ruby + pkgs.bundler + ]; + + # Generate configure and Makefile from configure.ac / Makefile.in + preConfigure = '' + echo "Running autoreconf..." + autoreconf -vfi + ''; + + # Configure with --without-gist as per upstream build + configurePhase = '' + echo "Configuring ASGL..." + ./configure --without-gist + ''; + + buildPhase = '' + echo "Building ASGL..." + make all + ''; + + installPhase = '' + echo "Installing ASGL into $out..." + mkdir -p $out/bin + cp bin/asgl $out/bin/ + ''; +} From 730c142d30e27ca2abee1ac2ae8e5138bcfce5e4 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 19:03:00 +0100 Subject: [PATCH 52/57] Change default.nix --- default.nix | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/default.nix b/default.nix index c83c393..91470d9 100644 --- a/default.nix +++ b/default.nix @@ -29,14 +29,11 @@ pkgs.stdenv.mkDerivation rec { pkgs.bundler ]; - # Generate configure and Makefile from configure.ac / Makefile.in - preConfigure = '' + # Configure with --without-gist as per upstream build + configurePhase = '' echo "Running autoreconf..." autoreconf -vfi - ''; - # Configure with --without-gist as per upstream build - configurePhase = '' echo "Configuring ASGL..." ./configure --without-gist ''; From e9d82feda3e6a60144d9bffd341fdb2d45240291 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 19:06:58 +0100 Subject: [PATCH 53/57] ch --- .gitignore | 1 + default.nix | 1 + 2 files changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 5d97109..4bbaef7 100644 --- a/.gitignore +++ b/.gitignore @@ -72,3 +72,4 @@ gecode.c af-constraints.c sat.c README.pdf +result diff --git a/default.nix b/default.nix index 91470d9..102e527 100644 --- a/default.nix +++ b/default.nix @@ -40,6 +40,7 @@ pkgs.stdenv.mkDerivation rec { buildPhase = '' echo "Building ASGL..." + bash scripts/generate-make-mk.sh make all ''; From 90f0d4d6c5f83b1c9640f803216297a423b689e4 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 19:42:05 +0100 Subject: [PATCH 54/57] Change .envrc --- .envrc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.envrc b/.envrc index d36389a..7a2240f 100644 --- a/.envrc +++ b/.envrc @@ -5,3 +5,5 @@ export NIX_PATH=nixpkgs=https://github.com/NixOS/nixpkgs/archive/63dacb46bf93952 # use nix export LC_ALL=C + +export ASGL_HOME=$(pwd) From 00f31b8907c5bb1abe546ae0373beb1d578e6596 Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 19:56:09 +0100 Subject: [PATCH 55/57] Add .github/workflows/ci.yml --- .github/workflows/ci.yml | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 .github/workflows/ci.yml diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..d524616 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,28 @@ +--- +on: + push: + branches: + - master + pull_request: + branches: + - master + +name: Build and deploy template + +jobs: + build_template: + name: Build template + runs-on: ubuntu-latest + steps: + - name: Checkout code + uses: actions/checkout@v3 + + - uses: cachix/install-nix-action@v22 + with: + nix_path: nixpkgs=https://github.com/NixOS/nixpkgs/archive/63dacb46bf939521bdc93981b4cbb7ecb58427a0.tar.gz + + - name: download shell env + run: nix-shell --run ls + + - name: ecl version + run: nix-shell --run 'ecl --version' From 29da18bf1572e2aa55e2ba886a7207b93067394c Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 19:58:51 +0100 Subject: [PATCH 56/57] Change .github/workflows/ci.yml --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d524616..e396b94 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -11,7 +11,7 @@ name: Build and deploy template jobs: build_template: - name: Build template + name: Build asgl runs-on: ubuntu-latest steps: - name: Checkout code From 23ac0f34474cae54467513b856697fbdbd5091df Mon Sep 17 00:00:00 2001 From: Kilian Sprotte Date: Fri, 13 Feb 2026 20:07:10 +0100 Subject: [PATCH 57/57] Change .github/workflows/ci.yml --- .github/workflows/ci.yml | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e396b94..d93a9f7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -1,13 +1,14 @@ --- on: - push: - branches: - - master - pull_request: - branches: - - master + # push: + # branches: + # - master + # pull_request: + # branches: + # - master + workflow_dispatch: -name: Build and deploy template +name: Build asgl jobs: build_template: