wrapper/nginx
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

latest njs

Browse source
This commit is contained in:
wrapper 2025-07-15 12:54:50 +07:00
parent 4f9707fe8a
commit aa5f13475f
440 changed files with 4 additions and 141268 deletions
Download patch file Download diff file Expand all files Collapse all files

6
configure.docker.sh
View file

@ -1,7 +1,7 @@
#!/bin/bash
./configure \
--with-cc-opt="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -fPIC -D_FORTIFY_SOURCE=2" \
--with-ld-opt="-Wl,-z,relro -Wl,-z,now -fPIC" \
--with-cc-opt="-g -O2 -fstack-protector-strong -Wformat -Werror=format-security -fPIC -D_FORTIFY_SOURCE=2 -I/tmp/build/quickjs/" \
--with-ld-opt="-Wl,-z,relro -Wl,-z,now -fPIC -L/tmp/build/quickjs/" \
--sbin-path=/usr/local/sbin/nginx \
--conf-path=/video_server/nginx/nginx.conf \
--error-log-path=/var/log/nginx/error.log \
@ -51,7 +51,7 @@
--add-dynamic-module=./modules_deb/libnginx-mod-http-subs-filter-0.6.4 \
--add-dynamic-module=./modules_deb/libnginx-mod-http-upstream-fair-0.0~git20120408.a18b409 \
--add-dynamic-module=./modules_deb/libnginx-mod-nchan-1.3.6+dfsg \
--add-dynamic-module=./modules_deb/libnginx-mod-js-0.7.9/nginx \
--add-dynamic-module=./modules/njs/nginx \
--add-module=./modules/media-framework/nginx-common \
--add-dynamic-module=./modules/nginx-stream-preread-str-module \
--add-dynamic-module=./modules/media-framework/nginx-kmp-in-module \

2
configure.sh
View file

@ -48,7 +48,7 @@
--add-dynamic-module=./modules_deb/libnginx-mod-http-subs-filter-0.6.4 \
--add-dynamic-module=./modules_deb/libnginx-mod-http-upstream-fair-0.0~git20120408.a18b409 \
--add-dynamic-module=./modules_deb/libnginx-mod-nchan-1.3.6+dfsg \
--add-dynamic-module=./modules_deb/libnginx-mod-js-0.7.9/nginx \
--add-dynamic-module=./modules/njs/nginx \
--add-module=./modules/media-framework/nginx-common \
--add-dynamic-module=./modules/nginx-stream-preread-str-module \
--add-dynamic-module=./modules/media-framework/nginx-kmp-in-module \

4
modules_deb/libnginx-mod-js-0.7.9/.gitignore vendored
View file

@ -1,4 +0,0 @@
node_modules/
package-lock.json
/build/
/Makefile

4
modules_deb/libnginx-mod-js-0.7.9/.hgignore
View file

@ -1,4 +0,0 @@
/node_modules/
package-lock.json
^build/
^Makefile$

56
modules_deb/libnginx-mod-js-0.7.9/.hgtags
View file

@ -1,56 +0,0 @@
cdb8d20935ee96f1fa0c99d994d4b11cefcbc119 0.1.0
0039a747d25a3e08792c23c43b75768896724031 0.1.1
5b066b4db54c17dc0a9a72948474f36957462e87 0.1.2
360449773d51e7f451e5396e27021badc6b86085 0.1.3
508689c1fb94c23f6b24be087c1dc63b2f9e6654 0.1.4
9c813c2bb2acfd5b6e9d1e9b6699af928baea15a 0.1.5
44b524f7e313369cd062a387511ea6fdc427875f 0.1.6
15dc54100400f99c3ec044d8fb0175dd3d69adcb 0.1.7
a29f29d481125db6101ecdc23dc20187c143cdc9 0.1.8
5bd2833988222900f60ad9b330ebc44df3b30662 0.1.9
b1456ef3e002376d9d146a8a02acf6a4a21748e9 0.1.10
fc5df33f4e6b02a673daf3728ff690fb1e09b95e 0.1.11
c07b060396be3622ca97b037a86076b61b850847 0.1.12
d548b78eb881ca799aa6fc8ba459d076f7db5ac8 0.1.13
d89d06dc638e78f8635c0bfbcd02469ac1a08748 0.1.14
215ca47b9167d513fd58ac88de97659377e45275 0.1.15
ddd1b2c9c64b2d459e9c399554dfaadcaabcc364 0.2.0
2a0a59728b5f197379ca62a334a516fabd4ea392 0.2.1
4adbb035caa39dae58611a061d78bc974652231e 0.2.2
e83f41520613987542472275d49633a9aa5955d1 0.2.3
3e6c38f64bdbc53e783813541559034ed6890aee 0.2.4
3315f6aa6000ce6d2dbc74c73660becf4178a549 0.2.5
0709b8b4f11ebec95dd4f72d5bb38044682f77e6 0.2.6
4624ba4f6497a3d10fe1c0a6f45fb453579502f5 0.2.7
ee190d3ace005f8eb063d4763b578f44d3028c68 0.2.8
1935ab4643fdaec5b4a8c36070f4d2cb8e3799d7 0.3.0
ebfbdb8d8fe2f640d880359575657cb53e38328f 0.3.1
82101d50fff6e4c7a92c0542a3d6026ff7e462fb 0.3.2
c65a4be9867d434ca449a18d868305d5dcd5b91b 0.3.3
8eadbb3a7c7b7c3426f73adabfa251cd9d296752 0.3.4
b7fa83f27f1b64443b88c990e1851f59583b2182 0.3.5
7b302775917b72537e1abdbd5dc9d04e55a7d582 0.3.6
9e5ef927c7eaed003de3e5e4a16fa3eab08de7f7 0.3.7
1abb97e9d9dc07dcff2616d4c75132e6d189a6aa 0.3.8
fc4eeaaf0dfe7dc7d41232f1b643bd364f1efe82 0.3.9
6144aafa1472fbdf79bc9d1f858555938ee08452 0.4.0
9400790bf53843001f94c77b47bc99b05518af78 0.4.1
b409e86fd02a6f2cb3d741a41b6562471e1b66ef 0.4.2
1ada1061a040e5cd5ec55744bfa916dfc6744e4c 0.4.3
fdfd580b0dd617a884ed9287d98341ebef03ee9f 0.4.4
69f07c6151628880bf7d5ac28bd8287ce96d8a36 0.5.0
d355071f55ef4612d89db0ba72e7aaeaa99deef7 0.5.1
e5de01378b1a8ab0a94dd3a8c4c6bb7a235f4b9c 0.5.2
282b9412976ceee31eb12876f1499fe975e6f08c 0.5.3
742ebceef2b5d15febc093172fe6174e427b26c8 0.6.0
4adbe67b292af2adc0a6fde4ec6cb95dbba9470a 0.6.1
dfba7f61745c7454ffdd55303a793206d0a9a84a 0.6.2
8418bd4a4ce3114d57b4d75f913e8c4912bf4b5d 0.7.0
35aca5cc5ea7582b80947caa1e3f4a4fb8ee232d 0.7.1
3dd315b80bab10b6ac475ee25dd207d2eb759881 0.7.2
f15d039cf625fb92e061f21c9f28a788032a0faa 0.7.3
b5198f7f11a3b5e174f9e75a7bd50394fa354fb0 0.7.4
63c258c456ca018385b13f352faefdf25c7bd3bb 0.7.5
461dfb0bb60e531d361319f30993f29860c19f55 0.7.6
1592d46d9076aa832b2d37d50b90f5edfca67030 0.7.7
3308415d7de83c3c0c7c65405bec4836685a71de 0.7.8

1714
modules_deb/libnginx-mod-js-0.7.9/CHANGES
View file

File diff suppressed because it is too large Load diff

28
modules_deb/libnginx-mod-js-0.7.9/LICENSE
View file

@ -1,28 +0,0 @@
/*
* Copyright (C) 2015-2022 NGINX, Inc.
* Copyright (C) 2015-2021 Igor Sysoev
* Copyright (C) 2017-2022 Dmitry Volyntsev
* Copyright (C) 2019-2022 Alexander Borisov
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

27
modules_deb/libnginx-mod-js-0.7.9/README
View file

@ -1,27 +0,0 @@
NGINX JavaScript (njs)
----------------------
njs is a subset of the JavaScript language that allows extending nginx
functionality. njs is created in compliance with ECMAScript 5.1 (strict mode)
with some ECMAScript 6 and later extensions. The compliance is still evolving.
The documentation is available online:
https://nginx.org/en/docs/njs/
Additional examples and howtos can be found here:
https://github.com/nginx/njs-examples
Please ask questions, report issues, and send patches to the mailing list:
nginx-devel@nginx.org (https://mailman.nginx.org/mailman/listinfo/nginx-devel)
or via Github:
https://github.com/nginx/njs
--
NGINX, Inc., https://nginx.com

193
modules_deb/libnginx-mod-js-0.7.9/auto/cc
View file

@ -1,193 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
echo checking for C compiler: $CC
cat << END >> $NJS_AUTOCONF_ERR
----------------------------------------
checking for C compiler: $CC
END
# Allow error exit status.
set +e
if [ -z `which $CC` ]; then
echo
echo $0: error: $CC not found.
echo
exit 1;
fi
if `/bin/sh -c "($CC -v)" 2>&1 | grep "gcc version" >> $NJS_AUTOCONF_ERR 2>&1`
then
NJS_CC_NAME=gcc
echo " + using GNU C compiler"
NJS_CC_VERSION=`/bin/sh -c "($CC -v)" 2>&1 | grep "gcc version" 2>&1`
echo " + $NJS_CC_VERSION"
else
if `/bin/sh -c "($CC -v)" 2>&1 | grep "clang version" >> $NJS_AUTOCONF_ERR 2>&1`
then
NJS_CC_NAME=clang
echo " + using Clang C compiler"
NJS_CC_VERSION=`/bin/sh -c "($CC -v)" 2>&1 | grep "clang version" 2>&1`
echo " + $NJS_CC_VERSION"
else
if `/bin/sh -c "($CC -v)" 2>&1 \
| grep "Apple LLVM version" >> $NJS_AUTOCONF_ERR 2>&1`
then
NJS_CC_NAME=clang
echo " + using Clang C compiler"
NJS_CC_VERSION=`/bin/sh -c "($CC -v)" 2>&1 | grep "Apple LLVM version" 2>&1`
echo " + $NJS_CC_VERSION"
else
if `/bin/sh -c "($CC -V)" 2>&1 | grep "Sun C" >> $NJS_AUTOCONF_ERR 2>&1`
then
NJS_CC_NAME=SunC
echo " + using Sun C compiler"
NJS_CC_VERSION=`/bin/sh -c "($CC -V)" 2>&1 | grep "Sun C" 2>&1`
echo " + $NJS_CC_VERSION"
fi # SunC
fi # Apple LLVM clang
fi # clang
fi # gcc
case $NJS_CC_NAME in
gcc)
njs_define=NJS_GCC . auto/define
NJS_CFLAGS="$NJS_CFLAGS -pipe"
NJS_CFLAGS="$NJS_CFLAGS -fPIC"
# Do not export symbols except explicitly marked with NJS_EXPORT.
NJS_CFLAGS="$NJS_CFLAGS -fvisibility=hidden"
# c99/gnu99 conflict with Solaris XOPEN.
#NJS_CFLAGS="$NJS_CFLAGS -std=gnu99"
NJS_CFLAGS="$NJS_CFLAGS -O"
#NJS_CFLAGS="$NJS_CFLAGS -O0"
NJS_CFLAGS="$NJS_CFLAGS -W -Wall -Wextra"
#NJS_CFLAGS="$NJS_CFLAGS -Wunused-result"
NJS_CFLAGS="$NJS_CFLAGS -Wno-unused-parameter"
#NJS_CFLAGS="$NJS_CFLAGS -Wshorten-64-to-32"
NJS_CFLAGS="$NJS_CFLAGS -Wwrite-strings"
# -O2 enables -fstrict-aliasing and -fstrict-overflow.
#NJS_CFLAGS="$NJS_CFLAGS -O2"
#NJS_CFLAGS="$NJS_CFLAGS -Wno-strict-aliasing"
#NJS_CFLAGS="$NJS_CFLAGS -fomit-frame-pointer"
#NJS_CFLAGS="$NJS_CFLAGS -momit-leaf-frame-pointer"
# -Wstrict-overflow is supported by GCC 4.2+.
#NJS_CFLAGS="$NJS_CFLAGS -Wstrict-overflow=5"
NJS_CFLAGS="$NJS_CFLAGS -Wmissing-prototypes"
# Stop on warning.
NJS_CFLAGS="$NJS_CFLAGS -Werror"
# Debug.
NJS_CFLAGS="$NJS_CFLAGS -g"
if [ "$NJS_ADDRESS_SANITIZER" = "YES" ]; then
NJS_CFLAGS="$NJS_CFLAGS -fsanitize=address"
NJS_CFLAGS="$NJS_CFLAGS -fno-omit-frame-pointer"
fi
;;
clang)
njs_define=NJS_CLANG . auto/define
NJS_CFLAGS="$NJS_CFLAGS -pipe"
NJS_CFLAGS="$NJS_CFLAGS -fPIC"
# Do not export symbols except explicitly marked with NJS_EXPORT.
NJS_CFLAGS="$NJS_CFLAGS -fvisibility=hidden"
NJS_CFLAGS="$NJS_CFLAGS -O"
#NJS_CFLAGS="$NJS_CFLAGS -O0"
NJS_CFLAGS="$NJS_CFLAGS -W -Wall -Wextra"
#NJS_CFLAGS="$NJS_CFLAGS -Wunused-result"
NJS_CFLAGS="$NJS_CFLAGS -Wno-unused-parameter"
#NJS_CFLAGS="$NJS_CFLAGS -Wshorten-64-to-32"
NJS_CFLAGS="$NJS_CFLAGS -Wwrite-strings"
#NJS_CFLAGS="$NJS_CFLAGS -O2"
#NJS_CFLAGS="$NJS_CFLAGS -fomit-frame-pointer"
NJS_CFLAGS="$NJS_CFLAGS -fstrict-aliasing"
NJS_CFLAGS="$NJS_CFLAGS -Wstrict-overflow=5"
NJS_CFLAGS="$NJS_CFLAGS -Wmissing-prototypes"
# Stop on warning.
NJS_CFLAGS="$NJS_CFLAGS -Werror"
# Debug.
if [ "$NJS_SYSTEM_PLATFORM" != "powerpc" ]; then
# "-g" flag causes the "unknown pseudo-op: `.cfi_sections'"
# error on PowerPC Clang.
NJS_CFLAGS="$NJS_CFLAGS -g"
fi
if [ "$NJS_ADDRESS_SANITIZER" = "YES" ]; then
NJS_CFLAGS="$NJS_CFLAGS -fsanitize=address"
NJS_CFLAGS="$NJS_CFLAGS -fno-omit-frame-pointer"
NJS_CFLAGS="$NJS_CFLAGS -fsanitize-address-use-after-scope"
fi
;;
SunC)
njs_define=NJS_SUNC . auto/define
NJS_CFLAGS="$NJS_CFLAGS -fPIC"
# Optimization.
NJS_CFLAGS="$NJS_CFLAGS -O -fast"
# Stop on warning.
NJS_CFLAGS="$NJS_CFLAGS -errwarn=%all"
# Debug.
NJS_CFLAGS="$NJS_CFLAGS -g"
if [ "$NJS_ADDRESS_SANITIZER" = "YES" ]; then
echo " - Address sanitizer is not supported by $NJS_CC_NAME"
fi
;;
*)
;;
esac
if [ "$NJS_DEBUG" = "YES" ]; then
njs_define=NJS_DEBUG . auto/define
fi
if [ "$NJS_DEBUG_MEMORY" = "YES" ]; then
njs_define=NJS_DEBUG_MEMORY . auto/define
fi
if [ "$NJS_DEBUG_OPCODE" = "YES" ]; then
njs_define=NJS_DEBUG_OPCODE . auto/define
fi
if [ "$NJS_DEBUG_GENERATOR" = "YES" ]; then
njs_define=NJS_DEBUG_GENERATOR . auto/define
fi
if [ "$NJS_TEST262" = "YES" ]; then
njs_define=NJS_TEST262 . auto/define
fi
# Stop on error exit status again.
set -e

207
modules_deb/libnginx-mod-js-0.7.9/auto/clang
View file

@ -1,207 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
# C language features.
njs_feature="GCC unsigned __int128"
njs_feature_name=NJS_HAVE_UNSIGNED_INT128
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(void) {
unsigned __int128 p = 0;
return (int) p;
}"
. auto/feature
njs_feature="GCC __builtin_expect()"
njs_feature_name=NJS_HAVE_BUILTIN_EXPECT
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(int argc, char *const *argv) {
if ((__typeof__(argc == 0))
__builtin_expect((argc == 0), 0))
return 0;
return 1;
}"
. auto/feature
njs_feature="GCC __builtin_unreachable()"
njs_feature_name=NJS_HAVE_BUILTIN_UNREACHABLE
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(void) {
__builtin_unreachable();
}"
. auto/feature
njs_feature="GCC __builtin_prefetch()"
njs_feature_name=NJS_HAVE_BUILTIN_PREFETCH
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(void) {
__builtin_prefetch(0);
return 0;
}"
. auto/feature
njs_feature="GCC __builtin_clz()"
njs_feature_name=NJS_HAVE_BUILTIN_CLZ
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(void) {
if (__builtin_clz(1) != 31) {
return 1;
}
return 0;
}"
. auto/feature
njs_feature="GCC __builtin_clzll()"
njs_feature_name=NJS_HAVE_BUILTIN_CLZLL
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(void) {
if (__builtin_clzll(1ULL) != 63) {
return 1;
}
return 0;
}"
. auto/feature
njs_feature="GCC __attribute__ visibility"
njs_feature_name=NJS_HAVE_GCC_ATTRIBUTE_VISIBILITY
njs_feature_run=no
njs_feature_path=
njs_feature_libs=
njs_feature_test="int n __attribute__ ((visibility(\"default\")));
int main(void) {
return 0;
}"
. auto/feature
njs_feature="GCC __attribute__ malloc"
njs_feature_name=NJS_HAVE_GCC_ATTRIBUTE_MALLOC
njs_feature_run=no
njs_feature_path=
njs_feature_libs=
njs_feature_test="#include <stdlib.h>
void *f(void) __attribute__ ((__malloc__));
void *f(void) {
return malloc(1);
}
int main(void) {
if (f() != NULL) {
return 1;
}
return 0;
}"
. auto/feature
njs_feature="GCC __attribute__ aligned"
njs_feature_name=NJS_HAVE_GCC_ATTRIBUTE_ALIGNED
njs_feature_run=no
njs_feature_path=
njs_feature_libs=
njs_feature_test="int n __attribute__ ((aligned(64)));
int main(void) {
return 0;
}"
. auto/feature
njs_feature="GCC __attribute__ packed"
njs_feature_name=NJS_HAVE_GCC_ATTRIBUTE_PACKED
njs_feature_run=no
njs_feature_path=
njs_feature_libs=
njs_feature_test="struct __attribute__((packed)) s { char v; };
int main(void) {
return 0;
}"
. auto/feature
njs_feature="GCC __attribute__ fallthrough"
njs_feature_name=NJS_HAVE_GCC_ATTRIBUTE_FALLTHROUGH
njs_feature_run=no
njs_feature_path=
njs_feature_libs=
njs_feature_test="int main(int argc, char *argv[]) {
switch (argc) {
case 0:
argc++;
__attribute__((fallthrough));
default:
argc++;
}
return argc;
}"
. auto/feature
njs_feature="Address sanitizer"
njs_feature_name=NJS_HAVE_ADDRESS_SANITIZER
njs_feature_run=no
njs_feature_path=
njs_feature_libs=
njs_feature_test="int main(void) {
return
#ifdef __SANITIZE_ADDRESS__
0;
#else
#if defined(__has_feature)
#if __has_feature(address_sanitizer)
0;
#endif
#endif
#endif
}"
. auto/feature
njs_feature="Memory sanitizer"
njs_feature_name=NJS_HAVE_MEMORY_SANITIZER
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <sanitizer/msan_interface.h>
int main(int argc, char *argv[]) {
__msan_unpoison(argv, sizeof(char *));
return 0;
}"
. auto/feature
njs_feature="_mm_setcsr()"
njs_feature_name=NJS_HAVE_DENORMALS_CONTROL
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <xmmintrin.h>
int main(void) {
_mm_setcsr(_mm_getcsr());
return 0;
}"
. auto/feature

25
modules_deb/libnginx-mod-js-0.7.9/auto/computed_goto
View file

@ -1,25 +0,0 @@
# Copyright (C) Vadim Zhestikov
# Copyright (C) NGINX, Inc.
NJS_HAVE_COMPUTED_GOTO=NO
if [ $NJS_TRY_GOTO = YES ]; then
njs_feature="Computed goto"
njs_feature_name=NJS_HAVE_COMPUTED_GOTO
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="int main(void) {
void *ptr;
ptr = &&label;
goto *ptr;
label:
return 0;
}"
. auto/feature
fi

12
modules_deb/libnginx-mod-js-0.7.9/auto/define
View file

@ -1,12 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
cat << END >> $NJS_AUTO_CONFIG_H
#ifndef $njs_define
#define $njs_define 1
#endif
END

29
modules_deb/libnginx-mod-js-0.7.9/auto/deps
View file

@ -1,29 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
case "$NJS_CC_NAME" in
SunC):
njs_gen_dep_flags() {
echo "-xMMD -xMF $NJS_BUILD_DIR/$1.tmp"
}
njs_gen_dep_post() {
printf "@sed -e 's#^.*:#$NJS_BUILD_DIR/$2:#' "
printf "$NJS_BUILD_DIR/$1.tmp > $NJS_BUILD_DIR/$1"
echo " && rm -f $NJS_BUILD_DIR/$1.tmp"
}
;;
*)
njs_gen_dep_flags() {
echo "-MMD -MF $NJS_BUILD_DIR/$1 -MT $NJS_BUILD_DIR/$2"
}
njs_gen_dep_post() {
echo ""
}
;;
esac

35
modules_deb/libnginx-mod-js-0.7.9/auto/endianness
View file

@ -1,35 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
njs_found=no
njs_feature="system byte ordering"
njs_feature_name=NJS_BYTE_ORDER
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=-lm
njs_feature_test="#include <stdio.h>
#include <stdint.h>
int main(void) {
uint16_t x = 1; /* 0x0001 */
printf(\"%s\n\", (*((uint8_t *) &x) == 0) ? \"big\" : \"little\");
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
echo
echo "$0: error: cannot detect system byte ordering"
echo
exit 1;
fi
if [ $njs_feature_value = big ]; then
njs_define=NJS_HAVE_BIG_ENDIAN . auto/define
else
njs_define=NJS_HAVE_LITTLE_ENDIAN . auto/define
fi

37
modules_deb/libnginx-mod-js-0.7.9/auto/expect
View file

@ -1,37 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
njs_found=no
printf "checking for expect ..."
if /bin/sh -c "(expect -v)" >> $NJS_AUTOCONF_ERR 2>&1; then
njs_found=yes
fi
if [ $njs_found = yes ]; then
echo " found"
echo " + Expect version: `expect -v`"
else
echo " not found"
fi
if [ $njs_found = yes -a $NJS_HAVE_READLINE = YES ]; then
cat << END >> $NJS_MAKEFILE
shell_test: njs test/shell_test.exp
INPUTRC=test/inputrc PATH=$NJS_BUILD_DIR:\$(PATH) \
expect -f test/shell_test.exp
END
else
echo " - expect tests are disabled"
cat << END >> $NJS_MAKEFILE
shell_test:
@echo "Skipping expect tests"
END
fi

40
modules_deb/libnginx-mod-js-0.7.9/auto/explicit_bzero
View file

@ -1,40 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
# Linux (glibc and musl from 1.1.20), OpenBSD and FreeBSD.
njs_feature="explicit_bzero()"
njs_feature_name=NJS_HAVE_EXPLICIT_BZERO
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <strings.h>
#include <string.h>
int main(void) {
int r;
explicit_bzero(&r, sizeof(r));
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
# NetBSD has explicit_memset instead.
njs_feature="explicit_memset()"
njs_feature_name=NJS_HAVE_EXPLICIT_MEMSET
njs_feature_test="#include <string.h>
int main(void) {
int r;
explicit_memset(&r, 0, sizeof(r));
return 0;
}"
. auto/feature
fi

112
modules_deb/libnginx-mod-js-0.7.9/auto/feature
View file

@ -1,112 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
printf "checking for $njs_feature ..."
cat << END >> $NJS_AUTOCONF_ERR
----------------------------------------
checking for $njs_feature
END
njs_found=no
njs_feature_value=
njs_feature_inc_path=
if test -n "$njs_feature_incs"; then
case "$njs_feature_incs" in
-*)
njs_feature_inc_path="$njs_feature_incs"
;;
*)
for njs_temp in $njs_feature_incs; do
njs_feature_inc_path="$njs_feature_inc_path -I $njs_temp"
done
;;
esac
fi
cat << END > $NJS_AUTOTEST.c
$njs_feature_test
END
njs_test="$CC $CFLAGS $NJS_CFLAGS $NJS_CC_OPT $NJS_TEST_CFLAGS \
$njs_feature_inc_path -o $NJS_AUTOTEST $NJS_AUTOTEST.c \
$NJS_LD_OPT $NJS_TEST_LIBS $njs_feature_libs"
# /bin/sh -c "(...)" is to intercept "Killed", "Abort trap",
# "Segmentation fault", or other shell messages.
# "|| true" is to bypass "set -e" setting.
/bin/sh -c "($njs_test || true)" >> $NJS_AUTOCONF_ERR 2>&1
if [ -x $NJS_AUTOTEST ]; then
case "$njs_feature_run" in
value)
if /bin/sh -c "($NJS_AUTOTEST)" >> $NJS_AUTOCONF_ERR 2>&1; then
echo >> $NJS_AUTOCONF_ERR
njs_found=yes
njs_feature_value=`$NJS_AUTOTEST`
echo " $njs_feature_value"
if [ -n "$njs_feature_name" ]; then
cat << END >> $NJS_AUTO_CONFIG_H
#ifndef $njs_feature_name
#define $njs_feature_name $njs_feature_value
#endif
END
fi
else
echo " not found"
fi
;;
yes)
if /bin/sh -c "($NJS_AUTOTEST)" >> $NJS_AUTOCONF_ERR 2>&1; then
echo " found"
njs_found=yes
cat << END >> $NJS_AUTO_CONFIG_H
#ifndef $njs_feature_name
#define $njs_feature_name 1
#endif
END
else
echo " found but is not working"
fi
;;
*)
echo " found"
njs_found=yes
cat << END >> $NJS_AUTO_CONFIG_H
#ifndef $njs_feature_name
#define $njs_feature_name 1
#endif
END
;;
esac
else
echo " not found"
echo "----------" >> $NJS_AUTOCONF_ERR
cat $NJS_AUTOTEST.c >> $NJS_AUTOCONF_ERR
echo "----------" >> $NJS_AUTOCONF_ERR
echo $njs_test >> $NJS_AUTOCONF_ERR
echo "----------" >> $NJS_AUTOCONF_ERR
fi
rm -rf $NJS_AUTOTEST*

91
modules_deb/libnginx-mod-js-0.7.9/auto/getrandom
View file

@ -1,91 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
# Linux 3.17 with glibc 2.25, FreeBSD 12, Solaris 11.3.
njs_feature="getrandom()"
njs_feature_name=NJS_HAVE_GETRANDOM
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <unistd.h>
#include <sys/random.h>
int main(void) {
char buf[4];
if (getrandom(buf, 4, 0) < 0) {
return 1;
}
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
# Linux 3.17 SYS_getrandom.
njs_feature="SYS_getrandom in Linux"
njs_feature_name=NJS_HAVE_LINUX_SYS_GETRANDOM
njs_feature_test="#include <unistd.h>
#include <sys/syscall.h>
#include <linux/random.h>
int main(void) {
char buf[4];
if (syscall(SYS_getrandom, buf, 4, 0) < 0) {
return 1;
}
return 0;
}"
. auto/feature
fi
if [ $njs_found = no ]; then
# OpenBSD 5.6 lacks <sys/random.h>.
njs_feature="getentropy()"
njs_feature_name=NJS_HAVE_GETENTROPY
njs_feature_test="#include <unistd.h>
int main(void) {
char buf[4];
if (getentropy(buf, 4) == -1) {
return 1;
}
return 0;
}"
. auto/feature
fi
if [ $njs_found = no ]; then
# macOS 10.12.
njs_feature="getentropy() in sys/random.h"
njs_feature_name=NJS_HAVE_GETENTROPY_SYS_RANDOM
njs_feature_test="#include <unistd.h>
#include <sys/random.h>
int main(void) {
char buf[4];
if (getentropy(buf, 4) == -1) {
return 1;
}
return 0;
}"
. auto/feature
fi

52
modules_deb/libnginx-mod-js-0.7.9/auto/help
View file

@ -1,52 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
cat << END
./configure options:
--cc=FILE set C compiler filename, default: "$CC"
--cc-opt=OPTIONS set additional C compiler options, \
default: "$NJS_CC_OPT"
--ld-opt=OPTIONS set additional linker options, \
default: "$NJS_LD_OPT"
--ar=FILE set static linking program, default: "$AR"
--build-dir=DIR set build directory, default: "$NJS_BUILD_DIR"
--no-pcre disables PCRE/PCRE2 discovery for RegExp
backend. This flag allows to build PCRE/PCRE2
outside of libnjs.a. When this option is enabled
functions described in njs_regex.h are not built.
Instead this functions are expected to be provided
while linking.
--no-pcre2 disables PCRE2 discovery for RegExp backend.
When this option is enabled only PCRE library
is discovered.
--no-goto disables computed goto discovery.
When this option is enabled 'switch' statement
will be always used in instead of computed goto.
--no-openssl disables OpenSSL discovery. When this option is
enabled OpenSSL dependant code is not built as a
part of libnjs.a.
--address-sanitizer=YES enables build with address sanitizer, \
default: "$NJS_ADDRESS_SANITIZER"
--addr2line=YES enables native function symbolization, \
default: "$NJS_ADDR2LINE"
--debug=YES enables additional runtime checks, \
default: "$NJS_DEBUG"
--debug-memory=YES enables memory alloc debug, \
default: "$NJS_DEBUG_MEMORY"
--debug-opcode=YES enables runtime function tracing, \
default: "$NJS_DEBUG_OPCODE"
--debug-generator=YES enables generator debug, \
default: "$NJS_DEBUG_GENERATOR"
--test262=YES enables test262 extentions, \
default: "$NJS_TEST262"
END

23
modules_deb/libnginx-mod-js-0.7.9/auto/init
View file

@ -1,23 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
# Initialize variables with null values if they are not defined.
CFLAGS=${CFLAGS=}
NJS_TEST_CFLAGS=${NJS_TEST_CFLAGS=}
NJS_TEST_LIBS=${NJS_TEST_LIBS=}
# Initialize variables with default if they are not defined.
CC=${CC:-cc}
AR=${AR:-ar}
NJS_CFLAGS=${NJS_CFLAGS=}
NJS_BUILD_DIR=${NJS_BUILD_DIR:-build}
NJS_LIB_MODULES=
NJS_LIBRT=
njs_regex_cont=' \\\
'

35
modules_deb/libnginx-mod-js-0.7.9/auto/libbfd
View file

@ -1,35 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
NJS_HAVE_LIBBFD=NO
if [ $NJS_ADDR2LINE = YES ]; then
njs_found=no
njs_feature="BFD library"
njs_feature_name=NJS_HAVE_LIBBFD
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs="-lbfd"
njs_feature_test="#include <bfd.h>
int main() {
bfd_init();
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
njs_feature="OpenSSL library -lcrypto"
njs_feature_libs="-lcrypto"
. auto/feature
fi
if [ $njs_found = yes ]; then
NJS_HAVE_LIBBFD=YES
NJS_LIB_AUX_LIBS="$NJS_LIB_AUX_LIBS $njs_feature_libs"
fi
fi

31
modules_deb/libnginx-mod-js-0.7.9/auto/link
View file

@ -1,31 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
NJS_HAVE_DL_ITERATE_PHDR=NO
if [ $NJS_ADDR2LINE = YES ]; then
njs_feature="dl_iterate_phdr()"
njs_feature_name=NJS_HAVE_DL_ITERATE_PHDR
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#define _GNU_SOURCE
#include <link.h>
static int
cb(struct dl_phdr_info *info, size_t size, void *data) {
return 0;
}
int main() {
dl_iterate_phdr(cb, 0);
return 0;
}"
. auto/feature
if [ $njs_found = yes ]; then
NJS_HAVE_DL_ITERATE_PHDR=YES
fi
fi

343
modules_deb/libnginx-mod-js-0.7.9/auto/make
View file

@ -1,343 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
. auto/deps
echo "creating $NJS_MAKEFILE"
mkdir -p $NJS_BUILD_DIR/src
mkdir -p $NJS_BUILD_DIR/external
mkdir -p $NJS_BUILD_DIR/$NJS_BUILD_DIR
mkdir -p $NJS_BUILD_DIR/test
njs_modules_c=$NJS_BUILD_DIR/njs_modules.c
NJS_LIB_SRCS="$NJS_LIB_SRCS $njs_modules_c"
njs_incs=`echo $NJS_LIB_INCS \
| sed -e "s# *\([^ ]*\)#$njs_regex_cont-I\1#g"`
njs_objs=`echo $NJS_LIB_SRCS \
| sed -e "s# *\([^ ]*\.\)c#$NJS_BUILD_DIR/\1o$njs_regex_cont#g"`
cat << END > $njs_modules_c
#include <njs_main.h>
END
for mod in $NJS_LIB_MODULES
do
echo "extern njs_module_t $mod;" >> $njs_modules_c
done
echo >> $njs_modules_c
echo 'njs_module_t *njs_modules[] = {' >> $njs_modules_c
for mod in $NJS_LIB_MODULES
do
echo " &$mod," >> $njs_modules_c
done
cat << END >> $njs_modules_c
NULL
};
END
cat << END > $NJS_MAKEFILE
# This file is auto-generated by configure
NJS_CC = ${CC}
NJS_STATIC_LINK = ${AR} -r -c
NJS_LINK = ${CC} ${NJS_LD_OPT}
NJS_CFLAGS = ${NJS_CFLAGS} ${NJS_CC_OPT} ${CFLAGS}
NJS_VER = $(grep NJS_VERSION src/njs.h | sed -e 's/.*"\(.*\)".*/\1/')
NJS_TYPES_VER = \$(NJS_VER)
NPM = npm
default: njs
NJS_LIB_INCS = $njs_incs
NJS_LIB_OBJS = $njs_objs
libnjs: $NJS_BUILD_DIR/libnjs.a pc
$NJS_BUILD_DIR/libnjs.a: \\
$NJS_BUILD_DIR/njs_auto_config.h \\
\$(NJS_LIB_OBJS)
\$(NJS_STATIC_LINK) $NJS_BUILD_DIR/libnjs.a \\
\$(NJS_LIB_OBJS)
END
# object files.
for njs_src in $NJS_LIB_SRCS
do
njs_obj="${njs_src%.c}.o"
njs_dep="${njs_src%.c}.dep"
njs_dep_flags=`njs_gen_dep_flags $njs_dep $njs_obj`
njs_dep_post=`njs_gen_dep_post $njs_dep $njs_obj`
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/$njs_obj: $njs_src
\$(NJS_CC) -c \$(NJS_CFLAGS) $NJS_LIB_AUX_CFLAGS \\
\$(NJS_LIB_INCS) -Injs \\
-o $NJS_BUILD_DIR/$njs_obj \\
$njs_dep_flags \\
$njs_src
$njs_dep_post
-include $NJS_BUILD_DIR/$njs_dep
END
done
# njs cli.
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/njs: \\
$NJS_BUILD_DIR/libnjs.a \\
src/njs_shell.c
\$(NJS_LINK) -o $NJS_BUILD_DIR/njs \$(NJS_CFLAGS) \\
$NJS_LIB_AUX_CFLAGS \$(NJS_LIB_INCS) -Injs \\
src/njs_shell.c \\
$NJS_BUILD_DIR/libnjs.a \\
$NJS_LD_OPT -lm $NJS_LIBS $NJS_LIB_AUX_LIBS $NJS_READLINE_LIB
END
# njs fuzzer.
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/njs_process_script_fuzzer.o: \\
src/njs_shell.c
\$(NJS_CC) -c \$(CFLAGS) $NJS_LIB_AUX_CFLAGS \\
\$(NJS_LIB_INCS) -Injs \\
-DNJS_FUZZER_TARGET \\
-o $NJS_BUILD_DIR/njs_process_script_fuzzer.o \\
src/njs_shell.c
$NJS_BUILD_DIR/njs_process_script_fuzzer: \\
$NJS_BUILD_DIR/libnjs.a \\
$NJS_BUILD_DIR/njs_process_script_fuzzer.o
\$(CXX) \$(CXXFLAGS) -o $NJS_BUILD_DIR/njs_process_script_fuzzer \\
$NJS_LIB_AUX_CFLAGS \$(NJS_LIB_INCS) -Injs \\
\$(LIB_FUZZING_ENGINE) \\
$NJS_BUILD_DIR/njs_process_script_fuzzer.o \\
$NJS_BUILD_DIR/libnjs.a \\
-lm $NJS_LIBS $NJS_LIB_AUX_LIBS
END
# lib tests.
for njs_src in $NJS_LIB_TEST_SRCS
do
fname=$(basename $njs_src)
njs_dep="test/${fname%.c}.dep"
njs_bin="${fname%.c}"
njs_dep_flags=`njs_gen_dep_flags $njs_dep $fname`
njs_dep_post=`njs_gen_dep_post $njs_dep $fname`
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/$njs_bin: $njs_src \\
$NJS_BUILD_DIR/libnjs.a
\$(NJS_LINK) -o $NJS_BUILD_DIR/$njs_bin \$(NJS_CFLAGS) \\
\$(NJS_LIB_INCS) $njs_dep_flags \\
$njs_src $NJS_BUILD_DIR/libnjs.a \\
$njs_dep_post -lm $NJS_LD_OPT
-include $NJS_BUILD_DIR/$njs_dep
END
done
# njs tests.
njs_src="src/test/njs_externals_test.c"
fname=$(basename $njs_src)
njs_externals_obj="test/${fname%.c}.o"
njs_dep="test/${fname%.c}.dep"
njs_dep_flags=`njs_gen_dep_flags $njs_dep $njs_externals_obj`
njs_dep_post=`njs_gen_dep_post $njs_dep $njs_externals_obj`
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/$njs_externals_obj: \\
$njs_src
\$(NJS_CC) -c \$(NJS_CFLAGS) $NJS_LIB_AUX_CFLAGS \\
\$(NJS_LIB_INCS) -Injs \\
-o $NJS_BUILD_DIR/$njs_externals_obj \\
$njs_dep_flags \\
$njs_src
$njs_dep_post
-include $NJS_BUILD_DIR/$njs_dep
END
for njs_src in $NJS_TEST_SRCS
do
fname=$(basename $njs_src)
njs_dep="test/${fname%.c}.dep"
njs_bin="${fname%.c}"
njs_dep_flags=`njs_gen_dep_flags $njs_dep $fname`
njs_dep_post=`njs_gen_dep_post $njs_dep $fname`
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/$njs_bin: $njs_src \\
$NJS_BUILD_DIR/libnjs.a \\
$NJS_BUILD_DIR/$njs_externals_obj
\$(NJS_LINK) -o $NJS_BUILD_DIR/$njs_bin \$(NJS_CFLAGS) \\
$NJS_LIB_AUX_CFLAGS \$(NJS_LIB_INCS) \\
$njs_dep_flags \\
$NJS_BUILD_DIR/$njs_externals_obj \\
-Injs $njs_src $NJS_BUILD_DIR/libnjs.a \\
$NJS_LD_OPT -lm $NJS_LIBS $NJS_LIB_AUX_LIBS
$njs_dep_post
-include $NJS_BUILD_DIR/$njs_dep
END
done
# main targets.
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/njs_auto_config.h:
@echo
@echo " Please run ./configure before make"
@echo
@exit 1
all: $NJS_BUILD_DIR/njs_auto_config.h \\
njs ts test lib_test benchmark
njs: $NJS_BUILD_DIR/njs_auto_config.h $NJS_BUILD_DIR/njs
njs_fuzzer: $NJS_BUILD_DIR/njs_auto_config.h \\
$NJS_BUILD_DIR/njs_process_script_fuzzer
lib_test: $NJS_BUILD_DIR/njs_auto_config.h \\
$NJS_BUILD_DIR/random_unit_test \\
$NJS_BUILD_DIR/rbtree_unit_test \\
$NJS_BUILD_DIR/lvlhsh_unit_test \\
$NJS_BUILD_DIR/unicode_unit_test
$NJS_BUILD_DIR/random_unit_test
$NJS_BUILD_DIR/rbtree_unit_test
$NJS_BUILD_DIR/lvlhsh_unit_test
$NJS_BUILD_DIR/unicode_unit_test
test262: njs
test/test262 --binary=$NJS_BUILD_DIR/njs
unit_test: $NJS_BUILD_DIR/njs_auto_config.h \\
$NJS_BUILD_DIR/njs_unit_test
$NJS_BUILD_DIR/njs_unit_test
test: shell_test unit_test test262
benchmark: $NJS_BUILD_DIR/njs_auto_config.h \\
$NJS_BUILD_DIR/njs_benchmark
$NJS_BUILD_DIR/njs_benchmark
dist:
rm -rf njs-\$(NJS_VER) \\
&& hg archive njs-\$(NJS_VER).tar.gz \\
-p njs-\$(NJS_VER) \\
-X ".hg*" \\
&& echo njs-\$(NJS_VER).tar.gz done
END
njs_ts_deps=`echo $NJS_TS_SRCS \
| sed -e "s# *\([^ ][^ ]*\)#\1$njs_regex_cont#g"`
njs_test_ts_deps=`echo $NJS_TEST_TS_SRCS \
| sed -e "s# *\([^ ][^ ]*\)#\1$njs_regex_cont#g"`
cat << END >> $NJS_MAKEFILE
$NJS_BUILD_DIR/ts/package.json: $njs_ts_deps
cp -fr ts $NJS_BUILD_DIR/
cp LICENSE $NJS_BUILD_DIR/ts/
sed 's/__VERSION__/"\$(NJS_TYPES_VER)"/' \\
ts/package.json > $NJS_BUILD_DIR/ts/package.json
$NJS_BUILD_DIR/ts/node_modules: $NJS_BUILD_DIR/ts/package.json
cd $NJS_BUILD_DIR/ts && \$(NPM) install
touch $NJS_BUILD_DIR/ts/node_modules
$NJS_BUILD_DIR/njs-types-\$(NJS_TYPES_VER).tgz: $NJS_BUILD_DIR/ts/package.json
hg id -i > $NJS_BUILD_DIR/ts/COMMITHASH || true
cd $NJS_BUILD_DIR && \$(NPM) pack ./ts
.PHONY: ts
ts: $NJS_BUILD_DIR/ts/package.json
ts_lint: $NJS_BUILD_DIR/ts/node_modules
cd $NJS_BUILD_DIR/ts && \$(NPM) run lint
$NJS_BUILD_DIR/test/ts/package.json: $njs_test_ts_deps
mkdir -p $NJS_BUILD_DIR/test
cp -fr test/ts $NJS_BUILD_DIR/test/
$NJS_BUILD_DIR/test/ts/node_modules: \\
$NJS_BUILD_DIR/njs-types-\$(NJS_TYPES_VER).tgz \\
$NJS_BUILD_DIR/test/ts/package.json
cd $NJS_BUILD_DIR/test/ts && \$(NPM) install \\
--save-dev file:../../njs-types-\$(NJS_TYPES_VER).tgz
cd $NJS_BUILD_DIR/test/ts && \$(NPM) install
touch $NJS_BUILD_DIR/test/ts/node_modules
ts_test: $NJS_BUILD_DIR/test/ts/node_modules
cd $NJS_BUILD_DIR/test/ts && \$(NPM) test
ts_publish: ts_clean $NJS_BUILD_DIR/njs-types-\$(NJS_TYPES_VER).tgz
cd $NJS_BUILD_DIR/ && \$(NPM) publish njs-types-\$(NJS_TYPES_VER).tgz
ts_clean:
rm -rf $NJS_BUILD_DIR/ts
END
# pkg-config file
cat << END >> $NJS_MAKEFILE
pc: $NJS_BUILD_DIR/njs.pc
$NJS_BUILD_DIR/njs.pc: $NJS_BUILD_DIR/njs_auto_config.h
sed -e "s,@PREFIX@,$(pwd)/$NJS_BUILD_DIR," \\
-e "s,@LIBDIR@,$(pwd)/$NJS_BUILD_DIR," \\
-e "s,@CFLAGS@,-I$(pwd)/$NJS_BUILD_DIR -I$(pwd)/src," \\
-e "s,@VERSION@,\$(NJS_VER)," \\
-e "s,@EXTRA_LIBS@,-lm $NJS_LIBS $NJS_LIB_AUX_LIBS," \\
src/njs.pc.in > \$@
END
# Makefile.
cat << END > Makefile
# This file is auto-generated by configure
include $NJS_MAKEFILE
.PHONY: clean
clean:
rm -rf $NJS_BUILD_DIR Makefile
END

50
modules_deb/libnginx-mod-js-0.7.9/auto/memalign
View file

@ -1,50 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
# Linux glibc 2.1.91, FreeBSD 7.0, Solaris 11,
# MacOSX 10.6 (Snow Leopard), NetBSD 5.0.
njs_feature="posix_memalign()"
njs_feature_name=NJS_HAVE_POSIX_MEMALIGN
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <stdlib.h>
int main(void) {
void *p;
if (posix_memalign(&p, 4096, 4096) != 0)
return 1;
free(p);
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
# Solaris, HP-UX.
njs_feature="memalign()"
njs_feature_name=NJS_HAVE_MEMALIGN
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <stdlib.h>
int main(void) {
void *p;
p = memalign(4096, 4096);
if (p == NULL)
return 1;
free(p);
return 0;
}"
. auto/feature
fi

6
modules_deb/libnginx-mod-js-0.7.9/auto/module
View file

@ -1,6 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
NJS_LIB_MODULES="$NJS_LIB_MODULES $njs_module_name"
NJS_LIB_SRCS="$NJS_LIB_SRCS $njs_module_srcs"
NJS_LIB_INCS="$NJS_LIB_INCS $njs_module_incs"

34
modules_deb/libnginx-mod-js-0.7.9/auto/modules
View file

@ -1,34 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
njs_module_name=njs_buffer_module
njs_module_incs=
njs_module_srcs=src/njs_buffer.c
. auto/module
njs_module_name=njs_crypto_module
njs_module_incs=
njs_module_srcs=external/njs_crypto_module.c
. auto/module
if [ $NJS_OPENSSL = YES -a $NJS_HAVE_OPENSSL = YES ]; then
njs_module_name=njs_webcrypto_module
njs_module_incs=
njs_module_srcs=external/njs_webcrypto_module.c
. auto/module
fi
njs_module_name=njs_fs_module
njs_module_incs=
njs_module_srcs=external/njs_fs_module.c
. auto/module
njs_module_name=njs_query_string_module
njs_module_incs=
njs_module_srcs=external/njs_query_string_module.c
. auto/module

52
modules_deb/libnginx-mod-js-0.7.9/auto/openssl
View file

@ -1,52 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
NJS_OPENSSL_LIB=
NJS_HAVE_OPENSSL=NO
if [ $NJS_OPENSSL = YES ]; then
njs_found=no
njs_feature="OpenSSL library"
njs_feature_name=NJS_HAVE_OPENSSL
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=""
njs_feature_test="#include <openssl/evp.h>
int main() {
EVP_CIPHER_CTX *ctx;
ctx = EVP_CIPHER_CTX_new();
EVP_CIPHER_CTX_free(ctx);
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
njs_feature="OpenSSL library -lcrypto"
njs_feature_libs="-lcrypto"
. auto/feature
fi
if [ $njs_found = yes ]; then
njs_feature="OpenSSL version"
njs_feature_name=NJS_OPENSSL_VERSION
njs_feature_run=value
njs_feature_test="#include <openssl/ssl.h>
int main() {
printf(\"\\\"%s\\\"\", OPENSSL_VERSION_TEXT);
return 0;
}"
. auto/feature
NJS_HAVE_OPENSSL=YES
NJS_OPENSSL_LIB="$njs_feature_libs"
NJS_LIB_AUX_LIBS="$NJS_LIB_AUX_LIBS $njs_feature_libs"
fi
fi

83
modules_deb/libnginx-mod-js-0.7.9/auto/options
View file

@ -1,83 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
NJS_CC_OPT=${NJS_CC_OPT:--O}
NJS_LD_OPT=${NJS_CC_OPT:--O}
NJS_DEBUG=NO
NJS_DEBUG_MEMORY=NO
NJS_DEBUG_OPCODE=NO
NJS_DEBUG_GENERATOR=NO
NJS_ADDRESS_SANITIZER=NO
NJS_ADDR2LINE=NO
NJS_TEST262=YES
NJS_OPENSSL=YES
NJS_PCRE=YES
NJS_TRY_PCRE2=YES
NJS_TRY_GOTO=YES
NJS_CONFIGURE_OPTIONS=
for njs_option
do
case "$njs_option" in
-*=*) value=`echo "$njs_option" | sed -e 's/[-_a-zA-Z0-9]*=//'` ;;
*) value="" ;;
esac
case "$njs_option" in
--cc=*) CC="$value" ;;
--cc-opt=*) NJS_CC_OPT="$value" ;;
--ld-opt=*) NJS_LD_OPT="$value" ;;
--ar=*) AR="$value" ;;
--build-dir=*) NJS_BUILD_DIR="$value" ;;
--address-sanitizer=*) NJS_ADDRESS_SANITIZER="$value" ;;
--addr2line=*) NJS_ADDR2LINE="$value" ;;
--debug=*) NJS_DEBUG="$value" ;;
--debug-memory=*) NJS_DEBUG_MEMORY="$value" ;;
--debug-opcode=*) NJS_DEBUG_OPCODE="$value" ;;
--debug-generator=*) NJS_DEBUG_GENERATOR="$value" ;;
--test262=*) NJS_TEST262="$value" ;;
--no-openssl) NJS_OPENSSL=NO ;;
--no-pcre) NJS_PCRE=NO ;;
--no-pcre2) NJS_TRY_PCRE2=NO ;;
--no-goto) NJS_TRY_GOTO=NO ;;
--help)
. auto/help
exit 0
;;
*)
echo
echo $0: error: invalid option \"$njs_option\".
echo Run \"$0 --help\" to see available options.
echo
exit 1
;;
esac
njs_opt=`echo $njs_option | sed -e "s/\(--[^=]*=\)\(.* .*\)/\1'\2'/"`
NJS_CONFIGURE_OPTIONS="$NJS_CONFIGURE_OPTIONS $njs_opt"
done
if [ "$NJS_DEBUG_MEMORY" = "YES" ]; then
NJS_DEBUG=YES
fi
if [ "$NJS_DEBUG_OPCODE" = "YES" ]; then
NJS_ADDR2LINE=YES
fi

46
modules_deb/libnginx-mod-js-0.7.9/auto/os
View file

@ -1,46 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
NJS_SYSTEM=`uname -s 2>/dev/null`
case "$NJS_SYSTEM" in
Linux)
njs_define=NJS_LINUX . auto/define
NJS_SYSTEM_VERSION=`uname -r 2>/dev/null`
# Linux uname -p can return "unknown".
NJS_SYSTEM_PLATFORM=`uname -m 2>/dev/null`
CC=${CC:-cc}
;;
FreeBSD | NetBSD | OpenBSD)
NJS_SYSTEM_VERSION=`uname -r 2>/dev/null`
NJS_SYSTEM_PLATFORM=`uname -m 2>/dev/null`
CC=${CC:-cc}
;;
SunOS)
njs_define=NJS_SOLARIS . auto/define
NJS_SYSTEM_VERSION=`uname -r 2>/dev/null`
NJS_SYSTEM_PLATFORM=`uname -p 2>/dev/null`
CC=${CC:-gcc}
;;
Darwin)
NJS_SYSTEM_VERSION=`uname -r 2>/dev/null`
NJS_SYSTEM_PLATFORM=`uname -m 2>/dev/null`
CC=${CC:-cc}
;;
*)
NJS_SYSTEM_VERSION=`uname -r 2>/dev/null`
NJS_SYSTEM_PLATFORM=`uname -p 2>/dev/null`
CC=${CC:-gcc}
;;
esac
echo configuring for $NJS_SYSTEM $NJS_SYSTEM_VERSION $NJS_SYSTEM_PLATFORM

139
modules_deb/libnginx-mod-js-0.7.9/auto/pcre
View file

@ -1,139 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
NJS_PCRE_CFLAGS=
NJS_PCRE_LIB=
NJS_HAVE_PCRE=NO
if [ $NJS_PCRE = YES ]; then
njs_found=no
if [ $NJS_TRY_PCRE2 = YES ]; then
njs_feature="PCRE2 library"
njs_feature_name=NJS_HAVE_PCRE2
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
int main(void) {
pcre2_code *re;
re = pcre2_compile((PCRE2_SPTR)\"\",
PCRE2_ZERO_TERMINATED, 0,
NULL, NULL, NULL);
return (re == NULL);
}"
. auto/feature
if [ $njs_found = no ]; then
# pcre2-config
if /bin/sh -c "(pcre2-config --version)" >> $NJS_AUTOCONF_ERR 2>&1; then
NJS_PCRE_CFLAGS=`pcre2-config --cflags`
NJS_PCRE_LIB=`pcre2-config --libs8`
njs_feature="PCRE2 library in `pcre2-config --prefix 2>/dev/null`"
njs_feature_incs=$NJS_PCRE_CFLAGS
njs_feature_libs=$NJS_PCRE_LIB
. auto/feature
fi
fi
if [ $njs_found = yes ]; then
njs_feature="PCRE2 version"
njs_feature_name=NJS_PCRE2_VERSION
njs_feature_run=value
njs_feature_test="#define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
#include <stdio.h>
int main(void) {
printf(\"%d.%d\", PCRE2_MAJOR, PCRE2_MINOR);
return 0;
}"
. auto/feature
NJS_HAVE_PCRE=YES
fi
fi
if [ $njs_found = no ]; then
njs_feature="PCRE library"
njs_feature_name=NJS_HAVE_PCRE
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <pcre.h>
int main(void) {
pcre *re;
re = pcre_compile(NULL, 0, NULL, 0, NULL);
if (re == NULL)
return 1;
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
# pcre-config
njs_pcre_prefix=`pcre-config --prefix 2>/dev/null`
if [ -n "$njs_pcre_prefix" ]; then
NJS_PCRE_CFLAGS=`pcre-config --cflags`
NJS_PCRE_LIB=`pcre-config --libs`
njs_feature="PCRE library in $njs_pcre_prefix"
njs_feature_incs="$NJS_PCRE_CFLAGS"
njs_feature_libs=$NJS_PCRE_LIB
. auto/feature
fi
fi
if [ $njs_found = yes ]; then
njs_feature="PCRE version"
njs_feature_name=NJS_PCRE_VERSION
njs_feature_run=value
njs_feature_test="#include <pcre.h>
#include <stdio.h>
int main(void) {
printf(\"%d.%d\", PCRE_MAJOR, PCRE_MINOR);
return 0;
}"
. auto/feature
NJS_HAVE_PCRE=YES
fi
fi
if [ $njs_found = no ]; then
echo
echo $0: error: no PCRE library found.
echo
exit 1;
fi
fi
NJS_LIB_AUX_CFLAGS="$NJS_LIB_AUX_CFLAGS $NJS_PCRE_CFLAGS"
NJS_LIB_AUX_LIBS="$NJS_LIB_AUX_LIBS $NJS_PCRE_LIB"

79
modules_deb/libnginx-mod-js-0.7.9/auto/readline
View file

@ -1,79 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
NJS_READLINE_LIB=
njs_found=no
njs_feature="GNU readline library"
njs_feature_name=NJS_HAVE_GNU_READLINE
njs_feature_run=no
njs_feature_incs=
njs_feature_libs="-lreadline"
njs_feature_test="#include <stdio.h>
#include <readline/readline.h>
#include <readline/history.h>
int main(void) {
add_history(NULL);
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
njs_feature="editline library in editline/readline.h"
njs_feature_name=NJS_HAVE_EDITLINE
njs_feature_libs="-ledit"
njs_feature_test="#include <stdio.h>
#include <editline/readline.h>
int main(void) {
add_history(NULL);
return 0;
}"
. auto/feature
fi
if [ $njs_found = no ]; then
# FreeBSD port
njs_feature_name=NJS_HAVE_EDIT_READLINE
njs_feature="editline in edit/readline/readline.h"
njs_feature_test="#include <stdio.h>
#include <edit/readline/readline.h>
int main(void) {
add_history(NULL);
return 0;
}"
. auto/feature
fi
if [ $njs_found = no ]; then
# NetBSD
njs_feature_name=NJS_HAVE_NETBSD_READLINE
njs_feature="editline in readline/readline.h"
njs_feature_test="#include <stdio.h>
#include <readline/readline.h>
int main(void) {
add_history(NULL);
return 0;
}"
. auto/feature
fi
if [ $njs_found = yes ]; then
NJS_HAVE_READLINE=YES
njs_define=NJS_HAVE_READLINE . auto/define
NJS_READLINE_LIB=$njs_feature_libs
else
NJS_HAVE_READLINE=NO
echo " - njs CLI is built without interactive shell support"
fi

84
modules_deb/libnginx-mod-js-0.7.9/auto/sources
View file

@ -1,84 +0,0 @@
NJS_LIB_SRCS=" \
src/njs_diyfp.c \
src/njs_dtoa.c \
src/njs_dtoa_fixed.c \
src/njs_str.c \
src/njs_strtod.c \
src/njs_murmur_hash.c \
src/njs_djb_hash.c \
src/njs_utf8.c \
src/njs_utf16.c \
src/njs_arr.c \
src/njs_rbtree.c \
src/njs_lvlhsh.c \
src/njs_trace.c \
src/njs_random.c \
src/njs_md5.c \
src/njs_sha1.c \
src/njs_sha2.c \
src/njs_time.c \
src/njs_file.c \
src/njs_malloc.c \
src/njs_mp.c \
src/njs_sprintf.c \
src/njs_utils.c \
src/njs_chb.c \
src/njs_value.c \
src/njs_vm.c \
src/njs_vmcode.c \
src/njs_boolean.c \
src/njs_number.c \
src/njs_symbol.c \
src/njs_string.c \
src/njs_object.c \
src/njs_object_prop.c \
src/njs_array.c \
src/njs_json.c \
src/njs_function.c \
src/njs_regexp.c \
src/njs_date.c \
src/njs_error.c \
src/njs_math.c \
src/njs_timer.c \
src/njs_module.c \
src/njs_event.c \
src/njs_extern.c \
src/njs_variable.c \
src/njs_builtin.c \
src/njs_lexer.c \
src/njs_lexer_keyword.c \
src/njs_parser.c \
src/njs_generator.c \
src/njs_disassembler.c \
src/njs_array_buffer.c \
src/njs_typed_array.c \
src/njs_promise.c \
src/njs_encoding.c \
src/njs_iterator.c \
src/njs_scope.c \
src/njs_async.c \
"
NJS_LIB_TEST_SRCS=" \
src/test/lvlhsh_unit_test.c \
src/test/random_unit_test.c \
src/test/rbtree_unit_test.c \
src/test/unicode_unit_test.c \
"
NJS_TEST_SRCS=" \
src/test/njs_unit_test.c \
src/test/njs_benchmark.c \
"
if [ "$NJS_PCRE" = "YES" ]; then
NJS_LIB_SRCS="$NJS_LIB_SRCS external/njs_regex.c"
fi
if [ "$NJS_HAVE_LIBBFD" = "YES" -a "$NJS_HAVE_DL_ITERATE_PHDR" = "YES" ]; then
NJS_LIB_SRCS="$NJS_LIB_SRCS src/njs_addr2line.c"
fi
NJS_TS_SRCS=$(find ts/ -name "*.d.ts" -o -name "*.json")
NJS_TEST_TS_SRCS=$(find test/ts/ -name "*.ts" -o -name "*.json")

58
modules_deb/libnginx-mod-js-0.7.9/auto/stat
View file

@ -1,58 +0,0 @@
# Copyright (C) Dmitry Volyntsev
# Copyright (C) NGINX, Inc.
njs_feature="stat.st_atimespec"
njs_feature_name=NJS_HAVE_STAT_ATIMESPEC
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <sys/stat.h>
int main(void) {
struct stat st;
if (fstat(0, &st) != 0) {
return 1;
}
return (int) st.st_atimespec.tv_sec;
}"
. auto/feature
njs_feature="stat.st_birthtim"
njs_feature_name=NJS_HAVE_STAT_BIRTHTIM
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <sys/stat.h>
int main(void) {
struct stat st;
if (fstat(0, &st) != 0) {
return 1;
}
return (int) st.st_birthtim.tv_sec;
}"
. auto/feature
njs_feature="stat.st_atim"
njs_feature_name=NJS_HAVE_STAT_ATIM
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <sys/stat.h>
int main(void) {
struct stat st;
if (fstat(0, &st) != 0) {
return 1;
}
return (int) st.st_atim.tv_sec;
}"
. auto/feature

34
modules_deb/libnginx-mod-js-0.7.9/auto/summary
View file

@ -1,34 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
echo
echo "NJS configuration summary:"
echo
echo " + using CC: \"$CC\""
echo " + using CFLAGS: \"$NJS_CFLAGS $NJS_CC_OPT $CFLAGS\""
echo
if [ $NJS_HAVE_PCRE = YES ]; then
echo " + using PCRE library: $NJS_PCRE_LIB"
fi
if [ $NJS_HAVE_READLINE = YES ]; then
echo " + using readline library: $NJS_READLINE_LIB"
fi
if [ $NJS_HAVE_OPENSSL = YES ]; then
echo " + using OpenSSL library: $NJS_OPENSSL_LIB"
fi
if [ $NJS_HAVE_COMPUTED_GOTO = YES ]; then
echo " + using computed goto"
fi
echo
echo " njs build dir: $NJS_BUILD_DIR"
echo " njs CLI: $NJS_BUILD_DIR/njs"
echo

70
modules_deb/libnginx-mod-js-0.7.9/auto/time
View file

@ -1,70 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
njs_feature="clock_gettime(CLOCK_MONOTONIC)"
njs_feature_name=NJS_HAVE_CLOCK_MONOTONIC
njs_feature_run=yes
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <time.h>
int main() {
struct timespec ts;
if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
return 1;
return 0;
}"
. auto/feature
if [ $njs_found = no ]; then
# Linux and Solaris 10 clock_gettime() are in librt.
njs_feature="clock_gettime(CLOCK_MONOTONIC) in librt"
njs_feature_libs="-lrt"
. auto/feature
if [ $njs_found = yes ]; then
NJS_LIBRT="-lrt"
fi
fi
# Linux, FreeBSD, MacOSX.
njs_feature="struct tm.tm_gmtoff"
njs_feature_name=NJS_HAVE_TM_GMTOFF
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <time.h>
int main(void) {
time_t t;
struct tm tm;
t = 0;
localtime_r(&t, &tm);
return tm.tm_gmtoff;
}"
. auto/feature
# Solaris
njs_feature="altzone"
njs_feature_name=NJS_HAVE_ALTZONE
njs_feature_run=no
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <time.h>
int main(void) {
altzone = 0;
return 0;
}"
. auto/feature

174
modules_deb/libnginx-mod-js-0.7.9/auto/types
View file

@ -1,174 +0,0 @@
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
# Sizes of C types.
# "-Wall -Werror" or similar constraints in default CFLAGS may require
# to use "%zu" format to printf() result of sizeof(). But "%zu" may
# be unavailable, so the "(int)" cast is a simple and portable solution:
# printf("%d", (int) sizeof(TYPE));
njs_feature="sizeof(int)"
njs_feature_name=NJS_INT_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <stdio.h>
int main() {
printf(\"%d\", (int) sizeof(int));
return 0;
}"
. auto/feature
njs_feature="sizeof(u_int)"
njs_feature_name=NJS_UINT_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <sys/types.h>
#include <stdio.h>
int main() {
printf(\"%d\", (int) sizeof(u_int));
return 0;
}"
. auto/feature
njs_feature="sizeof(void *)"
njs_feature_name=NJS_PTR_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <stdio.h>
int main() {
printf(\"%d\", (int) sizeof(void *));
return 0;
}"
. auto/feature
njs_feature="sizeof(uintptr_t)"
njs_feature_name=NJS_UINTPTR_T_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <stdint.h>
#include <stdio.h>
int main() {
printf(\"%d\", (int) sizeof(uintptr_t));
return 0;
}"
. auto/feature
case "$njs_feature_value" in
8) NJS_64BIT=1 ;;
*) NJS_64BIT=0 ;;
esac
njs_feature="sizeof(size_t)"
njs_feature_name=NJS_SIZE_T_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <stdio.h>
int main() {
printf(\"%d\", (int) sizeof(size_t));
return 0;
}"
. auto/feature
njs_feature="sizeof(off_t)"
njs_feature_name=NJS_OFF_T_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#define _FILE_OFFSET_BITS 64
#include <unistd.h>
#include <stdio.h>
int main() {
printf(\"%d\", (int) sizeof(off_t));
return 0;
}"
. auto/feature
njs_feature="sizeof(time_t)"
njs_feature_name=NJS_TIME_T_SIZE
njs_feature_run=value
njs_feature_incs=
njs_feature_libs=
njs_feature_test="#include <time.h>
#include <stdio.h>
int main(void) {
printf(\"%d\", (int) sizeof(time_t));
return 0;
}"
. auto/feature
# Ensuring that double type is always evaluated at standard
# precision required by njs_diyfp_t
case $NJS_CC_NAME in
gcc)
NJS_CFLAGS="$NJS_CFLAGS -fexcess-precision=standard"
;;
clang)
njs_found=no
njs_feature="flag -ffp-eval-method=double"
njs_feature_name=NJS_HAVE_FP_EVAL_METHOD
njs_feature_run=no
njs_feature_incs="-ffp-eval-method=double"
njs_feature_libs=
njs_feature_test="int main(void) {
return 0;
}"
. auto/feature
if [ $njs_found = yes ]; then
NJS_CFLAGS="$NJS_CFLAGS -ffp-eval-method=double"
fi
;;
SunC)
njs_found=no
njs_feature="flag -xarch=sse2"
njs_feature_name=NJS_HAVE_XARCH_SSE2
njs_feature_run=no
njs_feature_incs="-xarch=sse2"
njs_feature_libs=
njs_feature_test="int main(void) {
return 0;
}"
. auto/feature
if [ $njs_found = yes ]; then
NJS_CFLAGS="$NJS_CFLAGS -xarch=sse2"
fi
;;
esac

61
modules_deb/libnginx-mod-js-0.7.9/configure vendored
View file

@ -1,61 +0,0 @@
#!/bin/sh
# Copyright (C) Igor Sysoev
# Copyright (C) NGINX, Inc.
# Disable localized program messages.
LC_ALL=C
export LC_ALL
# Stop on error exit status.
set -e
# Stop on uninitialized variable.
set -u
. auto/init
. auto/options
NJS_AUTOTEST=$NJS_BUILD_DIR/autotest
NJS_AUTOCONF_ERR=$NJS_BUILD_DIR/autoconf.err
NJS_AUTO_CONFIG_H=$NJS_BUILD_DIR/njs_auto_config.h
NJS_MAKEFILE=$NJS_BUILD_DIR/Makefile
NJS_LIB_INCS="src $NJS_BUILD_DIR"
test -d $NJS_BUILD_DIR || mkdir $NJS_BUILD_DIR
> $NJS_AUTOCONF_ERR
cat << END > $NJS_AUTO_CONFIG_H
/* This file is auto-generated by configure */
END
NJS_LIBS="$NJS_LIBRT"
NJS_LIB_AUX_CFLAGS=
NJS_LIB_AUX_LIBS=
. auto/os
. auto/cc
. auto/types
. auto/endianness
. auto/clang
. auto/time
. auto/memalign
. auto/getrandom
. auto/stat
. auto/computed_goto
. auto/explicit_bzero
. auto/pcre
. auto/readline
. auto/openssl
. auto/libbfd
. auto/link
. auto/sources
. auto/modules
. auto/make
. auto/expect
. auto/summary

16
modules_deb/libnginx-mod-js-0.7.9/debian/changelog
View file

@ -1,16 +0,0 @@
libnginx-mod-js (0.7.9-2) unstable; urgency=medium
* Team upload.
* d/rules: configure: remove --no-pcre2
* d/control: bump Standards-Version: 4.6.2, no changes
* d/gbb.conf: switched to debian branch main (debian-branch = main)
* d/copyright: updated to be compatible with 'cme update dpkg-copyright'
* NEW ABI: rebuild with nginx-abi-1.22.1-7
-- Jan Mojžíš <jan.mojzis@gmail.com> Mon, 13 Feb 2023 12:56:52 +0100
libnginx-mod-js (0.7.9-1) unstable; urgency=medium
* Initial release. (Closes: 1025998)
-- Jérémy Lal <kapouer@melix.org> Tue, 20 Dec 2022 17:21:11 +0100

56
modules_deb/libnginx-mod-js-0.7.9/debian/control
View file

@ -1,56 +0,0 @@
Source: libnginx-mod-js
Section: httpd
Priority: optional
Maintainer: Debian Nginx Maintainers <pkg-nginx-maintainers@alioth-lists.debian.net>
Uploaders: Jérémy Lal <kapouer@melix.org>,
Build-Depends: debhelper-compat (= 13),
dh-sequence-nginx,
help2man,
libnginx-mod-stream (<<1.22.1.1~),
libnginx-mod-stream (>=1.22.1),
nginx-abi-1.22.1-7,
Standards-Version: 4.6.2
Homepage: https://nginx.org/en/docs/njs/
Vcs-Git: https://salsa.debian.org/nginx-team/libnginx-mod-js.git
Vcs-Browser: https://salsa.debian.org/nginx-team/libnginx-mod-js
Rules-Requires-Root: no
Package: libnginx-mod-http-js
Architecture: any
Depends: ${misc:Depends},
${shlibs:Depends},
Recommends: nginx,
Description: JavaScript HTTP module for Nginx
This module extends Nginx with configuration directives
that allows one to run a subset of ECMAScript 5.1 (and later
extensions) language.
It features integration with
- response body filter
- location content handler
- http, server, location variables
Package: libnginx-mod-stream-js
Architecture: any
Depends: libnginx-mod-stream (<<1.22.1.1~),
libnginx-mod-stream (>=1.22.1),
${misc:Depends},
${shlibs:Depends},
Recommends: nginx,
Description: JavaScript Stream module for Nginx
This module extends Nginx with configuration directives
that allows one to run a subset of ECMAScript 5.1 (and later
extensions) language.
It features integration with
- the access phase
- the content phase
- stream, server variables
Package: njs
Architecture: any
Depends: ${misc:Depends},
${shlibs:Depends},
Description: JavaScript for Nginx command-line utility
Run and debug scripts written for libnginx-mod-stream-js and
libnginx-mod-http-js Nginx modules.
This command is independent of Nginx and does not run inside it,
in consequence, HTTP and Stream objects are not available.

378
modules_deb/libnginx-mod-js-0.7.9/debian/copyright
View file

@ -1,378 +0,0 @@
Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
Files: *
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: auto/*
Copyright: NGINX, Inc.
Igor Sysoev
License: BSD-2-clause
Files: auto/computed_goto
Copyright: Vadim Zhestikov
NGINX, Inc.
License: BSD-2-clause
Files: auto/endianness
auto/expect
auto/init
auto/libbfd
auto/link
auto/module
auto/modules
auto/openssl
auto/readline
auto/stat
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: auto/sources
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: configure
Copyright: NGINX, Inc.
Igor Sysoev
License: BSD-2-clause
Files: external/*
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: external/njs_query_string_module.c
Copyright: NGINX, Inc.
Dmitry Volyntsev
Alexander Borisov
License: BSD-2-clause
Files: external/njs_regex.c
Copyright: NGINX, Inc.
Igor Sysoev
Dmitry Volyntsev
License: BSD-2-clause
Files: nginx/*
Copyright: Roman Arutyunyan
NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: nginx/config
Copyright: Roman Arutyunyan
License: BSD-2-clause
Files: nginx/ngx_js_fetch.c
Copyright: hongzhidao
NGINX, Inc.
Dmitry Volyntsev
Antoine Bonavita
License: BSD-2-clause
Files: nginx/ngx_js_fetch.h
nginx/ngx_js_regex.c
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: src/*
Copyright: NGINX, Inc.
Igor Sysoev
License: BSD-2-clause
Files: src/njs.pc.in
src/njs_md5.c
src/njs_unicode_lower_case.h
src/njs_unicode_lower_case.pl
src/njs_unicode_upper_case.h
src/njs_unicode_upper_case.pl
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: src/njs_addr2line.c
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: GPL-2+
Files: src/njs_addr2line.h
src/njs_dtoa.h
src/njs_dtoa_fixed.h
src/njs_strtod.h
Copyright: Nginx, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: src/njs_assert.h
src/njs_chb.c
src/njs_chb.h
src/njs_diyfp.c
src/njs_diyfp.h
src/njs_error.c
src/njs_error.h
src/njs_event.c
src/njs_event.h
src/njs_generator.h
src/njs_json.c
src/njs_json.h
src/njs_main.h
src/njs_module.c
src/njs_object_prop_declare.h
src/njs_sha2.c
src/njs_sha2.h
src/njs_shell.c
src/njs_str.c
src/njs_timer.c
src/njs_timer.h
src/njs_unix.h
src/njs_utils.c
src/njs_utils.h
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: src/njs_async.c
src/njs_async.h
src/njs_promise.c
Copyright: Nginx, Inc.
Alexander Borisov
License: BSD-2-clause
Files: src/njs_buffer.c
Copyright: NGINX, Inc.
Dmitry Volyntsev
Alexander Borisov
License: BSD-2-clause
Files: src/njs_buffer.h
src/njs_encoding.c
src/njs_encoding.h
src/njs_scope.c
src/njs_scope.h
src/njs_unicode.h
src/njs_utf16.c
src/njs_utf16.h
Copyright: NGINX, Inc.
Alexander Borisov
License: BSD-2-clause
Files: src/njs_builtin.c
src/njs_typed_array.c
src/njs_variable.c
Copyright: NGINX, Inc.
Igor Sysoev
Dmitry Volyntsev
License: BSD-2-clause
Files: src/njs_dtoa.c
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: Expat
Files: src/njs_dtoa_fixed.c
Copyright: NGINX, Inc.
Dmitry Volyntsev
2011, the V8 project authors.
License: BSD-3-clause
Files: src/njs_generator.c
Copyright: NGINX, Inc.
Igor Sysoev
Dmitry Volyntsev
Alexander Borisov
License: BSD-2-clause
Files: src/njs_iterator.c
src/njs_iterator.h
Copyright: NGINX, Inc.
Artem S. Povalyukhin
License: BSD-2-clause
Files: src/njs_lexer_keyword.c
Copyright: NGINX, Inc.
License: BSD-2-clause
Files: src/njs_lexer_tables.h
src/njs_promise.h
Copyright: Nginx, Inc.
License: BSD-2-clause
Files: src/njs_md5.h
Copyright: Nginx, Inc.
Igor Sysoev
License: BSD-2-clause
Files: src/njs_module.h
Copyright: NGINX, Inc.
Dmitry Volynsev
License: BSD-2-clause
Files: src/njs_murmur_hash.c
Copyright: Austin Appleby
License: public-domain
The code is based on the code by Austin Appleby,
released to the public domain.
Files: src/njs_parser.c
src/njs_parser.h
Copyright: NGINX, Inc.
Igor Sysoev
Alexander Borisov
License: BSD-2-clause
Files: src/njs_sha1.c
Copyright: NGINX, Inc.
Maxim Dounin
License: BSD-2-clause
Files: src/njs_strtod.c
Copyright: 2012, the V8 project authors.
License: BSD-3-clause
Files: src/test/njs_externals_test.c
src/test/njs_externals_test.h
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: test/*
Copyright: NGINX, Inc.
Dmitry Volyntsev
License: BSD-2-clause
Files: test/fs/*
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: test/harness/*
Copyright: 2012, 2017, Ecma International.
License: BSD-3-clause
Files: test/inputrc
test/script_args.js
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: test/js/*
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: test/ts/*
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: test/webcrypto/*
Copyright: 2019-2022, Alexander Borisov
2017-2022, Dmitry Volyntsev
2015-2022, NGINX, Inc.
2015-2021, Igor Sysoev
License: BSD-2-clause
Files: utils/*
Copyright: Nginx, Inc.
License: BSD-2-clause
License: BSD-2-clause
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
License: BSD-3-clause
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
.
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following
disclaimer in the documentation and/or other materials provided
with the distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
License: Expat
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the Software
without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to
whom the Software is furnished to do so, subject to the
following conditions:
.
The above copyright notice and this permission notice shall
be included in all copies or substantial portions of the
Software.
.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT
WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
License: GPL-2+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 dated June, 1991, or (at
your option) any later version.
On Debian systems, the complete text of version 2 of the GNU General
Public License can be found in '/usr/share/common-licenses/GPL-2'.

9
modules_deb/libnginx-mod-js-0.7.9/debian/gbp.conf
View file

@ -1,9 +0,0 @@
[DEFAULT]
debian-branch = main
upstream-branch = upstream
upstream-tag = upstream/%(version)s
pristine-tar = True
sign-tags = True
[import-orig]
merge-mode = replace

1
modules_deb/libnginx-mod-js-0.7.9/debian/libnginx-mod-http-js.install
View file

@ -1 +0,0 @@
/usr/lib/nginx/modules/ngx_http_js_module.so

1
modules_deb/libnginx-mod-js-0.7.9/debian/libnginx-mod-stream-js.install
View file

@ -1 +0,0 @@
/usr/lib/nginx/modules/ngx_stream_js_module.so

1
modules_deb/libnginx-mod-js-0.7.9/debian/njs.install
View file

@ -1 +0,0 @@
./build/njs /usr/bin

1
modules_deb/libnginx-mod-js-0.7.9/debian/njs.manpages
View file

@ -1 +0,0 @@
build/njs.1

30
modules_deb/libnginx-mod-js-0.7.9/debian/rules
View file

@ -1,30 +0,0 @@
#!/usr/bin/make -f
export DEB_BUILD_MAINT_OPTIONS = hardening=+all
# nginx_mod needs to find the modules source dir using sourcedirectory
# nginx_mod calls doit_in_builddir but without builddirectory,
# it tries to chdir from sourcedirectory and fails
%:
dh $@ --sourcedirectory=nginx --builddirectory=build-modules
override_dh_auto_configure:
./configure \
--cc-opt="$(shell dpkg-buildflags --get CFLAGS) -fPIC $(shell dpkg-buildflags --get CPPFLAGS)" \
--ld-opt="$(shell dpkg-buildflags --get LDFLAGS)"
dh_auto_configure --buildsystem=nginx_mod -- --with-stream
override_dh_auto_build-arch:
make
dh_auto_build --buildsystem=nginx_mod
help2man --no-info --version-option=-v --help-option=-h --name='JavaScript for Nginx' ./build/njs -o build/njs.1
override_dh_auto_test:
dh_auto_test --buildsystem=nginx_mod -- ngx_stream_module.so
override_dh_auto_clean:
rm -f Makefile
rm -rf build
rm -rf build-modules

1
modules_deb/libnginx-mod-js-0.7.9/debian/source/format
View file

@ -1 +0,0 @@
3.0 (quilt)

2
modules_deb/libnginx-mod-js-0.7.9/debian/source/lintian-overrides
View file

@ -1,2 +0,0 @@
# false positive
source-is-missing [test/js/import_very_long_path.t.js]

16
modules_deb/libnginx-mod-js-0.7.9/debian/tests/control
View file

@ -1,16 +0,0 @@
Tests: generic
Restrictions: allow-stderr isolation-container needs-root
Depends: curl,
nginx,
nginx-core,
@,
Tests: helloworld
Restrictions: allow-stderr isolation-container needs-root
Depends: curl,
nginx,
nginx-core,
@,
Test-Command: njs -v
Depends: njs,

73
modules_deb/libnginx-mod-js-0.7.9/debian/tests/generic
View file

@ -1,73 +0,0 @@
#!/bin/sh
# version 20221215
# generic test that only verifies that nginx is running with the given
# libnginx-... module
# - after installation
# - after nginx reload
# - after nginx restart
EX=0
CURL_CMD="curl --max-time 60 --silent --fail -o /dev/null"
#change directory to $AUTOPKGTEST_TMP
cd "${AUTOPKGTEST_TMP}"
echo -n "curl after installation: http status="
if $CURL_CMD -w "response_code: %{http_code}, ... " http://127.0.0.1/; then
echo "OK"
else
EX=1
echo "FAILED"
fi
echo -n "nginx reload ... "
if invoke-rc.d nginx reload; then
echo "OK"
else
EX=1
echo "FAILED"
fi
sleep 5
echo -n "curl after reload: http status="
if $CURL_CMD -w "response_code: %{http_code}, ... " http://127.0.0.1/; then
echo "OK"
else
EX=1
echo "FAILED"
fi
echo -n "nginx restart ... "
if invoke-rc.d nginx restart; then
echo "OK"
else
EX=1
echo "FAILED"
fi
sleep 5
echo -n "curl after restart: http status="
if $CURL_CMD -w "response_code: %{http_code}, ... " http://127.0.0.1/; then
echo "OK"
else
EX=1
echo "FAILED"
fi
if [ ${EX} -ne 0 ]; then
echo "=== journalctl ==="
journalctl -n all -xu nginx.service || :
echo "=== error.log ==="
if [ `wc -l /var/log/nginx/error.log | cut -d ' ' -f1` -gt 100 ]; then
head -n 50 /var/log/nginx/error.log
echo '...'
tail -n 50 /var/log/nginx/error.log
else
cat /var/log/nginx/error.log
fi
fi
exit ${EX}

42
modules_deb/libnginx-mod-js-0.7.9/debian/tests/helloworld
View file

@ -1,42 +0,0 @@
#!/bin/sh
set -e
cat <<EOF > '/etc/nginx/sites-enabled/default'
server {
listen 80 default_server;
location /helloworld {
js_path "/etc/nginx/njs/";
js_import hello.js;
js_content hello.hello;
}
}
EOF
mkdir -p '/etc/nginx/njs'
cat <<EOF > "/etc/nginx/njs/hello.js"
function hello(r) {
r.return(200, "Hello world!\n");
}
export default {hello}
EOF
exp="Hello world!
response_code: 200"
nginx -t
invoke-rc.d nginx restart || { journalctl -n all -xu nginx.service; exit 1; }
out=`curl --fail -w "response_code: %{http_code}\n" http://127.0.0.1/helloworld`
if [ x"${out}" != x"${exp}" ]; then
echo "output:"
echo "====================="
echo "${out}"
echo "====================="
echo "expected output:"
echo "====================="
echo "${exp}"
echo "====================="
exit 1
fi

4
modules_deb/libnginx-mod-js-0.7.9/debian/watch
View file

@ -1,4 +0,0 @@
version=4
opts="filenamemangle=s%(?:.*?)?v?(\d[\d.]*@ARCHIVE_EXT@)%@PACKAGE@-$1%" \
https://github.com/nginx/njs/tags \
(?:.*?/)?v?@ANY_VERSION@@ARCHIVE_EXT@

658
modules_deb/libnginx-mod-js-0.7.9/external/njs_crypto_module.c vendored
View file

@ -1,658 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
typedef void (*njs_hash_init)(void *ctx);
typedef void (*njs_hash_update)(void *ctx, const void *data, size_t size);
typedef void (*njs_hash_final)(u_char *result, void *ctx);
typedef njs_int_t (*njs_digest_encode)(njs_vm_t *vm, njs_value_t *value,
const njs_str_t *src);
typedef struct {
njs_str_t name;
size_t size;
njs_hash_init init;
njs_hash_update update;
njs_hash_final final;
} njs_hash_alg_t;
typedef struct {
union {
njs_md5_t md5;
njs_sha1_t sha1;
njs_sha2_t sha2;
} u;
njs_hash_alg_t *alg;
} njs_digest_t;
typedef struct {
u_char opad[64];
union {
njs_md5_t md5;
njs_sha1_t sha1;
njs_sha2_t sha2;
} u;
njs_hash_alg_t *alg;
} njs_hmac_t;
typedef struct {
njs_str_t name;
njs_digest_encode encode;
} njs_crypto_enc_t;
static njs_hash_alg_t *njs_crypto_algorithm(njs_vm_t *vm,
const njs_value_t *value);
static njs_crypto_enc_t *njs_crypto_encoding(njs_vm_t *vm,
const njs_value_t *value);
static njs_int_t njs_buffer_digest(njs_vm_t *vm, njs_value_t *value,
const njs_str_t *src);
static njs_int_t njs_crypto_create_hash(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused);
static njs_int_t njs_hash_prototype_update(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t hmac);
static njs_int_t njs_hash_prototype_digest(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t hmac);
static njs_int_t njs_crypto_create_hmac(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused);
static njs_int_t njs_crypto_init(njs_vm_t *vm);
static njs_hash_alg_t njs_hash_algorithms[] = {
{
njs_str("md5"),
16,
(njs_hash_init) njs_md5_init,
(njs_hash_update) njs_md5_update,
(njs_hash_final) njs_md5_final
},
{
njs_str("sha1"),
20,
(njs_hash_init) njs_sha1_init,
(njs_hash_update) njs_sha1_update,
(njs_hash_final) njs_sha1_final
},
{
njs_str("sha256"),
32,
(njs_hash_init) njs_sha2_init,
(njs_hash_update) njs_sha2_update,
(njs_hash_final) njs_sha2_final
},
{
njs_null_str,
0,
NULL,
NULL,
NULL
}
};
static njs_crypto_enc_t njs_encodings[] = {
{
njs_str("buffer"),
njs_buffer_digest
},
{
njs_str("hex"),
njs_string_hex
},
{
njs_str("base64"),
njs_string_base64
},
{
njs_str("base64url"),
njs_string_base64url
},
{
njs_null_str,
NULL
}
};
static njs_external_t njs_ext_crypto_hash[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "Hash",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("update"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_hash_prototype_update,
.magic8 = 0,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("digest"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_hash_prototype_digest,
.magic8 = 0,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("constructor"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_crypto_create_hash,
}
},
};
static njs_external_t njs_ext_crypto_hmac[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "Hmac",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("update"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_hash_prototype_update,
.magic8 = 1,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("digest"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_hash_prototype_digest,
.magic8 = 1,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("constructor"),
.writable = 1,
.configurable = 1,
.u.method = {
.native = njs_crypto_create_hmac,
.magic8 = 0,
}
},
};
static njs_external_t njs_ext_crypto_crypto[] = {
{
.flags = NJS_EXTERN_PROPERTY | NJS_EXTERN_SYMBOL,
.name.symbol = NJS_SYMBOL_TO_STRING_TAG,
.u.property = {
.value = "crypto",
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("createHash"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = njs_crypto_create_hash,
.magic8 = 0,
}
},
{
.flags = NJS_EXTERN_METHOD,
.name.string = njs_str("createHmac"),
.writable = 1,
.configurable = 1,
.enumerable = 1,
.u.method = {
.native = njs_crypto_create_hmac,
.magic8 = 0,
}
},
};
static njs_int_t njs_crypto_hash_proto_id;
static njs_int_t njs_crypto_hmac_proto_id;
njs_module_t njs_crypto_module = {
.name = njs_str("crypto"),
.init = njs_crypto_init,
};
static njs_int_t
njs_crypto_create_hash(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_digest_t *dgst;
njs_hash_alg_t *alg;
alg = njs_crypto_algorithm(vm, njs_arg(args, nargs, 1));
if (njs_slow_path(alg == NULL)) {
return NJS_ERROR;
}
dgst = njs_mp_alloc(vm->mem_pool, sizeof(njs_digest_t));
if (njs_slow_path(dgst == NULL)) {
njs_memory_error(vm);
return NJS_ERROR;
}
dgst->alg = alg;
alg->init(&dgst->u);
return njs_vm_external_create(vm, &vm->retval, njs_crypto_hash_proto_id,
dgst, 0);
}
static njs_int_t
njs_hash_prototype_update(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t hmac)
{
njs_str_t data;
njs_int_t ret;
njs_hmac_t *ctx;
njs_value_t *this, dst;
njs_digest_t *dgst;
njs_typed_array_t *array;
const njs_value_t *value;
njs_array_buffer_t *buffer;
const njs_buffer_encoding_t *encoding;
this = njs_argument(args, 0);
if (!hmac) {
dgst = njs_vm_external(vm, njs_crypto_hash_proto_id, this);
if (njs_slow_path(dgst == NULL)) {
njs_type_error(vm, "\"this\" is not a hash object");
return NJS_ERROR;
}
if (njs_slow_path(dgst->alg == NULL)) {
njs_error(vm, "Digest already called");
return NJS_ERROR;
}
ctx = NULL;
} else {
ctx = njs_vm_external(vm, njs_crypto_hmac_proto_id, this);
if (njs_slow_path(ctx == NULL)) {
njs_type_error(vm, "\"this\" is not a hmac object");
return NJS_ERROR;
}
if (njs_slow_path(ctx->alg == NULL)) {
njs_error(vm, "Digest already called");
return NJS_ERROR;
}
dgst = NULL;
}
value = njs_arg(args, nargs, 1);
switch (value->type) {
case NJS_STRING:
encoding = njs_buffer_encoding(vm, njs_arg(args, nargs, 2));
if (njs_slow_path(encoding == NULL)) {
return NJS_ERROR;
}
ret = njs_buffer_decode_string(vm, value, &dst, encoding);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
njs_string_get(&dst, &data);
break;
case NJS_TYPED_ARRAY:
case NJS_DATA_VIEW:
array = njs_typed_array(value);
buffer = array->buffer;
if (njs_slow_path(njs_is_detached_buffer(buffer))) {
njs_type_error(vm, "detached buffer");
return NJS_ERROR;
}
data.start = &buffer->u.u8[array->offset];
data.length = array->byte_length;
break;
default:
njs_type_error(vm, "data argument \"%s\" is not a string "
"or Buffer-like object", njs_type_string(value->type));
return NJS_ERROR;
}
if (!hmac) {
dgst->alg->update(&dgst->u, data.start, data.length);
} else {
ctx->alg->update(&ctx->u, data.start, data.length);
}
vm->retval = *this;
return NJS_OK;
}
static njs_int_t
njs_hash_prototype_digest(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t hmac)
{
njs_str_t str;
njs_hmac_t *ctx;
njs_value_t *this;
njs_digest_t *dgst;
njs_hash_alg_t *alg;
njs_crypto_enc_t *enc;
u_char hash1[32], digest[32];
this = njs_argument(args, 0);
if (!hmac) {
dgst = njs_vm_external(vm, njs_crypto_hash_proto_id, this);
if (njs_slow_path(dgst == NULL)) {
njs_type_error(vm, "\"this\" is not a hash object");
return NJS_ERROR;
}
if (njs_slow_path(dgst->alg == NULL)) {
goto exception;
}
ctx = NULL;
} else {
ctx = njs_vm_external(vm, njs_crypto_hmac_proto_id, this);
if (njs_slow_path(ctx == NULL)) {
njs_type_error(vm, "\"this\" is not a hmac object");
return NJS_ERROR;
}
if (njs_slow_path(ctx->alg == NULL)) {
goto exception;
}
dgst = NULL;
}
enc = njs_crypto_encoding(vm, njs_arg(args, nargs, 1));
if (njs_slow_path(enc == NULL)) {
return NJS_ERROR;
}
if (!hmac) {
alg = dgst->alg;
alg->final(digest, &dgst->u);
dgst->alg = NULL;
} else {
alg = ctx->alg;
alg->final(hash1, &ctx->u);
alg->init(&ctx->u);
alg->update(&ctx->u, ctx->opad, 64);
alg->update(&ctx->u, hash1, alg->size);
alg->final(digest, &ctx->u);
ctx->alg = NULL;
}
str.start = digest;
str.length = alg->size;
return enc->encode(vm, &vm->retval, &str);
exception:
njs_error(vm, "Digest already called");
return NJS_ERROR;
}
static njs_int_t
njs_crypto_create_hmac(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_str_t key;
njs_uint_t i;
njs_hmac_t *ctx;
njs_hash_alg_t *alg;
njs_typed_array_t *array;
const njs_value_t *value;
njs_array_buffer_t *buffer;
u_char digest[32], key_buf[64];
alg = njs_crypto_algorithm(vm, njs_arg(args, nargs, 1));
if (njs_slow_path(alg == NULL)) {
return NJS_ERROR;
}
value = njs_arg(args, nargs, 2);
switch (value->type) {
case NJS_STRING:
njs_string_get(value, &key);
break;
case NJS_TYPED_ARRAY:
case NJS_DATA_VIEW:
array = njs_typed_array(value);
buffer = array->buffer;
if (njs_slow_path(njs_is_detached_buffer(buffer))) {
njs_type_error(vm, "detached buffer");
return NJS_ERROR;
}
key.start = &buffer->u.u8[array->offset];
key.length = array->byte_length;
break;
default:
njs_type_error(vm, "key argument \"%s\" is not a string "
"or Buffer-like object", njs_type_string(value->type));
return NJS_ERROR;
}
ctx = njs_mp_alloc(vm->mem_pool, sizeof(njs_hmac_t));
if (njs_slow_path(ctx == NULL)) {
njs_memory_error(vm);
return NJS_ERROR;
}
ctx->alg = alg;
if (key.length > sizeof(key_buf)) {
alg->init(&ctx->u);
alg->update(&ctx->u, key.start, key.length);
alg->final(digest, &ctx->u);
memcpy(key_buf, digest, alg->size);
njs_explicit_memzero(key_buf + alg->size, sizeof(key_buf) - alg->size);
} else {
memcpy(key_buf, key.start, key.length);
njs_explicit_memzero(key_buf + key.length,
sizeof(key_buf) - key.length);
}
for (i = 0; i < 64; i++) {
ctx->opad[i] = key_buf[i] ^ 0x5c;
}
for (i = 0; i < 64; i++) {
key_buf[i] ^= 0x36;
}
alg->init(&ctx->u);
alg->update(&ctx->u, key_buf, 64);
return njs_vm_external_create(vm, &vm->retval, njs_crypto_hmac_proto_id,
ctx, 0);
}
static njs_hash_alg_t *
njs_crypto_algorithm(njs_vm_t *vm, const njs_value_t *value)
{
njs_str_t name;
njs_hash_alg_t *e;
if (njs_slow_path(!njs_is_string(value))) {
njs_type_error(vm, "algorithm must be a string");
return NULL;
}
njs_string_get(value, &name);
for (e = &njs_hash_algorithms[0]; e->name.length != 0; e++) {
if (njs_strstr_eq(&name, &e->name)) {
return e;
}
}
njs_type_error(vm, "not supported algorithm: \"%V\"", &name);
return NULL;
}
static njs_crypto_enc_t *
njs_crypto_encoding(njs_vm_t *vm, const njs_value_t *value)
{
njs_str_t name;
njs_crypto_enc_t *e;
if (njs_slow_path(!njs_is_string(value))) {
if (njs_is_defined(value)) {
njs_type_error(vm, "encoding must be a string");
return NULL;
}
return &njs_encodings[0];
}
njs_string_get(value, &name);
for (e = &njs_encodings[1]; e->name.length != 0; e++) {
if (njs_strstr_eq(&name, &e->name)) {
return e;
}
}
njs_type_error(vm, "Unknown digest encoding: \"%V\"", &name);
return NULL;
}
static njs_int_t
njs_buffer_digest(njs_vm_t *vm, njs_value_t *value, const njs_str_t *src)
{
return njs_buffer_new(vm, value, src->start, src->length);
}
static njs_int_t
njs_crypto_init(njs_vm_t *vm)
{
njs_int_t ret, proto_id;
njs_mod_t *module;
njs_opaque_value_t value;
njs_crypto_hash_proto_id =
njs_vm_external_prototype(vm, njs_ext_crypto_hash,
njs_nitems(njs_ext_crypto_hash));
if (njs_slow_path(njs_crypto_hash_proto_id < 0)) {
return NJS_ERROR;
}
njs_crypto_hmac_proto_id =
njs_vm_external_prototype(vm, njs_ext_crypto_hmac,
njs_nitems(njs_ext_crypto_hmac));
if (njs_slow_path(njs_crypto_hmac_proto_id < 0)) {
return NJS_ERROR;
}
proto_id = njs_vm_external_prototype(vm, njs_ext_crypto_crypto,
njs_nitems(njs_ext_crypto_crypto));
if (njs_slow_path(proto_id < 0)) {
return NJS_ERROR;
}
ret = njs_vm_external_create(vm, njs_value_arg(&value), proto_id, NULL, 1);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
module = njs_module_add(vm, &njs_str_value("crypto"));
if (njs_slow_path(module == NULL)) {
return NJS_ERROR;
}
njs_value_assign(&module->value, &value);
module->function.native = 1;
return NJS_OK;
}

3774
modules_deb/libnginx-mod-js-0.7.9/external/njs_fs_module.c vendored
View file

File diff suppressed because it is too large Load diff

59
modules_deb/libnginx-mod-js-0.7.9/external/njs_openssl.h vendored
View file

@ -1,59 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_EXTERNAL_OPENSSL_H_INCLUDED_
#define _NJS_EXTERNAL_OPENSSL_H_INCLUDED_
#define OPENSSL_SUPPRESS_DEPRECATED
#include <openssl/bn.h>
#include <openssl/bio.h>
#include <openssl/x509.h>
#include <openssl/evp.h>
#include <openssl/aes.h>
#include <openssl/rsa.h>
#include <openssl/err.h>
#include <openssl/rand.h>
#include <openssl/hmac.h>
#include <openssl/crypto.h>
#ifdef EVP_PKEY_HKDF
#include <openssl/kdf.h>
#endif
#if (defined LIBRESSL_VERSION_NUMBER && OPENSSL_VERSION_NUMBER == 0x20000000L)
#undef OPENSSL_VERSION_NUMBER
#if (LIBRESSL_VERSION_NUMBER >= 0x2080000fL)
#define OPENSSL_VERSION_NUMBER 0x1010000fL
#else
#define OPENSSL_VERSION_NUMBER 0x1000107fL
#endif
#endif
#if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
#define njs_evp_md_ctx_new() EVP_MD_CTX_new()
#define njs_evp_md_ctx_free(_ctx) EVP_MD_CTX_free(_ctx)
#else
#define njs_evp_md_ctx_new() EVP_MD_CTX_create()
#define njs_evp_md_ctx_free(_ctx) EVP_MD_CTX_destroy(_ctx)
#define ECDSA_SIG_get0_s(sig) (sig)->s
#define ECDSA_SIG_get0_r(sig) (sig)->r
#endif
#define njs_bio_new_mem_buf(b, len) BIO_new_mem_buf((void *) b, len)
#if (OPENSSL_VERSION_NUMBER < 0x30000000L && !defined ERR_peek_error_data)
#define ERR_peek_error_data(d, f) ERR_peek_error_line_data(NULL, NULL, d, f)
#endif
#endif /* _NJS_EXTERNAL_OPENSSL_H_INCLUDED_ */

1010
modules_deb/libnginx-mod-js-0.7.9/external/njs_query_string_module.c vendored
View file

File diff suppressed because it is too large Load diff

646
modules_deb/libnginx-mod-js-0.7.9/external/njs_regex.c vendored
View file

@ -1,646 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
#ifdef NJS_HAVE_PCRE2
#define PCRE2_CODE_UNIT_WIDTH 8
#include <pcre2.h>
static const u_char* njs_regex_pcre2_error(int errcode, u_char buffer[128]);
#else
#include <pcre.h>
static void *njs_pcre_malloc(size_t size);
static void njs_pcre_free(void *p);
static njs_regex_generic_ctx_t *regex_context;
#endif
njs_regex_generic_ctx_t *
njs_regex_generic_ctx_create(njs_pcre_malloc_t private_malloc,
njs_pcre_free_t private_free, void *memory_data)
{
#ifdef NJS_HAVE_PCRE2
return pcre2_general_context_create(private_malloc, private_free,
memory_data);
#else
njs_regex_generic_ctx_t *ctx;
ctx = private_malloc(sizeof(njs_regex_generic_ctx_t), memory_data);
if (njs_fast_path(ctx != NULL)) {
ctx->private_malloc = private_malloc;
ctx->private_free = private_free;
ctx->memory_data = memory_data;
}
return ctx;
#endif
}
njs_regex_compile_ctx_t *
njs_regex_compile_ctx_create(njs_regex_generic_ctx_t *ctx)
{
#ifdef NJS_HAVE_PCRE2
pcre2_compile_context *cc;
cc = pcre2_compile_context_create(ctx);
#ifdef PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES
if (njs_fast_path(cc != NULL)) {
/* Workaround for surrogate pairs in regular expressions
*
* This option is needed because njs, unlike the standard ECMAScript,
* stores and processes strings in UTF-8 encoding.
* PCRE2 does not support surrogate pairs by default when it
* is compiled for UTF-8 only strings. But many polyfills
* and transpilers use such surrogate pairs expressions.
*/
pcre2_set_compile_extra_options(cc,
PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES);
}
#endif
return cc;
#else
return ctx;
#endif
}
njs_int_t
njs_regex_escape(njs_mp_t *mp, njs_str_t *text)
{
#ifdef NJS_HAVE_PCRE2
return NJS_OK;
#else
/*
* 1) PCRE with PCRE_JAVASCRIPT_COMPAT flag rejects regexps with
* lone closing square brackets as invalid. Whereas according
* to ES6: 11.8.5 it is a valid regexp expression.
*
* 2) escaping zero byte characters as "\u0000".
*
* Escaping it here as a workaround.
*/
size_t brackets, zeros;
u_char *p, *dst, *start, *end;
njs_bool_t in;
start = text->start;
end = text->start + text->length;
in = 0;
zeros = 0;
brackets = 0;
for (p = start; p < end; p++) {
switch (*p) {
case '[':
in = 1;
break;
case ']':
if (!in) {
brackets++;
}
in = 0;
break;
case '\\':
p++;
if (p == end || *p != '\0') {
break;
}
/* Fall through. */
case '\0':
zeros++;
break;
}
}
if (!brackets && !zeros) {
return NJS_OK;
}
text->length = text->length + brackets + zeros * njs_length("\\u0000");
text->start = njs_mp_alloc(mp, text->length);
if (njs_slow_path(text->start == NULL)) {
return NJS_ERROR;
}
in = 0;
dst = text->start;
for (p = start; p < end; p++) {
switch (*p) {
case '[':
in = 1;
break;
case ']':
if (!in) {
*dst++ = '\\';
}
in = 0;
break;
case '\\':
*dst++ = *p++;
if (p == end) {
goto done;
}
if (*p != '\0') {
break;
}
/* Fall through. */
case '\0':
dst = njs_cpymem(dst, "\\u0000", 6);
continue;
}
*dst++ = *p;
}
done:
text->length = dst - text->start;
return NJS_OK;
#endif
}
njs_int_t
njs_regex_compile(njs_regex_t *regex, u_char *source, size_t len,
njs_regex_flags_t flags, njs_regex_compile_ctx_t *cctx, njs_trace_t *trace)
{
#ifdef NJS_HAVE_PCRE2
int ret;
u_char *error;
size_t erroff;
njs_uint_t options;
u_char errstr[128];
options = PCRE2_ALT_BSUX | PCRE2_MATCH_UNSET_BACKREF;
if ((flags & NJS_REGEX_IGNORE_CASE)) {
options |= PCRE2_CASELESS;
}
if ((flags & NJS_REGEX_MULTILINE)) {
options |= PCRE2_MULTILINE;
}
if ((flags & NJS_REGEX_STICKY)) {
options |= PCRE2_ANCHORED;
}
if ((flags & NJS_REGEX_UTF8)) {
options |= PCRE2_UTF;
}
regex->code = pcre2_compile(source, len, options, &ret, &erroff, cctx);
if (njs_slow_path(regex->code == NULL)) {
error = &source[erroff];
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre_compile2(\"%s\") failed: %s at \"%s\"",
source, njs_regex_pcre2_error(ret, errstr), error);
return NJS_DECLINED;
}
ret = pcre2_pattern_info(regex->code, PCRE2_INFO_CAPTURECOUNT,
&regex->ncaptures);
if (njs_slow_path(ret < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre2_pattern_info(\"%s\", PCRE2_INFO_CAPTURECOUNT) failed: %s",
source, njs_regex_pcre2_error(ret, errstr));
return NJS_ERROR;
}
ret = pcre2_pattern_info(regex->code, PCRE2_INFO_BACKREFMAX,
&regex->backrefmax);
if (njs_slow_path(ret < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre2_pattern_info(\"%s\", PCRE2_INFO_BACKREFMAX) failed: %s",
source, njs_regex_pcre2_error(ret, errstr));
return NJS_ERROR;
}
/* Reserve additional elements for the first "$0" capture. */
regex->ncaptures++;
if (regex->ncaptures > 1) {
ret = pcre2_pattern_info(regex->code, PCRE2_INFO_NAMECOUNT,
&regex->nentries);
if (njs_slow_path(ret < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre2_pattern_info(\"%s\", PCRE2_INFO_NAMECOUNT) failed: %s",
source, njs_regex_pcre2_error(ret, errstr));
return NJS_ERROR;
}
if (regex->nentries != 0) {
ret = pcre2_pattern_info(regex->code, PCRE2_INFO_NAMEENTRYSIZE,
&regex->entry_size);
if (njs_slow_path(ret < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre2_pattern_info(\"%s\", PCRE2_INFO_NAMEENTRYSIZE)"
" failed: %s", source,
njs_regex_pcre2_error(ret, errstr));
return NJS_ERROR;
}
ret = pcre2_pattern_info(regex->code, PCRE2_INFO_NAMETABLE,
&regex->entries);
if (njs_slow_path(ret < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre2_pattern_info(\"%s\", PCRE2_INFO_NAMETABLE) "
"failed: %s", source,
njs_regex_pcre2_error(ret, errstr));
return NJS_ERROR;
}
}
}
return NJS_OK;
#else
int ret, err, erroff;
char *pattern, *error;
void *(*saved_malloc)(size_t size);
void (*saved_free)(void *p);
njs_uint_t options;
const char *errstr;
njs_regex_generic_ctx_t *ctx;
ctx = cctx;
ret = NJS_ERROR;
saved_malloc = pcre_malloc;
pcre_malloc = njs_pcre_malloc;
saved_free = pcre_free;
pcre_free = njs_pcre_free;
regex_context = ctx;
#ifdef PCRE_JAVASCRIPT_COMPAT
/* JavaScript compatibility has been introduced in PCRE-7.7. */
options = PCRE_JAVASCRIPT_COMPAT;
#else
options = 0;
#endif
if ((flags & NJS_REGEX_IGNORE_CASE)) {
options |= PCRE_CASELESS;
}
if ((flags & NJS_REGEX_MULTILINE)) {
options |= PCRE_MULTILINE;
}
if ((flags & NJS_REGEX_STICKY)) {
options |= PCRE_ANCHORED;
}
if ((flags & NJS_REGEX_UTF8)) {
options |= PCRE_UTF8;
}
pattern = (char *) source;
regex->code = pcre_compile(pattern, options, &errstr, &erroff, NULL);
if (njs_slow_path(regex->code == NULL)) {
error = pattern + erroff;
if (*error != '\0') {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre_compile(\"%s\") failed: %s at \"%s\"",
pattern, errstr, error);
} else {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre_compile(\"%s\") failed: %s", pattern, errstr);
}
ret = NJS_DECLINED;
goto done;
}
regex->extra = pcre_study(regex->code, 0, &errstr);
if (njs_slow_path(errstr != NULL)) {
njs_alert(trace, NJS_LEVEL_WARN,
"pcre_study(\"%s\") failed: %s", pattern, errstr);
}
err = pcre_fullinfo(regex->code, NULL, PCRE_INFO_CAPTURECOUNT,
&regex->ncaptures);
if (njs_slow_path(err < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre_fullinfo(\"%s\", PCRE_INFO_CAPTURECOUNT) failed: %d",
pattern, err);
goto done;
}
err = pcre_fullinfo(regex->code, NULL, PCRE_INFO_BACKREFMAX,
&regex->backrefmax);
if (njs_slow_path(err < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre_fullinfo(\"%s\", PCRE_INFO_BACKREFMAX) failed: %d",
pattern, err);
goto done;
}
/* Reserve additional elements for the first "$0" capture. */
regex->ncaptures++;
if (regex->ncaptures > 1) {
err = pcre_fullinfo(regex->code, NULL, PCRE_INFO_NAMECOUNT,
&regex->nentries);
if (njs_slow_path(err < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR,
"pcre_fullinfo(\"%s\", PCRE_INFO_NAMECOUNT) failed: %d",
pattern, err);
goto done;
}
if (regex->nentries != 0) {
err = pcre_fullinfo(regex->code, NULL, PCRE_INFO_NAMEENTRYSIZE,
&regex->entry_size);
if (njs_slow_path(err < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR, "pcre_fullinfo(\"%s\", "
"PCRE_INFO_NAMEENTRYSIZE) failed: %d", pattern, err);
goto done;
}
err = pcre_fullinfo(regex->code, NULL, PCRE_INFO_NAMETABLE,
&regex->entries);
if (njs_slow_path(err < 0)) {
njs_alert(trace, NJS_LEVEL_ERROR, "pcre_fullinfo(\"%s\", "
"PCRE_INFO_NAMETABLE) failed: %d", pattern, err);
goto done;
}
}
}
ret = NJS_OK;
done:
pcre_malloc = saved_malloc;
pcre_free = saved_free;
regex_context = NULL;
return ret;
#endif
}
njs_bool_t
njs_regex_is_valid(njs_regex_t *regex)
{
return (regex->code != NULL);
}
njs_int_t
njs_regex_named_captures(njs_regex_t *regex, njs_str_t *name, int n)
{
char *entry;
if (name == NULL) {
return regex->nentries;
}
if (n >= regex->nentries) {
return NJS_ERROR;
}
entry = regex->entries + regex->entry_size * n;
name->start = (u_char *) entry + 2;
name->length = njs_strlen(name->start);
return (entry[0] << 8) + entry[1];
}
njs_regex_match_data_t *
njs_regex_match_data(njs_regex_t *regex, njs_regex_generic_ctx_t *ctx)
{
#ifdef NJS_HAVE_PCRE2
if (regex != NULL) {
return pcre2_match_data_create_from_pattern(regex->code, ctx);
}
return pcre2_match_data_create(0, ctx);
#else
size_t size;
njs_uint_t ncaptures;
njs_regex_match_data_t *match_data;
if (regex != NULL) {
ncaptures = regex->ncaptures - 1;
} else {
ncaptures = 0;
}
/* Each capture is stored in 3 "int" vector elements. */
ncaptures *= 3;
size = sizeof(njs_regex_match_data_t) + ncaptures * sizeof(int);
match_data = ctx->private_malloc(size, ctx->memory_data);
if (njs_fast_path(match_data != NULL)) {
match_data->ncaptures = ncaptures + 3;
}
return match_data;
#endif
}
void
njs_regex_match_data_free(njs_regex_match_data_t *match_data,
njs_regex_generic_ctx_t *ctx)
{
#ifdef NJS_HAVE_PCRE2
pcre2_match_data_free(match_data);
#else
ctx->private_free(match_data, ctx->memory_data);
#endif
}
njs_int_t
njs_regex_match(njs_regex_t *regex, const u_char *subject, size_t off,
size_t len, njs_regex_match_data_t *match_data, njs_trace_t *trace)
{
#ifdef NJS_HAVE_PCRE2
int ret;
u_char errstr[128];
ret = pcre2_match(regex->code, subject, len, off, 0, match_data, NULL);
if (ret < 0) {
if (ret == PCRE2_ERROR_NOMATCH) {
return NJS_DECLINED;
}
njs_alert(trace, NJS_LEVEL_ERROR, "pcre2_match() failed: %s",
njs_regex_pcre2_error(ret, errstr));
return NJS_ERROR;
}
return ret;
#else
int ret;
ret = pcre_exec(regex->code, regex->extra, (const char *) subject, len,
off, 0, match_data->captures, match_data->ncaptures);
if (ret <= PCRE_ERROR_NOMATCH) {
if (ret == PCRE_ERROR_NOMATCH) {
return NJS_DECLINED;
}
njs_alert(trace, NJS_LEVEL_ERROR, "pcre_exec() failed: %d", ret);
return NJS_ERROR;
}
return ret;
#endif
}
size_t
njs_regex_capture(njs_regex_match_data_t *match_data, njs_uint_t n)
{
#ifdef NJS_HAVE_PCRE2
size_t c;
c = pcre2_get_ovector_pointer(match_data)[n];
if (c == PCRE2_UNSET) {
return NJS_REGEX_UNSET;
}
return c;
#else
return match_data->captures[n];
#endif
}
#ifdef NJS_HAVE_PCRE2
static const u_char *
njs_regex_pcre2_error(int errcode, u_char buffer[128])
{
pcre2_get_error_message(errcode, buffer, 128);
return buffer;
}
#else
static void *
njs_pcre_malloc(size_t size)
{
return regex_context->private_malloc(size, regex_context->memory_data);
}
static void
njs_pcre_free(void *p)
{
regex_context->private_free(p, regex_context->memory_data);
}
#endif

2934
modules_deb/libnginx-mod-js-0.7.9/external/njs_webcrypto_module.c vendored
View file

File diff suppressed because it is too large Load diff

34
modules_deb/libnginx-mod-js-0.7.9/nginx/config
View file

@ -1,34 +0,0 @@
ngx_addon_name="ngx_js_module"
NJS_DEPS="$ngx_addon_dir/ngx_js.h \
$ngx_addon_dir/ngx_js_fetch.h"
NJS_SRCS="$ngx_addon_dir/ngx_js.c \
$ngx_addon_dir/ngx_js_fetch.c \
$ngx_addon_dir/ngx_js_regex.c \
$ngx_addon_dir/../external/njs_webcrypto_module.c"
if [ $HTTP != NO ]; then
ngx_module_type=HTTP_AUX_FILTER
ngx_module_name=ngx_http_js_module
ngx_module_incs="$ngx_addon_dir/../src $ngx_addon_dir/../build"
ngx_module_deps="$ngx_addon_dir/../build/libnjs.a $NJS_DEPS"
ngx_module_srcs="$ngx_addon_dir/ngx_http_js_module.c $NJS_SRCS"
ngx_module_libs="PCRE OPENSSL $ngx_addon_dir/../build/libnjs.a -lm"
. auto/module
if [ "$ngx_module_link" != DYNAMIC ]; then
NJS_SRCS=
fi
fi
if [ $STREAM != NO ]; then
ngx_module_type=STREAM
ngx_module_name=ngx_stream_js_module
ngx_module_incs="$ngx_addon_dir/../src $ngx_addon_dir/../build"
ngx_module_deps="$ngx_addon_dir/../build/libnjs.a $NJS_DEPS"
ngx_module_srcs="$ngx_addon_dir/ngx_stream_js_module.c $NJS_SRCS"
ngx_module_libs="PCRE OPENSSL $ngx_addon_dir/../build/libnjs.a -lm"
. auto/module
fi

9
modules_deb/libnginx-mod-js-0.7.9/nginx/config.make
View file

@ -1,9 +0,0 @@
cat << END >> $NGX_MAKEFILE
$ngx_addon_dir/../build/libnjs.a: $NGX_MAKEFILE
cd $ngx_addon_dir/.. \\
&& if [ -f build/Makefile ]; then \$(MAKE) clean; fi \\
&& CFLAGS="\$(CFLAGS)" CC="\$(CC)" ./configure --no-openssl --no-pcre \\
&& \$(MAKE) libnjs
END

4441
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_http_js_module.c
View file

File diff suppressed because it is too large Load diff

1133
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_js.c
View file

File diff suppressed because it is too large Load diff

154
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_js.h
View file

@ -1,154 +0,0 @@
/*
* Copyright (C) Roman Arutyunyan
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NGX_JS_H_INCLUDED_
#define _NGX_JS_H_INCLUDED_
#include <ngx_config.h>
#include <ngx_core.h>
#include <njs.h>
#define NGX_JS_UNSET 0
#define NGX_JS_DEPRECATED 1
#define NGX_JS_STRING 2
#define NGX_JS_BUFFER 4
#define NGX_JS_BOOLEAN 8
#define NGX_JS_NUMBER 16
#define NGX_JS_BOOL_FALSE 0
#define NGX_JS_BOOL_TRUE 1
#define NGX_JS_BOOL_UNSET 2
#define ngx_js_buffer_type(btype) ((btype) & ~NGX_JS_DEPRECATED)
typedef ngx_pool_t *(*ngx_external_pool_pt)(njs_vm_t *vm, njs_external_ptr_t e);
typedef void (*ngx_js_event_handler_pt)(njs_external_ptr_t e,
njs_vm_event_t vm_event, njs_value_t *args, njs_uint_t nargs);
typedef ngx_resolver_t *(*ngx_external_resolver_pt)(njs_vm_t *vm,
njs_external_ptr_t e);
typedef ngx_msec_t (*ngx_external_timeout_pt)(njs_vm_t *vm,
njs_external_ptr_t e);
typedef ngx_flag_t (*ngx_external_flag_pt)(njs_vm_t *vm,
njs_external_ptr_t e);
typedef ngx_flag_t (*ngx_external_size_pt)(njs_vm_t *vm,
njs_external_ptr_t e);
typedef ngx_ssl_t *(*ngx_external_ssl_pt)(njs_vm_t *vm, njs_external_ptr_t e);
typedef struct {
ngx_str_t name;
ngx_str_t path;
u_char *file;
ngx_uint_t line;
} ngx_js_named_path_t;
#define _NGX_JS_COMMON_CONF \
njs_vm_t *vm; \
ngx_array_t *imports; \
ngx_array_t *paths; \
\
njs_vm_t *preload_vm; \
ngx_array_t *preload_objects; \
\
size_t buffer_size; \
size_t max_response_body_size; \
ngx_msec_t timeout
#if defined(NGX_HTTP_SSL) || defined(NGX_STREAM_SSL)
#define NGX_JS_COMMON_CONF \
_NGX_JS_COMMON_CONF; \
\
ngx_ssl_t *ssl; \
ngx_str_t ssl_ciphers; \
ngx_uint_t ssl_protocols; \
ngx_flag_t ssl_verify; \
ngx_int_t ssl_verify_depth; \
ngx_str_t ssl_trusted_certificate
#else
#define NGX_JS_COMMON_CONF _NGX_JS_COMMON_CONF
#endif
typedef struct {
NGX_JS_COMMON_CONF;
} ngx_js_conf_t;
#define ngx_external_connection(vm, e) \
(*((ngx_connection_t **) ((u_char *) (e) + njs_vm_meta(vm, 0))))
#define ngx_external_pool(vm, e) \
((ngx_external_pool_pt) njs_vm_meta(vm, 1))(vm, e)
#define ngx_external_resolver(vm, e) \
((ngx_external_resolver_pt) njs_vm_meta(vm, 2))(vm, e)
#define ngx_external_resolver_timeout(vm, e) \
((ngx_external_timeout_pt) njs_vm_meta(vm, 3))(vm, e)
#define ngx_external_event_handler(vm, e) \
((ngx_js_event_handler_pt) njs_vm_meta(vm, 4))
#define ngx_external_ssl(vm, e) \
((ngx_external_ssl_pt) njs_vm_meta(vm, 5))(vm, e)
#define ngx_external_ssl_verify(vm, e) \
((ngx_external_flag_pt) njs_vm_meta(vm, 6))(vm, e)
#define ngx_external_fetch_timeout(vm, e) \
((ngx_external_timeout_pt) njs_vm_meta(vm, 7))(vm, e)
#define ngx_external_buffer_size(vm, e) \
((ngx_external_size_pt) njs_vm_meta(vm, 8))(vm, e)
#define ngx_external_max_response_buffer_size(vm, e) \
((ngx_external_size_pt) njs_vm_meta(vm, 9))(vm, e)
#define ngx_js_prop(vm, type, value, start, len) \
((type == NGX_JS_STRING) ? njs_vm_value_string_set(vm, value, start, len) \
: njs_vm_value_buffer_set(vm, value, start, len))
ngx_int_t ngx_js_call(njs_vm_t *vm, ngx_str_t *fname, ngx_log_t *log,
njs_opaque_value_t *args, njs_uint_t nargs);
ngx_int_t ngx_js_retval(njs_vm_t *vm, njs_opaque_value_t *retval,
ngx_str_t *s);
njs_int_t ngx_js_ext_log(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t level);
void ngx_js_logger(njs_vm_t *vm, njs_external_ptr_t external,
njs_log_level_t level, const u_char *start, size_t length);
char * ngx_js_import(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
char * ngx_js_preload_object(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
ngx_int_t ngx_js_init_preload_vm(ngx_conf_t *cf, ngx_js_conf_t *conf);
ngx_int_t ngx_js_merge_vm(ngx_conf_t *cf, ngx_js_conf_t *conf,
ngx_js_conf_t *prev,
ngx_int_t (*init_vm)(ngx_conf_t *cf, ngx_js_conf_t *conf));
ngx_int_t ngx_js_init_conf_vm(ngx_conf_t *cf, ngx_js_conf_t *conf,
njs_vm_opt_t *options,
ngx_int_t (*externals_init)(ngx_conf_t *cf, ngx_js_conf_t *conf));
ngx_js_conf_t *ngx_js_create_conf(ngx_conf_t *cf, size_t size);
char * ngx_js_merge_conf(ngx_conf_t *cf, void *parent, void *child,
ngx_int_t (*init_vm)(ngx_conf_t *cf, ngx_js_conf_t *conf));
njs_int_t ngx_js_ext_string(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval);
njs_int_t ngx_js_ext_uint(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval);
njs_int_t ngx_js_ext_constant(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval);
njs_int_t ngx_js_ext_flags(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval);
ngx_int_t ngx_js_core_init(njs_vm_t *vm, ngx_log_t *log);
ngx_int_t ngx_js_string(njs_vm_t *vm, njs_value_t *value, njs_str_t *str);
ngx_int_t ngx_js_integer(njs_vm_t *vm, njs_value_t *value, ngx_int_t *n);
extern njs_module_t *njs_js_addon_modules[];
#endif /* _NGX_JS_H_INCLUDED_ */

2464
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_js_fetch.c
View file

File diff suppressed because it is too large Load diff

18
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_js_fetch.h
View file

@ -1,18 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NGX_JS_FETCH_H_INCLUDED_
#define _NGX_JS_FETCH_H_INCLUDED_
njs_int_t ngx_js_ext_fetch(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t level);
ngx_int_t ngx_js_fetch_init(njs_vm_t *vm, ngx_log_t *log);
#endif /* _NGX_JS_FETCH_H_INCLUDED_ */

16
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_js_regex.c
View file

@ -1,16 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#include <ngx_config.h>
#if (NGX_PCRE2)
#define NJS_HAVE_PCRE2 1
#endif
#include "../external/njs_regex.c"

1897
modules_deb/libnginx-mod-js-0.7.9/nginx/ngx_stream_js_module.c
View file

File diff suppressed because it is too large Load diff

504
modules_deb/libnginx-mod-js-0.7.9/src/njs.h
View file

@ -1,504 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*
* njs public header.
*/
#ifndef _NJS_H_INCLUDED_
#define _NJS_H_INCLUDED_
#include <njs_auto_config.h>
#define NJS_VERSION "0.7.9"
#define NJS_VERSION_NUMBER 0x000709
#include <unistd.h> /* STDOUT_FILENO, STDERR_FILENO */
#include <njs_types.h>
#include <njs_clang.h>
#include <njs_str.h>
#include <njs_unicode.h>
#include <njs_utf8.h>
#include <njs_mp.h>
#include <njs_chb.h>
#include <njs_lvlhsh.h>
#include <njs_sprintf.h>
typedef uintptr_t njs_index_t;
typedef struct njs_vm_s njs_vm_t;
typedef struct njs_mod_s njs_mod_t;
typedef union njs_value_s njs_value_t;
typedef struct njs_function_s njs_function_t;
typedef struct njs_vm_shared_s njs_vm_shared_t;
typedef struct njs_object_prop_s njs_object_prop_t;
typedef struct njs_external_s njs_external_t;
/*
* njs_opaque_value_t is the external storage type for native njs_value_t type.
* sizeof(njs_opaque_value_t) == sizeof(njs_value_t).
*/
typedef struct {
uint64_t filler[2];
} njs_opaque_value_t;
typedef enum {
NJS_LOG_LEVEL_ERROR = 4,
NJS_LOG_LEVEL_WARN = 5,
NJS_LOG_LEVEL_INFO = 7,
} njs_log_level_t;
/* sizeof(njs_value_t) is 16 bytes. */
#define njs_argument(args, n) \
(njs_value_t *) ((u_char *) args + (n) * 16)
extern const njs_value_t njs_value_undefined;
#define njs_arg(args, nargs, n) \
((n < nargs) ? njs_argument(args, n) \
: (njs_value_t *) &njs_value_undefined)
#define njs_value_assign(dst, src) \
memcpy(dst, src, sizeof(njs_opaque_value_t))
#define njs_value_arg(val) ((njs_value_t *) val)
#define njs_lvalue_arg(lvalue, args, nargs, n) \
((n < nargs) ? njs_argument(args, n) \
: (njs_value_assign(lvalue, &njs_value_undefined), lvalue))
#define njs_vm_error(vm, fmt, ...) \
njs_vm_value_error_set(vm, njs_vm_retval(vm), fmt, ##__VA_ARGS__)
#define njs_vm_log(vm, fmt, ...) njs_vm_logger(vm, NJS_LOG_LEVEL_INFO, fmt, \
##__VA_ARGS__)
#define njs_vm_warn(vm, fmt, ...) njs_vm_logger(vm, NJS_LOG_LEVEL_WARN, fmt, \
##__VA_ARGS__)
#define njs_vm_err(vm, fmt, ...) njs_vm_logger(vm, NJS_LOG_LEVEL_ERROR, fmt, \
##__VA_ARGS__)
#define njs_deprecated(vm, text) \
do { \
static njs_bool_t reported; \
\
if (!reported) { \
njs_vm_warn(vm, text " is deprecated " \
"and will be removed in the future"); \
reported = 1; \
} \
} while(0)
/*
* njs_prop_handler_t operates as a property getter/setter or delete handler.
* - retval != NULL && setval == NULL - GET context.
* - retval != NULL && setval != NULL - SET context.
* - retval == NULL - DELETE context.
*
* njs_prop_handler_t is expected to return:
* NJS_OK - handler executed successfully;
* NJS_DECLINED - handler was applied to inappropriate object, retval
* contains undefined value;
* NJS_ERROR - some error, vm->retval contains appropriate exception.
*/
typedef njs_int_t (*njs_prop_handler_t) (njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval);
typedef njs_int_t (*njs_exotic_keys_t)(njs_vm_t *vm, njs_value_t *value,
njs_value_t *retval);
typedef njs_int_t (*njs_function_native_t) (njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t magic8);
typedef enum {
NJS_SYMBOL_INVALID,
NJS_SYMBOL_ASYNC_ITERATOR,
NJS_SYMBOL_HAS_INSTANCE,
NJS_SYMBOL_IS_CONCAT_SPREADABLE,
NJS_SYMBOL_ITERATOR,
NJS_SYMBOL_MATCH,
NJS_SYMBOL_MATCH_ALL,
NJS_SYMBOL_REPLACE,
NJS_SYMBOL_SEARCH,
NJS_SYMBOL_SPECIES,
NJS_SYMBOL_SPLIT,
NJS_SYMBOL_TO_PRIMITIVE,
NJS_SYMBOL_TO_STRING_TAG,
NJS_SYMBOL_UNSCOPABLES,
NJS_SYMBOL_KNOWN_MAX,
} njs_wellknown_symbol_t;
typedef enum {
NJS_EXTERN_PROPERTY = 0,
NJS_EXTERN_METHOD = 1,
NJS_EXTERN_OBJECT = 2,
NJS_EXTERN_SYMBOL = 4,
} njs_extern_flag_t;
typedef enum {
NJS_EXTERN_TYPE_INT = 0,
NJS_EXTERN_TYPE_UINT = 1,
NJS_EXTERN_TYPE_VALUE = 2,
} njs_extern_type_t;
struct njs_external_s {
njs_extern_flag_t flags;
union {
njs_str_t string;
uint32_t symbol;
} name;
unsigned writable;
unsigned configurable;
unsigned enumerable;
union {
struct {
const char value[15]; /* NJS_STRING_SHORT + 1. */
njs_prop_handler_t handler;
uint16_t magic16;
uint32_t magic32;
} property;
struct {
njs_function_native_t native;
uint8_t magic8;
uint8_t ctor;
} method;
struct {
njs_external_t *properties;
njs_uint_t nproperties;
unsigned writable;
unsigned configurable;
unsigned enumerable;
njs_prop_handler_t prop_handler;
uint32_t magic32;
njs_exotic_keys_t keys;
} object;
} u;
};
/*
* NJS and event loops.
*
* njs_vm_ops_t callbacks are used to interact with the event loop environment.
*
* Functions get an external object as the first argument. The external
* object is provided as the third argument to njs_vm_clone().
*
* The callbacks are expected to return to the VM the unique id of an
* underlying event. This id will be passed as the second argument to
* njs_event_destructor() at the moment the VM wants to destroy it.
*
* When an underlying events fires njs_vm_post_event() should be invoked with
* the value provided as vm_event.
*
* The events posted by njs_vm_post_event() are processed as soon as
* njs_vm_run() is invoked. njs_vm_run() returns NJS_AGAIN until pending events
* are present.
*/
typedef void * njs_vm_event_t;
typedef void * njs_host_event_t;
typedef void * njs_external_ptr_t;
typedef njs_host_event_t (*njs_set_timer_t)(njs_external_ptr_t external,
uint64_t delay, njs_vm_event_t vm_event);
typedef void (*njs_event_destructor_t)(njs_external_ptr_t external,
njs_host_event_t event);
typedef njs_mod_t *(*njs_module_loader_t)(njs_vm_t *vm,
njs_external_ptr_t external, njs_str_t *name);
typedef void (*njs_logger_t)(njs_vm_t *vm, njs_external_ptr_t external,
njs_log_level_t level, const u_char *start, size_t length);
typedef struct {
njs_set_timer_t set_timer;
njs_event_destructor_t clear_timer;
njs_module_loader_t module_loader;
njs_logger_t logger;
} njs_vm_ops_t;
typedef struct {
size_t size;
uintptr_t *values;
} njs_vm_meta_t;
typedef njs_int_t (*njs_addon_init_pt)(njs_vm_t *vm);
typedef struct {
njs_str_t name;
njs_addon_init_pt init;
} njs_module_t;
typedef struct {
njs_external_ptr_t external;
njs_vm_shared_t *shared;
njs_vm_ops_t *ops;
njs_vm_meta_t *metas;
njs_module_t **addons;
njs_str_t file;
char **argv;
njs_uint_t argc;
njs_uint_t max_stack_size;
njs_log_level_t log_level;
#define NJS_VM_OPT_UNHANDLED_REJECTION_IGNORE 0
#define NJS_VM_OPT_UNHANDLED_REJECTION_THROW 1
/*
* interactive - enables "interactive" mode.
* (REPL). Allows starting parent VM without cloning.
* disassemble - enables disassemble.
* backtrace - enables backtraces.
* quiet - removes filenames from backtraces. To produce comparable
test262 diffs.
* sandbox - "sandbox" mode. Disables file access.
* unsafe - enables unsafe language features:
* - Function constructors.
* module - ES6 "module" mode. Script mode is default.
* ast - print AST.
* unhandled_rejection IGNORE | THROW - tracks unhandled promise rejections:
* - throwing inside a Promise without a catch block.
* - throwing inside in a finally or catch block.
*/
uint8_t interactive; /* 1 bit */
uint8_t trailer; /* 1 bit */
uint8_t init; /* 1 bit */
uint8_t disassemble; /* 1 bit */
uint8_t backtrace; /* 1 bit */
uint8_t quiet; /* 1 bit */
uint8_t sandbox; /* 1 bit */
uint8_t unsafe; /* 1 bit */
uint8_t module; /* 1 bit */
uint8_t ast; /* 1 bit */
#ifdef NJS_DEBUG_OPCODE
uint8_t opcode_debug; /* 1 bit */
#endif
#ifdef NJS_DEBUG_GENERATOR
uint8_t generator_debug; /* 1 bit */
#endif
uint8_t unhandled_rejection;
} njs_vm_opt_t;
NJS_EXPORT void njs_vm_opt_init(njs_vm_opt_t *options);
NJS_EXPORT njs_vm_t *njs_vm_create(njs_vm_opt_t *options);
NJS_EXPORT void njs_vm_destroy(njs_vm_t *vm);
NJS_EXPORT njs_int_t njs_vm_compile(njs_vm_t *vm, u_char **start, u_char *end);
NJS_EXPORT njs_mod_t *njs_vm_compile_module(njs_vm_t *vm, njs_str_t *name,
u_char **start, u_char *end);
NJS_EXPORT njs_vm_t *njs_vm_clone(njs_vm_t *vm, njs_external_ptr_t external);
NJS_EXPORT njs_vm_event_t njs_vm_add_event(njs_vm_t *vm,
njs_function_t *function, njs_uint_t once, njs_host_event_t host_ev,
njs_event_destructor_t destructor);
NJS_EXPORT void njs_vm_del_event(njs_vm_t *vm, njs_vm_event_t vm_event);
NJS_EXPORT njs_int_t njs_vm_post_event(njs_vm_t *vm, njs_vm_event_t vm_event,
const njs_value_t *args, njs_uint_t nargs);
/*
* Returns 1 if async events are present.
*/
NJS_EXPORT njs_int_t njs_vm_waiting(njs_vm_t *vm);
/*
* Returns 1 if posted events are ready to be executed.
*/
NJS_EXPORT njs_int_t njs_vm_posted(njs_vm_t *vm);
#define njs_vm_pending(vm) (njs_vm_waiting(vm) || njs_vm_posted(vm))
#define njs_vm_unhandled_rejection(vm) \
((vm)->options.unhandled_rejection == NJS_VM_OPT_UNHANDLED_REJECTION_THROW \
&& (vm)->promise_reason != NULL && (vm)->promise_reason->length != 0)
/*
* Runs the specified function with provided arguments.
* NJS_OK successful run.
* NJS_ERROR some exception or internal error happens.
*
* njs_vm_retval(vm) can be used to get the retval or exception value.
*/
NJS_EXPORT njs_int_t njs_vm_call(njs_vm_t *vm, njs_function_t *function,
const njs_value_t *args, njs_uint_t nargs);
NJS_EXPORT njs_int_t njs_vm_invoke(njs_vm_t *vm, njs_function_t *function,
const njs_value_t *args, njs_uint_t nargs, njs_value_t *retval);
/*
* Runs posted events.
* NJS_OK successfully processed all posted events, no more events.
* NJS_AGAIN successfully processed all events, some posted events are
* still pending.
* NJS_ERROR some exception or internal error happens.
* njs_vm_retval(vm) can be used to get the retval or exception value.
*/
NJS_EXPORT njs_int_t njs_vm_run(njs_vm_t *vm);
/*
* Runs the global code.
* NJS_OK successful run.
* NJS_ERROR some exception or internal error happens.
*
* njs_vm_retval(vm) can be used to get the retval or exception value.
*/
NJS_EXPORT njs_int_t njs_vm_start(njs_vm_t *vm);
NJS_EXPORT njs_int_t njs_vm_add_path(njs_vm_t *vm, const njs_str_t *path);
#define NJS_PROTO_ID_ANY (-1)
NJS_EXPORT njs_int_t njs_vm_external_prototype(njs_vm_t *vm,
const njs_external_t *definition, njs_uint_t n);
NJS_EXPORT njs_int_t njs_vm_external_create(njs_vm_t *vm, njs_value_t *value,
njs_int_t proto_id, njs_external_ptr_t external, njs_bool_t shared);
NJS_EXPORT njs_external_ptr_t njs_vm_external(njs_vm_t *vm,
njs_int_t proto_id, const njs_value_t *value);
NJS_EXPORT njs_int_t njs_external_property(njs_vm_t *vm,
njs_object_prop_t *prop, njs_value_t *value, njs_value_t *setval,
njs_value_t *retval);
NJS_EXPORT uintptr_t njs_vm_meta(njs_vm_t *vm, njs_uint_t index);
NJS_EXPORT njs_function_t *njs_vm_function_alloc(njs_vm_t *vm,
njs_function_native_t native);
NJS_EXPORT void njs_disassembler(njs_vm_t *vm);
NJS_EXPORT njs_int_t njs_vm_bind(njs_vm_t *vm, const njs_str_t *var_name,
const njs_value_t *value, njs_bool_t shared);
NJS_EXPORT njs_int_t njs_vm_value(njs_vm_t *vm, const njs_str_t *path,
njs_value_t *retval);
NJS_EXPORT njs_function_t *njs_vm_function(njs_vm_t *vm, const njs_str_t *name);
NJS_EXPORT njs_value_t *njs_vm_retval(njs_vm_t *vm);
NJS_EXPORT void njs_vm_retval_set(njs_vm_t *vm, const njs_value_t *value);
NJS_EXPORT njs_mp_t *njs_vm_memory_pool(njs_vm_t *vm);
/* Gets string value, no copy. */
NJS_EXPORT void njs_value_string_get(njs_value_t *value, njs_str_t *dst);
/*
* Sets a byte string value.
* start data is not copied and should not be freed.
*/
NJS_EXPORT njs_int_t njs_vm_value_string_set(njs_vm_t *vm, njs_value_t *value,
const u_char *start, uint32_t size);
NJS_EXPORT u_char *njs_vm_value_string_alloc(njs_vm_t *vm, njs_value_t *value,
uint32_t size);
NJS_EXPORT njs_int_t njs_vm_value_string_copy(njs_vm_t *vm, njs_str_t *retval,
njs_value_t *value, uintptr_t *next);
NJS_EXPORT njs_int_t njs_vm_value_array_buffer_set(njs_vm_t *vm,
njs_value_t *value, const u_char *start, uint32_t size);
/*
* Sets a Buffer value.
* start data is not copied and should not be freed.
*/
NJS_EXPORT njs_int_t njs_vm_value_buffer_set(njs_vm_t *vm, njs_value_t *value,
const u_char *start, uint32_t size);
/*
* Converts a value to bytes.
*/
NJS_EXPORT njs_int_t njs_vm_value_to_bytes(njs_vm_t *vm, njs_str_t *dst,
njs_value_t *src);
/*
* Converts a value to string.
*/
NJS_EXPORT njs_int_t njs_vm_value_to_string(njs_vm_t *vm, njs_str_t *dst,
njs_value_t *src);
/*
* Calls njs_vm_value_to_string(), if exception was thrown adds backtrace.
*/
NJS_EXPORT njs_int_t njs_vm_value_string(njs_vm_t *vm, njs_str_t *dst,
njs_value_t *src);
NJS_EXPORT njs_int_t njs_vm_retval_string(njs_vm_t *vm, njs_str_t *dst);
NJS_EXPORT njs_int_t njs_vm_value_dump(njs_vm_t *vm, njs_str_t *dst,
njs_value_t *value, njs_uint_t console, njs_uint_t indent);
NJS_EXPORT njs_int_t njs_vm_retval_dump(njs_vm_t *vm, njs_str_t *dst,
njs_uint_t indent);
NJS_EXPORT void njs_vm_value_error_set(njs_vm_t *vm, njs_value_t *value,
const char *fmt, ...);
NJS_EXPORT void njs_vm_memory_error(njs_vm_t *vm);
NJS_EXPORT void njs_vm_logger(njs_vm_t *vm, njs_log_level_t level,
const char *fmt, ...);
NJS_EXPORT void njs_value_undefined_set(njs_value_t *value);
NJS_EXPORT void njs_value_null_set(njs_value_t *value);
NJS_EXPORT void njs_value_invalid_set(njs_value_t *value);
NJS_EXPORT void njs_value_boolean_set(njs_value_t *value, int yn);
NJS_EXPORT void njs_value_number_set(njs_value_t *value, double num);
NJS_EXPORT uint8_t njs_value_bool(const njs_value_t *value);
NJS_EXPORT double njs_value_number(const njs_value_t *value);
NJS_EXPORT njs_function_t *njs_value_function(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_external_tag(const njs_value_t *value);
NJS_EXPORT uint16_t njs_vm_prop_magic16(njs_object_prop_t *prop);
NJS_EXPORT uint32_t njs_vm_prop_magic32(njs_object_prop_t *prop);
NJS_EXPORT njs_int_t njs_vm_prop_name(njs_vm_t *vm, njs_object_prop_t *prop,
njs_str_t *dst);
NJS_EXPORT njs_int_t njs_value_is_null(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_undefined(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_null_or_undefined(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_valid(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_boolean(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_number(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_valid_number(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_string(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_object(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_array(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_function(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_value_is_buffer(const njs_value_t *value);
NJS_EXPORT njs_int_t njs_vm_object_alloc(njs_vm_t *vm, njs_value_t *retval,
...);
NJS_EXPORT njs_value_t *njs_vm_object_keys(njs_vm_t *vm, njs_value_t *value,
njs_value_t *retval);
NJS_EXPORT njs_value_t *njs_vm_object_prop(njs_vm_t *vm,
njs_value_t *value, const njs_str_t *key, njs_opaque_value_t *retval);
NJS_EXPORT njs_int_t njs_vm_array_alloc(njs_vm_t *vm, njs_value_t *retval,
uint32_t spare);
NJS_EXPORT njs_int_t njs_vm_array_length(njs_vm_t *vm, njs_value_t *value,
int64_t *length);
NJS_EXPORT njs_value_t *njs_vm_array_start(njs_vm_t *vm, njs_value_t *value);
NJS_EXPORT njs_value_t *njs_vm_array_prop(njs_vm_t *vm,
njs_value_t *value, int64_t index, njs_opaque_value_t *retval);
NJS_EXPORT njs_value_t *njs_vm_array_push(njs_vm_t *vm, njs_value_t *value);
NJS_EXPORT njs_int_t njs_vm_json_parse(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs);
NJS_EXPORT njs_int_t njs_vm_json_stringify(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs);
NJS_EXPORT njs_int_t njs_vm_query_string_parse(njs_vm_t *vm, u_char *start,
u_char *end, njs_value_t *retval);
NJS_EXPORT njs_int_t njs_vm_promise_create(njs_vm_t *vm, njs_value_t *retval,
njs_value_t *callbacks);
#endif /* _NJS_H_INCLUDED_ */

8
modules_deb/libnginx-mod-js-0.7.9/src/njs.pc.in
View file

@ -1,8 +0,0 @@
prefix=@PREFIX@
libdir=@LIBDIR@
Name: njs
Description: library to embed njs scripting language
Version: @VERSION@
Libs: -L${libdir} -lnjs @EXTRA_LIBS@
Cflags: @CFLAGS@

265
modules_deb/libnginx-mod-js-0.7.9/src/njs_addr2line.c
View file

@ -1,265 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* addr2line impementaton based upon the work by Jeff Muizelaar.
*
* A hacky replacement for backtrace_symbols in glibc
*
* backtrace_symbols in glibc looks up symbols using dladdr which is limited in
* the symbols that it sees. libbacktracesymbols opens the executable and
* shared libraries using libbfd and will look up backtrace information using
* the symbol table and the dwarf line information.
*
* Derived from addr2line.c from GNU Binutils by Jeff Muizelaar
*
* Copyright 2007 Jeff Muizelaar
*
* addr2line.c -- convert addresses to line number and function name
* Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
* Contributed by Ulrich Lauther <Ulrich.Lauther@mchp.siemens.de>
*
* This file was part of GNU Binutils.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#define _GNU_SOURCE
#include <njs_main.h>
#include <njs_addr2line.h>
#include <bfd.h>
#include <link.h>
typedef struct {
const char *file;
ElfW(Addr) address;
ElfW(Addr) base;
void *hdr;
} njs_file_match_t;
typedef struct {
bfd_vma pc;
const char *filename;
const char *functionname;
unsigned int line;
njs_bool_t found;
asymbol **syms;
} njs_translate_address_t;
static u_char *njs_process_file(u_char *buf, u_char *end, bfd_vma *addr,
const char *file_name);
static long njs_read_symtab(bfd *abfd, asymbol ***syms);
static u_char *njs_translate_address(u_char *buf, u_char *end, bfd_vma *addr,
bfd *abfd, asymbol **syms);
static void njs_find_address_in_section(bfd *abfd, asection *section,
void *data);
static int njs_find_matching_file(struct dl_phdr_info *info, size_t size,
void *data);
u_char *
_njs_addr2line(u_char *buf, u_char *end, void *address)
{
bfd_vma addr;
const char *fname;
njs_file_match_t match = { .address = (ElfW(Addr)) address };
bfd_init();
dl_iterate_phdr(njs_find_matching_file, &match);
fname = "/proc/self/exe";
if (match.file != NULL && njs_strlen(match.file)) {
fname = match.file;
}
addr = (ElfW(Addr)) address - match.base;
return njs_process_file(buf, end, &addr, fname);
}
static u_char *
njs_process_file(u_char *buf, u_char *end, bfd_vma *addr, const char *file_name)
{
bfd *abfd;
char **matching;
u_char *p;
asymbol **syms;
abfd = bfd_openr(file_name, NULL);
if (abfd == NULL) {
njs_stderror("%s: failed to open while looking for addr2line",
file_name);
return NULL;
}
if (bfd_check_format(abfd, bfd_archive)) {
njs_stderror("%s: can not get addresses from archive", file_name);
return NULL;
}
if (!bfd_check_format_matches(abfd, bfd_object, &matching)) {
njs_stderror("%s: bfd_check_format_matches() failed",
bfd_get_filename(abfd));
return NULL;
}
if (njs_read_symtab(abfd, &syms) <= 0) {
njs_stderror("%s: njs_read_symtab() failed",
bfd_get_filename(abfd));
return NULL;
}
p = njs_translate_address(buf, end, addr, abfd, syms);
if (syms != NULL) {
free(syms);
syms = NULL;
}
bfd_close(abfd);
return p;
}
static long
njs_read_symtab(bfd *abfd, asymbol ***syms)
{
long symcount;
unsigned size;
if ((bfd_get_file_flags(abfd) & HAS_SYMS) == 0) {
return 0;
}
symcount = bfd_read_minisymbols(abfd, 0, (PTR) syms, &size);
if (symcount == 0) {
symcount = bfd_read_minisymbols(abfd, 1 /* dynamic */,
(PTR) syms, &size);
}
return symcount;
}
static u_char *
njs_translate_address(u_char *buf, u_char *end, bfd_vma *addr, bfd *abfd,
asymbol **syms)
{
char *h;
const char *name;
njs_translate_address_t ctx;
ctx.pc = *addr;
ctx.found = 0;
ctx.syms = syms;
bfd_map_over_sections(abfd, njs_find_address_in_section, &ctx);
if (!ctx.found) {
return njs_sprintf(buf, end, "\?\? \t\?\?:0 [0x%p]", addr);
}
name = ctx.functionname;
if (name == NULL || *name == '\0') {
name = "??";
}
if (ctx.filename != NULL) {
h = strrchr(ctx.filename, '/');
if (h != NULL) {
ctx.filename = h + 1;
}
}
return njs_sprintf(buf, end, "%s() %s:%ud [0x%p]", name,
ctx.filename ? ctx.filename : "??", ctx.line, addr);
}
static void
njs_find_address_in_section(bfd *abfd, asection *section, void *data)
{
bfd_vma vma;
bfd_size_type size;
njs_translate_address_t *ctx;
ctx = data;
if (ctx->found) {
return;
}
if ((bfd_section_flags(section) & SEC_ALLOC) == 0) {
return;
}
vma = bfd_section_vma(section);
if (ctx->pc < vma) {
return;
}
size = bfd_section_size(section);
if (ctx->pc >= vma + size) {
return;
}
ctx->found = bfd_find_nearest_line(abfd, section, ctx->syms, ctx->pc - vma,
&ctx->filename, &ctx->functionname,
&ctx->line);
}
static int
njs_find_matching_file(struct dl_phdr_info *info, size_t size, void *data)
{
long n;
const ElfW(Phdr) *phdr;
ElfW(Addr) load_base = info->dlpi_addr;
njs_file_match_t *match = data;
/*
* This code is modeled from Gfind_proc_info-lsb.c:callback()
* from libunwind.
*/
phdr = info->dlpi_phdr;
for (n = info->dlpi_phnum; --n >= 0; phdr++) {
if (phdr->p_type == PT_LOAD) {
ElfW(Addr) vaddr = phdr->p_vaddr + load_base;
if (match->address >= vaddr
&& match->address < vaddr + phdr->p_memsz)
{
/* we found a match */
match->file = info->dlpi_name;
match->base = info->dlpi_addr;
}
}
}
return 0;
}

22
modules_deb/libnginx-mod-js-0.7.9/src/njs_addr2line.h
View file

@ -1,22 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) Nginx, Inc.
*/
#ifndef _NJS_ADDR2LINE_H_INCLUDED_
#define _NJS_ADDR2LINE_H_INCLUDED_
u_char *_njs_addr2line(u_char *buf, u_char *end, void *address);
#if defined(NJS_HAVE_LIBBFD) && defined(NJS_HAVE_DL_ITERATE_PHDR)
#define NJS_HAVE_ADDR2LINE 1
#define njs_addr2line(buf, end, addr) _njs_addr2line(buf, end, addr)
#else
#define njs_addr2line(buf, end, addr) \
njs_sprintf(buf, end, "\?\?() \?\?:0 [0x%p]", addr)
#endif
#endif /* _NJS_ADDR2LINE_H_INCLUDED_ */

164
modules_deb/libnginx-mod-js-0.7.9/src/njs_arr.c
View file

@ -1,164 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
njs_arr_t *
njs_arr_create(njs_mp_t *mp, njs_uint_t n, size_t size)
{
njs_arr_t *arr;
arr = njs_mp_alloc(mp, sizeof(njs_arr_t) + n * size);
if (njs_slow_path(arr == NULL)) {
return NULL;
}
arr->start = (char *) arr + sizeof(njs_arr_t);
arr->items = 0;
arr->item_size = size;
arr->available = n;
arr->pointer = 1;
arr->separate = 0;
arr->mem_pool = mp;
return arr;
}
void *
njs_arr_init(njs_mp_t *mp, njs_arr_t *arr, void *start, njs_uint_t n,
size_t size)
{
arr->start = start;
arr->items = n;
arr->item_size = size;
arr->available = n;
arr->pointer = 0;
arr->separate = 0;
arr->mem_pool = mp;
if (arr->start == NULL) {
arr->separate = 1;
arr->items = 0;
arr->start = njs_mp_alloc(mp, n * size);
}
return arr->start;
}
void
njs_arr_destroy(njs_arr_t *arr)
{
if (arr->separate) {
njs_mp_free(arr->mem_pool, arr->start);
#if (NJS_DEBUG)
arr->start = NULL;
arr->items = 0;
arr->available = 0;
#endif
}
if (arr->pointer) {
njs_mp_free(arr->mem_pool, arr);
}
}
void *
njs_arr_add(njs_arr_t *arr)
{
return njs_arr_add_multiple(arr, 1);
}
void *
njs_arr_add_multiple(njs_arr_t *arr, njs_uint_t items)
{
void *item, *start, *old;
uint32_t n;
n = arr->available;
items += arr->items;
if (items >= n) {
if (n < 16) {
/* Allocate new arr twice as much as current. */
n *= 2;
} else {
/* Allocate new arr half as much as current. */
n += n / 2;
}
if (n < items) {
n = items;
}
start = njs_mp_alloc(arr->mem_pool, n * arr->item_size);
if (njs_slow_path(start == NULL)) {
return NULL;
}
arr->available = n;
old = arr->start;
arr->start = start;
memcpy(start, old, arr->items * arr->item_size);
if (arr->separate == 0) {
arr->separate = 1;
} else {
njs_mp_free(arr->mem_pool, old);
}
}
item = (char *) arr->start + arr->items * arr->item_size;
arr->items = items;
return item;
}
void *
njs_arr_zero_add(njs_arr_t *arr)
{
void *item;
item = njs_arr_add(arr);
if (njs_fast_path(item != NULL)) {
njs_memzero(item, arr->item_size);
}
return item;
}
void
njs_arr_remove(njs_arr_t *arr, void *item)
{
u_char *next, *last, *end;
uint32_t item_size;
item_size = arr->item_size;
end = (u_char *) arr->start + item_size * arr->items;
last = end - item_size;
if (item != last) {
next = (u_char *) item + item_size;
memmove(item, next, end - next);
}
arr->items--;
}

64
modules_deb/libnginx-mod-js-0.7.9/src/njs_arr.h
View file

@ -1,64 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_ARR_H_INCLUDED_
#define _NJS_ARR_H_INCLUDED_
typedef struct {
void *start;
/*
* A array can hold no more than 2**32 items.
* the item size is no more than 64K.
*/
uint32_t items;
uint32_t available;
uint16_t item_size;
uint8_t pointer;
uint8_t separate;
njs_mp_t *mem_pool;
} njs_arr_t;
NJS_EXPORT njs_arr_t *njs_arr_create(njs_mp_t *mp, njs_uint_t n,
size_t size);
NJS_EXPORT void *njs_arr_init(njs_mp_t *mp, njs_arr_t *arr, void *start,
njs_uint_t n, size_t size);
NJS_EXPORT void njs_arr_destroy(njs_arr_t *arr);
NJS_EXPORT void *njs_arr_add(njs_arr_t *arr);
NJS_EXPORT void *njs_arr_add_multiple(njs_arr_t *arr, njs_uint_t n);
NJS_EXPORT void *njs_arr_zero_add(njs_arr_t *arr);
NJS_EXPORT void njs_arr_remove(njs_arr_t *arr, void *item);
#define njs_arr_item(arr, i) \
((void *) ((char *) (arr)->start + (arr)->item_size * (i)))
#define njs_arr_last(arr) \
((void *) \
((char *) (arr)->start \
+ (arr)->item_size * ((arr)->items - 1)))
#define njs_arr_reset(arr) \
(arr)->items = 0;
#define njs_arr_is_empty(arr) \
((arr)->items == 0)
njs_inline void *
njs_arr_remove_last(njs_arr_t *arr)
{
arr->items--;
return (char *) arr->start + arr->item_size * arr->items;
}
#endif /* _NJS_ARR_H_INCLUDED_ */

2912
modules_deb/libnginx-mod-js-0.7.9/src/njs_array.c
View file

File diff suppressed because it is too large Load diff

59
modules_deb/libnginx-mod-js-0.7.9/src/njs_array.h
View file

@ -1,59 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_ARRAY_H_INCLUDED_
#define _NJS_ARRAY_H_INCLUDED_
#define NJS_ARRAY_MAX_INDEX 0xffffffff
#define NJS_ARRAY_INVALID_INDEX NJS_ARRAY_MAX_INDEX
#define NJS_ARRAY_SPARE 8
#define NJS_ARRAY_FAST_OBJECT_LENGTH (1024)
#define NJS_ARRAY_LARGE_OBJECT_LENGTH (32768)
#define NJS_ARRAY_FLAT_MAX_LENGTH (1048576)
#define njs_fast_object(_sz) ((_sz) <= NJS_ARRAY_FAST_OBJECT_LENGTH)
njs_array_t *njs_array_alloc(njs_vm_t *vm, njs_bool_t flat, uint64_t length,
uint32_t spare);
void njs_array_destroy(njs_vm_t *vm, njs_array_t *array);
njs_int_t njs_array_add(njs_vm_t *vm, njs_array_t *array, njs_value_t *value);
njs_int_t njs_array_convert_to_slow_array(njs_vm_t *vm, njs_array_t *array);
njs_int_t njs_array_length_redefine(njs_vm_t *vm, njs_value_t *value,
uint32_t length, int writable);
njs_int_t njs_array_length_set(njs_vm_t *vm, njs_value_t *value,
njs_object_prop_t *prev, njs_value_t *setval);
njs_array_t *njs_array_keys(njs_vm_t *vm, njs_value_t *array, njs_bool_t all);
njs_array_t *njs_array_indices(njs_vm_t *vm, njs_value_t *object);
njs_int_t njs_array_string_add(njs_vm_t *vm, njs_array_t *array,
const u_char *start, size_t size, size_t length);
njs_int_t njs_array_expand(njs_vm_t *vm, njs_array_t *array, uint32_t prepend,
uint32_t append);
njs_int_t njs_array_prototype_to_string(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused);
njs_inline njs_value_t *
njs_array_push(njs_vm_t *vm, njs_array_t *array)
{
njs_int_t ret;
ret = njs_array_expand(vm, array, 0, 1);
if (njs_slow_path(ret != NJS_OK)) {
return NULL;
}
return &array->start[array->length++];
}
extern const njs_object_init_t njs_array_instance_init;
extern const njs_object_type_init_t njs_array_type_init;
#endif /* _NJS_ARRAY_H_INCLUDED_ */

274
modules_deb/libnginx-mod-js-0.7.9/src/njs_array_buffer.c
View file

@ -1,274 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
njs_array_buffer_t *
njs_array_buffer_alloc(njs_vm_t *vm, uint64_t size, njs_bool_t zeroing)
{
njs_object_t *proto;
njs_array_buffer_t *array;
if (njs_slow_path(size > UINT32_MAX)) {
goto overflow;
}
array = njs_mp_alloc(vm->mem_pool, sizeof(njs_array_buffer_t));
if (njs_slow_path(array == NULL)) {
goto memory_error;
}
if (zeroing) {
array->u.data = njs_mp_zalloc(vm->mem_pool, size);
} else {
array->u.data = njs_mp_alloc(vm->mem_pool, size);
}
if (njs_slow_path(array->u.data == NULL)) {
goto memory_error;
}
proto = &vm->prototypes[NJS_OBJ_TYPE_ARRAY_BUFFER].object;
njs_lvlhsh_init(&array->object.hash);
njs_lvlhsh_init(&array->object.shared_hash);
array->object.__proto__ = proto;
array->object.slots = NULL;
array->object.type = NJS_ARRAY_BUFFER;
array->object.shared = 0;
array->object.extensible = 1;
array->object.error_data = 0;
array->object.fast_array = 0;
array->size = size;
return array;
memory_error:
njs_memory_error(vm);
return NULL;
overflow:
njs_range_error(vm, "Invalid array length");
return NULL;
}
static njs_int_t
njs_array_buffer_constructor(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
uint64_t size;
njs_int_t ret;
njs_value_t *value;
njs_array_buffer_t *array;
if (!vm->top_frame->ctor) {
njs_type_error(vm, "Constructor ArrayBuffer requires 'new'");
return NJS_ERROR;
}
size = 0;
value = njs_arg(args, nargs, 1);
ret = njs_value_to_index(vm, value, &size);
if (njs_slow_path(ret != NJS_OK)) {
return NJS_ERROR;
}
array = njs_array_buffer_alloc(vm, size, 1);
if (njs_slow_path(array == NULL)) {
return NJS_ERROR;
}
njs_set_array_buffer(&vm->retval, array);
return NJS_OK;
}
static njs_int_t
njs_array_buffer_get_this(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
vm->retval = args[0];
return NJS_OK;
}
static njs_int_t
njs_array_buffer_is_view(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_set_boolean(&vm->retval, njs_is_typed_array(njs_arg(args, nargs, 1)));
return NJS_OK;
}
njs_int_t
njs_array_buffer_writable(njs_vm_t *vm, njs_array_buffer_t *buffer)
{
void *dst;
if (!buffer->object.shared) {
return NJS_OK;
}
dst = njs_mp_alloc(vm->mem_pool, buffer->size);
if (njs_slow_path(dst == NULL)) {
njs_memory_error(vm);
return NJS_ERROR;
}
memcpy(dst, buffer->u.data, buffer->size);
buffer->object.shared = 0;
buffer->u.data = dst;
return NJS_OK;
}
static const njs_object_prop_t njs_array_buffer_constructor_properties[] =
{
NJS_DECLARE_PROP_NAME("ArrayBuffer"),
NJS_DECLARE_PROP_LENGTH(1),
NJS_DECLARE_PROP_HANDLER("prototype", njs_object_prototype_create, 0, 0, 0),
{
.type = NJS_ACCESSOR,
.name = njs_wellknown_symbol(NJS_SYMBOL_SPECIES),
.u.accessor = njs_getter(njs_array_buffer_get_this, 0),
.writable = NJS_ATTRIBUTE_UNSET,
.configurable = 1,
},
NJS_DECLARE_PROP_NATIVE("isView", njs_array_buffer_is_view, 1, 0),
};
const njs_object_init_t njs_array_buffer_constructor_init = {
njs_array_buffer_constructor_properties,
njs_nitems(njs_array_buffer_constructor_properties),
};
static njs_int_t
njs_array_buffer_prototype_byte_length(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
njs_value_t *value;
njs_array_buffer_t *array;
value = njs_argument(args, 0);
if (!njs_is_array_buffer(value)) {
njs_type_error(vm, "Method ArrayBuffer.prototype.byteLength called "
"on incompatible receiver");
return NJS_ERROR;
}
array = njs_array_buffer(value);
if (njs_slow_path(njs_is_detached_buffer(array))) {
njs_type_error(vm, "detached buffer");
return NJS_ERROR;
}
njs_set_number(&vm->retval, array->size);
return NJS_OK;
}
static njs_int_t
njs_array_buffer_prototype_slice(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
int64_t len, start, end;
njs_int_t ret;
njs_value_t *value;
njs_array_buffer_t *this, *buffer;
value = njs_argument(args, 0);
if (!njs_is_array_buffer(value)) {
njs_type_error(vm, "Method ArrayBuffer.prototype.slice called "
"on incompatible receiver");
return NJS_ERROR;
}
this = njs_array_buffer(value);
len = njs_array_buffer_size(this);
end = len;
value = njs_arg(args, nargs, 1);
ret = njs_value_to_integer(vm, value, &start);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
value = njs_arg(args, nargs, 2);
if (!njs_is_undefined(value)) {
ret = njs_value_to_integer(vm, value, &end);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
}
buffer = njs_array_buffer_slice(vm, this, start, end);
if (njs_slow_path(buffer == NULL)) {
return NJS_ERROR;
}
njs_set_array_buffer(&vm->retval, buffer);
return NJS_OK;
}
static const njs_object_prop_t njs_array_buffer_prototype_properties[] =
{
NJS_DECLARE_PROP_HANDLER("constructor",
njs_object_prototype_create_constructor,
0, 0, NJS_OBJECT_PROP_VALUE_CW),
NJS_DECLARE_PROP_GETTER("byteLength",
njs_array_buffer_prototype_byte_length, 0),
NJS_DECLARE_PROP_NATIVE("slice", njs_array_buffer_prototype_slice, 2, 0),
{
.type = NJS_PROPERTY,
.name = njs_wellknown_symbol(NJS_SYMBOL_TO_STRING_TAG),
.u.value = njs_string("ArrayBuffer"),
.configurable = 1,
},
};
const njs_object_init_t njs_array_buffer_prototype_init = {
njs_array_buffer_prototype_properties,
njs_nitems(njs_array_buffer_prototype_properties),
};
const njs_object_type_init_t njs_array_buffer_type_init = {
.constructor = njs_native_ctor(njs_array_buffer_constructor, 1, 0),
.prototype_props = &njs_array_buffer_prototype_init,
.constructor_props = &njs_array_buffer_constructor_init,
.prototype_value = { .object = { .type = NJS_OBJECT } },
};

47
modules_deb/libnginx-mod-js-0.7.9/src/njs_array_buffer.h
View file

@ -1,47 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_ARRAY_BUFFER_H_INCLUDED_
#define _NJS_ARRAY_BUFFER_H_INCLUDED_
#define njs_array_buffer_size(buffer) \
((buffer)->size)
njs_array_buffer_t *njs_array_buffer_alloc(njs_vm_t *vm, uint64_t size,
njs_bool_t zeroing);
njs_int_t njs_array_buffer_writable(njs_vm_t *vm, njs_array_buffer_t *buffer);
njs_inline njs_array_buffer_t *
njs_array_buffer_slice(njs_vm_t *vm, njs_array_buffer_t *this, int64_t start,
int64_t end)
{
int64_t len, new_len, first, final;
njs_array_buffer_t *new_buffer;
len = njs_array_buffer_size(this);
first = (start < 0) ? njs_max(len + start, 0) : njs_min(start, len);
final = (end < 0) ? njs_max(len + end, 0) : njs_min(end, len);
new_len = njs_max(final - first, 0);
new_buffer = njs_array_buffer_alloc(vm, new_len, 1);
if (new_buffer == NULL) {
return NULL;
}
memcpy(new_buffer->u.u8, &this->u.u8[first], new_len);
return new_buffer;
}
extern const njs_object_type_init_t njs_array_buffer_type_init;
#endif /* _NJS_ARRAY_BUFFER_H_INCLUDED_ */

37
modules_deb/libnginx-mod-js-0.7.9/src/njs_assert.h
View file

@ -1,37 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_ASSERT_H_INCLUDED_
#define _NJS_ASSERT_H_INCLUDED_
#if (NJS_DEBUG)
#define njs_assert(condition) \
do { \
if (!(condition)) { \
njs_stderror("Assertion \"%s\" failed at %s:%d\n", #condition, \
__FILE__, __LINE__); \
abort(); \
} \
} while (0)
#define njs_assert_msg(condition, fmt, ...) \
do { \
if (!(condition)) { \
njs_stderror(fmt, ##__VA_ARGS__); \
njs_stderror(" at %s:%d\n", __FILE__, __LINE__); \
abort(); \
} \
} while (0)
#else
#define njs_assert(condition)
#define njs_assert_msg(condition, fmt, ...)
#endif
#endif /* _NJS_ASSERT_H_INCLUDED_ */

224
modules_deb/libnginx-mod-js-0.7.9/src/njs_async.c
View file

@ -1,224 +0,0 @@
/*
* Copyright (C) Alexander Borisov
* Copyright (C) Nginx, Inc.
*/
#include <njs_main.h>
static void
njs_async_context_free(njs_vm_t *vm, njs_async_ctx_t *ctx);
njs_int_t
njs_async_function_frame_invoke(njs_vm_t *vm, njs_value_t *retval)
{
njs_int_t ret;
njs_value_t ctor;
njs_native_frame_t *frame;
njs_promise_capability_t *capability;
frame = vm->top_frame;
frame->retval = retval;
njs_set_function(&ctor, &vm->constructors[NJS_OBJ_TYPE_PROMISE]);
capability = njs_promise_new_capability(vm, &ctor);
if (njs_slow_path(capability == NULL)) {
return NJS_ERROR;
}
ret = njs_function_lambda_call(vm, capability);
if (ret == NJS_OK) {
ret = njs_function_call(vm, njs_function(&capability->resolve),
&njs_value_undefined, retval, 1, &vm->retval);
} else if (ret == NJS_AGAIN) {
ret = NJS_OK;
} else if (ret == NJS_ERROR) {
if (njs_is_memory_error(vm, &vm->retval)) {
return NJS_ERROR;
}
ret = njs_function_call(vm, njs_function(&capability->reject),
&njs_value_undefined, &vm->retval, 1,
&vm->retval);
}
*retval = capability->promise;
return ret;
}
njs_int_t
njs_await_fulfilled(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_int_t ret;
njs_value_t **cur_local, **cur_closures, *value;
njs_frame_t *frame, *async_frame;
njs_async_ctx_t *ctx;
njs_native_frame_t *top, *async;
ctx = vm->top_frame->function->context;
value = njs_arg(args, nargs, 1);
async_frame = ctx->await;
async = &async_frame->native;
async->previous = vm->top_frame;
cur_local = vm->levels[NJS_LEVEL_LOCAL];
cur_closures = vm->levels[NJS_LEVEL_CLOSURE];
top = vm->top_frame;
frame = vm->active_frame;
vm->levels[NJS_LEVEL_LOCAL] = async->local;
vm->levels[NJS_LEVEL_CLOSURE] = njs_function_closures(async->function);
vm->top_frame = async;
vm->active_frame = async_frame;
*njs_scope_value(vm, ctx->index) = *value;
vm->retval = *value;
vm->top_frame->retval = &vm->retval;
ret = njs_vmcode_interpreter(vm, ctx->pc, ctx->capability, ctx);
vm->levels[NJS_LEVEL_LOCAL] = cur_local;
vm->levels[NJS_LEVEL_CLOSURE] = cur_closures;
vm->top_frame = top;
vm->active_frame = frame;
if (ret == NJS_OK) {
ret = njs_function_call(vm, njs_function(&ctx->capability->resolve),
&njs_value_undefined, &vm->retval, 1, &vm->retval);
njs_async_context_free(vm, ctx);
} else if (ret == NJS_AGAIN) {
ret = NJS_OK;
} else if (ret == NJS_ERROR) {
if (njs_is_memory_error(vm, &vm->retval)) {
return NJS_ERROR;
}
value = &vm->retval;
goto failed;
}
return ret;
failed:
(void) njs_function_call(vm, njs_function(&ctx->capability->reject),
&njs_value_undefined, value, 1, &vm->retval);
njs_async_context_free(vm, ctx);
return NJS_ERROR;
}
njs_int_t
njs_await_rejected(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_value_t *value;
njs_async_ctx_t *ctx;
ctx = vm->top_frame->function->context;
value = njs_arg(args, nargs, 1);
if (ctx->await->native.pc == ctx->pc) {
/* No catch block was set before await. */
(void) njs_function_call(vm, njs_function(&ctx->capability->reject),
&njs_value_undefined, value, 1, &vm->retval);
njs_async_context_free(vm, ctx);
return NJS_ERROR;
}
/* ctx->await->native.pc points to a catch block here. */
ctx->pc = ctx->await->native.pc;
return njs_await_fulfilled(vm, args, nargs, unused);
}
static void
njs_async_context_free(njs_vm_t *vm, njs_async_ctx_t *ctx)
{
njs_mp_free(vm->mem_pool, ctx->capability);
njs_mp_free(vm->mem_pool, ctx);
}
static const njs_object_prop_t njs_async_constructor_properties[] =
{
NJS_DECLARE_PROP_LENGTH(1),
NJS_DECLARE_PROP_HANDLER("prototype", njs_object_prototype_create, 0, 0, 0),
};
const njs_object_init_t njs_async_constructor_init = {
njs_async_constructor_properties,
njs_nitems(njs_async_constructor_properties),
};
static const njs_object_prop_t njs_async_prototype_properties[] =
{
{
.type = NJS_PROPERTY,
.name = njs_wellknown_symbol(NJS_SYMBOL_TO_STRING_TAG),
.u.value = njs_string("AsyncFunction"),
.configurable = 1,
},
NJS_DECLARE_PROP_HANDLER("constructor",
njs_object_prototype_create_constructor,
0, 0, NJS_OBJECT_PROP_VALUE_CW),
};
const njs_object_init_t njs_async_prototype_init = {
njs_async_prototype_properties,
njs_nitems(njs_async_prototype_properties),
};
const njs_object_type_init_t njs_async_function_type_init = {
.constructor = njs_native_ctor(njs_function_constructor, 1, 1),
.constructor_props = &njs_async_constructor_init,
.prototype_props = &njs_async_prototype_init,
.prototype_value = { .object = { .type = NJS_OBJECT } },
};
const njs_object_prop_t njs_async_function_instance_properties[] =
{
NJS_DECLARE_PROP_HANDLER("length", njs_function_instance_length, 0, 0,
NJS_OBJECT_PROP_VALUE_C),
NJS_DECLARE_PROP_HANDLER("name", njs_function_instance_name, 0, 0,
NJS_OBJECT_PROP_VALUE_C),
};
const njs_object_init_t njs_async_function_instance_init = {
njs_async_function_instance_properties,
njs_nitems(njs_async_function_instance_properties),
};

30
modules_deb/libnginx-mod-js-0.7.9/src/njs_async.h
View file

@ -1,30 +0,0 @@
/*
* Copyright (C) Alexander Borisov
* Copyright (C) Nginx, Inc.
*/
#ifndef _NJS_ASYNC_H_INCLUDED_
#define _NJS_ASYNC_H_INCLUDED_
typedef struct {
njs_promise_capability_t *capability;
njs_frame_t *await;
uintptr_t index;
u_char *pc;
} njs_async_ctx_t;
njs_int_t njs_async_function_frame_invoke(njs_vm_t *vm, njs_value_t *retval);
njs_int_t njs_await_fulfilled(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused);
njs_int_t njs_await_rejected(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused);
extern const njs_object_type_init_t njs_async_function_type_init;
extern const njs_object_init_t njs_async_function_instance_init;
#endif /* _NJS_ASYNC_H_INCLUDED_ */

148
modules_deb/libnginx-mod-js-0.7.9/src/njs_boolean.c
View file

@ -1,148 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
static njs_int_t
njs_boolean_constructor(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
const njs_value_t *value;
njs_object_value_t *object;
if (nargs == 1) {
value = &njs_value_false;
} else {
value = njs_is_true(&args[1]) ? &njs_value_true : &njs_value_false;
}
if (vm->top_frame->ctor) {
object = njs_object_value_alloc(vm, NJS_OBJ_TYPE_BOOLEAN, 0, value);
if (njs_slow_path(object == NULL)) {
return NJS_ERROR;
}
njs_set_object_value(&vm->retval, object);
} else {
vm->retval = *value;
}
return NJS_OK;
}
static const njs_object_prop_t njs_boolean_constructor_properties[] =
{
{
.type = NJS_PROPERTY,
.name = njs_string("name"),
.u.value = njs_string("Boolean"),
.configurable = 1,
},
{
.type = NJS_PROPERTY,
.name = njs_string("length"),
.u.value = njs_value(NJS_NUMBER, 1, 1.0),
.configurable = 1,
},
NJS_DECLARE_PROP_HANDLER("prototype", njs_object_prototype_create, 0, 0, 0),
};
const njs_object_init_t njs_boolean_constructor_init = {
njs_boolean_constructor_properties,
njs_nitems(njs_boolean_constructor_properties),
};
static njs_int_t
njs_boolean_prototype_value_of(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
njs_value_t *value;
value = &args[0];
if (value->type != NJS_BOOLEAN) {
if (njs_is_object_boolean(value)) {
value = njs_object_value(value);
} else {
njs_type_error(vm, "unexpected value type:%s",
njs_type_string(value->type));
return NJS_ERROR;
}
}
vm->retval = *value;
return NJS_OK;
}
static njs_int_t
njs_boolean_prototype_to_string(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_index_t unused)
{
njs_value_t *value;
value = &args[0];
if (value->type != NJS_BOOLEAN) {
if (njs_is_object_boolean(value)) {
value = njs_object_value(value);
} else {
njs_type_error(vm, "unexpected value type:%s",
njs_type_string(value->type));
return NJS_ERROR;
}
}
vm->retval = njs_is_true(value) ? njs_string_true : njs_string_false;
return NJS_OK;
}
static const njs_object_prop_t njs_boolean_prototype_properties[] =
{
NJS_DECLARE_PROP_HANDLER("__proto__", njs_primitive_prototype_get_proto,
0, 0, NJS_OBJECT_PROP_VALUE_CW),
NJS_DECLARE_PROP_HANDLER("constructor",
njs_object_prototype_create_constructor,
0, 0, NJS_OBJECT_PROP_VALUE_CW),
NJS_DECLARE_PROP_NATIVE("valueOf", njs_boolean_prototype_value_of, 0, 0),
NJS_DECLARE_PROP_NATIVE("toString", njs_boolean_prototype_to_string, 0, 0),
};
const njs_object_init_t njs_boolean_prototype_init = {
njs_boolean_prototype_properties,
njs_nitems(njs_boolean_prototype_properties),
};
const njs_object_type_init_t njs_boolean_type_init = {
.constructor = njs_native_ctor(njs_boolean_constructor, 1, 0),
.constructor_props = &njs_boolean_constructor_init,
.prototype_props = &njs_boolean_prototype_init,
.prototype_value = { .object_value = {
.value = njs_value(NJS_BOOLEAN, 0, 0.0),
.object = { .type = NJS_OBJECT_VALUE } }
},
};

14
modules_deb/libnginx-mod-js-0.7.9/src/njs_boolean.h
View file

@ -1,14 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_BOOLEAN_H_INCLUDED_
#define _NJS_BOOLEAN_H_INCLUDED_
extern const njs_object_type_init_t njs_boolean_type_init;
#endif /* _NJS_BOOLEAN_H_INCLUDED_ */

2614
modules_deb/libnginx-mod-js-0.7.9/src/njs_buffer.c
View file

File diff suppressed because it is too large Load diff

42
modules_deb/libnginx-mod-js-0.7.9/src/njs_buffer.h
View file

@ -1,42 +0,0 @@
/*
* Copyright (C) Alexander Borisov
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_BUFFER_H_INCLUDED_
#define _NJS_BUFFER_H_INCLUDED_
typedef njs_int_t (*njs_buffer_encode_t)(njs_vm_t *vm, njs_value_t *value,
const njs_str_t *src);
typedef size_t (*njs_buffer_encode_length_t)(const njs_str_t *src,
size_t *out_size);
typedef struct {
njs_str_t name;
njs_buffer_encode_t encode;
njs_buffer_encode_t decode;
njs_buffer_encode_length_t decode_length;
} njs_buffer_encoding_t;
njs_typed_array_t *njs_buffer_slot(njs_vm_t *vm, njs_value_t *value,
const char *name);
njs_int_t njs_buffer_set(njs_vm_t *vm, njs_value_t *value, const u_char *start,
uint32_t size);
njs_int_t njs_buffer_new(njs_vm_t *vm, njs_value_t *value, const u_char *start,
uint32_t size);
njs_typed_array_t *njs_buffer_alloc(njs_vm_t *vm, size_t size,
njs_bool_t zeroing);
const njs_buffer_encoding_t *njs_buffer_encoding(njs_vm_t *vm,
const njs_value_t *value);
njs_int_t njs_buffer_decode_string(njs_vm_t *vm, const njs_value_t *value,
njs_value_t *dst, const njs_buffer_encoding_t *encoding);
extern const njs_object_type_init_t njs_buffer_type_init;
#endif /* _NJS_BUFFER_H_INCLUDED_ */

1738
modules_deb/libnginx-mod-js-0.7.9/src/njs_builtin.c
View file

File diff suppressed because it is too large Load diff

244
modules_deb/libnginx-mod-js-0.7.9/src/njs_chb.c
View file

@ -1,244 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
#define NJS_CHB_MIN_SIZE 256
void
njs_chb_append0(njs_chb_t *chain, const char *msg, size_t len)
{
u_char *p;
if (len != 0 && !chain->error) {
p = njs_chb_reserve(chain, len);
if (njs_slow_path(p == NULL)) {
return;
}
memcpy(p, msg, len);
njs_chb_written(chain, len);
}
}
u_char *
njs_chb_reserve(njs_chb_t *chain, size_t size)
{
njs_chb_node_t *n;
n = chain->last;
if (njs_fast_path(n != NULL && njs_chb_node_room(n) >= size)) {
return n->pos;
}
if (size < NJS_CHB_MIN_SIZE) {
size = NJS_CHB_MIN_SIZE;
}
n = njs_mp_alloc(chain->pool, sizeof(njs_chb_node_t) + size);
if (njs_slow_path(n == NULL)) {
chain->error = 1;
return NULL;
}
n->next = NULL;
n->start = (u_char *) n + sizeof(njs_chb_node_t);
n->pos = n->start;
n->end = n->pos + size;
if (chain->last != NULL) {
chain->last->next = n;
} else {
chain->nodes = n;
}
chain->last = n;
return n->start;
}
void
njs_chb_vsprintf(njs_chb_t *chain, size_t size, const char *fmt, va_list args)
{
u_char *start, *end;
start = njs_chb_reserve(chain, size);
if (njs_slow_path(start == NULL)) {
return;
}
end = njs_vsprintf(start, start + size, fmt, args);
njs_chb_written(chain, end - start);
}
void
njs_chb_sprintf(njs_chb_t *chain, size_t size, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
njs_chb_vsprintf(chain, size, fmt, args);
va_end(args);
}
/*
* Drains size bytes from the beginning of the chain.
*/
void
njs_chb_drain(njs_chb_t *chain, size_t drain)
{
njs_chb_node_t *n;
n = chain->nodes;
while (n != NULL) {
if (njs_chb_node_size(n) > drain) {
n->start += drain;
return;
}
drain -= njs_chb_node_size(n);
chain->nodes = n->next;
njs_mp_free(chain->pool, n);
n = chain->nodes;
}
chain->last = NULL;
}
/*
* Drops size bytes from the end of the chain.
*/
void
njs_chb_drop(njs_chb_t *chain, size_t drop)
{
uint64_t size;
njs_chb_node_t *n, *next;
if (njs_slow_path(chain->error)) {
return;
}
n = chain->last;
if (njs_fast_path(n != NULL && (njs_chb_node_size(n) > drop))) {
n->pos -= drop;
return;
}
n = chain->nodes;
size = (uint64_t) njs_chb_size(chain);
if (drop >= size) {
njs_chb_destroy(chain);
njs_chb_init(chain, chain->pool);
return;
}
while (n != NULL) {
size -= njs_chb_node_size(n);
if (size <= drop) {
chain->last = n;
chain->last->pos -= drop - size;
n = chain->last->next;
chain->last->next = NULL;
break;
}
n = n->next;
}
while (n != NULL) {
next = n->next;
njs_mp_free(chain->pool, n);
n = next;
}
}
njs_int_t
njs_chb_join(njs_chb_t *chain, njs_str_t *str)
{
u_char *start;
uint64_t size;
njs_chb_node_t *n;
if (njs_slow_path(chain->error)) {
return NJS_DECLINED;
}
n = chain->nodes;
if (n == NULL) {
str->length = 0;
str->start = NULL;
return NJS_OK;
}
size = (uint64_t) njs_chb_size(chain);
if (njs_slow_path(size >= UINT32_MAX)) {
return NJS_ERROR;
}
start = njs_mp_alloc(chain->pool, size);
if (njs_slow_path(start == NULL)) {
return NJS_ERROR;
}
str->length = size;
str->start = start;
njs_chb_join_to(chain, start);
return NJS_OK;
}
void
njs_chb_join_to(njs_chb_t *chain, u_char *dst)
{
njs_chb_node_t *n;
n = chain->nodes;
while (n != NULL) {
dst = njs_cpymem(dst, n->start, njs_chb_node_size(n));
n = n->next;
}
}
void
njs_chb_destroy(njs_chb_t *chain)
{
njs_chb_node_t *n, *next;
n = chain->nodes;
while (n != NULL) {
next = n->next;
njs_mp_free(chain->pool, n);
n = next;
}
}

133
modules_deb/libnginx-mod-js-0.7.9/src/njs_chb.h
View file

@ -1,133 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_CHB_H_INCLUDED_
#define _NJS_CHB_H_INCLUDED_
typedef struct njs_chb_node_s njs_chb_node_t;
struct njs_chb_node_s {
njs_chb_node_t *next;
u_char *start;
u_char *pos;
u_char *end;
};
typedef struct {
njs_bool_t error;
njs_mp_t *pool;
njs_chb_node_t *nodes;
njs_chb_node_t *last;
} njs_chb_t;
void njs_chb_append0(njs_chb_t *chain, const char *msg, size_t len);
void njs_chb_vsprintf(njs_chb_t *chain, size_t size, const char *fmt,
va_list args);
void njs_chb_sprintf(njs_chb_t *chain, size_t size, const char* fmt, ...);
u_char *njs_chb_reserve(njs_chb_t *chain, size_t size);
void njs_chb_drain(njs_chb_t *chain, size_t drop);
void njs_chb_drop(njs_chb_t *chain, size_t drop);
njs_int_t njs_chb_join(njs_chb_t *chain, njs_str_t *str);
void njs_chb_join_to(njs_chb_t *chain, u_char *dst);
void njs_chb_destroy(njs_chb_t *chain);
#define njs_chb_append(chain, msg, len) \
njs_chb_append0(chain, (const char *) (msg), len)
#define njs_chb_append_literal(chain, literal) \
njs_chb_append0(chain, literal, njs_length(literal))
#define njs_chb_node_size(n) (size_t) ((n)->pos - (n)->start)
#define njs_chb_node_room(n) (size_t) ((n)->end - (n)->pos)
njs_inline void
njs_chb_init(njs_chb_t *chain, njs_mp_t *pool)
{
chain->error = 0;
chain->pool = pool;
chain->nodes = NULL;
chain->last = NULL;
}
njs_inline void
njs_chb_append_str(njs_chb_t *chain, njs_str_t *str)
{
njs_chb_append0(chain, (const char *) str->start, str->length);
}
njs_inline int64_t
njs_chb_size(njs_chb_t *chain)
{
uint64_t size;
njs_chb_node_t *n;
if (njs_slow_path(chain->error)) {
return -1;
}
n = chain->nodes;
size = 0;
while (n != NULL) {
size += njs_chb_node_size(n);
n = n->next;
}
return size;
}
njs_inline int64_t
njs_chb_utf8_length(njs_chb_t *chain)
{
int64_t len, length;
njs_chb_node_t *n;
if (njs_slow_path(chain->error)) {
return -1;
}
n = chain->nodes;
length = 0;
while (n != NULL) {
len = njs_utf8_length(n->start, njs_chb_node_size(n));
if (njs_slow_path(len < 0)) {
return 0;
}
length += len;
n = n->next;
}
return length;
}
njs_inline u_char *
njs_chb_current(njs_chb_t *chain)
{
return (chain->last != NULL) ? chain->last->pos : NULL;
}
njs_inline void
njs_chb_written(njs_chb_t *chain, size_t bytes)
{
chain->last->pos += bytes;
}
#endif /* _NJS_JSON_H_INCLUDED_ */

243
modules_deb/libnginx-mod-js-0.7.9/src/njs_clang.h
View file

@ -1,243 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_CLANG_H_INCLUDED_
#define _NJS_CLANG_H_INCLUDED_
#include <stdarg.h>
#include <stddef.h> /* offsetof(). */
#define njs_inline static inline __attribute__((always_inline))
#define njs_noinline __attribute__((noinline))
#define njs_cdecl
#define njs_container_of(p, type, field) \
(type *) ((u_char *) (p) - offsetof(type, field))
#define njs_nitems(x) \
(sizeof(x) / sizeof((x)[0]))
#define njs_max(val1, val2) \
((val1 < val2) ? (val2) : (val1))
#define njs_min(val1, val2) \
((val1 < val2) ? (val1) : (val2))
#if (NJS_HAVE_BUILTIN_EXPECT)
#define njs_expect(c, x) __builtin_expect((long) (x), (c))
#define njs_fast_path(x) njs_expect(1, x)
#define njs_slow_path(x) njs_expect(0, x)
#else
#define njs_expect(c, x) (x)
#define njs_fast_path(x) (x)
#define njs_slow_path(x) (x)
#endif
#if (NJS_HAVE_BUILTIN_UNREACHABLE)
#define njs_unreachable() __builtin_unreachable()
#else
#define njs_unreachable()
#endif
#if (NJS_HAVE_BUILTIN_PREFETCH)
#define njs_prefetch(a) __builtin_prefetch(a)
#else
#define njs_prefetch(a)
#endif
#if (NJS_HAVE_BUILTIN_CLZ)
#define njs_leading_zeros(x) (((x) == 0) ? 32 : __builtin_clz(x))
#else
njs_inline uint32_t
njs_leading_zeros(uint32_t x)
{
uint32_t n;
/*
* There is no sense to optimize this function, since almost
* all platforms nowadays support the built-in instruction.
*/
if (x == 0) {
return 32;
}
n = 0;
while ((x & 0x80000000) == 0) {
n++;
x <<= 1;
}
return n;
}
#endif
#if (NJS_HAVE_BUILTIN_CLZLL)
#define njs_leading_zeros64(x) (((x) == 0) ? 64 : __builtin_clzll(x))
#else
njs_inline uint64_t
njs_leading_zeros64(uint64_t x)
{
uint64_t n;
/*
* There is no sense to optimize this function, since almost
* all platforms nowadays support the built-in instruction.
*/
if (x == 0) {
return 64;
}
n = 0;
while ((x & 0x8000000000000000) == 0) {
n++;
x <<= 1;
}
return n;
}
#endif
#if (NJS_HAVE_GCC_ATTRIBUTE_VISIBILITY)
#define NJS_EXPORT __attribute__((visibility("default")))
#else
#define NJS_EXPORT
#endif
#if (NJS_HAVE_GCC_ATTRIBUTE_ALIGNED)
#define njs_aligned(x) __attribute__((aligned(x)))
#else
#define njs_aligned(x)
#endif
#if (NJS_HAVE_GCC_ATTRIBUTE_PACKED)
#define NJS_PACKED __attribute__((packed))
#else
#define NJS_PACKED
#endif
#if (NJS_HAVE_GCC_ATTRIBUTE_FALLTHROUGH)
#define NJS_FALLTHROUGH __attribute__((fallthrough))
#else
#define NJS_FALLTHROUGH
#endif
#if (NJS_HAVE_GCC_ATTRIBUTE_MALLOC)
#define NJS_MALLOC_LIKE __attribute__((__malloc__))
#else
#define NJS_MALLOC_LIKE
#endif
#if (NJS_CLANG)
/* Any __asm__ directive disables loop vectorization in GCC and Clang. */
#define njs_pragma_loop_disable_vectorization __asm__("")
#else
#define njs_pragma_loop_disable_vectorization
#endif
#define njs_stringify(v) #v
#if (NJS_HAVE_MEMORY_SANITIZER)
#include <sanitizer/msan_interface.h>
#define njs_msan_unpoison(ptr, size) __msan_unpoison(ptr, size)
#else
#define njs_msan_unpoison(ptr, size)
#endif
#if (NJS_HAVE_DENORMALS_CONTROL)
#include <xmmintrin.h>
/*
* 0x8000 Flush to zero
* 0x0040 Denormals are zeros
*/
#define NJS_MM_DENORMALS_MASK 0x8040
#define njs_mm_denormals(on) \
_mm_setcsr((_mm_getcsr() & ~NJS_MM_DENORMALS_MASK) | (!(on) ? 0x8040: 0x0))
#else
#define njs_mm_denormals(on)
#endif
#ifndef NJS_MAX_ALIGNMENT
#if (NJS_SOLARIS)
/* x86_64: 16, i386: 4, sparcv9: 16, sparcv8: 8. */
#define NJS_MAX_ALIGNMENT _MAX_ALIGNMENT
#elif (NJS_WINDOWS)
/* Win64: 16, Win32: 8. */
#define NJS_MAX_ALIGNMENT MEMORY_ALLOCATION_ALIGNMENT
#elif (__amd64__)
#define NJS_MAX_ALIGNMENT 16
#elif (__i386__ || __i386)
#define NJS_MAX_ALIGNMENT 4
#elif (__arm__)
#define NJS_MAX_ALIGNMENT 16
#else
#define NJS_MAX_ALIGNMENT 16
#endif
#endif
#define njs_align_size(size, a) \
(((size) + ((size_t) (a) - 1)) & ~((size_t) (a) - 1))
#define njs_align_ptr(p, a) \
(u_char *) (((uintptr_t) (p) + ((uintptr_t) (a) - 1)) \
& ~((uintptr_t) (a) - 1))
#define njs_trunc_ptr(p, a) \
(u_char *) ((uintptr_t) (p) & ~((uintptr_t) (a) - 1))
#endif /* _NJS_CLANG_H_INCLUDED_ */

1591
modules_deb/libnginx-mod-js-0.7.9/src/njs_date.c
View file

File diff suppressed because it is too large Load diff

19
modules_deb/libnginx-mod-js-0.7.9/src/njs_date.h
View file

@ -1,19 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_DATE_H_INCLUDED_
#define _NJS_DATE_H_INCLUDED_
njs_date_t *njs_date_alloc(njs_vm_t *vm, double time);
njs_int_t njs_date_to_string(njs_vm_t *vm, njs_value_t *retval,
const njs_value_t *date);
extern const njs_object_type_init_t njs_date_type_init;
#endif /* _NJS_DATE_H_INCLUDED_ */

564
modules_deb/libnginx-mod-js-0.7.9/src/njs_disassembler.c
View file

@ -1,564 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
typedef struct {
njs_vmcode_operation_t operation;
size_t size;
njs_str_t name;
} njs_code_name_t;
static njs_code_name_t code_names[] = {
{ NJS_VMCODE_PUT_ARG, sizeof(njs_vmcode_1addr_t),
njs_str("PUT ARG ") },
{ NJS_VMCODE_OBJECT, sizeof(njs_vmcode_object_t),
njs_str("OBJECT ") },
{ NJS_VMCODE_FUNCTION, sizeof(njs_vmcode_function_t),
njs_str("FUNCTION ") },
{ NJS_VMCODE_ARGUMENTS, sizeof(njs_vmcode_arguments_t),
njs_str("ARGUMENTS ") },
{ NJS_VMCODE_REGEXP, sizeof(njs_vmcode_regexp_t),
njs_str("REGEXP ") },
{ NJS_VMCODE_TEMPLATE_LITERAL, sizeof(njs_vmcode_template_literal_t),
njs_str("TEMPLATE LITERAL") },
{ NJS_VMCODE_OBJECT_COPY, sizeof(njs_vmcode_object_copy_t),
njs_str("OBJECT COPY ") },
{ NJS_VMCODE_FUNCTION_COPY, sizeof(njs_vmcode_function_copy_t),
njs_str("FUNCTION COPY ") },
{ NJS_VMCODE_PROPERTY_GET, sizeof(njs_vmcode_prop_get_t),
njs_str("PROP GET ") },
{ NJS_VMCODE_GLOBAL_GET, sizeof(njs_vmcode_prop_get_t),
njs_str("GLOBAL GET ") },
{ NJS_VMCODE_PROPERTY_INIT, sizeof(njs_vmcode_prop_set_t),
njs_str("PROP INIT ") },
{ NJS_VMCODE_PROTO_INIT, sizeof(njs_vmcode_prop_set_t),
njs_str("PROTO INIT ") },
{ NJS_VMCODE_PROPERTY_SET, sizeof(njs_vmcode_prop_set_t),
njs_str("PROP SET ") },
{ NJS_VMCODE_PROPERTY_IN, sizeof(njs_vmcode_3addr_t),
njs_str("PROP IN ") },
{ NJS_VMCODE_PROPERTY_DELETE, sizeof(njs_vmcode_3addr_t),
njs_str("PROP DELETE ") },
{ NJS_VMCODE_INSTANCE_OF, sizeof(njs_vmcode_instance_of_t),
njs_str("INSTANCE OF ") },
{ NJS_VMCODE_FUNCTION_CALL, sizeof(njs_vmcode_function_call_t),
njs_str("FUNCTION CALL ") },
{ NJS_VMCODE_RETURN, sizeof(njs_vmcode_return_t),
njs_str("RETURN ") },
{ NJS_VMCODE_STOP, sizeof(njs_vmcode_stop_t),
njs_str("STOP ") },
{ NJS_VMCODE_INCREMENT, sizeof(njs_vmcode_3addr_t),
njs_str("INC ") },
{ NJS_VMCODE_DECREMENT, sizeof(njs_vmcode_3addr_t),
njs_str("DEC ") },
{ NJS_VMCODE_POST_INCREMENT, sizeof(njs_vmcode_3addr_t),
njs_str("POST INC ") },
{ NJS_VMCODE_POST_DECREMENT, sizeof(njs_vmcode_3addr_t),
njs_str("POST DEC ") },
{ NJS_VMCODE_DELETE, sizeof(njs_vmcode_2addr_t),
njs_str("DELETE ") },
{ NJS_VMCODE_VOID, sizeof(njs_vmcode_2addr_t),
njs_str("VOID ") },
{ NJS_VMCODE_TYPEOF, sizeof(njs_vmcode_2addr_t),
njs_str("TYPEOF ") },
{ NJS_VMCODE_TO_PROPERTY_KEY, sizeof(njs_vmcode_2addr_t),
njs_str("TO PROP KEY ") },
{ NJS_VMCODE_TO_PROPERTY_KEY_CHK, sizeof(njs_vmcode_3addr_t),
njs_str("TO PROP KEY CHK ") },
{ NJS_VMCODE_SET_FUNCTION_NAME, sizeof(njs_vmcode_2addr_t),
njs_str("SET FUNC NAME ") },
{ NJS_VMCODE_UNARY_PLUS, sizeof(njs_vmcode_2addr_t),
njs_str("PLUS ") },
{ NJS_VMCODE_UNARY_NEGATION, sizeof(njs_vmcode_2addr_t),
njs_str("NEGATION ") },
{ NJS_VMCODE_ADDITION, sizeof(njs_vmcode_3addr_t),
njs_str("ADD ") },
{ NJS_VMCODE_SUBSTRACTION, sizeof(njs_vmcode_3addr_t),
njs_str("SUBSTRACT ") },
{ NJS_VMCODE_MULTIPLICATION, sizeof(njs_vmcode_3addr_t),
njs_str("MULTIPLY ") },
{ NJS_VMCODE_EXPONENTIATION, sizeof(njs_vmcode_3addr_t),
njs_str("POWER ") },
{ NJS_VMCODE_DIVISION, sizeof(njs_vmcode_3addr_t),
njs_str("DIVIDE ") },
{ NJS_VMCODE_REMAINDER, sizeof(njs_vmcode_3addr_t),
njs_str("REMAINDER ") },
{ NJS_VMCODE_LEFT_SHIFT, sizeof(njs_vmcode_3addr_t),
njs_str("LEFT SHIFT ") },
{ NJS_VMCODE_RIGHT_SHIFT, sizeof(njs_vmcode_3addr_t),
njs_str("RIGHT SHIFT ") },
{ NJS_VMCODE_UNSIGNED_RIGHT_SHIFT, sizeof(njs_vmcode_3addr_t),
njs_str("USGN RIGHT SHIFT") },
{ NJS_VMCODE_LOGICAL_NOT, sizeof(njs_vmcode_2addr_t),
njs_str("LOGICAL NOT ") },
{ NJS_VMCODE_BITWISE_NOT, sizeof(njs_vmcode_2addr_t),
njs_str("BINARY NOT ") },
{ NJS_VMCODE_BITWISE_AND, sizeof(njs_vmcode_3addr_t),
njs_str("BINARY AND ") },
{ NJS_VMCODE_BITWISE_XOR, sizeof(njs_vmcode_3addr_t),
njs_str("BINARY XOR ") },
{ NJS_VMCODE_BITWISE_OR, sizeof(njs_vmcode_3addr_t),
njs_str("BINARY OR ") },
{ NJS_VMCODE_EQUAL, sizeof(njs_vmcode_3addr_t),
njs_str("EQUAL ") },
{ NJS_VMCODE_NOT_EQUAL, sizeof(njs_vmcode_3addr_t),
njs_str("NOT EQUAL ") },
{ NJS_VMCODE_LESS, sizeof(njs_vmcode_3addr_t),
njs_str("LESS ") },
{ NJS_VMCODE_LESS_OR_EQUAL, sizeof(njs_vmcode_3addr_t),
njs_str("LESS OR EQUAL ") },
{ NJS_VMCODE_GREATER, sizeof(njs_vmcode_3addr_t),
njs_str("GREATER ") },
{ NJS_VMCODE_GREATER_OR_EQUAL, sizeof(njs_vmcode_3addr_t),
njs_str("GREATER OR EQUAL") },
{ NJS_VMCODE_STRICT_EQUAL, sizeof(njs_vmcode_3addr_t),
njs_str("STRICT EQUAL ") },
{ NJS_VMCODE_STRICT_NOT_EQUAL, sizeof(njs_vmcode_3addr_t),
njs_str("STRICT NOT EQUAL") },
{ NJS_VMCODE_MOVE, sizeof(njs_vmcode_move_t),
njs_str("MOVE ") },
{ NJS_VMCODE_THROW, sizeof(njs_vmcode_throw_t),
njs_str("THROW ") },
{ NJS_VMCODE_LET, sizeof(njs_vmcode_variable_t),
njs_str("LET ") },
{ NJS_VMCODE_LET_UPDATE, sizeof(njs_vmcode_variable_t),
njs_str("LET UPDATE ") },
{ NJS_VMCODE_INITIALIZATION_TEST, sizeof(njs_vmcode_variable_t),
njs_str("INIT TEST ") },
{ NJS_VMCODE_NOT_INITIALIZED, sizeof(njs_vmcode_variable_t),
njs_str("NOT INIT ") },
{ NJS_VMCODE_ASSIGNMENT_ERROR, sizeof(njs_vmcode_variable_t),
njs_str("ASSIGNMENT ERROR") },
{ NJS_VMCODE_DEBUGGER, sizeof(njs_vmcode_debugger_t),
njs_str("DEBUGGER ") },
{ NJS_VMCODE_AWAIT, sizeof(njs_vmcode_await_t),
njs_str("AWAIT ") },
};
void
njs_disassembler(njs_vm_t *vm)
{
njs_uint_t n;
njs_vm_code_t *code;
code = vm->codes->start;
n = vm->codes->items;
while (n != 0) {
njs_printf("%V:%V\n", &code->file, &code->name);
njs_disassemble(code->start, code->end, -1, code->lines);
code++;
n--;
}
njs_printf("\n");
}
void
njs_disassemble(u_char *start, u_char *end, njs_int_t count, njs_arr_t *lines)
{
u_char *p;
uint32_t line;
njs_str_t *name;
njs_uint_t n;
const char *type;
njs_code_name_t *code_name;
njs_vmcode_jump_t *jump;
njs_vmcode_error_t *error;
njs_vmcode_1addr_t *code1;
njs_vmcode_2addr_t *code2;
njs_vmcode_3addr_t *code3;
njs_vmcode_array_t *array;
njs_vmcode_catch_t *catch;
njs_vmcode_import_t *import;
njs_vmcode_finally_t *finally;
njs_vmcode_try_end_t *try_end;
njs_vmcode_try_start_t *try_start;
njs_vmcode_operation_t operation;
njs_vmcode_cond_jump_t *cond_jump;
njs_vmcode_test_jump_t *test_jump;
njs_vmcode_prop_next_t *prop_next;
njs_vmcode_try_return_t *try_return;
njs_vmcode_equal_jump_t *equal;
njs_vmcode_prop_foreach_t *prop_foreach;
njs_vmcode_method_frame_t *method;
njs_vmcode_prop_accessor_t *prop_accessor;
njs_vmcode_try_trampoline_t *try_tramp;
njs_vmcode_function_frame_t *function;
/*
* On some 32-bit platform uintptr_t is int and compilers warn
* about %l format modifier. size_t has the size as pointer so
* there is no run-time overhead.
*/
p = start;
while (((p < end) && (count == -1)) || (count-- > 0)) {
operation = *(njs_vmcode_operation_t *) p;
line = njs_lookup_line(lines, p - start);
if (operation == NJS_VMCODE_ARRAY) {
array = (njs_vmcode_array_t *) p;
njs_printf("%5uD | %05uz ARRAY %04Xz %uz%s\n",
line, p - start, (size_t) array->retval,
(size_t) array->length, array->ctor ? " INIT" : "");
p += sizeof(njs_vmcode_array_t);
continue;
}
if (operation == NJS_VMCODE_IF_TRUE_JUMP) {
cond_jump = (njs_vmcode_cond_jump_t *) p;
njs_printf("%5uD | %05uz JUMP IF TRUE %04Xz %z\n",
line, p - start, (size_t) cond_jump->cond,
(size_t) cond_jump->offset);
p += sizeof(njs_vmcode_cond_jump_t);
continue;
}
if (operation == NJS_VMCODE_IF_FALSE_JUMP) {
cond_jump = (njs_vmcode_cond_jump_t *) p;
njs_printf("%5uD | %05uz JUMP IF FALSE %04Xz %z\n",
line, p - start, (size_t) cond_jump->cond,
(size_t) cond_jump->offset);
p += sizeof(njs_vmcode_cond_jump_t);
continue;
}
if (operation == NJS_VMCODE_JUMP) {
jump = (njs_vmcode_jump_t *) p;
njs_printf("%5uD | %05uz JUMP %z\n",
line, p - start, (size_t) jump->offset);
p += sizeof(njs_vmcode_jump_t);
continue;
}
if (operation == NJS_VMCODE_IF_EQUAL_JUMP) {
equal = (njs_vmcode_equal_jump_t *) p;
njs_printf("%5uD | %05uz JUMP IF EQUAL %04Xz %04Xz %z\n",
line, p - start, (size_t) equal->value1,
(size_t) equal->value2, (size_t) equal->offset);
p += sizeof(njs_vmcode_equal_jump_t);
continue;
}
if (operation == NJS_VMCODE_TEST_IF_TRUE) {
test_jump = (njs_vmcode_test_jump_t *) p;
njs_printf("%5uD | %05uz TEST IF TRUE %04Xz %04Xz %z\n",
line, p - start, (size_t) test_jump->retval,
(size_t) test_jump->value, (size_t) test_jump->offset);
p += sizeof(njs_vmcode_test_jump_t);
continue;
}
if (operation == NJS_VMCODE_TEST_IF_FALSE) {
test_jump = (njs_vmcode_test_jump_t *) p;
njs_printf("%5uD | %05uz TEST IF FALSE %04Xz %04Xz %z\n",
line, p - start, (size_t) test_jump->retval,
(size_t) test_jump->value, (size_t) test_jump->offset);
p += sizeof(njs_vmcode_test_jump_t);
continue;
}
if (operation == NJS_VMCODE_COALESCE) {
test_jump = (njs_vmcode_test_jump_t *) p;
njs_printf("%5uD | %05uz COALESCE %04Xz %04Xz %z\n",
line, p - start, (size_t) test_jump->retval,
(size_t) test_jump->value, (size_t) test_jump->offset);
p += sizeof(njs_vmcode_test_jump_t);
continue;
}
if (operation == NJS_VMCODE_FUNCTION_FRAME) {
function = (njs_vmcode_function_frame_t *) p;
njs_printf("%5uD | %05uz FUNCTION FRAME %04Xz %uz%s\n",
line, p - start, (size_t) function->name,
function->nargs, function->ctor ? " CTOR" : "");
p += sizeof(njs_vmcode_function_frame_t);
continue;
}
if (operation == NJS_VMCODE_METHOD_FRAME) {
method = (njs_vmcode_method_frame_t *) p;
njs_printf("%5uD | %05uz METHOD FRAME %04Xz %04Xz %uz%s\n",
line, p - start, (size_t) method->object,
(size_t) method->method, method->nargs,
method->ctor ? " CTOR" : "");
p += sizeof(njs_vmcode_method_frame_t);
continue;
}
if (operation == NJS_VMCODE_PROPERTY_FOREACH) {
prop_foreach = (njs_vmcode_prop_foreach_t *) p;
njs_printf("%5uD | %05uz PROP FOREACH %04Xz %04Xz %z\n",
line, p - start, (size_t) prop_foreach->next,
(size_t) prop_foreach->object,
(size_t) prop_foreach->offset);
p += sizeof(njs_vmcode_prop_foreach_t);
continue;
}
if (operation == NJS_VMCODE_PROPERTY_NEXT) {
prop_next = (njs_vmcode_prop_next_t *) p;
njs_printf("%5uD | %05uz PROP NEXT %04Xz %04Xz %04Xz %z\n",
line, p - start, (size_t) prop_next->retval,
(size_t) prop_next->object, (size_t) prop_next->next,
(size_t) prop_next->offset);
p += sizeof(njs_vmcode_prop_next_t);
continue;
}
if (operation == NJS_VMCODE_PROPERTY_ACCESSOR) {
prop_accessor = (njs_vmcode_prop_accessor_t *) p;
njs_printf("%5uD | %05uz PROP %s ACCESSOR %04Xz %04Xz %04Xz\n",
line, p - start,
(prop_accessor->type == NJS_OBJECT_PROP_GETTER)
? "GET" : "SET",
(size_t) prop_accessor->value,
(size_t) prop_accessor->object,
(size_t) prop_accessor->property);
p += sizeof(njs_vmcode_prop_accessor_t);
continue;
}
if (operation == NJS_VMCODE_IMPORT) {
import = (njs_vmcode_import_t *) p;
njs_printf("%5uD | %05uz IMPORT %04Xz %V\n",
line, p - start, (size_t) import->retval,
&import->module->name);
p += sizeof(njs_vmcode_import_t);
continue;
}
if (operation == NJS_VMCODE_TRY_START) {
try_start = (njs_vmcode_try_start_t *) p;
njs_printf("%5uD | %05uz TRY START %04Xz %04Xz %z\n",
line, p - start, (size_t) try_start->exception_value,
(size_t) try_start->exit_value,
(size_t) try_start->offset);
p += sizeof(njs_vmcode_try_start_t);
continue;
}
if (operation == NJS_VMCODE_TRY_BREAK) {
try_tramp = (njs_vmcode_try_trampoline_t *) p;
njs_printf("%5uD | %05uz TRY BREAK %04Xz %z\n",
line, p - start, (size_t) try_tramp->exit_value,
(size_t) try_tramp->offset);
p += sizeof(njs_vmcode_try_trampoline_t);
continue;
}
if (operation == NJS_VMCODE_TRY_CONTINUE) {
try_tramp = (njs_vmcode_try_trampoline_t *) p;
njs_printf("%5uD | %05uz TRY CONTINUE %04Xz %z\n",
line, p - start, (size_t) try_tramp->exit_value,
(size_t) try_tramp->offset);
p += sizeof(njs_vmcode_try_trampoline_t);
continue;
}
if (operation == NJS_VMCODE_TRY_RETURN) {
try_return = (njs_vmcode_try_return_t *) p;
njs_printf("%5uD | %05uz TRY RETURN %04Xz %04Xz %z\n",
line, p - start, (size_t) try_return->save,
(size_t) try_return->retval,
(size_t) try_return->offset);
p += sizeof(njs_vmcode_try_return_t);
continue;
}
if (operation == NJS_VMCODE_CATCH) {
catch = (njs_vmcode_catch_t *) p;
njs_printf("%5uD | %05uz CATCH %04Xz %z\n",
line, p - start, (size_t) catch->exception,
(size_t) catch->offset);
p += sizeof(njs_vmcode_catch_t);
continue;
}
if (operation == NJS_VMCODE_TRY_END) {
try_end = (njs_vmcode_try_end_t *) p;
njs_printf("%5uD | %05uz TRY END %z\n",
line, p - start, (size_t) try_end->offset);
p += sizeof(njs_vmcode_try_end_t);
continue;
}
if (operation == NJS_VMCODE_FINALLY) {
finally = (njs_vmcode_finally_t *) p;
njs_printf("%5uD | %05uz TRY FINALLY %04Xz %04Xz %z %z\n",
line, p - start, (size_t) finally->retval,
(size_t) finally->exit_value,
(size_t) finally->continue_offset,
(size_t) finally->break_offset);
p += sizeof(njs_vmcode_finally_t);
continue;
}
if (operation == NJS_VMCODE_ERROR) {
error = (njs_vmcode_error_t *) p;
switch (error->type) {
case NJS_OBJ_TYPE_REF_ERROR:
type = "REFERENCE";
break;
case NJS_OBJ_TYPE_TYPE_ERROR:
type = "TYPE";
break;
case NJS_OBJ_TYPE_ERROR:
default:
type = "";
}
njs_printf("%5uD | %05uz %s ERROR\n", line, p - start, type);
p += sizeof(njs_vmcode_error_t);
continue;
}
code_name = code_names;
n = njs_nitems(code_names);
do {
if (operation == code_name->operation) {
name = &code_name->name;
if (code_name->size == sizeof(njs_vmcode_3addr_t)) {
code3 = (njs_vmcode_3addr_t *) p;
njs_printf("%5uD | %05uz %*s %04Xz %04Xz %04Xz\n",
line, p - start, name->length, name->start,
(size_t) code3->dst, (size_t) code3->src1,
(size_t) code3->src2);
} else if (code_name->size == sizeof(njs_vmcode_2addr_t)) {
code2 = (njs_vmcode_2addr_t *) p;
njs_printf("%5uD | %05uz %*s %04Xz %04Xz\n",
line, p - start, name->length, name->start,
(size_t) code2->dst, (size_t) code2->src);
} else if (code_name->size == sizeof(njs_vmcode_1addr_t)) {
code1 = (njs_vmcode_1addr_t *) p;
njs_printf("%5uD | %05uz %*s %04Xz\n",
line, p - start, name->length, name->start,
(size_t) code1->index);
}
p += code_name->size;
goto next;
}
code_name++;
n--;
} while (n != 0);
njs_printf("%5uD | %05uz UNKNOWN %04Xz\n", line,
p - start, (size_t) (uintptr_t) operation);
p += sizeof(njs_vmcode_operation_t);
next:
continue;
}
}

149
modules_deb/libnginx-mod-js-0.7.9/src/njs_diyfp.c
View file

@ -1,149 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* An internal diy_fp implementation.
* For details, see Loitsch, Florian. "Printing floating-point numbers quickly
* and accurately with integers." ACM Sigplan Notices 45.6 (2010): 233-243.
*/
#include <njs_main.h>
#include <njs_diyfp.h>
typedef struct njs_cpe_s {
uint64_t significand;
int16_t bin_exp;
int16_t dec_exp;
} njs_cpe_t;
static const njs_cpe_t njs_cached_powers[] = {
{ njs_uint64(0xfa8fd5a0, 0x081c0288), -1220, -348 },
{ njs_uint64(0xbaaee17f, 0xa23ebf76), -1193, -340 },
{ njs_uint64(0x8b16fb20, 0x3055ac76), -1166, -332 },
{ njs_uint64(0xcf42894a, 0x5dce35ea), -1140, -324 },
{ njs_uint64(0x9a6bb0aa, 0x55653b2d), -1113, -316 },
{ njs_uint64(0xe61acf03, 0x3d1a45df), -1087, -308 },
{ njs_uint64(0xab70fe17, 0xc79ac6ca), -1060, -300 },
{ njs_uint64(0xff77b1fc, 0xbebcdc4f), -1034, -292 },
{ njs_uint64(0xbe5691ef, 0x416bd60c), -1007, -284 },
{ njs_uint64(0x8dd01fad, 0x907ffc3c), -980, -276 },
{ njs_uint64(0xd3515c28, 0x31559a83), -954, -268 },
{ njs_uint64(0x9d71ac8f, 0xada6c9b5), -927, -260 },
{ njs_uint64(0xea9c2277, 0x23ee8bcb), -901, -252 },
{ njs_uint64(0xaecc4991, 0x4078536d), -874, -244 },
{ njs_uint64(0x823c1279, 0x5db6ce57), -847, -236 },
{ njs_uint64(0xc2109436, 0x4dfb5637), -821, -228 },
{ njs_uint64(0x9096ea6f, 0x3848984f), -794, -220 },
{ njs_uint64(0xd77485cb, 0x25823ac7), -768, -212 },
{ njs_uint64(0xa086cfcd, 0x97bf97f4), -741, -204 },
{ njs_uint64(0xef340a98, 0x172aace5), -715, -196 },
{ njs_uint64(0xb23867fb, 0x2a35b28e), -688, -188 },
{ njs_uint64(0x84c8d4df, 0xd2c63f3b), -661, -180 },
{ njs_uint64(0xc5dd4427, 0x1ad3cdba), -635, -172 },
{ njs_uint64(0x936b9fce, 0xbb25c996), -608, -164 },
{ njs_uint64(0xdbac6c24, 0x7d62a584), -582, -156 },
{ njs_uint64(0xa3ab6658, 0x0d5fdaf6), -555, -148 },
{ njs_uint64(0xf3e2f893, 0xdec3f126), -529, -140 },
{ njs_uint64(0xb5b5ada8, 0xaaff80b8), -502, -132 },
{ njs_uint64(0x87625f05, 0x6c7c4a8b), -475, -124 },
{ njs_uint64(0xc9bcff60, 0x34c13053), -449, -116 },
{ njs_uint64(0x964e858c, 0x91ba2655), -422, -108 },
{ njs_uint64(0xdff97724, 0x70297ebd), -396, -100 },
{ njs_uint64(0xa6dfbd9f, 0xb8e5b88f), -369, -92 },
{ njs_uint64(0xf8a95fcf, 0x88747d94), -343, -84 },
{ njs_uint64(0xb9447093, 0x8fa89bcf), -316, -76 },
{ njs_uint64(0x8a08f0f8, 0xbf0f156b), -289, -68 },
{ njs_uint64(0xcdb02555, 0x653131b6), -263, -60 },
{ njs_uint64(0x993fe2c6, 0xd07b7fac), -236, -52 },
{ njs_uint64(0xe45c10c4, 0x2a2b3b06), -210, -44 },
{ njs_uint64(0xaa242499, 0x697392d3), -183, -36 },
{ njs_uint64(0xfd87b5f2, 0x8300ca0e), -157, -28 },
{ njs_uint64(0xbce50864, 0x92111aeb), -130, -20 },
{ njs_uint64(0x8cbccc09, 0x6f5088cc), -103, -12 },
{ njs_uint64(0xd1b71758, 0xe219652c), -77, -4 },
{ njs_uint64(0x9c400000, 0x00000000), -50, 4 },
{ njs_uint64(0xe8d4a510, 0x00000000), -24, 12 },
{ njs_uint64(0xad78ebc5, 0xac620000), 3, 20 },
{ njs_uint64(0x813f3978, 0xf8940984), 30, 28 },
{ njs_uint64(0xc097ce7b, 0xc90715b3), 56, 36 },
{ njs_uint64(0x8f7e32ce, 0x7bea5c70), 83, 44 },
{ njs_uint64(0xd5d238a4, 0xabe98068), 109, 52 },
{ njs_uint64(0x9f4f2726, 0x179a2245), 136, 60 },
{ njs_uint64(0xed63a231, 0xd4c4fb27), 162, 68 },
{ njs_uint64(0xb0de6538, 0x8cc8ada8), 189, 76 },
{ njs_uint64(0x83c7088e, 0x1aab65db), 216, 84 },
{ njs_uint64(0xc45d1df9, 0x42711d9a), 242, 92 },
{ njs_uint64(0x924d692c, 0xa61be758), 269, 100 },
{ njs_uint64(0xda01ee64, 0x1a708dea), 295, 108 },
{ njs_uint64(0xa26da399, 0x9aef774a), 322, 116 },
{ njs_uint64(0xf209787b, 0xb47d6b85), 348, 124 },
{ njs_uint64(0xb454e4a1, 0x79dd1877), 375, 132 },
{ njs_uint64(0x865b8692, 0x5b9bc5c2), 402, 140 },
{ njs_uint64(0xc83553c5, 0xc8965d3d), 428, 148 },
{ njs_uint64(0x952ab45c, 0xfa97a0b3), 455, 156 },
{ njs_uint64(0xde469fbd, 0x99a05fe3), 481, 164 },
{ njs_uint64(0xa59bc234, 0xdb398c25), 508, 172 },
{ njs_uint64(0xf6c69a72, 0xa3989f5c), 534, 180 },
{ njs_uint64(0xb7dcbf53, 0x54e9bece), 561, 188 },
{ njs_uint64(0x88fcf317, 0xf22241e2), 588, 196 },
{ njs_uint64(0xcc20ce9b, 0xd35c78a5), 614, 204 },
{ njs_uint64(0x98165af3, 0x7b2153df), 641, 212 },
{ njs_uint64(0xe2a0b5dc, 0x971f303a), 667, 220 },
{ njs_uint64(0xa8d9d153, 0x5ce3b396), 694, 228 },
{ njs_uint64(0xfb9b7cd9, 0xa4a7443c), 720, 236 },
{ njs_uint64(0xbb764c4c, 0xa7a44410), 747, 244 },
{ njs_uint64(0x8bab8eef, 0xb6409c1a), 774, 252 },
{ njs_uint64(0xd01fef10, 0xa657842c), 800, 260 },
{ njs_uint64(0x9b10a4e5, 0xe9913129), 827, 268 },
{ njs_uint64(0xe7109bfb, 0xa19c0c9d), 853, 276 },
{ njs_uint64(0xac2820d9, 0x623bf429), 880, 284 },
{ njs_uint64(0x80444b5e, 0x7aa7cf85), 907, 292 },
{ njs_uint64(0xbf21e440, 0x03acdd2d), 933, 300 },
{ njs_uint64(0x8e679c2f, 0x5e44ff8f), 960, 308 },
{ njs_uint64(0xd433179d, 0x9c8cb841), 986, 316 },
{ njs_uint64(0x9e19db92, 0xb4e31ba9), 1013, 324 },
{ njs_uint64(0xeb96bf6e, 0xbadf77d9), 1039, 332 },
{ njs_uint64(0xaf87023b, 0x9bf0ee6b), 1066, 340 },
};
#define NJS_D_1_LOG2_10 0.30102999566398114 /* 1 / log2(10). */
njs_diyfp_t
njs_cached_power_dec(int exp, int *dec_exp)
{
u_int index;
const njs_cpe_t *cp;
index = (exp + NJS_DECIMAL_EXPONENT_OFF) / NJS_DECIMAL_EXPONENT_DIST;
cp = &njs_cached_powers[index];
*dec_exp = cp->dec_exp;
return njs_diyfp(cp->significand, cp->bin_exp);
}
njs_diyfp_t
njs_cached_power_bin(int exp, int *dec_exp)
{
int k;
u_int index;
const njs_cpe_t *cp;
k = (int) ceil((-61 - exp) * NJS_D_1_LOG2_10)
+ NJS_DECIMAL_EXPONENT_OFF - 1;
index = (unsigned) (k >> 3) + 1;
cp = &njs_cached_powers[index];
*dec_exp = -(NJS_DECIMAL_EXPONENT_MIN + (int) (index << 3));
return njs_diyfp(cp->significand, cp->bin_exp);
}

214
modules_deb/libnginx-mod-js-0.7.9/src/njs_diyfp.h
View file

@ -1,214 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* An internal diy_fp implementation.
* For details, see Loitsch, Florian. "Printing floating-point numbers quickly
* and accurately with integers." ACM Sigplan Notices 45.6 (2010): 233-243.
*/
#ifndef _NJS_DIYFP_H_INCLUDED_
#define _NJS_DIYFP_H_INCLUDED_
typedef struct {
uint64_t significand;
int exp;
} njs_diyfp_t;
typedef union {
double d;
uint64_t u64;
} njs_diyfp_conv_t;
#define njs_diyfp(_s, _e) (njs_diyfp_t) \
{ .significand = (_s), .exp = (_e) }
#define njs_uint64(h, l) (((uint64_t) (h) << 32) + (l))
#define NJS_DBL_SIGNIFICAND_SIZE 52
#define NJS_DBL_EXPONENT_OFFSET ((int64_t) 0x3ff)
#define NJS_DBL_EXPONENT_BIAS (NJS_DBL_EXPONENT_OFFSET \
+ NJS_DBL_SIGNIFICAND_SIZE)
#define NJS_DBL_EXPONENT_MIN (-NJS_DBL_EXPONENT_BIAS)
#define NJS_DBL_EXPONENT_MAX (0x7ff - NJS_DBL_EXPONENT_BIAS)
#define NJS_DBL_EXPONENT_DENORMAL (-NJS_DBL_EXPONENT_BIAS + 1)
#define NJS_DBL_SIGNIFICAND_MASK njs_uint64(0x000FFFFF, 0xFFFFFFFF)
#define NJS_DBL_HIDDEN_BIT njs_uint64(0x00100000, 0x00000000)
#define NJS_DBL_EXPONENT_MASK njs_uint64(0x7FF00000, 0x00000000)
#define NJS_DBL_SIGN_MASK njs_uint64(0x80000000, 0x00000000)
#define NJS_DIYFP_SIGNIFICAND_SIZE 64
#define NJS_SIGNIFICAND_SIZE 53
#define NJS_SIGNIFICAND_SHIFT (NJS_DIYFP_SIGNIFICAND_SIZE \
- NJS_DBL_SIGNIFICAND_SIZE)
#define NJS_DECIMAL_EXPONENT_OFF 348
#define NJS_DECIMAL_EXPONENT_MIN (-348)
#define NJS_DECIMAL_EXPONENT_MAX 340
#define NJS_DECIMAL_EXPONENT_DIST 8
njs_inline njs_diyfp_t
njs_d2diyfp(double d)
{
int biased_exp;
uint64_t significand;
njs_diyfp_t r;
union {
double d;
uint64_t u64;
} u;
u.d = d;
biased_exp = (u.u64 & NJS_DBL_EXPONENT_MASK) >> NJS_DBL_SIGNIFICAND_SIZE;
significand = u.u64 & NJS_DBL_SIGNIFICAND_MASK;
if (biased_exp != 0) {
r.significand = significand + NJS_DBL_HIDDEN_BIT;
r.exp = biased_exp - NJS_DBL_EXPONENT_BIAS;
} else {
r.significand = significand;
r.exp = NJS_DBL_EXPONENT_MIN + 1;
}
return r;
}
njs_inline double
njs_diyfp2d(njs_diyfp_t v)
{
int exp;
uint64_t significand, biased_exp;
njs_diyfp_conv_t conv;
exp = v.exp;
significand = v.significand;
while (significand > NJS_DBL_HIDDEN_BIT + NJS_DBL_SIGNIFICAND_MASK) {
significand >>= 1;
exp++;
}
if (exp >= NJS_DBL_EXPONENT_MAX) {
return INFINITY;
}
if (exp < NJS_DBL_EXPONENT_DENORMAL) {
return 0.0;
}
while (exp > NJS_DBL_EXPONENT_DENORMAL
&& (significand & NJS_DBL_HIDDEN_BIT) == 0)
{
significand <<= 1;
exp--;
}
if (exp == NJS_DBL_EXPONENT_DENORMAL
&& (significand & NJS_DBL_HIDDEN_BIT) == 0)
{
biased_exp = 0;
} else {
biased_exp = (uint64_t) (exp + NJS_DBL_EXPONENT_BIAS);
}
conv.u64 = (significand & NJS_DBL_SIGNIFICAND_MASK)
| (biased_exp << NJS_DBL_SIGNIFICAND_SIZE);
return conv.d;
}
njs_inline njs_diyfp_t
njs_diyfp_shift_left(njs_diyfp_t v, unsigned shift)
{
return njs_diyfp(v.significand << shift, v.exp - shift);
}
njs_inline njs_diyfp_t
njs_diyfp_shift_right(njs_diyfp_t v, unsigned shift)
{
return njs_diyfp(v.significand >> shift, v.exp + shift);
}
njs_inline njs_diyfp_t
njs_diyfp_sub(njs_diyfp_t lhs, njs_diyfp_t rhs)
{
return njs_diyfp(lhs.significand - rhs.significand, lhs.exp);
}
njs_inline njs_diyfp_t
njs_diyfp_mul(njs_diyfp_t lhs, njs_diyfp_t rhs)
{
#if (NJS_HAVE_UNSIGNED_INT128)
uint64_t l, h;
njs_uint128_t u128;
u128 = (njs_uint128_t) (lhs.significand)
* (njs_uint128_t) (rhs.significand);
h = u128 >> 64;
l = (uint64_t) u128;
/* rounding. */
if (l & ((uint64_t) 1 << 63)) {
h++;
}
return njs_diyfp(h, lhs.exp + rhs.exp + 64);
#else
uint64_t a, b, c, d, ac, bc, ad, bd, tmp;
a = lhs.significand >> 32;
b = lhs.significand & 0xffffffff;
c = rhs.significand >> 32;
d = rhs.significand & 0xffffffff;
ac = a * c;
bc = b * c;
ad = a * d;
bd = b * d;
tmp = (bd >> 32) + (ad & 0xffffffff) + (bc & 0xffffffff);
/* mult_round. */
tmp += 1U << 31;
return njs_diyfp(ac + (ad >> 32) + (bc >> 32) + (tmp >> 32),
lhs.exp + rhs.exp + 64);
#endif
}
njs_inline njs_diyfp_t
njs_diyfp_normalize(njs_diyfp_t v)
{
return njs_diyfp_shift_left(v, njs_leading_zeros64(v.significand));
}
njs_diyfp_t njs_cached_power_dec(int exp, int *dec_exp);
njs_diyfp_t njs_cached_power_bin(int exp, int *dec_exp);
#endif /* _NJS_DIYFP_H_INCLUDED_ */

44
modules_deb/libnginx-mod-js-0.7.9/src/njs_djb_hash.c
View file

@ -1,44 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
uint32_t
njs_djb_hash(const void *data, size_t len)
{
uint32_t hash;
const u_char *p;
p = data;
hash = NJS_DJB_HASH_INIT;
while (len != 0) {
hash = njs_djb_hash_add(hash, *p++);
len--;
}
return hash;
}
uint32_t
njs_djb_hash_lowcase(const void *data, size_t len)
{
uint32_t hash;
const u_char *p;
p = data;
hash = NJS_DJB_HASH_INIT;
while (len != 0) {
hash = njs_djb_hash_add(hash, njs_lower_case(*p++));
len--;
}
return hash;
}

25
modules_deb/libnginx-mod-js-0.7.9/src/njs_djb_hash.h
View file

@ -1,25 +0,0 @@
/*
* Copyright (C) Igor Sysoev
* Copyright (C) NGINX, Inc.
*/
#ifndef _NJS_DJB_HASH_H_INCLUDED_
#define _NJS_DJB_HASH_H_INCLUDED_
/* A fast and simple hash function by Daniel J. Bernstein. */
NJS_EXPORT uint32_t njs_djb_hash(const void *data, size_t len);
NJS_EXPORT uint32_t njs_djb_hash_lowcase(const void *data, size_t len);
#define NJS_DJB_HASH_INIT 5381
#define njs_djb_hash_add(hash, val) \
((uint32_t) ((((hash) << 5) + (hash)) ^ (uint32_t) (val)))
#endif /* _NJS_DJB_HASH_H_INCLUDED_ */

657
modules_deb/libnginx-mod-js-0.7.9/src/njs_dtoa.c
View file

@ -1,657 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* Grisu2 algorithm implementation for printing floating-point numbers based
* upon the work of Milo Yip and Doug Currie.
*
* For algorithm information, see Loitsch, Florian. "Printing
* floating-point numbers quickly and accurately with integers." ACM Sigplan
* Notices 45.6 (2010): 233-243.
*
* Copyright (C) 2015 Doug Currie
* based on dtoa_milo.h
* Copyright (C) 2014 Milo Yip
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include <njs_main.h>
#include <njs_diyfp.h>
#include <njs_dtoa.h>
njs_inline void
njs_round(char *start, size_t length, uint64_t delta, uint64_t rest,
uint64_t ten_kappa, uint64_t margin)
{
while (rest < margin && delta - rest >= ten_kappa
&& (rest + ten_kappa < margin || /* closer */
margin - rest > rest + ten_kappa - margin))
{
start[length - 1]--;
rest += ten_kappa;
}
}
njs_inline void
njs_round_prec(char *start, size_t length, uint64_t rest, uint64_t ten_kappa,
uint64_t unit, int *kappa)
{
njs_int_t i;
if (unit >= ten_kappa || ten_kappa - unit <= unit) {
return;
}
if ((ten_kappa - rest > rest) && (ten_kappa - 2 * rest >= 2 * unit)) {
return;
}
if ((rest > unit) && (ten_kappa - (rest - unit) <= (rest - unit))) {
start[length - 1]++;
for (i = length - 1; i > 0; --i) {
if (start[i] != '0' + 10) {
break;
}
start[i] = '0';
start[i - 1]++;
}
if (start[0] == '0' + 10) {
start[0] = '1';
*kappa += 1;
}
}
}
njs_inline int
njs_dec_count(uint32_t n)
{
if (n < 10000) {
if (n < 100) {
return (n < 10) ? 1 : 2;
} else {
return (n < 1000) ? 3 : 4;
}
} else {
if (n < 1000000) {
return (n < 100000) ? 5 : 6;
} else {
if (n < 100000000) {
return (n < 10000000) ? 7 : 8;
} else {
return (n < 1000000000) ? 9 : 10;
}
}
}
}
njs_inline size_t
njs_digit_gen(njs_diyfp_t v, njs_diyfp_t high, uint64_t delta, char *start,
int *dec_exp)
{
int kappa;
char *p;
uint32_t integer, d;
uint64_t fraction, rest, margin;
njs_diyfp_t one;
static const uint64_t pow10[] = {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000
};
one = njs_diyfp((uint64_t) 1 << -high.exp, high.exp);
integer = (uint32_t) (high.significand >> -one.exp);
fraction = high.significand & (one.significand - 1);
margin = njs_diyfp_sub(high, v).significand;
p = start;
kappa = njs_dec_count(integer);
while (kappa > 0) {
switch (kappa) {
case 10: d = integer / 1000000000; integer %= 1000000000; break;
case 9: d = integer / 100000000; integer %= 100000000; break;
case 8: d = integer / 10000000; integer %= 10000000; break;
case 7: d = integer / 1000000; integer %= 1000000; break;
case 6: d = integer / 100000; integer %= 100000; break;
case 5: d = integer / 10000; integer %= 10000; break;
case 4: d = integer / 1000; integer %= 1000; break;
case 3: d = integer / 100; integer %= 100; break;
case 2: d = integer / 10; integer %= 10; break;
default: d = integer; integer = 0; break;
}
if (d != 0 || p != start) {
*p++ = '0' + d;
}
kappa--;
rest = ((uint64_t) integer << -one.exp) + fraction;
if (rest < delta) {
*dec_exp += kappa;
njs_round(start, p - start, delta, rest, pow10[kappa] << -one.exp,
margin);
return p - start;
}
}
/* kappa = 0. */
for ( ;; ) {
fraction *= 10;
delta *= 10;
d = (uint32_t) (fraction >> -one.exp);
if (d != 0 || p != start) {
*p++ = '0' + d;
}
fraction &= one.significand - 1;
kappa--;
if (fraction < delta) {
*dec_exp += kappa;
margin *= (-kappa < 10) ? pow10[-kappa] : 0;
njs_round(start, p - start, delta, fraction, one.significand,
margin);
return p - start;
}
}
}
njs_inline size_t
njs_digit_gen_prec(njs_diyfp_t v, size_t prec, char *start, int *dec_exp)
{
int kappa;
char *p;
uint32_t integer, divisor;
uint64_t fraction, rest, error;
njs_diyfp_t one;
static const uint64_t pow10[] = {
1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000
};
one = njs_diyfp((uint64_t) 1 << -v.exp, v.exp);
integer = (uint32_t) (v.significand >> -one.exp);
fraction = v.significand & (one.significand - 1);
error = 1;
p = start;
kappa = njs_dec_count(integer);
while (kappa > 0) {
divisor = pow10[kappa - 1];
*p++ = '0' + integer / divisor;
integer %= divisor;
kappa--;
prec--;
if (prec == 0) {
rest = ((uint64_t) integer << -one.exp) + fraction;
njs_round_prec(start, p - start, rest, pow10[kappa] << -one.exp,
error, &kappa);
*dec_exp += kappa;
return p - start;
}
}
/* kappa = 0. */
while (prec > 0 && fraction > error) {
fraction *= 10;
error *= 10;
*p++ = '0' + (fraction >> -one.exp);
fraction &= one.significand - 1;
kappa--;
prec--;
}
njs_round_prec(start, p - start, fraction, one.significand, error, &kappa);
*dec_exp += kappa;
return p - start;
}
njs_inline njs_diyfp_t
njs_diyfp_normalize_boundary(njs_diyfp_t v)
{
while ((v.significand & (NJS_DBL_HIDDEN_BIT << 1)) == 0) {
v.significand <<= 1;
v.exp--;
}
return njs_diyfp_shift_left(v, NJS_SIGNIFICAND_SHIFT - 2);
}
njs_inline void
njs_diyfp_normalize_boundaries(njs_diyfp_t v, njs_diyfp_t* minus,
njs_diyfp_t* plus)
{
njs_diyfp_t pl, mi;
pl = njs_diyfp_normalize_boundary(njs_diyfp((v.significand << 1) + 1,
v.exp - 1));
if (v.significand == NJS_DBL_HIDDEN_BIT) {
mi = njs_diyfp((v.significand << 2) - 1, v.exp - 2);
} else {
mi = njs_diyfp((v.significand << 1) - 1, v.exp - 1);
}
mi.significand <<= mi.exp - pl.exp;
mi.exp = pl.exp;
*plus = pl;
*minus = mi;
}
/*
* Grisu2 produces optimal (shortest) decimal representation for 99.8%
* of IEEE doubles. For remaining 0.2% bignum algorithm like Dragon4 is requred.
*/
njs_inline size_t
njs_grisu2(double value, char *start, int *point)
{
int dec_exp;
size_t length;
njs_diyfp_t v, low, high, ten_mk, scaled_v, scaled_low, scaled_high;
v = njs_d2diyfp(value);
njs_diyfp_normalize_boundaries(v, &low, &high);
ten_mk = njs_cached_power_bin(high.exp, &dec_exp);
scaled_v = njs_diyfp_mul(njs_diyfp_normalize(v), ten_mk);
scaled_low = njs_diyfp_mul(low, ten_mk);
scaled_high = njs_diyfp_mul(high, ten_mk);
scaled_low.significand++;
scaled_high.significand--;
length = njs_digit_gen(scaled_v, scaled_high,
scaled_high.significand - scaled_low.significand,
start, &dec_exp);
*point = length + dec_exp;
return length;
}
njs_inline size_t
njs_grisu2_prec(double value, char *start, size_t prec, int *point)
{
int dec_exp;
size_t length;
njs_diyfp_t v, ten_mk, scaled_v;
v = njs_diyfp_normalize(njs_d2diyfp(value));
ten_mk = njs_cached_power_bin(v.exp, &dec_exp);
scaled_v = njs_diyfp_mul(v, ten_mk);
length = njs_digit_gen_prec(scaled_v, prec, start, &dec_exp);
*point = length + dec_exp;
return length;
}
njs_inline size_t
njs_write_exponent(int exp, char *start)
{
char *p;
size_t length;
uint32_t u32;
char buf[4];
/* -324 <= exp <= 308. */
if (exp < 0) {
*start++ = '-';
exp = -exp;
} else {
*start++ = '+';
}
u32 = exp;
p = buf + njs_length(buf);
do {
*--p = u32 % 10 + '0';
u32 /= 10;
} while (u32 != 0);
length = buf + njs_length(buf) - p;
memcpy(start, p, length);
return length + 1;
}
njs_inline size_t
njs_dtoa_format(char *start, size_t len, int point)
{
int offset, length;
size_t size;
length = (int) len;
if (length <= point && point <= 21) {
/* 1234e7 -> 12340000000 */
if (point - length > 0) {
njs_memset(&start[length], '0', point - length);
}
return point;
}
if (0 < point && point <= 21) {
/* 1234e-2 -> 12.34 */
memmove(&start[point + 1], &start[point], length - point);
start[point] = '.';
return length + 1;
}
if (-6 < point && point <= 0) {
/* 1234e-6 -> 0.001234 */
offset = 2 - point;
memmove(&start[offset], start, length);
start[0] = '0';
start[1] = '.';
if (offset - 2 > 0) {
njs_memset(&start[2], '0', offset - 2);
}
return length + offset;
}
/* 1234e30 -> 1.234e33 */
if (length == 1) {
/* 1e30 */
start[1] = 'e';
size = njs_write_exponent(point - 1, &start[2]);
return size + 2;
}
memmove(&start[2], &start[1], length - 1);
start[1] = '.';
start[length + 1] = 'e';
size = njs_write_exponent(point - 1, &start[length + 2]);
return size + length + 2;
}
njs_inline size_t
njs_dtoa_exp_format(char *start, int exponent, size_t prec, size_t len)
{
char *p;
p = &start[len];
if (prec != 1) {
memmove(&start[2], &start[1], len - 1);
start[1] = '.';
p++;
}
njs_memset(p, '0', prec - len);
p += prec - len;
*p++ = 'e';
return prec + 1 + (prec != 1) + njs_write_exponent(exponent, p);
}
njs_inline size_t
njs_dtoa_prec_format(char *start, size_t prec, size_t len, int point)
{
int exponent;
size_t m, rest;
exponent = point - 1;
if (exponent < -6 || exponent >= (int) prec) {
return njs_dtoa_exp_format(start, exponent, prec, len);
}
/* Fixed notation. */
if (point <= 0) {
/* 1234e-2 => 0.001234000 */
memmove(&start[2 + (-point)], start, len);
start[0] = '0';
start[1] = '.';
njs_memset(&start[2], '0', -point);
if (prec > len) {
njs_memset(&start[2 + (-point) + len], '0', prec - len);
}
return prec + 2 + (-point);
}
if (point >= (int) len) {
/* TODO: (2**96).toPrecision(45) not enough precision, BigInt needed. */
njs_memset(&start[len], '0', point - len);
if (point < (int) prec) {
start[point] = '.';
njs_memset(&start[point + 1], '0', prec - point);
}
} else if (point < (int) prec) {
/* 123456 -> 123.45600 */
m = njs_min((int) len, point);
rest = njs_min(len, prec) - m;
memmove(&start[m + 1], &start[m], rest);
start[m] = '.';
njs_memset(&start[m + rest + 1], '0', prec - m - rest);
}
return prec + (point < (int) prec);
}
size_t
njs_dtoa(double value, char *start)
{
int point, minus;
char *p;
size_t length;
/* Not handling NaN and inf. */
minus = 0;
p = start;
if (value == 0) {
*p++ = '0';
return p - start;
}
if (signbit(value)) {
*p++ = '-';
value = -value;
minus = 1;
}
length = njs_grisu2(value, p, &point);
return njs_dtoa_format(p, length, point) + minus;
}
/*
* TODO: For prec > 16 result maybe rounded. To support prec > 16 Bignum
* support is requred.
*/
size_t
njs_dtoa_precision(double value, char *start, size_t prec)
{
int point, minus;
char *p;
size_t length;
/* Not handling NaN and inf. */
p = start;
minus = 0;
if (value != 0) {
if (value < 0) {
*p++ = '-';
value = -value;
minus = 1;
}
length = njs_grisu2_prec(value, p, prec, &point);
} else {
start[0] = '0';
length = 1;
point = 1;
}
return njs_dtoa_prec_format(p, prec, length, point) + minus;
}
size_t
njs_dtoa_exponential(double value, char *start, njs_int_t frac)
{
int point, minus;
char *p;
size_t length;
/* Not handling NaN and inf. */
p = start;
minus = 0;
if (value != 0) {
if (value < 0) {
*p++ = '-';
value = -value;
minus = 1;
}
if (frac == -1) {
length = njs_grisu2(value, p, &point);
} else {
length = njs_grisu2_prec(value, p, frac + 1, &point);
}
} else {
start[0] = '0';
length = 1;
point = 1;
}
if (frac == -1) {
frac = length - 1;
}
return njs_dtoa_exp_format(p, point - 1, frac + 1, length) + minus;
}

15
modules_deb/libnginx-mod-js-0.7.9/src/njs_dtoa.h
View file

@ -1,15 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) Nginx, Inc.
*/
#ifndef _NJS_DTOA_H_INCLUDED_
#define _NJS_DTOA_H_INCLUDED_
NJS_EXPORT size_t njs_dtoa(double value, char *start);
NJS_EXPORT size_t njs_dtoa_precision(double value, char *start, size_t prec);
NJS_EXPORT size_t njs_dtoa_exponential(double value, char *start,
njs_int_t frac);
#endif /* _NJS_DTOA_H_INCLUDED_ */

446
modules_deb/libnginx-mod-js-0.7.9/src/njs_dtoa_fixed.c
View file

@ -1,446 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) NGINX, Inc.
*
* An internal fixed_dtoa() implementation based upon V8
* src/numbers/fixed-dtoa.cc without bignum support.
*
* Copyright 2011 the V8 project authors. All rights reserved.
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file.
*/
#include <njs_main.h>
#include <njs_diyfp.h>
typedef struct {
uint64_t high;
uint64_t low;
} njs_diyu128_t;
#define njs_diyu128(_h, _l) (njs_diyu128_t) { .high = (_h), .low = (_l) }
njs_inline njs_diyu128_t
njs_diyu128_mul(njs_diyu128_t v, uint32_t multiplicand)
{
uint32_t part;
uint64_t accumulator;
accumulator = (v.low & UINT32_MAX) * multiplicand;
part = (uint32_t) (accumulator & UINT32_MAX);
accumulator >>= 32;
accumulator = accumulator + (v.low >> 32) * multiplicand;
v.low = (accumulator << 32) + part;
accumulator >>= 32;
accumulator = accumulator + (v.high & UINT32_MAX) * multiplicand;
part = (uint32_t) (accumulator & UINT32_MAX);
accumulator >>= 32;
accumulator = accumulator + (v.high >> 32) * multiplicand;
v.high = (accumulator << 32) + part;
return v;
}
njs_inline njs_diyu128_t
njs_diyu128_shift(njs_diyu128_t v, njs_int_t shift)
{
/* -64 <= shift <= 64.*/
if (shift < 0) {
if (shift == -64) {
v.high = v.low;
v.low = 0;
} else {
v.high <<= -shift;
v.high += v.low >> (64 + shift);
v.low <<= -shift;
}
return v;
}
if (shift > 0) {
if (shift == 64) {
v.low = v.high;
v.high = 0;
} else {
v.low >>= shift;
v.low += v.high << (64 - shift);
v.high >>= shift;
}
}
return v;
}
njs_inline njs_int_t
njs_diyu128_div_mod_pow2(njs_diyu128_t *v, njs_int_t power)
{
uint64_t part_low, part_high;
njs_int_t result;
if (power >= 64) {
result = (int) (v->high >> (power - 64));
v->high -= (uint64_t) result << (power - 64);
return result;
}
part_low = v->low >> power;
part_high = v->high << (64 - power);
result = (int) (part_low + part_high);
v->low -= part_low << power;
v->high = 0;
return result;
}
njs_inline njs_bool_t
njs_diyu128_is_zero(njs_diyu128_t v)
{
if (v.low == 0 && v.high == 0) {
return 1;
}
return 0;
}
njs_inline njs_uint_t
njs_diyu128_bit_at(njs_diyu128_t v, njs_uint_t pos)
{
if (pos >= 64) {
return (njs_uint_t) (v.high >> (pos - 64)) & 1;
}
return (njs_uint_t) (v.low >> pos) & 1;
}
static size_t
njs_fill_digits32(uint32_t number, char *start, size_t length)
{
char c;
size_t i, j, n;
njs_int_t digit;
n = 0;
while (number != 0) {
digit = number % 10;
number /= 10;
start[length + n] = '0' + digit;
n++;
}
i = length;
j = length + n - 1;
while (i < j) {
c = start[i];
start[i] = start[j];
start[j] = c;
i++;
j--;
}
return length + n;
}
njs_inline size_t
njs_fill_digits32_fixed_length(uint32_t number, size_t requested_length,
char *start, size_t length)
{
size_t i;
i = requested_length;
while (i-- > 0) {
start[length + i] = '0' + number % 10;
number /= 10;
}
return length + requested_length;
}
njs_inline size_t
njs_fill_digits64(uint64_t number, char *start, size_t length)
{
uint32_t part0, part1, part2, ten7;
ten7 = 10000000;
part2 = (uint32_t) (number % ten7);
number /= ten7;
part1 = (uint32_t) (number % ten7);
part0 = (uint32_t) (number / ten7);
if (part0 != 0) {
length = njs_fill_digits32(part0, start, length);
length = njs_fill_digits32_fixed_length(part1, 7, start, length);
return njs_fill_digits32_fixed_length(part2, 7, start, length);
}
if (part1 != 0) {
length = njs_fill_digits32(part1, start, length);
return njs_fill_digits32_fixed_length(part2, 7, start, length);
}
return njs_fill_digits32(part2, start, length);
}
njs_inline size_t
njs_fill_digits64_fixed_length(uint64_t number, char *start, size_t length)
{
uint32_t part0, part1, part2, ten7;
ten7 = 10000000;
part2 = (uint32_t) (number % ten7);
number /= ten7;
part1 = (uint32_t) (number % ten7);
part0 = (uint32_t) (number / ten7);
length = njs_fill_digits32_fixed_length(part0, 3, start, length);
length = njs_fill_digits32_fixed_length(part1, 7, start, length);
return njs_fill_digits32_fixed_length(part2, 7, start, length);
}
njs_inline size_t
njs_dtoa_round_up(char *start, size_t length, njs_int_t *point)
{
size_t i;
if (length == 0) {
start[0] = '1';
*point = 1;
return 1;
}
start[length - 1]++;
for (i = length - 1; i > 0; --i) {
if (start[i] != '0' + 10) {
return length;
}
start[i] = '0';
start[i - 1]++;
}
if (start[0] == '0' + 10) {
start[0] = '1';
(*point)++;
}
return length;
}
static size_t
njs_fill_fractionals(uint64_t fractionals, int exponent, njs_uint_t frac,
char *start, size_t length, njs_int_t *point)
{
njs_int_t n, digit;
njs_uint_t i;
njs_diyu128_t fractionals128;
/*
* -128 <= exponent <= 0.
* 0 <= fractionals * 2^exponent < 1.
*/
if (-exponent <= 64) {
/* fractionals <= 2^56. */
n = -exponent;
for (i = 0; i < frac && fractionals != 0; ++i) {
/*
* Multiplication by 10 is replaced with multiplication by 5 and
* point location adjustment. To avoid integer-overflow.
*/
fractionals *= 5;
n--;
digit = (njs_int_t) (fractionals >> n);
fractionals -= (uint64_t) digit << n;
start[length++] = '0' + digit;
}
if (n > 0 && ((fractionals >> (n - 1)) & 1)) {
length = njs_dtoa_round_up(start, length, point);
}
} else {
fractionals128 = njs_diyu128(fractionals, 0);
fractionals128 = njs_diyu128_shift(fractionals128, -exponent - 64);
n = 128;
for (i = 0; i < frac && !njs_diyu128_is_zero(fractionals128); ++i) {
/*
* Multiplication by 10 is replaced with multiplication by 5 and
* point location adjustment. To avoid integer-overflow.
*/
fractionals128 = njs_diyu128_mul(fractionals128, 5);
n--;
digit = njs_diyu128_div_mod_pow2(&fractionals128, n);
start[length++] = '0' + digit;
}
if (njs_diyu128_bit_at(fractionals128, n - 1)) {
length = njs_dtoa_round_up(start, length, point);
}
}
return length;
}
njs_inline size_t
njs_trim_zeroes(char *start, size_t length, njs_int_t *point)
{
size_t i, n;
while (length > 0 && start[length - 1] == '0') {
length--;
}
n = 0;
while (n < length && start[n] == '0') {
n++;
}
if (n != 0) {
for (i = n; i < length; ++i) {
start[i - n] = start[i];
}
length -= n;
*point -= n;
}
return length;
}
size_t
njs_fixed_dtoa(double value, njs_uint_t frac, char *start, njs_int_t *point)
{
size_t length;
uint32_t quotient;
uint64_t significand, divisor, dividend, remainder, integral, fract;
njs_int_t exponent;
njs_diyfp_t v;
length = 0;
v = njs_d2diyfp(value);
significand = v.significand;
exponent = v.exp;
/* exponent <= 19. */
if (exponent + NJS_SIGNIFICAND_SIZE > 64) {
/* exponent > 11. */
divisor = njs_uint64(0xB1, 0xA2BC2EC5); /* 5 ^ 17 */
dividend = significand;
if (exponent > 17) {
/* (e - 17) <= 3. */
dividend <<= exponent - 17;
quotient = (uint32_t) (dividend / divisor);
remainder = (dividend % divisor) << 17;
} else {
divisor <<= 17 - exponent;
quotient = (uint32_t) (dividend / divisor);
remainder = (dividend % divisor) << exponent;
}
length = njs_fill_digits32(quotient, start, length);
length = njs_fill_digits64_fixed_length(remainder, start, length);
*point = (njs_int_t) length;
} else if (exponent >= 0) {
/* 0 <= exponent <= 11. */
significand <<= exponent;
length = njs_fill_digits64(significand, start, length);
*point = (njs_int_t) length;
} else if (exponent > -NJS_SIGNIFICAND_SIZE) {
/* -53 < exponent < 0. */
integral = significand >> -exponent;
fract = significand - (integral << -exponent);
if (integral > UINT32_MAX) {
length = njs_fill_digits64(integral, start, length);
} else {
length = njs_fill_digits32((uint32_t) integral, start, length);
}
*point = (njs_int_t) length;
length = njs_fill_fractionals(fract, exponent, frac, start, length,
point);
} else if (exponent < -128) {
/* Valid for frac =< 20 only. TODO: bignum support. */
start[0] = '\0';
*point = -frac;
} else {
/* -128 <= exponent <= -53. */
*point = 0;
length = njs_fill_fractionals(significand, exponent, frac, start,
length, point);
}
length = njs_trim_zeroes(start, length, point);
start[length] = '\0';
if (length == 0) {
*point = -frac;
}
return length;
}

13
modules_deb/libnginx-mod-js-0.7.9/src/njs_dtoa_fixed.h
View file

@ -1,13 +0,0 @@
/*
* Copyright (C) Dmitry Volyntsev
* Copyright (C) Nginx, Inc.
*/
#ifndef _NJS_DTOA_FIXED_H_INCLUDED_
#define _NJS_DTOA_FIXED_H_INCLUDED_
NJS_EXPORT size_t njs_fixed_dtoa(double value, njs_uint_t frac, char *start,
njs_int_t *point);
#endif /* _NJS_DTOA_FIXED_H_INCLUDED_ */

614
modules_deb/libnginx-mod-js-0.7.9/src/njs_encoding.c
View file

@ -1,614 +0,0 @@
/*
* Copyright (C) Alexander Borisov
* Copyright (C) NGINX, Inc.
*/
#include <njs_main.h>
typedef enum {
NJS_ENCODING_UTF8,
} njs_encoding_t;
typedef struct {
njs_encoding_t encoding;
njs_bool_t fatal;
njs_bool_t ignore_bom;
njs_unicode_decode_t ctx;
} njs_encoding_decode_t;
typedef struct {
njs_str_t name;
njs_encoding_t encoding;
} njs_encoding_label_t;
static njs_encoding_label_t njs_encoding_labels[] =
{
{ njs_str("utf-8"), NJS_ENCODING_UTF8 },
{ njs_str("utf8") , NJS_ENCODING_UTF8 },
{ njs_null_str, 0 }
};
static njs_int_t njs_text_encoder_encode_utf8(njs_vm_t *vm,
njs_string_prop_t *prop);
static njs_int_t njs_text_decoder_arg_encoding(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_encoding_decode_t *data);
static njs_int_t njs_text_decoder_arg_options(njs_vm_t *vm, njs_value_t *args,
njs_uint_t nargs, njs_encoding_decode_t *data);
static njs_int_t
njs_text_encoder_constructor(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_object_value_t *encoder;
if (!vm->top_frame->ctor) {
njs_type_error(vm, "Constructor of TextEncoder requires 'new'");
return NJS_ERROR;
}
encoder = njs_object_value_alloc(vm, NJS_OBJ_TYPE_TEXT_ENCODER, 0, NULL);
if (njs_slow_path(encoder == NULL)) {
return NJS_ERROR;
}
njs_set_data(&encoder->value, NULL, NJS_DATA_TAG_TEXT_ENCODER);
njs_set_object_value(&vm->retval, encoder);
return NJS_OK;
}
static njs_int_t
njs_text_encoder_encode(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
u_char *dst;
size_t size;
njs_int_t ret;
njs_value_t *this, *input, value;
const u_char *start, *end;
njs_string_prop_t prop;
njs_typed_array_t *array;
njs_unicode_decode_t ctx;
this = njs_argument(args, 0);
if (njs_slow_path(!njs_is_object_data(this, NJS_DATA_TAG_TEXT_ENCODER))) {
njs_type_error(vm, "\"this\" is not a TextEncoder");
return NJS_ERROR;
}
start = NULL;
end = NULL;
if (nargs > 1) {
input = njs_argument(args, 1);
if (njs_slow_path(!njs_is_string(input))) {
ret = njs_value_to_string(vm, input, input);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
}
(void) njs_string_prop(&prop, input);
if (prop.length != 0) {
return njs_text_encoder_encode_utf8(vm, &prop);
}
start = prop.start;
end = start + prop.size;
}
njs_utf8_decode_init(&ctx);
(void) njs_utf8_stream_length(&ctx, start, end - start, 1, 0, &size);
njs_set_number(&value, size);
array = njs_typed_array_alloc(vm, &value, 1, 0, NJS_OBJ_TYPE_UINT8_ARRAY);
if (njs_slow_path(array == NULL)) {
return NJS_ERROR;
}
dst = njs_typed_array_buffer(array)->u.u8;
njs_utf8_decode_init(&ctx);
(void) njs_utf8_stream_encode(&ctx, start, end, dst, 1, 0);
njs_set_typed_array(&vm->retval, array);
return NJS_OK;
}
static njs_int_t
njs_text_encoder_encode_utf8(njs_vm_t *vm, njs_string_prop_t *prop)
{
njs_value_t value;
njs_typed_array_t *array;
njs_set_number(&value, prop->size);
array = njs_typed_array_alloc(vm, &value, 1, 0, NJS_OBJ_TYPE_UINT8_ARRAY);
if (njs_slow_path(array == NULL)) {
return NJS_ERROR;
}
memcpy(njs_typed_array_buffer(array)->u.u8, prop->start, prop->size);
njs_set_typed_array(&vm->retval, array);
return NJS_OK;
}
static njs_int_t
njs_text_encoder_encode_into(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
u_char *to, *to_end;
size_t size;
uint32_t cp;
njs_int_t ret;
njs_str_t str;
njs_value_t *this, *input, *dest, retval, read, written;
const u_char *start, *end;
njs_typed_array_t *array;
njs_unicode_decode_t ctx;
static const njs_value_t read_str = njs_string("read");
static const njs_value_t written_str = njs_string("written");
this = njs_argument(args, 0);
input = njs_arg(args, nargs, 1);
dest = njs_arg(args, nargs, 2);
if (njs_slow_path(!njs_is_object_data(this, NJS_DATA_TAG_TEXT_ENCODER))) {
njs_type_error(vm, "\"this\" is not a TextEncoder");
return NJS_ERROR;
}
if (njs_slow_path(!njs_is_string(input))) {
ret = njs_value_to_string(vm, &retval, input);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
input = &retval;
}
if (njs_slow_path(!njs_is_typed_array_uint8(dest))) {
njs_type_error(vm, "The \"destination\" argument must be an instance "
"of Uint8Array");
return NJS_ERROR;
}
njs_string_get(input, &str);
start = str.start;
end = start + str.length;
array = njs_typed_array(dest);
to = njs_typed_array_start(array);
to_end = to + array->byte_length;
cp = 0;
njs_set_number(&read, 0);
njs_set_number(&written, 0);
njs_utf8_decode_init(&ctx);
while (start < end) {
cp = njs_utf8_decode(&ctx, &start, end);
if (cp > NJS_UNICODE_MAX_CODEPOINT) {
cp = NJS_UNICODE_REPLACEMENT;
}
size = njs_utf8_size(cp);
if (to + size > to_end) {
break;
}
njs_number(&read) += (cp > 0xFFFF) ? 2 : 1;
njs_number(&written) += size;
to = njs_utf8_encode(to, cp);
}
return njs_vm_object_alloc(vm, &vm->retval, &read_str, &read,
&written_str, &written, NULL);
}
static const njs_object_prop_t njs_text_encoder_properties[] =
{
NJS_DECLARE_PROP_HANDLER("constructor",
njs_object_prototype_create_constructor,
0, 0, NJS_OBJECT_PROP_VALUE_CW),
NJS_DECLARE_PROP_VALUE("encoding", njs_string("utf-8"), 0),
NJS_DECLARE_PROP_NATIVE("encode", njs_text_encoder_encode, 0, 0),
NJS_DECLARE_PROP_NATIVE("encodeInto", njs_text_encoder_encode_into, 2, 0),
};
const njs_object_init_t njs_text_encoder_init = {
njs_text_encoder_properties,
njs_nitems(njs_text_encoder_properties),
};
static const njs_object_prop_t njs_text_encoder_constructor_properties[] =
{
NJS_DECLARE_PROP_NAME("TextEncoder"),
NJS_DECLARE_PROP_LENGTH(0),
NJS_DECLARE_PROP_HANDLER("prototype", njs_object_prototype_create, 0, 0, 0),
};
const njs_object_init_t njs_text_encoder_constructor_init = {
njs_text_encoder_constructor_properties,
njs_nitems(njs_text_encoder_constructor_properties),
};
const njs_object_type_init_t njs_text_encoder_type_init = {
.constructor = njs_native_ctor(njs_text_encoder_constructor, 0, 0),
.prototype_props = &njs_text_encoder_init,
.constructor_props = &njs_text_encoder_constructor_init,
.prototype_value = { .object = { .type = NJS_OBJECT } },
};
static njs_int_t
njs_text_decoder_constructor(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
njs_int_t ret;
njs_object_value_t *decoder;
njs_encoding_decode_t *data;
if (!vm->top_frame->ctor) {
njs_type_error(vm, "Constructor of TextDecoder requires 'new'");
return NJS_ERROR;
}
decoder = njs_object_value_alloc(vm, NJS_OBJ_TYPE_TEXT_DECODER,
sizeof(njs_encoding_decode_t), NULL);
if (njs_slow_path(decoder == NULL)) {
return NJS_ERROR;
}
data = (njs_encoding_decode_t *) ((uint8_t *) decoder
+ sizeof(njs_object_value_t));
ret = njs_text_decoder_arg_encoding(vm, args, nargs, data);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
ret = njs_text_decoder_arg_options(vm, args, nargs, data);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
njs_utf8_decode_init(&data->ctx);
njs_set_data(&decoder->value, data, NJS_DATA_TAG_TEXT_DECODER);
njs_set_object_value(&vm->retval, decoder);
return NJS_OK;
}
static njs_int_t
njs_text_decoder_arg_encoding(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_encoding_decode_t *data)
{
njs_str_t str;
njs_int_t ret;
njs_value_t *value;
njs_encoding_label_t *label;
if (nargs < 2) {
data->encoding = NJS_ENCODING_UTF8;
return NJS_OK;
}
value = njs_argument(args, 1);
if (njs_slow_path(!njs_is_string(value))) {
ret = njs_value_to_string(vm, value, value);
if (njs_slow_path(ret != NJS_OK)) {
return ret;
}
}
njs_string_get(value, &str);
for (label = &njs_encoding_labels[0]; label->name.length != 0; label++) {
if (njs_strstr_eq(&str, &label->name)) {
data->encoding = label->encoding;
return NJS_OK;
}
}
njs_range_error(vm, "The \"%V\" encoding is not supported", &str);
return NJS_ERROR;
}
static njs_int_t
njs_text_decoder_arg_options(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_encoding_decode_t *data)
{
njs_int_t ret;
njs_value_t retval, *value;
static const njs_value_t fatal_str = njs_string("fatal");
static const njs_value_t ignore_bom_str = njs_string("ignoreBOM");
if (nargs < 3) {
data->fatal = 0;
data->ignore_bom = 0;
return NJS_OK;
}
value = njs_argument(args, 2);
if (njs_slow_path(!njs_is_object(value))) {
njs_type_error(vm, "The \"options\" argument must be of type object");
return NJS_ERROR;
}
ret = njs_value_property(vm, value, njs_value_arg(&fatal_str), &retval);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
data->fatal = njs_bool(&retval);
ret = njs_value_property(vm, value, njs_value_arg(&ignore_bom_str),
&retval);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
data->ignore_bom = njs_bool(&retval);
return NJS_OK;
}
static njs_int_t
njs_text_decoder_encoding(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
njs_encoding_decode_t *data;
static const njs_value_t utf8_str = njs_string("utf-8");
if (njs_slow_path(!njs_is_object_data(value, NJS_DATA_TAG_TEXT_DECODER))) {
njs_set_undefined(retval);
return NJS_DECLINED;
}
data = njs_object_data(value);
switch (data->encoding) {
case NJS_ENCODING_UTF8:
*retval = utf8_str;
break;
default:
njs_type_error(vm, "unknown encoding");
return NJS_ERROR;
}
return NJS_OK;
}
static njs_int_t
njs_text_decoder_fatal(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
njs_encoding_decode_t *data;
if (njs_slow_path(!njs_is_object_data(value, NJS_DATA_TAG_TEXT_DECODER))) {
njs_set_undefined(retval);
return NJS_DECLINED;
}
data = njs_object_data(value);
njs_set_boolean(retval, data->fatal);
return NJS_OK;
}
static njs_int_t
njs_text_decoder_ignore_bom(njs_vm_t *vm, njs_object_prop_t *prop,
njs_value_t *value, njs_value_t *setval, njs_value_t *retval)
{
njs_encoding_decode_t *data;
if (njs_slow_path(!njs_is_object_data(value, NJS_DATA_TAG_TEXT_DECODER))) {
njs_set_undefined(retval);
return NJS_DECLINED;
}
data = njs_object_data(value);
njs_set_boolean(retval, data->ignore_bom);
return NJS_OK;
}
static njs_int_t
njs_text_decoder_decode(njs_vm_t *vm, njs_value_t *args, njs_uint_t nargs,
njs_index_t unused)
{
u_char *dst;
size_t size;
ssize_t length;
njs_int_t ret;
njs_bool_t stream;
njs_value_t retval, *this, *value, *options;
const u_char *start, *end;
njs_unicode_decode_t ctx;
njs_encoding_decode_t *data;
const njs_typed_array_t *array;
const njs_array_buffer_t *buffer;
static const njs_value_t stream_str = njs_string("stream");
start = NULL;
end = NULL;
stream = 0;
this = njs_argument(args, 0);
if (njs_slow_path(!njs_is_object_data(this, NJS_DATA_TAG_TEXT_DECODER))) {
njs_type_error(vm, "\"this\" is not a TextDecoder");
return NJS_ERROR;
}
if (njs_fast_path(nargs > 1)) {
value = njs_argument(args, 1);
if (njs_is_typed_array(value)) {
array = njs_typed_array(value);
start = njs_typed_array_start(array);
end = start + array->byte_length;
} else if (njs_is_array_buffer(value)) {
buffer = njs_array_buffer(value);
start = buffer->u.u8;
end = start + buffer->size;
} else {
njs_type_error(vm, "The \"input\" argument must be an instance "
"of TypedArray");
return NJS_ERROR;
}
}
if (nargs > 2) {
options = njs_argument(args, 2);
if (njs_slow_path(!njs_is_object(options))) {
njs_type_error(vm, "The \"options\" argument must be "
"of type object");
return NJS_ERROR;
}
ret = njs_value_property(vm, options, njs_value_arg(&stream_str),
&retval);
if (njs_slow_path(ret == NJS_ERROR)) {
return ret;
}
stream = njs_bool(&retval);
}
data = njs_object_data(this);
ctx = data->ctx;
/* Looking for BOM. */
if (!data->ignore_bom) {
start += njs_utf8_bom(start, end);
}
length = njs_utf8_stream_length(&ctx, start, end - start, !stream,
data->fatal, &size);
if (length == -1) {
njs_type_error(vm, "The encoded data was not valid");
return NJS_ERROR;
}
dst = njs_string_alloc(vm, &vm->retval, size, length);
if (njs_slow_path(dst == NULL)) {
return NJS_ERROR;
}
(void) njs_utf8_stream_encode(&data->ctx, start, end, dst, !stream, 0);
if (!stream) {
njs_utf8_decode_init(&data->ctx);
}
return NJS_OK;
}
static const njs_object_prop_t njs_text_decoder_properties[] =
{
NJS_DECLARE_PROP_HANDLER("constructor",
njs_object_prototype_create_constructor,
0, 0, NJS_OBJECT_PROP_VALUE_CW),
NJS_DECLARE_PROP_HANDLER("encoding", njs_text_decoder_encoding, 0, 0, 0),
NJS_DECLARE_PROP_HANDLER("fatal", njs_text_decoder_fatal, 0, 0, 0),
NJS_DECLARE_PROP_HANDLER("ignoreBOM", njs_text_decoder_ignore_bom, 0, 0, 0),
NJS_DECLARE_PROP_NATIVE("decode", njs_text_decoder_decode, 0, 0),
};
const njs_object_init_t njs_text_decoder_init = {
njs_text_decoder_properties,
njs_nitems(njs_text_decoder_properties),
};
static const njs_object_prop_t njs_text_decoder_constructor_properties[] =
{
NJS_DECLARE_PROP_NAME("TextDecoder"),
NJS_DECLARE_PROP_LENGTH(0),
NJS_DECLARE_PROP_HANDLER("prototype", njs_object_prototype_create, 0, 0, 0),
};
const njs_object_init_t njs_text_decoder_constructor_init = {
njs_text_decoder_constructor_properties,
njs_nitems(njs_text_decoder_constructor_properties),
};
const njs_object_type_init_t njs_text_decoder_type_init = {
.constructor = njs_native_ctor(njs_text_decoder_constructor, 0, 0),
.prototype_props = &njs_text_decoder_init,
.constructor_props = &njs_text_decoder_constructor_init,
.prototype_value = { .object = { .type = NJS_OBJECT } },
};

Some files were not shown because too many files have changed in this diff Show more