Script 'mail_helper' called by obssrc
Hello community,
here is the log from the commit of package janet for openSUSE:Factory checked
in at 2024-01-10 21:52:31
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/janet (Old)
and /work/SRC/openSUSE:Factory/.janet.new.21961 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "janet"
Wed Jan 10 21:52:31 2024 rev:6 rq:1137852 version:1.33.0
Changes:
--------
--- /work/SRC/openSUSE:Factory/janet/janet.changes 2023-11-03
22:21:57.208041192 +0100
+++ /work/SRC/openSUSE:Factory/.janet.new.21961/janet.changes 2024-01-10
21:52:47.189251899 +0100
@@ -1,0 +2,12 @@
+Wed Jan 10 00:44:49 UTC 2024 - Soc Virnyl Estela
<uncomfy+openbuildserv...@uncomfyhalomacro.pl>
+
+- Update to version 1.33.0:
+ * Add more + and * keywords to default-peg-grammar
+ * Use libc strlen in janet_buffer_push_cstring
+ * net/ev: Cleaned up unused NetStateConnect, fixed janet_async_end() ev
refcount
+ * fix (doc next)
+ * Fix arity typo in peg
+ * Cosmetically tweak string/format docstring
+ * Add a new (sub) PEG special
+
+-------------------------------------------------------------------
Old:
----
janet-1.32.1.tar.gz
New:
----
janet-1.33.0.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ janet.spec ++++++
--- /var/tmp/diff_new_pack.kfn0kI/_old 2024-01-10 21:52:47.609267152 +0100
+++ /var/tmp/diff_new_pack.kfn0kI/_new 2024-01-10 21:52:47.609267152 +0100
@@ -1,7 +1,7 @@
#
# spec file for package janet
#
-# Copyright (c) 2023 SUSE LLC
+# Copyright (c) 2024 SUSE LLC
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -17,8 +17,8 @@
%global somajor 1
-%global sominor 32
-%global revision 1
+%global sominor 33
+%global revision 0
%global libname libjanet%{somajor}_%{sominor}
Name: janet
++++++ janet-1.32.1.tar.gz -> janet-1.33.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/CHANGELOG.md
new/janet-1.33.0/CHANGELOG.md
--- old/janet-1.32.1/CHANGELOG.md 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/CHANGELOG.md 2024-01-07 20:30:08.000000000 +0100
@@ -1,6 +1,29 @@
# Changelog
All notable changes to this project will be documented in this file.
+## 1.33.0 - 2023-01-07
+- Add more + and * keywords to default-peg-grammar by @sogaiu.
+- Use libc strlen in janet_buffer_push_cstring by @williewillus.
+- Be a bit safer with reference counting.
+- Add support for atomic loads in Janet's atomic abstraction.
+- Fix poll event loop CPU usage issue.
+- Add ipv6, shared, and cryptorand options to meson.
+- Add more ipv6 feature detection.
+- Fix loop for forever loop.
+- Cleaned up unused NetStateConnect, fixed janet_async_end() ev refcount by
@zevv.
+- Fix warnings w/ MSVC and format.
+- Fix marshal_one_env w/ JANET_MARSHAL_UNSAFE.
+- Fix `(default)`.
+- Fix cannot marshal fiber with c stackframe, in a dynamic way that is fairly
conservative.
+- Fix typo for SIGALARM in os/proc-kill.
+- Prevent bytecode optimization from remove mk* instructions.
+- Fix arity typo in peg.c by @pepe.
+- Update Makefile for MinGW.
+- Fix canceling waiting fiber.
+- Add a new (sub) PEG special by @ianthehenry.
+- Fix if net/server's handler has incorrect arity.
+- Fix macex raising on ().
+
## 1.32.1 - 2023-10-15
- Fix return value from C function `janet_dobytes` when called on Janet
functions that yield to event loop.
- Change C API for event loop interaction - get rid of JanetListener and
instead use `janet_async_start` and `janet_async_end`.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/Makefile new/janet-1.33.0/Makefile
--- old/janet-1.32.1/Makefile 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/Makefile 2024-01-07 20:30:08.000000000 +0100
@@ -33,6 +33,7 @@
JANET_TARGET=build/janet
JANET_BOOT=build/janet_boot
JANET_IMPORT_LIB=build/janet.lib
+JANET_LIBRARY_IMPORT_LIB=build/libjanet.lib
JANET_LIBRARY=build/libjanet.so
JANET_STATIC_LIBRARY=build/libjanet.a
JANET_PATH?=$(LIBDIR)/janet
@@ -42,6 +43,7 @@
JANET_BOOT_FLAGS:=. JANET_PATH '$(JANET_PATH)'
JANET_TARGET_OBJECTS=build/janet.o build/shell.o
JPM_TAG?=master
+HAS_SHARED?=1
DEBUGGER=gdb
SONAME_SETTER=-Wl,-soname,
@@ -51,6 +53,7 @@
# Symbols are (optionally) removed later, keep -g as default!
CFLAGS?=-O2 -g
LDFLAGS?=-rdynamic
+LIBJANET_LDFLAGS?=$(LD_FLAGS)
RUN:=$(RUN)
COMMON_CFLAGS:=-std=c99 -Wall -Wextra -Isrc/include -Isrc/conf
-fvisibility=hidden -fPIC
@@ -93,12 +96,17 @@
ifeq ($(findstring MINGW,$(UNAME)), MINGW)
CLIBS:=-lws2_32 -lpsapi -lwsock32
LDFLAGS:=-Wl,--out-implib,$(JANET_IMPORT_LIB)
+ LIBJANET_LDFLAGS:=-Wl,--out-implib,$(JANET_LIBRARY_IMPORT_LIB)
JANET_TARGET:=$(JANET_TARGET).exe
JANET_BOOT:=$(JANET_BOOT).exe
endif
+
$(shell mkdir -p build/core build/c build/boot build/mainclient)
-all: $(JANET_TARGET) $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/janet.h
+all: $(JANET_TARGET) $(JANET_STATIC_LIBRARY) build/janet.h
+ifeq ($(HAS_SHARED), 1)
+all: $(JANET_LIBRARY)
+endif
######################
##### Name Files #####
@@ -196,9 +204,9 @@
########################
ifeq ($(UNAME), Darwin)
-SONAME=libjanet.1.32.dylib
+SONAME=libjanet.1.33.dylib
else
-SONAME=libjanet.so.1.32
+SONAME=libjanet.so.1.33
endif
build/c/shell.c: src/mainclient/shell.c
@@ -220,7 +228,7 @@
$(HOSTCC) $(LDFLAGS) $(BUILD_CFLAGS) -o $@ $^ $(CLIBS)
$(JANET_LIBRARY): $(JANET_TARGET_OBJECTS)
- $(HOSTCC) $(LDFLAGS) $(BUILD_CFLAGS) $(SONAME_SETTER)$(SONAME) -shared
-o $@ $^ $(CLIBS)
+ $(HOSTCC) $(LIBJANET_LDFLAGS) $(BUILD_CFLAGS) $(SONAME_SETTER)$(SONAME)
-shared -o $@ $^ $(CLIBS)
$(JANET_STATIC_LIBRARY): $(JANET_TARGET_OBJECTS)
$(HOSTAR) rcs $@ $^
@@ -263,7 +271,7 @@
build/janet-%.tar.gz: $(JANET_TARGET) \
build/janet.h \
- janet.1 LICENSE CONTRIBUTING.md $(JANET_LIBRARY)
$(JANET_STATIC_LIBRARY) \
+ janet.1 LICENSE CONTRIBUTING.md $(JANET_STATIC_LIBRARY) \
README.md build/c/janet.c build/c/shell.c
mkdir -p build/$(JANET_DIST_DIR)/bin
cp $(JANET_TARGET) build/$(JANET_DIST_DIR)/bin/
@@ -271,13 +279,17 @@
mkdir -p build/$(JANET_DIST_DIR)/include
cp build/janet.h build/$(JANET_DIST_DIR)/include/
mkdir -p build/$(JANET_DIST_DIR)/lib/
- cp $(JANET_LIBRARY) $(JANET_STATIC_LIBRARY) build/$(JANET_DIST_DIR)/lib/
+ cp $(JANET_STATIC_LIBRARY) build/$(JANET_DIST_DIR)/lib/
+ cp $(JANET_LIBRARY) build/$(JANET_DIST_DIR)/lib/ || true
mkdir -p build/$(JANET_DIST_DIR)/man/man1/
cp janet.1 build/$(JANET_DIST_DIR)/man/man1/janet.1
mkdir -p build/$(JANET_DIST_DIR)/src/
cp build/c/janet.c build/c/shell.c build/$(JANET_DIST_DIR)/src/
cp CONTRIBUTING.md LICENSE README.md build/$(JANET_DIST_DIR)/
cd build && tar -czvf ../$@ ./$(JANET_DIST_DIR)
+ifeq ($(HAS_SHARED), 1)
+build/janet-%.tar.gz: $(JANET_LIBRARY)
+endif
#########################
##### Documentation #####
@@ -331,6 +343,7 @@
mkdir -p '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)'
cp build/janet.pc '$(DESTDIR)$(JANET_PKG_CONFIG_PATH)/janet.pc'
cp '$(JANET_IMPORT_LIB)' '$(DESTDIR)$(LIBDIR)' || echo 'no import lib
to install (mingw only)'
+ cp '$(JANET_LIBRARY_IMPORT_LIB)' '$(DESTDIR)$(LIBDIR)' || echo 'no
import lib to install (mingw only)'
[ -z '$(DESTDIR)' ] && $(LDCONFIG) || echo "You can ignore this error
for non-Linux systems or local installs"
install-jpm-git: $(JANET_TARGET)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/meson.build new/janet-1.33.0/meson.build
--- old/janet-1.32.1/meson.build 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/meson.build 2024-01-07 20:30:08.000000000 +0100
@@ -20,7 +20,7 @@
project('janet', 'c',
default_options : ['c_std=c99', 'build.c_std=c99', 'b_lundef=false',
'default_library=both'],
- version : '1.32.1')
+ version : '1.33.0')
# Global settings
janet_path = join_paths(get_option('prefix'), get_option('libdir'), 'janet')
@@ -61,6 +61,7 @@
conf.set('JANET_NO_ASSEMBLER', not get_option('assembler'))
conf.set('JANET_NO_PEG', not get_option('peg'))
conf.set('JANET_NO_NET', not get_option('net'))
+conf.set('JANET_NO_IPV6', not get_option('ipv6'))
conf.set('JANET_NO_EV', not get_option('ev') or get_option('single_threaded'))
conf.set('JANET_REDUCED_OS', get_option('reduced_os'))
conf.set('JANET_NO_INT_TYPES', not get_option('int_types'))
@@ -78,6 +79,7 @@
conf.set('JANET_NO_INTERPRETER_INTERRUPT', not
get_option('interpreter_interrupt'))
conf.set('JANET_NO_FFI', not get_option('ffi'))
conf.set('JANET_NO_FFI_JIT', not get_option('ffi_jit'))
+conf.set('JANET_NO_CRYPTORAND', not get_option('cryptorand'))
if get_option('os_name') != ''
conf.set('JANET_OS_NAME', get_option('os_name'))
endif
@@ -182,32 +184,41 @@
janet_dependencies += thread_dep
endif
+# Allow building with no shared library
if cc.has_argument('-fvisibility=hidden')
lib_cflags = ['-fvisibility=hidden']
else
lib_cflags = []
endif
-libjanet = library('janet', janetc,
- include_directories : incdir,
- dependencies : janet_dependencies,
- version: meson.project_version(),
- soversion: version_parts[0] + '.' + version_parts[1],
- c_args : lib_cflags,
- install : true)
-
+if get_option('shared')
+ libjanet = library('janet', janetc,
+ include_directories : incdir,
+ dependencies : janet_dependencies,
+ version: meson.project_version(),
+ soversion: version_parts[0] + '.' + version_parts[1],
+ c_args : lib_cflags,
+ install : true)
# Extra c flags - adding -fvisibility=hidden matches the Makefile and
# shaves off about 10k on linux x64, likely similar on other platforms.
-if cc.has_argument('-fvisibility=hidden')
- extra_cflags = ['-fvisibility=hidden', '-DJANET_DLL_IMPORT']
+ if cc.has_argument('-fvisibility=hidden')
+ extra_cflags = ['-fvisibility=hidden', '-DJANET_DLL_IMPORT']
+ else
+ extra_cflags = ['-DJANET_DLL_IMPORT']
+ endif
+ janet_mainclient = executable('janet', mainclient_src,
+ include_directories : incdir,
+ dependencies : janet_dependencies,
+ link_with: [libjanet],
+ c_args : extra_cflags,
+ install : true)
else
- extra_cflags = ['-DJANET_DLL_IMPORT']
+ # No shared library
+ janet_mainclient = executable('janet', mainclient_src, janetc,
+ include_directories : incdir,
+ dependencies : janet_dependencies,
+ c_args : lib_cflags,
+ install : true)
endif
-janet_mainclient = executable('janet', mainclient_src,
- include_directories : incdir,
- dependencies : janet_dependencies,
- link_with: [libjanet],
- c_args : extra_cflags,
- install : true)
if meson.is_cross_build()
native_cc = meson.get_compiler('c', native: true)
@@ -271,14 +282,15 @@
run_target('repl', command : [janet_nativeclient])
# For use as meson subproject (wrap)
-janet_dep = declare_dependency(include_directories : incdir,
- link_with : libjanet)
-
+if get_option('shared')
+ janet_dep = declare_dependency(include_directories : incdir,
+ link_with : libjanet)
# pkgconfig
-pkg = import('pkgconfig')
-pkg.generate(libjanet,
- subdirs: 'janet',
- description: 'Library for the Janet programming language.')
+ pkg = import('pkgconfig')
+ pkg.generate(libjanet,
+ subdirs: 'janet',
+ description: 'Library for the Janet programming language.')
+endif
# Installation
install_man('janet.1')
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/meson_options.txt
new/janet-1.33.0/meson_options.txt
--- old/janet-1.32.1/meson_options.txt 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/meson_options.txt 2024-01-07 20:30:08.000000000 +0100
@@ -11,6 +11,7 @@
option('int_types', type : 'boolean', value : true)
option('prf', type : 'boolean', value : false)
option('net', type : 'boolean', value : true)
+option('ipv6', type : 'boolean', value : true)
option('ev', type : 'boolean', value : true)
option('processes', type : 'boolean', value : true)
option('umask', type : 'boolean', value : true)
@@ -29,3 +30,5 @@
option('arch_name', type : 'string', value: '')
option('os_name', type : 'string', value: '')
+option('shared', type : 'boolean', value: true)
+option('cryptorand', type : 'boolean', value: true)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/boot/boot.janet
new/janet-1.33.0/src/boot/boot.janet
--- old/janet-1.32.1/src/boot/boot.janet 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/src/boot/boot.janet 2024-01-07 20:30:08.000000000
+0100
@@ -162,7 +162,7 @@
``Define a default value for an optional argument.
Expands to `(def sym (if (= nil sym) val sym))`.``
[sym val]
- ~(def ,sym (if (= nil ,sym) ,val ,sym)))
+ ~(def ,sym (if (,= nil ,sym) ,val ,sym)))
(defmacro comment
"Ignores the body of the comment."
@@ -420,10 +420,14 @@
(defn- range-template
[binding object kind rest op comparison]
- (let [[start stop step] (check-indexed object)]
- (case kind
- :range (for-template binding (if stop start 0) (or stop start) (or step
1) comparison op [rest])
- :down (for-template binding start (or stop 0) (or step 1) comparison op
[rest]))))
+ (check-indexed object)
+ (def [a b c] object)
+ (def [start stop step]
+ (case (length object)
+ 1 (case kind :range [0 a 1] :down [a 0 1])
+ 2 [a b 1]
+ [a b c]))
+ (for-template binding start stop step comparison op [rest]))
(defn- each-template
[binding inx kind body]
@@ -2123,6 +2127,7 @@
'upscope expandall})
(defn dotup [t]
+ (if (= nil (next t)) (break ()))
(def h (in t 0))
(def s (in specs h))
(def entry (or (dyn h) {}))
@@ -2333,26 +2338,36 @@
(def default-peg-grammar
`The default grammar used for pegs. This grammar defines several common
patterns
that should make it easier to write more complex patterns.`
- ~@{:d (range "09")
- :a (range "az" "AZ")
+ ~@{:a (range "az" "AZ")
+ :d (range "09")
+ :h (range "09" "af" "AF")
:s (set " \t\r\n\0\f\v")
:w (range "az" "AZ" "09")
- :h (range "09" "af" "AF")
- :S (if-not :s 1)
- :W (if-not :w 1)
:A (if-not :a 1)
:D (if-not :d 1)
:H (if-not :h 1)
- :d+ (some :d)
+ :S (if-not :s 1)
+ :W (if-not :w 1)
:a+ (some :a)
+ :d+ (some :d)
+ :h+ (some :h)
:s+ (some :s)
:w+ (some :w)
- :h+ (some :h)
- :d* (any :d)
+ :A+ (some :A)
+ :D+ (some :D)
+ :H+ (some :H)
+ :S+ (some :S)
+ :W+ (some :W)
:a* (any :a)
- :w* (any :w)
+ :d* (any :d)
+ :h* (any :h)
:s* (any :s)
- :h* (any :h)})
+ :w* (any :w)
+ :A* (any :A)
+ :D* (any :D)
+ :H* (any :H)
+ :S* (any :S)
+ :W* (any :W)})
(setdyn *peg-grammar* default-peg-grammar)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/conf/janetconf.h
new/janet-1.33.0/src/conf/janetconf.h
--- old/janet-1.32.1/src/conf/janetconf.h 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/src/conf/janetconf.h 2024-01-07 20:30:08.000000000
+0100
@@ -4,10 +4,10 @@
#define JANETCONF_H
#define JANET_VERSION_MAJOR 1
-#define JANET_VERSION_MINOR 32
-#define JANET_VERSION_PATCH 1
+#define JANET_VERSION_MINOR 33
+#define JANET_VERSION_PATCH 0
#define JANET_VERSION_EXTRA ""
-#define JANET_VERSION "1.32.1"
+#define JANET_VERSION "1.33.0"
/* #define JANET_BUILD "local" */
@@ -52,6 +52,8 @@
/* #define JANET_EV_NO_EPOLL */
/* #define JANET_EV_NO_KQUEUE */
/* #define JANET_NO_INTERPRETER_INTERRUPT */
+/* #define JANET_NO_IPV6 */
+/* #define JANET_NO_CRYPTORAND */
/* Custom vm allocator support */
/* #include <mimalloc.h> */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/buffer.c
new/janet-1.33.0/src/core/buffer.c
--- old/janet-1.32.1/src/core/buffer.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/buffer.c 2024-01-07 20:30:08.000000000 +0100
@@ -135,8 +135,7 @@
/* Push a cstring to buffer */
void janet_buffer_push_cstring(JanetBuffer *buffer, const char *cstring) {
- int32_t len = 0;
- while (cstring[len]) ++len;
+ int32_t len = (int32_t) strlen(cstring);
janet_buffer_push_bytes(buffer, (const uint8_t *) cstring, len);
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/bytecode.c
new/janet-1.33.0/src/core/bytecode.c
--- old/janet-1.32.1/src/core/bytecode.c 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/src/core/bytecode.c 2024-01-07 20:30:08.000000000
+0100
@@ -226,6 +226,7 @@
case JOP_LOAD_TRUE:
case JOP_LOAD_FALSE:
case JOP_LOAD_SELF:
+ break;
case JOP_MAKE_ARRAY:
case JOP_MAKE_BUFFER:
case JOP_MAKE_STRING:
@@ -233,6 +234,8 @@
case JOP_MAKE_TABLE:
case JOP_MAKE_TUPLE:
case JOP_MAKE_BRACKET_TUPLE:
+ /* Reads from the stack, don't remove */
+ janetc_regalloc_touch(&ra, DD);
break;
/* Read A */
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/capi.c
new/janet-1.33.0/src/core/capi.c
--- old/janet-1.32.1/src/core/capi.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/capi.c 2024-01-07 20:30:08.000000000 +0100
@@ -505,7 +505,15 @@
#ifdef JANET_WINDOWS
return InterlockedDecrement(x);
#else
- return __atomic_add_fetch(x, -1, __ATOMIC_RELAXED);
+ return __atomic_add_fetch(x, -1, __ATOMIC_ACQ_REL);
+#endif
+}
+
+JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x) {
+#ifdef JANET_WINDOWS
+ return InterlockedOr(x, 0);
+#else
+ return __atomic_load_n(x, __ATOMIC_ACQUIRE);
#endif
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/corelib.c
new/janet-1.33.0/src/core/corelib.c
--- old/janet-1.32.1/src/core/corelib.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/corelib.c 2024-01-07 20:30:08.000000000 +0100
@@ -1144,7 +1144,7 @@
JDOC("(next ds &opt key)\n\n"
"Gets the next key in a data structure. Can be used
to iterate through "
"the keys of a data structure in an unspecified
order. Keys are guaranteed "
- "to be seen only once per iteration if they data
structure is not mutated "
+ "to be seen only once per iteration if the data
structure is not mutated "
"during iteration. If key is nil, next returns the
first key. If next "
"returns nil, there are no more keys to iterate
through."));
janet_quick_asm(env, JANET_FUN_PROP,
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/ev.c
new/janet-1.33.0/src/core/ev.c
--- old/janet-1.32.1/src/core/ev.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/ev.c 2024-01-07 20:30:08.000000000 +0100
@@ -258,12 +258,12 @@
fiber->ev_callback(fiber, JANET_ASYNC_EVENT_DEINIT);
janet_gcunroot(janet_wrap_abstract(fiber->ev_stream));
fiber->ev_callback = NULL;
- if (fiber->ev_state) {
- if (!(fiber->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) {
+ if (!(fiber->flags & JANET_FIBER_EV_FLAG_IN_FLIGHT)) {
+ if (fiber->ev_state) {
janet_free(fiber->ev_state);
- janet_ev_dec_refcount();
+ fiber->ev_state = NULL;
}
- fiber->ev_state = NULL;
+ janet_ev_dec_refcount();
}
}
}
@@ -1284,7 +1284,7 @@
int janet_loop_done(void) {
return !((janet_vm.spawn.head != janet_vm.spawn.tail) ||
janet_vm.tq_count ||
- janet_vm.listener_count);
+ janet_atomic_load(&janet_vm.listener_count));
}
JanetFiber *janet_loop1(void) {
@@ -1346,7 +1346,7 @@
}
/* Poll for events */
- if (janet_vm.tq_count || janet_vm.listener_count) {
+ if (janet_vm.tq_count || janet_atomic_load(&janet_vm.listener_count)) {
JanetTimeout to;
memset(&to, 0, sizeof(to));
int has_timeout;
@@ -1365,7 +1365,7 @@
break;
}
/* Run polling implementation only if pending timeouts or pending
events */
- if (janet_vm.tq_count || janet_vm.listener_count) {
+ if (janet_vm.tq_count || janet_atomic_load(&janet_vm.listener_count)) {
janet_loop1_impl(has_timeout, to.when);
}
}
@@ -1818,8 +1818,8 @@
JanetStream *stream = janet_vm.streams[i];
janet_vm.fds[i + 1].events = 0;
janet_vm.fds[i + 1].revents = 0;
- if (stream->read_fiber) janet_vm.fds[i + 1].events |= POLLIN;
- if (stream->write_fiber) janet_vm.fds[i + 1].events |= POLLOUT;
+ if (stream->read_fiber && stream->read_fiber->ev_callback)
janet_vm.fds[i + 1].events |= POLLIN;
+ if (stream->write_fiber && stream->write_fiber->ev_callback)
janet_vm.fds[i + 1].events |= POLLOUT;
}
/* Poll for events */
@@ -2031,33 +2031,35 @@
if (return_value.fiber == NULL) {
return;
}
- switch (return_value.tag) {
- default:
- case JANET_EV_TCTAG_NIL:
- janet_schedule(return_value.fiber, janet_wrap_nil());
- break;
- case JANET_EV_TCTAG_INTEGER:
- janet_schedule(return_value.fiber,
janet_wrap_integer(return_value.argi));
- break;
- case JANET_EV_TCTAG_STRING:
- case JANET_EV_TCTAG_STRINGF:
- janet_schedule(return_value.fiber, janet_cstringv((const char *)
return_value.argp));
- if (return_value.tag == JANET_EV_TCTAG_STRINGF)
janet_free(return_value.argp);
- break;
- case JANET_EV_TCTAG_KEYWORD:
- janet_schedule(return_value.fiber, janet_ckeywordv((const char *)
return_value.argp));
- break;
- case JANET_EV_TCTAG_ERR_STRING:
- case JANET_EV_TCTAG_ERR_STRINGF:
- janet_cancel(return_value.fiber, janet_cstringv((const char *)
return_value.argp));
- if (return_value.tag == JANET_EV_TCTAG_STRINGF)
janet_free(return_value.argp);
- break;
- case JANET_EV_TCTAG_ERR_KEYWORD:
- janet_cancel(return_value.fiber, janet_ckeywordv((const char *)
return_value.argp));
- break;
- case JANET_EV_TCTAG_BOOLEAN:
- janet_schedule(return_value.fiber,
janet_wrap_boolean(return_value.argi));
- break;
+ if (janet_fiber_can_resume(return_value.fiber)) {
+ switch (return_value.tag) {
+ default:
+ case JANET_EV_TCTAG_NIL:
+ janet_schedule(return_value.fiber, janet_wrap_nil());
+ break;
+ case JANET_EV_TCTAG_INTEGER:
+ janet_schedule(return_value.fiber,
janet_wrap_integer(return_value.argi));
+ break;
+ case JANET_EV_TCTAG_STRING:
+ case JANET_EV_TCTAG_STRINGF:
+ janet_schedule(return_value.fiber, janet_cstringv((const char
*) return_value.argp));
+ if (return_value.tag == JANET_EV_TCTAG_STRINGF)
janet_free(return_value.argp);
+ break;
+ case JANET_EV_TCTAG_KEYWORD:
+ janet_schedule(return_value.fiber, janet_ckeywordv((const char
*) return_value.argp));
+ break;
+ case JANET_EV_TCTAG_ERR_STRING:
+ case JANET_EV_TCTAG_ERR_STRINGF:
+ janet_cancel(return_value.fiber, janet_cstringv((const char *)
return_value.argp));
+ if (return_value.tag == JANET_EV_TCTAG_STRINGF)
janet_free(return_value.argp);
+ break;
+ case JANET_EV_TCTAG_ERR_KEYWORD:
+ janet_cancel(return_value.fiber, janet_ckeywordv((const char
*) return_value.argp));
+ break;
+ case JANET_EV_TCTAG_BOOLEAN:
+ janet_schedule(return_value.fiber,
janet_wrap_boolean(return_value.argi));
+ break;
+ }
}
janet_gcunroot(janet_wrap_fiber(return_value.fiber));
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/ffi.c
new/janet-1.33.0/src/core/ffi.c
--- old/janet-1.32.1/src/core/ffi.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/ffi.c 2024-01-07 20:30:08.000000000 +0100
@@ -999,13 +999,13 @@
uint64_t x;
} sysv64_sseint_return;
typedef sysv64_int_return janet_sysv64_variant_1(uint64_t a, uint64_t b,
uint64_t c, uint64_t d, uint64_t e, uint64_t f,
- double r1, double r2, double r3, double r4, double r5, double r6, double
r7, double r8);
+ double r1, double r2, double r3, double r4, double r5, double r6,
double r7, double r8);
typedef sysv64_sse_return janet_sysv64_variant_2(uint64_t a, uint64_t b,
uint64_t c, uint64_t d, uint64_t e, uint64_t f,
- double r1, double r2, double r3, double r4, double r5, double r6, double
r7, double r8);
+ double r1, double r2, double r3, double r4, double r5, double r6,
double r7, double r8);
typedef sysv64_intsse_return janet_sysv64_variant_3(uint64_t a, uint64_t b,
uint64_t c, uint64_t d, uint64_t e, uint64_t f,
- double r1, double r2, double r3, double r4, double r5, double r6, double
r7, double r8);
+ double r1, double r2, double r3, double r4, double r5, double r6,
double r7, double r8);
typedef sysv64_sseint_return janet_sysv64_variant_4(uint64_t a, uint64_t b,
uint64_t c, uint64_t d, uint64_t e, uint64_t f,
- double r1, double r2, double r3, double r4, double r5, double r6, double
r7, double r8);
+ double r1, double r2, double r3, double r4, double r5, double r6,
double r7, double r8);
static Janet janet_ffi_sysv64(JanetFFISignature *signature, void
*function_pointer, const Janet *argv) {
union {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/marsh.c
new/janet-1.33.0/src/core/marsh.c
--- old/janet-1.32.1/src/core/marsh.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/marsh.c 2024-01-07 20:30:08.000000000 +0100
@@ -185,6 +185,19 @@
/* Prevent stack overflows */
#define MARSH_STACKCHECK if ((flags & 0xFFFF) > JANET_RECURSION_GUARD)
janet_panic("stack overflow")
+/* Quick check if a fiber cannot be marshalled. This is will
+ * have no false positives, but may have false negatives. */
+static int fiber_cannot_be_marshalled(JanetFiber *fiber) {
+ if (janet_fiber_status(fiber) == JANET_STATUS_ALIVE) return 1;
+ int32_t i = fiber->frame;
+ while (i > 0) {
+ JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i -
JANET_FRAME_SIZE);
+ if (!frame->func) return 1; /* has cfunction on stack */
+ i = frame->prevframe;
+ }
+ return 0;
+}
+
/* Marshal a function env */
static void marshal_one_env(MarshalState *st, JanetFuncEnv *env, int flags) {
MARSH_STACKCHECK;
@@ -197,7 +210,9 @@
}
janet_env_valid(env);
janet_v_push(st->seen_envs, env);
- if (env->offset > 0 && (JANET_STATUS_ALIVE ==
janet_fiber_status(env->as.fiber))) {
+
+ /* Special case for early detachment */
+ if (env->offset > 0 && fiber_cannot_be_marshalled(env->as.fiber)) {
pushint(st, 0);
pushint(st, env->length);
Janet *values = env->as.fiber->data + env->offset;
@@ -328,7 +343,7 @@
while (i > 0) {
JanetStackFrame *frame = (JanetStackFrame *)(fiber->data + i -
JANET_FRAME_SIZE);
if (frame->env) frame->flags |= JANET_STACKFRAME_HASENV;
- if (!frame->func) janet_panic("cannot marshal fiber with c
stackframe");
+ if (!frame->func) janet_panicf("cannot marshal fiber with c stackframe
(%v)", janet_wrap_cfunction((JanetCFunction) frame->pc));
pushint(st, frame->flags);
pushint(st, frame->prevframe);
int32_t pcdiff = (int32_t)(frame->pc - frame->func->def->bytecode);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/net.c
new/janet-1.33.0/src/core/net.c
--- old/janet-1.32.1/src/core/net.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/net.c 2024-01-07 20:30:08.000000000 +0100
@@ -79,12 +79,20 @@
/* maximum number of bytes in a socket address host (post name resolution) */
#ifdef JANET_WINDOWS
+#ifdef JANET_NO_IPV6
+#define SA_ADDRSTRLEN (INET_ADDRSTRLEN + 1)
+#else
#define SA_ADDRSTRLEN (INET6_ADDRSTRLEN + 1)
+#endif
typedef unsigned short in_port_t;
#else
#define JANET_SA_MAX(a, b) (((a) > (b))? (a) : (b))
+#ifdef JANET_NO_IPV6
+#define SA_ADDRSTRLEN JANET_SA_MAX(INET_ADDRSTRLEN + 1, (sizeof ((struct
sockaddr_un *)0)->sun_path) + 1)
+#else
#define SA_ADDRSTRLEN JANET_SA_MAX(INET6_ADDRSTRLEN + 1, (sizeof ((struct
sockaddr_un *)0)->sun_path) + 1)
#endif
+#endif
static JanetStream *make_stream(JSock handle, uint32_t flags);
@@ -114,18 +122,13 @@
/* State machine for async connect */
-typedef struct {
- int did_connect;
-} NetStateConnect;
-
void net_callback_connect(JanetFiber *fiber, JanetAsyncEvent event) {
JanetStream *stream = fiber->ev_stream;
- NetStateConnect *state = (NetStateConnect *)fiber->ev_state;
switch (event) {
default:
break;
#ifndef JANET_WINDOWS
- /* Wait until we have an actually event before checking.
+ /* Wait until we have an actual event before checking.
* Windows doesn't support async connect with this, just try
immediately.*/
case JANET_ASYNC_EVENT_INIT:
#endif
@@ -147,7 +150,6 @@
#endif
if (r == 0) {
if (res == 0) {
- state->did_connect = 1;
janet_schedule(fiber, janet_wrap_abstract(stream));
} else {
janet_cancel(fiber, janet_cstringv(strerror(res)));
@@ -160,10 +162,8 @@
janet_async_end(fiber);
}
-static void net_sched_connect(JanetStream *stream) {
- NetStateConnect *state = janet_malloc(sizeof(NetStateConnect));
- state->did_connect = 0;
- janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect,
state);
+static JANET_NO_RETURN void net_sched_connect(JanetStream *stream) {
+ janet_async_start(stream, JANET_ASYNC_LISTEN_WRITE, net_callback_connect,
NULL);
}
/* State machine for accepting connections. */
@@ -575,7 +575,6 @@
}
net_sched_connect(stream);
- janet_await();
}
static const char *serverify_socket(JSock sfd) {
@@ -746,6 +745,7 @@
Janet pair[2] = {janet_cstringv(buffer),
janet_wrap_integer(ntohs(sai->sin_port))};
return janet_wrap_tuple(janet_tuple_n(pair, 2));
}
+#ifndef JANET_NO_IPV6
case AF_INET6: {
const struct sockaddr_in6 *sai6 = sa_any;
if (!inet_ntop(AF_INET6, &(sai6->sin6_addr), buffer,
sizeof(buffer))) {
@@ -754,6 +754,7 @@
Janet pair[2] = {janet_cstringv(buffer),
janet_wrap_integer(ntohs(sai6->sin6_port))};
return janet_wrap_tuple(janet_tuple_n(pair, 2));
}
+#endif
#ifndef JANET_WINDOWS
case AF_UNIX: {
const struct sockaddr_un *sun = sa_any;
@@ -820,6 +821,7 @@
JanetStream *stream = janet_getabstract(argv, 0, &janet_stream_type);
janet_stream_flags(stream, JANET_STREAM_ACCEPTABLE | JANET_STREAM_SOCKET);
JanetFunction *fun = janet_getfunction(argv, 1);
+ if (fun->def->min_arity < 1) janet_panic("handler function must take at
least 1 argument");
janet_sched_accept(stream, fun);
}
@@ -956,8 +958,10 @@
{ "ip-multicast-ttl", IPPROTO_IP, IP_MULTICAST_TTL, JANET_NUMBER },
{ "ip-add-membership", IPPROTO_IP, IP_ADD_MEMBERSHIP, JANET_POINTER },
{ "ip-drop-membership", IPPROTO_IP, IP_DROP_MEMBERSHIP, JANET_POINTER },
+#ifndef JANET_NO_IPV6
{ "ipv6-join-group", IPPROTO_IPV6, IPV6_JOIN_GROUP, JANET_POINTER },
{ "ipv6-leave-group", IPPROTO_IPV6, IPV6_LEAVE_GROUP, JANET_POINTER },
+#endif
{ NULL, 0, 0, JANET_POINTER }
};
@@ -994,7 +998,9 @@
union {
int v_int;
struct ip_mreq v_mreq;
+#ifndef JANET_NO_IPV6
struct ipv6_mreq v_mreq6;
+#endif
} val;
void *optval = (void *)&val;
@@ -1012,12 +1018,14 @@
val.v_mreq.imr_interface.s_addr = htonl(INADDR_ANY);
inet_pton(AF_INET, addr, &val.v_mreq.imr_multiaddr.s_addr);
optlen = sizeof(val.v_mreq);
+#ifndef JANET_NO_IPV6
} else if (st->optname == IPV6_JOIN_GROUP || st->optname ==
IPV6_LEAVE_GROUP) {
const char *addr = janet_getcstring(argv, 2);
memset(&val.v_mreq6, 0, sizeof val.v_mreq6);
val.v_mreq6.ipv6mr_interface = 0;
inet_pton(AF_INET6, addr, &val.v_mreq6.ipv6mr_multiaddr);
optlen = sizeof(val.v_mreq6);
+#endif
} else {
janet_panicf("invalid socket option type");
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/os.c
new/janet-1.33.0/src/core/os.c
--- old/janet-1.32.1/src/core/os.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/os.c 2024-01-07 20:30:08.000000000 +0100
@@ -529,7 +529,9 @@
JanetString s = janet_formatc("command failed with non-zero exit
code %d", status);
janet_cancel(args.fiber, janet_wrap_string(s));
} else {
- janet_schedule(args.fiber, janet_wrap_integer(status));
+ if (janet_fiber_can_resume(args.fiber)) {
+ janet_schedule(args.fiber, janet_wrap_integer(status));
+ }
}
}
}
@@ -640,7 +642,7 @@
#ifdef SIGTERM
{"term", SIGTERM},
#endif
-#ifdef SIGARLM
+#ifdef SIGALRM
{"alrm", SIGALRM},
#endif
#ifdef SIGHUP
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/peg.c
new/janet-1.33.0/src/core/peg.c
--- old/janet-1.32.1/src/core/peg.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/peg.c 2024-01-07 20:30:08.000000000 +0100
@@ -39,6 +39,10 @@
typedef struct {
const uint8_t *text_start;
const uint8_t *text_end;
+ /* text_end will be restricted in a (sub) rule, but
+ outer_text_end will always contain the real end of
+ input, which we need to generate a line mapping */
+ const uint8_t *outer_text_end;
const uint32_t *bytecode;
const Janet *constants;
JanetArray *captures;
@@ -114,12 +118,12 @@
/* Generate if not made yet */
if (s->linemaplen < 0) {
int32_t newline_count = 0;
- for (const uint8_t *c = s->text_start; c < s->text_end; c++) {
+ for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) {
if (*c == '\n') newline_count++;
}
int32_t *mem = janet_smalloc(sizeof(int32_t) * newline_count);
size_t index = 0;
- for (const uint8_t *c = s->text_start; c < s->text_end; c++) {
+ for (const uint8_t *c = s->text_start; c < s->outer_text_end; c++) {
if (*c == '\n') mem[index++] = (int32_t)(c - s->text_start);
}
s->linemaplen = newline_count;
@@ -179,7 +183,7 @@
const uint32_t *rule,
const uint8_t *text) {
tail:
- switch (*rule & 0x1F) {
+ switch (*rule) {
default:
janet_panic("unexpected opcode");
return NULL;
@@ -482,6 +486,30 @@
return result;
}
+ case RULE_SUB: {
+ const uint8_t *text_start = text;
+ const uint32_t *rule_window = s->bytecode + rule[1];
+ const uint32_t *rule_subpattern = s->bytecode + rule[2];
+ down1(s);
+ const uint8_t *window_end = peg_rule(s, rule_window, text);
+ up1(s);
+ if (!window_end) {
+ return NULL;
+ }
+ const uint8_t *saved_end = s->text_end;
+ s->text_end = window_end;
+ down1(s);
+ const uint8_t *next_text = peg_rule(s, rule_subpattern,
text_start);
+ up1(s);
+ s->text_end = saved_end;
+
+ if (!next_text) {
+ return NULL;
+ }
+
+ return window_end;
+ }
+
case RULE_REPLACE:
case RULE_MATCHTIME: {
uint32_t tag = rule[3];
@@ -1107,6 +1135,14 @@
emit_3(r, RULE_MATCHTIME, subrule, cindex, tag);
}
+static void spec_sub(Builder *b, int32_t argc, const Janet *argv) {
+ peg_fixarity(b, argc, 2);
+ Reserve r = reserve(b, 3);
+ uint32_t subrule1 = peg_compile1(b, argv[0]);
+ uint32_t subrule2 = peg_compile1(b, argv[1]);
+ emit_2(r, RULE_SUB, subrule1, subrule2);
+}
+
#ifdef JANET_INT_TYPES
#define JANET_MAX_READINT_WIDTH 8
#else
@@ -1190,6 +1226,7 @@
{"sequence", spec_sequence},
{"set", spec_set},
{"some", spec_some},
+ {"sub", spec_sub},
{"thru", spec_thru},
{"to", spec_to},
{"uint", spec_uint_le},
@@ -1431,7 +1468,7 @@
uint32_t instr = bytecode[i];
uint32_t *rule = bytecode + i;
op_flags[i] |= 0x02;
- switch (instr & 0x1F) {
+ switch (instr) {
case RULE_LITERAL:
i += 2 + ((rule[1] + 3) >> 2);
break;
@@ -1524,6 +1561,14 @@
op_flags[rule[1]] |= 0x01;
i += 4;
break;
+ case RULE_SUB:
+ /* [rule, rule] */
+ if (rule[1] >= blen) goto bad;
+ if (rule[2] >= blen) goto bad;
+ op_flags[rule[1]] |= 0x01;
+ op_flags[rule[2]] |= 0x01;
+ i += 3;
+ break;
case RULE_ERROR:
case RULE_DROP:
case RULE_NOT:
@@ -1652,7 +1697,7 @@
static PegCall peg_cfun_init(int32_t argc, Janet *argv, int get_replace) {
PegCall ret;
int32_t min = get_replace ? 3 : 2;
- janet_arity(argc, get_replace, -1);
+ janet_arity(argc, min, -1);
if (janet_checktype(argv[0], JANET_ABSTRACT) &&
janet_abstract_type(janet_unwrap_abstract(argv[0])) ==
&janet_peg_type) {
ret.peg = janet_unwrap_abstract(argv[0]);
@@ -1677,6 +1722,7 @@
ret.s.mode = PEG_MODE_NORMAL;
ret.s.text_start = ret.bytes.bytes;
ret.s.text_end = ret.bytes.bytes + ret.bytes.len;
+ ret.s.outer_text_end = ret.s.text_end;
ret.s.depth = JANET_RECURSION_GUARD;
ret.s.captures = janet_array(0);
ret.s.tagged_captures = janet_array(0);
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/specials.c
new/janet-1.33.0/src/core/specials.c
--- old/janet-1.32.1/src/core/specials.c 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/src/core/specials.c 2024-01-07 20:30:08.000000000
+0100
@@ -531,17 +531,11 @@
}
/* Check if a form matches the pattern (= nil _) or (not= nil _) */
-static int janetc_check_nil_form(JanetFopts opts, Janet x, Janet *capture,
uint32_t fun_tag) {
+static int janetc_check_nil_form(Janet x, Janet *capture, uint32_t fun_tag) {
if (!janet_checktype(x, JANET_TUPLE)) return 0;
JanetTuple tup = janet_unwrap_tuple(x);
if (3 != janet_tuple_length(tup)) return 0;
Janet op1 = tup[0];
- if (janet_checktype(op1, JANET_SYMBOL)) {
- Janet entry = janet_table_get(opts.compiler->env, op1);
- if (janet_checktype(entry, JANET_TABLE)) {
- op1 = janet_table_get(janet_unwrap_table(entry),
janet_ckeywordv("value"));
- }
- }
if (!janet_checktype(op1, JANET_FUNCTION)) return 0;
JanetFunction *fun = janet_unwrap_function(op1);
uint32_t tag = fun->def->flags & JANET_FUNCDEF_FLAG_TAG;
@@ -601,10 +595,9 @@
janetc_scope(&condscope, c, 0, "if");
Janet condform = argv[0];
- if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_EQ)) {
+ if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) {
ifnjmp = JOP_JUMP_IF_NOT_NIL;
- }
- if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_NEQ)) {
+ } else if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) {
ifnjmp = JOP_JUMP_IF_NIL;
}
@@ -613,7 +606,11 @@
/* Check constant condition. */
/* TODO: Use type info for more short circuits */
if (cond.flags & JANET_SLOT_CONSTANT) {
- if (!janet_truthy(cond.constant)) {
+ int swap_condition = 0;
+ if (ifnjmp == JOP_JUMP_IF_NOT && !janet_truthy(cond.constant))
swap_condition = 1;
+ if (ifnjmp == JOP_JUMP_IF_NIL && janet_checktype(cond.constant,
JANET_NIL)) swap_condition = 1;
+ if (ifnjmp == JOP_JUMP_IF_NOT_NIL && !janet_checktype(cond.constant,
JANET_NIL)) swap_condition = 1;
+ if (swap_condition) {
/* Swap the true and false bodies */
Janet temp = falsebody;
falsebody = truebody;
@@ -808,12 +805,12 @@
* jmpnl or jmpnn instructions. This let's us implement `(each ...)`
* more efficiently. */
Janet condform = argv[0];
- if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_EQ)) {
+ if (janetc_check_nil_form(condform, &condform, JANET_FUN_EQ)) {
is_nil_form = 1;
ifjmp = JOP_JUMP_IF_NIL;
ifnjmp = JOP_JUMP_IF_NOT_NIL;
}
- if (janetc_check_nil_form(opts, condform, &condform, JANET_FUN_NEQ)) {
+ if (janetc_check_nil_form(condform, &condform, JANET_FUN_NEQ)) {
is_notnil_form = 1;
ifjmp = JOP_JUMP_IF_NOT_NIL;
ifnjmp = JOP_JUMP_IF_NIL;
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/string.c
new/janet-1.33.0/src/core/string.c
--- old/janet-1.32.1/src/core/string.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/string.c 2024-01-07 20:30:08.000000000 +0100
@@ -549,8 +549,8 @@
"- `a`, `A`: floating point number, formatted as a hexadecimal
number.\n"
"- `s`: formatted as a string, precision indicates padding and
maximum length.\n"
"- `t`: emit the type of the given value.\n"
- "- `v`: format with (describe x)"
- "- `V`: format with (string x)"
+ "- `v`: format with (describe x)\n"
+ "- `V`: format with (string x)\n"
"- `j`: format to jdn (Janet data notation).\n"
"\n"
"The following conversion specifiers are used for
\"pretty-printing\", where the upper-case "
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/symcache.c
new/janet-1.33.0/src/core/symcache.c
--- old/janet-1.32.1/src/core/symcache.c 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/src/core/symcache.c 2024-01-07 20:30:08.000000000
+0100
@@ -234,6 +234,7 @@
head->hash = hash;
sym = (uint8_t *)(head->data);
memcpy(sym, janet_vm.gensym_counter, sizeof(janet_vm.gensym_counter));
+ sym[head->length] = 0;
janet_symcache_put((const uint8_t *)sym, bucket);
return (const uint8_t *)sym;
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/core/util.c
new/janet-1.33.0/src/core/util.c
--- old/janet-1.32.1/src/core/util.c 2023-10-15 21:33:43.000000000 +0200
+++ new/janet-1.33.0/src/core/util.c 2024-01-07 20:30:08.000000000 +0100
@@ -960,6 +960,7 @@
#endif
int janet_cryptorand(uint8_t *out, size_t n) {
+#ifndef JANET_NO_CRYPTORAND
#ifdef JANET_WINDOWS
for (size_t i = 0; i < n; i += sizeof(unsigned int)) {
unsigned int v;
@@ -971,7 +972,10 @@
}
}
return 0;
-#elif defined(JANET_LINUX) || defined(JANET_CYGWIN) || ( defined(JANET_APPLE)
&& !defined(MAC_OS_X_VERSION_10_7) )
+#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)
+ arc4random_buf(out, n);
+ return 0;
+#else
/* We should be able to call getrandom on linux, but it doesn't seem
to be uniformly supported on linux distros.
On Mac, arc4random_buf wasn't available on until 10.7.
@@ -993,12 +997,10 @@
}
RETRY_EINTR(rc, close(randfd));
return 0;
-#elif defined(JANET_BSD) || defined(MAC_OS_X_VERSION_10_7)
- arc4random_buf(out, n);
- return 0;
+#endif
#else
- (void) n;
(void) out;
+ (void) n;
return -1;
#endif
}
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/src/include/janet.h
new/janet-1.33.0/src/include/janet.h
--- old/janet-1.32.1/src/include/janet.h 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/src/include/janet.h 2024-01-07 20:30:08.000000000
+0100
@@ -647,6 +647,7 @@
#endif
JANET_API JanetAtomicInt janet_atomic_inc(JanetAtomicInt volatile *x);
JANET_API JanetAtomicInt janet_atomic_dec(JanetAtomicInt volatile *x);
+JANET_API JanetAtomicInt janet_atomic_load(JanetAtomicInt volatile *x);
/* We provide three possible implementations of Janets. The preferred
* nanboxing approach, for 32 or 64 bits, and the standard C version. Code in
the rest of the
@@ -2139,7 +2140,8 @@
RULE_LINE, /* [tag] */
RULE_COLUMN, /* [tag] */
RULE_UNREF, /* [rule, tag] */
- RULE_CAPTURE_NUM /* [rule, tag] */
+ RULE_CAPTURE_NUM, /* [rule, tag] */
+ RULE_SUB /* [rule, rule] */
} JanetPegOpcod;
typedef struct {
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/test/suite-boot.janet
new/janet-1.33.0/test/suite-boot.janet
--- old/janet-1.32.1/test/suite-boot.janet 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/test/suite-boot.janet 2024-01-07 20:30:08.000000000
+0100
@@ -241,6 +241,16 @@
(assert (pos? (% x 4)) "generate in loop"))
(assert (= gencount 75) "generate loop count")
+# more loop checks
+(assert (deep= (seq [i :range [0 10]] i) @[0 1 2 3 4 5 6 7 8 9]) "seq 1")
+(assert (deep= (seq [i :range [0 10 2]] i) @[0 2 4 6 8]) "seq 2")
+(assert (deep= (seq [i :range [10]] i) @[0 1 2 3 4 5 6 7 8 9]) "seq 3")
+(assert (deep= (seq [i :range-to [10]] i) @[0 1 2 3 4 5 6 7 8 9 10]) "seq 4")
+(def gen (generate [x :range-to [0 nil 2]] x))
+(assert (deep= (take 5 gen) @[0 2 4 6 8]) "generate nil limit")
+(def gen (generate [x :range [0 nil 2]] x))
+(assert (deep= (take 5 gen) @[0 2 4 6 8]) "generate nil limit 2")
+
# Even and odd
# ff163a5ae
(assert (odd? 9) "odd? 1")
@@ -951,4 +961,15 @@
# (pp (disasm case-2))
# (pp (disasm case-3))
+# Regression #1330
+(defn regress-1330 [&]
+ (def a [1 2 3])
+ (def b [;a])
+ (identity a))
+(assert (= [1 2 3] (regress-1330)) "regression 1330")
+
+# Issue 1341
+(assert (= () '() (macex '())) "macex ()")
+(assert (= '[] (macex '[])) "macex []")
+
(end-suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/test/suite-ev.janet
new/janet-1.33.0/test/suite-ev.janet
--- old/janet-1.32.1/test/suite-ev.janet 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/test/suite-ev.janet 2024-01-07 20:30:08.000000000
+0100
@@ -366,4 +366,10 @@
(exec-slurp ;run janet "-e" "(print :hi)")))
"exec-slurp 1"))
+# valgrind-able check for #1337
+(def superv (ev/chan 10))
+(def f (ev/go |(ev/sleep 1e9) nil superv))
+(ev/cancel f (gensym))
+(ev/take superv)
+
(end-suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/test/suite-peg.janet
new/janet-1.33.0/test/suite-peg.janet
--- old/janet-1.32.1/test/suite-peg.janet 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/test/suite-peg.janet 2024-01-07 20:30:08.000000000
+0100
@@ -263,6 +263,8 @@
(marshpeg '(if-not "abcdf" 123))
(marshpeg ~(cmt "abcdf" ,identity))
(marshpeg '(group "abc"))
+(marshpeg '(sub "abcdf" "abc"))
+(marshpeg '(* (sub 1 1)))
# Peg swallowing errors
# 159651117
@@ -660,5 +662,53 @@
(peg/match '(if (not (* (constant 7) "a")) "hello") "hello")
@[]) "peg if not")
+(defn test [name peg input expected]
+ (assert (deep= (peg/match peg input) expected) name))
+
+(test "sub: matches the same input twice"
+ ~(sub "abcd" "abc")
+ "abcdef"
+ @[])
+
+(test "sub: second pattern cannot match more than the first pattern"
+ ~(sub "abcd" "abcde")
+ "abcdef"
+ nil)
+
+(test "sub: fails if first pattern fails"
+ ~(sub "x" "abc")
+ "abcdef"
+ nil)
+
+(test "sub: fails if second pattern fails"
+ ~(sub "abc" "x")
+ "abcdef"
+ nil)
+
+(test "sub: keeps captures from both patterns"
+ ~(sub '"abcd" '"abc")
+ "abcdef"
+ @["abcd" "abc"])
+
+(test "sub: second pattern can reference captures from first"
+ ~(* (constant 5 :tag) (sub (capture "abc" :tag) (backref :tag)))
+ "abcdef"
+ @[5 "abc" "abc"])
+
+(test "sub: second pattern can't see past what the first pattern matches"
+ ~(sub "abc" (* "abc" -1))
+ "abcdef"
+ @[])
+
+(test "sub: positions inside second match are still relative to the entire
input"
+ ~(* "one\ntw" (sub "o" (* ($) (line) (column))))
+ "one\ntwo\nthree\n"
+ @[6 2 3])
+
+(test "sub: advances to the end of the first pattern's match"
+ ~(* (sub "abc" "ab") "d")
+ "abcdef"
+ @[])
+
(end-suite)
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/janet-1.32.1/test/suite-specials.janet
new/janet-1.33.0/test/suite-specials.janet
--- old/janet-1.32.1/test/suite-specials.janet 2023-10-15 21:33:43.000000000
+0200
+++ new/janet-1.33.0/test/suite-specials.janet 2024-01-07 20:30:08.000000000
+0100
@@ -198,5 +198,9 @@
(assert (= (test) '(1 ())) "issue #919")
-(end-suite)
+# Regression #1327
+(def x "A")
+(def x (if (= nil x) "B" x))
+(assert (= x "A"))
+(end-suite)
