ref: 00c2c84deabbed8dfe7ed1c5e25af4dd093d3755
parent: 22b11e5411affc4a91204eb45590bd1796274e35
author: Sigrid Solveig Haflínudóttir <sigrid@ftrv.se>
date: Thu Mar 6 21:27:39 EST 2025
rename types; remove "_t" suffix from type names (leave sl_t as is) Third round of renamings to avoid conflicts and to fit more with Plan 9 style of namings.
--- a/3rd/brieflz/brieflz.c
+++ b/3rd/brieflz/brieflz.c
@@ -433,14 +433,14 @@
return blz_hash4_bits(p, BLZ_HASH_BITS);
}
-size_t
-blz_max_packed_size(size_t src_size)
+usize
+blz_max_packed_size(usize src_size)
{return src_size + src_size / 8 + 64;
}
-size_t
-blz_workmem_size(size_t src_size)
+usize
+blz_workmem_size(usize src_size)
{USED(src_size);
@@ -571,8 +571,8 @@
#include "brieflz_lazy.h"
#include "brieflz_leparse.h"
-size_t
-blz_workmem_size_level(size_t src_size, int level)
+usize
+blz_workmem_size_level(usize src_size, int level)
{ switch (level) {case 1:
@@ -592,7 +592,7 @@
case 10:
return blz_btparse_workmem_size(src_size);
default:
- return (size_t) -1;
+ return (usize) -1;
}
}
@@ -639,7 +639,7 @@
#endif
extern int
-LLVMFuzzerTestOneInput(const u8int *data, size_t size)
+LLVMFuzzerTestOneInput(const u8int *data, usize size)
{ if (size > ULONG_MAX / 2) { return 0; }void *workmem = MEM_MALLOC(blz_workmem_size_level(size, BLZ_FUZZ_LEVEL));
--- a/3rd/brieflz/brieflz.h
+++ b/3rd/brieflz/brieflz.h
@@ -78,8 +78,8 @@
* @param src_size number of bytes to compress
* @return maximum size of compressed data
*/
-BLZ_API size_t
-blz_max_packed_size(size_t src_size) sl_constfn;
+BLZ_API usize
+blz_max_packed_size(usize src_size) sl_constfn;
/**
* Get required size of `workmem` buffer.
@@ -89,8 +89,8 @@
* @param src_size number of bytes to compress
* @return required size in bytes of `workmem` buffer
*/
-BLZ_API size_t
-blz_workmem_size(size_t src_size) sl_constfn;
+BLZ_API usize
+blz_workmem_size(usize src_size) sl_constfn;
/**
* Compress `src_size` bytes of data from `src` to `dst`.
@@ -113,8 +113,8 @@
* @param level compression level
* @return required size in bytes of `workmem` buffer
*/
-BLZ_API size_t
-blz_workmem_size_level(size_t src_size, int level) sl_constfn;
+BLZ_API usize
+blz_workmem_size_level(usize src_size, int level) sl_constfn;
/**
* Compress `src_size` bytes of data from `src` to `dst`.
--- a/3rd/brieflz/brieflz_btparse.h
+++ b/3rd/brieflz/brieflz_btparse.h
@@ -28,8 +28,8 @@
#ifndef BRIEFLZ_BTPARSE_H_INCLUDED
#define BRIEFLZ_BTPARSE_H_INCLUDED
-static size_t
-blz_btparse_workmem_size(size_t src_size)
+static usize
+blz_btparse_workmem_size(usize src_size)
{return (5 * src_size + 3 + LOOKUP_SIZE) * sizeof(blz_word);
}
--- a/3rd/brieflz/brieflz_hashbucket.h
+++ b/3rd/brieflz/brieflz_hashbucket.h
@@ -29,13 +29,13 @@
#define BRIEFLZ_HASHBUCKET_H_INCLUDED
sl_constfn
-static size_t
-blz_hashbucket_workmem_size(size_t src_size, unsigned int bucket_size)
+static usize
+blz_hashbucket_workmem_size(usize src_size, unsigned int bucket_size)
{USED(src_size);
assert(bucket_size > 0);
- assert(sizeof(bucket_size) < sizeof(size_t)
+ assert(sizeof(bucket_size) < sizeof(usize)
);//|| bucket_size < SIZE_MAX / (LOOKUP_SIZE * sizeof(blz_word)));
return (LOOKUP_SIZE * bucket_size) * sizeof(blz_word);
--- a/3rd/brieflz/brieflz_hashchain.h
+++ b/3rd/brieflz/brieflz_hashchain.h
@@ -28,8 +28,8 @@
#ifndef BRIEFLZ_HASHCHAIN_H_INCLUDED
#define BRIEFLZ_HASHCHAIN_H_INCLUDED
-static size_t
-blz_hashchain_workmem_size(size_t src_size)
+static usize
+blz_hashchain_workmem_size(usize src_size)
{return (LOOKUP_SIZE + src_size) * sizeof(blz_word);
}
--- a/3rd/brieflz/brieflz_lazy.h
+++ b/3rd/brieflz/brieflz_lazy.h
@@ -28,8 +28,8 @@
#ifndef BRIEFLZ_LAZY_H_INCLUDED
#define BRIEFLZ_LAZY_H_INCLUDED
-static size_t
-blz_lazy_workmem_size(size_t src_size)
+static usize
+blz_lazy_workmem_size(usize src_size)
{USED(src_size);
--- a/3rd/brieflz/brieflz_leparse.h
+++ b/3rd/brieflz/brieflz_leparse.h
@@ -28,8 +28,8 @@
#ifndef BRIEFLZ_LEPARSE_H_INCLUDED
#define BRIEFLZ_LEPARSE_H_INCLUDED
-static size_t
-blz_leparse_workmem_size(size_t src_size)
+static usize
+blz_leparse_workmem_size(usize src_size)
{return (LOOKUP_SIZE < 2 * src_size ? 3 * src_size : src_size + LOOKUP_SIZE)
* sizeof(blz_word);
--- a/3rd/brieflz/brieflz_sliding.h
+++ b/3rd/brieflz/brieflz_sliding.h
@@ -28,14 +28,14 @@
#ifndef BRIEFLZ_SLIDING_H_INCLUDED
#define BRIEFLZ_SLIDING_H_INCLUDED
-static size_t
-blz_sliding_workmem_size(size_t src_size, int window_log)
+static usize
+blz_sliding_workmem_size(usize src_size, int window_log)
{(void) src_size;
assert(window_log > 0 && window_log < blz_log2(BLZ_WORD_MAX));
- return (LOOKUP_SIZE + ((size_t) 1 << window_log)) * sizeof(blz_word);
+ return (LOOKUP_SIZE + ((usize) 1 << window_log)) * sizeof(blz_word);
}
// Lazy parsing with a sliding window of previous positions.
--- a/3rd/brieflz/brieflz_ssparse.h
+++ b/3rd/brieflz/brieflz_ssparse.h
@@ -28,8 +28,8 @@
#ifndef BRIEFLZ_SSPARSE_H_INCLUDED
#define BRIEFLZ_SSPARSE_H_INCLUDED
-static size_t
-blz_ssparse_workmem_size(size_t src_size)
+static usize
+blz_ssparse_workmem_size(usize src_size)
{return (LOOKUP_SIZE < 2 * src_size ? 3 * src_size : src_size + LOOKUP_SIZE)
* sizeof(blz_word);
--- a/3rd/brieflz/depacks.c
+++ b/3rd/brieflz/depacks.c
@@ -298,7 +298,7 @@
#include <string.h>
extern int
-LLVMFuzzerTestOneInput(const u8int *data, size_t size)
+LLVMFuzzerTestOneInput(const u8int *data, usize size)
{ if (size > ULONG_MAX / 2) { return 0; }void *depacked = MEM_MALLOC(4096);
--- a/3rd/dlmalloc.inc
+++ b/3rd/dlmalloc.inc
@@ -47,10 +47,10 @@
* Vital statistics:
- Supported pointer/size_t representation: 4 or 8 bytes
- size_t MUST be an unsigned type of the same width as
+ Supported pointer/usize representation: 4 or 8 bytes
+ usize MUST be an unsigned type of the same width as
pointers. (If you are using an ancient system that declares
- size_t as a signed type, or need it to be a different width
+ usize as a signed type, or need it to be a different width
than pointers, you can use a previous release of this malloc
(e.g. 2.7.2) supporting these.)
@@ -176,7 +176,7 @@
All operations (except malloc_stats and mallinfo) have execution
times that are bounded by a constant factor of the number of bits in
- a size_t, not counting any clearing in calloc or copying in realloc,
+ a usize, not counting any clearing in calloc or copying in realloc,
or actions surrounding MORECORE and MMAP that have times
proportional to the number of non-contiguous regions returned by
system allocation routines, which is often just 1. In real-time
@@ -216,7 +216,7 @@
You can similarly create thread-local allocators by storing
mspaces as thread-locals. For example:
static __thread mspace tlms = 0;
- void* tlmalloc(size_t bytes) {+ void* tlmalloc(usize bytes) {if (tlms == 0) tlms = create_mspace(0, 0);
return mspace_malloc(tlms, bytes);
}
@@ -232,8 +232,8 @@
------------------------- Compile-time options ---------------------------
Be careful in setting #define values for numerical constants of type
-size_t. On some systems, literal values are not automatically extended
-to size_t precision unless they are explicitly casted. You can also
+usize. On some systems, literal values are not automatically extended
+to usize precision unless they are explicitly casted. You can also
use the symbolic values MAX_SIZE_T, SIZE_T_ONE, etc below.
WIN32 default: defined if _WIN32 defined
@@ -259,7 +259,7 @@
If you want a POSIX ELF shared object, you might use
#define DLMALLOC_EXPORT extern __attribute__((visibility("default")))-MALLOC_ALIGNMENT default: (size_t)(2 * sizeof(void *))
+MALLOC_ALIGNMENT default: (usize)(2 * sizeof(void *))
Controls the minimum alignment for malloc'ed chunks. It must be a
power of two and at least 8, even on machines for which smaller
alignments would suffice. It may be defined as larger than this
@@ -368,11 +368,11 @@
The name of the sbrk-style system routine to call to obtain more
memory. See below for guidance on writing custom MORECORE
functions. The type of the argument to sbrk/MORECORE varies across
- systems. It cannot be size_t, because it supports negative
+ systems. It cannot be usize, because it supports negative
arguments, so it is normally the signed type of the same width as
- size_t (sometimes declared as "intptr_t"). It doesn't much matter
+ usize (sometimes declared as "intptr"). It doesn't much matter
though. Internally, we only call it with arguments less than half
- the max value of a size_t, which should work across all reasonable
+ the max value of a usize, which should work across all reasonable
possibilities, although sometimes generating compiler warnings.
MORECORE_CONTIGUOUS default: 1 (true) if HAVE_MORECORE
@@ -437,10 +437,10 @@
of dealing with mismatches between system declarations and
those in this file.
-MALLINFO_FIELD_TYPE default: size_t
+MALLINFO_FIELD_TYPE default: usize
The type of the fields in the mallinfo struct. This was originally
defined as "int" in SVID etc, but is more usefully defined as
- size_t. The value is used only if HAVE_USR_INCLUDE_MALLOC_H is not set
+ usize. The value is used only if HAVE_USR_INCLUDE_MALLOC_H is not set
NO_MALLOC_STATS default: 0
If defined, don't compile "malloc_stats". This avoids calls to
@@ -586,17 +586,17 @@
#define HAVE_MMAP 1
/* OSX allocators provide 16 byte alignment */
#ifndef MALLOC_ALIGNMENT
-#define MALLOC_ALIGNMENT ((size_t)16U)
+#define MALLOC_ALIGNMENT ((usize)16U)
#endif
#endif /* HAVE_MORECORE */
#endif /* DARWIN */
#ifndef LACKS_SYS_TYPES_H
-#include <sys/types.h> /* For size_t */
+#include <sys/types.h> /* For usize */
#endif /* LACKS_SYS_TYPES_H */
-/* The maximum possible size_t value has all bits set */
-#define MAX_SIZE_T (~(size_t)0)
+/* The maximum possible usize value has all bits set */
+#define MAX_SIZE_T (~(usize)0)
#ifndef USE_LOCKS /* ensure true if spin or recursive locks set */
#define USE_LOCKS ((defined(USE_SPIN_LOCKS) && USE_SPIN_LOCKS != 0) || \
@@ -629,7 +629,7 @@
#endif /* ONLY_MSPACES */
#endif /* MSPACES */
#ifndef MALLOC_ALIGNMENT
-#define MALLOC_ALIGNMENT ((size_t)(2 * sizeof(void *)))
+#define MALLOC_ALIGNMENT ((usize)(2 * sizeof(void *)))
#endif /* MALLOC_ALIGNMENT */
#ifndef FOOTERS
#define FOOTERS 0
@@ -686,12 +686,12 @@
#if (MORECORE_CONTIGUOUS || defined(WIN32))
#define DEFAULT_GRANULARITY (0) /* 0 means to compute in init_mparams */
#else /* MORECORE_CONTIGUOUS */
-#define DEFAULT_GRANULARITY ((size_t)64U * (size_t)1024U)
+#define DEFAULT_GRANULARITY ((usize)64U * (usize)1024U)
#endif /* MORECORE_CONTIGUOUS */
#endif /* DEFAULT_GRANULARITY */
#ifndef DEFAULT_TRIM_THRESHOLD
#ifndef MORECORE_CANNOT_TRIM
-#define DEFAULT_TRIM_THRESHOLD ((size_t)2U * (size_t)1024U * (size_t)1024U)
+#define DEFAULT_TRIM_THRESHOLD ((usize)2U * (usize)1024U * (usize)1024U)
#else /* MORECORE_CANNOT_TRIM */
#define DEFAULT_TRIM_THRESHOLD MAX_SIZE_T
#endif /* MORECORE_CANNOT_TRIM */
@@ -698,7 +698,7 @@
#endif /* DEFAULT_TRIM_THRESHOLD */
#ifndef DEFAULT_MMAP_THRESHOLD
#if HAVE_MMAP
-#define DEFAULT_MMAP_THRESHOLD ((size_t)256U * (size_t)1024U)
+#define DEFAULT_MMAP_THRESHOLD ((usize)256U * (usize)1024U)
#else /* HAVE_MMAP */
#define DEFAULT_MMAP_THRESHOLD MAX_SIZE_T
#endif /* HAVE_MMAP */
@@ -720,7 +720,7 @@
#define NO_MALLINFO 0
#endif /* NO_MALLINFO */
#ifndef MALLINFO_FIELD_TYPE
-#define MALLINFO_FIELD_TYPE size_t
+#define MALLINFO_FIELD_TYPE usize
#endif /* MALLINFO_FIELD_TYPE */
#ifndef NO_MALLOC_STATS
#define NO_MALLOC_STATS 0
@@ -852,7 +852,7 @@
#endif /* USE_DL_PREFIX */
/*
- malloc(size_t n)
+ malloc(usize n)
Returns a pointer to a newly allocated chunk of at least n bytes, or
null if no space is available, in which case errno is set to ENOMEM
on ANSI C systems.
@@ -859,13 +859,13 @@
If n is zero, malloc returns a minimum-sized chunk. (The minimum
size is 16 bytes on most 32bit systems, and 32 bytes on 64bit
- systems.) Note that size_t is an unsigned type, so calls with
+ systems.) Note that usize is an unsigned type, so calls with
arguments that would be negative if signed are interpreted as
requests for huge amounts of space, which will often fail. The
maximum supported value of n differs across systems, but is in all
- cases less than the maximum representable value of a size_t.
+ cases less than the maximum representable value of a usize.
*/
-DLMALLOC_EXPORT void* dlmalloc(size_t);
+DLMALLOC_EXPORT void* dlmalloc(usize);
/*
free(void* p)
@@ -877,14 +877,14 @@
DLMALLOC_EXPORT void dlfree(void*);
/*
- calloc(size_t n_elements, size_t element_size);
+ calloc(usize n_elements, usize element_size);
Returns a pointer to n_elements * element_size bytes, with all locations
set to zero.
*/
-DLMALLOC_EXPORT void* dlcalloc(size_t, size_t);
+DLMALLOC_EXPORT void* dlcalloc(usize, usize);
/*
- realloc(void* p, size_t n)
+ realloc(void* p, usize n)
Returns a pointer to a chunk of size n that contains the same data
as does chunk p up to the minimum of (n, p's size) bytes, or null
if no space is available.
@@ -905,10 +905,10 @@
The old unix realloc convention of allowing the last-free'd chunk
to be used as an argument to realloc is not supported.
*/
-DLMALLOC_EXPORT void* dlrealloc(void*, size_t);
+DLMALLOC_EXPORT void* dlrealloc(void*, usize);
/*
- realloc_in_place(void* p, size_t n)
+ realloc_in_place(void* p, usize n)
Resizes the space allocated for p to size n, only if this can be
done without moving p (i.e., only if there is adjacent space
available if n is greater than p's current allocated size, or n is
@@ -920,10 +920,10 @@
Returns p if successful; otherwise null.
*/
-DLMALLOC_EXPORT void* dlrealloc_in_place(void*, size_t);
+DLMALLOC_EXPORT void* dlrealloc_in_place(void*, usize);
/*
- memalign(size_t alignment, size_t n);
+ memalign(usize alignment, usize n);
Returns a pointer to a newly allocated chunk of n bytes, aligned
in accord with the alignment argument.
@@ -934,10 +934,10 @@
Overreliance on memalign is a sure way to fragment space.
*/
-DLMALLOC_EXPORT void* dlmemalign(size_t, size_t);
+DLMALLOC_EXPORT void* dlmemalign(usize, usize);
/*
- int posix_memalign(void** pp, size_t alignment, size_t n);
+ int posix_memalign(void** pp, usize alignment, usize n);
Allocates a chunk of n bytes, aligned in accord with the alignment
argument. Differs from memalign only in that it (1) assigns the
allocated memory to *pp rather than returning it, (2) fails and
@@ -944,14 +944,14 @@
returns EINVAL if the alignment is not a power of two (3) fails and
returns ENOMEM if memory cannot be allocated.
*/
-DLMALLOC_EXPORT int dlposix_memalign(void**, size_t, size_t);
+DLMALLOC_EXPORT int dlposix_memalign(void**, usize, usize);
/*
- valloc(size_t n);
+ valloc(usize n);
Equivalent to memalign(pagesize, n), where pagesize is the page
size of the system. If the pagesize is unknown, 4096 is used.
*/
-DLMALLOC_EXPORT void* dlvalloc(size_t);
+DLMALLOC_EXPORT void* dlvalloc(usize);
/*
mallopt(int parameter_number, int parameter_value)
@@ -960,8 +960,8 @@
corresponding parameter to the argument value if it can (i.e., so
long as the value is meaningful), and returns 1 if successful else
0. To workaround the fact that mallopt is specified to use int,
- not size_t parameters, the value -1 is specially treated as the
- maximum unsigned size_t value.
+ not usize parameters, the value -1 is specially treated as the
+ maximum unsigned usize value.
SVID/XPG/ANSI defines four standard param numbers for mallopt,
normally defined in malloc.h. None of these are use in this malloc,
@@ -986,7 +986,7 @@
Even if locks are otherwise defined, this function does not use them,
so results might not be up to date.
*/
-DLMALLOC_EXPORT size_t dlmalloc_footprint(void);
+DLMALLOC_EXPORT usize dlmalloc_footprint(void);
/*
malloc_max_footprint();
@@ -999,18 +999,18 @@
otherwise defined, this function does not use them, so results might
not be up to date.
*/
-DLMALLOC_EXPORT size_t dlmalloc_max_footprint(void);
+DLMALLOC_EXPORT usize dlmalloc_max_footprint(void);
/*
malloc_footprint_limit();
Returns the number of bytes that the heap is allowed to obtain from
the system, returning the last value returned by
- malloc_set_footprint_limit, or the maximum size_t value if
+ malloc_set_footprint_limit, or the maximum usize value if
never set. The returned value reflects a permission. There is no
guarantee that this number of bytes can actually be obtained from
the system.
*/
-DLMALLOC_EXPORT size_t dlmalloc_footprint_limit(void);
+DLMALLOC_EXPORT usize dlmalloc_footprint_limit(void);
/*
malloc_set_footprint_limit();
@@ -1018,19 +1018,19 @@
failure returns from malloc and related functions upon attempts to
exceed this value. The argument value may be subject to page
rounding to an enforceable limit; this actual value is returned.
- Using an argument of the maximum possible size_t effectively
+ Using an argument of the maximum possible usize effectively
disables checks. If the argument is less than or equal to the
current malloc_footprint, then all future allocations that require
additional system memory will fail. However, invocation cannot
retroactively deallocate existing used memory.
*/
-DLMALLOC_EXPORT size_t dlmalloc_set_footprint_limit(size_t bytes);
+DLMALLOC_EXPORT usize dlmalloc_set_footprint_limit(usize bytes);
#if MALLOC_INSPECT_ALL
/*
malloc_inspect_all(void(*handler)(void *start,
void *end,
- size_t used_bytes,
+ usize used_bytes,
void* callback_arg),
void* arg);
Traverses the heap and calls the given handler for each managed
@@ -1047,7 +1047,7 @@
For example, to count the number of in-use chunks with size greater
than 1000, you could write:
static int count = 0;
- void count_chunks(void* start, void* end, size_t used, void* arg) {+ void count_chunks(void* start, void* end, usize used, void* arg) {if (used >= 1000) ++count;
}
then:
@@ -1055,7 +1055,7 @@
malloc_inspect_all is compiled only if MALLOC_INSPECT_ALL is defined.
*/
-DLMALLOC_EXPORT void dlmalloc_inspect_all(void(*handler)(void*, void *, size_t, void*),
+DLMALLOC_EXPORT void dlmalloc_inspect_all(void(*handler)(void*, void *, usize, void*),
void* arg);
#endif /* MALLOC_INSPECT_ALL */
@@ -1087,7 +1087,7 @@
#endif /* NO_MALLINFO */
/*
- independent_calloc(size_t n_elements, size_t element_size, void* chunks[]);
+ independent_calloc(usize n_elements, usize element_size, void* chunks[]);
independent_calloc is similar to calloc, but instead of returning a
single cleared space, it returns an array of pointers to n_elements
@@ -1135,10 +1135,10 @@
return first;
}
*/
-DLMALLOC_EXPORT void** dlindependent_calloc(size_t, size_t, void**);
+DLMALLOC_EXPORT void** dlindependent_calloc(usize, usize, void**);
/*
- independent_comalloc(size_t n_elements, size_t sizes[], void* chunks[]);
+ independent_comalloc(usize n_elements, usize sizes[], void* chunks[]);
independent_comalloc allocates, all at once, a set of n_elements
chunks with sizes indicated in the "sizes" array. It returns
@@ -1175,7 +1175,7 @@
void send_message(char* msg) {int msglen = strlen(msg);
- size_t sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };+ usize sizes[3] = { sizeof(struct Head), msglen, sizeof(struct Foot) };void* chunks[3];
if (independent_comalloc(3, sizes, chunks) == 0)
die();
@@ -1193,10 +1193,10 @@
since it cannot reuse existing noncontiguous small chunks that
might be available for some of the elements.
*/
-DLMALLOC_EXPORT void** dlindependent_comalloc(size_t, size_t*, void**);
+DLMALLOC_EXPORT void** dlindependent_comalloc(usize, usize*, void**);
/*
- bulk_free(void* array[], size_t n_elements)
+ bulk_free(void* array[], usize n_elements)
Frees and clears (sets to null) each non-null pointer in the given
array. This is likely to be faster than freeing them one-by-one.
If footers are used, pointers that have been allocated in different
@@ -1204,17 +1204,17 @@
is returned. For large arrays of pointers with poor locality, it
may be worthwhile to sort this array before calling bulk_free.
*/
-DLMALLOC_EXPORT size_t dlbulk_free(void**, size_t n_elements);
+DLMALLOC_EXPORT usize dlbulk_free(void**, usize n_elements);
/*
- pvalloc(size_t n);
+ pvalloc(usize n);
Equivalent to valloc(minimum-page-that-holds(n)), that is,
round up n to nearest pagesize.
*/
-DLMALLOC_EXPORT void* dlpvalloc(size_t);
+DLMALLOC_EXPORT void* dlpvalloc(usize);
/*
- malloc_trim(size_t pad);
+ malloc_trim(usize pad);
If possible, gives memory back to the system (via negative arguments
to sbrk) if there is unused memory at the `high' end of the malloc
@@ -1234,7 +1234,7 @@
Malloc_trim returns 1 if it actually released any memory, else 0.
*/
-DLMALLOC_EXPORT int dlmalloc_trim(size_t);
+DLMALLOC_EXPORT int dlmalloc_trim(usize);
/*
malloc_stats();
@@ -1271,7 +1271,7 @@
p = malloc(n);
assert(malloc_usable_size(p) >= 256);
*/
-size_t dlmalloc_usable_size(void*);
+usize dlmalloc_usable_size(void*);
#endif /* ONLY_MSPACES */
@@ -1294,7 +1294,7 @@
compiling with a different DEFAULT_GRANULARITY or dynamically
setting with mallopt(M_GRANULARITY, value).
*/
-DLMALLOC_EXPORT mspace create_mspace(size_t capacity, int locked);
+DLMALLOC_EXPORT mspace create_mspace(usize capacity, int locked);
/*
destroy_mspace destroys the given space, and attempts to return all
@@ -1302,11 +1302,11 @@
bytes freed. After destruction, the results of access to all memory
used by the space become undefined.
*/
-DLMALLOC_EXPORT size_t destroy_mspace(mspace msp);
+DLMALLOC_EXPORT usize destroy_mspace(mspace msp);
/*
create_mspace_with_base uses the memory supplied as the initial base
- of a new mspace. Part (less than 128*sizeof(size_t) bytes) of this
+ of a new mspace. Part (less than 128*sizeof(usize) bytes) of this
space is used for bookkeeping, so the capacity must be at least this
large. (Otherwise 0 is returned.) When this initial space is
exhausted, additional memory will be obtained from the system.
@@ -1313,7 +1313,7 @@
Destroying this space will deallocate all additionally allocated
space (if possible) but not the initial base.
*/
-DLMALLOC_EXPORT mspace create_mspace_with_base(void* base, size_t capacity, int locked);
+DLMALLOC_EXPORT mspace create_mspace_with_base(void* base, usize capacity, int locked);
/*
mspace_track_large_chunks controls whether requests for large chunks
@@ -1333,7 +1333,7 @@
mspace_malloc behaves as malloc, but operates within
the given space.
*/
-DLMALLOC_EXPORT void* mspace_malloc(mspace msp, size_t bytes);
+DLMALLOC_EXPORT void* mspace_malloc(mspace msp, usize bytes);
/*
mspace_free behaves as free, but operates within
@@ -1354,45 +1354,45 @@
realloced chunks from any space are handled by their originating
spaces.
*/
-DLMALLOC_EXPORT void* mspace_realloc(mspace msp, void* mem, size_t newsize);
+DLMALLOC_EXPORT void* mspace_realloc(mspace msp, void* mem, usize newsize);
/*
mspace_calloc behaves as calloc, but operates within
the given space.
*/
-DLMALLOC_EXPORT void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size);
+DLMALLOC_EXPORT void* mspace_calloc(mspace msp, usize n_elements, usize elem_size);
/*
mspace_memalign behaves as memalign, but operates within
the given space.
*/
-DLMALLOC_EXPORT void* mspace_memalign(mspace msp, size_t alignment, size_t bytes);
+DLMALLOC_EXPORT void* mspace_memalign(mspace msp, usize alignment, usize bytes);
/*
mspace_independent_calloc behaves as independent_calloc, but
operates within the given space.
*/
-DLMALLOC_EXPORT void** mspace_independent_calloc(mspace msp, size_t n_elements,
- size_t elem_size, void* chunks[]);
+DLMALLOC_EXPORT void** mspace_independent_calloc(mspace msp, usize n_elements,
+ usize elem_size, void* chunks[]);
/*
mspace_independent_comalloc behaves as independent_comalloc, but
operates within the given space.
*/
-DLMALLOC_EXPORT void** mspace_independent_comalloc(mspace msp, size_t n_elements,
- size_t sizes[], void* chunks[]);
+DLMALLOC_EXPORT void** mspace_independent_comalloc(mspace msp, usize n_elements,
+ usize sizes[], void* chunks[]);
/*
mspace_footprint() returns the number of bytes obtained from the
system for this space.
*/
-DLMALLOC_EXPORT size_t mspace_footprint(mspace msp);
+DLMALLOC_EXPORT usize mspace_footprint(mspace msp);
/*
mspace_max_footprint() returns the peak number of bytes obtained from the
system for this space.
*/
-DLMALLOC_EXPORT size_t mspace_max_footprint(mspace msp);
+DLMALLOC_EXPORT usize mspace_max_footprint(mspace msp);
#if !NO_MALLINFO
@@ -1406,7 +1406,7 @@
/*
malloc_usable_size(void* p) behaves the same as malloc_usable_size;
*/
-DLMALLOC_EXPORT size_t mspace_usable_size(const void* mem);
+DLMALLOC_EXPORT usize mspace_usable_size(const void* mem);
/*
mspace_malloc_stats behaves as malloc_stats, but reports
@@ -1418,7 +1418,7 @@
mspace_trim behaves as malloc_trim, but
operates within the given space.
*/
-DLMALLOC_EXPORT int mspace_trim(mspace msp, size_t pad);
+DLMALLOC_EXPORT int mspace_trim(mspace msp, usize pad);
/*
An alias for mallopt.
@@ -1570,7 +1570,7 @@
# define malloc_getpagesize sysconf(_SC_PAGE_SIZE)
# else
# if defined(BSD) || defined(DGUX) || defined(HAVE_GETPAGESIZE)
- extern size_t getpagesize();
+ extern usize getpagesize();
# define malloc_getpagesize getpagesize()
# else
# ifdef WIN32 /* use supplied emulation of getpagesize */
@@ -1595,7 +1595,7 @@
# ifdef PAGESIZE
# define malloc_getpagesize PAGESIZE
# else /* just guess */
-# define malloc_getpagesize ((size_t)4096U)
+# define malloc_getpagesize ((usize)4096U)
# endif
# endif
# endif
@@ -1606,18 +1606,18 @@
#endif
#endif
-/* ------------------- size_t and alignment properties -------------------- */
+/* ------------------- usize and alignment properties -------------------- */
-/* The byte and bit size of a size_t */
-#define SIZE_T_SIZE (sizeof(size_t))
-#define SIZE_T_BITSIZE (sizeof(size_t) << 3)
+/* The byte and bit size of a usize */
+#define SIZE_T_SIZE (sizeof(usize))
+#define SIZE_T_BITSIZE (sizeof(usize) << 3)
-/* Some constants coerced to size_t */
+/* Some constants coerced to usize */
/* Annoying but necessary to avoid errors on some platforms */
-#define SIZE_T_ZERO ((size_t)0)
-#define SIZE_T_ONE ((size_t)1)
-#define SIZE_T_TWO ((size_t)2)
-#define SIZE_T_FOUR ((size_t)4)
+#define SIZE_T_ZERO ((usize)0)
+#define SIZE_T_ONE ((usize)1)
+#define SIZE_T_TWO ((usize)2)
+#define SIZE_T_FOUR ((usize)4)
#define TWO_SIZE_T_SIZES (SIZE_T_SIZE<<1)
#define FOUR_SIZE_T_SIZES (SIZE_T_SIZE<<2)
#define SIX_SIZE_T_SIZES (FOUR_SIZE_T_SIZES+TWO_SIZE_T_SIZES)
@@ -1627,12 +1627,12 @@
#define CHUNK_ALIGN_MASK (MALLOC_ALIGNMENT - SIZE_T_ONE)
/* True if address a has acceptable alignment */
-#define is_aligned(A) (((size_t)((A)) & (CHUNK_ALIGN_MASK)) == 0)
+#define is_aligned(A) (((usize)((A)) & (CHUNK_ALIGN_MASK)) == 0)
/* the number of bytes to offset an address to align it */
#define align_offset(A)\
- ((((size_t)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\
- ((MALLOC_ALIGNMENT - ((size_t)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))
+ ((((usize)(A) & CHUNK_ALIGN_MASK) == 0)? 0 :\
+ ((MALLOC_ALIGNMENT - ((usize)(A) & CHUNK_ALIGN_MASK)) & CHUNK_ALIGN_MASK))
/* -------------------------- MMAP preliminaries ------------------------- */
@@ -1676,13 +1676,13 @@
#else /* WIN32 */
/* Win32 MMAP via VirtualAlloc */
-static FORCEINLINE void* win32mmap(size_t size) {+static FORCEINLINE void* win32mmap(usize size) {void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
return (ptr != 0)? ptr: MFAIL;
}
/* For direct MMAP, use MEM_TOP_DOWN to minimize interference */
-static FORCEINLINE void* win32direct_mmap(size_t size) {+static FORCEINLINE void* win32direct_mmap(usize size) {void* ptr = VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT|MEM_TOP_DOWN,
PAGE_READWRITE);
return (ptr != 0)? ptr: MFAIL;
@@ -1689,7 +1689,7 @@
}
/* This function supports releasing coalesed segments */
-static FORCEINLINE int win32munmap(void* ptr, size_t size) {+static FORCEINLINE int win32munmap(void* ptr, usize size) {MEMORY_BASIC_INFORMATION minfo;
char* cptr = (char*)ptr;
while (size) {@@ -2091,7 +2091,7 @@
| |
+- -+
| :
- +- size - sizeof(size_t) available payload bytes -+
+ +- size - sizeof(usize) available payload bytes -+
: |
chunk-> +- -+
| |
@@ -2194,8 +2194,8 @@
*/
struct malloc_chunk {- size_t prev_foot; /* Size of previous chunk (if free). */
- size_t head; /* Size and inuse bits. */
+ usize prev_foot; /* Size of previous chunk (if free). */
+ usize head; /* Size and inuse bits. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
};
@@ -2404,8 +2404,8 @@
struct malloc_tree_chunk {/* The first four fields must be compatible with malloc_chunk */
- size_t prev_foot;
- size_t head;
+ usize prev_foot;
+ usize head;
struct malloc_tree_chunk* fd;
struct malloc_tree_chunk* bk;
@@ -2480,7 +2480,7 @@
struct malloc_segment {char* base; /* base address */
- size_t size; /* allocated size */
+ usize size; /* allocated size */
struct malloc_segment* next; /* ptr to next segment */
flag_t sflags; /* mmap and extern flag */
};
@@ -2574,7 +2574,7 @@
around every public call using this mspace.
Extension support
- A void* pointer and a size_t field that can be used to help implement
+ A void* pointer and a usize field that can be used to help implement
extensions to this malloc.
*/
@@ -2591,19 +2591,19 @@
struct malloc_state {binmap_t smallmap;
binmap_t treemap;
- size_t dvsize;
- size_t topsize;
+ usize dvsize;
+ usize topsize;
char* least_addr;
mchunkptr dv;
mchunkptr top;
- size_t trim_check;
- size_t release_checks;
- size_t magic;
+ usize trim_check;
+ usize release_checks;
+ usize magic;
mchunkptr smallbins[(NSMALLBINS+1)*2];
tbinptr treebins[NTREEBINS];
- size_t footprint;
- size_t max_footprint;
- size_t footprint_limit; /* zero means no limit */
+ usize footprint;
+ usize max_footprint;
+ usize footprint_limit; /* zero means no limit */
flag_t mflags;
#if USE_LOCKS
MLOCK_T mutex; /* locate lock among fields that rarely change */
@@ -2610,7 +2610,7 @@
#endif /* USE_LOCKS */
msegment seg;
void* extp; /* Unused but available for extensions */
- size_t exts;
+ usize exts;
};
typedef struct malloc_state* mstate;
@@ -2625,11 +2625,11 @@
*/
struct malloc_params {- size_t magic;
- size_t page_size;
- size_t granularity;
- size_t mmap_threshold;
- size_t trim_threshold;
+ usize magic;
+ usize page_size;
+ usize granularity;
+ usize mmap_threshold;
+ usize trim_threshold;
flag_t default_mflags;
};
@@ -2698,9 +2698,9 @@
#define SYS_ALLOC_PADDING (TOP_FOOT_SIZE + MALLOC_ALIGNMENT)
#define is_page_aligned(S)\
- (((size_t)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)
+ (((usize)(S) & (mparams.page_size - SIZE_T_ONE)) == 0)
#define is_granularity_aligned(S)\
- (((size_t)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)
+ (((usize)(S) & (mparams.granularity - SIZE_T_ONE)) == 0)
/* True if segment S holds address A */
#define segment_holds(S, A)\
@@ -2824,13 +2824,13 @@
static void do_check_mmapped_chunk(mstate m, mchunkptr p);
static void do_check_inuse_chunk(mstate m, mchunkptr p);
static void do_check_free_chunk(mstate m, mchunkptr p);
-static void do_check_malloced_chunk(mstate m, void* mem, size_t s);
+static void do_check_malloced_chunk(mstate m, void* mem, usize s);
static void do_check_tree(mstate m, tchunkptr t);
static void do_check_treebin(mstate m, bindex_t i);
static void do_check_smallbin(mstate m, bindex_t i);
static void do_check_malloc_state(mstate m);
static int bin_find(mstate m, mchunkptr x);
-static size_t traverse_and_check(mstate m);
+static usize traverse_and_check(mstate m);
#endif /* DEBUG */
/* ---------------------------- Indexing Bins ---------------------------- */
@@ -2862,7 +2862,7 @@
#elif defined (__INTEL_COMPILER)
#define compute_tree_index(S, I)\
{\- size_t X = S >> TREEBIN_SHIFT;\
+ usize X = S >> TREEBIN_SHIFT;\
if (X == 0)\
I = 0;\
else if (X > 0xFFFF)\
@@ -2876,7 +2876,7 @@
#elif defined(_MSC_VER) && _MSC_VER>=1300
#define compute_tree_index(S, I)\
{\- size_t X = S >> TREEBIN_SHIFT;\
+ usize X = S >> TREEBIN_SHIFT;\
if (X == 0)\
I = 0;\
else if (X > 0xFFFF)\
@@ -2891,7 +2891,7 @@
#else /* GNUC */
#define compute_tree_index(S, I)\
{\- size_t X = S >> TREEBIN_SHIFT;\
+ usize X = S >> TREEBIN_SHIFT;\
if (X == 0)\
I = 0;\
else if (X > 0xFFFF)\
@@ -2920,7 +2920,7 @@
/* The size of the smallest chunk held in bin with index i */
#define minsize_for_tree_index(i) \
((SIZE_T_ONE << (((i) >> 1) + TREEBIN_SHIFT)) | \
- (((size_t)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1)))
+ (((usize)((i) & SIZE_T_ONE)) << (((i) >> 1) + TREEBIN_SHIFT - 1)))
/* ------------------------ Operations on bin maps ----------------------- */
@@ -3079,7 +3079,7 @@
/* Set foot of inuse chunk to be xor of mstate and seed */
#define mark_inuse_foot(M,p,s)\
- (((mchunkptr)((char*)(p) + (s)))->prev_foot = ((size_t)(M) ^ mparams.magic))
+ (((mchunkptr)((char*)(p) + (s)))->prev_foot = ((usize)(M) ^ mparams.magic))
#define get_mstate_for(p)\
((mstate)(((mchunkptr)((char*)(p) +\
@@ -3118,9 +3118,9 @@
ACQUIRE_MALLOC_GLOBAL_LOCK();
if (mparams.magic == 0) {- size_t magic;
- size_t psize;
- size_t gsize;
+ usize magic;
+ usize psize;
+ usize gsize;
#ifndef WIN32
psize = malloc_getpagesize;
@@ -3136,15 +3136,15 @@
#endif /* WIN32 */
/* Sanity-check configuration:
- size_t must be unsigned and as wide as pointer type.
+ usize must be unsigned and as wide as pointer type.
ints must be at least 4 bytes.
alignment must be at least 8.
Alignment, min chunk size, and page size must all be powers of 2.
*/
- if ((sizeof(size_t) != sizeof(char*)) ||
+ if ((sizeof(usize) != sizeof(char*)) ||
(MAX_SIZE_T < MIN_CHUNK_SIZE) ||
(sizeof(int) < 4) ||
- (MALLOC_ALIGNMENT < (size_t)8U) ||
+ (MALLOC_ALIGNMENT < (usize)8U) ||
((MALLOC_ALIGNMENT & (MALLOC_ALIGNMENT-SIZE_T_ONE)) != 0) ||
((MCHUNK_SIZE & (MCHUNK_SIZE-SIZE_T_ONE)) != 0) ||
((gsize & (gsize-SIZE_T_ONE)) != 0) ||
@@ -3172,26 +3172,26 @@
{#if USE_DEV_RANDOM
int fd;
- unsigned char buf[sizeof(size_t)];
+ unsigned char buf[sizeof(usize)];
/* Try to use /dev/urandom, else fall back on using time */
if ((fd = open("/dev/urandom", O_RDONLY)) >= 0 && read(fd, buf, sizeof(buf)) == sizeof(buf)) {- magic = *((size_t *) buf);
+ magic = *((usize *) buf);
close(fd);
}
else
#endif /* USE_DEV_RANDOM */
#ifdef WIN32
- magic = (size_t)(GetTickCount() ^ (size_t)0x55555555U);
+ magic = (usize)(GetTickCount() ^ (usize)0x55555555U);
#elif defined(LACKS_TIME_H)
- magic = (size_t)&magic ^ (size_t)0x55555555U;
+ magic = (usize)&magic ^ (usize)0x55555555U;
#else
- magic = (size_t)(time(0) ^ (size_t)0x55555555U);
+ magic = (usize)(time(0) ^ (usize)0x55555555U);
#endif
- magic |= (size_t)8U; /* ensure nonzero */
- magic &= ~(size_t)7U; /* improve chances of fault for bad values */
+ magic |= (usize)8U; /* ensure nonzero */
+ magic &= ~(usize)7U; /* improve chances of fault for bad values */
/* Until memory modes commonly available, use volatile-write */
- (*(volatile size_t *)(&(mparams.magic))) = magic;
+ (*(volatile usize *)(&(mparams.magic))) = magic;
}
}
@@ -3201,9 +3201,9 @@
/* support for mallopt */
static int change_mparam(int param_number, int value) {- size_t val;
+ usize val;
ensure_initialization();
- val = (value == -1)? MAX_SIZE_T : (size_t)value;
+ val = (value == -1)? MAX_SIZE_T : (usize)value;
switch(param_number) {case M_TRIM_THRESHOLD:
mparams.trim_threshold = val;
@@ -3235,7 +3235,7 @@
/* Check properties of top chunk */
static void do_check_top_chunk(mstate m, mchunkptr p) {msegmentptr sp = segment_holding(m, (char*)p);
- size_t sz = p->head & ~INUSE_BITS; /* third-lowest bit can be set! */
+ usize sz = p->head & ~INUSE_BITS; /* third-lowest bit can be set! */
assert(sp != 0);
assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
assert(ok_address(m, p));
@@ -3248,8 +3248,8 @@
/* Check properties of (inuse) mmapped chunks */
static void do_check_mmapped_chunk(mstate m, mchunkptr p) {- size_t sz = chunksize(p);
- size_t len = (sz + (p->prev_foot) + MMAP_FOOT_PAD);
+ usize sz = chunksize(p);
+ usize len = (sz + (p->prev_foot) + MMAP_FOOT_PAD);
assert(is_mmapped(p));
assert(use_mmap(m));
assert((is_aligned(chunk2mem(p))) || (p->head == FENCEPOST_HEAD));
@@ -3273,7 +3273,7 @@
/* Check properties of free chunks */
static void do_check_free_chunk(mstate m, mchunkptr p) {- size_t sz = chunksize(p);
+ usize sz = chunksize(p);
mchunkptr next = chunk_plus_offset(p, sz);
do_check_any_chunk(m, p);
assert(!is_inuse(p));
@@ -3295,10 +3295,10 @@
}
/* Check properties of malloced chunks at the point they are malloced */
-static void do_check_malloced_chunk(mstate m, void* mem, size_t s) {+static void do_check_malloced_chunk(mstate m, void* mem, usize s) { if (mem != 0) {mchunkptr p = mem2chunk(mem);
- size_t sz = p->head & ~INUSE_BITS;
+ usize sz = p->head & ~INUSE_BITS;
do_check_inuse_chunk(m, p);
assert((sz & CHUNK_ALIGN_MASK) == 0);
assert(sz >= MIN_CHUNK_SIZE);
@@ -3313,7 +3313,7 @@
tchunkptr head = 0;
tchunkptr u = t;
bindex_t tindex = t->index;
- size_t tsize = chunksize(t);
+ usize tsize = chunksize(t);
bindex_t idx;
compute_tree_index(tsize, idx);
assert(tindex == idx);
@@ -3379,7 +3379,7 @@
assert(empty);
if (!empty) { for (; p != b; p = p->bk) {- size_t size = chunksize(p);
+ usize size = chunksize(p);
mchunkptr q;
/* each chunk claims to be free */
do_check_free_chunk(m, p);
@@ -3396,7 +3396,7 @@
/* Find x in a bin. Used in other check functions. */
static int bin_find(mstate m, mchunkptr x) {- size_t size = chunksize(x);
+ usize size = chunksize(x);
if (is_small(size)) {bindex_t sidx = small_index(size);
sbinptr b = smallbin_at(m, sidx);
@@ -3413,7 +3413,7 @@
compute_tree_index(size, tidx);
if (treemap_is_marked(m, tidx)) {tchunkptr t = *treebin_at(m, tidx);
- size_t sizebits = size << leftshift_for_tree_index(tidx);
+ usize sizebits = size << leftshift_for_tree_index(tidx);
while (t != 0 && chunksize(t) != size) {t = t->child[(sizebits >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1];
sizebits <<= 1;
@@ -3431,8 +3431,8 @@
}
/* Traverse each chunk and check it; return total */
-static size_t traverse_and_check(mstate m) {- size_t sum = 0;
+static usize traverse_and_check(mstate m) {+ usize sum = 0;
if (is_initialized(m)) {msegmentptr s = &m->seg;
sum += m->topsize + TOP_FOOT_SIZE;
@@ -3465,7 +3465,7 @@
/* Check all properties of malloc_state. */
static void do_check_malloc_state(mstate m) {bindex_t i;
- size_t total;
+ usize total;
/* check bins */
for (i = 0; i < NSMALLBINS; ++i)
do_check_smallbin(m, i);
@@ -3501,15 +3501,15 @@
if (!PREACTION(m)) {check_malloc_state(m);
if (is_initialized(m)) {- size_t nfree = SIZE_T_ONE; /* top always free */
- size_t mfree = m->topsize + TOP_FOOT_SIZE;
- size_t sum = mfree;
+ usize nfree = SIZE_T_ONE; /* top always free */
+ usize mfree = m->topsize + TOP_FOOT_SIZE;
+ usize sum = mfree;
msegmentptr s = &m->seg;
while (s != 0) {mchunkptr q = align_as_chunk(s->base);
while (segment_holds(s, q) &&
q != m->top && q->head != FENCEPOST_HEAD) {- size_t sz = chunksize(q);
+ usize sz = chunksize(q);
sum += sz;
if (!is_inuse(q)) {mfree += sz;
@@ -3539,9 +3539,9 @@
static void internal_malloc_stats(mstate m) {ensure_initialization();
if (!PREACTION(m)) {- size_t maxfp = 0;
- size_t fp = 0;
- size_t used = 0;
+ usize maxfp = 0;
+ usize fp = 0;
+ usize used = 0;
check_malloc_state(m);
if (is_initialized(m)) {msegmentptr s = &m->seg;
@@ -3643,7 +3643,7 @@
/* Replace dv node, binning the old one */
/* Used only when dvsize known to be small */
#define replace_dv(M, P, S) {\- size_t DVS = M->dvsize;\
+ usize DVS = M->dvsize;\
assert(is_small(DVS));\
if (DVS != 0) {\mchunkptr DV = M->dv;\
@@ -3671,7 +3671,7 @@
}\
else {\tchunkptr T = *H;\
- size_t K = S << leftshift_for_tree_index(I);\
+ usize K = S << leftshift_for_tree_index(I);\
for (;;) {\ if (chunksize(T) != S) {\tchunkptr* C = &(T->child[(K >> (SIZE_T_BITSIZE-SIZE_T_ONE)) & 1]);\
@@ -3834,10 +3834,10 @@
*/
/* Malloc using mmap */
-static void* mmap_alloc(mstate m, size_t nb) {- size_t mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+static void* mmap_alloc(mstate m, usize nb) {+ usize mmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
if (m->footprint_limit != 0) {- size_t fp = m->footprint + mmsize;
+ usize fp = m->footprint + mmsize;
if (fp <= m->footprint || fp > m->footprint_limit)
return 0;
}
@@ -3844,8 +3844,8 @@
if (mmsize > nb) { /* Check for wrap around 0 */char* mm = (char*)(CALL_DIRECT_MMAP(mmsize));
if (mm != CMFAIL) {- size_t offset = align_offset(chunk2mem(mm));
- size_t psize = mmsize - offset - MMAP_FOOT_PAD;
+ usize offset = align_offset(chunk2mem(mm));
+ usize psize = mmsize - offset - MMAP_FOOT_PAD;
mchunkptr p = (mchunkptr)(mm + offset);
p->prev_foot = offset;
p->head = psize;
@@ -3866,8 +3866,8 @@
}
/* Realloc using mmap */
-static mchunkptr mmap_resize(mstate m, mchunkptr oldp, size_t nb, int flags) {- size_t oldsize = chunksize(oldp);
+static mchunkptr mmap_resize(mstate m, mchunkptr oldp, usize nb, int flags) {+ usize oldsize = chunksize(oldp);
(void)flags; /* placate people compiling -Wunused */
if (is_small(nb)) /* Can't shrink mmap regions below small size */
return 0;
@@ -3876,14 +3876,14 @@
(oldsize - nb) <= (mparams.granularity << 1))
return oldp;
else {- size_t offset = oldp->prev_foot;
- size_t oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
- size_t newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
+ usize offset = oldp->prev_foot;
+ usize oldmmsize = oldsize + offset + MMAP_FOOT_PAD;
+ usize newmmsize = mmap_align(nb + SIX_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
char* cp = (char*)CALL_MREMAP((char*)oldp - offset,
oldmmsize, newmmsize, flags);
if (cp != CMFAIL) {mchunkptr newp = (mchunkptr)(cp + offset);
- size_t psize = newmmsize - offset - MMAP_FOOT_PAD;
+ usize psize = newmmsize - offset - MMAP_FOOT_PAD;
newp->head = psize;
mark_inuse_foot(m, newp, psize);
chunk_plus_offset(newp, psize)->head = FENCEPOST_HEAD;
@@ -3904,9 +3904,9 @@
/* -------------------------- mspace management -------------------------- */
/* Initialize top chunk and its size */
-static void init_top(mstate m, mchunkptr p, size_t psize) {+static void init_top(mstate m, mchunkptr p, usize psize) {/* Ensure alignment */
- size_t offset = align_offset(chunk2mem(p));
+ usize offset = align_offset(chunk2mem(p));
p = (mchunkptr)((char*)p + offset);
psize -= offset;
@@ -3949,12 +3949,12 @@
/* Allocate chunk and prepend remainder with chunk in successor base. */
static void* prepend_alloc(mstate m, char* newbase, char* oldbase,
- size_t nb) {+ usize nb) {mchunkptr p = align_as_chunk(newbase);
mchunkptr oldfirst = align_as_chunk(oldbase);
- size_t psize = (char*)oldfirst - (char*)p;
+ usize psize = (char*)oldfirst - (char*)p;
mchunkptr q = chunk_plus_offset(p, nb);
- size_t qsize = psize - nb;
+ usize qsize = psize - nb;
set_size_and_pinuse_of_inuse_chunk(m, p, nb);
assert((char*)oldfirst > (char*)q);
@@ -3963,19 +3963,19 @@
/* consolidate remainder with first chunk of old base */
if (oldfirst == m->top) {- size_t tsize = m->topsize += qsize;
+ usize tsize = m->topsize += qsize;
m->top = q;
q->head = tsize | PINUSE_BIT;
check_top_chunk(m, q);
}
else if (oldfirst == m->dv) {- size_t dsize = m->dvsize += qsize;
+ usize dsize = m->dvsize += qsize;
m->dv = q;
set_size_and_pinuse_of_free_chunk(q, dsize);
}
else { if (!is_inuse(oldfirst)) {- size_t nsize = chunksize(oldfirst);
+ usize nsize = chunksize(oldfirst);
unlink_chunk(m, oldfirst, nsize);
oldfirst = chunk_plus_offset(oldfirst, nsize);
qsize += nsize;
@@ -3990,14 +3990,14 @@
}
/* Add a segment to hold a new noncontiguous region */
-static void add_segment(mstate m, char* tbase, size_t tsize, flag_t mmapped) {+static void add_segment(mstate m, char* tbase, usize tsize, flag_t mmapped) {/* Determine locations and sizes of segment, fenceposts, old top */
char* old_top = (char*)m->top;
msegmentptr oldsp = segment_holding(m, old_top);
char* old_end = oldsp->base + oldsp->size;
- size_t ssize = pad_request(sizeof(struct malloc_segment));
+ usize ssize = pad_request(sizeof(struct malloc_segment));
char* rawsp = old_end - (ssize + FOUR_SIZE_T_SIZES + CHUNK_ALIGN_MASK);
- size_t offset = align_offset(chunk2mem(rawsp));
+ usize offset = align_offset(chunk2mem(rawsp));
char* asp = rawsp + offset;
char* csp = (asp < (old_top + MIN_CHUNK_SIZE))? old_top : asp;
mchunkptr sp = (mchunkptr)csp;
@@ -4033,7 +4033,7 @@
/* Insert the rest of old top into a bin as an ordinary free chunk */
if (csp != old_top) {mchunkptr q = (mchunkptr)old_top;
- size_t psize = csp - old_top;
+ usize psize = csp - old_top;
mchunkptr tn = chunk_plus_offset(q, psize);
set_free_with_pinuse(q, psize, tn);
insert_chunk(m, q, psize);
@@ -4045,11 +4045,11 @@
/* -------------------------- System allocation -------------------------- */
/* Get memory from system using MORECORE or MMAP */
-static void* sys_alloc(mstate m, size_t nb) {+static void* sys_alloc(mstate m, usize nb) {char* tbase = CMFAIL;
- size_t tsize = 0;
+ usize tsize = 0;
flag_t mmap_flag = 0;
- size_t asize; /* allocation size */
+ usize asize; /* allocation size */
ensure_initialization();
@@ -4064,7 +4064,7 @@
if (asize <= nb)
return 0; /* wraparound */
if (m->footprint_limit != 0) {- size_t fp = m->footprint + asize;
+ usize fp = m->footprint + asize;
if (fp <= m->footprint || fp > m->footprint_limit)
return 0;
}
@@ -4093,7 +4093,7 @@
if (MORECORE_CONTIGUOUS && !use_noncontiguous(m)) {char* br = CMFAIL;
- size_t ssize = asize; /* sbrk call size */
+ usize ssize = asize; /* sbrk call size */
msegmentptr ss = (m->top == 0)? 0 : segment_holding(m, (char*)m->top);
ACQUIRE_MALLOC_GLOBAL_LOCK();
@@ -4100,10 +4100,10 @@
if (ss == 0) { /* First time through or recovery */char* base = (char*)CALL_MORECORE(0);
if (base != CMFAIL) {- size_t fp;
+ usize fp;
/* Adjust to end on a page boundary */
if (!is_page_aligned(base))
- ssize += (page_align((size_t)base) - (size_t)base);
+ ssize += (page_align((usize)base) - (usize)base);
fp = m->footprint + ssize; /* recheck limits */
if (ssize > nb && ssize < HALF_MAX_SIZE_T &&
(m->footprint_limit == 0 ||
@@ -4129,7 +4129,7 @@
if (br != CMFAIL) { /* Try to use/extend the space we did get */if (ssize < HALF_MAX_SIZE_T &&
ssize < nb + SYS_ALLOC_PADDING) {- size_t esize = granularity_align(nb + SYS_ALLOC_PADDING - ssize);
+ usize esize = granularity_align(nb + SYS_ALLOC_PADDING - ssize);
if (esize < HALF_MAX_SIZE_T) {char* end = (char*)CALL_MORECORE(esize);
if (end != CMFAIL)
@@ -4170,7 +4170,7 @@
end = (char*)(CALL_MORECORE(0));
RELEASE_MALLOC_GLOBAL_LOCK();
if (br != CMFAIL && end != CMFAIL && br < end) {- size_t ssize = end - br;
+ usize ssize = end - br;
if (ssize > nb + TOP_FOOT_SIZE) {tbase = br;
tsize = ssize;
@@ -4201,7 +4201,7 @@
{/* Offset top by embedded malloc_state */
mchunkptr mn = next_chunk(mem2chunk(m));
- init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE);
+ init_top(m, mn, (usize)((tbase + tsize) - (char*)mn) -TOP_FOOT_SIZE);
}
}
@@ -4238,7 +4238,7 @@
}
if (nb < m->topsize) { /* Allocate from new or extended top space */- size_t rsize = m->topsize -= nb;
+ usize rsize = m->topsize -= nb;
mchunkptr p = m->top;
mchunkptr r = m->top = chunk_plus_offset(p, nb);
r->head = rsize | PINUSE_BIT;
@@ -4256,19 +4256,19 @@
/* ----------------------- system deallocation -------------------------- */
/* Unmap and unlink any mmapped segments that don't contain used chunks */
-static size_t release_unused_segments(mstate m) {- size_t released = 0;
+static usize release_unused_segments(mstate m) {+ usize released = 0;
int nsegs = 0;
msegmentptr pred = &m->seg;
msegmentptr sp = pred->next;
while (sp != 0) {char* base = sp->base;
- size_t size = sp->size;
+ usize size = sp->size;
msegmentptr next = sp->next;
++nsegs;
if (is_mmapped_segment(sp) && !is_extern_segment(sp)) {mchunkptr p = align_as_chunk(base);
- size_t psize = chunksize(p);
+ usize psize = chunksize(p);
/* Can unmap if first chunk holds entire segment and not pinned */
if (!is_inuse(p) && (char*)p + psize >= base + size - TOP_FOOT_SIZE) {tchunkptr tp = (tchunkptr)p;
@@ -4298,13 +4298,13 @@
sp = next;
}
/* Reset check counter */
- m->release_checks = (((size_t) nsegs > (size_t) MAX_RELEASE_CHECK_RATE)?
- (size_t) nsegs : (size_t) MAX_RELEASE_CHECK_RATE);
+ m->release_checks = (((usize) nsegs > (usize) MAX_RELEASE_CHECK_RATE)?
+ (usize) nsegs : (usize) MAX_RELEASE_CHECK_RATE);
return released;
}
-static int sys_trim(mstate m, size_t pad) {- size_t released = 0;
+static int sys_trim(mstate m, usize pad) {+ usize released = 0;
ensure_initialization();
if (pad < MAX_REQUEST && is_initialized(m)) {pad += TOP_FOOT_SIZE; /* ensure enough room for segment overhead */
@@ -4311,8 +4311,8 @@
if (m->topsize > pad) {/* Shrink top space in granularity-size units, keeping at least one */
- size_t unit = mparams.granularity;
- size_t extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
+ usize unit = mparams.granularity;
+ usize extra = ((m->topsize - pad + (unit - SIZE_T_ONE)) / unit -
SIZE_T_ONE) * unit;
msegmentptr sp = segment_holding(m, (char*)m->top);
@@ -4321,7 +4321,7 @@
if (HAVE_MMAP &&
sp->size >= extra &&
!has_segment_link(m, sp)) { /* can't shrink if pinned */- size_t newsize = sp->size - extra;
+ usize newsize = sp->size - extra;
(void)newsize; /* placate people compiling -Wunused-variable */
/* Prefer mremap, fall back to munmap */
if ((CALL_MREMAP(sp->base, sp->size, newsize, 0) != MFAIL) ||
@@ -4371,11 +4371,11 @@
/* Consolidate and bin a chunk. Differs from exported versions
of free mainly in that the chunk need not be marked as inuse.
*/
-static void dispose_chunk(mstate m, mchunkptr p, size_t psize) {+static void dispose_chunk(mstate m, mchunkptr p, usize psize) {mchunkptr next = chunk_plus_offset(p, psize);
if (!pinuse(p)) {mchunkptr prev;
- size_t prevsize = p->prev_foot;
+ usize prevsize = p->prev_foot;
if (is_mmapped(p)) {psize += prevsize + MMAP_FOOT_PAD;
if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
@@ -4403,7 +4403,7 @@
if (RTCHECK(ok_address(m, next))) { if (!cinuse(next)) { /* consolidate forward */ if (next == m->top) {- size_t tsize = m->topsize += psize;
+ usize tsize = m->topsize += psize;
m->top = p;
p->head = tsize | PINUSE_BIT;
if (p == m->dv) {@@ -4413,13 +4413,13 @@
return;
}
else if (next == m->dv) {- size_t dsize = m->dvsize += psize;
+ usize dsize = m->dvsize += psize;
m->dv = p;
set_size_and_pinuse_of_free_chunk(p, dsize);
return;
}
else {- size_t nsize = chunksize(next);
+ usize nsize = chunksize(next);
psize += nsize;
unlink_chunk(m, next, nsize);
set_size_and_pinuse_of_free_chunk(p, psize);
@@ -4442,19 +4442,19 @@
/* ---------------------------- malloc --------------------------- */
/* allocate a large request from the best fitting chunk in a treebin */
-static void* tmalloc_large(mstate m, size_t nb) {+static void* tmalloc_large(mstate m, usize nb) {tchunkptr v = 0;
- size_t rsize = -nb; /* Unsigned negation */
+ usize rsize = -nb; /* Unsigned negation */
tchunkptr t;
bindex_t idx;
compute_tree_index(nb, idx);
if ((t = *treebin_at(m, idx)) != 0) {/* Traverse tree for this bin looking for node with size == nb */
- size_t sizebits = nb << leftshift_for_tree_index(idx);
+ usize sizebits = nb << leftshift_for_tree_index(idx);
tchunkptr rst = 0; /* The deepest untaken right subtree */
for (;;) {tchunkptr rt;
- size_t trem = chunksize(t) - nb;
+ usize trem = chunksize(t) - nb;
if (trem < rsize) {v = t;
if ((rsize = trem) == 0)
@@ -4482,7 +4482,7 @@
}
while (t != 0) { /* find smallest of tree or subtree */- size_t trem = chunksize(t) - nb;
+ usize trem = chunksize(t) - nb;
if (trem < rsize) {rsize = trem;
v = t;
@@ -4491,7 +4491,7 @@
}
/* If dv is a better fit, return 0 so malloc will use it */
- if (v != 0 && rsize < (size_t)(m->dvsize - nb)) {+ if (v != 0 && rsize < (usize)(m->dvsize - nb)) { if (RTCHECK(ok_address(m, v))) { /* split */mchunkptr r = chunk_plus_offset(v, nb);
assert(chunksize(v) == rsize + nb);
@@ -4513,9 +4513,9 @@
}
/* allocate a small request from the best fitting chunk in a treebin */
-static void* tmalloc_small(mstate m, size_t nb) {+static void* tmalloc_small(mstate m, usize nb) {tchunkptr t, v;
- size_t rsize;
+ usize rsize;
bindex_t i;
binmap_t leastbit = least_bit(m->treemap);
compute_bit2idx(leastbit, i);
@@ -4523,7 +4523,7 @@
rsize = chunksize(t) - nb;
while ((t = leftmost_child(t)) != 0) {- size_t trem = chunksize(t) - nb;
+ usize trem = chunksize(t) - nb;
if (trem < rsize) {rsize = trem;
v = t;
@@ -4552,7 +4552,7 @@
#if !ONLY_MSPACES
-void* dlmalloc(size_t bytes) {+void* dlmalloc(usize bytes) {/*
Basic algorithm:
If a small request (< 256 bytes minus per-chunk overhead):
@@ -4582,7 +4582,7 @@
if (!PREACTION(gm)) {void* mem;
- size_t nb;
+ usize nb;
if (bytes <= MAX_SMALL_REQUEST) {bindex_t idx;
binmap_t smallbits;
@@ -4606,7 +4606,7 @@
else if (nb > gm->dvsize) { if (smallbits != 0) { /* Use chunk in next nonempty smallbin */mchunkptr b, p, r;
- size_t rsize;
+ usize rsize;
bindex_t i;
binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
binmap_t leastbit = least_bit(leftbits);
@@ -4647,7 +4647,7 @@
}
if (nb <= gm->dvsize) {- size_t rsize = gm->dvsize - nb;
+ usize rsize = gm->dvsize - nb;
mchunkptr p = gm->dv;
if (rsize >= MIN_CHUNK_SIZE) { /* split dv */mchunkptr r = gm->dv = chunk_plus_offset(p, nb);
@@ -4656,7 +4656,7 @@
set_size_and_pinuse_of_inuse_chunk(gm, p, nb);
}
else { /* exhaust dv */- size_t dvs = gm->dvsize;
+ usize dvs = gm->dvsize;
gm->dvsize = 0;
gm->dv = 0;
set_inuse_and_pinuse(gm, p, dvs);
@@ -4667,7 +4667,7 @@
}
else if (nb < gm->topsize) { /* Split top */- size_t rsize = gm->topsize -= nb;
+ usize rsize = gm->topsize -= nb;
mchunkptr p = gm->top;
mchunkptr r = gm->top = chunk_plus_offset(p, nb);
r->head = rsize | PINUSE_BIT;
@@ -4711,10 +4711,10 @@
if (!PREACTION(fm)) {check_inuse_chunk(fm, p);
if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) {- size_t psize = chunksize(p);
+ usize psize = chunksize(p);
mchunkptr next = chunk_plus_offset(p, psize);
if (!pinuse(p)) {- size_t prevsize = p->prev_foot;
+ usize prevsize = p->prev_foot;
if (is_mmapped(p)) {psize += prevsize + MMAP_FOOT_PAD;
if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
@@ -4743,7 +4743,7 @@
if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { if (!cinuse(next)) { /* consolidate forward */ if (next == fm->top) {- size_t tsize = fm->topsize += psize;
+ usize tsize = fm->topsize += psize;
fm->top = p;
p->head = tsize | PINUSE_BIT;
if (p == fm->dv) {@@ -4755,13 +4755,13 @@
goto postaction;
}
else if (next == fm->dv) {- size_t dsize = fm->dvsize += psize;
+ usize dsize = fm->dvsize += psize;
fm->dv = p;
set_size_and_pinuse_of_free_chunk(p, dsize);
goto postaction;
}
else {- size_t nsize = chunksize(next);
+ usize nsize = chunksize(next);
psize += nsize;
unlink_chunk(fm, next, nsize);
set_size_and_pinuse_of_free_chunk(p, psize);
@@ -4799,12 +4799,12 @@
#endif /* FOOTERS */
}
-void* dlcalloc(size_t n_elements, size_t elem_size) {+void* dlcalloc(usize n_elements, usize elem_size) {void* mem;
- size_t req = 0;
+ usize req = 0;
if (n_elements != 0) {req = n_elements * elem_size;
- if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+ if (((n_elements | elem_size) & ~(usize)0xffff) &&
(req / n_elements != elem_size))
req = MAX_SIZE_T; /* force downstream failure on overflow */
}
@@ -4819,10 +4819,10 @@
/* ------------ Internal support for realloc, memalign, etc -------------- */
/* Try to realloc; only in-place unless can_move true */
-static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, size_t nb,
+static mchunkptr try_realloc_chunk(mstate m, mchunkptr p, usize nb,
int can_move) {mchunkptr newp = 0;
- size_t oldsize = chunksize(p);
+ usize oldsize = chunksize(p);
mchunkptr next = chunk_plus_offset(p, oldsize);
if (RTCHECK(ok_address(m, p) && ok_inuse(p) &&
ok_next(p, next) && ok_pinuse(next))) {@@ -4830,7 +4830,7 @@
newp = mmap_resize(m, p, nb, can_move);
}
else if (oldsize >= nb) { /* already big enough */- size_t rsize = oldsize - nb;
+ usize rsize = oldsize - nb;
if (rsize >= MIN_CHUNK_SIZE) { /* split off remainder */mchunkptr r = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
@@ -4841,8 +4841,8 @@
}
else if (next == m->top) { /* extend into top */ if (oldsize + m->topsize > nb) {- size_t newsize = oldsize + m->topsize;
- size_t newtopsize = newsize - nb;
+ usize newsize = oldsize + m->topsize;
+ usize newtopsize = newsize - nb;
mchunkptr newtop = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
newtop->head = newtopsize |PINUSE_BIT;
@@ -4852,9 +4852,9 @@
}
}
else if (next == m->dv) { /* extend into dv */- size_t dvs = m->dvsize;
+ usize dvs = m->dvsize;
if (oldsize + dvs >= nb) {- size_t dsize = oldsize + dvs - nb;
+ usize dsize = oldsize + dvs - nb;
if (dsize >= MIN_CHUNK_SIZE) {mchunkptr r = chunk_plus_offset(p, nb);
mchunkptr n = chunk_plus_offset(r, dsize);
@@ -4865,7 +4865,7 @@
m->dv = r;
}
else { /* exhaust dv */- size_t newsize = oldsize + dvs;
+ usize newsize = oldsize + dvs;
set_inuse(m, p, newsize);
m->dvsize = 0;
m->dv = 0;
@@ -4874,12 +4874,12 @@
}
}
else if (!cinuse(next)) { /* extend into next free chunk */- size_t nextsize = chunksize(next);
+ usize nextsize = chunksize(next);
if (oldsize + nextsize >= nb) {- size_t rsize = oldsize + nextsize - nb;
+ usize rsize = oldsize + nextsize - nb;
unlink_chunk(m, next, nextsize);
if (rsize < MIN_CHUNK_SIZE) {- size_t newsize = oldsize + nextsize;
+ usize newsize = oldsize + nextsize;
set_inuse(m, p, newsize);
}
else {@@ -4898,12 +4898,12 @@
return newp;
}
-static void* internal_memalign(mstate m, size_t alignment, size_t bytes) {+static void* internal_memalign(mstate m, usize alignment, usize bytes) {void* mem = 0;
if (alignment < MIN_CHUNK_SIZE) /* must be at least a minimum chunk size */
alignment = MIN_CHUNK_SIZE;
if ((alignment & (alignment-SIZE_T_ONE)) != 0) {/* Ensure a power of 2 */- size_t a = MALLOC_ALIGNMENT << 1;
+ usize a = MALLOC_ALIGNMENT << 1;
while (a < alignment) a <<= 1;
alignment = a;
}
@@ -4913,14 +4913,14 @@
}
}
else {- size_t nb = request2size(bytes);
- size_t req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
+ usize nb = request2size(bytes);
+ usize req = nb + alignment + MIN_CHUNK_SIZE - CHUNK_OVERHEAD;
mem = internal_malloc(m, req);
if (mem != 0) {mchunkptr p = mem2chunk(mem);
if (PREACTION(m))
return 0;
- if ((((size_t)(mem)) & (alignment - 1)) != 0) { /* misaligned */+ if ((((usize)(mem)) & (alignment - 1)) != 0) { /* misaligned *//*
Find an aligned spot inside chunk. Since we need to give
back leading space in a chunk of at least MIN_CHUNK_SIZE, if
@@ -4929,14 +4929,14 @@
We've allocated enough total room so that this is always
possible.
*/
- char* br = (char*)mem2chunk((size_t)(((size_t)((char*)mem + alignment -
+ char* br = (char*)mem2chunk((usize)(((usize)((char*)mem + alignment -
SIZE_T_ONE)) &
-alignment));
- char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE)?
+ char* pos = ((usize)(br - (char*)(p)) >= MIN_CHUNK_SIZE)?
br : br+alignment;
mchunkptr newp = (mchunkptr)pos;
- size_t leadsize = pos - (char*)(p);
- size_t newsize = chunksize(p) - leadsize;
+ usize leadsize = pos - (char*)(p);
+ usize newsize = chunksize(p) - leadsize;
if (is_mmapped(p)) { /* For mmapped chunks, just adjust offset */newp->prev_foot = p->prev_foot + leadsize;
@@ -4952,9 +4952,9 @@
/* Give back spare room at the end */
if (!is_mmapped(p)) {- size_t size = chunksize(p);
+ usize size = chunksize(p);
if (size > nb + MIN_CHUNK_SIZE) {- size_t remainder_size = size - nb;
+ usize remainder_size = size - nb;
mchunkptr remainder = chunk_plus_offset(p, nb);
set_inuse(m, p, nb);
set_inuse(m, remainder, remainder_size);
@@ -4964,7 +4964,7 @@
mem = chunk2mem(p);
assert (chunksize(p) >= nb);
- assert(((size_t)mem & (alignment - 1)) == 0);
+ assert(((usize)mem & (alignment - 1)) == 0);
check_inuse_chunk(m, p);
POSTACTION(m);
}
@@ -4980,22 +4980,22 @@
bit 1 set if elements should be zeroed
*/
static void** ialloc(mstate m,
- size_t n_elements,
- size_t* sizes,
+ usize n_elements,
+ usize* sizes,
int opts,
void* chunks[]) {- size_t element_size; /* chunksize of each element, if all same */
- size_t contents_size; /* total size of elements */
- size_t array_size; /* request size of pointer array */
+ usize element_size; /* chunksize of each element, if all same */
+ usize contents_size; /* total size of elements */
+ usize array_size; /* request size of pointer array */
void* mem; /* malloced aggregate space */
mchunkptr p; /* corresponding chunk */
- size_t remainder_size; /* remaining bytes while splitting */
+ usize remainder_size; /* remaining bytes while splitting */
void** marray; /* either "chunks" or malloced ptr array */
mchunkptr array_chunk; /* chunk for malloced ptr array */
flag_t was_enabled; /* to disable mmap */
- size_t size;
- size_t i;
+ usize size;
+ usize i;
ensure_initialization();
/* compute array length, if needed */
@@ -5047,12 +5047,12 @@
assert(!is_mmapped(p));
if (opts & 0x2) { /* optionally clear the elements */- memset((size_t*)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
+ memset((usize*)mem, 0, remainder_size - SIZE_T_SIZE - array_size);
}
/* If not provided, allocate the pointer array as final part of chunk */
if (marray == 0) {- size_t array_chunk_size;
+ usize array_chunk_size;
array_chunk = chunk_plus_offset(p, contents_size);
array_chunk_size = remainder_size - contents_size;
marray = (void**) (chunk2mem(array_chunk));
@@ -5105,8 +5105,8 @@
chunks before freeing, which will occur often if allocated
with ialloc or the array is sorted.
*/
-static size_t internal_bulk_free(mstate m, void* array[], size_t nelem) {- size_t unfreed = 0;
+static usize internal_bulk_free(mstate m, void* array[], usize nelem) {+ usize unfreed = 0;
if (!PREACTION(m)) {void** a;
void** fence = &(array[nelem]);
@@ -5114,7 +5114,7 @@
void* mem = *a;
if (mem != 0) {mchunkptr p = mem2chunk(mem);
- size_t psize = chunksize(p);
+ usize psize = chunksize(p);
#if FOOTERS
if (get_mstate_for(p) != m) {++unfreed;
@@ -5127,7 +5127,7 @@
void ** b = a + 1; /* try to merge with next chunk */
mchunkptr next = next_chunk(p);
if (b != fence && *b == chunk2mem(next)) {- size_t newsize = chunksize(next) + psize;
+ usize newsize = chunksize(next) + psize;
set_inuse(m, p, newsize);
*b = chunk2mem(p);
}
@@ -5152,7 +5152,7 @@
static void internal_inspect_all(mstate m,
void(*handler)(void *start,
void *end,
- size_t used_bytes,
+ usize used_bytes,
void* callback_arg),
void* arg) { if (is_initialized(m)) {@@ -5162,8 +5162,8 @@
mchunkptr q = align_as_chunk(s->base);
while (segment_holds(s, q) && q->head != FENCEPOST_HEAD) {mchunkptr next = next_chunk(q);
- size_t sz = chunksize(q);
- size_t used;
+ usize sz = chunksize(q);
+ usize used;
void* start;
if (is_inuse(q)) {used = sz - CHUNK_OVERHEAD; /* must not be mmapped */
@@ -5193,7 +5193,7 @@
#if !ONLY_MSPACES
-void* dlrealloc(void* oldmem, size_t bytes) {+void* dlrealloc(void* oldmem, usize bytes) {void* mem = 0;
if (oldmem == 0) {mem = dlmalloc(bytes);
@@ -5207,7 +5207,7 @@
}
#endif /* REALLOC_ZERO_BYTES_FREES */
else {- size_t nb = request2size(bytes);
+ usize nb = request2size(bytes);
mchunkptr oldp = mem2chunk(oldmem);
#if ! FOOTERS
mstate m = gm;
@@ -5228,7 +5228,7 @@
else {mem = internal_malloc(m, bytes);
if (mem != 0) {- size_t oc = chunksize(oldp) - overhead_for(oldp);
+ usize oc = chunksize(oldp) - overhead_for(oldp);
memcpy(mem, oldmem, (oc < bytes)? oc : bytes);
internal_free(m, oldmem);
}
@@ -5238,7 +5238,7 @@
return mem;
}
-void* dlrealloc_in_place(void* oldmem, size_t bytes) {+void* dlrealloc_in_place(void* oldmem, usize bytes) {void* mem = 0;
if (oldmem != 0) { if (bytes >= MAX_REQUEST) {@@ -5245,7 +5245,7 @@
MALLOC_FAILURE_ACTION;
}
else {- size_t nb = request2size(bytes);
+ usize nb = request2size(bytes);
mchunkptr oldp = mem2chunk(oldmem);
#if ! FOOTERS
mstate m = gm;
@@ -5269,7 +5269,7 @@
return mem;
}
-void* dlmemalign(size_t alignment, size_t bytes) {+void* dlmemalign(usize alignment, usize bytes) { if (alignment <= MALLOC_ALIGNMENT) {return dlmalloc(bytes);
}
@@ -5276,13 +5276,13 @@
return internal_memalign(gm, alignment, bytes);
}
-int dlposix_memalign(void** pp, size_t alignment, size_t bytes) {+int dlposix_memalign(void** pp, usize alignment, usize bytes) {void* mem = 0;
if (alignment == MALLOC_ALIGNMENT)
mem = dlmalloc(bytes);
else {- size_t d = alignment / sizeof(void*);
- size_t r = alignment % sizeof(void*);
+ usize d = alignment / sizeof(void*);
+ usize r = alignment % sizeof(void*);
if (r != 0 || d == 0 || (d & (d-SIZE_T_ONE)) != 0)
return EINVAL;
else if (bytes <= MAX_REQUEST - alignment) {@@ -5299,32 +5299,32 @@
}
}
-void* dlvalloc(size_t bytes) {- size_t pagesz;
+void* dlvalloc(usize bytes) {+ usize pagesz;
ensure_initialization();
pagesz = mparams.page_size;
return dlmemalign(pagesz, bytes);
}
-void* dlpvalloc(size_t bytes) {- size_t pagesz;
+void* dlpvalloc(usize bytes) {+ usize pagesz;
ensure_initialization();
pagesz = mparams.page_size;
return dlmemalign(pagesz, (bytes + pagesz - SIZE_T_ONE) & ~(pagesz - SIZE_T_ONE));
}
-void** dlindependent_calloc(size_t n_elements, size_t elem_size,
+void** dlindependent_calloc(usize n_elements, usize elem_size,
void* chunks[]) {- size_t sz = elem_size; /* serves as 1-element array */
+ usize sz = elem_size; /* serves as 1-element array */
return ialloc(gm, n_elements, &sz, 3, chunks);
}
-void** dlindependent_comalloc(size_t n_elements, size_t sizes[],
+void** dlindependent_comalloc(usize n_elements, usize sizes[],
void* chunks[]) {return ialloc(gm, n_elements, sizes, 0, chunks);
}
-size_t dlbulk_free(void* array[], size_t nelem) {+usize dlbulk_free(void* array[], usize nelem) {return internal_bulk_free(gm, array, nelem);
}
@@ -5331,7 +5331,7 @@
#if MALLOC_INSPECT_ALL
void dlmalloc_inspect_all(void(*handler)(void *start,
void *end,
- size_t used_bytes,
+ usize used_bytes,
void* callback_arg),
void* arg) {ensure_initialization();
@@ -5342,7 +5342,7 @@
}
#endif /* MALLOC_INSPECT_ALL */
-int dlmalloc_trim(size_t pad) {+int dlmalloc_trim(usize pad) {int result = 0;
ensure_initialization();
if (!PREACTION(gm)) {@@ -5353,23 +5353,23 @@
}
sl_purefn
-size_t dlmalloc_footprint(void) {+usize dlmalloc_footprint(void) {return gm->footprint;
}
sl_purefn
-size_t dlmalloc_max_footprint(void) {+usize dlmalloc_max_footprint(void) {return gm->max_footprint;
}
sl_purefn
-size_t dlmalloc_footprint_limit(void) {- size_t maf = gm->footprint_limit;
+usize dlmalloc_footprint_limit(void) {+ usize maf = gm->footprint_limit;
return maf == 0 ? MAX_SIZE_T : maf;
}
-size_t dlmalloc_set_footprint_limit(size_t bytes) {- size_t result; /* invert sense of 0 */
+usize dlmalloc_set_footprint_limit(usize bytes) {+ usize result; /* invert sense of 0 */
if (bytes == 0)
result = granularity_align(1); /* Use minimal size */
if (bytes == MAX_SIZE_T)
@@ -5396,7 +5396,7 @@
}
sl_purefn
-size_t dlmalloc_usable_size(void* mem) {+usize dlmalloc_usable_size(void* mem) { if (mem != 0) {mchunkptr p = mem2chunk(mem);
if (is_inuse(p))
@@ -5411,8 +5411,8 @@
#if MSPACES
-static mstate init_user_mstate(char* tbase, size_t tsize) {- size_t msize = pad_request(sizeof(struct malloc_state));
+static mstate init_user_mstate(char* tbase, usize tsize) {+ usize msize = pad_request(sizeof(struct malloc_state));
mchunkptr mn;
mchunkptr msp = align_as_chunk(tbase);
mstate m = (mstate)(chunk2mem(msp));
@@ -5429,20 +5429,20 @@
disable_contiguous(m);
init_bins(m);
mn = next_chunk(mem2chunk(m));
- init_top(m, mn, (size_t)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE);
+ init_top(m, mn, (usize)((tbase + tsize) - (char*)mn) - TOP_FOOT_SIZE);
check_top_chunk(m, m->top);
return m;
}
-mspace create_mspace(size_t capacity, int locked) {+mspace create_mspace(usize capacity, int locked) {mstate m = 0;
- size_t msize;
+ usize msize;
ensure_initialization();
msize = pad_request(sizeof(struct malloc_state));
- if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {- size_t rs = ((capacity == 0)? mparams.granularity :
+ if (capacity < (usize) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {+ usize rs = ((capacity == 0)? mparams.granularity :
(capacity + TOP_FOOT_SIZE + msize));
- size_t tsize = granularity_align(rs);
+ usize tsize = granularity_align(rs);
char* tbase = (char*)(CALL_MMAP(tsize));
if (tbase != CMFAIL) {m = init_user_mstate(tbase, tsize);
@@ -5453,13 +5453,13 @@
return (mspace)m;
}
-mspace create_mspace_with_base(void* base, size_t capacity, int locked) {+mspace create_mspace_with_base(void* base, usize capacity, int locked) {mstate m = 0;
- size_t msize;
+ usize msize;
ensure_initialization();
msize = pad_request(sizeof(struct malloc_state));
if (capacity > msize + TOP_FOOT_SIZE &&
- capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {+ capacity < (usize) -(msize + TOP_FOOT_SIZE + mparams.page_size)) {m = init_user_mstate((char*)base, capacity);
m->seg.sflags = EXTERN_BIT;
set_lock(m, locked);
@@ -5484,8 +5484,8 @@
return ret;
}
-size_t destroy_mspace(mspace msp) {- size_t freed = 0;
+usize destroy_mspace(mspace msp) {+ usize freed = 0;
mstate ms = (mstate)msp;
if (ok_magic(ms)) {msegmentptr sp = &ms->seg;
@@ -5492,7 +5492,7 @@
(void)DESTROY_LOCK(&ms->mutex); /* destroy before unmapped */
while (sp != 0) {char* base = sp->base;
- size_t size = sp->size;
+ usize size = sp->size;
flag_t flag = sp->sflags;
(void)base; /* placate people compiling -Wunused-variable */
sp = sp->next;
@@ -5512,7 +5512,7 @@
versions. This is not so nice but better than the alternatives.
*/
-void* mspace_malloc(mspace msp, size_t bytes) {+void* mspace_malloc(mspace msp, usize bytes) {mstate ms = (mstate)msp;
if (!ok_magic(ms)) {USAGE_ERROR_ACTION(ms,ms);
@@ -5520,7 +5520,7 @@
}
if (!PREACTION(ms)) {void* mem;
- size_t nb;
+ usize nb;
if (bytes <= MAX_SMALL_REQUEST) {bindex_t idx;
binmap_t smallbits;
@@ -5544,7 +5544,7 @@
else if (nb > ms->dvsize) { if (smallbits != 0) { /* Use chunk in next nonempty smallbin */mchunkptr b, p, r;
- size_t rsize;
+ usize rsize;
bindex_t i;
binmap_t leftbits = (smallbits << idx) & left_bits(idx2bit(idx));
binmap_t leastbit = least_bit(leftbits);
@@ -5585,7 +5585,7 @@
}
if (nb <= ms->dvsize) {- size_t rsize = ms->dvsize - nb;
+ usize rsize = ms->dvsize - nb;
mchunkptr p = ms->dv;
if (rsize >= MIN_CHUNK_SIZE) { /* split dv */mchunkptr r = ms->dv = chunk_plus_offset(p, nb);
@@ -5594,7 +5594,7 @@
set_size_and_pinuse_of_inuse_chunk(ms, p, nb);
}
else { /* exhaust dv */- size_t dvs = ms->dvsize;
+ usize dvs = ms->dvsize;
ms->dvsize = 0;
ms->dv = 0;
set_inuse_and_pinuse(ms, p, dvs);
@@ -5605,7 +5605,7 @@
}
else if (nb < ms->topsize) { /* Split top */- size_t rsize = ms->topsize -= nb;
+ usize rsize = ms->topsize -= nb;
mchunkptr p = ms->top;
mchunkptr r = ms->top = chunk_plus_offset(p, nb);
r->head = rsize | PINUSE_BIT;
@@ -5642,10 +5642,10 @@
if (!PREACTION(fm)) {check_inuse_chunk(fm, p);
if (RTCHECK(ok_address(fm, p) && ok_inuse(p))) {- size_t psize = chunksize(p);
+ usize psize = chunksize(p);
mchunkptr next = chunk_plus_offset(p, psize);
if (!pinuse(p)) {- size_t prevsize = p->prev_foot;
+ usize prevsize = p->prev_foot;
if (is_mmapped(p)) {psize += prevsize + MMAP_FOOT_PAD;
if (CALL_MUNMAP((char*)p - prevsize, psize) == 0)
@@ -5674,7 +5674,7 @@
if (RTCHECK(ok_next(p, next) && ok_pinuse(next))) { if (!cinuse(next)) { /* consolidate forward */ if (next == fm->top) {- size_t tsize = fm->topsize += psize;
+ usize tsize = fm->topsize += psize;
fm->top = p;
p->head = tsize | PINUSE_BIT;
if (p == fm->dv) {@@ -5686,13 +5686,13 @@
goto postaction;
}
else if (next == fm->dv) {- size_t dsize = fm->dvsize += psize;
+ usize dsize = fm->dvsize += psize;
fm->dv = p;
set_size_and_pinuse_of_free_chunk(p, dsize);
goto postaction;
}
else {- size_t nsize = chunksize(next);
+ usize nsize = chunksize(next);
psize += nsize;
unlink_chunk(fm, next, nsize);
set_size_and_pinuse_of_free_chunk(p, psize);
@@ -5727,9 +5727,9 @@
}
}
-void* mspace_calloc(mspace msp, size_t n_elements, size_t elem_size) {+void* mspace_calloc(mspace msp, usize n_elements, usize elem_size) {void* mem;
- size_t req = 0;
+ usize req = 0;
mstate ms = (mstate)msp;
if (!ok_magic(ms)) {USAGE_ERROR_ACTION(ms,ms);
@@ -5737,7 +5737,7 @@
}
if (n_elements != 0) {req = n_elements * elem_size;
- if (((n_elements | elem_size) & ~(size_t)0xffff) &&
+ if (((n_elements | elem_size) & ~(usize)0xffff) &&
(req / n_elements != elem_size))
req = MAX_SIZE_T; /* force downstream failure on overflow */
}
@@ -5747,7 +5747,7 @@
return mem;
}
-void* mspace_realloc(mspace msp, void* oldmem, size_t bytes) {+void* mspace_realloc(mspace msp, void* oldmem, usize bytes) {void* mem = 0;
if (oldmem == 0) {mem = mspace_malloc(msp, bytes);
@@ -5761,7 +5761,7 @@
}
#endif /* REALLOC_ZERO_BYTES_FREES */
else {- size_t nb = request2size(bytes);
+ usize nb = request2size(bytes);
mchunkptr oldp = mem2chunk(oldmem);
#if ! FOOTERS
mstate m = (mstate)msp;
@@ -5782,7 +5782,7 @@
else {mem = mspace_malloc(m, bytes);
if (mem != 0) {- size_t oc = chunksize(oldp) - overhead_for(oldp);
+ usize oc = chunksize(oldp) - overhead_for(oldp);
memcpy(mem, oldmem, (oc < bytes)? oc : bytes);
mspace_free(m, oldmem);
}
@@ -5792,7 +5792,7 @@
return mem;
}
-void* mspace_realloc_in_place(mspace msp, void* oldmem, size_t bytes) {+void* mspace_realloc_in_place(mspace msp, void* oldmem, usize bytes) {void* mem = 0;
if (oldmem != 0) { if (bytes >= MAX_REQUEST) {@@ -5799,7 +5799,7 @@
MALLOC_FAILURE_ACTION;
}
else {- size_t nb = request2size(bytes);
+ usize nb = request2size(bytes);
mchunkptr oldp = mem2chunk(oldmem);
#if ! FOOTERS
mstate m = (mstate)msp;
@@ -5824,7 +5824,7 @@
return mem;
}
-void* mspace_memalign(mspace msp, size_t alignment, size_t bytes) {+void* mspace_memalign(mspace msp, usize alignment, usize bytes) {mstate ms = (mstate)msp;
if (!ok_magic(ms)) {USAGE_ERROR_ACTION(ms,ms);
@@ -5835,9 +5835,9 @@
return internal_memalign(ms, alignment, bytes);
}
-void** mspace_independent_calloc(mspace msp, size_t n_elements,
- size_t elem_size, void* chunks[]) {- size_t sz = elem_size; /* serves as 1-element array */
+void** mspace_independent_calloc(mspace msp, usize n_elements,
+ usize elem_size, void* chunks[]) {+ usize sz = elem_size; /* serves as 1-element array */
mstate ms = (mstate)msp;
if (!ok_magic(ms)) {USAGE_ERROR_ACTION(ms,ms);
@@ -5846,8 +5846,8 @@
return ialloc(ms, n_elements, &sz, 3, chunks);
}
-void** mspace_independent_comalloc(mspace msp, size_t n_elements,
- size_t sizes[], void* chunks[]) {+void** mspace_independent_comalloc(mspace msp, usize n_elements,
+ usize sizes[], void* chunks[]) {mstate ms = (mstate)msp;
if (!ok_magic(ms)) {USAGE_ERROR_ACTION(ms,ms);
@@ -5856,7 +5856,7 @@
return ialloc(ms, n_elements, sizes, 0, chunks);
}
-size_t mspace_bulk_free(mspace msp, void* array[], size_t nelem) {+usize mspace_bulk_free(mspace msp, void* array[], usize nelem) {return internal_bulk_free((mstate)msp, array, nelem);
}
@@ -5864,7 +5864,7 @@
void mspace_inspect_all(mspace msp,
void(*handler)(void *start,
void *end,
- size_t used_bytes,
+ usize used_bytes,
void* callback_arg),
void* arg) {mstate ms = (mstate)msp;
@@ -5880,7 +5880,7 @@
}
#endif /* MALLOC_INSPECT_ALL */
-int mspace_trim(mspace msp, size_t pad) {+int mspace_trim(mspace msp, usize pad) {int result = 0;
mstate ms = (mstate)msp;
if (ok_magic(ms)) {@@ -5907,8 +5907,8 @@
}
#endif /* NO_MALLOC_STATS */
-size_t mspace_footprint(mspace msp) {- size_t result = 0;
+usize mspace_footprint(mspace msp) {+ usize result = 0;
mstate ms = (mstate)msp;
if (ok_magic(ms)) {result = ms->footprint;
@@ -5919,8 +5919,8 @@
return result;
}
-size_t mspace_max_footprint(mspace msp) {- size_t result = 0;
+usize mspace_max_footprint(mspace msp) {+ usize result = 0;
mstate ms = (mstate)msp;
if (ok_magic(ms)) {result = ms->max_footprint;
@@ -5931,11 +5931,11 @@
return result;
}
-size_t mspace_footprint_limit(mspace msp) {- size_t result = 0;
+usize mspace_footprint_limit(mspace msp) {+ usize result = 0;
mstate ms = (mstate)msp;
if (ok_magic(ms)) {- size_t maf = ms->footprint_limit;
+ usize maf = ms->footprint_limit;
result = (maf == 0) ? MAX_SIZE_T : maf;
}
else {@@ -5944,8 +5944,8 @@
return result;
}
-size_t mspace_set_footprint_limit(mspace msp, size_t bytes) {- size_t result = 0;
+usize mspace_set_footprint_limit(mspace msp, usize bytes) {+ usize result = 0;
mstate ms = (mstate)msp;
if (ok_magic(ms)) {if (bytes == 0)
@@ -5972,7 +5972,7 @@
}
#endif /* NO_MALLINFO */
-size_t mspace_usable_size(const void* mem) {+usize mspace_usable_size(const void* mem) { if (mem != 0) {mchunkptr p = mem2chunk(mem);
if (is_inuse(p))
@@ -6047,7 +6047,7 @@
// save ptrs so they can be freed during cleanup
our_os_pools[next_os_pool] = ptr;
next_os_pool++;
- ptr = (void *) ((((size_t) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
+ ptr = (void *) ((((usize) ptr) + RM_PAGE_MASK) & ~RM_PAGE_MASK);
sbrk_top = (char *) ptr + size;
return ptr;
}
@@ -6122,7 +6122,7 @@
V2.8.3 Thu Sep 22 11:16:32 2005 Doug Lea (dl at gee)
* Add max_footprint functions
- * Ensure all appropriate literals are size_t
+ * Ensure all appropriate literals are usize
* Fix conditional compilation problem for some #define settings
* Avoid concatenating segments with the one provided
in create_mspace_with_base
--- a/3rd/fn.c
+++ b/3rd/fn.c
@@ -9,7 +9,7 @@
#include "fn.h"
bool
-Tgetkv(Tbl *t, const char *key, size_t len, const char **pkey, void **pval)
+Tgetkv(Tbl *t, const char *key, usize len, const char **pkey, void **pval)
{if(t == nil)
return false;
@@ -29,7 +29,7 @@
}
static bool
-next_rec(Trie *t, const char **pkey, size_t *plen, void **pval)
+next_rec(Trie *t, const char **pkey, usize *plen, void **pval)
{Tindex i = t->index;
if(Tindex_branch(i)){@@ -61,7 +61,7 @@
}
bool
-Tnextl(Tbl *tbl, const char **pkey, size_t *plen, void **pval)
+Tnextl(Tbl *tbl, const char **pkey, usize *plen, void **pval)
{ if(tbl == nil){*pkey = nil;
@@ -72,7 +72,7 @@
}
Tbl *
-Tdelkv(Tbl *tbl, const char *key, size_t len, const char **pkey, void **pval)
+Tdelkv(Tbl *tbl, const char *key, usize len, const char **pkey, void **pval)
{if(tbl == nil)
return nil;
@@ -116,7 +116,7 @@
}
Tbl *
-Tsetl(Tbl *tbl, const char *key, size_t len, void *val)
+Tsetl(Tbl *tbl, const char *key, usize len, void *val)
{assert(!Tindex_branch((Tindex)(uintptr)val) && len <= Tmaxlen);
if(val == nil)
--- a/3rd/fn.h
+++ b/3rd/fn.h
@@ -158,7 +158,7 @@
}
static inline u8int
-nibble(Tindex i, const char *key, size_t len)
+nibble(Tindex i, const char *key, usize len)
{u32int off = Tindex_offset(i);
if(off >= len)
@@ -167,7 +167,7 @@
}
static inline Tbitmap
-twigbit(Tindex i, const char *key, size_t len)
+twigbit(Tindex i, const char *key, usize len)
{return 1U << nibble(i, key, len);
}
--- a/3rd/spooky.c
+++ b/3rd/spooky.c
@@ -232,7 +232,7 @@
// but it's used by Spooky just for short messages.
//
static void
-spooky_short(const void *restrict message, size_t length,
+spooky_short(const void *restrict message, usize length,
u64int *restrict hash1, u64int *restrict hash2)
{u64int buf[2 * SC_NUMVARS];
@@ -248,7 +248,7 @@
u.p64 = buf;
}
- size_t left = length % 32;
+ usize left = length % 32;
u64int h[4];
h[0] = *hash1;
h[1] = *hash2;
@@ -322,7 +322,7 @@
}
u64int
-spooky_hash64(const void *message, size_t length, u64int seed)
+spooky_hash64(const void *message, usize length, u64int seed)
{u64int hash1 = seed;
spooky_hash128(message, length, &hash1, &seed);
@@ -330,7 +330,7 @@
}
u32int
-spooky_hash32(const void *message, size_t length, u32int seed)
+spooky_hash32(const void *message, usize length, u32int seed)
{u64int hash1 = seed, hash2 = seed;
spooky_hash128(message, length, &hash1, &hash2);
@@ -339,7 +339,7 @@
// do the whole hash in one call
void
-spooky_hash128(const void *restrict message, size_t length,
+spooky_hash128(const void *restrict message, usize length,
u64int *restrict hash1, u64int *restrict hash2)
{ if (length < SC_BUFSIZE) {@@ -354,7 +354,7 @@
const u8int *p8;
u64int *p64;
} u;
- size_t left;
+ usize left;
h[0] = *hash1;
h[1] = *hash2;
@@ -413,10 +413,10 @@
// add a message fragment to the state
void
spooky_update(struct spooky_state *restrict state,
- const void *restrict message, size_t length)
+ const void *restrict message, usize length)
{u64int h[SC_NUMVARS];
- size_t newLength = length + state->left;
+ usize newLength = length + state->left;
u8int left;
union {const u8int *p8;
--- a/3rd/spooky.h
+++ b/3rd/spooky.h
@@ -53,13 +53,13 @@
struct spooky_state {u64int data[2 * SC_NUMVARS]; // unhashed data, for partial messages
u64int state[SC_NUMVARS]; // internal state of the hash
- size_t length; // total length of the input so far
+ usize length; // total length of the input so far
u8int left; // length of unhashed data stashed in data
};
-void spooky_hash128(const void *message, size_t length, u64int *hash1, u64int *hash2);
-u64int spooky_hash64(const void *message, size_t length, u64int seed);
-u32int spooky_hash32(const void *message, size_t length, u32int seed);
+void spooky_hash128(const void *message, usize length, u64int *hash1, u64int *hash2);
+u64int spooky_hash64(const void *message, usize length, u64int seed);
+u32int spooky_hash32(const void *message, usize length, u32int seed);
//void spooky_init(struct spooky_state *state, u64int seed1, u64int seed2);
-//void spooky_update(struct spooky_state *state, const void *message, size_t length);
+//void spooky_update(struct spooky_state *state, const void *message, usize length);
//void spooky_final(struct spooky_state *state, u64int *hash1, u64int *hash2);
--- a/3rd/tbl.c
+++ b/3rd/tbl.c
@@ -10,7 +10,7 @@
#if 0 // UNUSED
void *
-Tgetl(Tbl *tbl, const char *key, size_t len)
+Tgetl(Tbl *tbl, const char *key, usize len)
{const char *rkey = nil;
void *rval = nil;
@@ -45,7 +45,7 @@
#endif
Tbl *
-Tdell(Tbl *tbl, const char *key, size_t len)
+Tdell(Tbl *tbl, const char *key, usize len)
{const char *rkey = nil;
void *rval = nil;
@@ -55,6 +55,6 @@
bool
Tnext(Tbl *tbl, const char **pkey, void **pvalue)
{- size_t len = *pkey == nil ? 0 : strlen(*pkey);
+ usize len = *pkey == nil ? 0 : strlen(*pkey);
return Tnextl(tbl, pkey, &len, pvalue);
}
--- a/3rd/tbl.h
+++ b/3rd/tbl.h
@@ -17,13 +17,13 @@
// Get the value associated with a key.
// Returns NULL if the key is not in the Table.
//
-void *Tgetl(Tbl *tbl, const char *key, size_t klen);
+void *Tgetl(Tbl *tbl, const char *key, usize klen);
void *Tget(Tbl *tbl, const char *key);
// Returns false if the key is not found, otherwise returns true and
// sets *rkey and *rval to the table's key and value pointers.
//
-bool Tgetkv(Tbl *tbl, const char *key, size_t klen, const char **rkey, void **rval);
+bool Tgetkv(Tbl *tbl, const char *key, usize klen, const char **rkey, void **rval);
// Associate a key with a value in a table. Returns a new pointer to
// the modified table. If there is an error it sets errno and returns
@@ -35,15 +35,15 @@
// EINVAL - value pointer is not word-aligned
// ENOMEM - allocation failed
//
-Tbl *Tsetl(Tbl *tbl, const char *key, size_t klen, void *value);
+Tbl *Tsetl(Tbl *tbl, const char *key, usize klen, void *value);
Tbl *Tset(Tbl *tbl, const char *key, void *value);
-Tbl *Tdell(Tbl *tbl, const char *key, size_t klen);
+Tbl *Tdell(Tbl *tbl, const char *key, usize klen);
Tbl *Tdel(Tbl *tbl, const char *key);
// Deletes an entry from the table as above, and sets *rkey and *rval
// to the removed key and value pointers.
//
-Tbl *Tdelkv(Tbl *tbl, const char *key, size_t klen, const char **rkey, void **rval);
+Tbl *Tdelkv(Tbl *tbl, const char *key, usize klen, const char **rkey, void **rval);
// Find the next item in the table. The p... arguments are in/out
// parameters. To find the first key, pass *pkey=NULL and *pklen=0.
@@ -51,6 +51,6 @@
// updated to the lexicographically following key. Returns false or
// NULL when there are no more keys.
//
-bool Tnextl(Tbl *tbl, const char **pkey, size_t *pklen, void **pvalue);
+bool Tnextl(Tbl *tbl, const char **pkey, usize *pklen, void **pvalue);
bool Tnext(Tbl *tbl, const char **pkey, void **pvalue);
const char *Tnxt(Tbl *tbl, const char *key);
--- a/src/bitvector.c
+++ b/src/bitvector.c
@@ -4,12 +4,12 @@
bitvector_resize(u32int *b, u64int oldsz, u64int newsz, bool zero)
{u32int *p;
- size_t sz = ((newsz+31)>>5) * sizeof(u32int);
+ usize sz = ((newsz+31)>>5) * sizeof(u32int);
p = MEM_REALLOC(b, sz);
if(p == nil)
return nil;
if(zero && newsz > oldsz){- size_t osz = ((oldsz+31)>>5) * sizeof(u32int);
+ usize osz = ((oldsz+31)>>5) * sizeof(u32int);
memset(&p[osz/sizeof(u32int)], 0, sz-osz);
}
return p;
--- a/src/builtins.c
+++ b/src/builtins.c
@@ -8,10 +8,10 @@
#define DBL_MAXINT (1LL<<DBL_MANT_DIG)
#define FLT_MAXINT (1<<FLT_MANT_DIG)
-size_t
-llength(value_t v)
+usize
+llength(sl_v v)
{- size_t n = 0;
+ usize n = 0;
while(iscons(v)){n++;
v = cdr_(v);
@@ -24,9 +24,9 @@
if(nargs == 0)
return sl_nil;
- value_t lst, first = sl_nil;
- value_t *pcdr = &first;
- cons_t *c;
+ sl_v lst, first = sl_nil;
+ sl_v *pcdr = &first;
+ sl_cons *c;
int i = 0;
while(1){@@ -51,9 +51,9 @@
{argcount(nargs, 2);
- value_t item = args[0];
- value_t v = args[1];
- value_t bind;
+ sl_v item = args[0];
+ sl_v v = args[1];
+ sl_v bind;
while(iscons(v)){bind = car_(v);
@@ -69,8 +69,8 @@
{argcount(nargs, 2);
- value_t v;
- cons_t *c;
+ sl_v v;
+ sl_cons *c;
for(v = args[1]; iscons(v); v = c->cdr){if((c = ptr(v))->car == args[0])
return v;
@@ -82,12 +82,12 @@
{argcount(nargs, 1);
- value_t a = args[0];
- cvalue_t *cv;
+ sl_v a = args[0];
+ csl_v *cv;
if(iscons(a)){- size_t n = 0;
- value_t v = a, v2 = a;
+ usize n = 0;
+ sl_v v = a, v2 = a;
do{n++;
v = cdr_(v);
@@ -112,11 +112,11 @@
if(isvector(a))
return size_wrap(vector_size(a));
if(ishashtable(a)){- htable_t *h = totable(a);
+ sl_htable *h = totable(a);
void **t = h->table;
- size_t sz = h->size;
- size_t n = 0;
- for(size_t i = 0; i < sz; i += 2){+ usize sz = h->size;
+ usize n = 0;
+ for(usize i = 0; i < sz; i += 2){if(t[i+1] != HT_NOTFOUND)
n++;
}
@@ -154,7 +154,7 @@
BUILTIN("keyword?", keywordp) {argcount(nargs, 1);
- return (issymbol(args[0]) && iskeyword((symbol_t*)ptr(args[0]))) ? sl_t : sl_nil;
+ return (issymbol(args[0]) && iskeyword((sl_sym*)ptr(args[0]))) ? sl_t : sl_nil;
}
sl_purefn
@@ -161,7 +161,7 @@
BUILTIN("top-level-value", top_level_value) {argcount(nargs, 1);
- symbol_t *sym = tosymbol(args[0]);
+ sl_sym *sym = tosymbol(args[0]);
if(sym->binding == UNBOUND)
unbound_error(args[0]);
return sym->binding;
@@ -170,7 +170,7 @@
BUILTIN("set-top-level-value!", set_top_level_value) {argcount(nargs, 2);
- symbol_t *sym = tosymbol(args[0]);
+ sl_sym *sym = tosymbol(args[0]);
if(!isconstant(sym))
sym->binding = args[1];
return args[1];
@@ -179,7 +179,7 @@
BUILTIN("makunbound", makunbound) {argcount(nargs, 1);
- symbol_t *sym = tosymbol(args[0]);
+ sl_sym *sym = tosymbol(args[0]);
if(!isconstant(sym))
sym->binding = UNBOUND;
return sl_void;
@@ -189,13 +189,13 @@
{USED(args);
argcount(nargs, 0);
- value_t lst = sl_nil;
+ sl_v lst = sl_nil;
sl_gc_handle(&lst);
const char *k = nil;
- symbol_t *v;
+ sl_sym *v;
while(Tnext(SL(symtab), &k, (void**)&v)){if(v->binding != UNBOUND && (v->flags & FLAG_KEYWORD) == 0)
- lst = sl_cons(tagptr(v, TAG_SYM), lst);
+ lst = mk_cons(tagptr(v, TAG_SYM), lst);
}
sl_free_gc_handles(1);
return lst;
@@ -206,7 +206,7 @@
{argcount(nargs, 1);
if(issymbol(args[0]))
- return isconstant((symbol_t*)ptr(args[0])) ? sl_t : sl_nil;
+ return isconstant((sl_sym*)ptr(args[0])) ? sl_t : sl_nil;
if(iscons(args[0])){if(car_(args[0]) == sl_quote)
return sl_t;
@@ -219,11 +219,11 @@
BUILTIN("integer-valued?", integer_valuedp) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(isfixnum(v) || ismp(v))
return sl_t;
if(iscprim(v)){- numerictype_t nt = cp_numtype(ptr(v));
+ sl_numtype nt = cp_numtype(ptr(v));
if(nt < T_FLOAT)
return sl_t;
void *data = cp_data(ptr(v));
@@ -249,7 +249,7 @@
BUILTIN("integer?", integerp) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
return (isfixnum(v) || ismp(v) ||
(iscprim(v) && cp_numtype(ptr(v)) < T_FLOAT)) ?
sl_t : sl_nil;
@@ -265,7 +265,7 @@
BUILTIN("fixnum", fixnum) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(isfixnum(v))
return v;
if(iscprim(v)){@@ -284,13 +284,13 @@
BUILTIN("truncate", truncate) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(isfixnum(v) || ismp(v))
return v;
if(iscprim(v)){- cprim_t *cp = ptr(v);
+ sl_cprim *cp = ptr(v);
void *data = cp_data(cp);
- numerictype_t nt = cp_numtype(cp);
+ sl_numtype nt = cp_numtype(cp);
double d;
if(nt == T_FLOAT)
d = (double)*(float*)data;
@@ -315,11 +315,11 @@
{if(nargs < 1)
argcount(nargs, 1);
- size_t i = tosize(args[0]);
- value_t v = alloc_vector(i, 0);
+ usize i = tosize(args[0]);
+ sl_v v = alloc_vector(i, 0);
int a = 1;
- for(size_t k = 0; k < i; k++){- value_t f = a < nargs ? args[a] : sl_void;
+ for(usize k = 0; k < i; k++){+ sl_v f = a < nargs ? args[a] : sl_void;
vector_elt(v, k) = f;
if((a = (a + 1) % nargs) < 1)
a = 1;
@@ -342,13 +342,13 @@
}
double
-todouble(value_t a)
+todouble(sl_v a)
{if(isfixnum(a))
return (double)numval(a);
if(iscprim(a)){- cprim_t *cp = ptr(a);
- numerictype_t nt = cp_numtype(cp);
+ sl_cprim *cp = ptr(a);
+ sl_numtype nt = cp_numtype(cp);
return conv_to_double(cp_data(cp), nt);
}
if(ismp(a))
--- a/src/cc.h
+++ b/src/cc.h
@@ -14,6 +14,10 @@
typedef int64_t s64int;
typedef intptr_t intptr;
+typedef ssize_t ssize;
+typedef size_t usize;
+typedef off_t soffset;
+
#define sl_unlikely(x) __builtin_expect(!!(x), 0)
#define sl_likely(x) __builtin_expect(!!(x), 1)
#define sl_printfmt(x, y) __attribute__((format(printf, x, y)))
--- a/src/compress.c
+++ b/src/compress.c
@@ -4,7 +4,7 @@
#include "types.h"
#include "brieflz.h"
-static value_t sl_sizesym, sl_tosym;
+static sl_v sl_sizesym, sl_tosym;
BUILTIN("lz-pack", lz_pack) {@@ -16,7 +16,7 @@
if(!isarray(args[0]))
type_error("array", args[0]);u8int *in;
- size_t insz;
+ usize insz;
to_sized_ptr(args[0], &in, &insz);
int level = nargs > 1 ? tofixnum(args[1]) : 0;
if(level < 0)
@@ -24,10 +24,10 @@
else if(level > 10)
level = 10;
- value_t v = cvalue(cv_class(ptr(args[0])), blz_max_packed_size(insz));
+ sl_v v = cvalue(cv_class(ptr(args[0])), blz_max_packed_size(insz));
u8int *out = cvalue_data(v);
- size_t worksz = level > 0
+ usize worksz = level > 0
? blz_workmem_size_level(insz, level)
: blz_workmem_size(insz);
u8int *work = MEM_ALLOC(worksz);
@@ -46,13 +46,13 @@
argcount(nargs, 3);
u8int *in;
- size_t insz;
+ usize insz;
to_sized_ptr(args[0], &in, &insz);
if(!isarray(args[0]))
type_error("array", args[0]);- size_t outsz;
+ usize outsz;
u8int *out;
- value_t v;
+ sl_v v;
if(args[1] == sl_sizesym){outsz = tosize(args[2]);
v = cvalue(cv_class(ptr(args[0])), outsz);
--- a/src/cvalues.c
+++ b/src/cvalues.c
@@ -7,7 +7,7 @@
enum {MAX_INL_SIZE = 384,
- CVALUE_NWORDS = sizeof(cvalue_t)/sizeof(value_t),
+ CVALUE_NWORDS = sizeof(csl_v)/sizeof(sl_v),
CV_OWNED = 1<<0,
};
@@ -15,10 +15,10 @@
#define owned(cv) ((uintptr)(cv)->type & CV_OWNED)
#define isinlined(cv) ((cv)->data == (cv)->_space)
-static void cvalue_init(sltype_t *type, value_t v, void *dest);
+static void cvalue_init(sl_type *type, sl_v v, void *dest);
void
-add_finalizer(cvalue_t *cv)
+add_finalizer(csl_v *cv)
{ if(SL(nfinalizers) == SL(maxfinalizers)){SL(maxfinalizers) *= 2;
@@ -32,9 +32,9 @@
void
sweep_finalizers(void)
{- cvalue_t **lst = SL(finalizers);
- size_t n = 0, ndel = 0, l = SL(nfinalizers);
- cvalue_t *tmp;
+ csl_v **lst = SL(finalizers);
+ usize n = 0, ndel = 0, l = SL(nfinalizers);
+ csl_v *tmp;
#define SWAP_sf(a, b) (tmp = a, a = b, b = tmp, 1)
if(l == 0)
return;
@@ -41,12 +41,12 @@
bool exiting = SL(exiting);
do{tmp = lst[n];
- if(isforwarded((value_t)tmp)){+ if(isforwarded((sl_v)tmp)){// object is alive
- lst[n] = ptr(forwardloc((value_t)tmp));
+ lst[n] = ptr(forwardloc((sl_v)tmp));
n++;
}else{- sltype_t *t = cv_class(tmp);
+ sl_type *t = cv_class(tmp);
if(t->vtable != nil && t->vtable->finalize != nil)
t->vtable->finalize(tagptr(tmp, TAG_CVALUE));
if(!isinlined(tmp) && owned(tmp) && !exiting)
@@ -61,12 +61,12 @@
}
// compute the size of the metadata object for a cvalue
-static size_t
-cv_nwords(cvalue_t *cv)
+static usize
+cv_nwords(csl_v *cv)
{if(!isinlined(cv))
return CVALUE_NWORDS;
- size_t n = cv_len(cv);
+ usize n = cv_len(cv);
if(cv_isstr(cv))
n++;
return CVALUE_NWORDS + NWORDS(n);
@@ -73,24 +73,24 @@
}
void
-cv_autorelease(cvalue_t *cv)
+cv_autorelease(csl_v *cv)
{- cv->type = (sltype_t*)(((uintptr)cv->type) | CV_OWNED);
+ cv->type = (sl_type*)(((uintptr)cv->type) | CV_OWNED);
add_finalizer(cv);
}
-static value_t
-cprim(sltype_t *type, size_t sz)
+static sl_v
+cprim(sl_type *type, usize sz)
{assert(!ismanaged((uintptr)type));
assert(sz == type->size);
- cprim_t *pcp = alloc_words(CPRIM_NWORDS+NWORDS(sz));
+ sl_cprim *pcp = alloc_words(CPRIM_NWORDS+NWORDS(sz));
pcp->type = type;
return tagptr(pcp, TAG_CPRIM);
}
-value_t
-cvalue_(sltype_t *type, size_t sz, bool nofinalize)
+sl_v
+cvalue_(sl_type *type, usize sz, bool nofinalize)
{assert(type != nil);
if(valid_numtype(type->numtype) && type->numtype != T_MP)
@@ -103,9 +103,9 @@
sz++;
str = true;
}
- cvalue_t *pcv;
+ csl_v *pcv;
if(sz <= MAX_INL_SIZE){- size_t nw = CVALUE_NWORDS + NWORDS(sz);
+ usize nw = CVALUE_NWORDS + NWORDS(sz);
pcv = alloc_words(nw);
pcv->type = type;
pcv->data = pcv->_space;
@@ -134,10 +134,10 @@
// user explicitly calls (autorelease ) on the result of this function.
// 'parent' is an optional cvalue that this pointer is known to point
// into; NIL if none.
-value_t
-cvalue_from_ref(sltype_t *type, void *ptr, size_t sz)
+sl_v
+cvalue_from_ref(sl_type *type, void *ptr, usize sz)
{- cvalue_t *pcv;
+ csl_v *pcv;
assert(type != nil);
assert(ptr != nil);
@@ -148,8 +148,8 @@
return tagptr(pcv, TAG_CVALUE);
}
-value_t
-cvalue_string(size_t sz)
+sl_v
+cvalue_string(usize sz)
{if(sz == 0)
return SL(the_empty_string);
@@ -156,7 +156,7 @@
return cvalue(SL(stringtype), sz);
}
-value_t
+sl_v
cvalue_static_cstring(const char *str)
{if(*str == 0)
@@ -164,15 +164,15 @@
return cvalue_from_ref(SL(stringtype), (char*)str, strlen(str));
}
-value_t
-string_from_cstrn(char *str, size_t n)
+sl_v
+string_from_cstrn(char *str, usize n)
{- value_t v = cvalue_string(n);
+ sl_v v = cvalue_string(n);
memcpy(cvalue_data(v), str, n);
return v;
}
-value_t
+sl_v
string_from_cstr(char *str)
{return string_from_cstrn(str, strlen(str));
@@ -179,7 +179,7 @@
}
bool
-sl_isstring(value_t v)
+sl_isstring(sl_v v)
{return iscvalue(v) && cv_isstr(ptr(v));
}
@@ -186,11 +186,11 @@
// convert to malloc representation (fixed address)
void
-cv_pin(cvalue_t *cv)
+cv_pin(csl_v *cv)
{if(!isinlined(cv))
return;
- size_t sz = cv_len(cv);
+ usize sz = cv_len(cv);
if(cv_isstr(cv))
sz++;
void *data = MEM_ALLOC(sz);
@@ -201,7 +201,7 @@
#define num_init(ctype, cnvt, tag) \
static void \
- cvalue_##ctype##_init(sltype_t *type, value_t arg, void *dest) \
+ cvalue_##ctype##_init(sl_type *type, sl_v arg, void *dest) \
{ \ctype n; \
USED(type); \
@@ -208,7 +208,7 @@
if(isfixnum(arg)) \
n = (ctype)numval(arg); \
else if(iscprim(arg)){ \- cprim_t *cp = ptr(arg); \
+ sl_cprim *cp = ptr(arg); \
void *p = cp_data(cp); \
n = (ctype)conv_to_##cnvt(p, cp_numtype(cp)); \
}else if(ismp(arg)){ \@@ -238,15 +238,15 @@
PUSH(fixnum(0)); \
args = SL(sp)-1; \
} \
- value_t cp = cprim(SL(typenam##type), sizeof(ctype)); \
+ sl_v cp = cprim(SL(typenam##type), sizeof(ctype)); \
cvalue_##ctype##_init(SL(typenam##type), args[0], cp_data(ptr(cp))); \
return cp; \
}
#define num_ctor_ctor(typenam, ctype, tag) \
- value_t mk_##typenam(ctype n) \
+ sl_v mk_##typenam(ctype n) \
{ \- value_t cp = cprim(SL(typenam##type), sizeof(ctype)); \
+ sl_v cp = cprim(SL(typenam##type), sizeof(ctype)); \
*(ctype*)cp_data(ptr(cp)) = n; \
return cp; \
}
@@ -269,7 +269,7 @@
num_ctor(rune, u32int, T_U32)
static void
-cvalue_mp_init(sltype_t *type, value_t arg, void *dest)
+cvalue_mp_init(sl_type *type, sl_v arg, void *dest)
{mpint *n;
USED(type);
@@ -276,11 +276,11 @@
if(isfixnum(arg)){n = vtomp(numval(arg), nil);
}else if(iscvalue(arg)){- cvalue_t *cv = ptr(arg);
+ csl_v *cv = ptr(arg);
void *p = cv_data(cv);
n = conv_to_mp(p, cp_numtype(cv));
}else if(iscprim(arg)){- cprim_t *cp = ptr(arg);
+ sl_cprim *cp = ptr(arg);
void *p = cp_data(cp);
n = conv_to_mp(p, cp_numtype(cp));
}else
@@ -294,22 +294,22 @@
PUSH(fixnum(0));
args = SL(sp)-1;
}
- value_t cv = cvalue(SL(mptype), sizeof(mpint*));
+ sl_v cv = cvalue(SL(mptype), sizeof(mpint*));
cvalue_mp_init(SL(mptype), args[0], cvalue_data(cv));
return cv;
}
-value_t
+sl_v
mk_mp(mpint *n)
{- value_t cv = cvalue(SL(mptype), sizeof(mpint*));
+ sl_v cv = cvalue(SL(mptype), sizeof(mpint*));
*(mpint**)cvalue_data(cv) = n;
return cv;
}
static void
-free_mp(value_t self)
+free_mp(sl_v self)
{mpint **s = value2c(mpint**, self);
if(*s != mpzero && *s != mpone && *s != mptwo)
@@ -316,25 +316,25 @@
mpfree(*s);
}
-static cvtable_t mp_vtable = { nil, nil, free_mp, nil };+static sl_cvtable mp_vtable = { nil, nil, free_mp, nil };-value_t
-size_wrap(size_t sz)
+sl_v
+size_wrap(usize sz)
{- if(sizeof(size_t) == 8)
+ if(sizeof(usize) == 8)
return fits_fixnum(sz) ? fixnum(sz): mk_u64(sz);
else
return fits_fixnum(sz) ? fixnum(sz): mk_u32(sz);
}
-size_t
-tosize(value_t n)
+usize
+tosize(sl_v n)
{if(isfixnum(n))
- return (size_t)numval(n);
+ return (usize)numval(n);
if(iscprim(n)){- cprim_t *cp = ptr(n);
- if(sizeof(size_t) == 8)
+ sl_cprim *cp = ptr(n);
+ if(sizeof(usize) == 8)
return conv_to_u64(cp_data(cp), cp_numtype(cp));
return conv_to_u32(cp_data(cp), cp_numtype(cp));
}
@@ -341,13 +341,13 @@
type_error("number", n);}
-off_t
-tooffset(value_t n)
+soffset
+tooffset(sl_v n)
{if(isfixnum(n))
return numval(n);
if(iscprim(n)){- cprim_t *cp = ptr(n);
+ sl_cprim *cp = ptr(n);
return conv_to_s64(cp_data(cp), cp_numtype(cp));
}
type_error("number", n);@@ -354,13 +354,13 @@
}
bool
-isarray(value_t v)
+isarray(sl_v v)
{return iscvalue(v) && cv_class(ptr(v))->eltype != nil;
}
-static size_t
-predict_arraylen(value_t arg)
+static usize
+predict_arraylen(sl_v arg)
{if(isvector(arg))
return vector_size(arg);
@@ -374,17 +374,17 @@
}
void
-cvalue_array_init(sltype_t *ft, value_t arg, void *dest)
+cvalue_array_init(sl_type *ft, sl_v arg, void *dest)
{- value_t type = ft->type;
- size_t elsize, i, cnt, sz;
- sltype_t *eltype = ft->eltype;
+ sl_v type = ft->type;
+ usize elsize, i, cnt, sz;
+ sl_type *eltype = ft->eltype;
elsize = ft->elsz;
cnt = predict_arraylen(arg);
if(iscons(cdr_(cdr_(type)))){- size_t tc = tosize(car_(cdr_(cdr_(type))));
+ usize tc = tosize(car_(cdr_(cdr_(type))));
if(tc != cnt)
lerrorf(sl_errarg, "size mismatch");
}
@@ -416,9 +416,9 @@
return;
}
if(iscvalue(arg)){- cvalue_t *cv = ptr(arg);
+ csl_v *cv = ptr(arg);
if(isarray(arg)){- sltype_t *aet = cv_class(cv)->eltype;
+ sl_type *aet = cv_class(cv)->eltype;
if(aet == eltype){if(cv_len(cv) == sz)
memcpy(dest, cv_data(cv), sz);
@@ -438,18 +438,18 @@
BUILTIN("array", array) {- size_t elsize, cnt, sz;
- value_t arg;
+ usize elsize, cnt, sz;
+ sl_v arg;
if(nargs < 1)
argcount(nargs, 1);
cnt = nargs - 1;
- sltype_t *type = get_array_type(args[0]);
+ sl_type *type = get_array_type(args[0]);
elsize = type->elsz;
sz = elsize * cnt;
- value_t cv = cvalue(type, sz);
+ sl_v cv = cvalue(type, sz);
char *dest = cvalue_data(cv);
int i;
FOR_ARGS(i, 1, arg, args){@@ -463,7 +463,7 @@
BUILTIN("array-alloc", array_alloc) {- size_t elsize, sz;
+ usize elsize, sz;
long i, cnt, a;
if(nargs < 3)
@@ -472,15 +472,15 @@
if(cnt < 0)
lerrorf(sl_errarg, "invalid size: %"PRIu64, (u64int)cnt);
- sltype_t *type = get_array_type(args[0]);
+ sl_type *type = get_array_type(args[0]);
elsize = type->elsz;
sz = elsize * cnt;
- value_t cv = cvalue(type, sz);
+ sl_v cv = cvalue(type, sz);
char *dest = cvalue_data(cv);
a = 2;
for(i = 0; i < cnt; i++){- value_t arg = args[a];
+ sl_v arg = args[a];
if(!sl_isnumber(arg))
type_error("number", arg);cvalue_init(type->eltype, arg, dest);
@@ -492,29 +492,29 @@
}
// NOTE: v must be an array
-size_t
-cvalue_arraylen(value_t v)
+usize
+cvalue_arraylen(sl_v v)
{- cvalue_t *cv = ptr(v);
+ csl_v *cv = ptr(v);
return cv_len(cv)/cv_class(cv)->elsz;
}
-size_t
-ctype_sizeof(value_t type)
+usize
+ctype_sizeof(sl_v type)
{- symbol_t *s;
+ sl_sym *s;
if(issymbol(type) && (s = ptr(type)) != nil && valid_numtype(s->numtype))
return s->size;
if(iscons(type)){- value_t hed = car_(type);
+ sl_v hed = car_(type);
if(hed == sl_arraysym){- value_t t = car(cdr_(type));
+ sl_v t = car(cdr_(type));
if(!iscons(cdr_(cdr_(type))))
lerrorf(sl_errarg, "incomplete type");
- value_t n = car_(cdr_(cdr_(type)));
- size_t sz = tosize(n);
+ sl_v n = car_(cdr_(cdr_(type)));
+ usize sz = tosize(n);
return sz * ctype_sizeof(t);
}
}
@@ -524,11 +524,11 @@
// get pointer and size for any plain-old-data value
void
-to_sized_ptr(value_t v, u8int **pdata, size_t *psz)
+to_sized_ptr(sl_v v, u8int **pdata, usize *psz)
{ if(iscvalue(v)){- cvalue_t *pcv = ptr(v);
- ios_t *x = value2c(ios_t*, v);
+ csl_v *pcv = ptr(v);
+ sl_ios *x = value2c(sl_ios*, v);
if(cv_class(pcv) == SL(iostreamtype) && x->bm == bm_mem){*pdata = x->buf;
*psz = x->size;
@@ -541,7 +541,7 @@
}
}
if(iscprim(v)){- cprim_t *pcp = ptr(v);
+ sl_cprim *pcp = ptr(v);
*pdata = cp_data(pcp);
*psz = cp_class(pcp)->size;
return;
@@ -554,7 +554,7 @@
argcount(nargs, 1);
if(issymbol(args[0]) || iscons(args[0]))
return size_wrap(ctype_sizeof(args[0]));
- size_t n;
+ usize n;
u8int *data;
to_sized_ptr(args[0], &data, &n);
return size_wrap(n);
@@ -585,21 +585,21 @@
return cv_type(ptr(args[0]));
}
-value_t
-cvalue_relocate(value_t v)
+sl_v
+cvalue_relocate(sl_v v)
{- size_t nw;
- cvalue_t *cv = ptr(v);
- cvalue_t *nv;
- value_t ncv;
+ usize nw;
+ csl_v *cv = ptr(v);
+ csl_v *nv;
+ sl_v ncv;
nw = cv_nwords(cv);
nv = alloc_words(nw);
- memcpy(nv, cv, nw*sizeof(value_t));
+ memcpy(nv, cv, nw*sizeof(sl_v));
if(isinlined(cv))
nv->data = nv->_space;
ncv = tagptr(nv, TAG_CVALUE);
- sltype_t *t = cv_class(cv);
+ sl_type *t = cv_class(cv);
if(t->vtable != nil && t->vtable->relocate != nil)
t->vtable->relocate(v, ncv);
forward(v, ncv);
@@ -608,19 +608,19 @@
return ncv;
}
-value_t
-cvalue_copy(value_t v)
+sl_v
+cvalue_copy(sl_v v)
{assert(iscvalue(v));
PUSH(v);
- cvalue_t *cv = ptr(v);
- size_t nw = cv_nwords(cv);
- cvalue_t *ncv = alloc_words(nw);
+ csl_v *cv = ptr(v);
+ usize nw = cv_nwords(cv);
+ csl_v *ncv = alloc_words(nw);
v = POP();
cv = ptr(v);
- memcpy(ncv, cv, nw * sizeof(value_t));
+ memcpy(ncv, cv, nw * sizeof(sl_v));
if(!isinlined(cv)){- size_t len = cv_len(cv);
+ usize len = cv_len(cv);
if(cv_isstr(cv))
len++;
ncv->data = MEM_ALLOC(len);
@@ -655,7 +655,7 @@
}
static void
-cvalue_init(sltype_t *type, value_t v, void *dest)
+cvalue_init(sl_type *type, sl_v v, void *dest)
{cvinitfunc_t f = type->init;
if(f == nil)
@@ -671,13 +671,13 @@
{if(nargs < 1 || nargs > 2)
argcount(nargs, 2);
- value_t type = args[0];
- sltype_t *ft = get_type(type);
- value_t cv;
+ sl_v type = args[0];
+ sl_type *ft = get_type(type);
+ sl_v cv;
if(ft->eltype != nil){// special case to handle incomplete array types bla[]
- size_t elsz = ft->elsz;
- size_t cnt;
+ usize elsz = ft->elsz;
+ usize cnt;
if(iscons(cdr_(cdr_(type))))
cnt = tosize(car_(cdr_(cdr_(type))));
@@ -697,16 +697,16 @@
}
// NOTE: this only compares lexicographically; it ignores numeric formats
-value_t
-cvalue_compare(value_t a, value_t b)
+sl_v
+cvalue_compare(sl_v a, sl_v b)
{- cvalue_t *ca = ptr(a);
- cvalue_t *cb = ptr(b);
+ csl_v *ca = ptr(a);
+ csl_v *cb = ptr(b);
char *adata = cv_data(ca);
char *bdata = cv_data(cb);
- size_t asz = cv_len(ca);
- size_t bsz = cv_len(cb);
- size_t minsz = asz < bsz ? asz : bsz;
+ usize asz = cv_len(ca);
+ usize bsz = cv_len(cb);
+ usize minsz = asz < bsz ? asz : bsz;
int diff = memcmp(adata, bdata, minsz);
if(diff == 0){if(asz > bsz)
@@ -718,10 +718,10 @@
}
static void
-check_addr_args(value_t arr, value_t ind, u8int **data, int *index)
+check_addr_args(sl_v arr, sl_v ind, u8int **data, int *index)
{int numel;
- cvalue_t *cv = ptr(arr);
+ csl_v *cv = ptr(arr);
*data = cv_data(cv);
numel = cv_len(cv)/cv_class(cv)->elsz;
*index = tosize(ind);
@@ -729,14 +729,14 @@
bounds_error(arr, ind);
}
-value_t
-cvalue_array_aref(value_t *args)
+sl_v
+cvalue_array_aref(sl_v *args)
{u8int *data;
int index;
- sltype_t *eltype = cv_class(ptr(args[0]))->eltype;
- value_t el = 0;
- numerictype_t nt = eltype->numtype;
+ sl_type *eltype = cv_class(ptr(args[0]))->eltype;
+ sl_v el = 0;
+ sl_numtype nt = eltype->numtype;
if(nt >= T_S32)
el = cvalue(eltype, eltype->size);
check_addr_args(args[0], args[1], &data, &index);
@@ -750,7 +750,7 @@
return fixnum(((u16int*)data)[index]);
}
u8int *dest = cptr(el);
- size_t sz = eltype->size;
+ usize sz = eltype->size;
if(sz == 1)
*dest = data[index];
else if(sz == 2)
@@ -764,11 +764,11 @@
return el;
}
-value_t
-cvalue_array_aset(value_t *args)
+sl_v
+cvalue_array_aset(sl_v *args)
{u8int *data; int index;
- sltype_t *eltype = cv_class(ptr(args[0]))->eltype;
+ sl_type *eltype = cv_class(ptr(args[0]))->eltype;
check_addr_args(args[0], args[1], &data, &index);
u8int *dest = data + index*eltype->size;
cvalue_init(eltype, args[2], dest);
@@ -779,23 +779,23 @@
BUILTIN("builtin", builtin) {argcount(nargs, 1);
- symbol_t *s = tosymbol(args[0]);
+ sl_sym *s = tosymbol(args[0]);
if(!iscbuiltin(s->binding))
lerrorf(sl_errarg, "function \"%s\" not found", s->name);
return s->binding;
}
-value_t
+sl_v
cbuiltin(const char *name, builtin_t f)
{- cvalue_t *cv;
+ csl_v *cv;
cv = MEM_CALLOC(CVALUE_NWORDS-1, sizeof(*cv));
assert(cv != nil);
cv->type = SL(builtintype);
cv->cbuiltin = f;
- value_t sym = symbol(name, false);
- symbol_t *s = ptr(sym);
+ sl_v sym = symbol(name, false);
+ sl_sym *s = ptr(sym);
s->binding = tagptr(cv, TAG_CVALUE);
ptrhash_put(&SL(reverse_dlsym_lookup_table), cv, (void*)sym);
@@ -809,7 +809,7 @@
#define ctor_cv_intern(tok, nt, ctype) \
do{ \- symbol_t *s; \
+ sl_sym *s; \
cv_intern(tok); \
set(sl_##tok##sym, cbuiltin(#tok, fn_builtin_##tok)); \
if(valid_numtype(nt)){ \@@ -827,11 +827,11 @@
#define RETURN_NUM_AS(var, type) return(mk_##type(var))
-value_t
+sl_v
return_from_u64(u64int Uaccum)
{if(fits_fixnum(Uaccum))
- return fixnum((fixnum_t)Uaccum);
+ return fixnum((sl_fx)Uaccum);
if(Uaccum > (u64int)INT64_MAX)
RETURN_NUM_AS(Uaccum, u64);
if(Uaccum > (u64int)UINT32_MAX)
@@ -841,11 +841,11 @@
RETURN_NUM_AS(Uaccum, s32);
}
-value_t
+sl_v
return_from_s64(s64int Saccum)
{if(fits_fixnum(Saccum))
- return fixnum((fixnum_t)Saccum);
+ return fixnum((sl_fx)Saccum);
RETURN_NUM_AS(vtomp(Saccum, nil), mp);
}
@@ -853,8 +853,8 @@
#define ARITH_OP(a, b) (a)+(b)
#define MP_OP mpadd
#define ARITH_OVERFLOW sadd_overflow_64
-value_t
-sl_add_any(value_t *args, u32int nargs)
+sl_v
+sl_add_any(sl_v *args, u32int nargs)
{#include "sl_arith_any.inc"
}
@@ -863,20 +863,20 @@
#define ARITH_OP(a, b) (a)*(b)
#define MP_OP mpmul
#define ARITH_OVERFLOW smul_overflow_64
-value_t
-sl_mul_any(value_t *args, u32int nargs)
+sl_v
+sl_mul_any(sl_v *args, u32int nargs)
{#include "sl_arith_any.inc"
}
-value_t
-sl_neg(value_t n)
+sl_v
+sl_neg(sl_v n)
{s64int i64;
u64int ui64;
mpint *mp;
- numerictype_t pt;
- fixnum_t pi;
+ sl_numtype pt;
+ sl_fx pi;
void *a;
if(num_to_ptr(n, &pi, &pt, &a)){@@ -883,10 +883,10 @@
switch(pt){case T_DOUBLE: return mk_double(-*(double*)a);
case T_FLOAT: return mk_float(-*(float*)a);
- case T_S8: return fixnum(-(fixnum_t)*(s8int*)a);
- case T_U8: return fixnum(-(fixnum_t)*(u8int*)a);
- case T_S16: return fixnum(-(fixnum_t)*(s16int*)a);
- case T_U16: return fixnum(-(fixnum_t)*(u16int*)a);
+ case T_S8: return fixnum(-(sl_fx)*(s8int*)a);
+ case T_U8: return fixnum(-(sl_fx)*(u8int*)a);
+ case T_S16: return fixnum(-(sl_fx)*(s16int*)a);
+ case T_U16: return fixnum(-(sl_fx)*(u16int*)a);
case T_U32:
i64 = -(s64int)*(u32int*)a;
goto i64neg;
@@ -920,10 +920,10 @@
}
bool
-num_to_ptr(value_t a, fixnum_t *pi, numerictype_t *pt, void **pp)
+num_to_ptr(sl_v a, sl_fx *pi, sl_numtype *pt, void **pp)
{- cprim_t *cp;
- cvalue_t *cv;
+ sl_cprim *cp;
+ csl_v *cv;
if(isfixnum(a)){*pi = numval(a);
*pp = pi;
@@ -952,10 +952,10 @@
typeerr: if not 0, throws type errors, else returns 2 for type errors
*/
int
-numeric_compare(value_t a, value_t b, bool eq, bool eqnans, bool typeerr)
+numeric_compare(sl_v a, sl_v b, bool eq, bool eqnans, bool typeerr)
{- fixnum_t ai, bi;
- numerictype_t ta, tb;
+ sl_fx ai, bi;
+ sl_numtype ta, tb;
void *aptr, *bptr;
if(bothfixnums(a, b)){@@ -992,12 +992,12 @@
lerrorf(sl_errdiv0, "/: division by zero");
}
-value_t
-sl_div2(value_t a, value_t b)
+sl_v
+sl_div2(sl_v a, sl_v b)
{double da, db;
- fixnum_t ai, bi;
- numerictype_t ta, tb;
+ sl_fx ai, bi;
+ sl_numtype ta, tb;
void *aptr, *bptr;
if(!num_to_ptr(a, &ai, &ta, &aptr))
@@ -1018,11 +1018,11 @@
return mk_double(da);
}
-value_t
-sl_idiv2(value_t a, value_t b)
+sl_v
+sl_idiv2(sl_v a, sl_v b)
{- fixnum_t ai, bi;
- numerictype_t ta, tb;
+ sl_fx ai, bi;
+ sl_numtype ta, tb;
void *aptr, *bptr;
s64int a64, b64;
mpint *x;
@@ -1079,11 +1079,11 @@
divide_by_0_error();
}
-static value_t
-sl_bitwise_op(value_t a, value_t b, int opcode)
+static sl_v
+sl_bitwise_op(sl_v a, sl_v b, int opcode)
{- fixnum_t ai, bi;
- numerictype_t ta, tb, itmp;
+ sl_fx ai, bi;
+ sl_numtype ta, tb, itmp;
void *aptr = nil, *bptr = nil, *ptmp;
mpint *bmp = nil, *resmp = nil;
s64int b64;
@@ -1161,7 +1161,7 @@
BUILTIN("logand", logand) {- value_t v, e;
+ sl_v v, e;
if(nargs == 0)
return fixnum(-1);
v = args[0];
@@ -1177,7 +1177,7 @@
BUILTIN("logior", logior) {- value_t v, e;
+ sl_v v, e;
if(nargs == 0)
return fixnum(0);
v = args[0];
@@ -1193,7 +1193,7 @@
BUILTIN("logxor", logxor) {- value_t v, e;
+ sl_v v, e;
if(nargs == 0)
return fixnum(0);
v = args[0];
@@ -1210,8 +1210,8 @@
BUILTIN("lognot", lognot) {argcount(nargs, 1);
- value_t a = args[0];
- cprim_t *cp;
+ sl_v a = args[0];
+ sl_cprim *cp;
int ta;
void *aptr;
@@ -1233,7 +1233,7 @@
}
}
if(iscvalue(a)){- cvalue_t *cv = ptr(a);
+ csl_v *cv = ptr(a);
ta = cp_numtype(cv);
aptr = cv_data(cv);
if(ta == T_MP){@@ -1247,15 +1247,15 @@
BUILTIN("ash", ash) {- fixnum_t n;
+ sl_fx n;
s64int accum;
- cprim_t *cp;
+ sl_cprim *cp;
int ta;
mpint *mp;
void *aptr;
argcount(nargs, 2);
- value_t a = args[0];
+ sl_v a = args[0];
n = tofixnum(args[1]);
if(isfixnum(a)){if(n <= 0)
@@ -1325,10 +1325,10 @@
ctor_cv_intern(array, NONNUMERIC, int);
sl_stringtypesym = csymbol("*string-type*");- setc(sl_stringtypesym, sl_list2(sl_arraysym, sl_bytesym));
+ setc(sl_stringtypesym, mk_list2(sl_arraysym, sl_bytesym));
sl_runestringtypesym = csymbol("*runestring-type*");- setc(sl_runestringtypesym, sl_list2(sl_arraysym, sl_runesym));
+ setc(sl_runestringtypesym, mk_list2(sl_arraysym, sl_runesym));
mk_primtype(s8, s8int);
mk_primtype(u8, u8int);
--- a/src/cvalues.h
+++ b/src/cvalues.h
@@ -6,51 +6,51 @@
#define NWORDS(sz) (((sz)+3)>>2)
#endif
-void add_finalizer(cvalue_t *cv);
+void add_finalizer(csl_v *cv);
void sweep_finalizers(void);
-void cv_autorelease(cvalue_t *cv);
-value_t cvalue_(sltype_t *type, size_t sz, bool nofinalizer);
+void cv_autorelease(csl_v *cv);
+sl_v cvalue_(sl_type *type, usize sz, bool nofinalizer);
#define cvalue(type, sz) cvalue_(type, sz, false)
#define cvalue_nofinalizer(type, sz) cvalue_(type, sz, true)
-value_t cvalue_from_ref(sltype_t *type, void *ptr, size_t sz);
-value_t cvalue_string(size_t sz);
-value_t cvalue_static_cstring(const char *str);
-value_t string_from_cstrn(char *str, size_t n);
-value_t string_from_cstr(char *str);
-bool sl_isstring(value_t v) sl_purefn;
-void cv_pin(cvalue_t *cv);
-value_t size_wrap(size_t sz);
-size_t tosize(value_t n);
-off_t tooffset(value_t n);
-bool isarray(value_t v) sl_purefn;
-void cvalue_array_init(sltype_t *ft, value_t arg, void *dest);
-size_t cvalue_arraylen(value_t v) sl_purefn;
-size_t ctype_sizeof(value_t type);
-void to_sized_ptr(value_t v, u8int **pdata, size_t *psz);
-value_t cvalue_relocate(value_t v);
-value_t cvalue_copy(value_t v);
-value_t cvalue_compare(value_t a, value_t b) sl_purefn;
-value_t cvalue_array_aref(value_t *args);
-value_t cvalue_array_aset(value_t *args);
-value_t cbuiltin(const char *name, builtin_t f);
-value_t return_from_u64(u64int Uaccum);
-value_t return_from_s64(s64int Saccum);
-value_t sl_add_any(value_t *args, u32int nargs);
-value_t sl_neg(value_t n);
-value_t sl_mul_any(value_t *args, u32int nargs);
-bool num_to_ptr(value_t a, fixnum_t *pi, numerictype_t *pt, void **pp);
+sl_v cvalue_from_ref(sl_type *type, void *ptr, usize sz);
+sl_v cvalue_string(usize sz);
+sl_v cvalue_static_cstring(const char *str);
+sl_v string_from_cstrn(char *str, usize n);
+sl_v string_from_cstr(char *str);
+bool sl_isstring(sl_v v) sl_purefn;
+void cv_pin(csl_v *cv);
+sl_v size_wrap(usize sz);
+usize tosize(sl_v n);
+soffset tooffset(sl_v n);
+bool isarray(sl_v v) sl_purefn;
+void cvalue_array_init(sl_type *ft, sl_v arg, void *dest);
+usize cvalue_arraylen(sl_v v) sl_purefn;
+usize ctype_sizeof(sl_v type);
+void to_sized_ptr(sl_v v, u8int **pdata, usize *psz);
+sl_v cvalue_relocate(sl_v v);
+sl_v cvalue_copy(sl_v v);
+sl_v cvalue_compare(sl_v a, sl_v b) sl_purefn;
+sl_v cvalue_array_aref(sl_v *args);
+sl_v cvalue_array_aset(sl_v *args);
+sl_v cbuiltin(const char *name, builtin_t f);
+sl_v return_from_u64(u64int Uaccum);
+sl_v return_from_s64(s64int Saccum);
+sl_v sl_add_any(sl_v *args, u32int nargs);
+sl_v sl_neg(sl_v n);
+sl_v sl_mul_any(sl_v *args, u32int nargs);
+bool num_to_ptr(sl_v a, sl_fx *pi, sl_numtype *pt, void **pp);
_Noreturn void divide_by_0_error(void);
-value_t sl_div2(value_t a, value_t b);
-value_t sl_idiv2(value_t a, value_t b);
+sl_v sl_div2(sl_v a, sl_v b);
+sl_v sl_idiv2(sl_v a, sl_v b);
void cvalues_init(void);
-value_t mk_double(double n);
-value_t mk_float(float n);
-value_t mk_s32(s32int n);
-value_t mk_u32(u32int n);
-value_t mk_s64(s64int n);
-value_t mk_u64(u64int n);
-value_t mk_rune(Rune n);
-value_t mk_mp(mpint *n);
+sl_v mk_double(double n);
+sl_v mk_float(float n);
+sl_v mk_s32(s32int n);
+sl_v mk_u32(u32int n);
+sl_v mk_s64(s64int n);
+sl_v mk_u64(u64int n);
+sl_v mk_rune(Rune n);
+sl_v mk_mp(mpint *n);
-size_t llength(value_t v) sl_purefn;
+usize llength(sl_v v) sl_purefn;
--- a/src/equal.c
+++ b/src/equal.c
@@ -8,7 +8,7 @@
#define BOUNDED_HASH_BOUND 16384
#if defined(BITS64)
-#define MIX(a, b) inthash((value_t)(a) ^ (value_t)(b));
+#define MIX(a, b) inthash((sl_v)(a) ^ (sl_v)(b));
#define doublehash(a) inthash(a)
#else
#define MIX(a, b) int64to32hash((u64int)(a)<<32 | (u64int)(b));
@@ -18,11 +18,11 @@
// comparable tag
#define cmptag(v) (isfixnum(v) ? TAG_NUM : tag(v))
-static value_t
-eq_class(htable_t *table, value_t key)
+static sl_v
+eq_class(sl_htable *table, sl_v key)
{- value_t c = (value_t)ptrhash_get(table, (void*)key);
- if(c == (value_t)HT_NOTFOUND)
+ sl_v c = (sl_v)ptrhash_get(table, (void*)key);
+ if(c == (sl_v)HT_NOTFOUND)
return sl_nil;
if(c == key)
return c;
@@ -30,9 +30,9 @@
}
static void
-eq_union(htable_t *table, value_t a, value_t b, value_t c, value_t cb)
+eq_union(sl_htable *table, sl_v a, sl_v b, sl_v c, sl_v cb)
{- value_t ca = c == sl_nil ? a : c;
+ sl_v ca = c == sl_nil ? a : c;
if(cb != sl_nil)
ptrhash_put(table, (void*)cb, (void*)ca);
ptrhash_put(table, (void*)a, (void*)ca);
@@ -39,20 +39,20 @@
ptrhash_put(table, (void*)b, (void*)ca);
}
-static value_t bounded_compare(value_t a, value_t b, int bound, bool eq);
-static value_t cyc_compare(value_t a, value_t b, htable_t *table, bool eq);
+static sl_v bounded_compare(sl_v a, sl_v b, int bound, bool eq);
+static sl_v cyc_compare(sl_v a, sl_v b, sl_htable *table, bool eq);
-static value_t
-bounded_vector_compare(value_t a, value_t b, int bound, bool eq)
+static sl_v
+bounded_vector_compare(sl_v a, sl_v b, int bound, bool eq)
{- size_t la = vector_size(a);
- size_t lb = vector_size(b);
- size_t m, i;
+ usize la = vector_size(a);
+ usize lb = vector_size(b);
+ usize m, i;
if(eq && la != lb)
return fixnum(1);
m = la < lb ? la : lb;
for(i = 0; i < m; i++){- value_t d = bounded_compare(vector_elt(a, i), vector_elt(b, i), bound-1, eq);
+ sl_v d = bounded_compare(vector_elt(a, i), vector_elt(b, i), bound-1, eq);
if(d == sl_nil || numval(d) != 0)
return d;
}
@@ -65,11 +65,11 @@
// strange comparisons are resolved arbitrarily but consistently.
// ordering: number < cprim < function < vector < cvalue < symbol < cons
-static value_t
-bounded_compare(value_t a, value_t b, int bound, bool eq)
+static sl_v
+bounded_compare(sl_v a, sl_v b, int bound, bool eq)
{- value_t d;
- cvalue_t *cv;
+ sl_v d;
+ csl_v *cv;
compare_top:
if(a == b)
@@ -83,7 +83,7 @@
case TAG_NUM :
case TAG_NUM1:
if(isfixnum(b))
- return (fixnum_t)a < (fixnum_t)b ? fixnum(-1) : fixnum(1);
+ return (sl_fx)a < (sl_fx)b ? fixnum(-1) : fixnum(1);
if(iscprim(b)){if(cp_class(ptr(b)) == SL(runetype))
return fixnum(1);
@@ -130,8 +130,8 @@
case TAG_FUNCTION:
if(tagb == TAG_FUNCTION){ if(uintval(a) > N_BUILTINS && uintval(b) > N_BUILTINS){- function_t *fa = ptr(a);
- function_t *fb = ptr(b);
+ sl_fn *fa = ptr(a);
+ sl_fn *fb = ptr(b);
d = bounded_compare(fa->bcode, fb->bcode, bound-1, eq);
if(d == sl_nil || numval(d) != 0)
return d;
@@ -159,13 +159,13 @@
return taga < tagb ? fixnum(-1) : fixnum(1);
}
-static value_t
-cyc_vector_compare(value_t a, value_t b, htable_t *table, bool eq)
+static sl_v
+cyc_vector_compare(sl_v a, sl_v b, sl_htable *table, bool eq)
{- size_t la = vector_size(a);
- size_t lb = vector_size(b);
- size_t m, i;
- value_t d, xa, xb, ca, cb;
+ usize la = vector_size(a);
+ usize lb = vector_size(b);
+ usize m, i;
+ sl_v d, xa, xb, ca, cb;
// first try to prove them different with no recursion
if(eq && la != lb)
@@ -208,19 +208,19 @@
return fixnum(0);
}
-static value_t
-cyc_compare(value_t a, value_t b, htable_t *table, bool eq)
+static sl_v
+cyc_compare(sl_v a, sl_v b, sl_htable *table, bool eq)
{- value_t d, ca, cb;
+ sl_v d, ca, cb;
cyc_compare_top:
if(a == b)
return fixnum(0);
if(iscons(a)){ if(iscons(b)){- value_t aa = car_(a);
- value_t da = cdr_(a);
- value_t ab = car_(b);
- value_t db = cdr_(b);
+ sl_v aa = car_(a);
+ sl_v da = cdr_(a);
+ sl_v ab = car_(b);
+ sl_v db = cdr_(b);
int tagaa = tag(aa);
int tagda = tag(da);
int tagab = tag(ab);
@@ -263,8 +263,8 @@
if(isvector(a) && isvector(b))
return cyc_vector_compare(a, b, table, eq);
if(isfunction(a) && isfunction(b)){- function_t *fa = ptr(a);
- function_t *fb = ptr(b);
+ sl_fn *fa = ptr(a);
+ sl_fn *fb = ptr(b);
d = bounded_compare(fa->bcode, fb->bcode, 1, eq);
if(numval(d) != 0)
return d;
@@ -285,7 +285,7 @@
return bounded_compare(a, b, 1, eq);
}
-static htable_t equal_eq_hashtable;
+static sl_htable equal_eq_hashtable;
void
comparehash_init(void)
@@ -294,10 +294,10 @@
}
// 'eq' means unordered comparison is sufficient
-value_t
-sl_compare(value_t a, value_t b, bool eq)
+sl_v
+sl_compare(sl_v a, sl_v b, bool eq)
{- value_t guess = bounded_compare(a, b, BOUNDED_COMPARE_BOUND, eq);
+ sl_v guess = bounded_compare(a, b, BOUNDED_COMPARE_BOUND, eq);
if(guess == sl_nil){guess = cyc_compare(a, b, &equal_eq_hashtable, eq);
htable_reset(&equal_eq_hashtable, 512);
@@ -315,16 +315,16 @@
// *oob: output argument, means we hit the limit specified by 'bound'
static uintptr
-bounded_hash(value_t a, int bound, bool *oob)
+bounded_hash(sl_v a, int bound, bool *oob)
{ union {double d;
s64int i64;
}u;
- numerictype_t nt;
- size_t i, len;
- cvalue_t *cv;
- cprim_t *cp;
+ sl_numtype nt;
+ usize i, len;
+ csl_v *cv;
+ sl_cprim *cp;
void *data;
uintptr h = 0;
int tg = tag(a);
@@ -338,10 +338,10 @@
return doublehash(u.i64);
case TAG_FUNCTION:
if(uintval(a) > N_BUILTINS)
- return bounded_hash(((function_t*)ptr(a))->bcode, bound, oob);
+ return bounded_hash(((sl_fn*)ptr(a))->bcode, bound, oob);
return inthash(a);
case TAG_SYM:
- return ((symbol_t*)ptr(a))->hash;
+ return ((sl_sym*)ptr(a))->hash;
case TAG_CPRIM:
cp = ptr(a);
data = cp_data(cp);
@@ -402,7 +402,7 @@
}
int
-equal_lispvalue(value_t a, value_t b)
+equal_lispvalue(sl_v a, sl_v b)
{if(eq_comparable(a, b))
return a == b;
@@ -410,7 +410,7 @@
}
uintptr
-hash_lispvalue(value_t a)
+hash_lispvalue(sl_v a)
{bool oob = false;
return bounded_hash(a, BOUNDED_HASH_BOUND, &oob);
--- a/src/equal.h
+++ b/src/equal.h
@@ -4,8 +4,8 @@
#define eq_comparable(a, b) (!(((a)|(b))&1))
#define eq_comparablep(a) (!((a)&1)) /* mag: UNUSED? */
-int equal_lispvalue(value_t a, value_t b);
-uintptr hash_lispvalue(value_t a);
-value_t sl_compare(value_t a, value_t b, bool eq);
-int numeric_compare(value_t a, value_t b, bool eq, bool eqnans, bool typeerr);
+int equal_lispvalue(sl_v a, sl_v b);
+uintptr hash_lispvalue(sl_v a);
+sl_v sl_compare(sl_v a, sl_v b, bool eq);
+int numeric_compare(sl_v a, sl_v b, bool eq, bool eqnans, bool typeerr);
void comparehash_init(void);
--- a/src/equalhash.c
+++ b/src/equalhash.c
@@ -3,7 +3,7 @@
#include "equal.h"
#define HTNAME(suffix) equalhash##suffix
-#define HFUNC(v) hash_lispvalue((value_t)(v))
-#define EQFUNC(x, y) equal_lispvalue((value_t)(x), (value_t)(y))
+#define HFUNC(v) hash_lispvalue((sl_v)(v))
+#define EQFUNC(x, y) equal_lispvalue((sl_v)(x), (sl_v)(y))
#include "htable.inc"
--- a/src/hashing.c
+++ b/src/hashing.c
@@ -2,8 +2,8 @@
#include "hashing.h"
#include "spooky.h"
-value_t
-inthash(value_t a)
+sl_v
+inthash(sl_v a)
{#if defined(BITS64)
a = (~a) + (a << 21); // a = (a << 21) - a - 1;
@@ -39,7 +39,7 @@
#endif
u64int
-memhash(const char *buf, size_t n)
+memhash(const char *buf, usize n)
{return spooky_hash64(buf, n, 0xcafe8881ULL);
}
--- a/src/hashing.h
+++ b/src/hashing.h
@@ -1,5 +1,5 @@
#pragma once
-value_t inthash(value_t a) sl_constfn;
+sl_v inthash(sl_v a) sl_constfn;
u32int int64to32hash(u64int key) sl_constfn;
-u64int memhash(const char* buf, size_t n);
+u64int memhash(const char* buf, usize n);
--- a/src/htable.c
+++ b/src/htable.c
@@ -6,8 +6,8 @@
#include "htable.h"
#include "hashing.h"
-static sl_constfn value_t
-nextipow2(value_t i)
+static sl_constfn sl_v
+nextipow2(sl_v i)
{if(i == 0)
return 1;
@@ -23,8 +23,8 @@
return i ? i : TOP_BIT;
}
-htable_t *
-htable_new(htable_t *h, int size)
+sl_htable *
+htable_new(sl_htable *h, int size)
{ if(size <= HT_N_INLINE/2){size = HT_N_INLINE;
@@ -44,7 +44,7 @@
}
void
-htable_free(htable_t *h)
+htable_free(sl_htable *h)
{if(h->table != &h->_space[0])
MEM_FREE(h->table);
@@ -52,7 +52,7 @@
// empty and reduce size
void
-htable_reset(htable_t *h, int sz)
+htable_reset(sl_htable *h, int sz)
{sz = nextipow2(sz);
if(h->size > sz*4 && h->table != &h->_space[0]){@@ -59,7 +59,7 @@
MEM_FREE(h->table);
htable_new(h, sz);
}else{- for(size_t i = 0, hsz = h->size; i < hsz; i++)
+ for(usize i = 0, hsz = h->size; i < hsz; i++)
h->table[i] = HT_NOTFOUND;
}
}
--- a/src/htable.h
+++ b/src/htable.h
@@ -9,14 +9,14 @@
// FIXME(sigrid): in a multithreaded environment this isn't enough
int i;
void *_space[HT_N_INLINE];
-}sl_aligned(8) htable_t;
+}sl_aligned(8) sl_htable;
// define this to be an invalid key/value
#define HT_NOTFOUND ((void*)1)
// initialize and free
-htable_t *htable_new(htable_t *h, int size);
-void htable_free(htable_t *h);
+sl_htable *htable_new(sl_htable *h, int size);
+void htable_free(sl_htable *h);
// clear and (possibly) change size
-void htable_reset(htable_t *h, int sz);
+void htable_reset(sl_htable *h, int sz);
--- a/src/htable.inc
+++ b/src/htable.inc
@@ -8,12 +8,12 @@
#define max_probe(size) ((size) <= (HT_N_INLINE*2) ? (HT_N_INLINE/2) : (size)>>3)
static void **
-HTNAME(_lookup_bp)(htable_t *h, void *key)
+HTNAME(_lookup_bp)(sl_htable *h, void *key)
{- value_t hv;
- size_t i, orig, index, iter;
- size_t newsz, sz = hash_size(h);
- size_t maxprobe = max_probe(sz);
+ sl_v hv;
+ usize i, orig, index, iter;
+ usize newsz, sz = hash_size(h);
+ usize maxprobe = max_probe(sz);
void **tab = h->table;
void **ol;
@@ -69,7 +69,7 @@
}
void
-HTNAME(_put)(htable_t *h, void *key, void *val)
+HTNAME(_put)(sl_htable *h, void *key, void *val)
{void **bp = HTNAME(_lookup_bp)(h, key);
*bp = val;
@@ -76,7 +76,7 @@
}
void **
-HTNAME(_bp)(htable_t *h, void *key)
+HTNAME(_bp)(sl_htable *h, void *key)
{return HTNAME(_lookup_bp)(h, key);
}
@@ -84,15 +84,15 @@
/* returns bp if key is in hash, otherwise nil */
/* if return is non-nil and *bp == HT_NOTFOUND then key was deleted */
static void **
-HTNAME(_peek_bp)(htable_t *h, void *key)
+HTNAME(_peek_bp)(sl_htable *h, void *key)
{- size_t sz = hash_size(h);
- size_t maxprobe = max_probe(sz);
+ usize sz = hash_size(h);
+ usize maxprobe = max_probe(sz);
void **tab = h->table;
- size_t index = (HFUNC(key) & (sz-1)) * 2;
+ usize index = (HFUNC(key) & (sz-1)) * 2;
sz *= 2;
- size_t orig = index;
- size_t iter = 0;
+ usize orig = index;
+ usize iter = 0;
do {if(tab[index] == HT_NOTFOUND)
@@ -110,7 +110,7 @@
}
void *
-HTNAME(_get)(htable_t *h, void *key)
+HTNAME(_get)(sl_htable *h, void *key)
{void **bp = HTNAME(_peek_bp)(h, key);
if(bp == nil)
@@ -119,13 +119,13 @@
}
bool
-HTNAME(_has)(htable_t *h, void *key)
+HTNAME(_has)(sl_htable *h, void *key)
{return HTNAME(_get)(h, key) != HT_NOTFOUND;
}
bool
-HTNAME(_remove)(htable_t *h, void *key)
+HTNAME(_remove)(sl_htable *h, void *key)
{void **bp = HTNAME(_peek_bp)(h, key);
if(bp != nil && *bp != HT_NOTFOUND){--- a/src/htableh.inc
+++ b/src/htableh.inc
@@ -3,11 +3,11 @@
#include "htable.h"
#define HTPROT(HTNAME) \
-void *HTNAME##_get(htable_t *h, void *key) sl_purefn; \
-void HTNAME##_put(htable_t *h, void *key, void *val); \
-bool HTNAME##_has(htable_t *h, void *key) sl_purefn; \
-bool HTNAME##_remove(htable_t *h, void *key); \
-void **HTNAME##_bp(htable_t *h, void *key);
+void *HTNAME##_get(sl_htable *h, void *key) sl_purefn; \
+void HTNAME##_put(sl_htable *h, void *key, void *val); \
+bool HTNAME##_has(sl_htable *h, void *key) sl_purefn; \
+bool HTNAME##_remove(sl_htable *h, void *key); \
+void **HTNAME##_bp(sl_htable *h, void *key);
// return value, or HT_NOTFOUND if key not found
--- a/src/ios.c
+++ b/src/ios.c
@@ -5,14 +5,14 @@
static char emptystr[] = "";
-ios_t *ios_stdin = nil;
-ios_t *ios_stdout = nil;
-ios_t *ios_stderr = nil;
+sl_ios *ios_stdin = nil;
+sl_ios *ios_stdout = nil;
+sl_ios *ios_stderr = nil;
/* OS-level primitive wrappers */
void *
-llt_memrchr(const void *s, int c, size_t n)
+llt_memrchr(const void *s, int c, usize n)
{const u8int *src = (const u8int*)s + n;
u8int uc = c;
@@ -34,9 +34,9 @@
// return error code, #bytes read in *nread
// these wrappers retry operations until success or a fatal error
static int
-_os_read(int fd, u8int *buf, size_t n, size_t *nread)
+_os_read(int fd, u8int *buf, usize n, usize *nread)
{- ssize_t r;
+ ssize r;
while(1){#if !defined(__plan9__) && !defined(__macos__) && !defined(__dos__)
@@ -44,7 +44,7 @@
#endif
r = read(fd, buf, n);
if(r > -1){- *nread = (size_t)r;
+ *nread = (usize)r;
break;
}
#if defined(__plan9__) || defined(__macos__) || defined(__dos__)
@@ -61,9 +61,9 @@
}
static int
-_os_read_all(int fd, u8int *buf, size_t n, size_t *nread)
+_os_read_all(int fd, u8int *buf, usize n, usize *nread)
{- size_t got;
+ usize got;
*nread = 0;
@@ -79,9 +79,9 @@
}
static int
-_os_write(int fd, const void *buf, size_t n, size_t *nwritten)
+_os_write(int fd, const void *buf, usize n, usize *nwritten)
{- ssize_t r;
+ ssize r;
while(1){#if !defined(__plan9__) && !defined(__macos__) && !defined(__dos__)
@@ -89,7 +89,7 @@
#endif
r = write(fd, buf, n);
if(r > -1){- *nwritten = (size_t)r;
+ *nwritten = (usize)r;
break;
}
#if defined(__plan9__) || defined(__macos__) || defined(__dos__)
@@ -106,9 +106,9 @@
}
static int
-_os_write_all(int fd, const u8int *buf, size_t n, size_t *nwritten)
+_os_write_all(int fd, const u8int *buf, usize n, usize *nwritten)
{- size_t wrote;
+ usize wrote;
*nwritten = 0;
while(n > 0){@@ -127,7 +127,7 @@
/* internal utility functions */
static u8int *
-_buf_realloc(ios_t *s, size_t sz)
+_buf_realloc(sl_ios *s, usize sz)
{u8int *temp;
@@ -166,11 +166,11 @@
// write a block of data into the buffer at the current position, resizing
// if necessary. returns # written.
-static size_t
-_write_grow(ios_t *s, const void *data, size_t n)
+static usize
+_write_grow(sl_ios *s, const void *data, usize n)
{- size_t amt;
- size_t newsize;
+ usize amt;
+ usize newsize;
if(n == 0)
return 0;
@@ -203,11 +203,11 @@
/* interface functions, low level */
-static size_t
-_ios_read(ios_t *s, u8int *dest, size_t n, int all)
+static usize
+_ios_read(sl_ios *s, u8int *dest, usize n, int all)
{- size_t tot = 0;
- size_t got, avail;
+ usize tot = 0;
+ usize got, avail;
if(s->state == bst_closed)
return 0;
@@ -216,7 +216,7 @@
avail = s->size - s->bpos;
if(avail > 0){- size_t ncopy = avail >= n ? n : avail;
+ usize ncopy = avail >= n ? n : avail;
memcpy(dest, s->buf + s->bpos, ncopy);
s->bpos += ncopy;
if(ncopy >= n){@@ -269,21 +269,21 @@
return tot;
}
-size_t
-ios_read(ios_t *s, void *dest, size_t n)
+usize
+ios_read(sl_ios *s, void *dest, usize n)
{return _ios_read(s, dest, n, 0);
}
// ensure at least n bytes are buffered if possible. returns # available.
-static size_t
-ios_readprep(ios_t *s, size_t n)
+static usize
+ios_readprep(sl_ios *s, usize n)
{ if(s->state == bst_wr && s->bm != bm_mem){ios_flush(s);
s->bpos = s->size = 0;
}
- size_t space = s->size - s->bpos;
+ usize space = s->size - s->bpos;
s->state = bst_rd;
if(space >= n || s->bm == bm_mem || s->fd == -1)
return space;
@@ -300,7 +300,7 @@
return space;
}
}
- size_t got;
+ usize got;
int result = _os_read(s->fd, s->buf+s->size, s->maxsize - s->size, &got);
if(result)
return space;
@@ -309,7 +309,7 @@
}
static void
-_write_update_pos(ios_t *s)
+_write_update_pos(sl_ios *s)
{if(s->bpos > s->ndirty)
s->ndirty = s->bpos;
@@ -317,13 +317,13 @@
s->size = s->bpos;
}
-size_t
-ios_write(ios_t *s, const void *data, size_t n)
+usize
+ios_write(sl_ios *s, const void *data, usize n)
{if(s->readonly || s->state == bst_closed || n == 0)
return 0;
- size_t space;
- size_t wrote = 0;
+ usize space;
+ usize wrote = 0;
if(s->state == bst_none)
s->state = bst_wr;
@@ -347,7 +347,7 @@
if(s->bm == bm_line){const char *nl;
if((nl = llt_memrchr(data, '\n', n)) != nil){- size_t linesz = nl-(const char*)data+1;
+ usize linesz = nl-(const char*)data+1;
s->bm = bm_block;
wrote += ios_write(s, data, linesz);
ios_flush(s);
@@ -372,20 +372,20 @@
return wrote;
}
-off_t
-ios_seek(ios_t *s, off_t pos)
+soffset
+ios_seek(sl_ios *s, soffset pos)
{if(s->state == bst_closed)
return 0;
s->_eof = false;
if(s->bm == bm_mem){- if((size_t)pos > s->size)
+ if((usize)pos > s->size)
return -1;
s->bpos = pos;
}else{ios_flush(s);
- off_t fdpos = lseek(s->fd, pos, SEEK_SET);
- if(fdpos == (off_t)-1)
+ soffset fdpos = lseek(s->fd, pos, SEEK_SET);
+ if(fdpos == (soffset)-1)
return fdpos;
s->bpos = s->size = 0;
}
@@ -392,8 +392,8 @@
return 0;
}
-off_t
-ios_seek_end(ios_t *s)
+soffset
+ios_seek_end(sl_ios *s)
{if(s->state == bst_closed)
return 0;
@@ -402,8 +402,8 @@
s->bpos = s->size;
}else{ios_flush(s);
- off_t fdpos = lseek(s->fd, 0, SEEK_END);
- if(fdpos == (off_t)-1)
+ soffset fdpos = lseek(s->fd, 0, SEEK_END);
+ if(fdpos == (soffset)-1)
return fdpos;
s->bpos = s->size = 0;
}
@@ -410,14 +410,14 @@
return 0;
}
-off_t
-ios_skip(ios_t *s, off_t offs)
+soffset
+ios_skip(sl_ios *s, soffset offs)
{if(s->state == bst_closed)
return 0;
if(offs != 0){ if(offs > 0){- if(offs <= (off_t)(s->size-s->bpos)){+ if(offs <= (soffset)(s->size-s->bpos)){s->bpos += offs;
return 0;
}else if(s->bm == bm_mem){@@ -425,7 +425,7 @@
return -1;
}
}else if(offs < 0){- if(-offs <= (off_t)s->bpos){+ if(-offs <= (soffset)s->bpos){s->bpos += offs;
s->_eof = false;
return 0;
@@ -438,8 +438,8 @@
offs += s->bpos;
else if(s->state == bst_rd)
offs -= s->size - s->bpos;
- off_t fdpos = lseek(s->fd, offs, SEEK_CUR);
- if(fdpos == (off_t)-1)
+ soffset fdpos = lseek(s->fd, offs, SEEK_CUR);
+ if(fdpos == (soffset)-1)
return fdpos;
s->bpos = s->size = 0;
s->_eof = false;
@@ -447,18 +447,18 @@
return 0;
}
-off_t
-ios_pos(ios_t *s)
+soffset
+ios_pos(sl_ios *s)
{if(s->state == bst_closed)
return 0;
if(s->bm == bm_mem)
- return (off_t)s->bpos;
+ return (soffset)s->bpos;
- off_t fdpos = s->fpos;
- if(fdpos == (off_t)-1){+ soffset fdpos = s->fpos;
+ if(fdpos == (soffset)-1){fdpos = lseek(s->fd, 0, SEEK_CUR);
- if(fdpos == (off_t)-1)
+ if(fdpos == (soffset)-1)
return fdpos;
s->fpos = fdpos;
}
@@ -471,15 +471,15 @@
}
int
-ios_trunc(ios_t *s, off_t size)
+ios_trunc(sl_ios *s, soffset size)
{if(s->state == bst_closed || s->readonly || size < 0)
return -1;
if(s->bm == bm_mem){- if((size_t)size == s->size)
+ if((usize)size == s->size)
return 0;
- if((size_t)size < s->size){- if(s->bpos > (size_t)size)
+ if((usize)size < s->size){+ if(s->bpos > (usize)size)
s->bpos = size;
}else if(_buf_realloc(s, size) == nil)
return -1;
@@ -490,7 +490,7 @@
}
bool
-ios_eof(ios_t *s)
+ios_eof(sl_ios *s)
{if(s->state == bst_closed)
return true;
@@ -500,7 +500,7 @@
}
int
-ios_flush(ios_t *s)
+ios_flush(sl_ios *s)
{if(s->ndirty == 0 || s->bm == bm_mem || s->buf == nil)
return 0;
@@ -508,22 +508,22 @@
return -1;
if(s->state == bst_rd){- if(lseek(s->fd, -(off_t)s->size, SEEK_CUR) == (off_t)-1){+ if(lseek(s->fd, -(soffset)s->size, SEEK_CUR) == (soffset)-1){// FIXME eh?
}
}
- size_t nw, ntowrite = s->ndirty;
+ usize nw, ntowrite = s->ndirty;
s->fpos = -1;
int err = _os_write_all(s->fd, s->buf, ntowrite, &nw);
// todo: try recovering from some kinds of errors (e.g. retry)
if(s->state == bst_rd){- if(lseek(s->fd, s->size - nw, SEEK_CUR) == (off_t)-1){+ if(lseek(s->fd, s->size - nw, SEEK_CUR) == (soffset)-1){// FIXME eh?
}
}else if(s->state == bst_wr){- if(s->bpos != nw && lseek(s->fd, (off_t)s->bpos - (off_t)nw, SEEK_CUR) == (off_t)-1){+ if(s->bpos != nw && lseek(s->fd, (soffset)s->bpos - (soffset)nw, SEEK_CUR) == (soffset)-1){// FIXME eh?
}
// now preserve the invariant that data to write
@@ -530,7 +530,7 @@
// begins at the beginning of the buffer, and s->size refers
// to how much valid file data is stored in the buffer.
if(s->size > s->ndirty){- size_t delta = s->size - s->ndirty;
+ usize delta = s->size - s->ndirty;
memmove(s->buf, s->buf + s->ndirty, delta);
}
s->size -= s->ndirty;
@@ -547,7 +547,7 @@
}
void
-ios_close(ios_t *s)
+ios_close(sl_ios *s)
{if(s->state == bst_closed)
return;
@@ -563,7 +563,7 @@
}
void
-ios_free(ios_t *s)
+ios_free(sl_ios *s)
{ if(s->loc.filename != emptystr){MEM_FREE(s->loc.filename);
@@ -572,7 +572,7 @@
}
static void
-_buf_init(ios_t *s, bufmode_t bm)
+_buf_init(sl_ios *s, ios_bm bm)
{s->bm = bm;
if(s->bm == bm_mem || s->bm == bm_none){@@ -586,7 +586,7 @@
}
u8int *
-ios_takebuf(ios_t *s, size_t *psize)
+ios_takebuf(sl_ios *s, usize *psize)
{u8int *buf;
@@ -615,10 +615,10 @@
}
int
-ios_setbuf(ios_t *s, u8int *buf, size_t size, bool own)
+ios_setbuf(sl_ios *s, u8int *buf, usize size, bool own)
{ios_flush(s);
- size_t nvalid;
+ usize nvalid;
nvalid = size < s->size ? size : s->size;
if(nvalid > 0)
@@ -638,7 +638,7 @@
}
int
-ios_bufmode(ios_t *s, bufmode_t mode)
+ios_bufmode(sl_ios *s, ios_bm mode)
{// no fd; can only do mem-only buffering
if(s->fd == -1 && mode != bm_mem)
@@ -648,7 +648,7 @@
}
void
-ios_set_readonly(ios_t *s)
+ios_set_readonly(sl_ios *s)
{if(s->readonly)
return;
@@ -657,10 +657,10 @@
s->readonly = true;
}
-static size_t
-ios_copy_(ios_t *to, ios_t *from, size_t nbytes, int all)
+static usize
+ios_copy_(sl_ios *to, sl_ios *from, usize nbytes, int all)
{- size_t total = 0, avail;
+ usize total = 0, avail;
if(!ios_eof(from)){ do{avail = ios_readprep(from, IOS_BUFSIZE/2);
@@ -668,7 +668,7 @@
from->_eof = true;
break;
}
- size_t written, ntowrite;
+ usize written, ntowrite;
ntowrite = (avail <= nbytes || all) ? avail : nbytes;
written = ios_write(to, from->buf+from->bpos, ntowrite);
// TODO: should this be +=written instead?
@@ -686,14 +686,14 @@
return total;
}
-size_t
-ios_copy(ios_t *to, ios_t *from, size_t nbytes)
+usize
+ios_copy(sl_ios *to, sl_ios *from, usize nbytes)
{return ios_copy_(to, from, nbytes, 0);
}
-size_t
-ios_copyall(ios_t *to, ios_t *from)
+usize
+ios_copyall(sl_ios *to, sl_ios *from)
{return ios_copy_(to, from, 0, 1);
}
@@ -700,10 +700,10 @@
#define LINE_CHUNK_SIZE 160
-size_t
-ios_copyuntil(ios_t *to, ios_t *from, u8int delim)
+usize
+ios_copyuntil(sl_ios *to, sl_ios *from, u8int delim)
{- size_t total = 0, avail = from->size - from->bpos;
+ usize total = 0, avail = from->size - from->bpos;
bool first = true;
if(!ios_eof(from)){ do{@@ -711,7 +711,7 @@
first = false;
avail = ios_readprep(from, LINE_CHUNK_SIZE);
}
- size_t written;
+ usize written;
u8int *pd = memchr(from->buf+from->bpos, delim, avail);
if(pd == nil){written = ios_write(to, from->buf+from->bpos, avail);
@@ -719,7 +719,7 @@
total += written;
avail = 0;
}else{- size_t ntowrite = pd - (from->buf+from->bpos) + 1;
+ usize ntowrite = pd - (from->buf+from->bpos) + 1;
written = ios_write(to, from->buf+from->bpos, ntowrite);
from->bpos += ntowrite;
total += written;
@@ -732,7 +732,7 @@
}
static void
-_ios_init(ios_t *s)
+_ios_init(sl_ios *s)
{// put all fields in a sane initial state
memset(s, 0, sizeof(*s));
@@ -746,8 +746,8 @@
/* stream object initializers. we do no allocation. */
-ios_t *
-ios_file(ios_t *s, char *fname, bool rd, bool wr, bool creat, bool trunc)
+sl_ios *
+ios_file(sl_ios *s, char *fname, bool rd, bool wr, bool creat, bool trunc)
{int fd;
if(!(rd || wr)) // must specify read and/or write
@@ -774,8 +774,8 @@
return nil;
}
-ios_t *
-ios_mem(ios_t *s, size_t initsize)
+sl_ios *
+ios_mem(sl_ios *s, usize initsize)
{_ios_init(s);
s->bm = bm_mem;
@@ -784,8 +784,8 @@
return s;
}
-ios_t *
-ios_static_buffer(ios_t *s, const u8int *buf, size_t sz)
+sl_ios *
+ios_static_buffer(sl_ios *s, const u8int *buf, usize sz)
{ios_mem(s, 0);
ios_setbuf(s, (u8int*)buf, sz, 0);
@@ -794,8 +794,8 @@
return s;
}
-ios_t *
-ios_fd(ios_t *s, int fd, bool isfile, bool own)
+sl_ios *
+ios_fd(sl_ios *s, int fd, bool isfile, bool own)
{_ios_init(s);
s->fd = fd;
@@ -811,16 +811,16 @@
void
ios_init_stdstreams(void)
{- ios_stdin = MEM_ALLOC(sizeof(ios_t));
+ ios_stdin = MEM_ALLOC(sizeof(sl_ios));
ios_fd(ios_stdin, STDIN_FILENO, 0, 0);
ios_stdin->loc.filename = MEM_STRDUP("*stdin*");- ios_stdout = MEM_ALLOC(sizeof(ios_t));
+ ios_stdout = MEM_ALLOC(sizeof(sl_ios));
ios_fd(ios_stdout, STDOUT_FILENO, 0, 0);
ios_stdout->bm = bm_line;
ios_stdout->loc.filename = MEM_STRDUP("*stdout*");- ios_stderr = MEM_ALLOC(sizeof(ios_t));
+ ios_stderr = MEM_ALLOC(sizeof(sl_ios));
ios_fd(ios_stderr, STDERR_FILENO, 0, 0);
ios_stderr->bm = bm_none;
ios_stderr->loc.filename = MEM_STRDUP("*stderr*");@@ -829,7 +829,7 @@
/* higher level interface */
int
-ios_putc(ios_t *s, int c)
+ios_putc(sl_ios *s, int c)
{char ch = c;
@@ -844,7 +844,7 @@
}
static void
-ios_loc(ios_t *s, u8int ch)
+ios_loc(sl_ios *s, u8int ch)
{ if(ch == '\n'){s->loc.lineno++;
@@ -866,7 +866,7 @@
}
int
-ios_getc(ios_t *s)
+ios_getc(sl_ios *s)
{u8int ch;
if(s->state == bst_rd && s->bpos < s->size)
@@ -878,13 +878,13 @@
}
int
-ios_peekc(ios_t *s)
+ios_peekc(sl_ios *s)
{if(s->bpos < s->size)
return (u8int)s->buf[s->bpos];
if(s->_eof)
return IOS_EOF;
- size_t n = ios_readprep(s, 1);
+ usize n = ios_readprep(s, 1);
if(n == 0)
return IOS_EOF;
return (u8int)s->buf[s->bpos];
@@ -891,7 +891,7 @@
}
int
-ios_wait(ios_t *s, double ws)
+ios_wait(sl_ios *s, double ws)
{if(s->bpos < s->size)
return 1;
@@ -917,10 +917,10 @@
}
int
-ios_getutf8(ios_t *s, Rune *r)
+ios_getutf8(sl_ios *s, Rune *r)
{int c;
- size_t i;
+ usize i;
char buf[UTFmax];
for(i = 0; i < sizeof(buf); i++){@@ -943,7 +943,7 @@
}
int
-ios_pututf8(ios_t *s, Rune r)
+ios_pututf8(sl_ios *s, Rune r)
{char buf[UTFmax];
return ios_write(s, buf, runetochar(buf, &r));
@@ -950,7 +950,7 @@
}
void
-ios_purge(ios_t *s)
+ios_purge(sl_ios *s)
{ if(s->state == bst_rd){for(; s->bpos < s->size; s->bpos++)
@@ -959,7 +959,7 @@
}
int
-ios_vprintf(ios_t *s, const char *format, va_list args)
+ios_vprintf(sl_ios *s, const char *format, va_list args)
{char buf[256];
char *str;
@@ -990,7 +990,7 @@
}
int
-ios_printf(ios_t *s, const char *format, ...)
+ios_printf(sl_ios *s, const char *format, ...)
{va_list args;
int c;
--- a/src/ios.h
+++ b/src/ios.h
@@ -6,7 +6,7 @@
bm_line,
bm_block,
bm_mem,
-}bufmode_t;
+}ios_bm;
typedef enum {bst_none,
@@ -13,7 +13,7 @@
bst_rd,
bst_wr,
bst_closed,
-}bufstate_t;
+}ios_bst;
#define IOS_INLSIZE 128
#define IOS_BUFSIZE 32768
@@ -22,23 +22,23 @@
char *filename;
u32int lineno;
u32int colno;
-}ios_loc_t;
+}sl_loc;
typedef struct {u8int *buf; // start of buffer
- size_t maxsize; // space allocated to buffer
- size_t size; // length of valid data in buf, >=ndirty
- size_t bpos; // current position in buffer
- size_t ndirty; // # bytes at &buf[0] that need to be written
- off_t fpos; // cached file pos
- ios_loc_t loc;
- bufmode_t bm;
+ usize maxsize; // space allocated to buffer
+ usize size; // length of valid data in buf, >=ndirty
+ usize bpos; // current position in buffer
+ usize ndirty; // # bytes at &buf[0] that need to be written
+ soffset fpos; // cached file pos
+ sl_loc loc;
+ ios_bm bm;
int colnowait;
// the state only indicates where the underlying file position is relative
// to the buffer. reading: at the end. writing: at the beginning.
// in general, you can do any operation in any state.
- bufstate_t state;
+ ios_bst state;
int fd;
@@ -52,62 +52,62 @@
bool rereadable;
u8int local[IOS_INLSIZE];
-}ios_t;
+}sl_ios;
-void *llt_memrchr(const void *s, int c, size_t n) sl_purefn;
+void *llt_memrchr(const void *s, int c, usize n) sl_purefn;
/* low-level interface functions */
-size_t ios_read(ios_t *s, void *dest, size_t n);
-size_t ios_write(ios_t *s, const void *data, size_t n);
-off_t ios_seek(ios_t *s, off_t pos); // absolute seek
-off_t ios_seek_end(ios_t *s);
-off_t ios_skip(ios_t *s, off_t offs); // relative seek
-off_t ios_pos(ios_t *s); // get current position
-int ios_trunc(ios_t *s, off_t size);
-bool ios_eof(ios_t *s) sl_purefn;
-int ios_flush(ios_t *s);
-void ios_close(ios_t *s);
-void ios_free(ios_t *s);
-u8int *ios_takebuf(ios_t *s, size_t *psize); // null-terminate and release buffer to caller
+usize ios_read(sl_ios *s, void *dest, usize n);
+usize ios_write(sl_ios *s, const void *data, usize n);
+soffset ios_seek(sl_ios *s, soffset pos); // absolute seek
+soffset ios_seek_end(sl_ios *s);
+soffset ios_skip(sl_ios *s, soffset offs); // relative seek
+soffset ios_pos(sl_ios *s); // get current position
+int ios_trunc(sl_ios *s, soffset size);
+bool ios_eof(sl_ios *s) sl_purefn;
+int ios_flush(sl_ios *s);
+void ios_close(sl_ios *s);
+void ios_free(sl_ios *s);
+u8int *ios_takebuf(sl_ios *s, usize *psize); // null-terminate and release buffer to caller
// set buffer space to use
-int ios_setbuf(ios_t *s, u8int *buf, size_t size, bool own);
-int ios_bufmode(ios_t *s, bufmode_t mode);
-void ios_set_readonly(ios_t *s);
-size_t ios_copy(ios_t *to, ios_t *from, size_t nbytes);
-size_t ios_copyall(ios_t *to, ios_t *from);
-size_t ios_copyuntil(ios_t *to, ios_t *from, u8int delim);
+int ios_setbuf(sl_ios *s, u8int *buf, usize size, bool own);
+int ios_bufmode(sl_ios *s, ios_bm mode);
+void ios_set_readonly(sl_ios *s);
+usize ios_copy(sl_ios *to, sl_ios *from, usize nbytes);
+usize ios_copyall(sl_ios *to, sl_ios *from);
+usize ios_copyuntil(sl_ios *to, sl_ios *from, u8int delim);
-int ios_wait(ios_t *s, double ws);
+int ios_wait(sl_ios *s, double ws);
/* stream creation */
-ios_t *ios_file(ios_t *s, char *fname, bool rd, bool wr, bool create, bool trunc);
-ios_t *ios_mem(ios_t *s, size_t initsize);
-ios_t *ios_static_buffer(ios_t *s, const u8int *buf, size_t sz);
-ios_t *ios_fd(ios_t *s, int fd, bool isfile, bool own);
+sl_ios *ios_file(sl_ios *s, char *fname, bool rd, bool wr, bool create, bool trunc);
+sl_ios *ios_mem(sl_ios *s, usize initsize);
+sl_ios *ios_static_buffer(sl_ios *s, const u8int *buf, usize sz);
+sl_ios *ios_fd(sl_ios *s, int fd, bool isfile, bool own);
// todo: ios_socket
-extern ios_t *ios_stdin;
-extern ios_t *ios_stdout;
-extern ios_t *ios_stderr;
+extern sl_ios *ios_stdin;
+extern sl_ios *ios_stdout;
+extern sl_ios *ios_stderr;
void ios_init_stdstreams(void);
/* high-level functions - output */
-int ios_pututf8(ios_t *s, Rune r);
-int ios_printf(ios_t *s, const char *format, ...) sl_printfmt(2, 3);
-int ios_vprintf(ios_t *s, const char *format, va_list args) sl_printfmt(2, 0);
+int ios_pututf8(sl_ios *s, Rune r);
+int ios_printf(sl_ios *s, const char *format, ...) sl_printfmt(2, 3);
+int ios_vprintf(sl_ios *s, const char *format, va_list args) sl_printfmt(2, 0);
-void hexdump(ios_t *dest, const u8int *buffer, size_t len, size_t startoffs);
+void hexdump(sl_ios *dest, const u8int *buffer, usize len, usize startoffs);
/* high-level stream functions - input */
-int ios_getutf8(ios_t *s, Rune *r);
+int ios_getutf8(sl_ios *s, Rune *r);
// discard data buffered for reading
-void ios_purge(ios_t *s);
+void ios_purge(sl_ios *s);
/* stdio-style functions */
#define IOS_EOF (-1)
-int ios_putc(ios_t *s, int c);
-int ios_getc(ios_t *s);
-int ios_peekc(ios_t *s);
+int ios_putc(sl_ios *s, int c);
+int ios_getc(sl_ios *s);
+int ios_peekc(sl_ios *s);
#define ios_puts(s, str) ios_write(s, str, strlen(str))
/*
--- a/src/iostream.c
+++ b/src/iostream.c
@@ -6,9 +6,9 @@
#include "iostream.h"
static void
-print_iostream(value_t v, ios_t *f)
+print_iostream(sl_v v, sl_ios *f)
{- ios_t *s = value2c(ios_t*, v);
+ sl_ios *s = value2c(sl_ios*, v);
sl_print_str(f, "#<io stream");
if(*s->loc.filename){sl_print_chr(f, ' ');
@@ -18,23 +18,23 @@
}
static void
-free_iostream(value_t self)
+free_iostream(sl_v self)
{- ios_t *s = value2c(ios_t*, self);
+ sl_ios *s = value2c(sl_ios*, self);
ios_close(s);
ios_free(s);
}
static void
-relocate_iostream(value_t oldv, value_t newv)
+relocate_iostream(sl_v oldv, sl_v newv)
{- ios_t *olds = value2c(ios_t*, oldv);
- ios_t *news = value2c(ios_t*, newv);
+ sl_ios *olds = value2c(sl_ios*, oldv);
+ sl_ios *news = value2c(sl_ios*, newv);
if(news->buf == &olds->local[0])
news->buf = &news->local[0];
}
-static cvtable_t iostream_vtable = {+static sl_cvtable iostream_vtable = {print_iostream,
relocate_iostream,
free_iostream,
@@ -42,7 +42,7 @@
};
static int
-isiostream(value_t v)
+isiostream(sl_v v)
{return iscvalue(v) && cv_class(ptr(v)) == SL(iostreamtype);
}
@@ -62,12 +62,12 @@
}
sl_purefn
-ios_t *
-toiostream(value_t v)
+sl_ios *
+toiostream(sl_v v)
{if(sl_unlikely(!isiostream(v)))
type_error("iostream", v);- return value2c(ios_t*, v);
+ return value2c(sl_ios*, v);
}
BUILTIN("file", file)@@ -89,9 +89,9 @@
}
if(!r && !w && !c && !t && !a)
r = true; // default to reading
- value_t f = cvalue(SL(iostreamtype), sizeof(ios_t));
+ sl_v f = cvalue(SL(iostreamtype), sizeof(sl_ios));
char *fname = tostring(args[0]);
- ios_t *s = value2c(ios_t*, f);
+ sl_ios *s = value2c(sl_ios*, f);
if(ios_file(s, fname, r, w, c, t) == nil)
lerrorf(sl_errio, "could not open \"%s\"", fname);
if(a)
@@ -103,8 +103,8 @@
{argcount(nargs, 0);
USED(args);
- value_t f = cvalue(SL(iostreamtype), sizeof(ios_t));
- ios_t *s = value2c(ios_t*, f);
+ sl_v f = cvalue(SL(iostreamtype), sizeof(sl_ios));
+ sl_ios *s = value2c(sl_ios*, f);
if(ios_mem(s, 0) == nil)
lerrorf(sl_errmem, "could not allocate stream");
return f;
@@ -114,9 +114,9 @@
{if(nargs > 1)
argcount(nargs, 1);
- value_t a = nargs == 0 ? symbol_value(sl_instrsym) : args[0];
+ sl_v a = nargs == 0 ? symbol_value(sl_instrsym) : args[0];
sl_gc_handle(&a);
- value_t v = sl_read_sexpr(a);
+ sl_v v = sl_read_sexpr(a);
sl_free_gc_handles(1);
return ios_eof(toiostream(a)) ? sl_eof : v;
}
@@ -124,7 +124,7 @@
BUILTIN("io-getc", io_getc) {argcount(nargs, 1);
- ios_t *s = toiostream(args[0]);
+ sl_ios *s = toiostream(args[0]);
Rune r;
int res;
if((res = ios_getutf8(s, &r)) == IOS_EOF)
@@ -139,7 +139,7 @@
{if(nargs > 2)
argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
+ sl_ios *s = toiostream(args[0]);
int r = ios_wait(s, nargs > 1 ? todouble(args[1]) : -1);
if(r >= 0)
return r ? sl_t : sl_nil;
@@ -151,8 +151,8 @@
BUILTIN("io-putc", io_putc) {argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
- cprim_t *cp = ptr(args[1]);
+ sl_ios *s = toiostream(args[0]);
+ sl_cprim *cp = ptr(args[1]);
if(!iscprim(args[1]) || cp_class(cp) != SL(runetype))
type_error("rune", args[1]);Rune r = *(Rune*)cp_data(cp);
@@ -162,9 +162,9 @@
BUILTIN("io-skip", io_skip) {argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
- off_t off = tooffset(args[1]);
- off_t res = ios_skip(s, off);
+ sl_ios *s = toiostream(args[0]);
+ soffset off = tooffset(args[1]);
+ soffset res = ios_skip(s, off);
if(res < 0)
return sl_nil;
return sizeof(res) == sizeof(s64int) ? mk_s64(res) : mk_s32(res);
@@ -186,7 +186,7 @@
BUILTIN("io-truncate", io_truncate) {argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
+ sl_ios *s = toiostream(args[0]);
if(ios_trunc(s, tooffset(args[1])) < 0)
lerrorf(sl_errio, "truncation failed");
return sl_void;
@@ -209,9 +209,9 @@
BUILTIN("io-seek", io_seek) {argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
- size_t pos = tosize(args[1]);
- off_t res = ios_seek(s, (off_t)pos);
+ sl_ios *s = toiostream(args[0]);
+ usize pos = tosize(args[1]);
+ soffset res = ios_seek(s, (soffset)pos);
if(res < 0)
return sl_nil;
return sl_t;
@@ -220,11 +220,11 @@
BUILTIN("io-pos", io_pos) {argcount(nargs, 1);
- ios_t *s = toiostream(args[0]);
- off_t res = ios_pos(s);
+ sl_ios *s = toiostream(args[0]);
+ soffset res = ios_pos(s);
if(res < 0)
return sl_nil;
- return size_wrap((size_t)res);
+ return size_wrap((usize)res);
}
BUILTIN("write", write)@@ -231,7 +231,7 @@
{if(nargs < 1 || nargs > 2)
argcount(nargs, 1);
- ios_t *s;
+ sl_ios *s;
s = nargs == 2 ? toiostream(args[1]) : toiostream(symbol_value(sl_outstrsym));
sl_print(s, args[0]);
return args[0];
@@ -241,9 +241,9 @@
{if(nargs != 3)
argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
- size_t n;
- sltype_t *ft;
+ sl_ios *s = toiostream(args[0]);
+ usize n;
+ sl_type *ft;
if(nargs == 3){// form (io.read s type count)
ft = get_array_type(args[1]);
@@ -254,9 +254,9 @@
lerrorf(sl_errarg, "incomplete type");
n = ft->size;
}
- value_t cv = cvalue(ft, n);
+ sl_v cv = cvalue(ft, n);
u8int *data = cptr(cv);
- size_t got = ios_read(s, data, n);
+ usize got = ios_read(s, data, n);
if(got < n)
//lerrorf(sl_errio, "end of input reached");
return sl_eof;
@@ -265,7 +265,7 @@
// args must contain data[, offset[, count]]
static void
-get_start_count_args(value_t *args, u32int nargs, size_t sz, size_t *offs, size_t *nb)
+get_start_count_args(sl_v *args, u32int nargs, usize sz, usize *offs, usize *nb)
{ if(nargs > 1){*offs = tosize(args[1]);
@@ -279,9 +279,9 @@
{if(nargs < 2 || nargs > 4)
argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
- value_t v = args[1];
- cprim_t *cp = ptr(v);
+ sl_ios *s = toiostream(args[0]);
+ sl_v v = args[1];
+ sl_cprim *cp = ptr(v);
if(iscprim(args[1]) && cp_class(cp) == SL(runetype)){if(nargs > 2)
lerrorf(sl_errarg, "offset argument not supported for characters");
@@ -289,9 +289,9 @@
return fixnum(ios_pututf8(s, r));
}
u8int *data;
- size_t sz, offs = 0;
+ usize sz, offs = 0;
to_sized_ptr(v, &data, &sz);
- size_t nb = sz;
+ usize nb = sz;
if(nargs > 2){get_start_count_args(args+1, nargs-1, sz, &offs, &nb);
data += offs;
@@ -300,9 +300,9 @@
}
static u8int
-get_delim_arg(value_t arg)
+get_delim_arg(sl_v arg)
{- size_t uldelim = tosize(arg);
+ usize uldelim = tosize(arg);
if(uldelim > 0x7f){// runes > 0x7f, or anything else > 0xff, are out of range
if((iscprim(arg) && cp_class(ptr(arg)) == SL(runetype)) || uldelim > 0xff)
@@ -314,19 +314,19 @@
BUILTIN("io-readuntil", io_readuntil) {argcount(nargs, 2);
- value_t str = cvalue_string(80);
- cvalue_t *cv = ptr(str);
+ sl_v str = cvalue_string(80);
+ csl_v *cv = ptr(str);
u8int *data = cv_data(cv);
- ios_t dest;
+ sl_ios dest;
ios_mem(&dest, 0);
ios_setbuf(&dest, data, 80, 0);
u8int delim = get_delim_arg(args[1]);
- ios_t *src = toiostream(args[0]);
- size_t n = ios_copyuntil(&dest, src, delim);
+ sl_ios *src = toiostream(args[0]);
+ usize n = ios_copyuntil(&dest, src, delim);
cv->len = n;
if(dest.buf != data){// outgrew initial space
- size_t sz;
+ usize sz;
cv->data = ios_takebuf(&dest, &sz);
cv_autorelease(cv);
}else{@@ -340,8 +340,8 @@
BUILTIN("io-copyuntil", io_copyuntil) {argcount(nargs, 3);
- ios_t *dest = toiostream(args[0]);
- ios_t *src = toiostream(args[1]);
+ sl_ios *dest = toiostream(args[0]);
+ sl_ios *src = toiostream(args[1]);
u8int delim = get_delim_arg(args[2]);
return size_wrap(ios_copyuntil(dest, src, delim));
}
@@ -350,8 +350,8 @@
{if(nargs < 2 || nargs > 3)
argcount(nargs, 2);
- ios_t *dest = toiostream(args[0]);
- ios_t *src = toiostream(args[1]);
+ sl_ios *dest = toiostream(args[0]);
+ sl_ios *src = toiostream(args[1]);
if(nargs == 3)
return size_wrap(ios_copy(dest, src, tosize(args[2])));
return size_wrap(ios_copyall(dest, src));
@@ -366,7 +366,7 @@
BUILTIN("io-set-filename!", io_set_filename) {argcount(nargs, 2);
- ios_t *s = toiostream(args[0]);
+ sl_ios *s = toiostream(args[0]);
char *f = tostring(args[1]);
MEM_FREE(s->loc.filename);
s->loc.filename = MEM_STRDUP(f);
@@ -399,12 +399,12 @@
return args[1];
}
-value_t
-stream_to_string(value_t *ps)
+sl_v
+stream_to_string(sl_v *ps)
{- value_t str;
- size_t n;
- ios_t *st = value2c(ios_t*, *ps);
+ sl_v str;
+ usize n;
+ sl_ios *st = value2c(sl_ios*, *ps);
if(st->buf == &st->local[0]){n = st->size;
str = cvalue_string(n);
@@ -424,11 +424,11 @@
BUILTIN("iostream->string", io_tostring) {argcount(nargs, 1);
- ios_t *src = toiostream(args[0]);
+ sl_ios *src = toiostream(args[0]);
if(src->bm != bm_mem)
lerrorf(sl_errarg, "requires memory stream");
bool eof = ios_eof(src);
- value_t v = stream_to_string(&args[0]);
+ sl_v v = stream_to_string(&args[0]);
if(eof && v == SL(the_empty_string))
v = sl_eof;
return v;
@@ -445,8 +445,8 @@
sl_truncsym = csymbol(":truncate"); sl_instrsym = csymbol("*input-stream*"); sl_outstrsym = csymbol("*output-stream*");- SL(iostreamtype) = define_opaque_type(sl_iostreamsym, sizeof(ios_t), &iostream_vtable, nil);
- set(csymbol("*stdout*"), cvalue_from_ref(SL(iostreamtype), ios_stdout, sizeof(ios_t)));- set(csymbol("*stderr*"), cvalue_from_ref(SL(iostreamtype), ios_stderr, sizeof(ios_t)));- set(csymbol("*stdin*"), cvalue_from_ref(SL(iostreamtype), ios_stdin, sizeof(ios_t)));+ SL(iostreamtype) = define_opaque_type(sl_iostreamsym, sizeof(sl_ios), &iostream_vtable, nil);
+ set(csymbol("*stdout*"), cvalue_from_ref(SL(iostreamtype), ios_stdout, sizeof(sl_ios)));+ set(csymbol("*stderr*"), cvalue_from_ref(SL(iostreamtype), ios_stderr, sizeof(sl_ios)));+ set(csymbol("*stdin*"), cvalue_from_ref(SL(iostreamtype), ios_stdin, sizeof(sl_ios)));}
--- a/src/iostream.h
+++ b/src/iostream.h
@@ -1,3 +1,3 @@
-ios_t *toiostream(value_t v);
-value_t stream_to_string(value_t *ps);
+sl_ios *toiostream(sl_v v);
+sl_v stream_to_string(sl_v *ps);
void iostream_init(void);
--- a/src/macos/sys.c
+++ b/src/macos/sys.c
@@ -44,7 +44,7 @@
}
int
-ftruncate(int f, off_t sz)
+ftruncate(int f, soffset sz)
{USED(f); USED(sz);
return -1;
@@ -51,7 +51,7 @@
}
char *
-getcwd(char *buf, size_t len)
+getcwd(char *buf, usize len)
{USED(buf); USED(len);
return nil;
--- a/src/mem.c
+++ b/src/mem.c
@@ -26,7 +26,7 @@
#include "dlmalloc.inc"
void *
-sl_malloc(size_t size)
+sl_malloc(usize size)
{return dlmalloc(size);
}
@@ -38,13 +38,13 @@
}
void *
-sl_calloc(size_t n, size_t size)
+sl_calloc(usize n, usize size)
{return dlcalloc(n, size);
}
void *
-sl_realloc(void *p, size_t size)
+sl_realloc(void *p, usize size)
{return dlrealloc(p, size);
}
@@ -52,7 +52,7 @@
char *
sl_strdup(const char *s)
{- size_t sz = strlen(s)+1;
+ usize sz = strlen(s)+1;
char *p = dlmalloc(sz);
memcpy(p, s, sz);
return p;
--- a/src/mem.h
+++ b/src/mem.h
@@ -11,26 +11,26 @@
#endif
#if defined(USE_DLMALLOC)
-void *sl_malloc(size_t);
+void *sl_malloc(usize);
void sl_free(void *);
-void *sl_calloc(size_t, size_t);
-void *sl_realloc(void *, size_t);
+void *sl_calloc(usize, usize);
+void *sl_realloc(void *, usize);
char *sl_strdup(const char *s);
-#define MEM_CALLOC(n, sz) sl_calloc((size_t)(n), (size_t)(sz))
-#define MEM_ALLOC(n) sl_malloc((size_t)(n))
-#define MEM_REALLOC(p, n) sl_realloc((p), (size_t)(n))
+#define MEM_CALLOC(n, sz) sl_calloc((usize)(n), (usize)(sz))
+#define MEM_ALLOC(n) sl_malloc((usize)(n))
+#define MEM_REALLOC(p, n) sl_realloc((p), (usize)(n))
#define MEM_FREE(x) sl_free(x)
#define MEM_STRDUP(s) sl_strdup(s)
-#define sl_segalloc(sz) MEM_ALLOC((size_t)sz)
+#define sl_segalloc(sz) MEM_ALLOC((usize)sz)
#define sl_segfree(s, sz) MEM_FREE(s)
#define sl_segused(s, sz, used) do{}while(0)#else
-#define MEM_CALLOC(n, sz) calloc((size_t)(n), (size_t)(sz))
-#define MEM_ALLOC(n) malloc((size_t)(n))
-#define MEM_REALLOC(p, n) realloc((p), (size_t)(n))
+#define MEM_CALLOC(n, sz) calloc((usize)(n), (usize)(sz))
+#define MEM_ALLOC(n) malloc((usize)(n))
+#define MEM_REALLOC(p, n) realloc((p), (usize)(n))
#define MEM_FREE(x) free(x)
#define MEM_STRDUP(s) strdup(s)
-void *sl_segalloc(size_t sz);
-void sl_segfree(void *s, size_t sz);
-void sl_segused(void *s, size_t sz, size_t used);
+void *sl_segalloc(usize sz);
+void sl_segfree(void *s, usize sz);
+void sl_segused(void *s, usize sz, usize used);
#endif
--- a/src/opcodes.h
+++ b/src/opcodes.h
@@ -89,6 +89,6 @@
OP_OPTARGS,
OP_EOF_OBJECT,
N_OPCODES
-}opcode_t;
+}sl_op;
extern const Builtin builtins[N_OPCODES];
--- a/src/operators.c
+++ b/src/operators.c
@@ -2,7 +2,7 @@
#include "operators.h"
mpint *
-conv_to_mp(void *data, numerictype_t tag)
+conv_to_mp(void *data, sl_numtype tag)
{ switch(tag){case T_S8: return itomp(*(s8int*)data, nil);
@@ -22,7 +22,7 @@
sl_purefn
double
-conv_to_double(void *data, numerictype_t tag)
+conv_to_double(void *data, sl_numtype tag)
{double d;
switch(tag){@@ -49,7 +49,7 @@
#define CONV_TO_INTTYPE(name, ctype) \
sl_purefn \
ctype \
-conv_to_##name(void *data, numerictype_t tag) \
+conv_to_##name(void *data, sl_numtype tag) \
{ \ switch(tag){ \case T_S8: return (ctype)*(s8int*)data; \
@@ -76,7 +76,7 @@
// first.
sl_purefn
u64int
-conv_to_u64(void *data, numerictype_t tag)
+conv_to_u64(void *data, sl_numtype tag)
{s64int s;
switch(tag){@@ -105,7 +105,7 @@
sl_purefn
bool
-cmp_same_lt(void *a, void *b, numerictype_t tag)
+cmp_same_lt(void *a, void *b, sl_numtype tag)
{ switch(tag){case T_S8: return *(s8int*)a < *(s8int*)b;
@@ -125,7 +125,7 @@
sl_purefn
bool
-cmp_same_eq(void *a, void *b, numerictype_t tag)
+cmp_same_eq(void *a, void *b, sl_numtype tag)
{ switch(tag){case T_S8: return *(s8int*)a == *(s8int*)b;
@@ -147,7 +147,7 @@
static mpint *cmpmpint;
bool
-cmp_lt(void *a, numerictype_t atag, void *b, numerictype_t btag)
+cmp_lt(void *a, sl_numtype atag, void *b, sl_numtype btag)
{if(atag == btag)
return cmp_same_lt(a, b, atag);
@@ -200,7 +200,7 @@
}
bool
-cmp_eq(void *a, numerictype_t atag, void *b, numerictype_t btag, bool equalnans)
+cmp_eq(void *a, sl_numtype atag, void *b, sl_numtype btag, bool equalnans)
{ union {double d;
--- a/src/operators.h
+++ b/src/operators.h
@@ -1,15 +1,15 @@
#pragma once
-mpint *conv_to_mp(void *data, numerictype_t tag);
-double conv_to_double(void *data, numerictype_t tag);
+mpint *conv_to_mp(void *data, sl_numtype tag);
+double conv_to_double(void *data, sl_numtype tag);
-bool cmp_same_lt(void *a, void *b, numerictype_t tag);
-bool cmp_same_eq(void *a, void *b, numerictype_t tag);
-bool cmp_lt(void *a, numerictype_t atag, void *b, numerictype_t btag);
-bool cmp_eq(void *a, numerictype_t atag, void *b, numerictype_t btag, bool equalnans);
+bool cmp_same_lt(void *a, void *b, sl_numtype tag);
+bool cmp_same_eq(void *a, void *b, sl_numtype tag);
+bool cmp_lt(void *a, sl_numtype atag, void *b, sl_numtype btag);
+bool cmp_eq(void *a, sl_numtype atag, void *b, sl_numtype btag, bool equalnans);
-s64int conv_to_s64(void *data, numerictype_t tag);
-u64int conv_to_u64(void *data, numerictype_t tag);
-s32int conv_to_s32(void *data, numerictype_t tag);
-u32int conv_to_u32(void *data, numerictype_t tag);
-Rune conv_to_Rune(void *data, numerictype_t tag);
+s64int conv_to_s64(void *data, sl_numtype tag);
+u64int conv_to_u64(void *data, sl_numtype tag);
+s32int conv_to_s32(void *data, sl_numtype tag);
+u32int conv_to_u32(void *data, sl_numtype tag);
+Rune conv_to_Rune(void *data, sl_numtype tag);
--- a/src/plan9/platform.h
+++ b/src/plan9/platform.h
@@ -38,9 +38,11 @@
#define BITS64
#define PRIdPTR PRId64
#define PRIuPTR PRIu64
+typedef long long ssize;
#else
#define PRIdPTR "ld"
#define PRIuPTR "lud"
+typedef long ssize;
#endif
#if defined(__386__) || defined(__amd64__) || defined(__arm64__)
@@ -115,12 +117,10 @@
#define BYTE_ORDER LITTLE_ENDIAN
#endif
-typedef vlong off_t;
-typedef intptr ssize_t;
-typedef uintptr size_t;
+typedef vlong soffset;
typedef enum { false, true } bool;-int ftruncate(int f, off_t sz);
+int ftruncate(int f, soffset sz);
#include "cc.h"
#include "mem.h"
--- a/src/plan9/sys.c
+++ b/src/plan9/sys.c
@@ -16,13 +16,13 @@
}
void *
-sl_segalloc(size_t sz)
+sl_segalloc(usize sz)
{return segattach(SG_CEXEC, "memory", nil, sz);
}
void
-sl_segfree(void *s, size_t sz)
+sl_segfree(void *s, usize sz)
{USED(sz);
if(s != nil)
@@ -30,7 +30,7 @@
}
void
-sl_segused(void *s, size_t sz, size_t used)
+sl_segused(void *s, usize sz, usize used)
{USED(s); USED(sz); USED(used);
}
@@ -92,7 +92,7 @@
}
int
-ftruncate(int f, off_t sz)
+ftruncate(int f, soffset sz)
{Dir d;
--- a/src/posix/sys.c
+++ b/src/posix/sys.c
@@ -2,11 +2,11 @@
#include "timefuncs.h"
#include <sys/mman.h>
-static size_t pagesize = 4096;
+static usize pagesize = 4096;
#define PAGEALIGNED(x) (((x) + pagesize-1) & ~(pagesize-1))
void *
-sl_segalloc(size_t sz)
+sl_segalloc(usize sz)
{sz = PAGEALIGNED(sz);
void *s = mmap(nil, sz, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
@@ -16,7 +16,7 @@
}
void
-sl_segfree(void *s, size_t sz)
+sl_segfree(void *s, usize sz)
{if(s == nil)
return;
@@ -26,7 +26,7 @@
}
void
-sl_segused(void *s, size_t sz, size_t used)
+sl_segused(void *s, usize sz, usize used)
{sz = PAGEALIGNED(sz);
used = PAGEALIGNED(used);
--- a/src/print.c
+++ b/src/print.c
@@ -8,7 +8,7 @@
#define LOG2_10 3.321928094887362347870319429489
static void
-outc(ios_t *f, char c)
+outc(sl_ios *f, char c)
{ios_putc(f, c);
if(c == '\n')
@@ -18,22 +18,22 @@
}
static inline void
-outsn(ios_t *f, const char *s, size_t n)
+outsn(sl_ios *f, const char *s, usize n)
{ios_write(f, s, n);
- ssize_t w = u8_strwidth(s, n);
+ ssize w = u8_strwidth(s, n);
if(w > 0)
SL(hpos) += w;
}
static inline void
-outs(ios_t *f, const char *s)
+outs(sl_ios *f, const char *s)
{outsn(f, s, strlen(s));
}
static int
-outindent(ios_t *f, int n)
+outindent(sl_ios *f, int n)
{// move back to left margin if we get too indented
if(n > SL(scr_width)-12)
@@ -54,25 +54,25 @@
}
void
-sl_print_chr(ios_t *f, char c)
+sl_print_chr(sl_ios *f, char c)
{outc(f, c);
}
void
-sl_print_str(ios_t *f, const char *s)
+sl_print_str(sl_ios *f, const char *s)
{outs(f, s);
}
void
-print_traverse(value_t v)
+print_traverse(sl_v v)
{- value_t *bp;
+ sl_v *bp;
while(iscons(v)){ if(ismarked(v)){- bp = (value_t*)ptrhash_bp(&SL(printconses), (void*)v);
- if(*bp == (value_t)HT_NOTFOUND)
+ bp = (sl_v*)ptrhash_bp(&SL(printconses), (void*)v);
+ if(*bp == (sl_v)HT_NOTFOUND)
*bp = fixnum(SL(printlabel)++);
return;
}
@@ -83,8 +83,8 @@
if(!ismanaged(v) || issymbol(v))
return;
if(ismarked(v)){- bp = (value_t*)ptrhash_bp(&SL(printconses), (void*)v);
- if(*bp == (value_t)HT_NOTFOUND)
+ bp = (sl_v*)ptrhash_bp(&SL(printconses), (void*)v);
+ if(*bp == (sl_v)HT_NOTFOUND)
*bp = fixnum(SL(printlabel)++);
return;
}
@@ -98,16 +98,16 @@
// don't consider shared references to e.g. chars
}else if(isfunction(v)){mark_cons(v);
- function_t *f = ptr(v);
+ sl_fn *f = ptr(v);
print_traverse(f->bcode);
print_traverse(f->vals);
print_traverse(f->env);
}else if(iscvalue(v)){- cvalue_t *cv = ptr(v);
+ csl_v *cv = ptr(v);
// don't consider shared references to ""
if(!cv_isstr(cv) || cv_len(cv) != 0)
mark_cons(v);
- sltype_t *t = cv_class(cv);
+ sl_type *t = cv_class(cv);
if(t->vtable != nil && t->vtable->print_traverse != nil)
t->vtable->print_traverse(v);
}
@@ -114,7 +114,7 @@
}
static void
-print_symbol_name(ios_t *f, const char *name)
+print_symbol_name(sl_ios *f, const char *name)
{int i;
bool escape = false, charescape = false;
@@ -167,7 +167,7 @@
*/
#define SMALL_STR_LEN 20
static inline int
-tinyp(value_t v)
+tinyp(sl_v v)
{ if(issymbol(v)){const char *s = symbol_name(v);
@@ -182,7 +182,7 @@
}
static bool
-smallp(value_t v)
+smallp(sl_v v)
{if(tinyp(v))
return true;
@@ -195,7 +195,7 @@
return false;
}
if(isvector(v)){- size_t s = vector_size(v);
+ usize s = vector_size(v);
return (
s == 0 ||
(tinyp(vector_elt(v, 0)) && (s == 1 || (s == 2 && tinyp(vector_elt(v, 1)))))
@@ -205,7 +205,7 @@
}
static int
-specialindent(value_t head)
+specialindent(sl_v head)
{// indent these forms 2 spaces, not lined up with the first argument
if(head == sl_lambda || head == sl_trycatch || head == sl_defsym ||
@@ -215,7 +215,7 @@
}
static int
-lengthestimate(value_t v)
+lengthestimate(sl_v v)
{// get the width of an expression if we can do so cheaply
if(issymbol(v)){@@ -228,7 +228,7 @@
}
static int
-allsmallp(value_t v)
+allsmallp(sl_v v)
{int n = 1;
while(iscons(v)){@@ -243,7 +243,7 @@
}
static int
-indentafter3(value_t head, value_t v)
+indentafter3(sl_v head, sl_v v)
{// for certain X always indent (X a b c) after b
return head == sl_forsym && !allsmallp(cdr_(v));
@@ -250,7 +250,7 @@
}
static int
-indentafter2(value_t head, value_t v)
+indentafter2(sl_v head, sl_v v)
{// for certain X always indent (X a b) after a
return (head == sl_defsym || head == sl_defmacrosym) && !allsmallp(cdr_(v));
@@ -257,11 +257,11 @@
}
static bool
-indentevery(value_t v)
+indentevery(sl_v v)
{// indent before every subform of a special form, unless every
// subform is "small"
- value_t c = car_(v);
+ sl_v c = car_(v);
if(c == sl_lambda || c == sl_setqsym)
return false;
//if(c == SL(IF)) // TODO: others
@@ -270,7 +270,7 @@
}
static bool
-blockindent(value_t v)
+blockindent(sl_v v)
{// in this case we switch to block indent mode, where the head
// is no longer considered special:
@@ -280,9 +280,9 @@
}
static void
-print_cons(ios_t *f, value_t v)
+print_cons(sl_ios *f, sl_v v)
{- value_t cd;
+ sl_v cd;
const char *op;
if(iscons(cdr_(v)) && cdr_(cdr_(v)) == sl_nil &&
!ptrhash_has(&SL(printconses), (void*)cdr_(v)) &&
@@ -305,7 +305,7 @@
bool always = false, blk = blockindent(v);
if(!blk)
always = indentevery(v);
- value_t head = car_(v);
+ sl_v head = car_(v);
int after3 = indentafter3(head, v);
int after2 = indentafter2(head, v);
int n_unindented = 1;
@@ -374,13 +374,13 @@
}
}
-static void cvalue_print(ios_t *f, value_t v);
+static void cvalue_print(sl_ios *f, sl_v v);
static bool
-print_circle_prefix(ios_t *f, value_t v)
+print_circle_prefix(sl_ios *f, sl_v v)
{- value_t label;
- if((label = (value_t)ptrhash_get(&SL(printconses), (void*)v)) != (value_t)HT_NOTFOUND){+ sl_v label;
+ if((label = (sl_v)ptrhash_get(&SL(printconses), (void*)v)) != (sl_v)HT_NOTFOUND){ if(!ismarked(v)){SL(hpos) += ios_printf(f, "#%"PRIdPTR"#", (intptr)numval(label));
return true;
@@ -393,7 +393,7 @@
}
void
-sl_print_child(ios_t *f, value_t v)
+sl_print_child(sl_ios *f, sl_v v)
{const char *name;
if(SL(print_level) >= 0 && SL(p_level) >= SL(print_level) && (iscons(v) || isvector(v) || isfunction(v))){@@ -434,10 +434,10 @@
if(!SL(print_princ)){if(print_circle_prefix(f, v))
break;
- function_t *fn = ptr(v);
+ sl_fn *fn = ptr(v);
outs(f, "#fn(");char *data = cvalue_data(fn->bcode);
- size_t i, sz = cvalue_len(fn->bcode);
+ usize i, sz = cvalue_len(fn->bcode);
for(i = 0; i < sz; i++)
data[i] += 48;
sl_print_child(f, fn->bcode);
@@ -507,13 +507,13 @@
}
static void
-print_string(ios_t *f, const char *str, size_t sz)
+print_string(sl_ios *f, const char *str, usize sz)
{char buf[64];
u8int c;
static const char hexdig[] = "0123456789abcdef";
- size_t i = 0;
+ usize i = 0;
if(!u8_isvalid(str, sz)){// alternate print algorithm that preserves data if it's not UTF-8
for(; i < sz; i++){@@ -532,7 +532,7 @@
}
}else{ while(i < sz){- size_t n = u8_escape(buf, sizeof(buf), str, &i, sz, true, false);
+ usize n = u8_escape(buf, sizeof(buf), str, &i, sz, true, false);
outsn(f, buf, n-1);
}
}
@@ -548,7 +548,7 @@
}
static void
-snprint_real(char *s, size_t cnt, double r,
+snprint_real(char *s, usize cnt, double r,
int width, // printf field width, or 0
int dec, // # decimal digits desired, recommend 16
// # of zeros in .00...0x before using scientific notation
@@ -639,7 +639,7 @@
// printing in a context where a type is already implied, e.g. inside
// an array.
static void
-cvalue_printdata(ios_t *f, void *data, size_t len, value_t type, int weak)
+cvalue_printdata(sl_ios *f, void *data, usize len, sl_v type, int weak)
{ if(type == sl_bytesym){u8int ch = *(u8int*)data;
@@ -731,7 +731,7 @@
}else if(issymbol(type)){// handle other integer prims. we know it's smaller than uint64
// at this point, so int64 is big enough to capture everything.
- numerictype_t nt = sym_to_numtype(type);
+ sl_numtype nt = sym_to_numtype(type);
if(valid_numtype(nt)){s64int i64 = conv_to_s64(data, nt);
if(weak || SL(print_princ))
@@ -743,9 +743,9 @@
}
}else if(iscons(type)){ if(car_(type) == sl_arraysym){- size_t i;
- value_t eltype = car(cdr_(type));
- size_t cnt, elsize;
+ usize i;
+ sl_v eltype = car(cdr_(type));
+ usize cnt, elsize;
if(iscons(cdr_(cdr_(type)))){cnt = tosize(car_(cdr_(cdr_(type))));
elsize = cnt ? len/cnt : 0;
@@ -810,15 +810,15 @@
}
static void
-cvalue_print(ios_t *f, value_t v)
+cvalue_print(sl_ios *f, sl_v v)
{- cvalue_t *cv = ptr(v);
+ csl_v *cv = ptr(v);
void *data = cptr(v);
- value_t label;
+ sl_v label;
if(cv_class(cv) == SL(builtintype)){- label = (value_t)ptrhash_get(&SL(reverse_dlsym_lookup_table), cv);
- assert(label != (value_t)HT_NOTFOUND);
+ label = (sl_v)ptrhash_get(&SL(reverse_dlsym_lookup_table), cv);
+ assert(label != (sl_v)HT_NOTFOUND);
if(SL(print_princ)){outs(f, symbol_name(label));
}else{@@ -829,8 +829,8 @@
}else if(cv_class(cv)->vtable != nil && cv_class(cv)->vtable->print != nil){cv_class(cv)->vtable->print(v, f);
}else{- value_t type = cv_type(cv);
- size_t len = iscprim(v) ? cv_class(cv)->size : cv_len(cv);
+ sl_v type = cv_type(cv);
+ usize len = iscprim(v) ? cv_class(cv)->size : cv_len(cv);
cvalue_printdata(f, data, len, type, 0);
}
}
@@ -838,7 +838,7 @@
static void
set_print_width(void)
{- value_t pw = symbol_value(sl_printwidthsym);
+ sl_v pw = symbol_value(sl_printwidthsym);
if(!isfixnum(pw))
return;
SL(scr_width) = numval(pw);
@@ -845,13 +845,13 @@
}
void
-sl_print(ios_t *f, value_t v)
+sl_print(sl_ios *f, sl_v v)
{SL(print_pretty) = symbol_value(sl_printprettysym) != sl_nil;
if(SL(print_pretty))
set_print_width();
SL(print_princ) = symbol_value(sl_printreadablysym) == sl_nil;
- value_t pl = symbol_value(sl_printlengthsym);
+ sl_v pl = symbol_value(sl_printlengthsym);
SL(print_length) = isfixnum(pl) ? numval(pl) : -1;
pl = symbol_value(sl_printlevelsym);
SL(print_level) = isfixnum(pl) ? numval(pl) : -1;
@@ -865,7 +865,7 @@
sl_print_child(f, v);
if(SL(print_level) >= 0 || SL(print_length) >= 0)
- memset(SL(consflags), 0, 4*bitvector_nwords(SL(heapsize)/sizeof(cons_t)));
+ memset(SL(consflags), 0, 4*bitvector_nwords(SL(heapsize)/sizeof(sl_cons)));
if((iscons(v) || isvector(v) || isfunction(v) || iscvalue(v)) &&
!sl_isstring(v) && v != sl_t && v != sl_nil && v != sl_void)
--- a/src/print.h
+++ b/src/print.h
@@ -1,7 +1,7 @@
#pragma once
-void sl_print(ios_t *f, value_t v);
-void print_traverse(value_t v);
-void sl_print_chr(ios_t *f, char c);
-void sl_print_str(ios_t *f, const char *s);
-void sl_print_child(ios_t *f, value_t v);
+void sl_print(sl_ios *f, sl_v v);
+void print_traverse(sl_v v);
+void sl_print_chr(sl_ios *f, char c);
+void sl_print_str(sl_ios *f, const char *s);
+void sl_print_child(sl_ios *f, sl_v v);
--- a/src/ptrhash.c
+++ b/src/ptrhash.c
@@ -33,7 +33,7 @@
#endif
#define HTNAME(suffix) ptrhash##suffix
-#define HFUNC(v) _pinthash((value_t)(v))
+#define HFUNC(v) _pinthash((sl_v)(v))
#define EQFUNC(x, y) ((x) == (y))
#include "htable.inc"
--- a/src/read.c
+++ b/src/read.c
@@ -17,17 +17,17 @@
struct Rctx {u32int toktype;
- value_t tokval;
- ios_loc_t loc;
+ sl_v tokval;
+ sl_loc loc;
char buf[1024];
};
-static value_t do_read_sexpr(Rctx *ctx, value_t label);
+static sl_v do_read_sexpr(Rctx *ctx, sl_v label);
-#define RS value2c(ios_t*, SL(readstate)->source)
+#define RS value2c(sl_ios*, SL(readstate)->source)
bool
-sl_read_numtok(const char *tok, value_t *pval, int base)
+sl_read_numtok(const char *tok, sl_v *pval, int base)
{char *end;
s64int i64;
@@ -95,7 +95,7 @@
{int ch;
char c;
- ios_t *f = RS;
+ sl_ios *f = RS;
do{ch = ios_getc(RS);
@@ -122,7 +122,7 @@
}
static _Noreturn void sl_printfmt(2, 3)
-parse_error(ios_loc_t *loc, const char *format, ...)
+parse_error(sl_loc *loc, const char *format, ...)
{char msgbuf[512];
va_list args;
@@ -134,10 +134,10 @@
n = 0;
va_start(args, format);
vsnprintf(msgbuf+n, sizeof(msgbuf)-n, format, args);
- value_t msg = string_from_cstr(msgbuf);
+ sl_v msg = string_from_cstr(msgbuf);
va_end(args);
- sl_raise(sl_list2(sl_errparse, msg));
+ sl_raise(mk_list2(sl_errparse, msg));
}
static void
@@ -200,7 +200,7 @@
peek(Rctx *ctx)
{char c, *end;
- fixnum_t x;
+ sl_fx x;
int ch, base;
if(ctx->toktype != TOK_NONE)
@@ -389,14 +389,14 @@
// NOTE: this is NOT an efficient operation. it is only used by the
// reader, and requires at least 1 and up to 3 garbage collections!
-static value_t
-vector_grow(value_t v, bool rewrite_refs)
+static sl_v
+vector_grow(sl_v v, bool rewrite_refs)
{- size_t i, s = vector_size(v);
- size_t d = vector_grow_amt(s);
+ usize i, s = vector_size(v);
+ usize d = vector_grow_amt(s);
PUSH(v);
assert(s+d > s);
- value_t newv = alloc_vector(s+d, 1);
+ sl_v newv = alloc_vector(s+d, 1);
v = SL(sp)[-1];
for(i = 0; i < s; i++)
vector_elt(newv, i) = vector_elt(v, i);
@@ -403,7 +403,7 @@
// use gc to rewrite references from the old vector to the new
SL(sp)[-1] = newv;
if(s > 0 && rewrite_refs){- ((size_t*)ptr(v))[0] |= 0x1;
+ ((usize*)ptr(v))[0] |= 0x1;
vector_elt(v, 0) = newv;
sl_gc(false);
}
@@ -410,10 +410,10 @@
return POP();
}
-static value_t
-read_vector(Rctx *ctx, value_t label, u32int closer)
+static sl_v
+read_vector(Rctx *ctx, sl_v label, u32int closer)
{- value_t v = SL(the_empty_vector), elt;
+ sl_v v = SL(the_empty_vector), elt;
u32int i = 0;
PUSH(v);
if(label != UNBOUND)
@@ -439,14 +439,14 @@
return POP();
}
-static value_t
+static sl_v
read_string(Rctx *ctx)
{char *buf, *temp;
char eseq[10];
- size_t i = 0, j, sz, ndig;
+ usize i = 0, j, sz, ndig;
int c;
- value_t s;
+ sl_v s;
Rune r = 0;
sz = sizeof(ctx->buf);
@@ -521,7 +521,7 @@
if(esc == (char)c && !strchr("\\'\"`", esc)){if(buf != ctx->buf)
MEM_FREE(buf);
- ios_loc_t *l = &RS->loc;
+ sl_loc *l = &RS->loc;
parse_error(
&ctx->loc,
"invalid escape sequence \\%c "PAtLoc,
@@ -547,11 +547,11 @@
// can move whenever a new cons is allocated. we have to refer to every cons
// through a handle to a relocatable pointer (i.e. a pointer on the stack).
static void
-read_list(Rctx *ctx, value_t label, u32int closer)
+read_list(Rctx *ctx, sl_v label, u32int closer)
{- value_t c, *pc, *pval, *ipval, *ipc;
+ sl_v c, *pc, *pval, *ipval, *ipc;
u32int t;
- ios_loc_t loc0;
+ sl_loc loc0;
loc0 = RS->loc;
loc0.colno--;
@@ -562,7 +562,7 @@
while(t != closer){if(ios_eof(RS))
parse_error(&loc0, "not closed: unexpected EOI "PAtLoc, ctx->loc.lineno, ctx->loc.colno);
- c = mk_cons(); car_(c) = cdr_(c) = sl_nil;
+ c = alloc_cons(); car_(c) = cdr_(c) = sl_nil;
pc = ipc;
if(iscons(*pc))
cdr_(*pc) = c;
@@ -602,11 +602,11 @@
}
// label is the backreference we'd like to fix up with this read
-static value_t
-do_read_sexpr(Rctx *ctx, value_t label)
+static sl_v
+do_read_sexpr(Rctx *ctx, sl_v label)
{- value_t v, sym, oldtokval, *head;
- value_t *pv;
+ sl_v v, sym, oldtokval, *head;
+ sl_v *pv;
u32int t;
char c;
@@ -641,7 +641,7 @@
listwith:
v = cons_reserve(2);
car_(v) = *head;
- cdr_(v) = tagptr((cons_t*)ptr(v)+1, TAG_CONS);
+ cdr_(v) = tagptr((sl_cons*)ptr(v)+1, TAG_CONS);
car_(cdr_(v)) = cdr_(cdr_(v)) = sl_nil;
PUSH(v);
if(label != UNBOUND)
@@ -665,7 +665,7 @@
read_list(ctx, UNBOUND, TOK_CLOSE);
if(sym == sl_vu8sym){sym = sl_arraysym;
- SL(sp)[-1] = sl_cons(sl_u8sym, SL(sp)[-1]);
+ SL(sp)[-1] = mk_cons(sl_u8sym, SL(sp)[-1]);
}else if(sym == sl_fnsym){sym = sl_function;
}
@@ -699,13 +699,13 @@
return v;
case TOK_BACKREF:
// look up backreference
- v = (value_t)ptrhash_get(&SL(readstate)->backrefs, (void*)ctx->tokval);
- if(v == (value_t)HT_NOTFOUND)
+ v = (sl_v)ptrhash_get(&SL(readstate)->backrefs, (void*)ctx->tokval);
+ if(v == (sl_v)HT_NOTFOUND)
parse_error(&ctx->loc, "undefined label %"PRIdPTR, (intptr)numval(ctx->tokval));
return v;
case TOK_GENSYM:
- pv = (value_t*)ptrhash_bp(&SL(readstate)->gensyms, (void*)ctx->tokval);
- if(*pv == (value_t)HT_NOTFOUND)
+ pv = (sl_v*)ptrhash_bp(&SL(readstate)->gensyms, (void*)ctx->tokval);
+ if(*pv == (sl_v)HT_NOTFOUND)
*pv = gensym();
return *pv;
case TOK_DOUBLEQUOTE:
@@ -722,10 +722,10 @@
return sl_void;
}
-value_t
-sl_read_sexpr(value_t f)
+sl_v
+sl_read_sexpr(sl_v f)
{- sl_readstate_t state;
+ sl_readstate state;
state.prev = SL(readstate);
htable_new(&state.backrefs, 8);
htable_new(&state.gensyms, 8);
@@ -735,7 +735,7 @@
ctx.toktype = TOK_NONE;
sl_gc_handle(&ctx.tokval);
- value_t v = do_read_sexpr(&ctx, UNBOUND);
+ sl_v v = do_read_sexpr(&ctx, UNBOUND);
sl_free_gc_handles(1);
SL(readstate) = state.prev;
--- a/src/read.h
+++ b/src/read.h
@@ -1,7 +1,7 @@
#pragma once
-value_t sl_read_sexpr(value_t f);
-bool sl_read_numtok(const char *tok, value_t *pval, int base);
+sl_v sl_read_sexpr(sl_v f);
+bool sl_read_numtok(const char *tok, sl_v *pval, int base);
// defines which characters are ordinary symbol characters.
// exceptions are '.', which is an ordinary symbol character
--- a/src/sl.c
+++ b/src/sl.c
@@ -11,25 +11,25 @@
#include "iostream.h"
#include "compress.h"
-value_t sl_builtins_table_sym, sl_quote, sl_lambda, sl_function, sl_comma, sl_commaat;
-value_t sl_commadot, sl_trycatch, sl_backquote;
-value_t sl_conssym, sl_symbolsym, sl_fixnumsym, sl_vectorsym, sl_builtinsym, sl_vu8sym;
-value_t sl_defsym, sl_defmacrosym, sl_forsym, sl_setqsym;
-value_t sl_booleansym, sl_nullsym, sl_evalsym, sl_fnsym;
-value_t sl_nulsym, sl_alarmsym, sl_backspacesym, sl_tabsym, sl_linefeedsym, sl_newlinesym;
-value_t sl_vtabsym, sl_pagesym, sl_returnsym, sl_escsym, sl_spacesym, sl_deletesym;
-value_t sl_errio, sl_errparse, sl_errtype, sl_errarg, sl_errmem;
-value_t sl_errdiv0, sl_errbounds, sl_err, sl_errkey, sl_errunbound;
+sl_v sl_builtins_table_sym, sl_quote, sl_lambda, sl_function, sl_comma, sl_commaat;
+sl_v sl_commadot, sl_trycatch, sl_backquote;
+sl_v sl_conssym, sl_symbolsym, sl_fixnumsym, sl_vectorsym, sl_builtinsym, sl_vu8sym;
+sl_v sl_defsym, sl_defmacrosym, sl_forsym, sl_setqsym;
+sl_v sl_booleansym, sl_nullsym, sl_evalsym, sl_fnsym;
+sl_v sl_nulsym, sl_alarmsym, sl_backspacesym, sl_tabsym, sl_linefeedsym, sl_newlinesym;
+sl_v sl_vtabsym, sl_pagesym, sl_returnsym, sl_escsym, sl_spacesym, sl_deletesym;
+sl_v sl_errio, sl_errparse, sl_errtype, sl_errarg, sl_errmem;
+sl_v sl_errdiv0, sl_errbounds, sl_err, sl_errkey, sl_errunbound;
-value_t sl_printwidthsym, sl_printreadablysym, sl_printprettysym, sl_printlengthsym;
-value_t sl_printlevelsym;
-value_t sl_tablesym, sl_arraysym;
-value_t sl_iostreamsym, sl_rdsym, sl_wrsym, sl_apsym, sl_crsym, sl_truncsym;
-value_t sl_instrsym, sl_outstrsym;
-value_t sl_s8sym, sl_u8sym, sl_s16sym, sl_u16sym, sl_s32sym, sl_u32sym;
-value_t sl_s64sym, sl_u64sym, sl_bignumsym;
-value_t sl_bytesym, sl_runesym, sl_floatsym, sl_doublesym;
-value_t sl_stringtypesym, sl_runestringtypesym;
+sl_v sl_printwidthsym, sl_printreadablysym, sl_printprettysym, sl_printlengthsym;
+sl_v sl_printlevelsym;
+sl_v sl_tablesym, sl_arraysym;
+sl_v sl_iostreamsym, sl_rdsym, sl_wrsym, sl_apsym, sl_crsym, sl_truncsym;
+sl_v sl_instrsym, sl_outstrsym;
+sl_v sl_s8sym, sl_u8sym, sl_s16sym, sl_u16sym, sl_s32sym, sl_u32sym;
+sl_v sl_s64sym, sl_u64sym, sl_bignumsym;
+sl_v sl_bytesym, sl_runesym, sl_floatsym, sl_doublesym;
+sl_v sl_stringtypesym, sl_runestringtypesym;
sl_thread(Sl *sl);
@@ -36,21 +36,21 @@
typedef struct {const char *name;
builtin_t fptr;
-}builtinspec_t;
+}sl_builtinspec;
bool
-isbuiltin(value_t x)
+isbuiltin(sl_v x)
{int i;
return tag(x) == TAG_FUNCTION && (i = uintval(x)) < nelem(builtins) && builtins[i].name != nil;
}
-static value_t apply_cl(int nargs) sl_hotfn;
+static sl_v apply_cl(int nargs) sl_hotfn;
// error utilities ------------------------------------------------------------
void
-free_readstate(sl_readstate_t *rs)
+free_readstate(sl_readstate *rs)
{htable_free(&rs->backrefs);
htable_free(&rs->gensyms);
@@ -65,7 +65,7 @@
}
#define sl_TRY \
- sl_exception_context_t _ctx; int l__tr, l__ca; \
+ sl_exctx _ctx; int l__tr, l__ca; \
_ctx.sp = SL(sp); _ctx.frame = SL(curr_frame); _ctx.rdst = SL(readstate); _ctx.prev = SL(exctx); \
_ctx.ngchnd = SL(ngchandles); SL(exctx) = &_ctx; \
if(!sl_setjmp(_ctx.buf)) \
@@ -83,7 +83,7 @@
for(l__ca = 1; l__ca;)
void
-sl_savestate(sl_exception_context_t *_ctx)
+sl_savestate(sl_exctx *_ctx)
{_ctx->sp = SL(sp);
_ctx->frame = SL(curr_frame);
@@ -93,7 +93,7 @@
}
void
-sl_restorestate(sl_exception_context_t *_ctx)
+sl_restorestate(sl_exctx *_ctx)
{SL(lasterror) = sl_nil;
SL(throwing_frame) = 0;
@@ -102,7 +102,7 @@
}
_Noreturn void
-sl_raise(value_t e)
+sl_raise(sl_v e)
{ios_flush(ios_stdout);
ios_flush(ios_stderr);
@@ -116,7 +116,7 @@
if(SL(throwing_frame) == 0)
SL(throwing_frame) = SL(curr_frame);
SL(ngchandles) = SL(exctx)->ngchnd;
- sl_exception_context_t *thisctx = SL(exctx);
+ sl_exctx *thisctx = SL(exctx);
if(SL(exctx)->prev) // don't throw past toplevel
SL(exctx) = SL(exctx)->prev;
sl_longjmp(thisctx->buf, 1);
@@ -123,7 +123,7 @@
}
_Noreturn void
-lerrorf(value_t e, const char *format, ...)
+lerrorf(sl_v e, const char *format, ...)
{char msgbuf[256];
va_list args;
@@ -131,29 +131,29 @@
PUSH(e);
va_start(args, format);
vsnprintf(msgbuf, sizeof(msgbuf), format, args);
- value_t msg = string_from_cstr(msgbuf);
+ sl_v msg = string_from_cstr(msgbuf);
va_end(args);
e = POP();
- sl_raise(sl_list2(e, msg));
+ sl_raise(mk_list2(e, msg));
}
_Noreturn void
-type_error(const char *expected, value_t got)
+type_error(const char *expected, sl_v got)
{- sl_raise(sl_listn(3, sl_errtype, symbol(expected, false), got));
+ sl_raise(mk_listn(3, sl_errtype, symbol(expected, false), got));
}
_Noreturn void
-bounds_error(value_t arr, value_t ind)
+bounds_error(sl_v arr, sl_v ind)
{- sl_raise(sl_listn(3, sl_errbounds, arr, ind));
+ sl_raise(mk_listn(3, sl_errbounds, arr, ind));
}
_Noreturn void
-unbound_error(value_t sym)
+unbound_error(sl_v sym)
{- sl_raise(sl_listn(2, sl_errunbound, sym));
+ sl_raise(mk_listn(2, sl_errunbound, sym));
}
_Noreturn void
@@ -166,28 +166,28 @@
#define isstring sl_isstring
#define SAFECAST_OP(type, ctype, cnvt) \
- ctype to##type(value_t v) \
+ ctype to##type(sl_v v) \
{ \if(sl_likely(is##type(v))) \
return (ctype)cnvt(v); \
type_error(#type, v); \
}
-SAFECAST_OP(cons, cons_t*, ptr)
-SAFECAST_OP(symbol, symbol_t*, ptr)
-SAFECAST_OP(fixnum, fixnum_t, numval)
-//SAFECAST_OP(cvalue, cvalue_t*, ptr)
+SAFECAST_OP(cons, sl_cons*, ptr)
+SAFECAST_OP(symbol, sl_sym*, ptr)
+SAFECAST_OP(fixnum, sl_fx, numval)
+//SAFECAST_OP(cvalue, csl_v*, ptr)
SAFECAST_OP(string, char*, cvalue_data)
#undef isstring
// symbol table ---------------------------------------------------------------
-static symbol_t *
+static sl_sym *
mk_symbol(const char *str, int len, bool copy)
{- symbol_t *sym = MEM_ALLOC(sizeof(*sym) + (copy ? len+1 : 0));
+ sl_sym *sym = MEM_ALLOC(sizeof(*sym) + (copy ? len+1 : 0));
sym->numtype = NONNUMERIC;
if(str[0] == ':' && str[1] != 0){- value_t s = tagptr(sym, TAG_SYM);
+ sl_v s = tagptr(sym, TAG_SYM);
sym->flags = FLAG_KEYWORD;
setc(s, s);
}else{@@ -206,11 +206,11 @@
return sym;
}
-value_t
+sl_v
symbol(const char *str, bool copy)
{int len = strlen(str);
- symbol_t *v;
+ sl_sym *v;
const char *k;
if(!Tgetkv(SL(symtab), str, len, &k, (void**)&v)){v = mk_symbol(str, len, copy);
@@ -219,10 +219,10 @@
return tagptr(v, TAG_SYM);
}
-value_t
+sl_v
csymbol_(const char *str, int len)
{- symbol_t *v = mk_symbol(str, len, false);
+ sl_sym *v = mk_symbol(str, len, false);
SL(symtab) = Tsetl(SL(symtab), str, len, v);
return tagptr(v, TAG_SYM);
}
@@ -231,7 +231,7 @@
{argcount(nargs, 0);
USED(args);
- gensym_t *gs = alloc_words(sizeof(gensym_t)/sizeof(value_t));
+ sl_gensym *gs = alloc_words(sizeof(sl_gensym)/sizeof(sl_v));
gs->id = SL(gensym_ctr)++;
gs->binding = UNBOUND;
gs->type = nil;
@@ -238,7 +238,7 @@
return tagptr(gs, TAG_SYM);
}
-value_t
+sl_v
gensym(void)
{return fn_builtin_gensym(nil, 0);
@@ -252,7 +252,7 @@
}
char *
-uint2str(char *dest, size_t len, u64int num, int base)
+uint2str(char *dest, usize len, u64int num, int base)
{int i = len-1;
u64int b = (u64int)base;
@@ -273,29 +273,29 @@
}
const char *
-symbol_name(value_t v)
+symbol_name(sl_v v)
{ if(ismanaged(v)){- gensym_t *gs = ptr(v);
+ sl_gensym *gs = ptr(v);
SL(gsnameno) = 1-SL(gsnameno);
char *n = uint2str(SL(gsname)[SL(gsnameno)]+1, sizeof(SL(gsname)[0])-1, gs->id, 10);
*(--n) = 'g';
return n;
}
- return ((symbol_t*)ptr(v))->name;
+ return ((sl_sym*)ptr(v))->name;
}
// conses ---------------------------------------------------------------------
-value_t
-mk_cons(void)
+sl_v
+alloc_cons(void)
{- cons_t *c;
+ sl_cons *c;
if(sl_unlikely(SL(curheap) > SL(lim)))
sl_gc(false);
- c = (cons_t*)SL(curheap);
- SL(curheap) += sizeof(cons_t);
+ c = (sl_cons*)SL(curheap);
+ SL(curheap) += sizeof(sl_cons);
return tagptr(c, TAG_CONS);
}
@@ -302,7 +302,7 @@
void *
alloc_words(int n)
{- value_t *first;
+ sl_v *first;
#if !defined(BITS64)
// force 8-byte alignment
@@ -309,26 +309,26 @@
if(n & 1)
n++;
#endif
- if(sl_unlikely((value_t*)SL(curheap) > (value_t*)SL(lim)+2-n)){+ if(sl_unlikely((sl_v*)SL(curheap) > (sl_v*)SL(lim)+2-n)){sl_gc(false);
- while(sl_unlikely((value_t*)SL(curheap) > ((value_t*)SL(lim))+2-n))
+ while(sl_unlikely((sl_v*)SL(curheap) > ((sl_v*)SL(lim))+2-n))
sl_gc(true);
}
- first = (value_t*)SL(curheap);
- SL(curheap) += n*sizeof(value_t);
+ first = (sl_v*)SL(curheap);
+ SL(curheap) += n*sizeof(sl_v);
return first;
}
-value_t
-alloc_vector(size_t n, bool init)
+sl_v
+alloc_vector(usize n, bool init)
{if(n == 0)
return SL(the_empty_vector);
- value_t *c = alloc_words(n+1);
- value_t v = tagptr(c, TAG_VECTOR);
+ sl_v *c = alloc_words(n+1);
+ sl_v v = tagptr(c, TAG_VECTOR);
vector_setsize(v, n);
if(init){- for(size_t i = 0; i < n; i++)
+ for(usize i = 0; i < n; i++)
vector_elt(v, i) = sl_void;
}
return v;
@@ -337,7 +337,7 @@
// collector ------------------------------------------------------------------
void
-sl_gc_handle(value_t *pv)
+sl_gc_handle(sl_v *pv)
{if(sl_unlikely(SL(ngchandles) >= N_GC_HANDLES))
lerrorf(sl_errmem, "out of gc handles");
@@ -351,10 +351,10 @@
SL(ngchandles) -= n;
}
-value_t
-relocate(value_t v)
+sl_v
+relocate(sl_v v)
{- value_t a, d, nc, first, *pcdr;
+ sl_v a, d, nc, first, *pcdr;
if(isfixnum(v))
return v;
@@ -370,8 +370,8 @@
return first;
}
d = cdr_(v);
- *pcdr = nc = tagptr((cons_t*)SL(curheap), TAG_CONS);
- SL(curheap) += sizeof(cons_t);
+ *pcdr = nc = tagptr((sl_cons*)SL(curheap), TAG_CONS);
+ SL(curheap) += sizeof(sl_cons);
forward(v, nc);
car_(nc) = ismanaged(a) ? relocate(a) : a;
pcdr = &cdr_(nc);
@@ -390,7 +390,7 @@
return cvalue_relocate(v);
if(t == TAG_VECTOR){// N.B.: 0-length vectors secretly have space for a first element
- size_t i, sz = vector_size(v);
+ usize i, sz = vector_size(v);
if(vector_elt(v, -1) & 0x1){// grown vector
nc = relocate(vector_elt(v, 0));
@@ -409,8 +409,8 @@
return nc;
}
if(t == TAG_FUNCTION){- function_t *fn = ptr(v);
- function_t *nfn = alloc_words(sizeof(function_t)/sizeof(value_t));
+ sl_fn *fn = ptr(v);
+ sl_fn *nfn = alloc_words(sizeof(sl_fn)/sizeof(sl_v));
nfn->vals = fn->vals;
nfn->bcode = fn->bcode;
nc = tagptr(nfn, TAG_FUNCTION);
@@ -423,8 +423,8 @@
return nc;
}
if(t == TAG_SYM){- gensym_t *gs = ptr(v);
- gensym_t *ng = alloc_words(sizeof(gensym_t)/sizeof(value_t));
+ sl_gensym *gs = ptr(v);
+ sl_gensym *ng = alloc_words(sizeof(sl_gensym)/sizeof(sl_v));
ng->id = gs->id;
ng->binding = gs->binding;
ng->type = gs->type;
@@ -435,11 +435,11 @@
return nc;
}
if(t == TAG_CPRIM){- cprim_t *pcp = ptr(v);
- size_t nw = CPRIM_NWORDS+NWORDS(cp_class(pcp)->size);
- cprim_t *ncp = alloc_words(nw);
+ sl_cprim *pcp = ptr(v);
+ usize nw = CPRIM_NWORDS+NWORDS(cp_class(pcp)->size);
+ sl_cprim *ncp = alloc_words(nw);
while(nw--)
- ((value_t*)ncp)[nw] = ((value_t*)pcp)[nw];
+ ((sl_v*)ncp)[nw] = ((sl_v*)pcp)[nw];
nc = tagptr(ncp, TAG_CPRIM);
forward(v, nc);
return nc;
@@ -451,7 +451,7 @@
trace_globals(void)
{const char *k = nil;
- symbol_t *v;
+ sl_sym *v;
while(Tnext(SL(symtab), &k, (void**)&v)){if(v->binding != UNBOUND)
v->binding = relocate(v->binding);
@@ -464,41 +464,41 @@
SL(gccalls)++;
SL(curheap) = SL(tospace);
if(SL(grew))
- SL(lim) = SL(curheap)+SL(heapsize)*2-sizeof(cons_t);
+ SL(lim) = SL(curheap)+SL(heapsize)*2-sizeof(sl_cons);
else
- SL(lim) = SL(curheap)+SL(heapsize)-sizeof(cons_t);
+ SL(lim) = SL(curheap)+SL(heapsize)-sizeof(sl_cons);
- value_t *top, *f;
+ sl_v *top, *f;
if(SL(throwing_frame) > SL(curr_frame)){top = SL(throwing_frame) - 3;
- f = (value_t*)*top;
+ f = (sl_v*)*top;
}else{top = SL(sp);
f = SL(curr_frame);
}
for(;;){- for(value_t *p = f; p < top; p++)
+ for(sl_v *p = f; p < top; p++)
*p = relocate(*p);
if(f == SL(stack))
break;
top = f - 3;
- f = (value_t*)*top;
+ f = (sl_v*)*top;
}
for(int i = 0; i < SL(ngchandles); i++)
*SL(gchandles)[i] = relocate(*SL(gchandles)[i]);
trace_globals();
relocate_typetable();
- sl_readstate_t *rs = SL(readstate);
+ sl_readstate *rs = SL(readstate);
while(rs){- value_t ent;
+ sl_v ent;
for(int i = 0; i < rs->backrefs.size; i++){- ent = (value_t)rs->backrefs.table[i];
- if(ent != (value_t)HT_NOTFOUND)
+ ent = (sl_v)rs->backrefs.table[i];
+ if(ent != (sl_v)HT_NOTFOUND)
rs->backrefs.table[i] = (void*)relocate(ent);
}
for(int i = 0; i < rs->gensyms.size; i++){- ent = (value_t)rs->gensyms.table[i];
- if(ent != (value_t)HT_NOTFOUND)
+ ent = (sl_v)rs->gensyms.table[i];
+ if(ent != (sl_v)HT_NOTFOUND)
rs->gensyms.table[i] = (void*)relocate(ent);
}
rs->source = relocate(rs->source);
@@ -536,7 +536,7 @@
}
if(SL(grew)){SL(heapsize) *= 2;
- temp = bitvector_resize(SL(consflags), 0, SL(heapsize)/sizeof(cons_t), 1);
+ temp = bitvector_resize(SL(consflags), 0, SL(heapsize)/sizeof(sl_cons), 1);
if(sl_unlikely(temp == nil))
sl_raise(SL(memory_exception_value));
SL(consflags) = (u32int*)temp;
@@ -543,7 +543,7 @@
}
SL(grew) = !SL(grew);
}
- if(sl_unlikely((value_t*)SL(curheap) > (value_t*)SL(lim)-2)){+ if(sl_unlikely((sl_v*)SL(curheap) > (sl_v*)SL(lim)-2)){// all data was live; gc again and grow heap.
// but also always leave at least 4 words available, so a closure
// can be allocated without an extra check.
@@ -555,18 +555,18 @@
// apply function with n args on the stack
sl_hotfn
-static value_t
+static sl_v
_applyn(int n)
{- value_t *saveSP = SL(sp);
- value_t f = saveSP[-n-1];
- value_t v;
+ sl_v *saveSP = SL(sp);
+ sl_v f = saveSP[-n-1];
+ sl_v v;
if(iscbuiltin(f))
- v = ((cvalue_t*)ptr(f))->cbuiltin(saveSP-n, n);
+ v = ((csl_v*)ptr(f))->cbuiltin(saveSP-n, n);
else if(isfunction(f))
v = apply_cl(n);
else if(sl_likely(isbuiltin(f))){- value_t tab = symbol_value(sl_builtins_table_sym);
+ sl_v tab = symbol_value(sl_builtins_table_sym);
if(sl_unlikely(ptr(tab) == nil))
unbound_error(tab);
saveSP[-n-1] = vector_elt(tab, uintval(f));
@@ -578,10 +578,10 @@
return v;
}
-value_t
-sl_apply(value_t f, value_t v)
+sl_v
+sl_apply(sl_v f, sl_v v)
{- value_t *saveSP = SL(sp);
+ sl_v *saveSP = SL(sp);
PUSH(f);
int n;
@@ -596,8 +596,8 @@
return v;
}
-value_t
-sl_applyn(int n, value_t f, ...)
+sl_v
+sl_applyn(int n, sl_v f, ...)
{va_list ap;
va_start(ap, f);
@@ -604,28 +604,28 @@
PUSH(f);
for(int i = 0; i < n; i++){- value_t a = va_arg(ap, value_t);
+ sl_v a = va_arg(ap, sl_v);
PUSH(a);
}
- value_t v = _applyn(n);
+ sl_v v = _applyn(n);
POPN(n+1);
va_end(ap);
return v;
}
-value_t
-sl_listn(int n, ...)
+sl_v
+mk_listn(int n, ...)
{va_list ap;
va_start(ap, n);
- value_t *si = SL(sp);
+ sl_v *si = SL(sp);
for(int i = 0; i < n; i++){- value_t a = va_arg(ap, value_t);
+ sl_v a = va_arg(ap, sl_v);
PUSH(a);
}
- cons_t *c = alloc_words(n*2);
- cons_t *l = c;
+ sl_cons *c = alloc_words(n*2);
+ sl_cons *l = c;
for(int i = 0; i < n; i++){c->car = *si++;
c->cdr = tagptr(c+1, TAG_CONS);
@@ -638,12 +638,12 @@
return tagptr(l, TAG_CONS);
}
-value_t
-sl_list2(value_t a, value_t b)
+sl_v
+mk_list2(sl_v a, sl_v b)
{PUSH(a);
PUSH(b);
- cons_t *c = alloc_words(4);
+ sl_cons *c = alloc_words(4);
b = POP();
a = POP();
c[0].car = a;
@@ -653,12 +653,12 @@
return tagptr(c, TAG_CONS);
}
-value_t
-sl_cons(value_t a, value_t b)
+sl_v
+mk_cons(sl_v a, sl_v b)
{PUSH(a);
PUSH(b);
- value_t c = mk_cons();
+ sl_v c = alloc_cons();
cdr_(c) = POP();
car_(c) = POP();
return c;
@@ -665,12 +665,12 @@
}
bool
-sl_isnumber(value_t v)
+sl_isnumber(sl_v v)
{if(isfixnum(v) || ismp(v))
return true;
if(iscprim(v)){- cprim_t *c = ptr(v);
+ sl_cprim *c = ptr(v);
return c->type != SL(runetype) && valid_numtype(c->type->numtype);
}
return false;
@@ -679,13 +679,13 @@
// eval -----------------------------------------------------------------------
sl_hotfn
-static value_t
-list(value_t *args, int nargs, bool star)
+static sl_v
+list(sl_v *args, int nargs, bool star)
{if(sl_unlikely(nargs == 0))
return sl_nil;
- value_t v = cons_reserve(nargs);
- cons_t *c = ptr(v);
+ sl_v v = cons_reserve(nargs);
+ sl_cons *c = ptr(v);
for(int i = 0; i < nargs; i++){c->car = args[i];
c->cdr = tagptr(c+1, TAG_CONS);
@@ -698,23 +698,23 @@
return v;
}
-static value_t
-copy_list(value_t L)
+static sl_v
+copy_list(sl_v L)
{if(!iscons(L))
return sl_nil;
- value_t *plcons = SL(sp);
- value_t *pL = plcons+1;
+ sl_v *plcons = SL(sp);
+ sl_v *pL = plcons+1;
PUSH(sl_nil);
PUSH(L);
- value_t c;
- c = mk_cons(); PUSH(c); // save first cons
+ sl_v c;
+ c = alloc_cons(); PUSH(c); // save first cons
car_(c) = car_(*pL);
cdr_(c) = sl_nil;
*plcons = c;
*pL = cdr_(*pL);
while(iscons(*pL)){- c = mk_cons();
+ c = alloc_cons();
car_(c) = car_(*pL);
cdr_(c) = sl_nil;
cdr_(*plcons) = c;
@@ -726,12 +726,12 @@
return c;
}
-static value_t
+static sl_v
do_trycatch(void)
{- value_t *saveSP = SL(sp);
- value_t v = sl_nil;
- value_t thunk = saveSP[-2];
+ sl_v *saveSP = SL(sp);
+ sl_v v = sl_nil;
+ sl_v thunk = saveSP[-2];
SL(sp)[-2] = saveSP[-1];
SL(sp)[-1] = thunk;
@@ -753,15 +753,15 @@
|--required args--|--opt args--|--kw args--|--rest args...
*/
static int
-process_keys(value_t kwtable, int nreq, int nkw, int nopt, value_t *bp, int nargs, int va)
+process_keys(sl_v kwtable, int nreq, int nkw, int nopt, sl_v *bp, int nargs, int va)
{int extr = nopt+nkw;
int ntot = nreq+extr;
- value_t args[64], v = sl_nil;
+ sl_v args[64], v = sl_nil;
int i, a = 0, nrestargs;
- value_t s1 = SL(sp)[-1];
- value_t s3 = SL(sp)[-3];
- value_t s4 = SL(sp)[-4];
+ sl_v s1 = SL(sp)[-1];
+ sl_v s3 = SL(sp)[-3];
+ sl_v s4 = SL(sp)[-4];
if(sl_unlikely(nargs < nreq))
lerrorf(sl_errarg, "too few arguments");
if(sl_unlikely(extr > nelem(args)))
@@ -770,7 +770,7 @@
args[i] = UNBOUND;
for(i = nreq; i < nargs; i++){v = bp[i];
- if(issymbol(v) && iskeyword((symbol_t*)ptr(v)))
+ if(issymbol(v) && iskeyword((sl_sym*)ptr(v)))
break;
if(a >= nopt)
goto no_kw;
@@ -784,8 +784,8 @@
i++;
if(sl_unlikely(i >= nargs))
lerrorf(sl_errarg, "keyword %s requires an argument", symbol_name(v));
- value_t hv = fixnum(((symbol_t*)ptr(v))->hash);
- fixnum_t lx = numval(hv);
+ sl_v hv = fixnum(((sl_sym*)ptr(v))->hash);
+ sl_fx lx = numval(hv);
uintptr x = 2*((lx < 0 ? -lx : lx) % n);
if(sl_likely(vector_elt(kwtable, x) == v)){intptr idx = numval(vector_elt(kwtable, x+1));
@@ -802,7 +802,7 @@
if(i >= nargs)
break;
v = bp[i];
- }while(issymbol(v) && iskeyword((symbol_t*)ptr(v)));
+ }while(issymbol(v) && iskeyword((sl_sym*)ptr(v)));
no_kw:
nrestargs = nargs - i;
if(sl_unlikely(!va && nrestargs > 0))
@@ -809,8 +809,8 @@
lerrorf(sl_errarg, "too many arguments");
nargs = ntot + nrestargs;
if(nrestargs)
- memmove(bp+ntot, bp+i, nrestargs*sizeof(value_t));
- memmove(bp+nreq, args, extr*sizeof(value_t));
+ memmove(bp+ntot, bp+i, nrestargs*sizeof(sl_v));
+ memmove(bp+nreq, args, extr*sizeof(sl_v));
SL(sp) = bp + nargs;
assert((intptr)(SL(sp)-SL(stack)) < (intptr)SL(nstack)-4);
PUSH(s4);
@@ -842,11 +842,11 @@
- allocate vararg array
- push closed env, set up new environment
*/
-static value_t
+static sl_v
apply_cl(int nargs)
{- value_t *top_frame = SL(curr_frame), *bp, *ipd;
- register value_t *sp = SL(sp);
+ sl_v *top_frame = SL(curr_frame), *bp, *ipd;
+ register sl_v *sp = SL(sp);
const u8int *ip;
bool tail;
int n;
@@ -887,31 +887,31 @@
}
// top = top frame pointer to start at
-static value_t
-_stacktrace(value_t *top)
+static sl_v
+_stacktrace(sl_v *top)
{- value_t lst = sl_nil;
- value_t *stack = SL(stack);
+ sl_v lst = sl_nil;
+ sl_v *stack = SL(stack);
sl_gc_handle(&lst);
while(top > stack){const u8int *ip1 = (void*)top[-1];
int sz = top[-2]+1;
- value_t *bp = top-4-sz;
- value_t func = bp[0];
+ sl_v *bp = top-4-sz;
+ sl_v func = bp[0];
const u8int *ip0 = cvalue_data(fn_bcode(func));
intptr ip = ip1 - ip0 - 1; /* -1: ip1 is *after* the one that was being executed */
- value_t v = alloc_vector(sz+1, 0);
+ sl_v v = alloc_vector(sz+1, 0);
vector_elt(v, 0) = fixnum(ip);
vector_elt(v, 1) = func;
for(int i = 1; i < sz; i++){- value_t si = bp[i];
+ sl_v si = bp[i];
// if there's an error evaluating argument defaults some slots
// might be left set to UNBOUND
vector_elt(v, i+1) = si == UNBOUND ? sl_void : si;
}
- lst = sl_cons(v, lst);
- top = (value_t*)top[-3];
+ lst = mk_cons(v, lst);
+ top = (sl_v*)top[-3];
}
sl_free_gc_handles(1);
return lst;
@@ -937,17 +937,17 @@
type_error("string", args[0]);if(sl_unlikely(!isvector(args[1])))
type_error("vector", args[1]);- cvalue_t *arr = ptr(args[0]);
+ csl_v *arr = ptr(args[0]);
cv_pin(arr);
u8int *data = cv_data(arr);
if(SL(loading)){// read syntax, shifted 48 for compact text representation
- size_t i, sz = cv_len(arr);
+ usize i, sz = cv_len(arr);
for(i = 0; i < sz; i++)
data[i] -= 48;
}
- function_t *fn = alloc_words(sizeof(function_t)/sizeof(value_t));
- value_t fv = tagptr(fn, TAG_FUNCTION);
+ sl_fn *fn = alloc_words(sizeof(sl_fn)/sizeof(sl_v));
+ sl_v fv = tagptr(fn, TAG_FUNCTION);
fn->bcode = args[0];
fn->vals = args[1];
fn->env = sl_nil;
@@ -975,7 +975,7 @@
BUILTIN("function:code", function_code) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(sl_unlikely(!isfunction(v)))
type_error("function", v);return fn_bcode(v);
@@ -985,7 +985,7 @@
BUILTIN("function:vals", function_vals) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(sl_unlikely(!isfunction(v)))
type_error("function", v);return fn_vals(v);
@@ -995,7 +995,7 @@
BUILTIN("function:env", function_env) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(sl_unlikely(!isfunction(v)))
type_error("function", v);return fn_env(v);
@@ -1004,14 +1004,14 @@
BUILTIN("function:name", function_name) {argcount(nargs, 1);
- value_t v = args[0];
+ sl_v v = args[0];
if(isfunction(v))
return fn_name(v);
if(isbuiltin(v))
return symbol(builtins[uintval(v)].name, false);
if(iscbuiltin(v)){- v = (value_t)ptrhash_get(&SL(reverse_dlsym_lookup_table), ptr(v));
- if(v == (value_t)HT_NOTFOUND)
+ v = (sl_v)ptrhash_get(&SL(reverse_dlsym_lookup_table), ptr(v));
+ if(v == (sl_v)HT_NOTFOUND)
return sl_nil;
return v;
}
@@ -1026,7 +1026,7 @@
BUILTIN("append", append) {- value_t first = sl_nil, lst, lastcons = sl_nil;
+ sl_v first = sl_nil, lst, lastcons = sl_nil;
int i;
if(nargs == 0)
return sl_nil;
@@ -1040,7 +1040,7 @@
first = lst;
else
cdr_(lastcons) = lst;
- lastcons = tagptr((((cons_t*)SL(curheap))-1), TAG_CONS);
+ lastcons = tagptr((((sl_cons*)SL(curheap))-1), TAG_CONS);
}else if(lst != sl_nil){ type_error("cons", lst);}
@@ -1069,7 +1069,7 @@
{if(sl_unlikely(nargs < 2))
lerrorf(sl_errarg, "too few arguments");
- value_t *k = SL(sp);
+ sl_v *k = SL(sp);
PUSH(sl_nil);
PUSH(sl_nil);
for(bool first = true;;){@@ -1082,10 +1082,10 @@
PUSH(car(args[i]));
args[i] = cdr_(args[i]);
}
- value_t v = _applyn(nargs-1);
+ sl_v v = _applyn(nargs-1);
POPN(nargs);
PUSH(v);
- value_t c = mk_cons();
+ sl_v c = alloc_cons();
car_(c) = POP(); cdr_(c) = sl_nil;
if(first)
k[1] = c;
@@ -1100,11 +1100,11 @@
{if(sl_unlikely(nargs < 2))
lerrorf(sl_errarg, "too few arguments");
- for(size_t n = 0;; n++){+ for(usize n = 0;; n++){PUSH(args[0]);
int pargs = 0;
for(int i = 1; i < nargs; i++, pargs++){- value_t v = args[i];
+ sl_v v = args[i];
if(iscons(v)){PUSH(car_(v));
args[i] = cdr_(v);
@@ -1111,7 +1111,7 @@
continue;
}
if(isvector(v)){- size_t sz = vector_size(v);
+ usize sz = vector_size(v);
if(n < sz){PUSH(vector_elt(v, n));
continue;
@@ -1118,9 +1118,9 @@
}
}
if(isarray(v)){- size_t sz = cvalue_arraylen(v);
+ usize sz = cvalue_arraylen(v);
if(n < sz){- value_t a[2];
+ sl_v a[2];
a[0] = v;
a[1] = fixnum(n);
PUSH(cvalue_array_aref(a));
@@ -1128,7 +1128,7 @@
}
}
if(ishashtable(v)){- htable_t *h = totable(v);
+ sl_htable *h = totable(v);
assert(n != 0 || h->i == 0);
void **table = h->table;
for(; h->i < h->size; h->i += 2){@@ -1136,9 +1136,9 @@
break;
}
if(h->i < h->size){- PUSH((value_t)table[h->i]);
+ PUSH((sl_v)table[h->i]);
pargs++;
- PUSH((value_t)table[h->i+1]);
+ PUSH((sl_v)table[h->i+1]);
h->i += 2;
continue;
}
@@ -1168,7 +1168,7 @@
ios_printf(ios_stderr, "heap total %10"PRIuPTR" bytes\n", SL(heapsize));
ios_printf(ios_stderr, "heap free %10"PRIuPTR" bytes\n", (uintptr)(SL(lim)-SL(curheap)));
ios_printf(ios_stderr, "heap used %10"PRIuPTR" bytes\n", (uintptr)(SL(curheap)-SL(fromspace)));
- ios_printf(ios_stderr, "stack %10"PRIu64" bytes\n", (u64int)SL(nstack)*sizeof(value_t));
+ ios_printf(ios_stderr, "stack %10"PRIu64" bytes\n", (u64int)SL(nstack)*sizeof(sl_v));
ios_printf(ios_stderr, "finalizers %10"PRIu32"\n", (u32int)SL(nfinalizers));
ios_printf(ios_stderr, "max finalizers %10"PRIu32"\n", (u32int)SL(maxfinalizers));
ios_printf(ios_stderr, "gc handles %10"PRIu32"\n", (u32int)SL(ngchandles));
@@ -1177,7 +1177,7 @@
return sl_void;
}
-static const builtinspec_t builtin_fns[] = {+static const sl_builtinspec builtin_fns[] = { #define BUILTIN_FN(l, c, attr){l, (builtin_t)fn_builtin_##c},#include "builtin_fns.h"
#undef BUILTIN_FN
@@ -1186,7 +1186,7 @@
// initialization -------------------------------------------------------------
int
-sl_init(size_t heapsize, size_t stacksize)
+sl_init(usize heapsize, usize stacksize)
{int i;
@@ -1194,7 +1194,7 @@
return -1;
SL(scr_width) = 100;
- SL(heapsize) = heapsize*sizeof(value_t);
+ SL(heapsize) = heapsize*sizeof(sl_v);
if((SL(fromspace) = sl_segalloc(SL(heapsize))) == nil){failed:
@@ -1202,7 +1202,7 @@
MEM_FREE(SL(finalizers));
sl_segfree(SL(fromspace), SL(heapsize));
sl_segfree(SL(tospace), SL(heapsize));
- sl_segfree(SL(stack), stacksize*sizeof(value_t));
+ sl_segfree(SL(stack), stacksize*sizeof(sl_v));
htable_free(&SL(printconses));
MEM_FREE(sl);
return -1;
@@ -1211,9 +1211,9 @@
if((SL(tospace) = sl_segalloc(SL(heapsize))) == nil)
goto failed;
SL(curheap) = SL(fromspace);
- SL(lim) = SL(curheap)+SL(heapsize)-sizeof(cons_t);
+ SL(lim) = SL(curheap)+SL(heapsize)-sizeof(sl_cons);
- if((SL(stack) = sl_segalloc(stacksize*sizeof(value_t))) == nil)
+ if((SL(stack) = sl_segalloc(stacksize*sizeof(sl_v))) == nil)
goto failed;
SL(curr_frame) = SL(sp) = SL(stack);
SL(nstack) = stacksize;
@@ -1222,7 +1222,7 @@
if((SL(finalizers) = MEM_ALLOC(SL(maxfinalizers) * sizeof(*SL(finalizers)))) == nil)
goto failed;
- if((SL(consflags) = bitvector_new(SL(heapsize)/sizeof(cons_t), 1)) == nil)
+ if((SL(consflags) = bitvector_new(SL(heapsize)/sizeof(sl_cons), 1)) == nil)
goto failed;
if((htable_new(&SL(printconses), 32)) == nil)
goto failed;
@@ -1298,9 +1298,9 @@
#if defined(__os_version__)
set(csymbol("*os-version*"), cvalue_static_cstring(__os_version__));#endif
- SL(memory_exception_value) = sl_list2(sl_errmem, cvalue_static_cstring("out of memory"));+ SL(memory_exception_value) = mk_list2(sl_errmem, cvalue_static_cstring("out of memory"));- const builtinspec_t *b;
+ const sl_builtinspec *b;
for(i = 0, b = builtin_fns; i < nelem(builtin_fns); i++, b++)
cbuiltin(b->name, b->fptr);
table_init();
@@ -1311,23 +1311,23 @@
// top level ------------------------------------------------------------------
-value_t
-sl_toplevel_eval(value_t expr)
+sl_v
+sl_toplevel_eval(sl_v expr)
{return sl_applyn(1, symbol_value(sl_evalsym), expr);
}
int
-sl_load_system_image(value_t sys_image_iostream)
+sl_load_system_image(sl_v sys_image_iostream)
{SL(loading) = true;
PUSH(sys_image_iostream);
- value_t *saveSP = SL(sp);
+ sl_v *saveSP = SL(sp);
sl_TRY{ while(1){SL(sp) = saveSP;
- value_t e = sl_read_sexpr(SL(sp)[-1]);
- if(ios_eof(value2c(ios_t*, SL(sp)[-1])))
+ sl_v e = sl_read_sexpr(SL(sp)[-1]);
+ if(ios_eof(value2c(sl_ios*, SL(sp)[-1])))
break;
if(isfunction(e)){// stage 0 format: series of thunks
@@ -1336,7 +1336,7 @@
}else{// stage 1 format: list alternating symbol/value
while(iscons(e)){- symbol_t *sym = tosymbol(car_(e));
+ sl_sym *sym = tosymbol(car_(e));
e = cdr_(e);
if(sym->binding != UNBOUND)
ios_printf(ios_stderr, "%s redefined on boot\n", sym->name);
--- a/src/sl.h
+++ b/src/sl.h
@@ -8,7 +8,7 @@
#include "htableh.inc"
HTPROT(ptrhash)
-typedef struct sltype_t sltype_t;
+typedef struct sl_type sl_type;
enum {TAG_NUM,
@@ -37,18 +37,18 @@
T_MP,
T_FLOAT,
T_DOUBLE,
-}numerictype_t;
+}sl_numtype;
-typedef uintptr value_t;
+typedef uintptr sl_v;
#if defined(BITS64)
-typedef s64int fixnum_t;
+typedef s64int sl_fx;
#define FIXNUM_BITS 62
#define TOP_BIT (1ULL<<63)
#define T_FIXNUM T_S64
#define PRIdFIXNUM PRId64
#else
-typedef s32int fixnum_t;
+typedef s32int sl_fx;
#define FIXNUM_BITS 30
#define TOP_BIT (1U<<31)
#define T_FIXNUM T_S32
@@ -60,28 +60,28 @@
#endif
typedef struct {- value_t car;
- value_t cdr;
-}sl_aligned(8) cons_t;
+ sl_v car;
+ sl_v cdr;
+}sl_aligned(8) sl_cons;
-// NOTE: symbol_t MUST have the same fields as gensym_t first
+// NOTE: sl_sym MUST have the same fields as sl_gensym first
// there are places where gensyms are treated as normal symbols
typedef struct {u64int hash;
- sltype_t *type;
- value_t binding; // global value binding
+ sl_type *type;
+ sl_v binding; // global value binding
u8int numtype;
u8int size;
u8int flags;
u8int _dummy;
const char *name;
-}sl_aligned(8) symbol_t;
+}sl_aligned(8) sl_sym;
typedef struct {u64int id;
- sltype_t *type;
- value_t binding;
-}sl_aligned(8) gensym_t;
+ sl_type *type;
+ sl_v binding;
+}sl_aligned(8) sl_gensym;
typedef struct Builtin Builtin;
@@ -90,7 +90,7 @@
int nargs;
};
-typedef value_t (*builtin_t)(value_t*, int);
+typedef sl_v (*builtin_t)(sl_v*, int);
#define fits_bits(x, b) (((x)>>(b-1)) == 0 || (~((x)>>(b-1))) == 0)
#define fits_fixnum(x) fits_bits(x, FIXNUM_BITS)
@@ -98,14 +98,14 @@
#define ANYARGS -10000
#define NONNUMERIC (0xff)
#define valid_numtype(v) ((v) <= T_DOUBLE)
-#define UNBOUND ((value_t)1) // an invalid value
+#define UNBOUND ((sl_v)1) // an invalid value
#define tag(x) ((x) & 7)
#define ptr(x) ((void*)((uintptr)(x) & (~(uintptr)7)))
-#define tagptr(p, t) ((value_t)(p) | (t))
-#define fixnum(x) ((value_t)(x)<<2)
-#define numval(x) ((fixnum_t)(x)>>2)
+#define tagptr(p, t) ((sl_v)(p) | (t))
+#define fixnum(x) ((sl_v)(x)<<2)
+#define numval(x) ((sl_fx)(x)>>2)
#define uintval(x) (((unsigned int)(x))>>3)
-#define builtin(n) tagptr(((value_t)n<<3), TAG_FUNCTION)
+#define builtin(n) tagptr(((sl_v)n<<3), TAG_FUNCTION)
#define iscons(x) (tag(x) == TAG_CONS)
#define issymbol(x) (tag(x) == TAG_SYM)
#define isfixnum(x) (((x)&3) == TAG_NUM)
@@ -118,42 +118,42 @@
// allocate n consecutive conses
#define cons_reserve(n) tagptr(alloc_words((n)*2), TAG_CONS)
-#define cons_index(c) (((cons_t*)ptr(c))-((cons_t*)SL(fromspace)))
+#define cons_index(c) (((sl_cons*)ptr(c))-((sl_cons*)SL(fromspace)))
#define ismarked(c) bitvector_get(SL(consflags), cons_index(c))
#define mark_cons(c) bitvector_set(SL(consflags), cons_index(c))
#define unmark_cons(c) bitvector_reset(SL(consflags), cons_index(c))
-#define isforwarded(v) (*(value_t*)ptr(v) & FWD_BIT)
-#define forwardloc(v) (*(value_t*)ptr(v) ^ FWD_BIT)
+#define isforwarded(v) (*(sl_v*)ptr(v) & FWD_BIT)
+#define forwardloc(v) (*(sl_v*)ptr(v) ^ FWD_BIT)
#define forward(v, to) \
do{ \- *(value_t*)ptr(v) = (value_t)(to) | FWD_BIT; \
+ *(sl_v*)ptr(v) = (sl_v)(to) | FWD_BIT; \
}while(0)
-#define vector_size(v) (((size_t*)ptr(v))[0]>>2)
-#define vector_setsize(v, n) (((size_t*)ptr(v))[0] = ((n)<<2))
-#define vector_elt(v, i) (((value_t*)ptr(v))[1+(i)])
+#define vector_size(v) (((usize*)ptr(v))[0]>>2)
+#define vector_setsize(v, n) (((usize*)ptr(v))[0] = ((n)<<2))
+#define vector_elt(v, i) (((sl_v*)ptr(v))[1+(i)])
#define vector_grow_amt(x) ((x)<8 ? 5 : 6*((x)>>3))
// functions ending in _ are unsafe, faster versions
-#define car_(v) (((cons_t*)ptr(v))->car)
-#define cdr_(v) (((cons_t*)ptr(v))->cdr)
+#define car_(v) (((sl_cons*)ptr(v))->car)
+#define cdr_(v) (((sl_cons*)ptr(v))->cdr)
#define car(v) (tocons(v)->car)
#define cdr(v) (tocons(v)->cdr)
-#define fn_bcode(f) (((function_t*)ptr(f))->bcode)
-#define fn_vals(f) (((function_t*)ptr(f))->vals)
-#define fn_env(f) (((function_t*)ptr(f))->env)
-#define fn_name(f) (((function_t*)ptr(f))->name)
-#define set(s, v) (((symbol_t*)ptr(s))->binding = (v))
+#define fn_bcode(f) (((sl_fn*)ptr(f))->bcode)
+#define fn_vals(f) (((sl_fn*)ptr(f))->vals)
+#define fn_env(f) (((sl_fn*)ptr(f))->env)
+#define fn_name(f) (((sl_fn*)ptr(f))->name)
+#define set(s, v) (((sl_sym*)ptr(s))->binding = (v))
#define setc(s, v) \
do{ \- symbol_t *sy = (symbol_t*)ptr(s); \
+ sl_sym *sy = (sl_sym*)ptr(s); \
sy->flags |= FLAG_CONST; \
sy->binding = (v); \
}while(0)
#define isconstant(s) ((s)->flags & FLAG_CONST)
#define iskeyword(s) ((s)->flags & FLAG_KEYWORD)
-#define symbol_value(s) (((symbol_t*)ptr(s))->binding)
-#define sym_to_numtype(s) (((symbol_t*)ptr(s))->numtype)
+#define symbol_value(s) (((sl_sym*)ptr(s))->binding)
+#define sym_to_numtype(s) (((sl_sym*)ptr(s))->numtype)
#define ismanaged(v) ((((u8int*)ptr(v)) >= SL(fromspace)) && (((u8int*)ptr(v)) < SL(fromspace)+SL(heapsize)))
#define isgensym(x) (issymbol(x) && ismanaged(x))
#define isfunction(x) (tag(x) == TAG_FUNCTION && (x) > (N_BUILTINS<<3))
@@ -174,36 +174,36 @@
}while(0)
#define POP() *(--SL(sp))
-bool isbuiltin(value_t x) sl_constfn sl_hotfn;
-int sl_init(size_t heapsize, size_t stacksize);
-int sl_load_system_image(value_t ios);
+bool isbuiltin(sl_v x) sl_constfn sl_hotfn;
+int sl_init(usize heapsize, usize stacksize);
+int sl_load_system_image(sl_v ios);
_Noreturn void sl_exit(int status);
/* collector */
-value_t relocate(value_t v) sl_hotfn;
+sl_v relocate(sl_v v) sl_hotfn;
void sl_gc(bool mustgrow);
-void sl_gc_handle(value_t *pv);
+void sl_gc_handle(sl_v *pv);
void sl_free_gc_handles(int n);
/* symbol table */
-value_t gensym(void);
-value_t symbol(const char *str, bool copy) sl_hotfn;
-value_t csymbol_(const char *str, int len);
+sl_v gensym(void);
+sl_v symbol(const char *str, bool copy) sl_hotfn;
+sl_v csymbol_(const char *str, int len);
#define csymbol(str) csymbol_(str, sizeof(str)-1)
-const char *symbol_name(value_t v);
+const char *symbol_name(sl_v v);
/* read, eval, print main entry points */
-value_t sl_toplevel_eval(value_t expr);
-value_t sl_apply(value_t f, value_t l);
-value_t sl_applyn(int n, value_t f, ...);
+sl_v sl_toplevel_eval(sl_v expr);
+sl_v sl_apply(sl_v f, sl_v l);
+sl_v sl_applyn(int n, sl_v f, ...);
/* object model manipulation */
-value_t sl_cons(value_t a, value_t b);
-value_t sl_list2(value_t a, value_t b);
-value_t sl_listn(int n, ...);
-bool sl_isnumber(value_t v) sl_purefn;
-value_t alloc_vector(size_t n, bool init);
+sl_v mk_cons(sl_v a, sl_v b);
+sl_v mk_list2(sl_v a, sl_v b);
+sl_v mk_listn(int n, ...);
+bool sl_isnumber(sl_v v) sl_purefn;
+sl_v alloc_vector(usize n, bool init);
/* consistent iswprint and wcwidth */
int sl_iswprint(Rune c) sl_constfn;
@@ -210,39 +210,39 @@
int sl_wcwidth(Rune c) sl_constfn;
/* safe casts */
-cons_t *tocons(value_t v) sl_purefn;
-symbol_t *tosymbol(value_t v) sl_purefn;
-fixnum_t tofixnum(value_t v) sl_purefn;
-char *tostring(value_t v) sl_purefn;
-double todouble(value_t a) sl_purefn;
+sl_cons *tocons(sl_v v) sl_purefn;
+sl_sym *tosymbol(sl_v v) sl_purefn;
+sl_fx tofixnum(sl_v v) sl_purefn;
+char *tostring(sl_v v) sl_purefn;
+double todouble(sl_v a) sl_purefn;
/* conses */
-value_t mk_cons(void) sl_hotfn;
+sl_v alloc_cons(void) sl_hotfn;
void *alloc_words(int n) sl_hotfn;
-char *uint2str(char *dest, size_t len, u64int num, int base);
+char *uint2str(char *dest, usize len, u64int num, int base);
/* error handling */
-typedef struct _sl_readstate_t {- htable_t backrefs;
- htable_t gensyms;
- value_t source;
- struct _sl_readstate_t *prev;
-}sl_readstate_t;
+typedef struct _sl_readstate {+ sl_htable backrefs;
+ sl_htable gensyms;
+ sl_v source;
+ struct _sl_readstate *prev;
+}sl_readstate;
typedef struct _ectx_t {- sl_readstate_t *rdst;
+ sl_readstate *rdst;
struct _ectx_t *prev;
jmp_buf buf;
- value_t *sp;
- value_t *frame;
+ sl_v *sp;
+ sl_v *frame;
int ngchnd;
-}sl_exception_context_t;
+}sl_exctx;
-void free_readstate(sl_readstate_t *rs);
+void free_readstate(sl_readstate *rs);
#define sl_TRY_EXTERN \
- sl_exception_context_t _ctx; int l__tr, l__ca; \
+ sl_exctx _ctx; int l__tr, l__ca; \
sl_savestate(&_ctx); SL(exctx) = &_ctx; \
if(!sl_setjmp(_ctx.buf)) \
for(l__tr = 1; l__tr; l__tr = 0, (void)(SL(exctx) = SL(exctx)->prev))
@@ -255,13 +255,13 @@
else \
for(l__ca=1; l__ca; l__ca=0, sl_restorestate(&_ctx))
-_Noreturn void lerrorf(value_t e, const char *format, ...) sl_printfmt(2, 3);
-void sl_savestate(sl_exception_context_t *_ctx);
-void sl_restorestate(sl_exception_context_t *_ctx);
-_Noreturn void sl_raise(value_t e);
-_Noreturn void type_error(const char *expected, value_t got);
-_Noreturn void bounds_error(value_t arr, value_t ind);
-_Noreturn void unbound_error(value_t sym);
+_Noreturn void lerrorf(sl_v e, const char *format, ...) sl_printfmt(2, 3);
+void sl_savestate(sl_exctx *_ctx);
+void sl_restorestate(sl_exctx *_ctx);
+_Noreturn void sl_raise(sl_v e);
+_Noreturn void type_error(const char *expected, sl_v got);
+_Noreturn void bounds_error(sl_v arr, sl_v ind);
+_Noreturn void unbound_error(sl_v sym);
_Noreturn void arity_error(int nargs, int c);
#define argcount(nargs, c) \
@@ -271,61 +271,61 @@
}while(0)
typedef struct {- void (*print)(value_t self, ios_t *f);
- void (*relocate)(value_t oldv, value_t newv);
- void (*finalize)(value_t self);
- void (*print_traverse)(value_t self);
-} cvtable_t;
+ void (*print)(sl_v self, sl_ios *f);
+ void (*relocate)(sl_v oldv, sl_v newv);
+ void (*finalize)(sl_v self);
+ void (*print_traverse)(sl_v self);
+} sl_cvtable;
-typedef void (*cvinitfunc_t)(sltype_t*, value_t, void*);
+typedef void (*cvinitfunc_t)(sl_type*, sl_v, void*);
-struct sltype_t {- value_t type;
- cvtable_t *vtable;
- sltype_t *eltype; // for arrays
- sltype_t *artype; // (array this)
+struct sl_type {+ sl_v type;
+ sl_cvtable *vtable;
+ sl_type *eltype; // for arrays
+ sl_type *artype; // (array this)
cvinitfunc_t init;
- size_t size;
- size_t elsz;
- numerictype_t numtype;
+ usize size;
+ usize elsz;
+ sl_numtype numtype;
};
typedef struct {- sltype_t *type;
+ sl_type *type;
union {void *data;
builtin_t cbuiltin;
};
- size_t len; // length of *data in bytes
+ usize len; // length of *data in bytes
u8int _space[]; // variable size
-}sl_aligned(8) cvalue_t;
+}sl_aligned(8) csl_v;
typedef struct {- sltype_t *type;
+ sl_type *type;
u8int _space[];
-}sl_aligned(8) cprim_t;
+}sl_aligned(8) sl_cprim;
typedef struct {- value_t vals;
- value_t bcode;
- value_t env;
- value_t name;
-}sl_aligned(8) function_t;
+ sl_v vals;
+ sl_v bcode;
+ sl_v env;
+ sl_v name;
+}sl_aligned(8) sl_fn;
-#define CPRIM_NWORDS sizeof(cprim_t)/sizeof(value_t)
-#define cv_class(cv) ((sltype_t*)(((uintptr)((cvalue_t*)cv)->type)&~(uintptr)3))
-#define cv_len(cv) (((cvalue_t*)(cv))->len)
+#define CPRIM_NWORDS sizeof(sl_cprim)/sizeof(sl_v)
+#define cv_class(cv) ((sl_type*)(((uintptr)((csl_v*)cv)->type)&~(uintptr)3))
+#define cv_len(cv) (((csl_v*)(cv))->len)
#define cv_type(cv) (cv_class(cv)->type)
-#define cv_data(cv) (((cvalue_t*)(cv))->data)
+#define cv_data(cv) (((csl_v*)(cv))->data)
#define cv_isstr(cv) (cv_class(cv)->eltype == SL(bytetype))
#define cv_isPOD(cv) (cv_class(cv)->init != nil)
-#define cvalue_data(v) cv_data((cvalue_t*)ptr(v))
-#define cvalue_len(v) cv_len((cvalue_t*)ptr(v))
+#define cvalue_data(v) cv_data((csl_v*)ptr(v))
+#define cvalue_len(v) cv_len((csl_v*)ptr(v))
#define value2c(type, v) ((type)cvalue_data(v))
-#define cp_class(cp) (((cprim_t*)(cp))->type)
+#define cp_class(cp) (((sl_cprim*)(cp))->type)
#define cp_type(cp) (cp_class(cp)->type)
#define cp_numtype(cp) (cp_class(cp)->numtype)
-#define cp_data(cp) (((cprim_t*)(cp))->_space)
+#define cp_data(cp) (((sl_cprim*)(cp))->_space)
// WARNING: multiple evaluation!
#define cptr(v) (iscprim(v) ? cp_data(ptr(v)) : cvalue_data(v))
@@ -333,7 +333,7 @@
#define tomp(v) (*(mpint**)cv_data(ptr(v)))
#define BUILTIN(lname, cname) \
- value_t fn_builtin_##cname(value_t *args, int nargs)
+ sl_v fn_builtin_##cname(sl_v *args, int nargs)
#define BUILTIN_FN(l, c, attr) attr BUILTIN(l, c);
#include "builtin_fns.h"
@@ -353,49 +353,49 @@
typedef struct Sl Sl;
struct Sl {- value_t *sp;
+ sl_v *sp;
u8int *curheap;
- value_t *curr_frame;
+ sl_v *curr_frame;
u8int *fromspace;
u8int *tospace;
u8int *lim;
- value_t *stack;
+ sl_v *stack;
uintptr heapsize;//bytes
- size_t malloc_pressure;
+ usize malloc_pressure;
u32int nstack;
- cvalue_t **finalizers;
- size_t nfinalizers;
- size_t maxfinalizers;
+ csl_v **finalizers;
+ usize nfinalizers;
+ usize maxfinalizers;
- sl_readstate_t *readstate;
+ sl_readstate *readstate;
Tbl *symtab;
// saved execution state for an unwind target
- sl_exception_context_t *exctx;
- value_t *throwing_frame; // active frame when exception was thrown
- value_t lasterror;
+ sl_exctx *exctx;
+ sl_v *throwing_frame; // active frame when exception was thrown
+ sl_v lasterror;
- sltype_t *tabletype;
+ sl_type *tabletype;
- sltype_t *iostreamtype;
+ sl_type *iostreamtype;
- value_t the_empty_vector;
- value_t the_empty_string;
- value_t memory_exception_value;
+ sl_v the_empty_vector;
+ sl_v the_empty_string;
+ sl_v memory_exception_value;
- sltype_t *mptype;
- sltype_t *s8type, *u8type;
- sltype_t *s16type, *u16type;
- sltype_t *s32type, *u32type;
- sltype_t *s64type, *u64type;
- sltype_t *floattype, *doubletype;
- sltype_t *bytetype, *runetype;
- sltype_t *stringtype, *runestringtype;
- sltype_t *builtintype;
+ sl_type *mptype;
+ sl_type *s8type, *u8type;
+ sl_type *s16type, *u16type;
+ sl_type *s32type, *u32type;
+ sl_type *s64type, *u64type;
+ sl_type *floattype, *doubletype;
+ sl_type *bytetype, *runetype;
+ sl_type *stringtype, *runestringtype;
+ sl_type *builtintype;
u32int gensym_ctr;
// two static buffers for gensym printing so there can be two
@@ -408,45 +408,45 @@
bool grew;
u32int *consflags;
- size_t gccalls;
+ usize gccalls;
- htable_t printconses;
+ sl_htable printconses;
u32int printlabel;
int print_pretty;
int print_princ;
- fixnum_t print_length;
- fixnum_t print_level;
- fixnum_t p_level;
+ sl_fx print_length;
+ sl_fx print_level;
+ sl_fx p_level;
int scr_width;
- ssize_t hpos, vpos;
+ ssize hpos, vpos;
- htable_t reverse_dlsym_lookup_table;
- htable_t TypeTable;
+ sl_htable reverse_dlsym_lookup_table;
+ sl_htable TypeTable;
int ngchandles;
- value_t *gchandles[N_GC_HANDLES];
+ sl_v *gchandles[N_GC_HANDLES];
};
extern sl_thread(Sl *sl);
#define SL(f) sl->f
-extern value_t sl_builtins_table_sym, sl_quote, sl_lambda, sl_function, sl_comma, sl_commaat;
-extern value_t sl_commadot, sl_trycatch, sl_backquote;
-extern value_t sl_conssym, sl_symbolsym, sl_fixnumsym, sl_vectorsym, sl_builtinsym, sl_vu8sym;
-extern value_t sl_defsym, sl_defmacrosym, sl_forsym, sl_setqsym;
-extern value_t sl_booleansym, sl_nullsym, sl_evalsym, sl_fnsym;
-extern value_t sl_nulsym, sl_alarmsym, sl_backspacesym, sl_tabsym, sl_linefeedsym, sl_newlinesym;
-extern value_t sl_vtabsym, sl_pagesym, sl_returnsym, sl_escsym, sl_spacesym, sl_deletesym;
-extern value_t sl_errio, sl_errparse, sl_errtype, sl_errarg, sl_errmem;
-extern value_t sl_errdiv0, sl_errbounds, sl_err, sl_errkey, sl_errunbound;
+extern sl_v sl_builtins_table_sym, sl_quote, sl_lambda, sl_function, sl_comma, sl_commaat;
+extern sl_v sl_commadot, sl_trycatch, sl_backquote;
+extern sl_v sl_conssym, sl_symbolsym, sl_fixnumsym, sl_vectorsym, sl_builtinsym, sl_vu8sym;
+extern sl_v sl_defsym, sl_defmacrosym, sl_forsym, sl_setqsym;
+extern sl_v sl_booleansym, sl_nullsym, sl_evalsym, sl_fnsym;
+extern sl_v sl_nulsym, sl_alarmsym, sl_backspacesym, sl_tabsym, sl_linefeedsym, sl_newlinesym;
+extern sl_v sl_vtabsym, sl_pagesym, sl_returnsym, sl_escsym, sl_spacesym, sl_deletesym;
+extern sl_v sl_errio, sl_errparse, sl_errtype, sl_errarg, sl_errmem;
+extern sl_v sl_errdiv0, sl_errbounds, sl_err, sl_errkey, sl_errunbound;
-extern value_t sl_printwidthsym, sl_printreadablysym, sl_printprettysym, sl_printlengthsym;
-extern value_t sl_printlevelsym;
-extern value_t sl_arraysym;
-extern value_t sl_iostreamsym, sl_rdsym, sl_wrsym, sl_apsym, sl_crsym, sl_truncsym;
-extern value_t sl_instrsym, sl_outstrsym;
-extern value_t sl_s8sym, sl_u8sym, sl_s16sym, sl_u16sym, sl_s32sym, sl_u32sym;
-extern value_t sl_s64sym, sl_u64sym, sl_bignumsym;
-extern value_t sl_bytesym, sl_runesym, sl_floatsym, sl_doublesym;
-extern value_t sl_stringtypesym, sl_runestringtypesym;
+extern sl_v sl_printwidthsym, sl_printreadablysym, sl_printprettysym, sl_printlengthsym;
+extern sl_v sl_printlevelsym;
+extern sl_v sl_arraysym;
+extern sl_v sl_iostreamsym, sl_rdsym, sl_wrsym, sl_apsym, sl_crsym, sl_truncsym;
+extern sl_v sl_instrsym, sl_outstrsym;
+extern sl_v sl_s8sym, sl_u8sym, sl_s16sym, sl_u16sym, sl_s32sym, sl_u32sym;
+extern sl_v sl_s64sym, sl_u64sym, sl_bignumsym;
+extern sl_v sl_bytesym, sl_runesym, sl_floatsym, sl_doublesym;
+extern sl_v sl_stringtypesym, sl_runestringtypesym;
_Noreturn void slmain(const u8int *boot, int bootsz, int argc, char **argv);
--- a/src/sl_arith_any.inc
+++ b/src/sl_arith_any.inc
@@ -1,5 +1,5 @@
-//value_t
-//sl_*_any(value_t *args, u32int nargs)
+//sl_v
+//sl_*_any(sl_v *args, u32int nargs)
// input: ACCUM_DEFAULT ARITH_OP(a,b) MP_OP ARITH_OVERFLOW
// add: 0 a+b mpadd sadd_overflow_64
// mul: 1 a*b mpmul smul_overflow_64
@@ -9,11 +9,11 @@
u64int u64;
double Faccum = ACCUM_DEFAULT;
bool inexact = false;
- value_t arg;
- numerictype_t pt;
+ sl_v arg;
+ sl_numtype pt;
void *a;
- cprim_t *cp;
- cvalue_t *cv;
+ sl_cprim *cp;
+ csl_v *cv;
u32int i, j;
FOR_ARGS(i, 0, arg, args){@@ -73,7 +73,7 @@
if(inexact)
return mk_double(ARITH_OP(Faccum, Saccum));
if(fits_fixnum(Saccum))
- return fixnum((fixnum_t)Saccum);
+ return fixnum((sl_fx)Saccum);
u64 = ACCUM_DEFAULT;
x = ACCUM_DEFAULT;
@@ -150,7 +150,7 @@
if(inexact)
return mk_double(ARITH_OP(Faccum, Saccum));
assert(fits_fixnum(Saccum));
- return fixnum((fixnum_t)Saccum);
+ return fixnum((sl_fx)Saccum);
#undef ACCUM_DEFAULT
#undef ARITH_OP
--- a/src/slmain.c
+++ b/src/slmain.c
@@ -28,24 +28,24 @@
#define EARGF(x) (_argt=_args, _args="", (*_argt? _argt: argv[1]? (argc--, *++argv): (x, (char*)0)))
#endif
-static value_t
+static sl_v
argv_list(int argc, char **argv)
{int i;
- value_t lst = sl_nil, temp;
+ sl_v lst = sl_nil, temp;
sl_gc_handle(&lst);
sl_gc_handle(&temp);
for(i = argc-1; i >= 0; i--){temp = cvalue_static_cstring(argv[i]);
- lst = sl_cons(temp, lst);
+ lst = mk_cons(temp, lst);
}
- lst = sl_cons(cvalue_static_cstring(argv0), lst);
+ lst = mk_cons(cvalue_static_cstring(argv0), lst);
sl_free_gc_handles(2);
return lst;
}
static void
-sizesuffix(size_t *sz, char su)
+sizesuffix(usize *sz, char su)
{ switch(tolower(su)){case 'k':
@@ -73,13 +73,13 @@
_Noreturn void
slmain(const u8int *boot, int bootsz, int argc, char **argv)
{- size_t heapsize = HEAP_SIZE0, stacksize = STACK_SIZE0;
+ usize heapsize = HEAP_SIZE0, stacksize = STACK_SIZE0;
char *e;
nan_init();
randomize();
ios_init_stdstreams();
- mpsetminbits(sizeof(fixnum_t)*8);
+ mpsetminbits(sizeof(sl_fx)*8);
ARGBEGIN{case 'H':
@@ -101,11 +101,11 @@
exit(1);
}
- value_t f = cvalue(SL(iostreamtype), (int)sizeof(ios_t));
+ sl_v f = cvalue(SL(iostreamtype), (int)sizeof(sl_ios));
sl_gc_handle(&f);
- value_t args = argv_list(argc, argv);
+ sl_v args = argv_list(argc, argv);
sl_gc_handle(&args);
- ios_t *s = value2c(ios_t*, f);
+ sl_ios *s = value2c(sl_ios*, f);
u8int *unpacked = nil;
if(boot[0] == 0){u32int unpackedsz =
@@ -128,7 +128,7 @@
sl_TRY_EXTERN{ if(sl_load_system_image(f) == 0){MEM_FREE(unpacked);
- s = value2c(ios_t*, f);
+ s = value2c(sl_ios*, f);
sl_free_gc_handles(2);
ios_close(s);
sl_applyn(1, symbol_value(symbol("__start", false)), args);--- a/src/string.c
+++ b/src/string.c
@@ -18,13 +18,13 @@
BUILTIN("string-length", string_length) {- size_t start = 0;
+ usize start = 0;
if(nargs < 1 || nargs > 3)
argcount(nargs, 1);
if(!sl_isstring(args[0]))
type_error("string", args[0]);- size_t len = cv_len(ptr(args[0]));
- size_t stop = len;
+ usize len = cv_len(ptr(args[0]));
+ usize stop = len;
if(nargs > 1){start = tosize(args[1]);
if(start > len)
@@ -45,7 +45,7 @@
{argcount(nargs, 1);
if(iscprim(args[0])){- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(cp_class(cp) == SL(runetype)){int w = sl_wcwidth(*(Rune*)cp_data(cp));
return w < 0 ? sl_nil : fixnum(w);
@@ -54,8 +54,8 @@
if(!sl_isstring(args[0]))
type_error("string", args[0]);char *str = tostring(args[0]);
- size_t len = cv_len(ptr(args[0]));
- ssize_t w = u8_strwidth(str, len);
+ usize len = cv_len(ptr(args[0]));
+ ssize w = u8_strwidth(str, len);
return w < 0 ? sl_nil : size_wrap(w);
}
@@ -64,8 +64,8 @@
argcount(nargs, 1);
if(!sl_isstring(args[0]))
type_error("string", args[0]);- size_t len = cv_len(ptr(args[0]));
- value_t ns = cvalue_string(len);
+ usize len = cv_len(ptr(args[0]));
+ sl_v ns = cvalue_string(len);
u8_reverse(cvalue_data(ns), cvalue_data(args[0]), len);
return ns;
}
@@ -74,15 +74,15 @@
{argcount(nargs, 1);
if(iscvalue(args[0])){- cvalue_t *cv = ptr(args[0]);
- sltype_t *t = cv_class(cv);
+ csl_v *cv = ptr(args[0]);
+ sl_type *t = cv_class(cv);
if(t->eltype == SL(runetype)){- size_t nr = cv_len(cv) / sizeof(Rune);
+ usize nr = cv_len(cv) / sizeof(Rune);
Rune *r = (Rune*)cv_data(cv);
- size_t nb = runenlen(r, nr);
- value_t str = cvalue_string(nb);
+ usize nb = runenlen(r, nr);
+ sl_v str = cvalue_string(nb);
char *s = cvalue_data(str);
- for(size_t i = 0; i < nr; i++)
+ for(usize i = 0; i < nr; i++)
s += runetochar(s, r+i);
return str;
}
@@ -99,17 +99,17 @@
argcount(nargs, 1);
if(!sl_isstring(args[0]))
type_error("string", args[0]);- cvalue_t *cv = ptr(args[0]);
+ csl_v *cv = ptr(args[0]);
char *ptr = (char*)cv_data(cv);
- size_t nb = cv_len(cv);
- size_t nc = u8_runelen(ptr, nb);
- size_t newsz = nc*sizeof(Rune);
+ usize nb = cv_len(cv);
+ usize nc = u8_runelen(ptr, nb);
+ usize newsz = nc*sizeof(Rune);
if(term)
newsz += sizeof(Rune);
- value_t runestr = cvalue(SL(runestringtype), newsz);
+ sl_v runestr = cvalue(SL(runestringtype), newsz);
ptr = cvalue_data(args[0]); // relocatable pointer
Rune *r = cvalue_data(runestr);
- for(size_t i = 0; i < nb; i++)
+ for(usize i = 0; i < nb; i++)
ptr += chartorune(r+i, ptr);
if(term)
r[nb] = 0;
@@ -120,11 +120,11 @@
{if(nargs == 1 && sl_isstring(args[0]))
return args[0];
- value_t arg, buf = fn_builtin_buffer(nil, 0);
+ sl_v arg, buf = fn_builtin_buffer(nil, 0);
sl_gc_handle(&buf);
- ios_t *s = value2c(ios_t*, buf);
- value_t oldpr = symbol_value(sl_printreadablysym);
- value_t oldpp = symbol_value(sl_printprettysym);
+ sl_ios *s = value2c(sl_ios*, buf);
+ sl_v oldpr = symbol_value(sl_printreadablysym);
+ sl_v oldpp = symbol_value(sl_printprettysym);
set(sl_printreadablysym, sl_nil);
set(sl_printprettysym, sl_nil);
int i;
@@ -134,7 +134,7 @@
}
set(sl_printreadablysym, oldpr);
set(sl_printprettysym, oldpp);
- value_t outp = stream_to_string(&buf);
+ sl_v outp = stream_to_string(&buf);
sl_free_gc_handles(1);
return outp;
}
@@ -144,11 +144,11 @@
argcount(nargs, 2);
char *s = tostring(args[0]);
char *delim = tostring(args[1]);
- size_t len = cv_len(ptr(args[0]));
- size_t dlen = cv_len(ptr(args[1]));
- size_t ssz, tokend, tokstart, i = 0;
- value_t first = sl_nil, c = sl_nil, last;
- size_t junk;
+ usize len = cv_len(ptr(args[0]));
+ usize dlen = cv_len(ptr(args[1]));
+ usize ssz, tokend, tokstart, i = 0;
+ sl_v first = sl_nil, c = sl_nil, last;
+ usize junk;
sl_gc_handle(&first);
sl_gc_handle(&last);
@@ -159,7 +159,7 @@
tokend = i;
ssz = tokend - tokstart;
last = c; // save previous cons cell
- c = sl_cons(cvalue_string(ssz), sl_nil);
+ c = mk_cons(cvalue_string(ssz), sl_nil);
// we've done allocation; reload movable pointers
s = cvalue_data(args[0]);
@@ -172,7 +172,7 @@
if(last == sl_nil)
first = c; // first time, save first cons
else
- ((cons_t*)ptr(last))->cdr = c;
+ ((sl_cons*)ptr(last))->cdr = c;
// note this tricky condition: if the string ends with a
// delimiter, we need to go around one more time to add an
@@ -187,21 +187,21 @@
if(nargs != 2)
argcount(nargs, 3);
char *s = tostring(args[0]);
- size_t lenbytes = cv_len(ptr(args[0]));
- size_t startbytes, n, startchar = tosize(args[1]);
+ usize lenbytes = cv_len(ptr(args[0]));
+ usize startbytes, n, startchar = tosize(args[1]);
for(startbytes = n = 0; n < startchar && startbytes < lenbytes; n++)
startbytes += u8_seqlen(s+startbytes);
if(n != startchar)
bounds_error(args[0], args[1]);
- size_t endbytes = lenbytes;
+ usize endbytes = lenbytes;
if(nargs == 3){- size_t endchar = tosize(args[2]);
+ usize endchar = tosize(args[2]);
for(endbytes = startbytes; n < endchar && endbytes < lenbytes; n++)
endbytes += u8_seqlen(s+endbytes);
if(n != endchar)
bounds_error(args[0], args[2]);
}
- value_t ns = cvalue_string(endbytes-startbytes);
+ sl_v ns = cvalue_string(endbytes-startbytes);
s = cvalue_data(args[0]); // reload after alloc
memmove(cvalue_data(ns), s+startbytes, endbytes-startbytes);
return ns;
@@ -211,8 +211,8 @@
{argcount(nargs, 2);
char *s = tostring(args[0]);
- size_t lenbytes = cv_len(ptr(args[0]));
- size_t startbytes, n, startchar = tosize(args[1]);
+ usize lenbytes = cv_len(ptr(args[0]));
+ usize startbytes, n, startchar = tosize(args[1]);
for(startbytes = n = 0; n < startchar && startbytes < lenbytes; n++)
startbytes += u8_seqlen(s+startbytes);
if(n != startchar || startbytes >= lenbytes)
@@ -225,7 +225,7 @@
BUILTIN("char-upcase", char_upcase) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return mk_rune(toupperrune(*(Rune*)cp_data(cp)));
@@ -234,7 +234,7 @@
BUILTIN("char-downcase", char_downcase) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return mk_rune(tolowerrune(*(Rune*)cp_data(cp)));
@@ -243,7 +243,7 @@
BUILTIN("char-titlecase", char_titlecase) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return mk_rune(totitlerune(*(Rune*)cp_data(cp)));
@@ -253,7 +253,7 @@
BUILTIN("char-alphabetic?", char_alphabeticp) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return isalpharune(*(Rune*)cp_data(cp)) ? sl_t : sl_nil;
@@ -263,7 +263,7 @@
BUILTIN("char-lower-case?", char_lower_casep) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return islowerrune(*(Rune*)cp_data(cp)) ? sl_t : sl_nil;
@@ -273,7 +273,7 @@
BUILTIN("char-upper-case?", char_upper_casep) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return isupperrune(*(Rune*)cp_data(cp)) ? sl_t : sl_nil;
@@ -283,7 +283,7 @@
BUILTIN("char-title-case?", char_title_casep) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return istitlerune(*(Rune*)cp_data(cp)) ? sl_t : sl_nil;
@@ -293,7 +293,7 @@
BUILTIN("char-numeric?", char_numericp) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return isdigitrune(*(Rune*)cp_data(cp)) ? sl_t : sl_nil;
@@ -303,7 +303,7 @@
BUILTIN("char-whitespace?", char_whitespacep) {argcount(nargs, 1);
- cprim_t *cp = ptr(args[0]);
+ sl_cprim *cp = ptr(args[0]);
if(!iscprim(args[0]) || cp_class(cp) != SL(runetype))
type_error("rune", args[0]);return isspacerune(*(Rune*)cp_data(cp)) ? sl_t : sl_nil;
@@ -312,19 +312,19 @@
BUILTIN("string-find", string_find) {char cbuf[UTFmax+1];
- size_t start = 0;
+ usize start = 0;
if(nargs == 3)
start = tosize(args[2]);
else
argcount(nargs, 2);
char *s = tostring(args[0]);
- size_t len = cv_len(ptr(args[0]));
+ usize len = cv_len(ptr(args[0]));
if(start > len)
bounds_error(args[0], args[2]);
- char *needle; size_t needlesz;
+ char *needle; usize needlesz;
- value_t v = args[1];
- cprim_t *cp = ptr(v);
+ sl_v v = args[1];
+ sl_cprim *cp = ptr(v);
if(iscprim(v) && cp_class(cp) == SL(runetype)){Rune r = *(Rune*)cp_data(cp);
needlesz = runetochar(cbuf, &r);
@@ -336,7 +336,7 @@
needle[0] = *(char*)cp_data(cp);
needle[needlesz] = 0;
}else if(sl_isstring(v)){- cvalue_t *cv = ptr(v);
+ csl_v *cv = ptr(v);
needlesz = cv_len(cv);
needle = (char*)cv_data(cv);
}else{@@ -346,7 +346,7 @@
return sl_nil;
if(needlesz == 0)
return size_wrap(start);
- size_t i;
+ usize i;
for(i = start; i < len-needlesz+1; i++){if(s[i] == needle[0] && memcmp(&s[i+1], needle+1, needlesz-1) == 0)
return size_wrap(i);
@@ -355,7 +355,7 @@
}
static unsigned long
-get_radix_arg(value_t arg)
+get_radix_arg(sl_v arg)
{unsigned long radix = tosize(arg);
if(radix < 2 || radix > 36)
@@ -367,7 +367,7 @@
{if(nargs < 1 || nargs > 2)
argcount(nargs, 2);
- value_t n = args[0];
+ sl_v n = args[0];
bool neg = false;
u64int num;
int radix = 10;
@@ -414,7 +414,7 @@
if(nargs < 1 || nargs > 2)
argcount(nargs, 2);
char *str = tostring(args[0]);
- value_t n;
+ sl_v n;
unsigned long radix = 0;
if(nargs == 2)
radix = get_radix_arg(args[1]);
@@ -428,6 +428,6 @@
{argcount(nargs, 1);
char *s = tostring(args[0]);
- size_t len = cv_len(ptr(args[0]));
+ usize len = cv_len(ptr(args[0]));
return u8_isvalid(s, len) ? sl_t : sl_nil;
}
--- a/src/table.c
+++ b/src/table.c
@@ -5,12 +5,12 @@
#include "print.h"
#include "table.h"
-#define inline_space sizeof(((htable_t*)nil)->_space)
+#define inline_space sizeof(((sl_htable*)nil)->_space)
static void
-print_htable(value_t v, ios_t *f)
+print_htable(sl_v v, sl_ios *f)
{- htable_t *h = cvalue_data(v);
+ sl_htable *h = cvalue_data(v);
int first = 1;
sl_print_str(f, "#table("); for(int i = 0; i < h->size; i += 2){@@ -17,9 +17,9 @@
if(h->table[i+1] != HT_NOTFOUND){if(!first)
sl_print_str(f, " ");
- sl_print_child(f, (value_t)h->table[i]);
+ sl_print_child(f, (sl_v)h->table[i]);
sl_print_chr(f, ' ');
- sl_print_child(f, (value_t)h->table[i+1]);
+ sl_print_child(f, (sl_v)h->table[i+1]);
first = 0;
}
}
@@ -27,39 +27,39 @@
}
static void
-print_traverse_htable(value_t self)
+print_traverse_htable(sl_v self)
{- htable_t *h = cvalue_data(self);
+ sl_htable *h = cvalue_data(self);
for(int i = 0; i < h->size; i += 2){ if(h->table[i+1] != HT_NOTFOUND){- print_traverse((value_t)h->table[i]);
- print_traverse((value_t)h->table[i+1]);
+ print_traverse((sl_v)h->table[i]);
+ print_traverse((sl_v)h->table[i+1]);
}
}
}
static void
-free_htable(value_t self)
+free_htable(sl_v self)
{- htable_t *h = cvalue_data(self);
+ sl_htable *h = cvalue_data(self);
htable_free(h);
}
static void
-relocate_htable(value_t oldv, value_t newv)
+relocate_htable(sl_v oldv, sl_v newv)
{- htable_t *oldh = cvalue_data(oldv);
- htable_t *h = cvalue_data(newv);
+ sl_htable *oldh = cvalue_data(oldv);
+ sl_htable *h = cvalue_data(newv);
if(oldh->table == &oldh->_space[0])
h->table = &h->_space[0];
h->i = oldh->i;
for(int i = 0; i < h->size; i++){if(h->table[i] != HT_NOTFOUND)
- h->table[i] = (void*)relocate((value_t)h->table[i]);
+ h->table[i] = (void*)relocate((sl_v)h->table[i]);
}
}
-static cvtable_t table_vtable = {+static sl_cvtable table_vtable = {print_htable,
relocate_htable,
free_htable,
@@ -67,7 +67,7 @@
};
bool
-ishashtable(value_t v)
+ishashtable(sl_v v)
{return iscvalue(v) && cv_class(ptr(v)) == SL(tabletype);
}
@@ -79,8 +79,8 @@
return ishashtable(args[0]) ? sl_t : sl_nil;
}
-htable_t *
-totable(value_t v)
+sl_htable *
+totable(sl_v v)
{if(!ishashtable(v))
type_error("table", v);@@ -92,15 +92,15 @@
int cnt = nargs;
if(cnt & 1)
lerrorf(sl_errarg, "arguments must come in pairs");
- value_t nt;
+ sl_v nt;
// prevent small tables from being added to finalizer list
if(cnt <= HT_N_INLINE)
- nt = cvalue_nofinalizer(SL(tabletype), sizeof(htable_t));
+ nt = cvalue_nofinalizer(SL(tabletype), sizeof(sl_htable));
else
- nt = cvalue(SL(tabletype), sizeof(htable_t)-inline_space);
- htable_t *h = cvalue_data(nt);
+ nt = cvalue(SL(tabletype), sizeof(sl_htable)-inline_space);
+ sl_htable *h = cvalue_data(nt);
htable_new(h, cnt/2);
- value_t k = sl_nil, arg;
+ sl_v k = sl_nil, arg;
int i;
FOR_ARGS(i, 0, arg, args){if(i & 1)
@@ -116,14 +116,14 @@
BUILTIN("put!", put) {argcount(nargs, 3);
- htable_t *h = totable(args[0]);
+ sl_htable *h = totable(args[0]);
void **table0 = h->table;
equalhash_put(h, (void*)args[1], (void*)args[2]);
// register finalizer if we outgrew inline space
if(table0 == &h->_space[0] && h->table != &h->_space[0]){- cvalue_t *cv = ptr(args[0]);
+ csl_v *cv = ptr(args[0]);
add_finalizer(cv);
- cv->len = sizeof(htable_t) - inline_space;
+ cv->len = sizeof(sl_htable) - inline_space;
}
return args[0];
}
@@ -130,9 +130,9 @@
_Noreturn
static void
-key_error(value_t key)
+key_error(sl_v key)
{- lerrorf(sl_list2(sl_errkey, key), "key not found");
+ lerrorf(mk_list2(sl_errkey, key), "key not found");
}
// (get table key [default])
@@ -141,9 +141,9 @@
{if(nargs != 3)
argcount(nargs, 2);
- htable_t *h = totable(args[0]);
- value_t v = (value_t)equalhash_get(h, (void*)args[1]);
- if(v == (value_t)HT_NOTFOUND){+ sl_htable *h = totable(args[0]);
+ sl_v v = (sl_v)equalhash_get(h, (void*)args[1]);
+ if(v == (sl_v)HT_NOTFOUND){if(nargs == 3)
return args[2];
key_error(args[1]);
@@ -156,7 +156,7 @@
BUILTIN("has?", has) {argcount(nargs, 2);
- htable_t *h = totable(args[0]);
+ sl_htable *h = totable(args[0]);
return equalhash_has(h, (void*)args[1]) ? sl_t : sl_nil;
}
@@ -164,7 +164,7 @@
BUILTIN("del!", del) {argcount(nargs, 2);
- htable_t *h = totable(args[0]);
+ sl_htable *h = totable(args[0]);
if(!equalhash_remove(h, (void*)args[1]))
key_error(args[1]);
return args[0];
@@ -173,8 +173,8 @@
BUILTIN("table-foldl", table_foldl) {argcount(nargs, 3);
- value_t f = args[0], zero = args[1], t = args[2];
- htable_t *h = totable(t);
+ sl_v f = args[0], zero = args[1], t = args[2];
+ sl_htable *h = totable(t);
int n = h->size;
void **table = h->table;
sl_gc_handle(&f);
@@ -183,7 +183,7 @@
for(int i = 0; i < n; i += 2){if(table[i+1] == HT_NOTFOUND)
continue;
- zero = sl_applyn(3, f, (value_t)table[i], (value_t)table[i+1], zero);
+ zero = sl_applyn(3, f, (sl_v)table[i], (sl_v)table[i+1], zero);
// reload pointer
h = cvalue_data(t);
n = h->size;
@@ -196,5 +196,5 @@
void
table_init(void)
{- SL(tabletype) = define_opaque_type(symbol("table", false), sizeof(htable_t), &table_vtable, nil);+ SL(tabletype) = define_opaque_type(symbol("table", false), sizeof(sl_htable), &table_vtable, nil);}
--- a/src/table.h
+++ b/src/table.h
@@ -1,3 +1,3 @@
-bool ishashtable(value_t v) sl_purefn;
-htable_t *totable(value_t v) sl_purefn;
+bool ishashtable(sl_v v) sl_purefn;
+sl_htable *totable(sl_v v) sl_purefn;
void table_init(void);
--- a/src/types.c
+++ b/src/types.c
@@ -3,12 +3,12 @@
#include "equalhash.h"
#include "types.h"
-sltype_t *
-get_type(value_t t)
+sl_type *
+get_type(sl_v t)
{- sltype_t *ft;
+ sl_type *ft;
if(issymbol(t)){- ft = ((symbol_t*)ptr(t))->type;
+ ft = ((sl_sym*)ptr(t))->type;
if(ft != nil)
return ft;
}
@@ -19,7 +19,7 @@
}
bool isarray = iscons(t) && car_(t) == sl_arraysym && iscons(cdr_(t));
- size_t sz;
+ usize sz;
if(isarray && !iscons(cdr_(cdr_(t)))){// special case: incomplete array type
sz = 0;
@@ -27,7 +27,7 @@
sz = ctype_sizeof(t);
}
- ft = MEM_CALLOC(1, sizeof(sltype_t));
+ ft = MEM_CALLOC(1, sizeof(sl_type));
assert(ft != nil);
ft->type = t;
ft->numtype = NONNUMERIC;
@@ -34,11 +34,11 @@
if(issymbol(t)){ft->numtype = sym_to_numtype(t);
assert(valid_numtype(ft->numtype));
- ((symbol_t*)ptr(t))->type = ft;
+ ((sl_sym*)ptr(t))->type = ft;
}
ft->size = sz;
if(isarray && iscons(t)){- sltype_t *eltype = get_type(car_(cdr_(t)));
+ sl_type *eltype = get_type(car_(cdr_(t)));
assert(eltype != nil && eltype->size > 0);
ft->elsz = eltype->size;
ft->eltype = eltype;
@@ -49,19 +49,19 @@
return ft;
}
-sltype_t *
-get_array_type(value_t eltype)
+sl_type *
+get_array_type(sl_v eltype)
{- sltype_t *et = get_type(eltype);
+ sl_type *et = get_type(eltype);
if(et->artype == nil)
- et->artype = get_type(sl_list2(sl_arraysym, eltype));
+ et->artype = get_type(mk_list2(sl_arraysym, eltype));
return et->artype;
}
-sltype_t *
-define_opaque_type(value_t sym, size_t sz, cvtable_t *vtab, cvinitfunc_t init)
+sl_type *
+define_opaque_type(sl_v sym, usize sz, sl_cvtable *vtab, cvinitfunc_t init)
{- sltype_t *ft = MEM_CALLOC(1, sizeof(sltype_t));
+ sl_type *ft = MEM_CALLOC(1, sizeof(sl_type));
assert(ft != nil);
ft->type = sym;
ft->numtype = NONNUMERIC;
@@ -74,13 +74,13 @@
void
relocate_typetable(void)
{- htable_t *h = &SL(TypeTable);
+ sl_htable *h = &SL(TypeTable);
for(int i = 0; i < h->size; i += 2){ if(h->table[i] != HT_NOTFOUND){- void *nv = (void*)relocate((value_t)h->table[i]);
+ void *nv = (void*)relocate((sl_v)h->table[i]);
h->table[i] = nv;
if(h->table[i+1] != HT_NOTFOUND)
- ((sltype_t*)h->table[i+1])->type = (value_t)nv;
+ ((sl_type*)h->table[i+1])->type = (sl_v)nv;
}
}
}
--- a/src/types.h
+++ b/src/types.h
@@ -1,6 +1,6 @@
#pragma once
-sltype_t *get_type(value_t t);
-sltype_t *get_array_type(value_t eltype);
-sltype_t *define_opaque_type(value_t sym, size_t sz, cvtable_t *vtab, cvinitfunc_t init);
+sl_type *get_type(sl_v t);
+sl_type *get_array_type(sl_v eltype);
+sl_type *define_opaque_type(sl_v sym, usize sz, sl_cvtable *vtab, cvinitfunc_t init);
void relocate_typetable(void);
--- a/src/utf8.c
+++ b/src/utf8.c
@@ -32,16 +32,16 @@
};
/* returns length of next utf-8 sequence */
-size_t
+usize
u8_seqlen(const char *s)
{return trailingBytesForUTF8[(u8int)s[0]] + 1;
}
-size_t
-u8_runelen(const char *s, size_t nb)
+usize
+u8_runelen(const char *s, usize nb)
{- size_t nr, i;
+ usize nr, i;
for(i = nr = 0; i < nb; nr++)
i += trailingBytesForUTF8[(u8int)s[i]] + 1;
return nr;
@@ -48,10 +48,10 @@
}
/* byte offset => charnum */
-size_t
-u8_charnum(const char *s, size_t offset)
+usize
+u8_charnum(const char *s, usize offset)
{- size_t charnum = 0, i = 0;
+ usize charnum = 0, i = 0;
while(i < offset){if((s[i++] & 0x80) != 0 && !isutf(s[++i]) && !isutf(s[++i]))
@@ -61,16 +61,16 @@
return charnum;
}
-ssize_t
-u8_strwidth(const char *s, ssize_t n)
+ssize
+u8_strwidth(const char *s, ssize n)
{- ssize_t i, w;
+ ssize i, w;
Rune r;
assert(n >= 0);
for(i = w = 0; i < n;){i += chartorune(&r, s+i);
- ssize_t x = sl_wcwidth(r);
+ ssize x = sl_wcwidth(r);
if(x < 0)
return -1;
w += x;
@@ -80,11 +80,11 @@
/* next character without NUL character terminator */
Rune
-u8_nextmemchar(const char *s, size_t *i)
+u8_nextmemchar(const char *s, usize *i)
{- size_t sz = trailingBytesForUTF8[(u8int)s[*i]];
+ usize sz = trailingBytesForUTF8[(u8int)s[*i]];
Rune ch = 0;
- for(size_t j = 0; j <= sz; j++){+ for(usize j = 0; j <= sz; j++){ch <<= 6;
ch += (u8int)s[(*i)++];
};
@@ -129,7 +129,7 @@
}
int
-u8_escape_rune(char *buf, size_t sz, Rune ch)
+u8_escape_rune(char *buf, usize sz, Rune ch)
{assert(sz > 12);
if(ch == '\\')
@@ -156,10 +156,10 @@
return snprintf(buf, sz, "\\x%02"PRIx32, ch);
}
-size_t
-u8_escape(char *buf, size_t sz, const char *src, size_t *pi, size_t end, bool escape_quotes, bool ascii)
+usize
+u8_escape(char *buf, usize sz, const char *src, usize *pi, usize end, bool escape_quotes, bool ascii)
{- size_t i = *pi, i0;
+ usize i = *pi, i0;
Rune ch;
char *start = buf;
char *blim = start + sz-11;
@@ -192,9 +192,9 @@
}
char *
-u8_memchr(char *s, Rune ch, size_t sz, size_t *charn)
+u8_memchr(char *s, Rune ch, usize sz, usize *charn)
{- size_t i = 0, lasti = 0;
+ usize i = 0, lasti = 0;
Rune c;
int csz;
@@ -286,9 +286,9 @@
}
void
-u8_reverse(char *dest, char *src, size_t len)
+u8_reverse(char *dest, char *src, usize len)
{- size_t si, di;
+ usize si, di;
if(len == 0)
return;
--- a/src/utf8.h
+++ b/src/utf8.h
@@ -4,16 +4,16 @@
#define isutf(c) (((c)&0xC0) != 0x80)
/* byte offset to character number */
-size_t u8_charnum(const char *s, size_t offset) sl_purefn;
+usize u8_charnum(const char *s, usize offset) sl_purefn;
/* next character without NUL character terminator */
-Rune u8_nextmemchar(const char *s, size_t *i);
+Rune u8_nextmemchar(const char *s, usize *i);
/* returns length of next utf-8 sequence */
-size_t u8_seqlen(const char *s) sl_purefn;
+usize u8_seqlen(const char *s) sl_purefn;
/* length of a utf-8 string in runes */
-size_t u8_runelen(const char *s, size_t nb) sl_purefn;
+usize u8_runelen(const char *s, usize nb) sl_purefn;
char read_escape_control_char(char c) sl_constfn;
@@ -20,7 +20,7 @@
/* given a wide character, convert it to an ASCII escape sequence stored in
buf, where buf is "sz" bytes. returns the number of characters output.
sz must be at least 3. */
-int u8_escape_rune(char *buf, size_t sz, Rune ch);
+int u8_escape_rune(char *buf, usize sz, Rune ch);
/* convert UTF-8 "src" to escape sequences.
@@ -37,7 +37,7 @@
returns number of bytes placed in buf, including a NUL terminator.
*/
-size_t u8_escape(char *buf, size_t sz, const char *src, size_t *pi, size_t end,
+usize u8_escape(char *buf, usize sz, const char *src, usize *pi, usize end,
bool escape_quotes, bool ascii);
/* utility predicates used by the above */
@@ -46,10 +46,10 @@
/* same as the above, but searches a buffer of a given size instead of
a NUL-terminated string. */
-char *u8_memchr(char *s, Rune ch, size_t sz, size_t *charn);
+char *u8_memchr(char *s, Rune ch, usize sz, usize *charn);
/* number of columns occupied by a string */
-ssize_t u8_strwidth(const char *s, ssize_t n) sl_purefn;
+ssize u8_strwidth(const char *s, ssize n) sl_purefn;
/* determine whether a sequence of bytes is valid UTF-8. length is in bytes */
bool u8_isvalid(const char *str, int length) sl_purefn;
@@ -56,4 +56,4 @@
/* reverse a UTF-8 string. len is length in bytes. dest and src must both
be allocated to at least len+1 bytes. returns 1 for error, 0 otherwise */
-void u8_reverse(char *dest, char *src, size_t len);
+void u8_reverse(char *dest, char *src, usize len);
--- a/src/vm.inc
+++ b/src/vm.inc
@@ -28,13 +28,13 @@
}
LABEL(do_call):
*ipd = (uintptr)ip;
- value_t v = sp[-n-1];
+ sl_v v = sp[-n-1];
if(tag(v) == TAG_FUNCTION){ if(v > (N_BUILTINS<<3)){nargs = n;
if(tail){- SL(curr_frame) = (value_t*)SL(curr_frame)[-3];
- for(fixnum_t s = -1; s < (fixnum_t)n; s++)
+ SL(curr_frame) = (sl_v*)SL(curr_frame)[-3];
+ for(sl_fx s = -1; s < (sl_fx)n; s++)
bp[s] = sp[s-n];
sp = bp+n;
}else{@@ -41,11 +41,11 @@
LABEL(apply_func):
bp = sp-nargs;
}
- function_t *fn = (function_t*)ptr(bp[-1]);
+ sl_fn *fn = (sl_fn*)ptr(bp[-1]);
ip = cvalue_data(fn->bcode);
assert(!ismanaged((uintptr)ip));
*sp++ = fn->env;
- *sp++ = (value_t)SL(curr_frame);
+ *sp++ = (sl_v)SL(curr_frame);
*sp++ = nargs;
ipd = sp++;
SL(curr_frame) = sp;
@@ -53,7 +53,7 @@
}
int i = uintval(v);
assert(isbuiltin(v));
- fixnum_t s = builtins[i].nargs;
+ sl_fx s = builtins[i].nargs;
if(s >= 0){SL(sp) = sp;
argcount(n, s);
@@ -62,7 +62,7 @@
argcount(n, -s);
}
// remove function arg
- for(value_t *p = sp-n-1; p < sp-1; p++)
+ for(sl_v *p = sp-n-1; p < sp-1; p++)
p[0] = p[1];
sp--;
switch(i){@@ -86,9 +86,9 @@
#endif
}
}else if(sl_likely(iscbuiltin(v))){- value_t *p = sp - n;
+ sl_v *p = sp - n;
SL(sp) = sp;
- v = ((cvalue_t*)ptr(v))->cbuiltin(p, n);
+ v = ((csl_v*)ptr(v))->cbuiltin(p, n);
sp = p;
p[-1] = v;
NEXT_OP;
@@ -117,9 +117,9 @@
NEXT_OP;
OP(OP_RET) {- value_t v = *(--sp);
+ sl_v v = *(--sp);
sp = SL(curr_frame);
- SL(curr_frame) = (value_t*)sp[-3];
+ SL(curr_frame) = (sl_v*)sp[-3];
if(SL(curr_frame) == top_frame){SL(sp) = sp;
return v;
@@ -146,7 +146,7 @@
NEXT_OP;
OP(OP_LOADG) {- value_t v = fn_vals(bp[-1]);
+ sl_v v = fn_vals(bp[-1]);
assert(*ip < vector_size(v));
v = vector_elt(v, *ip);
ip++;
@@ -157,7 +157,7 @@
ip += 4;
}
assert(issymbol(v));
- symbol_t *sym = ptr(v);
+ sl_sym *sym = ptr(v);
if(sl_unlikely(sym->binding == UNBOUND)){*ipd = (uintptr)ip;
SL(sp) = sp;
@@ -171,12 +171,12 @@
n = *ip++;
LABEL(apply_lt):;
int i = n;
- value_t a = sp[-i], b, v;
+ sl_v a = sp[-i], b, v;
for(v = sl_t; i > 1; a = b){i--;
b = sp[-i];
if(bothfixnums(a, b)){- if((fixnum_t)a >= (fixnum_t)b){+ if((sl_fx)a >= (sl_fx)b){v = sl_nil;
break;
}
@@ -196,7 +196,7 @@
}
OP(OP_LOADV) {- value_t v = fn_vals(bp[-1]);
+ sl_v v = fn_vals(bp[-1]);
assert(*ip < vector_size(v));
*sp++ = vector_elt(v, *ip++);
NEXT_OP;
@@ -203,8 +203,8 @@
}
OP(OP_ADD2) {- fixnum_t a, b, q;
- value_t v;
+ sl_fx a, b, q;
+ sl_v v;
LABEL(do_add2):
*ipd = (uintptr)ip;
if(0){@@ -251,7 +251,7 @@
NEXT_OP;
OP(OP_CAR) {- value_t v = sp[-1];
+ sl_v v = sp[-1];
if(sl_likely(iscons(v)))
v = car_(v);
else if(sl_unlikely(v != sl_nil)){@@ -267,13 +267,13 @@
int x = *ip++;
assert(x > 0);
SL(sp) = sp;
- value_t *pv = alloc_words(
+ sl_v *pv = alloc_words(
1+x+
#if !defined(BITS64)
!(x&1)+
#endif
- sizeof(function_t)/sizeof(value_t));
- value_t v = tagptr(pv, TAG_VECTOR);
+ sizeof(sl_fn)/sizeof(sl_v));
+ sl_v v = tagptr(pv, TAG_VECTOR);
*pv++ = fixnum(x);
for(int i = 0; i < x; i++)
*pv++ = sp[-x+i];
@@ -283,8 +283,8 @@
if((x & 1) == 0)
pv++;
#endif
- function_t *f = (function_t*)pv;
- value_t e = sp[-1]; // closure to copy
+ sl_fn *f = (sl_fn*)pv;
+ sl_v e = sp[-1]; // closure to copy
sp[-1] = tagptr(f, TAG_FUNCTION);
assert(isfunction(e));
f->vals = fn_vals(e);
@@ -299,8 +299,8 @@
SL(sp) = sp;
sl_gc(0);
}
- cons_t *c = (cons_t*)SL(curheap);
- SL(curheap) += sizeof(cons_t);
+ sl_cons *c = (sl_cons*)SL(curheap);
+ SL(curheap) += sizeof(sl_cons);
c->car = sp[-2];
c->cdr = sp[-1];
sp[-2] = tagptr(c, TAG_CONS);
@@ -314,7 +314,7 @@
NEXT_OP;
OP(OP_CDR) {- value_t v = sp[-1];
+ sl_v v = sp[-1];
if(sl_likely(iscons(v)))
v = cdr_(v);
else if(sl_unlikely(v != sl_nil)){@@ -345,9 +345,9 @@
i = GET_S32(ip);
ip += 4;
}
- fixnum_t s = (fixnum_t)nargs - (fixnum_t)i;
+ sl_fx s = (sl_fx)nargs - (sl_fx)i;
if(s > 0){- value_t v = list(bp+i, s, false);
+ sl_v v = list(bp+i, s, false);
bp[i] = v;
if(s > 1){bp[i+1] = bp[nargs+0];
@@ -382,7 +382,7 @@
}
OP(OP_SETCAR) {- value_t v = sp[-2];
+ sl_v v = sp[-2];
if(sl_unlikely(!iscons(v))){*ipd = (uintptr)ip;
SL(sp) = sp;
@@ -400,7 +400,7 @@
OP(OP_BOX) {int i = *ip++;
SL(sp) = sp;
- value_t v = mk_cons();
+ sl_v v = alloc_cons();
car_(v) = bp[i];
cdr_(v) = sl_nil;
bp[i] = v;
@@ -423,7 +423,7 @@
n = 3 + *ip++;
}
LABEL(apply_aref):;
- value_t v = sp[-n];
+ sl_v v = sp[-n];
for(int i = n-1; i > 0; i--){ if(isarray(v)){sp[-i-1] = v;
@@ -430,8 +430,8 @@
v = cvalue_array_aref(sp-i-1);
continue;
}
- value_t e = sp[-i];
- size_t isz = tosize(e);
+ sl_v e = sp[-i];
+ usize isz = tosize(e);
if(isvector(v)){ if(sl_unlikely(isz >= vector_size(v))){SL(sp) = sp;
@@ -444,7 +444,7 @@
SL(sp) = sp;
type_error("sequence", v);}
- for(value_t v0 = v;; isz--){+ for(sl_v v0 = v;; isz--){ if(isz == 0){v = car_(v);
break;
@@ -462,7 +462,7 @@
}
OP(OP_NANP) {- value_t v = sp[-1];
+ sl_v v = sp[-1];
if(!iscprim(v))
v = sl_nil;
else{@@ -488,7 +488,7 @@
NEXT_OP;
OP(OP_SETCDR) {- value_t v = sp[-2];
+ sl_v v = sp[-2];
if(sl_unlikely(!iscons(v))){*ipd = (uintptr)ip;
SL(sp) = sp;
@@ -505,7 +505,7 @@
OP(OP_ASET) {*ipd = (uintptr)ip;
- value_t v = sp[-3];
+ sl_v v = sp[-3];
n = 3;
if(0){LABEL(apply_aset):
@@ -516,8 +516,8 @@
v = cvalue_array_aref(sp-i-1);
continue;
}
- value_t e = sp[-i];
- size_t isz = tosize(e);
+ sl_v e = sp[-i];
+ usize isz = tosize(e);
if(isvector(v)){ if(sl_unlikely(isz >= vector_size(v))){SL(sp) = sp;
@@ -530,7 +530,7 @@
SL(sp) = sp;
type_error("sequence", v);}
- for(value_t v0 = v;; isz--){+ for(sl_v v0 = v;; isz--){ if(isz == 0){v = car_(v);
break;
@@ -544,8 +544,8 @@
}
sp[-3] = v;
}
- value_t e = sp[-2];
- size_t isz = tosize(e);
+ sl_v e = sp[-2];
+ usize isz = tosize(e);
if(isvector(v)){ if(sl_unlikely(isz >= vector_size(v))){SL(sp) = sp;
@@ -553,7 +553,7 @@
}
vector_elt(v, isz) = (e = sp[-1]);
}else if(iscons(v) || v == sl_nil){- for(value_t v0 = v;; isz--){+ for(sl_v v0 = v;; isz--){ if(isz == 0){car_(v) = (e = sp[-1]);
break;
@@ -576,7 +576,7 @@
}
OP(OP_EQUAL) {- value_t a = sp[-2], b = sp[-1];
+ sl_v a = sp[-2], b = sp[-1];
sp--;
sp[-1] = (a == b || sl_compare(a, b, true) == 0) ? sl_t : sl_nil;
NEXT_OP;
@@ -587,7 +587,7 @@
NEXT_OP;
OP(OP_LOADC) {- value_t v = bp[nargs];
+ sl_v v = bp[nargs];
int i = *ip++;
assert(isvector(v));
assert(i < (int)vector_size(v));
@@ -650,7 +650,7 @@
OP(OP_LIST) {n = *ip++;
LABEL(apply_list):;
- value_t v;
+ sl_v v;
v = list(sp-n, n, false);
sp -= n;
*sp++ = v;
@@ -659,7 +659,7 @@
OP(OP_BOUNDP) {*ipd = (uintptr)ip;
- symbol_t *sym = tosymbol(sp[-1]);
+ sl_sym *sym = tosymbol(sp[-1]);
sp[-1] = sym->binding == UNBOUND ? sl_nil : sl_t;
NEXT_OP;
}
@@ -668,7 +668,7 @@
n = *ip++;
LABEL(apply_numeq):;
int i = n;
- value_t a = sp[-i], b, v;
+ sl_v a = sp[-i], b, v;
for(v = sl_t; i > 1; a = b){i--;
b = sp[-i];
@@ -688,7 +688,7 @@
}
OP(OP_CADR) {- value_t v = sp[-1];
+ sl_v v = sp[-1];
if(sl_likely(iscons(v))){v = cdr_(v);
if(sl_likely(iscons(v)))
@@ -715,8 +715,8 @@
}
n = *ip++;
LABEL(apply_apply):;
- value_t v = *(--sp); // arglist
- value_t *p = sp-(n-2); // n-2 == # leading arguments not in the list
+ sl_v v = *(--sp); // arglist
+ sl_v *p = sp-(n-2); // n-2 == # leading arguments not in the list
while(iscons(v)){*sp++ = car_(v);
v = cdr_(v);
@@ -735,7 +735,7 @@
NEXT_OP;
OP(OP_BUILTINP) {- value_t v = sp[-1];
+ sl_v v = sp[-1];
sp[-1] = (isbuiltin(v) || iscbuiltin(v)) ? sl_t : sl_nil;
NEXT_OP;
}
@@ -743,7 +743,7 @@
OP(OP_NEG) {LABEL(do_neg):
*ipd = (uintptr)ip;
- value_t v = sp[-1];
+ sl_v v = sp[-1];
s64int i64;
sp[-1] = isfixnum(v) ? fixnum_neg(v) : sl_neg(v);
NEXT_OP;
@@ -757,7 +757,7 @@
n = *ip++;
LABEL(apply_mul):
*ipd = (uintptr)ip;
- value_t v = sl_mul_any(sp-n, n);
+ sl_v v = sl_mul_any(sp-n, n);
sp -= n;
*sp++ = v;
NEXT_OP;
@@ -764,16 +764,16 @@
}
OP(OP_IDIV) {- value_t a = sp[-2];
- value_t b = sp[-1];
+ sl_v a = sp[-2];
+ sl_v b = sp[-1];
if(sl_unlikely(b == 0)){*ipd = (uintptr)ip;
SL(sp) = sp;
divide_by_0_error();
}
- value_t v;
+ sl_v v;
if(bothfixnums(a, b))
- v = fixnum((fixnum_t)a / (fixnum_t)b);
+ v = fixnum((sl_fx)a / (sl_fx)b);
else{*ipd = (uintptr)ip;
v = sl_idiv2(a, b);
@@ -787,7 +787,7 @@
n = *ip++;
LABEL(apply_div):
*ipd = (uintptr)ip;
- value_t *p = sp-n;
+ sl_v *p = sp-n;
if(n == 1){sp[-1] = sl_div2(fixnum(1), *p);
}else{@@ -797,7 +797,7 @@
p[1] = sl_mul_any(p, n);
*p = *(--sp);
}
- value_t v = sl_div2(p[0], p[1]);
+ sl_v v = sl_div2(p[0], p[1]);
sp -= n;
*sp++ = v;
}
@@ -808,8 +808,8 @@
n = *ip++;
LABEL(apply_vector):;
SL(sp) = sp;
- value_t v = alloc_vector(n, 0);
- memcpy(&vector_elt(v, 0), sp-n, n*sizeof(value_t));
+ sl_v v = alloc_vector(n, 0);
+ memcpy(&vector_elt(v, 0), sp-n, n*sizeof(sl_v));
sp -= n;
*sp++ = v;
NEXT_OP;
@@ -822,10 +822,10 @@
OP(OP_FOR) {*ipd = (uintptr)ip;
- value_t *p = sp;
- value_t v;
- fixnum_t s = tofixnum(p[-3]);
- fixnum_t hi = tofixnum(p[-2]);
+ sl_v *p = sp;
+ sl_v v;
+ sl_fx s = tofixnum(p[-3]);
+ sl_fx hi = tofixnum(p[-2]);
sp += 2;
SL(sp) = sp;
for(v = sl_void; s <= hi; s++){@@ -845,11 +845,11 @@
i = GET_S32(ip);
ip += 4;
}
- value_t v = fn_vals(bp[-1]);
+ sl_v v = fn_vals(bp[-1]);
assert(i < (int)vector_size(v));
v = vector_elt(v, i);
assert(issymbol(v));
- symbol_t *sym = ptr(v);
+ sl_sym *sym = ptr(v);
v = sp[-1];
if(!isconstant(sym))
sym->binding = v;
@@ -863,7 +863,7 @@
OP(OP_TRYCATCH) {*ipd = (uintptr)ip;
SL(sp) = sp;
- value_t v = do_trycatch();
+ sl_v v = do_trycatch();
sp--;
sp[-1] = v;
NEXT_OP;
@@ -875,7 +875,7 @@
goto LABEL(do_add2);
LABEL(apply_add):
*ipd = (uintptr)ip;
- value_t v = sl_add_any(sp-n, n);
+ sl_v v = sl_add_any(sp-n, n);
sp -= n;
*sp++ = v;
NEXT_OP;
@@ -888,7 +888,7 @@
NEXT_OP;
OP(OP_EQV) {- value_t a = sp[-2], b = sp[-1];
+ sl_v a = sp[-2], b = sp[-1];
sp[-2] = (a == b || (leafp(a) && leafp(b) && sl_compare(a, b, true) == 0)) ? sl_t : sl_nil;
sp--;
NEXT_OP;
@@ -895,13 +895,13 @@
}
OP(OP_KEYARGS) {- value_t v = fn_vals(bp[-1]);
+ sl_v v = fn_vals(bp[-1]);
v = vector_elt(v, 0);
int i = GET_S32(ip);
ip += 4;
int x = GET_S32(ip);
ip += 4;
- fixnum_t s = GET_S32(ip);
+ sl_fx s = GET_S32(ip);
ip += 4;
*ipd = (uintptr)ip;
SL(sp) = sp;
@@ -919,12 +919,12 @@
if(n == 1)
goto LABEL(do_neg);
*ipd = (uintptr)ip;
- value_t *p = sp-n;
+ sl_v *p = sp-n;
// we need to pass the full arglist on to sl_add_any
// so it can handle rest args properly
*sp++ = *p;
*p = fixnum(0);
- value_t v = sl_add_any(p, n);
+ sl_v v = sl_add_any(p, n);
s64int i64;
p[1] = isfixnum(v) ? fixnum_neg(v) : sl_neg(v);
p[0] = *(--sp);
@@ -947,7 +947,7 @@
int i = GET_S32(ip);
ip += 4;
SL(sp) = sp;
- value_t v = mk_cons();
+ sl_v v = alloc_cons();
car_(v) = bp[i];
cdr_(v) = sl_nil;
bp[i] = v;
@@ -955,7 +955,7 @@
}
OP(OP_FUNCTIONP) {- value_t v = sp[-1];
+ sl_v v = sp[-1];
sp[-1] =
((tag(v) == TAG_FUNCTION &&
(isbuiltin(v) || v>(N_BUILTINS<<3))) ||
@@ -983,7 +983,7 @@
NEXT_OP;
OP(OP_LOADVL) {- value_t v = fn_vals(bp[-1]);
+ sl_v v = fn_vals(bp[-1]);
v = vector_elt(v, GET_S32(ip));
ip += 4;
*sp++ = v;
--- a/tools/gen.lsp
+++ b/tools/gen.lsp
@@ -135,7 +135,7 @@
(set! i (1+ i))))
opcodes 5)
(io-close builtins-doc)
- (io-write c-header "\tN_OPCODES\n}opcode_t;\n\n")
+ (io-write c-header "\tN_OPCODES\n}sl_op;\n\n")
(io-write c-header "extern const Builtin builtins[N_OPCODES];\n")
(io-close c-header)
(io-write c-code "#include \"sl.h\"\n\n")